optirs_learned/meta_learning/
types.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5use crate::error::{OptimError, Result};
6use scirs2_core::ndarray::{Array1, Dimension};
7use scirs2_core::numeric::Float;
8use std::collections::{HashMap, VecDeque};
9use std::fmt::Debug;
10use std::time::Instant;
11
12/// Adaptation step
13#[derive(Debug, Clone)]
14pub struct AdaptationStep<T: Float + Debug + Send + Sync + 'static> {
15    /// Step number
16    pub step: usize,
17    /// Loss at this step
18    pub loss: T,
19    /// Gradient norm
20    pub gradient_norm: T,
21    /// Parameter change norm
22    pub parameter_change_norm: T,
23    /// Learning rate used
24    pub learning_rate: T,
25}
26/// Meta-training metrics
27#[derive(Debug, Clone)]
28pub struct MetaTrainingMetrics<T: Float + Debug + Send + Sync + 'static> {
29    /// Average adaptation speed
30    pub avg_adaptation_speed: T,
31    /// Generalization performance
32    pub generalization_performance: T,
33    /// Task diversity handled
34    pub task_diversity: T,
35    /// Gradient alignment score
36    pub gradient_alignment: T,
37}
38/// Task identification methods
39#[derive(Debug, Clone, Copy)]
40pub enum TaskIdentificationMethod {
41    Oracle,
42    Learned,
43    Clustering,
44    EntropyBased,
45    GradientBased,
46}
47/// Query evaluation metrics
48#[derive(Debug, Clone)]
49pub struct QueryEvaluationMetrics<T: Float + Debug + Send + Sync + 'static> {
50    /// Mean squared error (for regression)
51    pub mse: Option<T>,
52    /// Classification accuracy (for classification)
53    pub classification_accuracy: Option<T>,
54    /// AUC score
55    pub auc: Option<T>,
56    /// Uncertainty estimation quality
57    pub uncertainty_quality: T,
58}
59/// Meta-parameters for meta-learning
60#[derive(Debug, Clone)]
61pub struct MetaParameters<T: Float + Debug + Send + Sync + 'static> {
62    /// Parameter values
63    pub parameters: HashMap<String, Array1<T>>,
64    /// Parameter metadata
65    pub metadata: HashMap<String, String>,
66}
67/// MAML implementation over the shared linear task model
68/// ([`super::linear_model`]).
69///
70/// The inner loop descends the *support-set* loss of that model with analytic
71/// gradients; the outer loop applies FOMAML by default and the exact
72/// second-order MAML meta-gradient when `config.second_order` is set (exact
73/// because the model is linear in its parameters, so its MSE Hessian is
74/// constant and the Hessian-vector product is closed-form).
75pub struct MAMLLearner<T: Float + Debug + Send + Sync + 'static, D: Dimension> {
76    /// MAML configuration
77    pub(super) config: MAMLConfig<T>,
78    /// Task adaptation history (most recent last, bounded)
79    pub(super) adaptation_history: VecDeque<TaskAdaptationResult<T>>,
80    /// Number of meta-training steps performed
81    pub(super) meta_steps: usize,
82    /// Dimension marker retained for API compatibility
83    _phantom: std::marker::PhantomData<D>,
84}
85
86/// Maximum number of task adaptations retained for reporting.
87pub(super) const MAML_HISTORY_CAPACITY: usize = 1000;
88
89impl<
90        T: Float
91            + Default
92            + Clone
93            + Send
94            + Sync
95            + scirs2_core::ndarray::ScalarOperand
96            + std::fmt::Debug,
97        D: Dimension,
98    > MAMLLearner<T, D>
99{
100    pub fn new(config: MAMLConfig<T>) -> Result<Self> {
101        if config.inner_steps == 0 {
102            return Err(OptimError::InvalidConfig(
103                "MAML requires at least one inner step".to_string(),
104            ));
105        }
106        Ok(Self {
107            config,
108            adaptation_history: VecDeque::with_capacity(MAML_HISTORY_CAPACITY),
109            meta_steps: 0,
110            _phantom: std::marker::PhantomData,
111        })
112    }
113
114    /// Number of task adaptations recorded so far.
115    pub fn adaptations_recorded(&self) -> usize {
116        self.adaptation_history.len()
117    }
118}
119impl<T: Float + Debug + Send + Sync + 'static + Default + Clone + std::iter::Sum, D: Dimension>
120    MAMLLearner<T, D>
121{
122    /// Support-set loss of the shared linear model at `parameters`.
123    pub(super) fn compute_support_loss(
124        &self,
125        task: &MetaTask<T>,
126        parameters: &HashMap<String, Array1<T>>,
127    ) -> Result<T> {
128        super::linear_model::mse_loss(
129            &task.support_set.features,
130            &task.support_set.targets,
131            parameters,
132        )
133    }
134
135    /// Analytic gradient of the support-set loss at `parameters`.
136    pub(super) fn compute_support_gradients(
137        &self,
138        task: &MetaTask<T>,
139        parameters: &HashMap<String, Array1<T>>,
140    ) -> Result<HashMap<String, Array1<T>>> {
141        let mut grads = super::linear_model::mse_gradients(
142            &task.support_set.features,
143            &task.support_set.targets,
144            parameters,
145        )?;
146        if let Some(clip) = self.config.gradient_clip {
147            if let Some(max_norm) = scirs2_core::numeric::NumCast::from(clip) {
148                super::linear_model::clip_gradients(&mut grads, max_norm);
149            }
150        }
151        Ok(grads)
152    }
153
154    /// Analytic gradient of the query-set loss at `parameters`.
155    pub(super) fn compute_query_gradients(
156        &self,
157        task: &MetaTask<T>,
158        parameters: &HashMap<String, Array1<T>>,
159    ) -> Result<HashMap<String, Array1<T>>> {
160        super::linear_model::mse_gradients(
161            &task.query_set.features,
162            &task.query_set.targets,
163            parameters,
164        )
165    }
166}
167/// Memory selection criteria
168#[derive(Debug, Clone, Copy)]
169pub enum MemorySelectionCriteria {
170    Random,
171    GradientMagnitude,
172    LossBased,
173    Uncertainty,
174    Diversity,
175    TemporalProximity,
176}
177/// Task metadata
178#[derive(Debug, Clone)]
179pub struct TaskMetadata {
180    /// Task name
181    pub name: String,
182    /// Task description
183    pub description: String,
184    /// Task properties
185    pub properties: HashMap<String, String>,
186    /// Creation timestamp
187    pub created_at: Instant,
188    /// Task source
189    pub source: String,
190}
191/// Meta-training epoch
192#[derive(Debug, Clone)]
193pub struct MetaTrainingEpoch<T: Float + Debug + Send + Sync + 'static> {
194    pub epoch: usize,
195    pub training_result: MetaTrainingResult<T>,
196    pub validation_result: MetaValidationResult<T>,
197    pub meta_parameters: HashMap<String, Array1<T>>,
198}
199/// Task dataset
200#[derive(Debug, Clone)]
201pub struct TaskDataset<T: Float + Debug + Send + Sync + 'static> {
202    /// Input features
203    pub features: Vec<Array1<T>>,
204    /// Target values
205    pub targets: Vec<T>,
206    /// Sample weights
207    pub weights: Vec<T>,
208    /// Dataset metadata
209    pub metadata: DatasetMetadata,
210}
211/// MAML configuration
212#[derive(Debug, Clone)]
213pub struct MAMLConfig<T: Float + Debug + Send + Sync + 'static> {
214    /// Enable second-order gradients
215    pub second_order: bool,
216    /// Inner learning rate
217    pub inner_lr: T,
218    /// Outer learning rate
219    pub outer_lr: T,
220    /// Number of inner steps
221    pub inner_steps: usize,
222    /// Allow unused parameters
223    pub allow_unused: bool,
224    /// Gradient clipping
225    pub gradient_clip: Option<f64>,
226}
227/// Meta-training result
228#[derive(Debug, Clone)]
229pub struct MetaTrainingResult<T: Float + Debug + Send + Sync + 'static> {
230    /// Meta-loss
231    pub meta_loss: T,
232    /// Per-task losses
233    pub task_losses: Vec<T>,
234    /// Meta-gradients
235    pub meta_gradients: HashMap<String, Array1<T>>,
236    /// Training metrics
237    pub metrics: MetaTrainingMetrics<T>,
238    /// Adaptation statistics
239    pub adaptation_stats: AdaptationStatistics<T>,
240}
241/// Metric learning settings
242#[derive(Debug, Clone)]
243pub struct MetricLearningSettings {
244    /// Distance metric
245    pub distance_metric: DistanceMetric,
246    /// Embedding dimension
247    pub embedding_dim: usize,
248    /// Learned metric parameters
249    pub learned_metric: bool,
250}
251/// Multi-task learning result
252#[derive(Debug, Clone)]
253pub struct MultiTaskResult<T: Float + Debug + Send + Sync + 'static> {
254    pub task_results: Vec<TaskResult<T>>,
255    pub coordination_overhead: T,
256    pub convergence_status: String,
257}
258/// Memory replay settings
259#[derive(Debug, Clone)]
260pub struct MemoryReplaySettings {
261    /// Memory buffer size
262    pub buffer_size: usize,
263    /// Replay strategy
264    pub replay_strategy: ReplayStrategy,
265    /// Replay frequency
266    pub replay_frequency: usize,
267    /// Memory selection criteria
268    pub selection_criteria: MemorySelectionCriteria,
269}
270/// Task types
271#[derive(Debug, Clone, Copy)]
272pub enum TaskType {
273    Regression,
274    Classification,
275    Optimization,
276    ReinforcementLearning,
277    StructuredPrediction,
278    Generative,
279}
280/// Interference mitigation strategies
281#[derive(Debug, Clone, Copy)]
282pub enum InterferenceMitigationStrategy {
283    OrthogonalGradients,
284    TaskSpecificLayers,
285    AttentionMechanisms,
286    MetaGradients,
287}
288/// Replay strategies
289#[derive(Debug, Clone, Copy)]
290pub enum ReplayStrategy {
291    Random,
292    GradientBased,
293    UncertaintyBased,
294    DiversityBased,
295    Temporal,
296}
297/// Transfer learning settings
298#[derive(Debug, Clone)]
299pub struct TransferLearningSettings {
300    /// Enable domain adaptation
301    pub domain_adaptation: bool,
302    /// Source domain weights
303    pub source_domain_weights: Vec<f64>,
304    /// Transfer learning strategies
305    pub strategies: Vec<TransferStrategy>,
306    /// Domain similarity measures
307    pub similarity_measures: Vec<SimilarityMeasure>,
308    /// Enable progressive transfer
309    pub progressive_transfer: bool,
310}
311/// Validation result for meta-learning
312#[derive(Debug, Clone)]
313pub struct ValidationResult {
314    /// Whether validation passed
315    pub is_valid: bool,
316    /// Validation loss
317    pub validation_loss: f64,
318    /// Additional validation metrics
319    pub metrics: HashMap<String, f64>,
320}
321/// Transfer learning result
322#[derive(Debug, Clone)]
323pub struct TransferLearningResult<T: Float + Debug + Send + Sync + 'static> {
324    pub transfer_efficiency: T,
325    pub domain_adaptation_score: T,
326    pub source_task_retention: T,
327    pub target_task_performance: T,
328}
329/// Adaptation strategies
330#[derive(Debug, Clone, Copy)]
331pub enum AdaptationStrategy {
332    /// Fine-tuning all parameters
333    FullFineTuning,
334    /// Fine-tuning only specific layers
335    LayerWiseFineTuning,
336    /// Parameter-efficient adaptation
337    ParameterEfficient,
338    /// Adaptation via learned learning rates
339    LearnedLearningRates,
340    /// Gradient-based adaptation
341    GradientBased,
342    /// Memory-based adaptation
343    MemoryBased,
344    /// Attention-based adaptation
345    AttentionBased,
346    /// Modular adaptation
347    ModularAdaptation,
348}
349/// Meta-task representation
350#[derive(Debug, Clone)]
351pub struct MetaTask<T: Float + Debug + Send + Sync + 'static> {
352    /// Task identifier
353    pub id: String,
354    /// Support set (training data for adaptation)
355    pub support_set: TaskDataset<T>,
356    /// Query set (test data for evaluation)
357    pub query_set: TaskDataset<T>,
358    /// Task metadata
359    pub metadata: TaskMetadata,
360    /// Task difficulty
361    pub difficulty: T,
362    /// Task domain
363    pub domain: String,
364    /// Task type
365    pub task_type: TaskType,
366}
367/// Continual learning result
368#[derive(Debug, Clone)]
369pub struct ContinualLearningResult<T: Float + Debug + Send + Sync + 'static> {
370    pub sequence_results: Vec<TaskResult<T>>,
371    pub forgetting_measure: T,
372    pub adaptation_efficiency: T,
373}
374/// Anti-forgetting strategies
375#[derive(Debug, Clone, Copy)]
376pub enum AntiForgettingStrategy {
377    ElasticWeightConsolidation,
378    SynapticIntelligence,
379    MemoryReplay,
380    ProgressiveNetworks,
381    PackNet,
382    Piggyback,
383    HAT,
384}
385/// Training result for meta-learning
386#[derive(Debug, Clone)]
387pub struct TrainingResult {
388    /// Training loss
389    pub training_loss: f64,
390    /// Training metrics
391    pub metrics: HashMap<String, f64>,
392    /// Number of training steps
393    pub steps: usize,
394}
395/// Meta-training results
396#[derive(Debug, Clone)]
397pub struct MetaTrainingResults<T: Float + Debug + Send + Sync + 'static> {
398    pub final_parameters: HashMap<String, Array1<T>>,
399    pub training_history: Vec<MetaTrainingEpoch<T>>,
400    pub best_performance: T,
401    pub total_epochs: usize,
402}
403/// Dataset metadata
404#[derive(Debug, Clone)]
405pub struct DatasetMetadata {
406    /// Number of samples
407    pub num_samples: usize,
408    /// Feature dimension
409    pub feature_dim: usize,
410    /// Data distribution type
411    pub distribution_type: String,
412    /// Noise level
413    pub noise_level: f64,
414}
415/// Meta-learning statistics
416#[derive(Debug, Clone)]
417pub struct MetaLearningStatistics<T: Float + Debug + Send + Sync + 'static> {
418    pub algorithm: MetaLearningAlgorithm,
419    pub total_tasks_seen: usize,
420    pub adaptation_efficiency: T,
421    pub transfer_success_rate: T,
422    pub forgetting_measure: T,
423    pub multitask_interference: T,
424    pub few_shot_performance: T,
425}
426/// Task adaptation result
427#[derive(Debug, Clone)]
428pub struct TaskAdaptationResult<T: Float + Debug + Send + Sync + 'static> {
429    /// Adapted parameters
430    pub adapted_parameters: HashMap<String, Array1<T>>,
431    /// Adaptation trajectory
432    pub adaptation_trajectory: Vec<AdaptationStep<T>>,
433    /// Final adaptation loss
434    pub final_loss: T,
435    /// Adaptation metrics
436    pub metrics: TaskAdaptationMetrics<T>,
437}
438/// Transfer strategies
439#[derive(Debug, Clone, Copy)]
440pub enum TransferStrategy {
441    FeatureExtraction,
442    FineTuning,
443    DomainAdaptation,
444    MultiTask,
445    MetaTransfer,
446    Progressive,
447}
448/// Augmentation strategies
449#[derive(Debug, Clone, Copy)]
450pub enum AugmentationStrategy {
451    Geometric,
452    Color,
453    Noise,
454    Mixup,
455    CutMix,
456    Learned,
457}
458/// Stability metrics
459#[derive(Debug, Clone)]
460pub struct StabilityMetrics<T: Float + Debug + Send + Sync + 'static> {
461    /// Parameter stability
462    pub parameter_stability: T,
463    /// Performance stability
464    pub performance_stability: T,
465    /// Gradient stability
466    pub gradient_stability: T,
467    /// Catastrophic forgetting measure
468    pub forgetting_measure: T,
469}
470/// Task result for meta-learning
471#[derive(Debug, Clone)]
472pub struct TaskResult<T: Float + Debug + Send + Sync + 'static> {
473    pub task_id: String,
474    pub loss: T,
475    pub metrics: HashMap<String, T>,
476}
477/// Meta-learning algorithms
478#[derive(Debug, Clone, Copy)]
479pub enum MetaLearningAlgorithm {
480    /// Model-Agnostic Meta-Learning
481    MAML,
482    /// First-Order MAML (FOMAML)
483    FOMAML,
484    /// Reptile algorithm
485    Reptile,
486    /// Meta-SGD
487    MetaSGD,
488    /// Learning to Learn by Gradient Descent
489    L2L,
490    /// Gradient-Based Meta-Learning
491    GBML,
492    /// Meta-Learning with Implicit Gradients
493    IMaml,
494    /// Prototypical Networks
495    ProtoNet,
496    /// Matching Networks
497    MatchingNet,
498    /// Relation Networks
499    RelationNet,
500    /// Memory-Augmented Neural Networks
501    MANN,
502    /// Meta-Learning with Warped Gradient Descent
503    WarpGrad,
504    /// Learned Gradient Descent
505    LearnedGD,
506}
507/// Gradient balancing methods
508#[derive(Debug, Clone, Copy)]
509pub enum GradientBalancingMethod {
510    Uniform,
511    GradNorm,
512    PCGrad,
513    CAGrad,
514    NashMTL,
515}
516/// Query evaluation result
517#[derive(Debug, Clone)]
518pub struct QueryEvaluationResult<T: Float + Debug + Send + Sync + 'static> {
519    /// Query set loss
520    pub query_loss: T,
521    /// Prediction accuracy
522    pub accuracy: T,
523    /// Per-sample predictions
524    pub predictions: Vec<T>,
525    /// Confidence scores
526    pub confidence_scores: Vec<T>,
527    /// Evaluation metrics
528    pub metrics: QueryEvaluationMetrics<T>,
529}
530/// Few-shot learning algorithms
531#[derive(Debug, Clone, Copy)]
532pub enum FewShotAlgorithm {
533    Prototypical,
534    Matching,
535    Relation,
536    MAML,
537    Reptile,
538    MetaOptNet,
539}
540/// Activation functions
541#[derive(Debug, Clone, Copy)]
542pub enum ActivationFunction {
543    ReLU,
544    Sigmoid,
545    Tanh,
546    Softmax,
547    GELU,
548}
549/// Adaptation statistics
550#[derive(Debug, Clone)]
551pub struct AdaptationStatistics<T: Float + Debug + Send + Sync + 'static> {
552    /// Convergence steps per task
553    pub convergence_steps: Vec<usize>,
554    /// Final losses per task
555    pub final_losses: Vec<T>,
556    /// Adaptation efficiency
557    pub adaptation_efficiency: T,
558    /// Stability metrics
559    pub stability_metrics: StabilityMetrics<T>,
560}
561/// Meta-validation result
562#[derive(Debug, Clone)]
563pub struct MetaValidationResult<T: Float + Debug + Send + Sync + 'static> {
564    pub performance: T,
565    pub adaptation_speed: T,
566    pub generalization_gap: T,
567    pub task_specific_metrics: HashMap<String, T>,
568}
569/// Continual learning settings
570#[derive(Debug, Clone)]
571pub struct ContinualLearningSettings {
572    /// Catastrophic forgetting mitigation
573    pub anti_forgetting_strategies: Vec<AntiForgettingStrategy>,
574    /// Memory replay settings
575    pub memory_replay: MemoryReplaySettings,
576    /// Task identification method
577    pub task_identification: TaskIdentificationMethod,
578    /// Plasticity-stability trade-off
579    pub plasticity_stability_balance: f64,
580}
581/// Task weighting strategies
582#[derive(Debug, Clone, Copy)]
583pub enum TaskWeightingStrategy {
584    Uniform,
585    UncertaintyBased,
586    GradientMagnitude,
587    PerformanceBased,
588    Adaptive,
589    Learned,
590}
591/// Multi-task settings
592#[derive(Debug, Clone)]
593pub struct MultiTaskSettings {
594    /// Task weighting strategy
595    pub task_weighting: TaskWeightingStrategy,
596    /// Gradient balancing method
597    pub gradient_balancing: GradientBalancingMethod,
598    /// Task interference mitigation
599    pub interference_mitigation: InterferenceMitigationStrategy,
600    /// Shared representation learning
601    pub shared_representation: SharedRepresentationStrategy,
602}
603/// Shared representation strategies
604#[derive(Debug, Clone, Copy)]
605pub enum SharedRepresentationStrategy {
606    HardSharing,
607    SoftSharing,
608    HierarchicalSharing,
609    AttentionBased,
610    Modular,
611}
612/// Distance metrics
613#[derive(Debug, Clone, Copy)]
614pub enum DistanceMetric {
615    Euclidean,
616    Cosine,
617    Mahalanobis,
618    Learned,
619}
620/// Task adaptation metrics
621#[derive(Debug, Clone)]
622pub struct TaskAdaptationMetrics<T: Float + Debug + Send + Sync + 'static> {
623    /// Convergence speed
624    pub convergence_speed: T,
625    /// Final performance
626    pub final_performance: T,
627    /// Adaptation efficiency
628    pub efficiency: T,
629    /// Robustness to noise
630    pub robustness: T,
631}
632/// Few-shot learning settings
633#[derive(Debug, Clone)]
634pub struct FewShotSettings {
635    /// Number of shots (examples per class)
636    pub num_shots: usize,
637    /// Number of ways (classes)
638    pub num_ways: usize,
639    /// Few-shot algorithm
640    pub algorithm: FewShotAlgorithm,
641    /// Metric learning settings
642    pub metric_learning: MetricLearningSettings,
643    /// Augmentation strategies
644    pub augmentation_strategies: Vec<AugmentationStrategy>,
645}
646/// Domain similarity measures
647#[derive(Debug, Clone, Copy)]
648pub enum SimilarityMeasure {
649    CosineDistance,
650    KLDivergence,
651    WassersteinDistance,
652    CentralMomentDiscrepancy,
653    MaximumMeanDiscrepancy,
654}
655/// Meta-learning configuration
656#[derive(Debug, Clone)]
657pub struct MetaLearningConfig {
658    /// Meta-learning algorithm
659    pub algorithm: MetaLearningAlgorithm,
660    /// Number of inner loop steps
661    pub inner_steps: usize,
662    /// Number of outer loop steps
663    pub outer_steps: usize,
664    /// Meta-learning rate
665    pub meta_learning_rate: f64,
666    /// Inner learning rate
667    pub inner_learning_rate: f64,
668    /// Task batch size
669    pub task_batch_size: usize,
670    /// Support set size per task
671    pub support_set_size: usize,
672    /// Query set size per task
673    pub query_set_size: usize,
674    /// Enable second-order gradients
675    pub second_order: bool,
676    /// Gradient clipping threshold
677    pub gradient_clip: f64,
678    /// Adaptation strategies
679    pub adaptation_strategies: Vec<AdaptationStrategy>,
680    /// Transfer learning settings
681    pub transfer_settings: TransferLearningSettings,
682    /// Continual learning settings
683    pub continual_settings: ContinualLearningSettings,
684    /// Multi-task settings
685    pub multitask_settings: MultiTaskSettings,
686    /// Few-shot learning settings
687    pub few_shot_settings: FewShotSettings,
688    /// Enable meta-regularization
689    pub enable_meta_regularization: bool,
690    /// Meta-regularization strength
691    pub meta_regularization_strength: f64,
692    /// Task sampling strategy
693    pub task_sampling_strategy: TaskSamplingStrategy,
694}
695/// Task sampling strategies
696#[derive(Debug, Clone, Copy)]
697pub enum TaskSamplingStrategy {
698    Uniform,
699    Curriculum,
700    DifficultyBased,
701    DiversityBased,
702    ActiveLearning,
703    Adversarial,
704}
705/// Few-shot learning result
706#[derive(Debug, Clone)]
707pub struct FewShotResult<T: Float + Debug + Send + Sync + 'static> {
708    pub accuracy: T,
709    pub confidence: T,
710    pub adaptation_steps: usize,
711    pub uncertainty_estimates: Vec<T>,
712}
713
714impl Default for MetaLearningConfig {
715    /// A small, valid configuration: first-order MAML over the shared linear
716    /// task model with uniform task sampling.
717    fn default() -> Self {
718        Self {
719            algorithm: MetaLearningAlgorithm::MAML,
720            inner_steps: 5,
721            outer_steps: 100,
722            meta_learning_rate: 0.3,
723            inner_learning_rate: 0.4,
724            task_batch_size: 8,
725            support_set_size: 6,
726            query_set_size: 6,
727            second_order: false,
728            gradient_clip: 10.0,
729            adaptation_strategies: vec![AdaptationStrategy::FullFineTuning],
730            transfer_settings: TransferLearningSettings {
731                domain_adaptation: true,
732                source_domain_weights: vec![1.0],
733                strategies: vec![TransferStrategy::FineTuning],
734                similarity_measures: vec![SimilarityMeasure::CosineDistance],
735                progressive_transfer: false,
736            },
737            continual_settings: ContinualLearningSettings {
738                anti_forgetting_strategies: vec![
739                    AntiForgettingStrategy::ElasticWeightConsolidation,
740                ],
741                memory_replay: MemoryReplaySettings {
742                    buffer_size: 256,
743                    replay_strategy: ReplayStrategy::Random,
744                    replay_frequency: 8,
745                    selection_criteria: MemorySelectionCriteria::Random,
746                },
747                task_identification: TaskIdentificationMethod::Oracle,
748                plasticity_stability_balance: 0.5,
749            },
750            multitask_settings: MultiTaskSettings {
751                task_weighting: TaskWeightingStrategy::Uniform,
752                gradient_balancing: GradientBalancingMethod::Uniform,
753                interference_mitigation: InterferenceMitigationStrategy::OrthogonalGradients,
754                shared_representation: SharedRepresentationStrategy::HardSharing,
755            },
756            few_shot_settings: FewShotSettings {
757                num_shots: 5,
758                num_ways: 2,
759                algorithm: FewShotAlgorithm::MAML,
760                metric_learning: MetricLearningSettings {
761                    distance_metric: DistanceMetric::Euclidean,
762                    embedding_dim: 16,
763                    learned_metric: false,
764                },
765                augmentation_strategies: Vec::new(),
766            },
767            enable_meta_regularization: false,
768            meta_regularization_strength: 0.0,
769            task_sampling_strategy: TaskSamplingStrategy::Uniform,
770        }
771    }
772}
773
774impl MetaLearningConfig {
775    /// Reject configurations that cannot produce a meaningful meta-training run.
776    pub fn validate(&self) -> Result<()> {
777        if self.inner_steps == 0 {
778            return Err(OptimError::InvalidConfig(
779                "inner_steps must be greater than zero".to_string(),
780            ));
781        }
782        if self.task_batch_size == 0 {
783            return Err(OptimError::InvalidConfig(
784                "task_batch_size must be greater than zero".to_string(),
785            ));
786        }
787        if !(self.meta_learning_rate.is_finite() && self.meta_learning_rate > 0.0) {
788            return Err(OptimError::InvalidConfig(
789                "meta_learning_rate must be finite and positive".to_string(),
790            ));
791        }
792        if !(self.inner_learning_rate.is_finite() && self.inner_learning_rate > 0.0) {
793            return Err(OptimError::InvalidConfig(
794                "inner_learning_rate must be finite and positive".to_string(),
795            ));
796        }
797        if !(self.gradient_clip.is_finite() && self.gradient_clip > 0.0) {
798            return Err(OptimError::InvalidConfig(
799                "gradient_clip must be finite and positive".to_string(),
800            ));
801        }
802        if !(0.0..=1.0).contains(&self.continual_settings.plasticity_stability_balance) {
803            return Err(OptimError::InvalidConfig(
804                "plasticity_stability_balance must lie in [0, 1]".to_string(),
805            ));
806        }
807        Ok(())
808    }
809}
optirs_learned/meta_learning/types.rs

optirs_learned/meta_learning/
types.rs
