Struct TextInput 

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

Represents the raw text input, as a list of text chunks and a list of entity classes

Fields

texts: Vec<String>

entities: Vec<String>

Implementations

impl TextInput

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

Default constructor that moves the input data given as a vector of the text sequences to be analyzed, and a vector of entity classes.

pub fn from_str(texts: &[&str], entities: &[&str]) -> Result<Self>

This constructor will mostly be used to test with plain arrays of static strs.

Examples found in repository

examples/multilingual.rs (line 39)

fn main() -> Result<()> {    
    println!("Loading model...");
    let model = GLiNER::<SpanMode>::new(Parameters::default(), RuntimeParameters::default(), TOKENIZER, MODEL)?;    

    println!("Inferencing...");
    let input = TextInput::from_str(&[TEXT], &LABELS)?;
    let output = model.inference(input)?;

    println!("Results:\n{output}");    

    Ok(check_results(&output))
}

examples/span_mode.rs (lines 17-30)

fn main() -> Result<()> {    
    
    println!("Loading model...");
    let model = GLiNER::<SpanMode>::new(
        Parameters::default(),
        RuntimeParameters::default(),
        "models/gliner_small-v2.1/tokenizer.json",
        "models/gliner_small-v2.1/onnx/model.onnx",
    )?;

    let input = TextInput::from_str(
        &[ 
            "I am James Bond",
            "This is James and I live in Chelsea, London.",
            "My name is Bond, James Bond.",
            "I like to drive my Aston Martin.",
            "The villain in the movie is Auric Goldfinger."
        ],
        &[
            "person", 
            "location",
            "vehicle",
        ]
    )?;

    println!("Inferencing...");
    let output = model.inference(input)?;

    println!("Results:");
    for spans in output.spans {
        for span in spans {
            println!("{:3} | {:16} | {:10} | {:.1}%", span.sequence(), span.text(), span.class(), span.probability() * 100.0);
        }
    }

    Ok(())

}

examples/token_mode.rs (lines 17-30)

fn main() -> Result<()> {    
    
    println!("Loading model...");
    let model = GLiNER::<TokenMode>::new(
        Parameters::default(),
        RuntimeParameters::default(),
        "models/gliner-multitask-large-v0.5/tokenizer.json",
        "models/gliner-multitask-large-v0.5/onnx/model.onnx",
    )?;
    
    let input = TextInput::from_str(
        &[ 
            "I am James Bond",
            "This is James and I live in Chelsea, London.",
            "My name is Bond, James Bond.",
            "I like to drive my Aston Martin.",
            "The villain in the movie is Auric Goldfinger."
        ],
        &[
            "person", 
            "location",
            "vehicle",
        ]
    )?;

    println!("Inferencing...");
    let output = model.inference(input)?;

    println!("Results:");
    for spans in output.spans {
        for span in spans {
            println!("{:3} | {:16} | {:10} | {:.1}%", span.sequence(), span.text(), span.class(), span.probability() * 100.0);
        }
    }

    Ok(())

}

examples/relation_extraction.rs (lines 39-42)

fn main() -> Result<()> {
    // Set model and tokenizer paths    
    const MODEL_PATH: &str = "models/gliner-multitask-large-v0.5/onnx/model.onnx";
    const TOKENIZER_PATH: &str = "models/gliner-multitask-large-v0.5/tokenizer.json";
    
    // Use default parameters
    let params: Parameters = Parameters::default();
    let runtime_params = RuntimeParameters::default();

    // Define a relation schema.
    // We declare a "founded" relation which subject has to be a "person" and object has to be a "company"
    let mut relation_schema = RelationSchema::new();
    relation_schema.push_with_allowed_labels("founded", &["person"], &["company"]);

    // Sample input text and entity labels
    let input = TextInput::from_str(
        &["Bill Gates is an American businessman who co-founded Microsoft."],
        &["person", "company"],
    )?;
    
    // Load the model that will be leveraged for the pipeline below
    println!("Loading model...");      
    let model = Model::new(MODEL_PATH, runtime_params)?;
    
    // Relation Extraction needs Named Entity Recognition to be applied first.
    // Here we combine the two pipelines: one for NER, and one for RE.
    // For testing purposes we also insert printing functions.
    let pipeline = composed![
        TokenPipeline::new(TOKENIZER_PATH)?.to_composable(&model, &params),
        Print::new(Some("Entities:\n"), None),
        RelationPipeline::default(TOKENIZER_PATH, &relation_schema)?.to_composable(&model, &params),
        Print::new(Some("Relations:\n"), None)
    ];

    // Actually perform inferences using the pipeline defined above
    pipeline.apply(input)?;
    
    Ok(())
}

