quantrs2_anneal/meta_learning/
config.rs

1//! Configuration types for Meta-Learning Optimization
2//!
3//! This module contains all configuration structures and enums used throughout
4//! the meta-learning optimization system.
5
6use std::collections::HashMap;
7use std::time::Duration;
8
9/// Meta-learning optimization engine configuration
10#[derive(Debug, Clone)]
11pub struct MetaLearningConfig {
12    /// Enable transfer learning
13    pub enable_transfer_learning: bool,
14    /// Enable few-shot learning
15    pub enable_few_shot_learning: bool,
16    /// Experience buffer size
17    pub experience_buffer_size: usize,
18    /// Learning rate for meta-updates
19    pub meta_learning_rate: f64,
20    /// Number of inner optimization steps
21    pub inner_steps: usize,
22    /// Feature extraction configuration
23    pub feature_config: FeatureExtractionConfig,
24    /// Neural architecture search settings
25    pub nas_config: NeuralArchitectureSearchConfig,
26    /// Portfolio management settings
27    pub portfolio_config: PortfolioManagementConfig,
28    /// Multi-objective optimization settings
29    pub multi_objective_config: MultiObjectiveConfig,
30}
31
32impl Default for MetaLearningConfig {
33    fn default() -> Self {
34        Self {
35            enable_transfer_learning: true,
36            enable_few_shot_learning: true,
37            experience_buffer_size: 10_000,
38            meta_learning_rate: 0.001,
39            inner_steps: 5,
40            feature_config: FeatureExtractionConfig::default(),
41            nas_config: NeuralArchitectureSearchConfig::default(),
42            portfolio_config: PortfolioManagementConfig::default(),
43            multi_objective_config: MultiObjectiveConfig::default(),
44        }
45    }
46}
47
48/// Feature extraction configuration
49#[derive(Debug, Clone)]
50pub struct FeatureExtractionConfig {
51    /// Enable graph-based features
52    pub enable_graph_features: bool,
53    /// Enable statistical features
54    pub enable_statistical_features: bool,
55    /// Enable spectral features
56    pub enable_spectral_features: bool,
57    /// Enable domain-specific features
58    pub enable_domain_features: bool,
59    /// Feature selection method
60    pub selection_method: FeatureSelectionMethod,
61    /// Dimensionality reduction method
62    pub reduction_method: DimensionalityReduction,
63    /// Feature normalization
64    pub normalization: FeatureNormalization,
65}
66
67impl Default for FeatureExtractionConfig {
68    fn default() -> Self {
69        Self {
70            enable_graph_features: true,
71            enable_statistical_features: true,
72            enable_spectral_features: true,
73            enable_domain_features: true,
74            selection_method: FeatureSelectionMethod::AutomaticRelevance,
75            reduction_method: DimensionalityReduction::PCA,
76            normalization: FeatureNormalization::StandardScaling,
77        }
78    }
79}
80
81/// Feature selection methods
82#[derive(Debug, Clone, PartialEq, Eq)]
83pub enum FeatureSelectionMethod {
84    /// Automatic relevance determination
85    AutomaticRelevance,
86    /// Mutual information
87    MutualInformation,
88    /// Recursive feature elimination
89    RecursiveElimination,
90    /// LASSO regularization
91    LASSO,
92    /// Random forest importance
93    RandomForestImportance,
94}
95
96/// Dimensionality reduction methods
97#[derive(Debug, Clone, PartialEq, Eq)]
98pub enum DimensionalityReduction {
99    /// Principal Component Analysis
100    PCA,
101    /// Independent Component Analysis
102    ICA,
103    /// t-Distributed Stochastic Neighbor Embedding
104    tSNE,
105    /// Uniform Manifold Approximation and Projection
106    UMAP,
107    /// Linear Discriminant Analysis
108    LDA,
109    /// No reduction
110    None,
111}
112
113/// Feature normalization methods
114#[derive(Debug, Clone, PartialEq, Eq)]
115pub enum FeatureNormalization {
116    /// Standard scaling (z-score)
117    StandardScaling,
118    /// Min-max scaling
119    MinMaxScaling,
120    /// Robust scaling
121    RobustScaling,
122    /// Unit vector scaling
123    UnitVector,
124    /// No normalization
125    None,
126}
127
128/// Neural Architecture Search configuration
129#[derive(Debug, Clone)]
130pub struct NeuralArchitectureSearchConfig {
131    /// Enable NAS
132    pub enable_nas: bool,
133    /// Search space definition
134    pub search_space: SearchSpace,
135    /// Search strategy
136    pub search_strategy: SearchStrategy,
137    /// Maximum search iterations
138    pub max_iterations: usize,
139    /// Early stopping criteria
140    pub early_stopping: EarlyStoppingCriteria,
141    /// Resource constraints
142    pub resource_constraints: ResourceConstraints,
143}
144
145impl Default for NeuralArchitectureSearchConfig {
146    fn default() -> Self {
147        Self {
148            enable_nas: true,
149            search_space: SearchSpace::default(),
150            search_strategy: SearchStrategy::DifferentiableNAS,
151            max_iterations: 100,
152            early_stopping: EarlyStoppingCriteria::default(),
153            resource_constraints: ResourceConstraints::default(),
154        }
155    }
156}
157
158/// Neural architecture search space
159#[derive(Debug, Clone)]
160pub struct SearchSpace {
161    /// Layer types to consider
162    pub layer_types: Vec<LayerType>,
163    /// Number of layers range
164    pub num_layers_range: (usize, usize),
165    /// Hidden dimension options
166    pub hidden_dims: Vec<usize>,
167    /// Activation functions
168    pub activations: Vec<ActivationFunction>,
169    /// Dropout rates
170    pub dropout_rates: Vec<f64>,
171    /// Skip connection options
172    pub skip_connections: bool,
173}
174
175impl Default for SearchSpace {
176    fn default() -> Self {
177        Self {
178            layer_types: vec![
179                LayerType::Dense,
180                LayerType::LSTM,
181                LayerType::GRU,
182                LayerType::Attention,
183                LayerType::Convolution1D,
184            ],
185            num_layers_range: (2, 8),
186            hidden_dims: vec![64, 128, 256, 512],
187            activations: vec![
188                ActivationFunction::ReLU,
189                ActivationFunction::Tanh,
190                ActivationFunction::Swish,
191                ActivationFunction::GELU,
192            ],
193            dropout_rates: vec![0.0, 0.1, 0.2, 0.3],
194            skip_connections: true,
195        }
196    }
197}
198
199/// Neural network layer types
200#[derive(Debug, Clone, PartialEq, Eq)]
201pub enum LayerType {
202    /// Dense/Linear layer
203    Dense,
204    /// LSTM layer
205    LSTM,
206    /// GRU layer
207    GRU,
208    /// Attention layer
209    Attention,
210    /// 1D Convolution layer
211    Convolution1D,
212    /// Normalization layer
213    Normalization,
214    /// Residual block
215    ResidualBlock,
216}
217
218/// Activation functions
219#[derive(Debug, Clone, PartialEq)]
220pub enum ActivationFunction {
221    ReLU,
222    Tanh,
223    Sigmoid,
224    Swish,
225    GELU,
226    LeakyReLU(f64),
227    ELU(f64),
228}
229
230/// Search strategies for NAS
231#[derive(Debug, Clone, PartialEq, Eq)]
232pub enum SearchStrategy {
233    /// Differentiable NAS
234    DifferentiableNAS,
235    /// Evolutionary search
236    EvolutionarySearch,
237    /// Reinforcement learning
238    ReinforcementLearning,
239    /// Bayesian optimization
240    BayesianOptimization,
241    /// Random search
242    RandomSearch,
243    /// Progressive search
244    ProgressiveSearch,
245}
246
247/// Early stopping criteria
248#[derive(Debug, Clone)]
249pub struct EarlyStoppingCriteria {
250    /// Patience (iterations without improvement)
251    pub patience: usize,
252    /// Minimum improvement threshold
253    pub min_improvement: f64,
254    /// Maximum runtime
255    pub max_runtime: Duration,
256    /// Target performance threshold
257    pub target_performance: Option<f64>,
258}
259
260impl Default for EarlyStoppingCriteria {
261    fn default() -> Self {
262        Self {
263            patience: 10,
264            min_improvement: 0.001,
265            max_runtime: Duration::from_secs(2 * 3600),
266            target_performance: None,
267        }
268    }
269}
270
271/// Resource constraints for NAS
272#[derive(Debug, Clone)]
273pub struct ResourceConstraints {
274    /// Maximum memory usage (MB)
275    pub max_memory: usize,
276    /// Maximum training time per architecture
277    pub max_training_time: Duration,
278    /// Maximum model parameters
279    pub max_parameters: usize,
280    /// Maximum FLOPs
281    pub max_flops: usize,
282}
283
284impl Default for ResourceConstraints {
285    fn default() -> Self {
286        Self {
287            max_memory: 2048,
288            max_training_time: Duration::from_secs(10 * 60),
289            max_parameters: 1_000_000,
290            max_flops: 1_000_000_000,
291        }
292    }
293}
294
295/// Portfolio management configuration
296#[derive(Debug, Clone)]
297pub struct PortfolioManagementConfig {
298    /// Enable dynamic portfolio
299    pub enable_dynamic_portfolio: bool,
300    /// Maximum portfolio size
301    pub max_portfolio_size: usize,
302    /// Algorithm selection strategy
303    pub selection_strategy: AlgorithmSelectionStrategy,
304    /// Performance evaluation window
305    pub evaluation_window: Duration,
306    /// Diversity criteria
307    pub diversity_criteria: DiversityCriteria,
308}
309
310impl Default for PortfolioManagementConfig {
311    fn default() -> Self {
312        Self {
313            enable_dynamic_portfolio: true,
314            max_portfolio_size: 10,
315            selection_strategy: AlgorithmSelectionStrategy::MultiArmedBandit,
316            evaluation_window: Duration::from_secs(24 * 3600),
317            diversity_criteria: DiversityCriteria::default(),
318        }
319    }
320}
321
322/// Algorithm selection strategies
323#[derive(Debug, Clone, PartialEq)]
324pub enum AlgorithmSelectionStrategy {
325    /// Multi-armed bandit
326    MultiArmedBandit,
327    /// Upper confidence bound
328    UpperConfidenceBound,
329    /// Thompson sampling
330    ThompsonSampling,
331    /// ε-greedy
332    EpsilonGreedy(f64),
333    /// Collaborative filtering
334    CollaborativeFiltering,
335    /// Meta-learning based
336    MetaLearningBased,
337}
338
339/// Diversity criteria for portfolio
340#[derive(Debug, Clone)]
341pub struct DiversityCriteria {
342    /// Minimum performance diversity
343    pub min_performance_diversity: f64,
344    /// Minimum algorithmic diversity
345    pub min_algorithmic_diversity: f64,
346    /// Diversity measurement method
347    pub diversity_method: DiversityMethod,
348}
349
350impl Default for DiversityCriteria {
351    fn default() -> Self {
352        Self {
353            min_performance_diversity: 0.1,
354            min_algorithmic_diversity: 0.2,
355            diversity_method: DiversityMethod::KullbackLeibler,
356        }
357    }
358}
359
360/// Diversity measurement methods
361#[derive(Debug, Clone, PartialEq, Eq)]
362pub enum DiversityMethod {
363    /// Kullback-Leibler divergence
364    KullbackLeibler,
365    /// Jensen-Shannon divergence
366    JensenShannon,
367    /// Cosine distance
368    CosineDistance,
369    /// Euclidean distance
370    EuclideanDistance,
371    /// Hamming distance
372    HammingDistance,
373}
374
375/// Multi-objective optimization configuration
376#[derive(Debug, Clone)]
377pub struct MultiObjectiveConfig {
378    /// Enable multi-objective optimization
379    pub enable_multi_objective: bool,
380    /// Objectives to optimize
381    pub objectives: Vec<OptimizationObjective>,
382    /// Pareto frontier management
383    pub pareto_config: ParetoFrontierConfig,
384    /// Scalarization method
385    pub scalarization: ScalarizationMethod,
386    /// Constraint handling
387    pub constraint_handling: ConstraintHandling,
388}
389
390impl Default for MultiObjectiveConfig {
391    fn default() -> Self {
392        Self {
393            enable_multi_objective: true,
394            objectives: vec![
395                OptimizationObjective::SolutionQuality,
396                OptimizationObjective::Runtime,
397                OptimizationObjective::ResourceUsage,
398            ],
399            pareto_config: ParetoFrontierConfig::default(),
400            scalarization: ScalarizationMethod::WeightedSum,
401            constraint_handling: ConstraintHandling::PenaltyMethod,
402        }
403    }
404}
405
406/// Optimization objectives
407#[derive(Debug, Clone, PartialEq, Eq)]
408pub enum OptimizationObjective {
409    /// Solution quality
410    SolutionQuality,
411    /// Runtime performance
412    Runtime,
413    /// Resource usage
414    ResourceUsage,
415    /// Energy consumption
416    EnergyConsumption,
417    /// Robustness
418    Robustness,
419    /// Scalability
420    Scalability,
421    /// Custom objective
422    Custom(String),
423}
424
425/// Pareto frontier configuration
426#[derive(Debug, Clone)]
427pub struct ParetoFrontierConfig {
428    /// Maximum frontier size
429    pub max_frontier_size: usize,
430    /// Dominance tolerance
431    pub dominance_tolerance: f64,
432    /// Frontier update strategy
433    pub update_strategy: FrontierUpdateStrategy,
434    /// Crowding distance weight
435    pub crowding_weight: f64,
436}
437
438impl Default for ParetoFrontierConfig {
439    fn default() -> Self {
440        Self {
441            max_frontier_size: 100,
442            dominance_tolerance: 1e-6,
443            update_strategy: FrontierUpdateStrategy::NonDominatedSort,
444            crowding_weight: 0.5,
445        }
446    }
447}
448
449/// Frontier update strategies
450#[derive(Debug, Clone, PartialEq, Eq)]
451pub enum FrontierUpdateStrategy {
452    /// Non-dominated sorting
453    NonDominatedSort,
454    /// ε-dominance
455    EpsilonDominance,
456    /// Hypervolume-based
457    HypervolumeBased,
458    /// Reference point-based
459    ReferencePointBased,
460}
461
462/// Scalarization methods
463#[derive(Debug, Clone, PartialEq, Eq)]
464pub enum ScalarizationMethod {
465    /// Weighted sum
466    WeightedSum,
467    /// Weighted Tchebycheff
468    WeightedTchebycheff,
469    /// Achievement scalarizing function
470    AchievementScalarizing,
471    /// Penalty-based boundary intersection
472    PenaltyBoundaryIntersection,
473    /// Reference point method
474    ReferencePoint,
475}
476
477/// Constraint handling methods
478#[derive(Debug, Clone, PartialEq, Eq)]
479pub enum ConstraintHandling {
480    /// Penalty method
481    PenaltyMethod,
482    /// Barrier method
483    BarrierMethod,
484    /// Lagrangian method
485    LagrangianMethod,
486    /// Feasibility rules
487    FeasibilityRules,
488    /// Multi-objective constraint handling
489    MultiObjectiveConstraint,
490}
491
492/// Algorithm types
493#[derive(Debug, Clone, PartialEq)]
494pub enum AlgorithmType {
495    /// Simulated annealing
496    SimulatedAnnealing,
497    /// Quantum annealing
498    QuantumAnnealing,
499    /// Tabu search
500    TabuSearch,
501    /// Genetic algorithm
502    GeneticAlgorithm,
503    /// Particle swarm optimization
504    ParticleSwarm,
505    /// Ant colony optimization
506    AntColony,
507    /// Variable neighborhood search
508    VariableNeighborhood,
509    /// Hybrid algorithm
510    Hybrid(Vec<Self>),
511}
512
513/// Architecture specification
514#[derive(Debug, Clone)]
515pub struct ArchitectureSpec {
516    /// Layer specifications
517    pub layers: Vec<LayerSpec>,
518    /// Connection pattern
519    pub connections: ConnectionPattern,
520    /// Optimization settings
521    pub optimization: OptimizationSettings,
522}
523
524/// Layer specification
525#[derive(Debug, Clone)]
526pub struct LayerSpec {
527    /// Layer type
528    pub layer_type: LayerType,
529    /// Input dimension
530    pub input_dim: usize,
531    /// Output dimension
532    pub output_dim: usize,
533    /// Activation function
534    pub activation: ActivationFunction,
535    /// Dropout rate
536    pub dropout: f64,
537    /// Additional parameters
538    pub parameters: HashMap<String, f64>,
539}
540
541/// Connection patterns
542#[derive(Debug, Clone, PartialEq, Eq)]
543pub enum ConnectionPattern {
544    /// Sequential connections
545    Sequential,
546    /// Skip connections
547    SkipConnections,
548    /// Dense connections
549    DenseConnections,
550    /// Residual connections
551    ResidualConnections,
552    /// Custom pattern
553    Custom(Vec<(usize, usize)>),
554}
555
556/// Optimization settings
557#[derive(Debug, Clone)]
558pub struct OptimizationSettings {
559    /// Optimizer type
560    pub optimizer: OptimizerType,
561    /// Learning rate
562    pub learning_rate: f64,
563    /// Batch size
564    pub batch_size: usize,
565    /// Number of epochs
566    pub epochs: usize,
567    /// Regularization
568    pub regularization: RegularizationConfig,
569}
570
571/// Optimizer types
572#[derive(Debug, Clone, PartialEq, Eq)]
573pub enum OptimizerType {
574    SGD,
575    Adam,
576    AdamW,
577    RMSprop,
578    Adagrad,
579    Adadelta,
580    LBFGS,
581}
582
583/// Regularization configuration
584#[derive(Debug, Clone)]
585pub struct RegularizationConfig {
586    /// L1 regularization weight
587    pub l1_weight: f64,
588    /// L2 regularization weight
589    pub l2_weight: f64,
590    /// Dropout rate
591    pub dropout: f64,
592    /// Batch normalization
593    pub batch_norm: bool,
594    /// Early stopping
595    pub early_stopping: bool,
596}
597
598/// Optimization configuration
599#[derive(Debug, Clone)]
600pub struct OptimizationConfiguration {
601    /// Algorithm used
602    pub algorithm: AlgorithmType,
603    /// Hyperparameters
604    pub hyperparameters: HashMap<String, f64>,
605    /// Architecture specification
606    pub architecture: Option<ArchitectureSpec>,
607    /// Resource allocation
608    pub resources: ResourceAllocation,
609}
610
611/// Resource allocation
612#[derive(Debug, Clone)]
613pub struct ResourceAllocation {
614    /// CPU allocation
615    pub cpu: f64,
616    /// Memory allocation (MB)
617    pub memory: usize,
618    /// GPU allocation
619    pub gpu: f64,
620    /// Time allocation
621    pub time: Duration,
622}
623
624/// Problem domains
625#[derive(Debug, Clone, PartialEq, Eq, Hash)]
626pub enum ProblemDomain {
627    /// Combinatorial optimization
628    Combinatorial,
629    /// Portfolio optimization
630    Portfolio,
631    /// Scheduling
632    Scheduling,
633    /// Graph problems
634    Graph,
635    /// Machine learning
636    MachineLearning,
637    /// Physics simulation
638    Physics,
639    /// Chemistry
640    Chemistry,
641    /// Custom domain
642    Custom(String),
643}
quantrs2_anneal/meta_learning/config.rs

quantrs2_anneal/meta_learning/
config.rs
