quantrs2_device/adaptive_compilation/
ml_integration.rs

1//! Machine Learning Integration and Optimization Configuration
2
3use std::collections::HashMap;
4use std::time::Duration;
5
6/// Machine learning optimization configuration
7#[derive(Debug, Clone)]
8pub struct MLOptimizationConfig {
9    /// Enable ML-driven optimization
10    pub enable_ml_optimization: bool,
11    /// ML models to use
12    pub ml_models: Vec<MLModelType>,
13    /// Training configuration
14    pub training_config: MLTrainingConfig,
15    /// Feature engineering settings
16    pub feature_engineering: FeatureEngineeringConfig,
17    /// Online learning settings
18    pub online_learning: OnlineLearningConfig,
19    /// Transfer learning settings
20    pub transfer_learning: TransferLearningConfig,
21}
22
23/// Types of ML models
24#[derive(Debug, Clone, PartialEq, Eq)]
25pub enum MLModelType {
26    NeuralNetwork,
27    RandomForest,
28    SupportVectorMachine,
29    GradientBoosting,
30    BayesianOptimization,
31    ReinforcementLearning,
32    GaussianProcess,
33    EnsembleModel,
34}
35
36/// ML training configuration
37#[derive(Debug, Clone, Default)]
38pub struct MLTrainingConfig {
39    /// Training data requirements
40    pub training_data: TrainingDataConfig,
41    /// Model hyperparameters
42    pub hyperparameters: ModelHyperparameters,
43    /// Training optimization
44    pub optimization: TrainingOptimizationConfig,
45    /// Regularization settings
46    pub regularization: RegularizationConfig,
47    /// Early stopping configuration
48    pub early_stopping: EarlyStoppingConfig,
49    /// Cross-validation settings
50    pub cross_validation: CrossValidationConfig,
51}
52
53/// Training data configuration
54#[derive(Debug, Clone)]
55pub struct TrainingDataConfig {
56    /// Minimum training samples
57    pub min_training_samples: usize,
58    /// Data collection strategy
59    pub data_collection_strategy: DataCollectionStrategy,
60    /// Data preprocessing settings
61    pub preprocessing: DataPreprocessingConfig,
62    /// Data augmentation settings
63    pub augmentation: DataAugmentationConfig,
64}
65
66/// Data collection strategies
67#[derive(Debug, Clone, PartialEq, Eq)]
68pub enum DataCollectionStrategy {
69    Passive,
70    Active,
71    Adaptive,
72    Balanced,
73    Targeted,
74}
75
76/// Data preprocessing configuration
77#[derive(Debug, Clone)]
78pub struct DataPreprocessingConfig {
79    /// Normalization method
80    pub normalization: NormalizationMethod,
81    /// Outlier handling
82    pub outlier_handling: OutlierHandling,
83    /// Missing value strategy
84    pub missing_value_strategy: MissingValueStrategy,
85    /// Data validation rules
86    pub validation_rules: Vec<DataValidationRule>,
87}
88
89/// Normalization methods
90#[derive(Debug, Clone, PartialEq, Eq)]
91pub enum NormalizationMethod {
92    MinMax,
93    ZScore,
94    Robust,
95    Quantile,
96    None,
97}
98
99/// Outlier handling strategies
100#[derive(Debug, Clone, PartialEq, Eq)]
101pub enum OutlierHandling {
102    Remove,
103    Cap,
104    Transform,
105    Ignore,
106}
107
108/// Missing value handling strategies
109#[derive(Debug, Clone, PartialEq, Eq)]
110pub enum MissingValueStrategy {
111    Remove,
112    Impute,
113    Interpolate,
114    Forward,
115    Backward,
116}
117
118/// Data validation rules
119#[derive(Debug, Clone)]
120pub struct DataValidationRule {
121    /// Rule name
122    pub name: String,
123    /// Rule condition
124    pub condition: ValidationCondition,
125    /// Action on failure
126    pub failure_action: ValidationFailureAction,
127}
128
129/// Validation conditions
130#[derive(Debug, Clone, PartialEq)]
131pub enum ValidationCondition {
132    RangeCheck(f64, f64),
133    NotNull,
134    UniqueValues,
135    Custom(String),
136}
137
138/// Actions to take on validation failure
139#[derive(Debug, Clone, PartialEq, Eq)]
140pub enum ValidationFailureAction {
141    Reject,
142    Warn,
143    Transform,
144    Ignore,
145}
146
147/// Data augmentation configuration
148#[derive(Debug, Clone)]
149pub struct DataAugmentationConfig {
150    /// Enable data augmentation
151    pub enable_augmentation: bool,
152    /// Augmentation techniques
153    pub techniques: Vec<AugmentationTechnique>,
154    /// Augmentation ratio
155    pub augmentation_ratio: f64,
156}
157
158/// Data augmentation techniques
159#[derive(Debug, Clone, PartialEq, Eq)]
160pub enum AugmentationTechnique {
161    NoiseInjection,
162    Rotation,
163    Scaling,
164    Permutation,
165    Interpolation,
166    Synthetic,
167}
168
169/// Model hyperparameters
170#[derive(Debug, Clone)]
171pub struct ModelHyperparameters {
172    /// Learning rate
173    pub learning_rate: f64,
174    /// Batch size
175    pub batch_size: usize,
176    /// Number of epochs
177    pub epochs: usize,
178    /// Model-specific parameters
179    pub model_specific: HashMap<String, f64>,
180    /// Hyperparameter optimization
181    pub optimization: HyperparameterOptimization,
182}
183
184/// Hyperparameter optimization configuration
185#[derive(Debug, Clone)]
186pub struct HyperparameterOptimization {
187    /// Enable hyperparameter optimization
188    pub enable_optimization: bool,
189    /// Optimization strategy
190    pub strategy: HyperparameterStrategy,
191    /// Search space definition
192    pub search_space: SearchSpaceConfig,
193    /// Optimization budget
194    pub optimization_budget: OptimizationBudget,
195}
196
197/// Hyperparameter optimization strategies
198#[derive(Debug, Clone, PartialEq, Eq)]
199pub enum HyperparameterStrategy {
200    GridSearch,
201    RandomSearch,
202    BayesianOptimization,
203    GeneticAlgorithm,
204    HalvingSearch,
205}
206
207/// Search space configuration
208#[derive(Debug, Clone, Default)]
209pub struct SearchSpaceConfig {
210    /// Parameter ranges
211    pub parameter_ranges: HashMap<String, ParameterRange>,
212    /// Categorical parameters
213    pub categorical_parameters: HashMap<String, Vec<String>>,
214    /// Constraints between parameters
215    pub constraints: Vec<ParameterConstraint>,
216}
217
218/// Parameter range definition
219#[derive(Debug, Clone)]
220pub struct ParameterRange {
221    /// Minimum value
222    pub min: f64,
223    /// Maximum value
224    pub max: f64,
225    /// Step size (for discrete parameters)
226    pub step: Option<f64>,
227    /// Distribution type
228    pub distribution: ParameterDistribution,
229}
230
231/// Parameter distributions
232#[derive(Debug, Clone, PartialEq, Eq)]
233pub enum ParameterDistribution {
234    Uniform,
235    LogUniform,
236    Normal,
237    LogNormal,
238}
239
240/// Constraints between parameters
241#[derive(Debug, Clone)]
242pub struct ParameterConstraint {
243    /// Constraint name
244    pub name: String,
245    /// Constraint expression
246    pub expression: String,
247    /// Constraint type
248    pub constraint_type: ConstraintType,
249}
250
251/// Types of parameter constraints
252#[derive(Debug, Clone, PartialEq, Eq)]
253pub enum ConstraintType {
254    Equality,
255    Inequality,
256    Conditional,
257}
258
259/// Optimization budget configuration
260#[derive(Debug, Clone)]
261pub struct OptimizationBudget {
262    /// Maximum evaluations
263    pub max_evaluations: usize,
264    /// Maximum time
265    pub max_time: Duration,
266    /// Early stopping criteria
267    pub early_stopping: EarlyStoppingCriteria,
268}
269
270/// Early stopping criteria for hyperparameter optimization
271#[derive(Debug, Clone)]
272pub struct EarlyStoppingCriteria {
273    /// Patience (evaluations without improvement)
274    pub patience: usize,
275    /// Minimum improvement threshold
276    pub min_improvement: f64,
277    /// Improvement metric
278    pub improvement_metric: String,
279}
280
281/// Training optimization configuration
282#[derive(Debug, Clone)]
283pub struct TrainingOptimizationConfig {
284    /// Optimizer type
285    pub optimizer: OptimizerType,
286    /// Learning rate scheduling
287    pub lr_scheduling: LearningRateScheduling,
288    /// Gradient clipping
289    pub gradient_clipping: GradientClippingConfig,
290    /// Loss function configuration
291    pub loss_function: LossFunctionConfig,
292}
293
294/// Types of optimizers
295#[derive(Debug, Clone, PartialEq, Eq)]
296pub enum OptimizerType {
297    SGD,
298    Adam,
299    RMSprop,
300    AdaGrad,
301    LBFGS,
302}
303
304/// Learning rate scheduling configuration
305#[derive(Debug, Clone)]
306pub struct LearningRateScheduling {
307    /// Enable learning rate scheduling
308    pub enable_scheduling: bool,
309    /// Scheduling strategy
310    pub strategy: LRSchedulingStrategy,
311    /// Schedule parameters
312    pub parameters: HashMap<String, f64>,
313}
314
315/// Learning rate scheduling strategies
316#[derive(Debug, Clone, PartialEq, Eq)]
317pub enum LRSchedulingStrategy {
318    StepDecay,
319    ExponentialDecay,
320    CosineAnnealing,
321    ReduceOnPlateau,
322    Cyclical,
323}
324
325/// Gradient clipping configuration
326#[derive(Debug, Clone)]
327pub struct GradientClippingConfig {
328    /// Enable gradient clipping
329    pub enable_clipping: bool,
330    /// Clipping method
331    pub method: ClippingMethod,
332    /// Clipping threshold
333    pub threshold: f64,
334}
335
336/// Gradient clipping methods
337#[derive(Debug, Clone, PartialEq, Eq)]
338pub enum ClippingMethod {
339    Norm,
340    Value,
341    Global,
342}
343
344/// Loss function configuration
345#[derive(Debug, Clone)]
346pub struct LossFunctionConfig {
347    /// Primary loss function
348    pub primary_loss: LossFunction,
349    /// Auxiliary losses
350    pub auxiliary_losses: Vec<AuxiliaryLoss>,
351    /// Loss weighting scheme
352    pub weighting_scheme: LossWeightingScheme,
353}
354
355/// Loss function types
356#[derive(Debug, Clone, PartialEq, Eq)]
357pub enum LossFunction {
358    MeanSquaredError,
359    MeanAbsoluteError,
360    Huber,
361    CrossEntropy,
362    FocalLoss,
363    Custom(String),
364}
365
366/// Auxiliary loss functions
367#[derive(Debug, Clone)]
368pub struct AuxiliaryLoss {
369    /// Loss function
370    pub loss_function: LossFunction,
371    /// Weight in total loss
372    pub weight: f64,
373    /// Application scope
374    pub scope: String,
375}
376
377/// Loss weighting schemes
378#[derive(Debug, Clone, PartialEq, Eq)]
379pub enum LossWeightingScheme {
380    Static,
381    Dynamic,
382    Adaptive,
383    Uncertainty,
384}
385
386/// Regularization configuration
387#[derive(Debug, Clone)]
388pub struct RegularizationConfig {
389    /// L1 regularization strength
390    pub l1_strength: f64,
391    /// L2 regularization strength
392    pub l2_strength: f64,
393    /// Dropout rate
394    pub dropout_rate: f64,
395    /// Batch normalization
396    pub batch_normalization: bool,
397    /// Additional regularization techniques
398    pub additional_techniques: Vec<RegularizationTechnique>,
399}
400
401/// Additional regularization techniques
402#[derive(Debug, Clone, PartialEq, Eq)]
403pub enum RegularizationTechnique {
404    Dropout,
405    BatchNorm,
406    LayerNorm,
407    WeightDecay,
408    EarlyStop,
409    DataAugmentation,
410}
411
412/// Early stopping configuration
413#[derive(Debug, Clone)]
414pub struct EarlyStoppingConfig {
415    /// Enable early stopping
416    pub enable_early_stopping: bool,
417    /// Patience (epochs without improvement)
418    pub patience: usize,
419    /// Minimum improvement delta
420    pub min_delta: f64,
421    /// Metric to monitor
422    pub monitor_metric: String,
423    /// Improvement direction
424    pub improvement_direction: ImprovementDirection,
425}
426
427/// Direction of improvement for monitored metric
428#[derive(Debug, Clone, PartialEq, Eq)]
429pub enum ImprovementDirection {
430    Maximize,
431    Minimize,
432}
433
434/// Cross-validation configuration
435#[derive(Debug, Clone)]
436pub struct CrossValidationConfig {
437    /// Enable cross-validation
438    pub enable_cv: bool,
439    /// Number of folds
440    pub folds: usize,
441    /// Cross-validation strategy
442    pub strategy: CVStrategy,
443    /// Stratification settings
444    pub stratification: StratificationConfig,
445}
446
447/// Cross-validation strategies
448#[derive(Debug, Clone, PartialEq, Eq)]
449pub enum CVStrategy {
450    KFold,
451    StratifiedKFold,
452    TimeSeriesSplit,
453    GroupKFold,
454    LeaveOneOut,
455}
456
457/// Stratification configuration
458#[derive(Debug, Clone)]
459pub struct StratificationConfig {
460    /// Enable stratification
461    pub enable_stratification: bool,
462    /// Stratification variable
463    pub stratification_variable: String,
464    /// Balance strategy
465    pub balance_strategy: BalanceStrategy,
466}
467
468/// Strategies for balancing stratified samples
469#[derive(Debug, Clone, PartialEq, Eq)]
470pub enum BalanceStrategy {
471    None,
472    Oversample,
473    Undersample,
474    SMOTE,
475    Adaptive,
476}
477
478/// Feature engineering configuration
479#[derive(Debug, Clone)]
480pub struct FeatureEngineeringConfig {
481    /// Enable automatic feature engineering
482    pub automatic_feature_engineering: bool,
483    /// Feature selection methods
484    pub feature_selection: Vec<FeatureSelectionMethod>,
485    /// Feature scaling method
486    pub feature_scaling: FeatureScalingMethod,
487    /// Dimensionality reduction
488    pub dimensionality_reduction: DimensionalityReductionConfig,
489    /// Feature interaction detection
490    pub interaction_detection: InteractionDetectionConfig,
491}
492
493/// Feature selection methods
494#[derive(Debug, Clone, PartialEq, Eq)]
495pub enum FeatureSelectionMethod {
496    VarianceThreshold,
497    UnivariateSelection,
498    RecursiveFeatureElimination,
499    FeatureImportance,
500    LassoRegularization,
501    MutualInformation,
502}
503
504/// Feature scaling methods
505#[derive(Debug, Clone, PartialEq, Eq)]
506pub enum FeatureScalingMethod {
507    StandardScaler,
508    MinMaxScaler,
509    RobustScaler,
510    Normalizer,
511    QuantileTransformer,
512    PowerTransformer,
513}
514
515/// Dimensionality reduction configuration
516#[derive(Debug, Clone)]
517pub struct DimensionalityReductionConfig {
518    /// Enable dimensionality reduction
519    pub enable_reduction: bool,
520    /// Reduction methods
521    pub methods: Vec<DimensionalityReductionMethod>,
522    /// Target dimensionality
523    pub target_dimensions: Option<usize>,
524    /// Variance explained threshold
525    pub variance_threshold: f64,
526}
527
528/// Dimensionality reduction methods
529#[derive(Debug, Clone, PartialEq, Eq)]
530pub enum DimensionalityReductionMethod {
531    PCA,
532    ICA,
533    LDA,
534    TSNE,
535    UMAP,
536    FactorAnalysis,
537}
538
539/// Feature interaction detection configuration
540#[derive(Debug, Clone)]
541pub struct InteractionDetectionConfig {
542    /// Enable interaction detection
543    pub enable_detection: bool,
544    /// Detection methods
545    pub methods: Vec<InteractionDetectionMethod>,
546    /// Interaction order (2-way, 3-way, etc.)
547    pub interaction_order: usize,
548    /// Significance threshold
549    pub significance_threshold: f64,
550}
551
552/// Feature interaction detection methods
553#[derive(Debug, Clone, PartialEq, Eq)]
554pub enum InteractionDetectionMethod {
555    Correlation,
556    MutualInformation,
557    ANOVA,
558    TreeBased,
559    Statistical,
560}
561
562/// Online learning configuration
563#[derive(Debug, Clone)]
564pub struct OnlineLearningConfig {
565    /// Enable online learning
566    pub enable_online_learning: bool,
567    /// Learning rate adaptation
568    pub learning_rate_adaptation: AdaptiveLearningRate,
569    /// Model update frequency
570    pub update_frequency: UpdateFrequency,
571    /// Concept drift detection
572    pub concept_drift: ConceptDriftConfig,
573    /// Memory management
574    pub memory_management: MemoryManagementConfig,
575}
576
577/// Adaptive learning rate configuration
578#[derive(Debug, Clone)]
579pub struct AdaptiveLearningRate {
580    /// Initial learning rate
581    pub initial_rate: f64,
582    /// Adaptation strategy
583    pub adaptation_strategy: LRAdaptationStrategy,
584    /// Adaptation parameters
585    pub parameters: HashMap<String, f64>,
586}
587
588/// Learning rate adaptation strategies
589#[derive(Debug, Clone, PartialEq, Eq)]
590pub enum LRAdaptationStrategy {
591    Constant,
592    InverseScaling,
593    Adaptive,
594    Performance,
595}
596
597/// Model update frequency configuration
598#[derive(Debug, Clone)]
599pub struct UpdateFrequency {
600    /// Update trigger
601    pub trigger: UpdateTrigger,
602    /// Minimum update interval
603    pub min_interval: Duration,
604    /// Maximum update interval
605    pub max_interval: Duration,
606}
607
608/// Triggers for model updates
609#[derive(Debug, Clone, PartialEq, Eq)]
610pub enum UpdateTrigger {
611    TimeInterval,
612    DataVolume,
613    PerformanceDrift,
614    Manual,
615    Adaptive,
616}
617
618/// Concept drift detection configuration
619#[derive(Debug, Clone)]
620pub struct ConceptDriftConfig {
621    /// Enable drift detection
622    pub enable_detection: bool,
623    /// Detection methods
624    pub detection_methods: Vec<DriftDetectionMethod>,
625    /// Detection sensitivity
626    pub sensitivity: f64,
627    /// Response strategy
628    pub response_strategy: DriftResponseStrategy,
629}
630
631/// Concept drift detection methods
632#[derive(Debug, Clone, PartialEq, Eq)]
633pub enum DriftDetectionMethod {
634    StatisticalTest,
635    PerformanceMonitoring,
636    DistributionComparison,
637    EnsembleBased,
638}
639
640/// Response strategies for concept drift
641#[derive(Debug, Clone, PartialEq, Eq)]
642pub enum DriftResponseStrategy {
643    Retrain,
644    Adapt,
645    EnsembleUpdate,
646    ModelSwitch,
647}
648
649/// Memory management for online learning
650#[derive(Debug, Clone)]
651pub struct MemoryManagementConfig {
652    /// Memory window size
653    pub window_size: usize,
654    /// Forgetting factor
655    pub forgetting_factor: f64,
656    /// Memory strategy
657    pub strategy: MemoryStrategy,
658}
659
660/// Memory management strategies
661#[derive(Debug, Clone, PartialEq, Eq)]
662pub enum MemoryStrategy {
663    FixedWindow,
664    SlidingWindow,
665    FadingMemory,
666    Adaptive,
667}
668
669/// Transfer learning configuration
670#[derive(Debug, Clone)]
671pub struct TransferLearningConfig {
672    /// Enable transfer learning
673    pub enable_transfer_learning: bool,
674    /// Transfer strategies
675    pub transfer_strategies: Vec<TransferStrategy>,
676    /// Source domain configuration
677    pub source_domain: SourceDomainConfig,
678    /// Domain adaptation
679    pub domain_adaptation: DomainAdaptationConfig,
680}
681
682/// Transfer learning strategies
683#[derive(Debug, Clone, PartialEq, Eq)]
684pub enum TransferStrategy {
685    FeatureExtraction,
686    FineTuning,
687    DomainAdaptation,
688    TaskSpecificLayers,
689    MetaLearning,
690}
691
692/// Source domain configuration
693#[derive(Debug, Clone)]
694pub struct SourceDomainConfig {
695    /// Source domain identifier
696    pub domain_id: String,
697    /// Similarity metrics
698    pub similarity_metrics: Vec<SimilarityMetric>,
699    /// Transfer eligibility criteria
700    pub eligibility_criteria: EligibilityCriteria,
701}
702
703/// Similarity metrics for domain comparison
704#[derive(Debug, Clone, PartialEq, Eq)]
705pub enum SimilarityMetric {
706    Statistical,
707    Distributional,
708    Performance,
709    Structural,
710}
711
712/// Criteria for transfer learning eligibility
713#[derive(Debug, Clone)]
714pub struct EligibilityCriteria {
715    /// Minimum similarity threshold
716    pub min_similarity: f64,
717    /// Performance requirements
718    pub performance_requirements: PerformanceRequirements,
719    /// Data requirements
720    pub data_requirements: DataRequirements,
721}
722
723/// Performance requirements for transfer learning
724#[derive(Debug, Clone)]
725pub struct PerformanceRequirements {
726    /// Minimum source model accuracy
727    pub min_source_accuracy: f64,
728    /// Expected transfer benefit
729    pub expected_benefit: f64,
730}
731
732/// Data requirements for transfer learning
733#[derive(Debug, Clone)]
734pub struct DataRequirements {
735    /// Minimum source data size
736    pub min_source_size: usize,
737    /// Minimum target data size
738    pub min_target_size: usize,
739    /// Data quality requirements
740    pub quality_requirements: DataQualityRequirements,
741}
742
743/// Data quality requirements
744#[derive(Debug, Clone)]
745pub struct DataQualityRequirements {
746    /// Minimum data completeness
747    pub min_completeness: f64,
748    /// Maximum noise level
749    pub max_noise_level: f64,
750    /// Consistency requirements
751    pub consistency_requirements: Vec<String>,
752}
753
754/// Domain adaptation configuration
755#[derive(Debug, Clone)]
756pub struct DomainAdaptationConfig {
757    /// Adaptation methods
758    pub methods: Vec<DomainAdaptationMethod>,
759    /// Adaptation strength
760    pub adaptation_strength: f64,
761    /// Validation strategy
762    pub validation_strategy: AdaptationValidationStrategy,
763}
764
765/// Domain adaptation methods
766#[derive(Debug, Clone, PartialEq, Eq)]
767pub enum DomainAdaptationMethod {
768    FeatureAlignment,
769    DistributionMatching,
770    AdversarialTraining,
771    CorrectionModels,
772}
773
774/// Validation strategies for domain adaptation
775#[derive(Debug, Clone, PartialEq, Eq)]
776pub enum AdaptationValidationStrategy {
777    TargetValidation,
778    SourceValidation,
779    CombinedValidation,
780    UnsupervisedMetrics,
781}
782
783// Default implementations for the main configuration types
784
785impl Default for MLOptimizationConfig {
786    fn default() -> Self {
787        Self {
788            enable_ml_optimization: true,
789            ml_models: vec![
790                MLModelType::NeuralNetwork,
791                MLModelType::BayesianOptimization,
792            ],
793            training_config: MLTrainingConfig::default(),
794            feature_engineering: FeatureEngineeringConfig::default(),
795            online_learning: OnlineLearningConfig::default(),
796            transfer_learning: TransferLearningConfig::default(),
797        }
798    }
799}
800
801impl Default for FeatureEngineeringConfig {
802    fn default() -> Self {
803        Self {
804            automatic_feature_engineering: true,
805            feature_selection: vec![
806                FeatureSelectionMethod::VarianceThreshold,
807                FeatureSelectionMethod::FeatureImportance,
808            ],
809            feature_scaling: FeatureScalingMethod::StandardScaler,
810            dimensionality_reduction: DimensionalityReductionConfig::default(),
811            interaction_detection: InteractionDetectionConfig::default(),
812        }
813    }
814}
815
816impl Default for OnlineLearningConfig {
817    fn default() -> Self {
818        Self {
819            enable_online_learning: true,
820            learning_rate_adaptation: AdaptiveLearningRate::default(),
821            update_frequency: UpdateFrequency::default(),
822            concept_drift: ConceptDriftConfig::default(),
823            memory_management: MemoryManagementConfig::default(),
824        }
825    }
826}
827
828impl Default for TransferLearningConfig {
829    fn default() -> Self {
830        Self {
831            enable_transfer_learning: true,
832            transfer_strategies: vec![TransferStrategy::FeatureExtraction],
833            source_domain: SourceDomainConfig::default(),
834            domain_adaptation: DomainAdaptationConfig::default(),
835        }
836    }
837}
838
839// Additional default implementations for supporting types would go here
840// (truncated for brevity)
841
842impl Default for TrainingDataConfig {
843    fn default() -> Self {
844        Self {
845            min_training_samples: 1000,
846            data_collection_strategy: DataCollectionStrategy::Adaptive,
847            preprocessing: DataPreprocessingConfig::default(),
848            augmentation: DataAugmentationConfig::default(),
849        }
850    }
851}
852
853impl Default for DataPreprocessingConfig {
854    fn default() -> Self {
855        Self {
856            normalization: NormalizationMethod::ZScore,
857            outlier_handling: OutlierHandling::Cap,
858            missing_value_strategy: MissingValueStrategy::Impute,
859            validation_rules: vec![],
860        }
861    }
862}
863
864impl Default for DataAugmentationConfig {
865    fn default() -> Self {
866        Self {
867            enable_augmentation: false,
868            techniques: vec![],
869            augmentation_ratio: 0.1,
870        }
871    }
872}
873
874impl Default for ModelHyperparameters {
875    fn default() -> Self {
876        Self {
877            learning_rate: 0.001,
878            batch_size: 32,
879            epochs: 100,
880            model_specific: HashMap::new(),
881            optimization: HyperparameterOptimization::default(),
882        }
883    }
884}
885
886impl Default for HyperparameterOptimization {
887    fn default() -> Self {
888        Self {
889            enable_optimization: false,
890            strategy: HyperparameterStrategy::RandomSearch,
891            search_space: SearchSpaceConfig::default(),
892            optimization_budget: OptimizationBudget::default(),
893        }
894    }
895}
896
897impl Default for OptimizationBudget {
898    fn default() -> Self {
899        Self {
900            max_evaluations: 100,
901            max_time: Duration::from_secs(3600),
902            early_stopping: EarlyStoppingCriteria::default(),
903        }
904    }
905}
906
907impl Default for EarlyStoppingCriteria {
908    fn default() -> Self {
909        Self {
910            patience: 20,
911            min_improvement: 0.001,
912            improvement_metric: "validation_loss".to_string(),
913        }
914    }
915}
916
917impl Default for TrainingOptimizationConfig {
918    fn default() -> Self {
919        Self {
920            optimizer: OptimizerType::Adam,
921            lr_scheduling: LearningRateScheduling::default(),
922            gradient_clipping: GradientClippingConfig::default(),
923            loss_function: LossFunctionConfig::default(),
924        }
925    }
926}
927
928impl Default for LearningRateScheduling {
929    fn default() -> Self {
930        Self {
931            enable_scheduling: false,
932            strategy: LRSchedulingStrategy::ReduceOnPlateau,
933            parameters: HashMap::new(),
934        }
935    }
936}
937
938impl Default for GradientClippingConfig {
939    fn default() -> Self {
940        Self {
941            enable_clipping: true,
942            method: ClippingMethod::Norm,
943            threshold: 1.0,
944        }
945    }
946}
947
948impl Default for LossFunctionConfig {
949    fn default() -> Self {
950        Self {
951            primary_loss: LossFunction::MeanSquaredError,
952            auxiliary_losses: vec![],
953            weighting_scheme: LossWeightingScheme::Static,
954        }
955    }
956}
957
958impl Default for RegularizationConfig {
959    fn default() -> Self {
960        Self {
961            l1_strength: 0.0,
962            l2_strength: 0.001,
963            dropout_rate: 0.1,
964            batch_normalization: true,
965            additional_techniques: vec![],
966        }
967    }
968}
969
970impl Default for EarlyStoppingConfig {
971    fn default() -> Self {
972        Self {
973            enable_early_stopping: true,
974            patience: 10,
975            min_delta: 0.001,
976            monitor_metric: "validation_loss".to_string(),
977            improvement_direction: ImprovementDirection::Minimize,
978        }
979    }
980}
981
982impl Default for CrossValidationConfig {
983    fn default() -> Self {
984        Self {
985            enable_cv: true,
986            folds: 5,
987            strategy: CVStrategy::KFold,
988            stratification: StratificationConfig::default(),
989        }
990    }
991}
992
993impl Default for StratificationConfig {
994    fn default() -> Self {
995        Self {
996            enable_stratification: false,
997            stratification_variable: String::new(),
998            balance_strategy: BalanceStrategy::None,
999        }
1000    }
1001}
1002
1003impl Default for DimensionalityReductionConfig {
1004    fn default() -> Self {
1005        Self {
1006            enable_reduction: false,
1007            methods: vec![DimensionalityReductionMethod::PCA],
1008            target_dimensions: None,
1009            variance_threshold: 0.95,
1010        }
1011    }
1012}
1013
1014impl Default for InteractionDetectionConfig {
1015    fn default() -> Self {
1016        Self {
1017            enable_detection: false,
1018            methods: vec![InteractionDetectionMethod::Correlation],
1019            interaction_order: 2,
1020            significance_threshold: 0.05,
1021        }
1022    }
1023}
1024
1025impl Default for AdaptiveLearningRate {
1026    fn default() -> Self {
1027        Self {
1028            initial_rate: 0.001,
1029            adaptation_strategy: LRAdaptationStrategy::Adaptive,
1030            parameters: HashMap::new(),
1031        }
1032    }
1033}
1034
1035impl Default for UpdateFrequency {
1036    fn default() -> Self {
1037        Self {
1038            trigger: UpdateTrigger::TimeInterval,
1039            min_interval: Duration::from_secs(300),
1040            max_interval: Duration::from_secs(3600),
1041        }
1042    }
1043}
1044
1045impl Default for ConceptDriftConfig {
1046    fn default() -> Self {
1047        Self {
1048            enable_detection: true,
1049            detection_methods: vec![DriftDetectionMethod::PerformanceMonitoring],
1050            sensitivity: 0.05,
1051            response_strategy: DriftResponseStrategy::Adapt,
1052        }
1053    }
1054}
1055
1056impl Default for MemoryManagementConfig {
1057    fn default() -> Self {
1058        Self {
1059            window_size: 10000,
1060            forgetting_factor: 0.99,
1061            strategy: MemoryStrategy::SlidingWindow,
1062        }
1063    }
1064}
1065
1066impl Default for SourceDomainConfig {
1067    fn default() -> Self {
1068        Self {
1069            domain_id: String::new(),
1070            similarity_metrics: vec![SimilarityMetric::Statistical],
1071            eligibility_criteria: EligibilityCriteria::default(),
1072        }
1073    }
1074}
1075
1076impl Default for EligibilityCriteria {
1077    fn default() -> Self {
1078        Self {
1079            min_similarity: 0.7,
1080            performance_requirements: PerformanceRequirements::default(),
1081            data_requirements: DataRequirements::default(),
1082        }
1083    }
1084}
1085
1086impl Default for PerformanceRequirements {
1087    fn default() -> Self {
1088        Self {
1089            min_source_accuracy: 0.8,
1090            expected_benefit: 0.1,
1091        }
1092    }
1093}
1094
1095impl Default for DataRequirements {
1096    fn default() -> Self {
1097        Self {
1098            min_source_size: 1000,
1099            min_target_size: 100,
1100            quality_requirements: DataQualityRequirements::default(),
1101        }
1102    }
1103}
1104
1105impl Default for DataQualityRequirements {
1106    fn default() -> Self {
1107        Self {
1108            min_completeness: 0.9,
1109            max_noise_level: 0.1,
1110            consistency_requirements: vec![],
1111        }
1112    }
1113}
1114
1115impl Default for DomainAdaptationConfig {
1116    fn default() -> Self {
1117        Self {
1118            methods: vec![DomainAdaptationMethod::FeatureAlignment],
1119            adaptation_strength: 0.5,
1120            validation_strategy: AdaptationValidationStrategy::CombinedValidation,
1121        }
1122    }
1123}
quantrs2_device/adaptive_compilation/ml_integration.rs

quantrs2_device/adaptive_compilation/
ml_integration.rs
