scirs2-stats 0.4.2

Statistical functions module for SciRS2 (scirs2-stats)
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

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

use scirs2_core::numeric::{Float, NumCast, One, Zero};
use scirs2_core::{parallel_ops::*, simd_ops::SimdUnifiedOps, validation::*};
use std::collections::HashMap;

use super::functions::const_f64;
use super::types::{
    AnnealingSchedule, BlockEncodingConfig, ClassicalOptimizer, ContractionStrategy,
    DataEncodingMethod, DecoherenceConfig, EntanglementType, MeasurementStrategy, NoiseModel,
    ParameterConfig, ParameterInitialization, QuantumAmplitudeEstimationConfig,
    QuantumAnnealingConfig, QuantumClusteringAlgorithm, QuantumClusteringConfig, QuantumConfig,
    QuantumFeatureMap, QuantumKernelType, QuantumLayerConfig, QuantumLayerType,
    QuantumNeuralNetworkConfig, QuantumPCAConfig, QuantumSVMConfig, QuantumTrainingConfig,
    RotationAxis, TensorNetworkConfig, TensorNetworkType, VQEAnsatz, VQEConfig,
};

impl<F> Default for QuantumConfig<F>
where
    F: Float + NumCast + Copy + std::fmt::Display,
{
    fn default() -> Self {
        Self {
            num_qubits: 10,
            circuit_depth: 5,
            qae_config: QuantumAmplitudeEstimationConfig {
                evaluation_qubits: 3,
                target_accuracy: const_f64::<F>(0.01),
                max_iterations: 100,
                use_mlae: true,
                use_iqae: false,
            },
            qpca_config: QuantumPCAConfig {
                num_components: 5,
                matrix_exp_precision: const_f64::<F>(1e-6),
                use_variational: true,
                block_encoding: BlockEncodingConfig {
                    precision: const_f64::<F>(1e-8),
                    alpha: F::one(),
                    ancilla_qubits: 2,
                },
            },
            qsvm_config: QuantumSVMConfig {
                kernel_type: QuantumKernelType::FidelityKernel,
                feature_map: QuantumFeatureMap::ZZFeatureMap {
                    repetitions: 2,
                    entanglement: EntanglementType::Linear,
                },
                c_parameter: F::one(),
                use_vqc: true,
                ansatz_layers: 3,
            },
            qclustering_config: QuantumClusteringConfig {
                algorithm: QuantumClusteringAlgorithm::QuantumKMeans,
                num_clusters: 3,
                annealing_config: QuantumAnnealingConfig {
                    annealing_schedule: AnnealingSchedule::Linear {
                        duration: const_f64::<F>(100.0),
                    },
                    num_runs: 100,
                    temperature_range: (const_f64::<F>(0.01), const_f64::<F>(10.0)),
                    use_simulated_fallback: true,
                },
                use_qaoa: false,
            },
            vqe_config: VQEConfig {
                ansatz_type: VQEAnsatz::HardwareEfficient { layers: 3 },
                optimizer: ClassicalOptimizer::COBYLA,
                tolerance: const_f64::<F>(1e-6),
                max_iterations: 1000,
                measurement_shots: 1024,
            },
            tensor_network_config: TensorNetworkConfig {
                network_type: TensorNetworkType::MPS,
                max_bond_dim: 50,
                truncation_threshold: const_f64::<F>(1e-12),
                use_gpu: false,
                contraction_strategy: ContractionStrategy::Optimal,
            },
            qnn_config: QuantumNeuralNetworkConfig {
                quantum_layers: vec![QuantumLayerConfig {
                    layer_type: QuantumLayerType::RotationLayer {
                        axes: vec![RotationAxis::Y, RotationAxis::Z],
                    },
                    num_qubits: 4,
                    parameters: ParameterConfig {
                        num_parameters: 8,
                        initialization: ParameterInitialization::Random,
                        bounds: Some((-std::f64::consts::PI, std::f64::consts::PI)),
                    },
                }],
                data_encoding: DataEncodingMethod::AngleEncoding,
                measurement_strategy: MeasurementStrategy::PauliExpectation {
                    operators: vec!["Z".to_string()],
                },
                classical_layers: vec![],
                training_config: QuantumTrainingConfig {
                    learning_rate: const_f64::<F>(0.01),
                    epochs: 100,
                    batchsize: 32,
                    use_parameter_shift: true,
                    regularization: const_f64::<F>(0.001),
                },
            },
            noise_model: NoiseModel {
                gate_errors: HashMap::new(),
                decoherence_times: DecoherenceConfig {
                    t1: const_f64::<F>(100.0),
                    t2: const_f64::<F>(50.0),
                    t2_star: const_f64::<F>(30.0),
                },
                readout_errors: const_f64::<F>(0.01),
                enable_noise: false,
            },
        }
    }
}