quantrs2-device 0.1.3

Quantum device connectors for the QuantRS2 framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! # AdvancedBenchmarkConfig - Trait Implementations
//!
//! This module contains trait implementations for `AdvancedBenchmarkConfig`.
//!
//! ## Implemented Traits
//!
//! - `Default`
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use crate::benchmarking::BenchmarkConfig;
use quantrs2_circuit::prelude::*;
use scirs2_core::random::prelude::*;
use std::collections::{BTreeMap, HashMap, VecDeque};
use std::time::{Duration, Instant, SystemTime};

use super::types::{
    AdvancedBenchmarkConfig, AdvancedStatsConfig, AnomalyDetectionConfig, AnomalyDetectionMethod,
    BenchmarkOptimizationConfig, BootstrapConfig, BootstrapMethod, ConstraintMethod,
    FeatureEngineeringConfig, FeatureSelectionMethod, LinearRegression, MLBenchmarkConfig,
    MLModelType, MLTrainingConfig, MultiObjectiveConfig, NotificationChannel, NotificationConfig,
    OptimizationAlgorithm, OptimizationObjective, PermutationConfig, PredictiveModelingConfig,
    RealtimeBenchmarkConfig, RetrainTrigger, SmoothingParams, TimeSeriesConfig,
};

impl Default for AdvancedBenchmarkConfig {
    fn default() -> Self {
        Self {
            base_config: BenchmarkConfig::default(),
            ml_config: MLBenchmarkConfig {
                enable_adaptive_selection: true,
                enable_prediction: true,
                enable_clustering: true,
                model_types: vec![
                    MLModelType::LinearRegression,
                    MLModelType::RandomForest { n_estimators: 100 },
                    MLModelType::GradientBoosting {
                        n_estimators: 100,
                        learning_rate: 0.1,
                    },
                ],
                training_config: MLTrainingConfig {
                    test_size: 0.2,
                    cv_folds: 5,
                    random_state: Some(42),
                    enable_hyperparameter_tuning: true,
                    grid_search_params: HashMap::new(),
                },
                feature_config: FeatureEngineeringConfig {
                    enable_polynomial_features: true,
                    polynomial_degree: 2,
                    enable_interactions: true,
                    enable_feature_selection: true,
                    selection_method: FeatureSelectionMethod::UnivariateSelection { k_best: 10 },
                },
            },
            realtime_config: RealtimeBenchmarkConfig {
                enable_realtime: true,
                monitoring_interval: Duration::from_secs(60),
                enable_adaptive_thresholds: true,
                degradation_threshold: 0.05,
                retrain_triggers: vec![
                    RetrainTrigger::PerformanceDegradation { threshold: 0.1 },
                    RetrainTrigger::TimeBasedInterval {
                        interval: Duration::from_secs(3600),
                    },
                ],
                notification_config: NotificationConfig {
                    enable_alerts: true,
                    alert_thresholds: HashMap::new(),
                    channels: vec![NotificationChannel::Log {
                        level: "INFO".to_string(),
                    }],
                },
            },
            prediction_config: PredictiveModelingConfig {
                enable_prediction: true,
                prediction_horizon: 10,
                time_series_config: TimeSeriesConfig {
                    enable_trend: true,
                    enable_seasonality: true,
                    seasonality_period: 24,
                    enable_changepoint: true,
                    smoothing_params: SmoothingParams {
                        alpha: 0.3,
                        beta: 0.1,
                        gamma: 0.1,
                    },
                },
                confidence_level: 0.95,
                enable_uncertainty: true,
            },
            anomaly_config: AnomalyDetectionConfig {
                enable_detection: true,
                methods: vec![
                    AnomalyDetectionMethod::IsolationForest { contamination: 0.1 },
                    AnomalyDetectionMethod::StatisticalOutliers { threshold: 3.0 },
                ],
                sensitivity: 0.1,
                window_size: 100,
                enable_realtime: true,
            },
            advanced_stats_config: AdvancedStatsConfig {
                enable_bayesian: true,
                enable_multivariate: true,
                enable_nonparametric: true,
                enable_robust: true,
                bootstrap_config: BootstrapConfig {
                    n_bootstrap: 1000,
                    confidence_level: 0.95,
                    method: BootstrapMethod::Percentile,
                },
                permutation_config: PermutationConfig {
                    n_permutations: 1000,
                    test_statistics: vec!["mean".to_string(), "median".to_string()],
                },
            },
            optimization_config: BenchmarkOptimizationConfig {
                enable_optimization: true,
                objectives: vec![
                    OptimizationObjective::MaximizeFidelity,
                    OptimizationObjective::MinimizeExecutionTime,
                ],
                algorithms: vec![
                    OptimizationAlgorithm::GradientDescent,
                    OptimizationAlgorithm::ParticleSwarm,
                ],
                multi_objective_config: MultiObjectiveConfig {
                    enable_pareto: true,
                    weights: HashMap::new(),
                    constraint_method: ConstraintMethod::PenaltyFunction,
                },
            },
        }
    }
}