Struct ClassificationPipeline

pub struct ClassificationPipeline { /* private fields */ }

Pipeline for GLiClass classification, to be executed using orp.

Implementations

impl ClassificationPipeline

pub fn new<P: AsRef<Path>>( tokenizer_path: P, _params: &Parameters, ) -> Result<Self>

Examples found in repository

examples/sample2.rs (line 10)

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(())
}

examples/sample3.rs (line 10)

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 (line 9)

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<'a> Pipeline<'a> for ClassificationPipeline

type Input = TextInput

type Output = Classes

type Context = Labels

type Parameters = Parameters

fn pre_processor( &self, params: &Self::Parameters, ) -> impl PreProcessor<'a, Self::Input, Self::Context>

fn post_processor( &self, _params: &Self::Parameters, ) -> impl PostProcessor<'a, Self::Output, Self::Context>

fn to_composable( self, model: &'a Model, params: &'a Self::Parameters, ) -> impl Composable<Self::Input, Self::Output>

where Self: Sized,

fn expected_inputs(&self) -> Option<&HashSet<&str>>

Optionally, the pipeline can expose the (exact) set of input tensors that must be exposed by the model In such case it will be checked before inferencing.

fn expected_outputs(&self) -> Option<&HashSet<&str>>

Optionally, the pipeline can expose the (sub-)set of output tensors that must be exposed by the model In such case it will be checked before inferencing.