optirs_learned/meta_learning/
types.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5#[allow(unused_imports)]
6use crate::error::{OptimError, Result};
7use optirs_core::optimizers::Optimizer;
8#[allow(dead_code)]
9use scirs2_core::ndarray::{Array1, Array2, Dimension};
10use scirs2_core::numeric::Float;
11use std::collections::{HashMap, VecDeque};
12use std::fmt::Debug;
13use std::time::Instant;
14
15use super::functions::MetaLearner;
16
17/// Adaptation step
18#[derive(Debug, Clone)]
19pub struct AdaptationStep<T: Float + Debug + Send + Sync + 'static> {
20    /// Step number
21    pub step: usize,
22    /// Loss at this step
23    pub loss: T,
24    /// Gradient norm
25    pub gradient_norm: T,
26    /// Parameter change norm
27    pub parameter_change_norm: T,
28    /// Learning rate used
29    pub learning_rate: T,
30}
31/// Meta-training metrics
32#[derive(Debug, Clone)]
33pub struct MetaTrainingMetrics<T: Float + Debug + Send + Sync + 'static> {
34    /// Average adaptation speed
35    pub avg_adaptation_speed: T,
36    /// Generalization performance
37    pub generalization_performance: T,
38    /// Task diversity handled
39    pub task_diversity: T,
40    /// Gradient alignment score
41    pub gradient_alignment: T,
42}
43/// Hessian-vector product engine
44#[derive(Debug)]
45pub struct HessianVectorProductEngine<T: Float + Debug + Send + Sync + 'static> {
46    /// HVP computation method
47    method: HVPComputationMethod,
48    /// Vector cache
49    vector_cache: Vec<Array1<T>>,
50    /// Product cache
51    product_cache: Vec<Array1<T>>,
52}
53impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> HessianVectorProductEngine<T> {
54    /// Create a new HVP engine
55    pub fn new() -> Result<Self> {
56        Ok(Self {
57            method: HVPComputationMethod::FiniteDifference,
58            vector_cache: Vec::new(),
59            product_cache: Vec::new(),
60        })
61    }
62}
63/// Task identification methods
64#[derive(Debug, Clone, Copy)]
65pub enum TaskIdentificationMethod {
66    Oracle,
67    Learned,
68    Clustering,
69    EntropyBased,
70    GradientBased,
71}
72/// Query evaluation metrics
73#[derive(Debug, Clone)]
74pub struct QueryEvaluationMetrics<T: Float + Debug + Send + Sync + 'static> {
75    /// Mean squared error (for regression)
76    pub mse: Option<T>,
77    /// Classification accuracy (for classification)
78    pub classification_accuracy: Option<T>,
79    /// AUC score
80    pub auc: Option<T>,
81    /// Uncertainty estimation quality
82    pub uncertainty_quality: T,
83}
84/// Meta-parameters for meta-learning
85#[derive(Debug, Clone)]
86pub struct MetaParameters<T: Float + Debug + Send + Sync + 'static> {
87    /// Parameter values
88    pub parameters: HashMap<String, Array1<T>>,
89    /// Parameter metadata
90    pub metadata: HashMap<String, String>,
91}
92/// MAML implementation
93pub struct MAMLLearner<T: Float + Debug + Send + Sync + 'static, D: Dimension> {
94    /// MAML configuration
95    pub(super) config: MAMLConfig<T>,
96    /// Inner loop optimizer
97    inner_optimizer: Box<dyn Optimizer<T, D> + Send + Sync>,
98    /// Outer loop optimizer
99    outer_optimizer: Box<dyn Optimizer<T, D> + Send + Sync>,
100    /// Gradient computation engine
101    gradient_engine: GradientComputationEngine<T>,
102    /// Second-order gradient computation
103    second_order_engine: Option<SecondOrderGradientEngine<T>>,
104    /// Task adaptation history
105    adaptation_history: VecDeque<TaskAdaptationResult<T>>,
106}
107impl<
108        T: Float
109            + Default
110            + Clone
111            + Send
112            + Sync
113            + scirs2_core::ndarray::ScalarOperand
114            + std::fmt::Debug,
115        D: Dimension,
116    > MAMLLearner<T, D>
117{
118    pub fn new(config: MAMLConfig<T>) -> Result<Self> {
119        let inner_optimizer: Box<dyn Optimizer<T, D> + Send + Sync> =
120            Box::new(optirs_core::optimizers::SGD::new(config.inner_lr));
121        let outer_optimizer: Box<dyn Optimizer<T, D> + Send + Sync> =
122            Box::new(optirs_core::optimizers::SGD::new(config.outer_lr));
123        let gradient_engine = GradientComputationEngine::new()?;
124        let second_order_engine = if config.second_order {
125            Some(SecondOrderGradientEngine::new()?)
126        } else {
127            None
128        };
129        let adaptation_history = VecDeque::with_capacity(1000);
130        Ok(Self {
131            config,
132            inner_optimizer,
133            outer_optimizer,
134            gradient_engine,
135            second_order_engine,
136            adaptation_history,
137        })
138    }
139}
140impl<T: Float + Debug + Send + Sync + 'static + Default + Clone + std::iter::Sum, D: Dimension>
141    MAMLLearner<T, D>
142{
143    pub(super) fn compute_support_loss(
144        &self,
145        task: &MetaTask<T>,
146        _parameters: &HashMap<String, Array1<T>>,
147    ) -> Result<T> {
148        let mut total_loss = T::zero();
149        for (features, target) in task
150            .support_set
151            .features
152            .iter()
153            .zip(&task.support_set.targets)
154        {
155            let prediction = features.iter().copied().sum::<T>()
156                / T::from(features.len()).expect("unwrap failed");
157            let loss = (prediction - *target) * (prediction - *target);
158            total_loss = total_loss + loss;
159        }
160        Ok(total_loss / T::from(task.support_set.features.len()).expect("unwrap failed"))
161    }
162    pub(super) fn compute_gradients(
163        &self,
164        parameters: &HashMap<String, Array1<T>>,
165        _loss: T,
166    ) -> Result<HashMap<String, Array1<T>>> {
167        let epsilon = T::from(1e-5)
168            .ok_or_else(|| OptimError::ComputationError("Failed to convert epsilon".to_string()))?;
169        let two = T::from(2.0)
170            .ok_or_else(|| OptimError::ComputationError("Failed to convert 2.0".to_string()))?;
171        let mut gradients = HashMap::new();
172
173        for (name, param) in parameters {
174            let mut grad = Array1::zeros(param.len());
175            for i in 0..param.len() {
176                // Forward perturbation
177                let mut params_plus = parameters.clone();
178                let p_plus = params_plus.get_mut(name).ok_or_else(|| {
179                    OptimError::ComputationError(format!("Parameter {} not found", name))
180                })?;
181                p_plus[i] = p_plus[i] + epsilon;
182
183                // Backward perturbation
184                let mut params_minus = parameters.clone();
185                let p_minus = params_minus.get_mut(name).ok_or_else(|| {
186                    OptimError::ComputationError(format!("Parameter {} not found", name))
187                })?;
188                p_minus[i] = p_minus[i] - epsilon;
189
190                // Compute simple loss for both (sum of squared params as proxy)
191                let loss_plus: T = params_plus
192                    .values()
193                    .flat_map(|a| a.iter().copied())
194                    .map(|v| v * v)
195                    .fold(T::zero(), |a, b| a + b);
196                let loss_minus: T = params_minus
197                    .values()
198                    .flat_map(|a| a.iter().copied())
199                    .map(|v| v * v)
200                    .fold(T::zero(), |a, b| a + b);
201
202                grad[i] = (loss_plus - loss_minus) / (two * epsilon);
203            }
204            gradients.insert(name.clone(), grad);
205        }
206        Ok(gradients)
207    }
208}
209/// Memory selection criteria
210#[derive(Debug, Clone, Copy)]
211pub enum MemorySelectionCriteria {
212    Random,
213    GradientMagnitude,
214    LossBased,
215    Uncertainty,
216    Diversity,
217    TemporalProximity,
218}
219/// Task distribution manager
220pub struct TaskDistributionManager<T: Float + Debug + Send + Sync + 'static> {
221    config: MetaLearningConfig,
222    _phantom: std::marker::PhantomData<T>,
223}
224impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> TaskDistributionManager<T> {
225    pub fn new(config: &MetaLearningConfig) -> Result<Self> {
226        Ok(Self {
227            config: config.clone(),
228            _phantom: std::marker::PhantomData,
229        })
230    }
231    pub fn sample_task_batch(
232        &self,
233        _tasks: &[MetaTask<T>],
234        batch_size: usize,
235    ) -> Result<Vec<MetaTask<T>>> {
236        Ok(vec![MetaTask::default(); batch_size.min(10)])
237    }
238}
239/// Task metadata
240#[derive(Debug, Clone)]
241pub struct TaskMetadata {
242    /// Task name
243    pub name: String,
244    /// Task description
245    pub description: String,
246    /// Task properties
247    pub properties: HashMap<String, String>,
248    /// Creation timestamp
249    pub created_at: Instant,
250    /// Task source
251    pub source: String,
252}
253/// Computation graph for gradient computation
254#[derive(Debug)]
255pub struct ComputationGraph<T: Float + Debug + Send + Sync + 'static> {
256    /// Graph nodes
257    nodes: Vec<ComputationNode<T>>,
258    /// Node dependencies
259    dependencies: HashMap<usize, Vec<usize>>,
260    /// Topological order
261    topological_order: Vec<usize>,
262    /// Input nodes
263    input_nodes: Vec<usize>,
264    /// Output nodes
265    output_nodes: Vec<usize>,
266}
267impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> ComputationGraph<T> {
268    /// Create a new computation graph
269    pub fn new() -> Result<Self> {
270        Ok(Self {
271            nodes: Vec::new(),
272            dependencies: HashMap::new(),
273            topological_order: Vec::new(),
274            input_nodes: Vec::new(),
275            output_nodes: Vec::new(),
276        })
277    }
278}
279/// Meta-training epoch
280#[derive(Debug, Clone)]
281pub struct MetaTrainingEpoch<T: Float + Debug + Send + Sync + 'static> {
282    pub epoch: usize,
283    pub training_result: MetaTrainingResult<T>,
284    pub validation_result: MetaValidationResult<T>,
285    pub meta_parameters: HashMap<String, Array1<T>>,
286}
287/// Task dataset
288#[derive(Debug, Clone)]
289pub struct TaskDataset<T: Float + Debug + Send + Sync + 'static> {
290    /// Input features
291    pub features: Vec<Array1<T>>,
292    /// Target values
293    pub targets: Vec<T>,
294    /// Sample weights
295    pub weights: Vec<T>,
296    /// Dataset metadata
297    pub metadata: DatasetMetadata,
298}
299/// MAML configuration
300#[derive(Debug, Clone)]
301pub struct MAMLConfig<T: Float + Debug + Send + Sync + 'static> {
302    /// Enable second-order gradients
303    pub second_order: bool,
304    /// Inner learning rate
305    pub inner_lr: T,
306    /// Outer learning rate
307    pub outer_lr: T,
308    /// Number of inner steps
309    pub inner_steps: usize,
310    /// Allow unused parameters
311    pub allow_unused: bool,
312    /// Gradient clipping
313    pub gradient_clip: Option<f64>,
314}
315/// Continual learning system
316pub struct ContinualLearningSystem<T: Float + Debug + Send + Sync + 'static> {
317    settings: ContinualLearningSettings,
318    _phantom: std::marker::PhantomData<T>,
319}
320impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> ContinualLearningSystem<T> {
321    pub fn new(settings: &ContinualLearningSettings) -> Result<Self> {
322        Ok(Self {
323            settings: settings.clone(),
324            _phantom: std::marker::PhantomData,
325        })
326    }
327    pub fn learn_sequence(
328        &mut self,
329        sequence: &[MetaTask<T>],
330        _meta_parameters: &mut HashMap<String, Array1<T>>,
331    ) -> Result<ContinualLearningResult<T>> {
332        let mut sequence_results = Vec::new();
333        for task in sequence {
334            let task_result = TaskResult {
335                task_id: task.id.clone(),
336                loss: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
337                metrics: HashMap::new(),
338            };
339            sequence_results.push(task_result);
340        }
341        Ok(ContinualLearningResult {
342            sequence_results,
343            forgetting_measure: scirs2_core::numeric::NumCast::from(0.05)
344                .unwrap_or_else(|| T::zero()),
345            adaptation_efficiency: scirs2_core::numeric::NumCast::from(0.95)
346                .unwrap_or_else(|| T::zero()),
347        })
348    }
349    pub fn forgetting_measure(&self) -> T {
350        T::from(0.05).unwrap_or_default()
351    }
352}
353/// Meta-training result
354#[derive(Debug, Clone)]
355pub struct MetaTrainingResult<T: Float + Debug + Send + Sync + 'static> {
356    /// Meta-loss
357    pub meta_loss: T,
358    /// Per-task losses
359    pub task_losses: Vec<T>,
360    /// Meta-gradients
361    pub meta_gradients: HashMap<String, Array1<T>>,
362    /// Training metrics
363    pub metrics: MetaTrainingMetrics<T>,
364    /// Adaptation statistics
365    pub adaptation_stats: AdaptationStatistics<T>,
366}
367/// Metric learning settings
368#[derive(Debug, Clone)]
369pub struct MetricLearningSettings {
370    /// Distance metric
371    pub distance_metric: DistanceMetric,
372    /// Embedding dimension
373    pub embedding_dim: usize,
374    /// Learned metric parameters
375    pub learned_metric: bool,
376}
377/// Multi-task learning result
378#[derive(Debug, Clone)]
379pub struct MultiTaskResult<T: Float + Debug + Send + Sync + 'static> {
380    pub task_results: Vec<TaskResult<T>>,
381    pub coordination_overhead: T,
382    pub convergence_status: String,
383}
384/// Memory replay settings
385#[derive(Debug, Clone)]
386pub struct MemoryReplaySettings {
387    /// Memory buffer size
388    pub buffer_size: usize,
389    /// Replay strategy
390    pub replay_strategy: ReplayStrategy,
391    /// Replay frequency
392    pub replay_frequency: usize,
393    /// Memory selection criteria
394    pub selection_criteria: MemorySelectionCriteria,
395}
396/// Task types
397#[derive(Debug, Clone, Copy)]
398pub enum TaskType {
399    Regression,
400    Classification,
401    Optimization,
402    ReinforcementLearning,
403    StructuredPrediction,
404    Generative,
405}
406/// Forward mode automatic differentiation
407#[derive(Debug)]
408pub struct ForwardModeAD<T: Float + Debug + Send + Sync + 'static> {
409    /// Dual numbers
410    dual_numbers: Vec<DualNumber<T>>,
411    /// Jacobian matrix
412    jacobian: Array2<T>,
413}
414impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> ForwardModeAD<T> {
415    /// Create a new forward mode AD engine
416    pub fn new() -> Result<Self> {
417        Ok(Self {
418            dual_numbers: Vec::new(),
419            jacobian: Array2::zeros((1, 1)),
420        })
421    }
422}
423/// Tape entry for reverse mode AD
424#[derive(Debug, Clone)]
425pub struct TapeEntry<T: Float + Debug + Send + Sync + 'static> {
426    /// Operation ID
427    pub op_id: usize,
428    /// Input IDs
429    pub inputs: Vec<usize>,
430    /// Output ID
431    pub output: usize,
432    /// Local gradients
433    pub local_gradients: Vec<T>,
434}
435/// Interference mitigation strategies
436#[derive(Debug, Clone, Copy)]
437pub enum InterferenceMitigationStrategy {
438    OrthogonalGradients,
439    TaskSpecificLayers,
440    AttentionMechanisms,
441    MetaGradients,
442}
443/// Hessian computation methods
444#[derive(Debug, Clone, Copy)]
445pub enum HessianComputationMethod {
446    Exact,
447    FiniteDifference,
448    GaussNewton,
449    BFGS,
450    LBfgs,
451}
452/// Curvature estimator
453#[derive(Debug)]
454pub struct CurvatureEstimator<T: Float + Debug + Send + Sync + 'static> {
455    /// Curvature estimation method
456    method: CurvatureEstimationMethod,
457    /// Curvature history
458    curvature_history: VecDeque<T>,
459    /// Local curvature estimates
460    local_curvature: HashMap<String, T>,
461}
462impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> CurvatureEstimator<T> {
463    /// Create a new curvature estimator
464    pub fn new() -> Result<Self> {
465        Ok(Self {
466            method: CurvatureEstimationMethod::DiagonalHessian,
467            curvature_history: VecDeque::new(),
468            local_curvature: HashMap::new(),
469        })
470    }
471}
472/// Automatic differentiation engine
473#[derive(Debug)]
474pub struct AutoDiffEngine<T: Float + Debug + Send + Sync + 'static> {
475    /// Forward mode AD
476    forward_mode: ForwardModeAD<T>,
477    /// Reverse mode AD
478    reverse_mode: ReverseModeAD<T>,
479    /// Mixed mode AD
480    mixed_mode: MixedModeAD<T>,
481}
482impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> AutoDiffEngine<T> {
483    /// Create a new autodiff engine
484    pub fn new() -> Result<Self> {
485        Ok(Self {
486            forward_mode: ForwardModeAD::new()?,
487            reverse_mode: ReverseModeAD::new()?,
488            mixed_mode: MixedModeAD::new()?,
489        })
490    }
491}
492/// Replay strategies
493#[derive(Debug, Clone, Copy)]
494pub enum ReplayStrategy {
495    Random,
496    GradientBased,
497    UncertaintyBased,
498    DiversityBased,
499    Temporal,
500}
501/// Transfer learning settings
502#[derive(Debug, Clone)]
503pub struct TransferLearningSettings {
504    /// Enable domain adaptation
505    pub domain_adaptation: bool,
506    /// Source domain weights
507    pub source_domain_weights: Vec<f64>,
508    /// Transfer learning strategies
509    pub strategies: Vec<TransferStrategy>,
510    /// Domain similarity measures
511    pub similarity_measures: Vec<SimilarityMeasure>,
512    /// Enable progressive transfer
513    pub progressive_transfer: bool,
514}
515/// Validation result for meta-learning
516#[derive(Debug, Clone)]
517pub struct ValidationResult {
518    /// Whether validation passed
519    pub is_valid: bool,
520    /// Validation loss
521    pub validation_loss: f64,
522    /// Additional validation metrics
523    pub metrics: HashMap<String, f64>,
524}
525/// Transfer learning result
526#[derive(Debug, Clone)]
527pub struct TransferLearningResult<T: Float + Debug + Send + Sync + 'static> {
528    pub transfer_efficiency: T,
529    pub domain_adaptation_score: T,
530    pub source_task_retention: T,
531    pub target_task_performance: T,
532}
533/// Adaptation strategies
534#[derive(Debug, Clone, Copy)]
535pub enum AdaptationStrategy {
536    /// Fine-tuning all parameters
537    FullFineTuning,
538    /// Fine-tuning only specific layers
539    LayerWiseFineTuning,
540    /// Parameter-efficient adaptation
541    ParameterEfficient,
542    /// Adaptation via learned learning rates
543    LearnedLearningRates,
544    /// Gradient-based adaptation
545    GradientBased,
546    /// Memory-based adaptation
547    MemoryBased,
548    /// Attention-based adaptation
549    AttentionBased,
550    /// Modular adaptation
551    ModularAdaptation,
552}
553/// Meta-task representation
554#[derive(Debug, Clone)]
555pub struct MetaTask<T: Float + Debug + Send + Sync + 'static> {
556    /// Task identifier
557    pub id: String,
558    /// Support set (training data for adaptation)
559    pub support_set: TaskDataset<T>,
560    /// Query set (test data for evaluation)
561    pub query_set: TaskDataset<T>,
562    /// Task metadata
563    pub metadata: TaskMetadata,
564    /// Task difficulty
565    pub difficulty: T,
566    /// Task domain
567    pub domain: String,
568    /// Task type
569    pub task_type: TaskType,
570}
571/// Few-shot learner
572pub struct FewShotLearner<T: Float + Debug + Send + Sync + 'static> {
573    settings: FewShotSettings,
574    _phantom: std::marker::PhantomData<T>,
575}
576impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> FewShotLearner<T> {
577    pub fn new(settings: &FewShotSettings) -> Result<Self> {
578        Ok(Self {
579            settings: settings.clone(),
580            _phantom: std::marker::PhantomData,
581        })
582    }
583    pub fn learn(
584        &mut self,
585        _support_set: &TaskDataset<T>,
586        _query_set: &TaskDataset<T>,
587        _meta_parameters: &HashMap<String, Array1<T>>,
588    ) -> Result<FewShotResult<T>> {
589        Ok(FewShotResult {
590            accuracy: T::from(0.8).unwrap_or_default(),
591            confidence: T::from(0.9).unwrap_or_default(),
592            adaptation_steps: 5,
593            uncertainty_estimates: vec![T::from(0.1).unwrap_or_default(); 10],
594        })
595    }
596    pub fn average_performance(&self) -> T {
597        T::from(0.8).unwrap_or_default()
598    }
599}
600/// Reverse mode automatic differentiation
601#[derive(Debug)]
602pub struct ReverseModeAD<T: Float + Debug + Send + Sync + 'static> {
603    /// Computational tape
604    tape: Vec<TapeEntry<T>>,
605    /// Adjoint values
606    adjoints: HashMap<usize, T>,
607    /// Gradient accumulator
608    gradient_accumulator: Array1<T>,
609}
610impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> ReverseModeAD<T> {
611    /// Create a new reverse mode AD engine
612    pub fn new() -> Result<Self> {
613        Ok(Self {
614            tape: Vec::new(),
615            adjoints: HashMap::new(),
616            gradient_accumulator: Array1::zeros(1),
617        })
618    }
619}
620/// Meta-optimization tracker
621pub struct MetaOptimizationTracker<T: Float + Debug + Send + Sync + 'static> {
622    step_count: usize,
623    _phantom: std::marker::PhantomData<T>,
624}
625impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> MetaOptimizationTracker<T> {
626    pub fn new() -> Self {
627        Self {
628            step_count: 0,
629            _phantom: std::marker::PhantomData,
630        }
631    }
632    pub fn record_epoch(
633        &mut self,
634        _epoch: usize,
635        _training_result: &TrainingResult,
636        _validation_result: &ValidationResult,
637    ) -> Result<()> {
638        self.step_count += 1;
639        Ok(())
640    }
641    pub fn update_best_parameters(&mut self, _metaparameters: &MetaParameters<T>) -> Result<()> {
642        Ok(())
643    }
644    pub fn total_tasks_seen(&self) -> usize {
645        self.step_count * 10
646    }
647    pub fn adaptation_efficiency(&self) -> T {
648        T::from(0.9).unwrap_or_default()
649    }
650}
651/// Continual learning result
652#[derive(Debug, Clone)]
653pub struct ContinualLearningResult<T: Float + Debug + Send + Sync + 'static> {
654    pub sequence_results: Vec<TaskResult<T>>,
655    pub forgetting_measure: T,
656    pub adaptation_efficiency: T,
657}
658/// Anti-forgetting strategies
659#[derive(Debug, Clone, Copy)]
660pub enum AntiForgettingStrategy {
661    ElasticWeightConsolidation,
662    SynapticIntelligence,
663    MemoryReplay,
664    ProgressiveNetworks,
665    PackNet,
666    Piggyback,
667    HAT,
668}
669/// Training result for meta-learning
670#[derive(Debug, Clone)]
671pub struct TrainingResult {
672    /// Training loss
673    pub training_loss: f64,
674    /// Training metrics
675    pub metrics: HashMap<String, f64>,
676    /// Number of training steps
677    pub steps: usize,
678}
679/// Meta-training results
680#[derive(Debug, Clone)]
681pub struct MetaTrainingResults<T: Float + Debug + Send + Sync + 'static> {
682    pub final_parameters: HashMap<String, Array1<T>>,
683    pub training_history: Vec<MetaTrainingEpoch<T>>,
684    pub best_performance: T,
685    pub total_epochs: usize,
686}
687/// Meta-Learning Framework for Learned Optimizers
688pub struct MetaLearningFramework<T: Float + Debug + Send + Sync + 'static> {
689    /// Meta-learning configuration
690    config: MetaLearningConfig,
691    /// Meta-learner implementation
692    meta_learner: Box<dyn MetaLearner<T> + Send + Sync>,
693    /// Task distribution manager
694    task_manager: TaskDistributionManager<T>,
695    /// Meta-validation system
696    meta_validator: MetaValidator<T>,
697    /// Adaptation engine
698    adaptation_engine: AdaptationEngine<T>,
699    /// Transfer learning manager
700    transfer_manager: TransferLearningManager<T>,
701    /// Continual learning system
702    continual_learner: ContinualLearningSystem<T>,
703    /// Multi-task coordinator
704    multitask_coordinator: MultiTaskCoordinator<T>,
705    /// Meta-optimization tracker
706    meta_tracker: MetaOptimizationTracker<T>,
707    /// Few-shot learning specialist
708    few_shot_learner: FewShotLearner<T>,
709}
710impl<
711        T: Float
712            + Default
713            + Clone
714            + Send
715            + Sync
716            + std::iter::Sum
717            + for<'a> std::iter::Sum<&'a T>
718            + scirs2_core::ndarray::ScalarOperand
719            + std::fmt::Debug,
720    > MetaLearningFramework<T>
721{
722    /// Create a new meta-learning framework
723    pub fn new(config: MetaLearningConfig) -> Result<Self> {
724        let meta_learner = Self::create_meta_learner(&config)?;
725        let task_manager = TaskDistributionManager::new(&config)?;
726        let meta_validator = MetaValidator::new(&config)?;
727        let adaptation_engine = AdaptationEngine::new(&config)?;
728        let transfer_manager = TransferLearningManager::new(&config.transfer_settings)?;
729        let continual_learner = ContinualLearningSystem::new(&config.continual_settings)?;
730        let multitask_coordinator = MultiTaskCoordinator::new(&config.multitask_settings)?;
731        let meta_tracker = MetaOptimizationTracker::new();
732        let few_shot_learner = FewShotLearner::new(&config.few_shot_settings)?;
733        Ok(Self {
734            config,
735            meta_learner,
736            task_manager,
737            meta_validator,
738            adaptation_engine,
739            transfer_manager,
740            continual_learner,
741            multitask_coordinator,
742            meta_tracker,
743            few_shot_learner,
744        })
745    }
746    fn create_meta_learner(
747        config: &MetaLearningConfig,
748    ) -> Result<Box<dyn MetaLearner<T> + Send + Sync>> {
749        match config.algorithm {
750            MetaLearningAlgorithm::MAML => {
751                let maml_config = MAMLConfig {
752                    second_order: config.second_order,
753                    inner_lr: scirs2_core::numeric::NumCast::from(config.inner_learning_rate)
754                        .unwrap_or_else(|| T::zero()),
755                    outer_lr: scirs2_core::numeric::NumCast::from(config.meta_learning_rate)
756                        .unwrap_or_else(|| T::zero()),
757                    inner_steps: config.inner_steps,
758                    allow_unused: true,
759                    gradient_clip: Some(config.gradient_clip),
760                };
761                Ok(Box::new(MAMLLearner::<T, scirs2_core::ndarray::Ix1>::new(
762                    maml_config,
763                )?))
764            }
765            _ => {
766                let maml_config = MAMLConfig {
767                    second_order: false,
768                    inner_lr: scirs2_core::numeric::NumCast::from(config.inner_learning_rate)
769                        .unwrap_or_else(|| T::zero()),
770                    outer_lr: scirs2_core::numeric::NumCast::from(config.meta_learning_rate)
771                        .unwrap_or_else(|| T::zero()),
772                    inner_steps: config.inner_steps,
773                    allow_unused: true,
774                    gradient_clip: Some(config.gradient_clip),
775                };
776                Ok(Box::new(MAMLLearner::<T, scirs2_core::ndarray::Ix1>::new(
777                    maml_config,
778                )?))
779            }
780        }
781    }
782    /// Perform meta-training
783    pub async fn meta_train(
784        &mut self,
785        tasks: Vec<MetaTask<T>>,
786        num_epochs: usize,
787    ) -> Result<MetaTrainingResults<T>> {
788        let meta_params_raw = self.initialize_meta_parameters()?;
789        let mut meta_parameters = MetaParameters {
790            parameters: meta_params_raw,
791            metadata: HashMap::new(),
792        };
793        let mut training_history = Vec::new();
794        let mut best_performance = T::neg_infinity();
795        for epoch in 0..num_epochs {
796            let task_batch = self
797                .task_manager
798                .sample_task_batch(&tasks, self.config.task_batch_size)?;
799            let training_result = self
800                .meta_learner
801                .meta_train_step(&task_batch, &mut meta_parameters.parameters)?;
802            self.update_meta_parameters(
803                &mut meta_parameters.parameters,
804                &training_result.meta_gradients,
805            )?;
806            let validation_result = self.meta_validator.validate(&meta_parameters, &tasks)?;
807            let training_result_simple = TrainingResult {
808                training_loss: training_result.meta_loss.to_f64().unwrap_or(0.0),
809                metrics: HashMap::new(),
810                steps: epoch,
811            };
812            self.meta_tracker
813                .record_epoch(epoch, &training_result_simple, &validation_result)?;
814            let current_performance =
815                T::from(-validation_result.validation_loss).unwrap_or_default();
816            if current_performance > best_performance {
817                best_performance = current_performance;
818                self.meta_tracker.update_best_parameters(&meta_parameters)?;
819            }
820            let meta_validation_result = MetaValidationResult {
821                performance: current_performance,
822                adaptation_speed: T::from(0.0).unwrap_or_default(),
823                generalization_gap: T::from(validation_result.validation_loss).unwrap_or_default(),
824                task_specific_metrics: HashMap::new(),
825            };
826            training_history.push(MetaTrainingEpoch {
827                epoch,
828                training_result,
829                validation_result: meta_validation_result,
830                meta_parameters: meta_parameters.parameters.clone(),
831            });
832            if self.should_early_stop(&training_history) {
833                break;
834            }
835        }
836        let total_epochs = training_history.len();
837        Ok(MetaTrainingResults {
838            final_parameters: meta_parameters.parameters,
839            training_history,
840            best_performance,
841            total_epochs,
842        })
843    }
844    /// Adapt to new task
845    pub fn adapt_to_task(
846        &mut self,
847        task: &MetaTask<T>,
848        meta_parameters: &HashMap<String, Array1<T>>,
849    ) -> Result<TaskAdaptationResult<T>> {
850        self.adaptation_engine.adapt(
851            task,
852            meta_parameters,
853            &mut *self.meta_learner,
854            self.config.inner_steps,
855        )
856    }
857    /// Perform few-shot learning
858    pub fn few_shot_learning(
859        &mut self,
860        support_set: &TaskDataset<T>,
861        query_set: &TaskDataset<T>,
862        meta_parameters: &HashMap<String, Array1<T>>,
863    ) -> Result<FewShotResult<T>> {
864        self.few_shot_learner
865            .learn(support_set, query_set, meta_parameters)
866    }
867    /// Transfer learning to new domain
868    pub fn transfer_to_domain(
869        &mut self,
870        source_tasks: &[MetaTask<T>],
871        target_tasks: &[MetaTask<T>],
872        meta_parameters: &HashMap<String, Array1<T>>,
873    ) -> Result<TransferLearningResult<T>> {
874        self.transfer_manager
875            .transfer(source_tasks, target_tasks, meta_parameters)
876    }
877    /// Continual learning across task sequence
878    pub fn continual_learning(
879        &mut self,
880        task_sequence: &[MetaTask<T>],
881        meta_parameters: &mut HashMap<String, Array1<T>>,
882    ) -> Result<ContinualLearningResult<T>> {
883        self.continual_learner
884            .learn_sequence(task_sequence, meta_parameters)
885    }
886    /// Multi-task learning
887    pub fn multi_task_learning(
888        &mut self,
889        tasks: &[MetaTask<T>],
890        meta_parameters: &mut HashMap<String, Array1<T>>,
891    ) -> Result<MultiTaskResult<T>> {
892        self.multitask_coordinator
893            .learn_simultaneously(tasks, meta_parameters)
894    }
895    fn initialize_meta_parameters(&self) -> Result<HashMap<String, Array1<T>>> {
896        let mut parameters = HashMap::new();
897        parameters.insert("lstm_weights".to_string(), Array1::zeros(256 * 4));
898        parameters.insert("output_weights".to_string(), Array1::zeros(256));
899        Ok(parameters)
900    }
901    fn update_meta_parameters(
902        &self,
903        meta_parameters: &mut HashMap<String, Array1<T>>,
904        meta_gradients: &HashMap<String, Array1<T>>,
905    ) -> Result<()> {
906        let meta_lr = scirs2_core::numeric::NumCast::from(self.config.meta_learning_rate)
907            .unwrap_or_else(|| T::zero());
908        for (name, gradient) in meta_gradients {
909            if let Some(parameter) = meta_parameters.get_mut(name) {
910                for i in 0..parameter.len() {
911                    parameter[i] = parameter[i] - meta_lr * gradient[i];
912                }
913            }
914        }
915        Ok(())
916    }
917    fn should_early_stop(&self, history: &[MetaTrainingEpoch<T>]) -> bool {
918        if history.len() < 10 {
919            return false;
920        }
921        let recent_performances: Vec<_> = history
922            .iter()
923            .rev()
924            .take(5)
925            .map(|epoch| epoch.validation_result.performance)
926            .collect();
927        let max_recent = recent_performances
928            .iter()
929            .fold(T::neg_infinity(), |a, &b| a.max(b));
930        let min_recent = recent_performances
931            .iter()
932            .fold(T::infinity(), |a, &b| a.min(b));
933        let performance_range = max_recent - min_recent;
934        let threshold = scirs2_core::numeric::NumCast::from(1e-4).unwrap_or_else(|| T::zero());
935        performance_range < threshold
936    }
937    /// Get meta-learning statistics
938    pub fn get_meta_learning_statistics(&self) -> MetaLearningStatistics<T> {
939        MetaLearningStatistics {
940            algorithm: self.config.algorithm,
941            total_tasks_seen: self.meta_tracker.total_tasks_seen(),
942            adaptation_efficiency: self.meta_tracker.adaptation_efficiency(),
943            transfer_success_rate: self.transfer_manager.success_rate(),
944            forgetting_measure: self.continual_learner.forgetting_measure(),
945            multitask_interference: self.multitask_coordinator.interference_measure(),
946            few_shot_performance: self.few_shot_learner.average_performance(),
947        }
948    }
949}
950/// Gradient computation methods
951#[derive(Debug, Clone, Copy)]
952pub enum GradientComputationMethod {
953    FiniteDifference,
954    AutomaticDifferentiation,
955    SymbolicDifferentiation,
956    Hybrid,
957}
958/// Dataset metadata
959#[derive(Debug, Clone)]
960pub struct DatasetMetadata {
961    /// Number of samples
962    pub num_samples: usize,
963    /// Feature dimension
964    pub feature_dim: usize,
965    /// Data distribution type
966    pub distribution_type: String,
967    /// Noise level
968    pub noise_level: f64,
969}
970/// Transfer learning manager
971pub struct TransferLearningManager<T: Float + Debug + Send + Sync + 'static> {
972    settings: TransferLearningSettings,
973    _phantom: std::marker::PhantomData<T>,
974}
975impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> TransferLearningManager<T> {
976    pub fn new(settings: &TransferLearningSettings) -> Result<Self> {
977        Ok(Self {
978            settings: settings.clone(),
979            _phantom: std::marker::PhantomData,
980        })
981    }
982    pub fn transfer(
983        &mut self,
984        _source_tasks: &[MetaTask<T>],
985        _target_tasks: &[MetaTask<T>],
986        _meta_parameters: &HashMap<String, Array1<T>>,
987    ) -> Result<TransferLearningResult<T>> {
988        Ok(TransferLearningResult {
989            transfer_efficiency: T::from(0.85).unwrap_or_default(),
990            domain_adaptation_score: T::from(0.8).unwrap_or_default(),
991            source_task_retention: T::from(0.9).unwrap_or_default(),
992            target_task_performance: T::from(0.8).unwrap_or_default(),
993        })
994    }
995    pub fn success_rate(&self) -> T {
996        T::from(0.85).unwrap_or_default()
997    }
998}
999/// Second-order gradient engine
1000#[derive(Debug)]
1001pub struct SecondOrderGradientEngine<T: Float + Debug + Send + Sync + 'static> {
1002    /// Hessian computation method
1003    hessian_method: HessianComputationMethod,
1004    /// Hessian matrix
1005    hessian: Array2<T>,
1006    /// Hessian-vector product engine
1007    hvp_engine: HessianVectorProductEngine<T>,
1008    /// Curvature estimation
1009    curvature_estimator: CurvatureEstimator<T>,
1010}
1011impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> SecondOrderGradientEngine<T> {
1012    /// Create a new second-order gradient engine
1013    pub fn new() -> Result<Self> {
1014        Ok(Self {
1015            hessian_method: HessianComputationMethod::BFGS,
1016            hessian: Array2::zeros((1, 1)),
1017            hvp_engine: HessianVectorProductEngine::new()?,
1018            curvature_estimator: CurvatureEstimator::new()?,
1019        })
1020    }
1021}
1022/// Meta-learning statistics
1023#[derive(Debug, Clone)]
1024pub struct MetaLearningStatistics<T: Float + Debug + Send + Sync + 'static> {
1025    pub algorithm: MetaLearningAlgorithm,
1026    pub total_tasks_seen: usize,
1027    pub adaptation_efficiency: T,
1028    pub transfer_success_rate: T,
1029    pub forgetting_measure: T,
1030    pub multitask_interference: T,
1031    pub few_shot_performance: T,
1032}
1033/// Task adaptation result
1034#[derive(Debug, Clone)]
1035pub struct TaskAdaptationResult<T: Float + Debug + Send + Sync + 'static> {
1036    /// Adapted parameters
1037    pub adapted_parameters: HashMap<String, Array1<T>>,
1038    /// Adaptation trajectory
1039    pub adaptation_trajectory: Vec<AdaptationStep<T>>,
1040    /// Final adaptation loss
1041    pub final_loss: T,
1042    /// Adaptation metrics
1043    pub metrics: TaskAdaptationMetrics<T>,
1044}
1045/// Transfer strategies
1046#[derive(Debug, Clone, Copy)]
1047pub enum TransferStrategy {
1048    FeatureExtraction,
1049    FineTuning,
1050    DomainAdaptation,
1051    MultiTask,
1052    MetaTransfer,
1053    Progressive,
1054}
1055/// Augmentation strategies
1056#[derive(Debug, Clone, Copy)]
1057pub enum AugmentationStrategy {
1058    Geometric,
1059    Color,
1060    Noise,
1061    Mixup,
1062    CutMix,
1063    Learned,
1064}
1065/// Stability metrics
1066#[derive(Debug, Clone)]
1067pub struct StabilityMetrics<T: Float + Debug + Send + Sync + 'static> {
1068    /// Parameter stability
1069    pub parameter_stability: T,
1070    /// Performance stability
1071    pub performance_stability: T,
1072    /// Gradient stability
1073    pub gradient_stability: T,
1074    /// Catastrophic forgetting measure
1075    pub forgetting_measure: T,
1076}
1077/// Gradient computation engine
1078#[derive(Debug)]
1079pub struct GradientComputationEngine<T: Float + Debug + Send + Sync + 'static> {
1080    /// Gradient computation method
1081    method: GradientComputationMethod,
1082    /// Computational graph
1083    computation_graph: ComputationGraph<T>,
1084    /// Gradient cache
1085    gradient_cache: HashMap<String, Array1<T>>,
1086    /// Automatic differentiation engine
1087    autodiff_engine: AutoDiffEngine<T>,
1088}
1089impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> GradientComputationEngine<T> {
1090    /// Create a new gradient computation engine
1091    pub fn new() -> Result<Self> {
1092        Ok(Self {
1093            method: GradientComputationMethod::AutomaticDifferentiation,
1094            computation_graph: ComputationGraph::new()?,
1095            gradient_cache: HashMap::new(),
1096            autodiff_engine: AutoDiffEngine::new()?,
1097        })
1098    }
1099}
1100/// Task result for meta-learning
1101#[derive(Debug, Clone)]
1102pub struct TaskResult<T: Float + Debug + Send + Sync + 'static> {
1103    pub task_id: String,
1104    pub loss: T,
1105    pub metrics: HashMap<String, T>,
1106}
1107/// Multi-task coordinator
1108pub struct MultiTaskCoordinator<T: Float + Debug + Send + Sync + 'static> {
1109    settings: MultiTaskSettings,
1110    _phantom: std::marker::PhantomData<T>,
1111}
1112impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> MultiTaskCoordinator<T> {
1113    pub fn new(settings: &MultiTaskSettings) -> Result<Self> {
1114        Ok(Self {
1115            settings: settings.clone(),
1116            _phantom: std::marker::PhantomData,
1117        })
1118    }
1119    pub fn learn_simultaneously(
1120        &mut self,
1121        tasks: &[MetaTask<T>],
1122        _meta_parameters: &mut HashMap<String, Array1<T>>,
1123    ) -> Result<MultiTaskResult<T>> {
1124        let mut task_results = Vec::new();
1125        for task in tasks {
1126            let task_result = TaskResult {
1127                task_id: task.id.clone(),
1128                loss: scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero()),
1129                metrics: HashMap::new(),
1130            };
1131            task_results.push(task_result);
1132        }
1133        Ok(MultiTaskResult {
1134            task_results,
1135            coordination_overhead: scirs2_core::numeric::NumCast::from(0.01)
1136                .unwrap_or_else(|| T::zero()),
1137            convergence_status: "converged".to_string(),
1138        })
1139    }
1140    pub fn interference_measure(&self) -> T {
1141        T::from(0.1).unwrap_or_default()
1142    }
1143}
1144/// HVP computation methods
1145#[derive(Debug, Clone, Copy)]
1146pub enum HVPComputationMethod {
1147    FiniteDifference,
1148    AutomaticDifferentiation,
1149    ConjugateGradient,
1150}
1151/// Computation graph node
1152#[derive(Debug, Clone)]
1153pub struct ComputationNode<T: Float + Debug + Send + Sync + 'static> {
1154    /// Node ID
1155    pub id: usize,
1156    /// Operation type
1157    pub operation: ComputationOperation<T>,
1158    /// Input connections
1159    pub inputs: Vec<usize>,
1160    /// Output value
1161    pub output: Option<Array1<T>>,
1162    /// Gradient w.r.t. this node
1163    pub gradient: Option<Array1<T>>,
1164}
1165/// Meta-learning algorithms
1166#[derive(Debug, Clone, Copy)]
1167pub enum MetaLearningAlgorithm {
1168    /// Model-Agnostic Meta-Learning
1169    MAML,
1170    /// First-Order MAML (FOMAML)
1171    FOMAML,
1172    /// Reptile algorithm
1173    Reptile,
1174    /// Meta-SGD
1175    MetaSGD,
1176    /// Learning to Learn by Gradient Descent
1177    L2L,
1178    /// Gradient-Based Meta-Learning
1179    GBML,
1180    /// Meta-Learning with Implicit Gradients
1181    IMaml,
1182    /// Prototypical Networks
1183    ProtoNet,
1184    /// Matching Networks
1185    MatchingNet,
1186    /// Relation Networks
1187    RelationNet,
1188    /// Memory-Augmented Neural Networks
1189    MANN,
1190    /// Meta-Learning with Warped Gradient Descent
1191    WarpGrad,
1192    /// Learned Gradient Descent
1193    LearnedGD,
1194}
1195/// Gradient balancing methods
1196#[derive(Debug, Clone, Copy)]
1197pub enum GradientBalancingMethod {
1198    Uniform,
1199    GradNorm,
1200    PCGrad,
1201    CAGrad,
1202    NashMTL,
1203}
1204/// Meta-validation system for meta-learning
1205pub struct MetaValidator<T: Float + Debug + Send + Sync + 'static> {
1206    config: MetaLearningConfig,
1207    _phantom: std::marker::PhantomData<T>,
1208}
1209impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> MetaValidator<T> {
1210    pub fn new(config: &MetaLearningConfig) -> Result<Self> {
1211        Ok(Self {
1212            config: config.clone(),
1213            _phantom: std::marker::PhantomData,
1214        })
1215    }
1216    pub fn validate(
1217        &self,
1218        _meta_parameters: &MetaParameters<T>,
1219        _tasks: &[MetaTask<T>],
1220    ) -> Result<ValidationResult> {
1221        Ok(ValidationResult {
1222            is_valid: true,
1223            validation_loss: 0.5,
1224            metrics: std::collections::HashMap::new(),
1225        })
1226    }
1227}
1228/// Query evaluation result
1229#[derive(Debug, Clone)]
1230pub struct QueryEvaluationResult<T: Float + Debug + Send + Sync + 'static> {
1231    /// Query set loss
1232    pub query_loss: T,
1233    /// Prediction accuracy
1234    pub accuracy: T,
1235    /// Per-sample predictions
1236    pub predictions: Vec<T>,
1237    /// Confidence scores
1238    pub confidence_scores: Vec<T>,
1239    /// Evaluation metrics
1240    pub metrics: QueryEvaluationMetrics<T>,
1241}
1242/// Few-shot learning algorithms
1243#[derive(Debug, Clone, Copy)]
1244pub enum FewShotAlgorithm {
1245    Prototypical,
1246    Matching,
1247    Relation,
1248    MAML,
1249    Reptile,
1250    MetaOptNet,
1251}
1252/// Activation functions
1253#[derive(Debug, Clone, Copy)]
1254pub enum ActivationFunction {
1255    ReLU,
1256    Sigmoid,
1257    Tanh,
1258    Softmax,
1259    GELU,
1260}
1261/// Curvature estimation methods
1262#[derive(Debug, Clone, Copy)]
1263pub enum CurvatureEstimationMethod {
1264    DiagonalHessian,
1265    BlockDiagonalHessian,
1266    KroneckerFactored,
1267    NaturalGradient,
1268}
1269/// Mixed mode automatic differentiation
1270#[derive(Debug)]
1271pub struct MixedModeAD<T: Float + Debug + Send + Sync + 'static> {
1272    /// Forward mode component
1273    forward_component: ForwardModeAD<T>,
1274    /// Reverse mode component
1275    reverse_component: ReverseModeAD<T>,
1276    /// Mode selection strategy
1277    mode_selection: ModeSelectionStrategy,
1278}
1279impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> MixedModeAD<T> {
1280    /// Create a new mixed mode AD engine
1281    pub fn new() -> Result<Self> {
1282        Ok(Self {
1283            forward_component: ForwardModeAD::new()?,
1284            reverse_component: ReverseModeAD::new()?,
1285            mode_selection: ModeSelectionStrategy::Adaptive,
1286        })
1287    }
1288}
1289/// Adaptation statistics
1290#[derive(Debug, Clone)]
1291pub struct AdaptationStatistics<T: Float + Debug + Send + Sync + 'static> {
1292    /// Convergence steps per task
1293    pub convergence_steps: Vec<usize>,
1294    /// Final losses per task
1295    pub final_losses: Vec<T>,
1296    /// Adaptation efficiency
1297    pub adaptation_efficiency: T,
1298    /// Stability metrics
1299    pub stability_metrics: StabilityMetrics<T>,
1300}
1301/// Meta-validation result
1302#[derive(Debug, Clone)]
1303pub struct MetaValidationResult<T: Float + Debug + Send + Sync + 'static> {
1304    pub performance: T,
1305    pub adaptation_speed: T,
1306    pub generalization_gap: T,
1307    pub task_specific_metrics: HashMap<String, T>,
1308}
1309/// Loss functions
1310#[derive(Debug, Clone, Copy)]
1311pub enum LossFunction {
1312    MeanSquaredError,
1313    CrossEntropy,
1314    Hinge,
1315    Huber,
1316}
1317/// Adaptation engine for meta-learning
1318pub struct AdaptationEngine<T: Float + Debug + Send + Sync + 'static> {
1319    config: MetaLearningConfig,
1320    _phantom: std::marker::PhantomData<T>,
1321}
1322impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> AdaptationEngine<T> {
1323    pub fn new(config: &MetaLearningConfig) -> Result<Self> {
1324        Ok(Self {
1325            config: config.clone(),
1326            _phantom: std::marker::PhantomData,
1327        })
1328    }
1329    pub fn adapt(
1330        &mut self,
1331        task: &MetaTask<T>,
1332        _meta_parameters: &HashMap<String, Array1<T>>,
1333        _meta_learner: &mut dyn MetaLearner<T>,
1334        _inner_steps: usize,
1335    ) -> Result<TaskAdaptationResult<T>> {
1336        Ok(TaskAdaptationResult {
1337            adapted_parameters: _meta_parameters.clone(),
1338            adaptation_trajectory: Vec::new(),
1339            final_loss: T::from(0.1).unwrap_or_default(),
1340            metrics: TaskAdaptationMetrics {
1341                convergence_speed: T::from(1.0).unwrap_or_default(),
1342                final_performance: T::from(0.9).unwrap_or_default(),
1343                efficiency: T::from(0.8).unwrap_or_default(),
1344                robustness: T::from(0.85).unwrap_or_default(),
1345            },
1346        })
1347    }
1348}
1349/// Continual learning settings
1350#[derive(Debug, Clone)]
1351pub struct ContinualLearningSettings {
1352    /// Catastrophic forgetting mitigation
1353    pub anti_forgetting_strategies: Vec<AntiForgettingStrategy>,
1354    /// Memory replay settings
1355    pub memory_replay: MemoryReplaySettings,
1356    /// Task identification method
1357    pub task_identification: TaskIdentificationMethod,
1358    /// Plasticity-stability trade-off
1359    pub plasticity_stability_balance: f64,
1360}
1361/// Task weighting strategies
1362#[derive(Debug, Clone, Copy)]
1363pub enum TaskWeightingStrategy {
1364    Uniform,
1365    UncertaintyBased,
1366    GradientMagnitude,
1367    PerformanceBased,
1368    Adaptive,
1369    Learned,
1370}
1371/// Multi-task settings
1372#[derive(Debug, Clone)]
1373pub struct MultiTaskSettings {
1374    /// Task weighting strategy
1375    pub task_weighting: TaskWeightingStrategy,
1376    /// Gradient balancing method
1377    pub gradient_balancing: GradientBalancingMethod,
1378    /// Task interference mitigation
1379    pub interference_mitigation: InterferenceMitigationStrategy,
1380    /// Shared representation learning
1381    pub shared_representation: SharedRepresentationStrategy,
1382}
1383/// Shared representation strategies
1384#[derive(Debug, Clone, Copy)]
1385pub enum SharedRepresentationStrategy {
1386    HardSharing,
1387    SoftSharing,
1388    HierarchicalSharing,
1389    AttentionBased,
1390    Modular,
1391}
1392/// Distance metrics
1393#[derive(Debug, Clone, Copy)]
1394pub enum DistanceMetric {
1395    Euclidean,
1396    Cosine,
1397    Mahalanobis,
1398    Learned,
1399}
1400/// Dual number for forward mode AD
1401#[derive(Debug, Clone)]
1402pub struct DualNumber<T: Float + Debug + Send + Sync + 'static> {
1403    /// Real part
1404    pub real: T,
1405    /// Infinitesimal part
1406    pub dual: T,
1407}
1408/// Task adaptation metrics
1409#[derive(Debug, Clone)]
1410pub struct TaskAdaptationMetrics<T: Float + Debug + Send + Sync + 'static> {
1411    /// Convergence speed
1412    pub convergence_speed: T,
1413    /// Final performance
1414    pub final_performance: T,
1415    /// Adaptation efficiency
1416    pub efficiency: T,
1417    /// Robustness to noise
1418    pub robustness: T,
1419}
1420/// Mode selection strategies
1421#[derive(Debug, Clone, Copy)]
1422pub enum ModeSelectionStrategy {
1423    ForwardOnly,
1424    ReverseOnly,
1425    Adaptive,
1426    Hybrid,
1427}
1428/// Few-shot learning settings
1429#[derive(Debug, Clone)]
1430pub struct FewShotSettings {
1431    /// Number of shots (examples per class)
1432    pub num_shots: usize,
1433    /// Number of ways (classes)
1434    pub num_ways: usize,
1435    /// Few-shot algorithm
1436    pub algorithm: FewShotAlgorithm,
1437    /// Metric learning settings
1438    pub metric_learning: MetricLearningSettings,
1439    /// Augmentation strategies
1440    pub augmentation_strategies: Vec<AugmentationStrategy>,
1441}
1442/// Domain similarity measures
1443#[derive(Debug, Clone, Copy)]
1444pub enum SimilarityMeasure {
1445    CosineDistance,
1446    KLDivergence,
1447    WassersteinDistance,
1448    CentralMomentDiscrepancy,
1449    MaximumMeanDiscrepancy,
1450}
1451/// Computation operations
1452#[derive(Debug, Clone)]
1453pub enum ComputationOperation<T: Float + Debug + Send + Sync + 'static> {
1454    Add,
1455    Multiply,
1456    MatMul(Array2<T>),
1457    Activation(ActivationFunction),
1458    Loss(LossFunction),
1459    Parameter(Array1<T>),
1460    Input,
1461}
1462/// Meta-learning configuration
1463#[derive(Debug, Clone)]
1464pub struct MetaLearningConfig {
1465    /// Meta-learning algorithm
1466    pub algorithm: MetaLearningAlgorithm,
1467    /// Number of inner loop steps
1468    pub inner_steps: usize,
1469    /// Number of outer loop steps
1470    pub outer_steps: usize,
1471    /// Meta-learning rate
1472    pub meta_learning_rate: f64,
1473    /// Inner learning rate
1474    pub inner_learning_rate: f64,
1475    /// Task batch size
1476    pub task_batch_size: usize,
1477    /// Support set size per task
1478    pub support_set_size: usize,
1479    /// Query set size per task
1480    pub query_set_size: usize,
1481    /// Enable second-order gradients
1482    pub second_order: bool,
1483    /// Gradient clipping threshold
1484    pub gradient_clip: f64,
1485    /// Adaptation strategies
1486    pub adaptation_strategies: Vec<AdaptationStrategy>,
1487    /// Transfer learning settings
1488    pub transfer_settings: TransferLearningSettings,
1489    /// Continual learning settings
1490    pub continual_settings: ContinualLearningSettings,
1491    /// Multi-task settings
1492    pub multitask_settings: MultiTaskSettings,
1493    /// Few-shot learning settings
1494    pub few_shot_settings: FewShotSettings,
1495    /// Enable meta-regularization
1496    pub enable_meta_regularization: bool,
1497    /// Meta-regularization strength
1498    pub meta_regularization_strength: f64,
1499    /// Task sampling strategy
1500    pub task_sampling_strategy: TaskSamplingStrategy,
1501}
1502/// Task sampling strategies
1503#[derive(Debug, Clone, Copy)]
1504pub enum TaskSamplingStrategy {
1505    Uniform,
1506    Curriculum,
1507    DifficultyBased,
1508    DiversityBased,
1509    ActiveLearning,
1510    Adversarial,
1511}
1512/// Few-shot learning result
1513#[derive(Debug, Clone)]
1514pub struct FewShotResult<T: Float + Debug + Send + Sync + 'static> {
1515    pub accuracy: T,
1516    pub confidence: T,
1517    pub adaptation_steps: usize,
1518    pub uncertainty_estimates: Vec<T>,
1519}
optirs_learned/meta_learning/types.rs

optirs_learned/meta_learning/
types.rs
