Struct RealTimeFinetuningModel 

pub struct RealTimeFinetuningModel {

    pub config: RealTimeFinetuningConfig,
    pub model_id: Uuid,
    pub embeddings: Array2<f32>,
    pub fisher_information: Array2<f32>,
    pub optimal_parameters: Array2<f32>,
    pub replay_buffer: VecDeque<ExperienceEntry>,
    pub performance_tracker: OnlinePerformanceTracker,
    pub entities: HashMap<String, usize>,
    pub relations: HashMap<String, usize>,
    pub examples_seen: usize,
    pub last_update: DateTime<Utc>,
    pub is_adapting: bool,
    pub task_memory: HashMap<String, Array2<f32>>,
    pub current_task: Option<String>,
    pub training_stats: Option<TrainingStats>,
    pub is_trained: bool,
}

Real-time fine-tuning model

Fields

config: RealTimeFinetuningConfig

model_id: Uuid

embeddings: Array2<f32>

Core model parameters

fisher_information: Array2<f32>

optimal_parameters: Array2<f32>

replay_buffer: VecDeque<ExperienceEntry>

Experience replay buffer

performance_tracker: OnlinePerformanceTracker

Online performance tracking

entities: HashMap<String, usize>

Entity and relation mappings

relations: HashMap<String, usize>

examples_seen: usize

Training state

last_update: DateTime<Utc>

is_adapting: bool

task_memory: HashMap<String, Array2<f32>>

Task-specific memory

current_task: Option<String>

training_stats: Option<TrainingStats>

Statistics

is_trained: bool

Implementations

impl RealTimeFinetuningModel

pub fn new(config: RealTimeFinetuningConfig) -> Self

Create new real-time fine-tuning model

pub async fn add_example( &mut self, input: Array1<f32>, target: Array1<f32>, task_id: Option<String>, ) -> Result<()>

Add new example for online learning

pub async fn adapt_online(&mut self) -> Result<()>

Perform online adaptation

pub fn set_current_task(&mut self, task_id: Option<String>)

Set current task context

pub fn save_task_parameters(&mut self, task_id: String) -> Result<()>

Save task-specific parameters

pub fn load_task_parameters(&mut self, task_id: &str) -> Result<()>

Load task-specific parameters

pub fn get_online_stats(&self) -> HashMap<String, f32>

Get online performance statistics

Trait Implementations

impl Debug for RealTimeFinetuningModel

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

Formats the value using the given formatter.

impl EmbeddingModel for RealTimeFinetuningModel

fn config(&self) -> &ModelConfig

fn model_id(&self) -> &Uuid

fn model_type(&self) -> &'static str

fn add_triple(&mut self, triple: Triple) -> Result<()>

fn train<'life0, 'async_trait>( &'life0 mut self, epochs: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<TrainingStats>> + Send + 'async_trait>>

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

fn get_entity_embedding(&self, entity: &str) -> Result<Vector>

fn get_relation_embedding(&self, relation: &str) -> Result<Vector>

fn score_triple( &self, subject: &str, predicate: &str, object: &str, ) -> Result<f64>

fn predict_objects( &self, subject: &str, predicate: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn predict_subjects( &self, predicate: &str, object: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn predict_relations( &self, subject: &str, object: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn get_entities(&self) -> Vec<String>

fn get_relations(&self) -> Vec<String>

fn get_stats(&self) -> ModelStats

fn save(&self, _path: &str) -> Result<()>

fn load(&mut self, _path: &str) -> Result<()>

fn clear(&mut self)

fn is_trained(&self) -> bool

fn encode<'life0, 'life1, 'async_trait>( &'life0 self, texts: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<f32>>>> + Send + 'async_trait>>

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

Encode text strings into embeddings