Struct Translator 

pub struct Translator { /* private fields */ }

A text translator.

This struct is a Rust binding to the ctranslate2::Translator.

Example

Below is an example where a given list of tokens is translated:

use ct2rs::sys::{Config, Device, Translator};

let translator = Translator::new("/path/to/model", &Config::default())?;
let res = translator.translate_batch(
    &[vec!["▁Hello", "▁world", "!", "</s>", "<unk>"]],
    &Default::default(),
    None,
)?;
for r in res {
    println!("{:?}", r);
}

If the model requires target prefixes, use Translator::translate_batch_with_target_prefix instead:

use ct2rs::sys::{Config, Device, Translator};

let translator = Translator::new("/path/to/model", &Config::default())?;
let res = translator.translate_batch_with_target_prefix(
    &[vec!["▁Hello", "▁world", "!", "</s>", "<unk>"]],
    &[vec!["jpn_Jpan"]],
    &Default::default(),
    None,
)?;
for r in res {
    println!("{:?}", r);
}

Implementations

impl Translator

pub fn new<T: AsRef<Path>>(model_path: T, config: &Config) -> Result<Translator>

Creates and initializes an instance of Translator.

This function constructs a new Translator by loading a language model from the specified model_path and applying the provided config settings.

Arguments

• model_path - A path to the directory containing the language model to be loaded.
• config - A reference to a Config structure that specifies various settings and configurations for the Translator.

Returns

Returns a Result that, if successful, contains the initialized Translator. If an error occurs during initialization, the function will return an error wrapped in the Result.

Example

use ct2rs::sys::{Config, Translator};

let config = Config::default();
let translator = Translator::new("/path/to/model", &config)?;

pub fn translate_batch<T, U, V>( &self, source: &[Vec<T>], options: &TranslationOptions<U, V>, callback: Option<&mut dyn FnMut(GenerationStepResult) -> bool>, ) -> Result<Vec<TranslationResult>>

where T: AsRef<str>, U: AsRef<str>, V: AsRef<str>,

Translates multiple lists of tokens in a batch processing manner.

This function takes a vector of token lists and performs batch translation according to the specified settings in options. The results of the batch translation are returned as a vector. An optional callback closure can be provided which is invoked for each new token generated during the translation process. This allows for step-by-step reception of the batch translation results. If the callback returns true, it will stop the translation for that batch. Note that if a callback is provided, options.beam_size must be set to 1.

Arguments

• source - A vector of token lists, each list representing a sequence of tokens to be translated.
• options - Settings applied to the batch translation process.
• callback - An optional mutable reference to a closure that is called for each token generation step. The closure takes a GenerationStepResult and returns a bool. If it returns true, the translation process for the current batch will stop.

Returns

Returns a Result containing a vector of TranslationResult if successful, or an error if the translation fails.

Example

use ct2rs::sys::{Config, GenerationStepResult, Translator, TranslationOptions};

let source_tokens = [
    vec!["▁Hall", "o", "▁World", "!", "</s>"],
    vec![
        "▁This", "▁library", "▁is", "▁a", "▁", "Rust", "▁", "binding", "s", "▁of",
        "▁C", "Trans", "late", "2", ".", "</s>"
    ],
];
let options = TranslationOptions::default();
let mut callback = |step_result: GenerationStepResult| -> bool {
    println!("{:?}", step_result);
    false // Continue processing
};
let translator = Translator::new("/path/to/model", &Config::default())?;
let results = translator.translate_batch(&source_tokens, &options, Some(&mut callback))?;

pub fn translate_batch_with_target_prefix<T, U, V, W>( &self, source: &[Vec<T>], target_prefix: &[Vec<U>], options: &TranslationOptions<V, W>, callback: Option<&mut dyn FnMut(GenerationStepResult) -> bool>, ) -> Result<Vec<TranslationResult>>

where T: AsRef<str>, U: AsRef<str>, V: AsRef<str>, W: AsRef<str>,

Translates multiple lists of tokens with target prefixes in a batch processing manner.

This function takes a vector of token lists and corresponding target prefixes, performing batch translation according to the specified settings in options. An optional callback closure can be provided which is invoked for each new token generated during the translation process.

This function is similar to translate_batch, with the addition of handling target prefixes that guide the translation process. For more detailed parameter and option descriptions, refer to the documentation for Translator::translate_batch.

Arguments

• source - A vector of token lists, each list representing a sequence of tokens to be translated.
• target_prefix - A vector of token lists, each list representing a sequence of target prefix tokens that provide a starting point for the translation output.
• options - Settings applied to the batch translation process.
• callback - An optional mutable reference to a closure that is called for each token generation step. The closure takes a GenerationStepResult and returns a bool. If it returns true, the translation process for the current batch will stop.

Returns

Returns a Result containing a vector of TranslationResult if successful, or an error if the translation fails.

pub fn num_queued_batches(&self) -> Result<usize>

Number of batches in the work queue.

pub fn num_active_batches(&self) -> Result<usize>

Number of batches in the work queue or currently processed by a worker.

pub fn num_replicas(&self) -> Result<usize>

Number of parallel replicas.

Trait Implementations

impl Debug for Translator

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

Formats the value using the given formatter.