Struct TextInput

pub struct TextInput {
    pub texts: Vec<String>,
    pub labels: Labels,
}

Input text and labels

Fields

texts: Vec<String>

labels: Labels

Implementations

impl TextInput

pub fn new(texts: Vec<String>, labels: Vec<String>) -> Self

Creates an input with the same set of labels for every text

pub fn from_str(texts: &[&str], labels: &[&str]) -> Self

Creates an input with the same set of labels for every text

Examples found in repository

examples/sample1.rs (lines 13-16)

fn main() -> gliclass::util::result::Result<()> {    
    const TOKENIZER_PATH: &str = "models/gliclass-small-v1.0/tokenizer.json";
    const MODEL_PATH: &str = "models/gliclass-small-v1.0/onnx/model.onnx";    

    let gliclass = GLiClass::new(TOKENIZER_PATH, MODEL_PATH, Parameters::default())?;
            
    let input = TextInput::from_str(
        &["One day I will see the world!"],
        &["travel", "dreams", "sport", "science", "politics"],
    ); 

    let classes = gliclass.inference(input)?;
    println!("Scores: {:?}", classes.scores);

    // check the results against the results obtained with the original implementation
    assert!(gliclass::util::test::is_close_to_a(
        &classes.scores.slice(ndarray::s![0, ..]), 
        &[0.9999985694885254, 0.9999986886978149, 0.9999117851257324, 0.9996119141578674, 0.8172177672386169],
        0.00001,
    ));

    Ok(())
}

examples/sample2.rs (lines 13-20)

fn main() -> gliclass::util::result::Result<()> {    
    const TOKENIZER_PATH: &str = "models/gliclass-small-v1.0/tokenizer.json";
    const MODEL_PATH: &str = "models/gliclass-small-v1.0/onnx/model.onnx";

    let params = gliclass::params::Parameters::default();
    let pipeline = gliclass::pipeline::ClassificationPipeline::new(TOKENIZER_PATH, &params)?;
    let model = orp::model::Model::new(MODEL_PATH, orp::params::RuntimeParameters::default())?;
            
    let inputs = gliclass::input::text::TextInput::from_str(
        &[
            "Rust is a systems programming language focused on safety, speed, and concurrency, with a strong ownership model that prevents memory errors without needing a garbage collector.",
            "Traveling is the perfect way to explore new cultures through their food, from savoring street tacos in Mexico to indulging in fresh sushi in Japan.",
            "Traveling for science allows researchers to explore new environments, gather crucial data, and collaborate with experts worldwide to expand our understanding of the universe.",
        ],
        &["computing", "science", "programming", "travel", "food", "politics"]
    );    

    let classes = model.inference(inputs, &pipeline, &params)?;

    for i in 0..classes.len() {
        println!("Text {i}:\n\t=> {}\n\t=> {:?}",
            classes.best_label(i, None).unwrap(),
            classes.ordered_scores(i, None).unwrap().iter().rev().collect::<Vec<_>>(),
        );
    }

    Ok(())
}

pub fn new_per_text(texts: Vec<String>, labels: Vec<Vec<String>>) -> Self

Creates an input with a different set of labels for each text. The texts and labels arrays must have the same length, otherwise an error will be raised at some point.

pub fn from_str_per_text(texts: &[&str], labels: &[&[&str]]) -> Self

Creates an input with a different set of labels for each text. The texts and labels arrays must have the same length, otherwise an error will be raised at some point.

Examples found in repository

examples/sample3.rs (lines 13-24)

fn main() -> gliclass::util::result::Result<()> {    
    const TOKENIZER_PATH: &str = "models/gliclass-small-v1.0/tokenizer.json";
    const MODEL_PATH: &str = "models/gliclass-small-v1.0/onnx/model.onnx";

    let params = gliclass::params::Parameters::default();
    let pipeline = gliclass::pipeline::ClassificationPipeline::new(TOKENIZER_PATH, &params)?;
    let model = orp::model::Model::new(MODEL_PATH, orp::params::RuntimeParameters::default())?;
            
    let inputs = gliclass::input::text::TextInput::from_str_per_text(
        &[
            "Rust is a systems programming language focused on safety, speed, and concurrency, with a strong ownership model that prevents memory errors without needing a garbage collector.",
            "Traveling is the perfect way to explore new cultures through their food, from savoring street tacos in Mexico to indulging in fresh sushi in Japan.",
            "Traveling for science allows researchers to explore new environments, gather crucial data, and collaborate with experts worldwide to expand our understanding of the universe.",
        ],
        &[
            &["performance", "user interface"], // expecting 'performance'
            &["gastronomy", "plane"], // expecting 'gastronomy'
            &["conferencing", "teaching"], // expecting 'conferencing'
        ]
    );    

    let classes = model.inference(inputs, &pipeline, &params)?;

    for i in 0..classes.len() {
        println!("Text {i} => {}", classes.best_label(i, None).unwrap());
    }

    Ok(())
}

examples/sample4.rs (lines 12-23)

fn main() -> gliclass::util::result::Result<()> {    
    const TOKENIZER_PATH: &str = "models/gliclass-modern-base-v2.0-init/tokenizer.json";
    const MODEL_PATH: &str = "models/gliclass-modern-base-v2.0-init/onnx/model.onnx";

    let params = gliclass::params::Parameters::default().with_prompt_first(true);
    let pipeline = gliclass::pipeline::ClassificationPipeline::new(TOKENIZER_PATH, &params)?;
    let model = orp::model::Model::new(MODEL_PATH, orp::params::RuntimeParameters::default())?;
            
    let inputs = gliclass::input::text::TextInput::from_str_per_text(
        &[
            "Rust is a systems programming language focused on safety, speed, and concurrency, with a strong ownership model that prevents memory errors without needing a garbage collector.",
            "Traveling is the perfect way to explore new cultures through their food, from savoring street tacos in Mexico to indulging in fresh sushi in Japan.",
            "Traveling for science allows researchers to explore new environments, gather crucial data, and collaborate with experts worldwide to expand our understanding of the universe.",
        ],
        &[
            &["performance", "user interface"], // expecting 'performance'
            &["gastronomy", "plane"], // expecting 'gastronomy'
            &["conferencing", "teaching"], // expecting 'conferencing'
        ]
    );    

    let classes = model.inference(inputs, &pipeline, &params)?;

    for i in 0..classes.len() {
        println!("Text {i}:\n\t=> {}\n\t=> {:?}",
            classes.best_label(i, None).unwrap(),
            classes.ordered_scores(i, None).unwrap().iter().rev().collect::<Vec<_>>(),
        );
    }

    Ok(())
}

Trait Implementations

impl Composable<TextInput, PromptInput> for InputToPrompt

Transformation from input text to prompts

fn apply(&self, input: TextInput) -> Result<PromptInput>

fn compose<T, P>(self, other: T) -> impl Composable<I, P>

where Self: Sized, T: Composable<O, P>,