Struct BertModelExecutor 

pub struct BertModelExecutor { /* private fields */ }

BERT Executor for embedding tasks

Implementations

impl BertModelExecutor

pub fn new( model: BertModelWrapper, model_info: ModelInfo, device: CandleDevice, ) -> Self

Create a new BERT executor

pub async fn from_path( model_path: &str, model_def: &ModelDefinition, device: CandleDevice, ) -> Result<Self>

Load BERT executor from path

pub fn get_embeddings(&self, input_ids: &[u32]) -> Result<Tensor>

Get embeddings for input tokens

pub fn model(&self) -> &BertModelWrapper

Get model reference

Trait Implementations

impl ModelExecutor for BertModelExecutor

fn prefill<'life0, 'life1, 'async_trait>( &'life0 self, input: &'life1 PrefillInput, ) -> Pin<Box<dyn Future<Output = Result<PrefillOutput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

For BERT, prefill returns the embeddings (not logits)

fn decode<'life0, 'life1, 'async_trait>( &'life0 self, _input: &'life1 DecodeInput, ) -> Pin<Box<dyn Future<Output = Result<DecodeOutput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

BERT doesn’t support decode (it’s an encoder model)

fn info(&self) -> &ModelInfo

Get model information and metadata

fn capabilities(&self) -> ExecutorCapabilities

Get executor capabilities

fn status(&self) -> ExecutorStatus

Get current executor status

fn batch_decode<'life0, 'life1, 'async_trait>( &'life0 self, inputs: &'life1 [DecodeInput], ) -> Pin<Box<dyn Future<Output = Result<Vec<DecodeOutput>, FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Batch decode: process multiple sequences in one forward pass.

fn forward<'life0, 'life1, 'async_trait>( &'life0 self, _input: &'life1 Arc<dyn TensorLike>, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn TensorLike>, FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Optional: full forward pass (for non-autoregressive use cases)

fn warmup<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Warm up executor (load model, allocate memory, etc.)

fn shutdown<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), FerrumError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Shutdown executor gracefully

fn release_cache(&self, _cache_id: &str)

Release KV cache and state for a completed sequence.