quantrs2_device/qec/
adaptive.rs

1//! Adaptive QEC Methods, ML Integration, and Real-time Optimization
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::time::Duration;
6
7/// Adaptive QEC configuration
8#[derive(Debug, Clone, Serialize, Deserialize)]
9pub struct AdaptiveQECConfig {
10    /// Enable real-time adaptation
11    pub enable_real_time_adaptation: bool,
12    /// Adaptation window
13    pub adaptation_window: std::time::Duration,
14    /// Performance threshold
15    pub performance_threshold: f64,
16    /// Enable threshold adaptation
17    pub enable_threshold_adaptation: bool,
18    /// Enable strategy switching
19    pub enable_strategy_switching: bool,
20    /// Learning rate
21    pub learning_rate: f64,
22    /// Enable adaptive QEC
23    pub enable_adaptive: bool,
24    /// Adaptation strategies
25    pub strategies: Vec<AdaptationStrategy>,
26    /// Learning configuration
27    pub learning: AdaptiveLearningConfig,
28    /// Real-time optimization
29    pub realtime_optimization: RealtimeOptimizationConfig,
30    /// Feedback control
31    pub feedback_control: FeedbackControlConfig,
32    /// Prediction configuration
33    pub prediction: PredictionConfig,
34    /// Optimization configuration
35    pub optimization: OptimizationConfig,
36}
37
38/// Adaptation strategies for QEC
39#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
40pub enum AdaptationStrategy {
41    ErrorRateBased,
42    PerformanceBased,
43    ResourceBased,
44    MLBased,
45    HybridAdaptation,
46    PredictiveAdaptation,
47}
48
49/// Adaptive learning configuration
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct AdaptiveLearningConfig {
52    /// Learning algorithms
53    pub algorithms: Vec<LearningAlgorithm>,
54    /// Online learning
55    pub online_learning: OnlineLearningConfig,
56    /// Transfer learning
57    pub transfer_learning: TransferLearningConfig,
58    /// Meta-learning
59    pub meta_learning: MetaLearningConfig,
60}
61
62/// Learning algorithms for adaptive QEC
63#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
64pub enum LearningAlgorithm {
65    ReinforcementLearning,
66    SupervisedLearning,
67    UnsupervisedLearning,
68    SemiSupervisedLearning,
69    FederatedLearning,
70    ContinualLearning,
71}
72
73/// Online learning configuration
74#[derive(Debug, Clone, Serialize, Deserialize)]
75pub struct OnlineLearningConfig {
76    /// Enable online learning
77    pub enable_online: bool,
78    /// Learning rate adaptation
79    pub learning_rate_adaptation: LearningRateAdaptation,
80    /// Concept drift detection
81    pub concept_drift: ConceptDriftConfig,
82    /// Model updates
83    pub model_updates: ModelUpdateConfig,
84}
85
86/// Learning rate adaptation strategies
87#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
88pub enum LearningRateAdaptation {
89    Fixed,
90    Exponential,
91    Polynomial,
92    Adaptive,
93    PerformanceBased,
94}
95
96/// Concept drift detection configuration
97#[derive(Debug, Clone, Serialize, Deserialize)]
98pub struct ConceptDriftConfig {
99    /// Enable drift detection
100    pub enable_detection: bool,
101    /// Detection methods
102    pub methods: Vec<DriftDetectionMethod>,
103    /// Response strategies
104    pub responses: Vec<DriftResponse>,
105}
106
107/// Drift detection methods
108#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
109pub enum DriftDetectionMethod {
110    StatisticalTest,
111    PerformanceMonitoring,
112    DistributionChange,
113    ModelPerformance,
114}
115
116/// Responses to concept drift
117#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
118pub enum DriftResponse {
119    Retrain,
120    Adapt,
121    Reset,
122    EnsembleUpdate,
123}
124
125/// Model update configuration
126#[derive(Debug, Clone, Serialize, Deserialize)]
127pub struct ModelUpdateConfig {
128    /// Update frequency
129    pub frequency: UpdateFrequency,
130    /// Update triggers
131    pub triggers: Vec<UpdateTrigger>,
132    /// Update strategies
133    pub strategies: Vec<UpdateStrategy>,
134}
135
136/// Update frequency options
137#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
138pub enum UpdateFrequency {
139    Continuous,
140    Periodic(Duration),
141    EventTriggered,
142    Adaptive,
143}
144
145/// Update triggers
146#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
147pub enum UpdateTrigger {
148    PerformanceDegradation,
149    NewData,
150    EnvironmentChange,
151    UserRequest,
152}
153
154/// Update strategies
155#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
156pub enum UpdateStrategy {
157    FullRetrain,
158    IncrementalUpdate,
159    EnsembleUpdate,
160    ParameterUpdate,
161}
162
163/// Transfer learning configuration
164#[derive(Debug, Clone, Serialize, Deserialize)]
165pub struct TransferLearningConfig {
166    /// Enable transfer learning
167    pub enable_transfer: bool,
168    /// Source domains
169    pub source_domains: Vec<SourceDomain>,
170    /// Transfer strategies
171    pub strategies: Vec<TransferStrategy>,
172    /// Domain adaptation
173    pub domain_adaptation: DomainAdaptationConfig,
174}
175
176/// Source domain definition
177#[derive(Debug, Clone, Serialize, Deserialize)]
178pub struct SourceDomain {
179    /// Domain identifier
180    pub id: String,
181    /// Domain characteristics
182    pub characteristics: HashMap<String, f64>,
183    /// Similarity metrics
184    pub similarity: SimilarityMetrics,
185}
186
187/// Similarity metrics for domains
188#[derive(Debug, Clone, Serialize, Deserialize)]
189pub struct SimilarityMetrics {
190    /// Statistical similarity
191    pub statistical: f64,
192    /// Structural similarity
193    pub structural: f64,
194    /// Performance similarity
195    pub performance: f64,
196}
197
198/// Transfer learning strategies
199#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
200pub enum TransferStrategy {
201    FeatureTransfer,
202    ParameterTransfer,
203    ModelTransfer,
204    KnowledgeDistillation,
205}
206
207/// Domain adaptation configuration
208#[derive(Debug, Clone, Serialize, Deserialize)]
209pub struct DomainAdaptationConfig {
210    /// Adaptation methods
211    pub methods: Vec<AdaptationMethod>,
212    /// Validation strategies
213    pub validation: Vec<ValidationStrategy>,
214}
215
216/// Domain adaptation methods
217#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
218pub enum AdaptationMethod {
219    FeatureAlignment,
220    DistributionMatching,
221    AdversarialTraining,
222    CorrectionModels,
223}
224
225/// Validation strategies for domain adaptation
226#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
227pub enum ValidationStrategy {
228    CrossDomainValidation,
229    TargetValidation,
230    UnsupervisedMetrics,
231}
232
233/// Meta-learning configuration
234#[derive(Debug, Clone, Serialize, Deserialize)]
235pub struct MetaLearningConfig {
236    /// Enable meta-learning
237    pub enable_meta: bool,
238    /// Meta-learning algorithms
239    pub algorithms: Vec<MetaLearningAlgorithm>,
240    /// Task distribution
241    pub task_distribution: TaskDistributionConfig,
242    /// Meta-optimization
243    pub meta_optimization: MetaOptimizationConfig,
244}
245
246/// Meta-learning algorithms
247#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
248pub enum MetaLearningAlgorithm {
249    MAML,
250    Reptile,
251    ProtoNet,
252    RelationNet,
253    MatchingNet,
254}
255
256/// Task distribution configuration
257#[derive(Debug, Clone, Serialize, Deserialize)]
258pub struct TaskDistributionConfig {
259    /// Task types
260    pub task_types: Vec<String>,
261    /// Task complexity
262    pub complexity_range: (f64, f64),
263    /// Task generation
264    pub generation_strategy: TaskGenerationStrategy,
265}
266
267/// Task generation strategies
268#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
269pub enum TaskGenerationStrategy {
270    Random,
271    Curriculum,
272    Adaptive,
273    HumanDesigned,
274}
275
276/// Meta-optimization configuration
277#[derive(Debug, Clone, Serialize, Deserialize)]
278pub struct MetaOptimizationConfig {
279    /// Meta-optimizer
280    pub optimizer: MetaOptimizer,
281    /// Learning rates
282    pub learning_rates: LearningRates,
283    /// Regularization
284    pub regularization: MetaRegularization,
285}
286
287/// Meta-optimizers
288#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
289pub enum MetaOptimizer {
290    SGD,
291    Adam,
292    RMSprop,
293    AdaGrad,
294}
295
296/// Learning rates for meta-learning
297#[derive(Debug, Clone, Serialize, Deserialize)]
298pub struct LearningRates {
299    /// Inner loop learning rate
300    pub inner_lr: f64,
301    /// Outer loop learning rate
302    pub outer_lr: f64,
303    /// Adaptive learning rates
304    pub adaptive: bool,
305}
306
307/// Meta-regularization configuration
308#[derive(Debug, Clone, Serialize, Deserialize)]
309pub struct MetaRegularization {
310    /// Regularization type
311    pub regularization_type: RegularizationType,
312    /// Regularization strength
313    pub strength: f64,
314}
315
316/// Types of regularization
317#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
318pub enum RegularizationType {
319    L1,
320    L2,
321    Dropout,
322    BatchNorm,
323    None,
324}
325
326/// Real-time optimization configuration
327#[derive(Debug, Clone, Serialize, Deserialize)]
328pub struct RealtimeOptimizationConfig {
329    /// Enable real-time optimization
330    pub enable_realtime: bool,
331    /// Optimization objectives
332    pub objectives: Vec<OptimizationObjective>,
333    /// Optimization algorithms
334    pub algorithms: Vec<RealtimeAlgorithm>,
335    /// Resource constraints
336    pub constraints: ResourceConstraints,
337}
338
339/// Optimization objectives
340#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
341pub enum OptimizationObjective {
342    MinimizeErrorRate,
343    MaximizeFidelity,
344    MinimizeLatency,
345    MaximizeThroughput,
346    MinimizeResourceUsage,
347    BalancedObjective,
348}
349
350/// Real-time optimization algorithms
351#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
352pub enum RealtimeAlgorithm {
353    OnlineGradientDescent,
354    AdaptiveMomentum,
355    ParticleSwarm,
356    GeneticAlgorithm,
357    BayesianOptimization,
358    ModelPredictiveControl,
359}
360
361/// Resource constraints for real-time optimization
362#[derive(Debug, Clone, Serialize, Deserialize)]
363pub struct ResourceConstraints {
364    /// Computation time limit
365    pub time_limit: Duration,
366    /// Memory limit
367    pub memory_limit: usize,
368    /// Power budget
369    pub power_budget: f64,
370    /// Hardware constraints
371    pub hardware_constraints: HardwareConstraints,
372}
373
374/// Hardware constraints
375#[derive(Debug, Clone, Serialize, Deserialize)]
376pub struct HardwareConstraints {
377    /// Qubit connectivity
378    pub connectivity: ConnectivityConstraints,
379    /// Gate fidelities
380    pub gate_fidelities: HashMap<String, f64>,
381    /// Coherence times
382    pub coherence_times: CoherenceTimes,
383}
384
385/// Connectivity constraints
386#[derive(Debug, Clone, Serialize, Deserialize)]
387pub struct ConnectivityConstraints {
388    /// Coupling map
389    pub coupling_map: Vec<(usize, usize)>,
390    /// Maximum distance
391    pub max_distance: usize,
392    /// Routing overhead
393    pub routing_overhead: f64,
394}
395
396/// Coherence times
397#[derive(Debug, Clone, Serialize, Deserialize)]
398pub struct CoherenceTimes {
399    /// T1 times
400    pub t1_times: HashMap<usize, f64>,
401    /// T2 times
402    pub t2_times: HashMap<usize, f64>,
403    /// Gate times
404    pub gate_times: HashMap<String, f64>,
405}
406
407/// Feedback control configuration
408#[derive(Debug, Clone, Serialize, Deserialize)]
409pub struct FeedbackControlConfig {
410    /// Enable feedback control
411    pub enable_feedback: bool,
412    /// Control algorithms
413    pub algorithms: Vec<ControlAlgorithm>,
414    /// Sensor configuration
415    pub sensors: SensorConfig,
416    /// Actuator configuration
417    pub actuators: ActuatorConfig,
418}
419
420/// Control algorithms for feedback
421#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
422pub enum ControlAlgorithm {
423    PID,
424    LQR,
425    MPC,
426    AdaptiveControl,
427    RobustControl,
428    NeuralControl,
429}
430
431/// Sensor configuration
432#[derive(Debug, Clone, Serialize, Deserialize)]
433pub struct SensorConfig {
434    /// Sensor types
435    pub sensor_types: Vec<SensorType>,
436    /// Sampling rates
437    pub sampling_rates: HashMap<String, f64>,
438    /// Noise characteristics
439    pub noise_characteristics: NoiseCharacteristics,
440}
441
442/// Types of sensors
443#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
444pub enum SensorType {
445    PerformanceMonitor,
446    ErrorRateMonitor,
447    TemperatureSensor,
448    VibrationseSensor,
449    CustomSensor(String),
450}
451
452/// Noise characteristics of sensors
453#[derive(Debug, Clone, Serialize, Deserialize)]
454pub struct NoiseCharacteristics {
455    /// Gaussian noise
456    pub gaussian_noise: f64,
457    /// Systematic bias
458    pub systematic_bias: f64,
459    /// Temporal correlation
460    pub temporal_correlation: f64,
461}
462
463/// Actuator configuration
464#[derive(Debug, Clone, Serialize, Deserialize)]
465pub struct ActuatorConfig {
466    /// Actuator types
467    pub actuator_types: Vec<ActuatorType>,
468    /// Response times
469    pub response_times: HashMap<String, Duration>,
470    /// Control ranges
471    pub control_ranges: HashMap<String, (f64, f64)>,
472}
473
474/// Types of actuators
475#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
476pub enum ActuatorType {
477    PulseController,
478    FrequencyController,
479    PhaseController,
480    AmplitudeController,
481    CustomActuator(String),
482}
483
484/// QEC optimization configuration
485#[derive(Debug, Clone, Serialize, Deserialize)]
486pub struct QECOptimizationConfig {
487    /// Enable optimization
488    pub enable_optimization: bool,
489    /// Enable code optimization
490    pub enable_code_optimization: bool,
491    /// Enable layout optimization
492    pub enable_layout_optimization: bool,
493    /// Enable scheduling optimization
494    pub enable_scheduling_optimization: bool,
495    /// Optimization algorithm
496    pub optimization_algorithm: crate::unified_benchmarking::config::OptimizationAlgorithm,
497    /// Optimization objectives
498    pub optimization_objectives: Vec<crate::unified_benchmarking::config::OptimizationObjective>,
499    /// Constraint satisfaction configuration
500    pub constraint_satisfaction: ConstraintSatisfactionConfig,
501    /// Optimization targets
502    pub targets: Vec<OptimizationTarget>,
503    /// Performance metrics
504    pub metrics: Vec<PerformanceMetric>,
505    /// Optimization strategies
506    pub strategies: Vec<OptimizationStrategy>,
507}
508
509/// Constraint satisfaction configuration
510#[derive(Debug, Clone, Serialize, Deserialize)]
511pub struct ConstraintSatisfactionConfig {
512    /// Hardware constraints
513    pub hardware_constraints: Vec<HardwareConstraint>,
514    /// Resource constraints
515    pub resource_constraints: Vec<ResourceConstraint>,
516    /// Performance constraints
517    pub performance_constraints: Vec<PerformanceConstraint>,
518}
519
520/// Hardware constraint types
521#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
522pub enum HardwareConstraint {
523    ConnectivityGraph,
524    GateTimes,
525    ErrorRates,
526}
527
528/// Resource constraint types
529#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
530pub enum ResourceConstraint {
531    QubitCount,
532    CircuitDepth,
533    ExecutionTime,
534}
535
536/// Performance constraint types
537#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
538pub enum PerformanceConstraint {
539    LogicalErrorRate,
540    ThroughputTarget,
541}
542
543/// Optimization targets
544#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
545pub enum OptimizationTarget {
546    ErrorCorrection,
547    ResourceEfficiency,
548    Latency,
549    Throughput,
550    EnergyConsumption,
551    FaultTolerance,
552}
553
554/// Performance metrics for QEC
555#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
556pub enum PerformanceMetric {
557    LogicalErrorRate,
558    DecodingLatency,
559    SyndromeAccuracy,
560    CorrectionSuccess,
561    ResourceUtilization,
562    ThroughputRate,
563}
564
565/// Optimization strategies
566#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
567pub enum OptimizationStrategy {
568    HeuristicOptimization,
569    ExactOptimization,
570    ApproximateOptimization,
571    MachineLearningOptimization,
572    HybridOptimization,
573}
574
575/// QEC machine learning configuration
576#[derive(Debug, Clone, Serialize, Deserialize)]
577pub struct QECMLConfig {
578    /// Model type
579    pub model_type: crate::unified_benchmarking::config::MLModelType,
580    /// Training data size
581    pub training_data_size: usize,
582    /// Validation split ratio
583    pub validation_split: f64,
584    /// Enable online learning
585    pub enable_online_learning: bool,
586    /// Feature extraction configuration
587    pub feature_extraction: crate::ml_optimization::FeatureExtractionConfig,
588    /// Model update frequency
589    pub model_update_frequency: std::time::Duration,
590    /// Enable ML for QEC
591    pub enable_ml: bool,
592    /// ML models
593    pub models: Vec<MLModel>,
594    /// Training configuration
595    pub training: MLTrainingConfig,
596    /// Inference configuration
597    pub inference: MLInferenceConfig,
598    /// Model management
599    pub model_management: ModelManagementConfig,
600}
601
602/// ML models for QEC
603#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
604pub enum MLModel {
605    NeuralNetwork,
606    ConvolutionalNN,
607    RecurrentNN,
608    Transformer,
609    RandomForest,
610    SupportVectorMachine,
611    GaussianProcess,
612    EnsembleModel,
613}
614
615/// ML training configuration for QEC
616#[derive(Debug, Clone, Serialize, Deserialize)]
617pub struct MLTrainingConfig {
618    /// Training data
619    pub data: TrainingDataConfig,
620    /// Model architecture
621    pub architecture: ModelArchitectureConfig,
622    /// Training parameters
623    pub parameters: TrainingParameters,
624    /// Validation
625    pub validation: ValidationConfig,
626}
627
628/// Training data configuration
629#[derive(Debug, Clone, Serialize, Deserialize)]
630pub struct TrainingDataConfig {
631    /// Data sources
632    pub sources: Vec<DataSource>,
633    /// Data preprocessing
634    pub preprocessing: DataPreprocessingConfig,
635    /// Data augmentation
636    pub augmentation: DataAugmentationConfig,
637}
638
639/// Data sources for ML training
640#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
641pub enum DataSource {
642    HistoricalData,
643    SimulatedData,
644    RealTimeData,
645    SyntheticData,
646    ExternalData,
647}
648
649/// Data preprocessing configuration
650#[derive(Debug, Clone, Serialize, Deserialize)]
651pub struct DataPreprocessingConfig {
652    /// Normalization
653    pub normalization: NormalizationMethod,
654    /// Feature selection
655    pub feature_selection: FeatureSelectionMethod,
656    /// Dimensionality reduction
657    pub dimensionality_reduction: DimensionalityReductionMethod,
658}
659
660/// Normalization methods
661#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
662pub enum NormalizationMethod {
663    MinMax,
664    ZScore,
665    Robust,
666    None,
667}
668
669/// Feature selection methods
670#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
671pub enum FeatureSelectionMethod {
672    Statistical,
673    ModelBased,
674    Wrapper,
675    Embedded,
676}
677
678/// Dimensionality reduction methods
679#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
680pub enum DimensionalityReductionMethod {
681    PCA,
682    LDA,
683    TSNE,
684    UMAP,
685    None,
686}
687
688/// Data augmentation configuration
689#[derive(Debug, Clone, Serialize, Deserialize)]
690pub struct DataAugmentationConfig {
691    /// Enable augmentation
692    pub enable: bool,
693    /// Augmentation techniques
694    pub techniques: Vec<AugmentationTechnique>,
695    /// Augmentation ratio
696    pub ratio: f64,
697}
698
699/// Data augmentation techniques
700#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
701pub enum AugmentationTechnique {
702    NoiseInjection,
703    Rotation,
704    Scaling,
705    Cropping,
706    Synthesis,
707}
708
709/// Model architecture configuration
710#[derive(Debug, Clone, Serialize, Deserialize)]
711pub struct ModelArchitectureConfig {
712    /// Architecture type
713    pub architecture_type: ArchitectureType,
714    /// Layer configuration
715    pub layers: Vec<LayerConfig>,
716    /// Connection patterns
717    pub connections: ConnectionPattern,
718}
719
720/// Architecture types
721#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
722pub enum ArchitectureType {
723    Sequential,
724    Residual,
725    DenseNet,
726    Attention,
727    Custom,
728}
729
730/// Layer configuration
731#[derive(Debug, Clone, Serialize, Deserialize)]
732pub struct LayerConfig {
733    /// Layer type
734    pub layer_type: LayerType,
735    /// Layer parameters
736    pub parameters: HashMap<String, f64>,
737    /// Activation function
738    pub activation: ActivationFunction,
739}
740
741/// Layer types
742#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
743pub enum LayerType {
744    Dense,
745    Convolutional,
746    Recurrent,
747    Attention,
748    Normalization,
749    Dropout,
750}
751
752/// Activation functions
753#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
754pub enum ActivationFunction {
755    ReLU,
756    Sigmoid,
757    Tanh,
758    Softmax,
759    LeakyReLU,
760    ELU,
761}
762
763/// Connection patterns in neural networks
764#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
765pub enum ConnectionPattern {
766    FullyConnected,
767    Sparse,
768    Skip,
769    Residual,
770    Dense,
771}
772
773/// Training parameters
774#[derive(Debug, Clone, Serialize, Deserialize)]
775pub struct TrainingParameters {
776    /// Learning rate
777    pub learning_rate: f64,
778    /// Batch size
779    pub batch_size: usize,
780    /// Number of epochs
781    pub epochs: usize,
782    /// Optimizer
783    pub optimizer: OptimizerType,
784    /// Loss function
785    pub loss_function: LossFunction,
786}
787
788/// Optimizer types
789#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
790pub enum OptimizerType {
791    SGD,
792    Adam,
793    RMSprop,
794    AdaGrad,
795    AdaDelta,
796}
797
798/// Loss functions
799#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
800pub enum LossFunction {
801    MeanSquaredError,
802    CrossEntropy,
803    BinaryCrossEntropy,
804    HuberLoss,
805    Custom(String),
806}
807
808/// Validation configuration
809#[derive(Debug, Clone, Serialize, Deserialize)]
810pub struct ValidationConfig {
811    /// Validation method
812    pub method: ValidationMethod,
813    /// Validation split
814    pub split: f64,
815    /// Cross-validation folds
816    pub cv_folds: usize,
817}
818
819/// Validation methods
820#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
821pub enum ValidationMethod {
822    HoldOut,
823    CrossValidation,
824    Bootstrap,
825    TimeSeriesSplit,
826}
827
828/// ML inference configuration
829#[derive(Debug, Clone, Serialize, Deserialize)]
830pub struct MLInferenceConfig {
831    /// Inference mode
832    pub mode: InferenceMode,
833    /// Batch processing
834    pub batch_processing: BatchProcessingConfig,
835    /// Performance optimization
836    pub optimization: InferenceOptimizationConfig,
837}
838
839/// Inference modes
840#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
841pub enum InferenceMode {
842    Synchronous,
843    Asynchronous,
844    Batch,
845    Streaming,
846}
847
848/// Batch processing configuration
849#[derive(Debug, Clone, Serialize, Deserialize)]
850pub struct BatchProcessingConfig {
851    /// Enable batch processing
852    pub enable: bool,
853    /// Batch size
854    pub batch_size: usize,
855    /// Timeout
856    pub timeout: Duration,
857}
858
859/// Inference optimization configuration
860#[derive(Debug, Clone, Serialize, Deserialize)]
861pub struct InferenceOptimizationConfig {
862    /// Model optimization
863    pub model_optimization: ModelOptimization,
864    /// Hardware acceleration
865    pub hardware_acceleration: HardwareAcceleration,
866    /// Caching
867    pub caching: InferenceCaching,
868}
869
870/// Model optimization techniques
871#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
872pub enum ModelOptimization {
873    Quantization,
874    Pruning,
875    Distillation,
876    Compilation,
877    None,
878}
879
880/// Hardware acceleration options
881#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
882pub enum HardwareAcceleration {
883    GPU,
884    TPU,
885    FPGA,
886    CPU,
887    Custom,
888}
889
890/// Inference caching configuration
891#[derive(Debug, Clone, Serialize, Deserialize)]
892pub struct InferenceCaching {
893    /// Enable caching
894    pub enable: bool,
895    /// Cache size
896    pub cache_size: usize,
897    /// Eviction policy
898    pub eviction_policy: CacheEvictionPolicy,
899}
900
901/// Cache eviction policies
902#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
903pub enum CacheEvictionPolicy {
904    LRU,
905    LFU,
906    FIFO,
907    Random,
908}
909
910/// Model management configuration
911#[derive(Debug, Clone, Serialize, Deserialize)]
912pub struct ModelManagementConfig {
913    /// Model versioning
914    pub versioning: ModelVersioning,
915    /// Model deployment
916    pub deployment: ModelDeployment,
917    /// Model monitoring
918    pub monitoring: ModelMonitoring,
919}
920
921/// Model versioning configuration
922#[derive(Debug, Clone, Serialize, Deserialize)]
923pub struct ModelVersioning {
924    /// Enable versioning
925    pub enable: bool,
926    /// Version control system
927    pub version_control: VersionControlSystem,
928    /// Rollback strategy
929    pub rollback: RollbackStrategy,
930}
931
932/// Version control systems
933#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
934pub enum VersionControlSystem {
935    Git,
936    MLflow,
937    DVC,
938    Custom,
939}
940
941/// Rollback strategies
942#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
943pub enum RollbackStrategy {
944    Automatic,
945    Manual,
946    PerformanceBased,
947    TimeBased,
948}
949
950/// Model deployment configuration
951#[derive(Debug, Clone, Serialize, Deserialize)]
952pub struct ModelDeployment {
953    /// Deployment strategy
954    pub strategy: DeploymentStrategy,
955    /// Environment configuration
956    pub environment: EnvironmentConfig,
957    /// Scaling configuration
958    pub scaling: ScalingConfig,
959}
960
961/// Deployment strategies
962#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
963pub enum DeploymentStrategy {
964    BlueGreen,
965    Canary,
966    RollingUpdate,
967    Shadow,
968}
969
970/// Environment configuration
971#[derive(Debug, Clone, Serialize, Deserialize)]
972pub struct EnvironmentConfig {
973    /// Environment type
974    pub environment_type: EnvironmentType,
975    /// Resource allocation
976    pub resources: ResourceAllocation,
977    /// Dependencies
978    pub dependencies: Vec<String>,
979}
980
981/// Environment types
982#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
983pub enum EnvironmentType {
984    Development,
985    Staging,
986    Production,
987    Testing,
988}
989
990/// Resource allocation for deployment
991#[derive(Debug, Clone, Serialize, Deserialize)]
992pub struct ResourceAllocation {
993    /// CPU allocation
994    pub cpu: f64,
995    /// Memory allocation
996    pub memory: usize,
997    /// GPU allocation
998    pub gpu: Option<usize>,
999}
1000
1001/// Scaling configuration
1002#[derive(Debug, Clone, Serialize, Deserialize)]
1003pub struct ScalingConfig {
1004    /// Auto-scaling
1005    pub auto_scaling: bool,
1006    /// Minimum replicas
1007    pub min_replicas: usize,
1008    /// Maximum replicas
1009    pub max_replicas: usize,
1010    /// Scaling metrics
1011    pub metrics: Vec<ScalingMetric>,
1012}
1013
1014/// Scaling metrics
1015#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1016pub enum ScalingMetric {
1017    CpuUtilization,
1018    MemoryUtilization,
1019    RequestRate,
1020    ResponseTime,
1021    Custom(String),
1022}
1023
1024/// Model monitoring configuration
1025#[derive(Debug, Clone, Serialize, Deserialize)]
1026pub struct ModelMonitoring {
1027    /// Performance monitoring
1028    pub performance: PerformanceMonitoring,
1029    /// Drift detection
1030    pub drift_detection: DriftDetection,
1031    /// Alerting
1032    pub alerting: AlertingConfig,
1033}
1034
1035/// Performance monitoring for models
1036#[derive(Debug, Clone, Serialize, Deserialize)]
1037pub struct PerformanceMonitoring {
1038    /// Metrics to monitor
1039    pub metrics: Vec<MonitoringMetric>,
1040    /// Monitoring frequency
1041    pub frequency: Duration,
1042    /// Baseline comparison
1043    pub baseline_comparison: bool,
1044}
1045
1046/// Monitoring metrics
1047#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1048pub enum MonitoringMetric {
1049    Accuracy,
1050    Precision,
1051    Recall,
1052    F1Score,
1053    Latency,
1054    Throughput,
1055}
1056
1057/// Drift detection configuration
1058#[derive(Debug, Clone, Serialize, Deserialize)]
1059pub struct DriftDetection {
1060    /// Enable drift detection
1061    pub enable: bool,
1062    /// Detection methods
1063    pub methods: Vec<DriftDetectionMethod>,
1064    /// Sensitivity
1065    pub sensitivity: f64,
1066}
1067
1068/// Alerting configuration
1069#[derive(Debug, Clone, Serialize, Deserialize)]
1070pub struct AlertingConfig {
1071    /// Alert channels
1072    pub channels: Vec<AlertChannel>,
1073    /// Alert thresholds
1074    pub thresholds: HashMap<String, f64>,
1075    /// Escalation rules
1076    pub escalation: EscalationRules,
1077}
1078
1079/// Alert channels
1080#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1081pub enum AlertChannel {
1082    Email,
1083    Slack,
1084    PagerDuty,
1085    Webhook,
1086    Dashboard,
1087}
1088
1089/// Escalation rules
1090#[derive(Debug, Clone, Serialize, Deserialize)]
1091pub struct EscalationRules {
1092    /// Escalation levels
1093    pub levels: Vec<EscalationLevel>,
1094    /// Escalation timeouts
1095    pub timeouts: HashMap<String, Duration>,
1096}
1097
1098/// Escalation level definition
1099#[derive(Debug, Clone, Serialize, Deserialize)]
1100pub struct EscalationLevel {
1101    /// Level name
1102    pub name: String,
1103    /// Threshold
1104    pub threshold: f64,
1105    /// Actions
1106    pub actions: Vec<String>,
1107}
1108
1109/// QEC monitoring configuration
1110#[derive(Debug, Clone, Serialize, Deserialize)]
1111pub struct QECMonitoringConfig {
1112    /// Enable performance tracking
1113    pub enable_performance_tracking: bool,
1114    /// Enable error analysis
1115    pub enable_error_analysis: bool,
1116    /// Enable resource monitoring
1117    pub enable_resource_monitoring: bool,
1118    /// Reporting interval
1119    pub reporting_interval: std::time::Duration,
1120    /// Enable predictive analytics
1121    pub enable_predictive_analytics: bool,
1122    /// Enable monitoring
1123    pub enable_monitoring: bool,
1124    /// Monitoring targets
1125    pub targets: Vec<MonitoringTarget>,
1126    /// Real-time dashboard
1127    pub dashboard: DashboardConfig,
1128    /// Data collection
1129    pub data_collection: DataCollectionConfig,
1130    /// Alerting system
1131    pub alerting: MonitoringAlertingConfig,
1132}
1133
1134/// Monitoring targets
1135#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1136pub enum MonitoringTarget {
1137    ErrorRates,
1138    CorrectionPerformance,
1139    ResourceUtilization,
1140    SystemHealth,
1141    UserExperience,
1142}
1143
1144/// Dashboard configuration
1145#[derive(Debug, Clone, Serialize, Deserialize)]
1146pub struct DashboardConfig {
1147    /// Enable dashboard
1148    pub enable: bool,
1149    /// Dashboard components
1150    pub components: Vec<DashboardComponent>,
1151    /// Update frequency
1152    pub update_frequency: Duration,
1153    /// Access control
1154    pub access_control: AccessControl,
1155}
1156
1157/// Dashboard components
1158#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1159pub enum DashboardComponent {
1160    RealTimeMetrics,
1161    HistoricalTrends,
1162    Alerts,
1163    SystemStatus,
1164    PerformanceGraphs,
1165}
1166
1167/// Access control for dashboard
1168#[derive(Debug, Clone, Serialize, Deserialize)]
1169pub struct AccessControl {
1170    /// Authentication required
1171    pub authentication: bool,
1172    /// User roles
1173    pub roles: Vec<UserRole>,
1174    /// Permissions
1175    pub permissions: HashMap<String, Vec<String>>,
1176}
1177
1178/// User roles
1179#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1180pub enum UserRole {
1181    Admin,
1182    Operator,
1183    Viewer,
1184    Guest,
1185}
1186
1187/// Data collection configuration
1188#[derive(Debug, Clone, Serialize, Deserialize)]
1189pub struct DataCollectionConfig {
1190    /// Collection frequency
1191    pub frequency: Duration,
1192    /// Data retention
1193    pub retention: DataRetention,
1194    /// Storage configuration
1195    pub storage: StorageConfig,
1196}
1197
1198/// Data retention configuration
1199#[derive(Debug, Clone, Serialize, Deserialize)]
1200pub struct DataRetention {
1201    /// Retention period
1202    pub period: Duration,
1203    /// Archival strategy
1204    pub archival: ArchivalStrategy,
1205    /// Compression
1206    pub compression: bool,
1207}
1208
1209/// Archival strategies
1210#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1211pub enum ArchivalStrategy {
1212    CloudStorage,
1213    LocalStorage,
1214    HybridStorage,
1215    NoArchival,
1216}
1217
1218/// Storage configuration
1219#[derive(Debug, Clone, Serialize, Deserialize)]
1220pub struct StorageConfig {
1221    /// Storage backend
1222    pub backend: StorageBackend,
1223    /// Replication factor
1224    pub replication: usize,
1225    /// Consistency level
1226    pub consistency: ConsistencyLevel,
1227}
1228
1229/// Storage backends
1230#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1231pub enum StorageBackend {
1232    FileSystem,
1233    Database,
1234    CloudStorage,
1235    DistributedStorage,
1236}
1237
1238/// Consistency levels
1239#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1240pub enum ConsistencyLevel {
1241    Eventual,
1242    Strong,
1243    Session,
1244    Bounded,
1245}
1246
1247/// Monitoring alerting configuration
1248#[derive(Debug, Clone, Serialize, Deserialize)]
1249pub struct MonitoringAlertingConfig {
1250    /// Alert rules
1251    pub rules: Vec<AlertRule>,
1252    /// Notification channels
1253    pub channels: Vec<NotificationChannel>,
1254    /// Alert suppression
1255    pub suppression: AlertSuppression,
1256}
1257
1258/// Alert rule definition
1259#[derive(Debug, Clone, Serialize, Deserialize)]
1260pub struct AlertRule {
1261    /// Rule name
1262    pub name: String,
1263    /// Condition
1264    pub condition: String,
1265    /// Severity
1266    pub severity: AlertSeverity,
1267    /// Actions
1268    pub actions: Vec<AlertAction>,
1269}
1270
1271/// Alert severity levels
1272#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1273pub enum AlertSeverity {
1274    Critical,
1275    High,
1276    Medium,
1277    Low,
1278    Info,
1279}
1280
1281/// Alert actions
1282#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1283pub enum AlertAction {
1284    Notify,
1285    Log,
1286    Execute,
1287    Escalate,
1288}
1289
1290/// Notification channels
1291#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1292pub enum NotificationChannel {
1293    Email,
1294    SMS,
1295    Slack,
1296    Teams,
1297    Webhook,
1298}
1299
1300/// Alert suppression configuration
1301#[derive(Debug, Clone, Serialize, Deserialize)]
1302pub struct AlertSuppression {
1303    /// Enable suppression
1304    pub enable: bool,
1305    /// Suppression rules
1306    pub rules: Vec<SuppressionRule>,
1307    /// Default suppression time
1308    pub default_time: Duration,
1309}
1310
1311/// Suppression rule
1312#[derive(Debug, Clone, Serialize, Deserialize)]
1313pub struct SuppressionRule {
1314    /// Rule name
1315    pub name: String,
1316    /// Condition
1317    pub condition: String,
1318    /// Suppression duration
1319    pub duration: Duration,
1320}
1321
1322/// Prediction configuration for adaptive QEC
1323#[derive(Debug, Clone, Serialize, Deserialize)]
1324pub struct PredictionConfig {
1325    /// Prediction horizon
1326    pub horizon: Duration,
1327    /// Confidence threshold
1328    pub confidence_threshold: f64,
1329}
1330
1331/// Optimization configuration for adaptive QEC
1332#[derive(Debug, Clone, Serialize, Deserialize)]
1333pub struct OptimizationConfig {
1334    /// Optimization objectives
1335    pub objectives: Vec<String>,
1336    /// Optimization constraints
1337    pub constraints: Vec<String>,
1338}
1339
1340impl Default for PredictionConfig {
1341    fn default() -> Self {
1342        Self {
1343            horizon: Duration::from_secs(60),
1344            confidence_threshold: 0.8,
1345        }
1346    }
1347}
1348
1349impl Default for OptimizationConfig {
1350    fn default() -> Self {
1351        Self {
1352            objectives: vec!["minimize_error_rate".to_string()],
1353            constraints: vec!["hardware_connectivity".to_string()],
1354        }
1355    }
1356}
quantrs2_device/qec/adaptive.rs

quantrs2_device/qec/
adaptive.rs
