Struct ContinualLearningModel 

pub struct ContinualLearningModel {

    pub config: ContinualLearningConfig,
    pub model_id: Uuid,
    pub embeddings: Array2<f32>,
    pub task_specific_embeddings: HashMap<String, Array2<f32>>,
    pub episodic_memory: VecDeque<MemoryEntry>,
    pub semantic_memory: HashMap<String, Array1<f32>>,
    pub ewc_states: Vec<EWCState>,
    pub synaptic_importance: Array2<f32>,
    pub parameter_trajectory: Array2<f32>,
    pub current_task: Option<TaskInfo>,
    pub task_history: Vec<TaskInfo>,
    pub task_boundaries: Vec<usize>,
    pub network_columns: Vec<Array2<f32>>,
    pub lateral_connections: Vec<Array2<f32>>,
    pub generator: Option<Array2<f32>>,
    pub discriminator: Option<Array2<f32>>,
    pub entities: HashMap<String, usize>,
    pub relations: HashMap<String, usize>,
    pub examples_seen: usize,
    pub training_stats: Option<TrainingStats>,
    pub is_trained: bool,
}

Continual learning model

Fields

config: ContinualLearningConfig

model_id: Uuid

embeddings: Array2<f32>

Core model parameters

task_specific_embeddings: HashMap<String, Array2<f32>>

episodic_memory: VecDeque<MemoryEntry>

Memory systems

semantic_memory: HashMap<String, Array1<f32>>

ewc_states: Vec<EWCState>

Regularization state

synaptic_importance: Array2<f32>

parameter_trajectory: Array2<f32>

current_task: Option<TaskInfo>

Task management

task_history: Vec<TaskInfo>

task_boundaries: Vec<usize>

network_columns: Vec<Array2<f32>>

Progressive networks

lateral_connections: Vec<Array2<f32>>

generator: Option<Array2<f32>>

Generative models for replay

discriminator: Option<Array2<f32>>

entities: HashMap<String, usize>

Entity and relation mappings

relations: HashMap<String, usize>

examples_seen: usize

Training state

training_stats: Option<TrainingStats>

is_trained: bool

Implementations

impl ContinualLearningModel

pub fn new(config: ContinualLearningConfig) -> Self

Create new continual learning model

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

Start new task

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

Add example to continual learning

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

Get task performance statistics

pub fn evaluate_forgetting(&self) -> f32

Evaluate catastrophic forgetting

Trait Implementations

impl Debug for ContinualLearningModel

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

Formats the value using the given formatter.

impl EmbeddingModel for ContinualLearningModel

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