pub fn new_from_csv<P: AsRef<Path>>( path: P, column: usize, limit: usize, entities: Vec<String>, ) -> Result<Self>

For testing purposes. Panics if the specified column does not exist

Examples found in repository

examples/benchmark_gpu.rs (line 33)

fn main() -> Result<()> {    

    const MAX_SAMPLES: usize = 1000;
    const CSV_PATH: &str = "data/nuner-sample-1k.csv";

    let entities = [
        "person", 
        "location",
        "vehicle",
    ];

    println!("Loading data...");
    let input = TextInput::new_from_csv(CSV_PATH, 0, MAX_SAMPLES, entities.map(|x| x.to_string()).to_vec())?;
    let nb_samples = input.texts.len();
    
    println!("Loading model...");
    let model = GLiNER::<TokenMode>::new(
        Parameters::default(),
        RuntimeParameters::default().with_execution_providers([
            CUDAExecutionProvider::default().build(),
            CoreMLExecutionProvider::default().build(),            
        ]),
        "models/gliner-multitask-large-v0.5/tokenizer.json",
        "models/gliner-multitask-large-v0.5/onnx/model.onnx",
    )?;

    println!("Inferencing...");
    let inference_start = std::time::Instant::now();
    let _output = model.inference(input)?;
    
    let inference_time = inference_start.elapsed();
    println!("Inference took {} seconds on {} samples ({:.2} samples/sec)", inference_time.as_secs(), nb_samples, nb_samples as f32 / inference_time.as_secs() as f32);

    Ok(())
}

examples/benchmark_cpu.rs (line 23)

fn main() -> Result<()> {
    let entities = [
        "person", 
        "location",
        "vehicle",
    ];

    println!("Loading data...");
    let input = input::text::TextInput::new_from_csv(CSV_PATH, 0, MAX_SAMPLES, entities.map(|x| x.to_string()).to_vec())?;
    let nb_samples = input.texts.len();
    
    println!("Loading model...");
    let model = GLiNER::<TokenMode>::new(
        Parameters::default(),
        RuntimeParameters::default().with_threads(THREADS),
        std::path::Path::new("models/gliner-multitask-large-v0.5/tokenizer.json"),
        std::path::Path::new("models/gliner-multitask-large-v0.5/onnx/model.onnx")
    )?;
    
    let global_inference_start = std::time::Instant::now();

    for i in 0..REPEAT {
        println!("Inferencing ({})...", i + 1);
        let inference_start = std::time::Instant::now();
        let _output = model.inference(input.clone())?;
        
        let inference_time = inference_start.elapsed();
        println!("Took {} seconds on {} samples ({:.2} samples/sec)", inference_time.as_secs(), nb_samples, nb_samples as f32 / inference_time.as_secs() as f32);

        #[cfg(feature = "memprof")] 
        print_memory_usage();
    }

    let global_inference_time = global_inference_start.elapsed();
    let global_nb_samples = nb_samples * REPEAT;
    println!("All {} inferences took {} seconds on {} samples total ({:.2} samples/sec)", REPEAT, global_inference_time.as_secs(), global_nb_samples, global_nb_samples as f32 / global_inference_time.as_secs() as f32);

    Ok(())
}

Trait Implementations

impl Clone for TextInput

fn clone(&self) -> TextInput

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Splitter> Composable<TextInput, TokenizedInput> for RawToTokenized<'_, S>

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

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

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

impl Debug for TextInput

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.