quantrs2-ml 0.1.3

Quantum Machine Learning module for QuantRS2
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
137

//! Optimization Objectives
//!
//! This module defines optimization objectives and multi-objective optimization configurations.

/// Optimization objectives
#[derive(Debug, Clone)]
pub enum OptimizationObjective {
    /// Maximize accuracy/performance
    MaximizeAccuracy { weight: f64 },

    /// Minimize model complexity
    MinimizeComplexity { weight: f64 },

    /// Minimize quantum resource usage
    MinimizeQuantumResources { weight: f64 },

    /// Maximize quantum advantage
    MaximizeQuantumAdvantage { weight: f64 },

    /// Minimize inference time
    MinimizeInferenceTime { weight: f64 },

    /// Minimize training time
    MinimizeTrainingTime { weight: f64 },

    /// Maximize robustness
    MaximizeRobustness { weight: f64 },

    /// Maximize interpretability
    MaximizeInterpretability { weight: f64 },
}

impl OptimizationObjective {
    /// Get the weight of this objective
    pub fn weight(&self) -> f64 {
        match self {
            OptimizationObjective::MaximizeAccuracy { weight } => *weight,
            OptimizationObjective::MinimizeComplexity { weight } => *weight,
            OptimizationObjective::MinimizeQuantumResources { weight } => *weight,
            OptimizationObjective::MaximizeQuantumAdvantage { weight } => *weight,
            OptimizationObjective::MinimizeInferenceTime { weight } => *weight,
            OptimizationObjective::MinimizeTrainingTime { weight } => *weight,
            OptimizationObjective::MaximizeRobustness { weight } => *weight,
            OptimizationObjective::MaximizeInterpretability { weight } => *weight,
        }
    }

    /// Check if this is a maximization objective
    pub fn is_maximization(&self) -> bool {
        matches!(
            self,
            OptimizationObjective::MaximizeAccuracy { .. }
                | OptimizationObjective::MaximizeQuantumAdvantage { .. }
                | OptimizationObjective::MaximizeRobustness { .. }
                | OptimizationObjective::MaximizeInterpretability { .. }
        )
    }

    /// Get the objective name
    pub fn name(&self) -> &'static str {
        match self {
            OptimizationObjective::MaximizeAccuracy { .. } => "accuracy",
            OptimizationObjective::MinimizeComplexity { .. } => "complexity",
            OptimizationObjective::MinimizeQuantumResources { .. } => "quantum_resources",
            OptimizationObjective::MaximizeQuantumAdvantage { .. } => "quantum_advantage",
            OptimizationObjective::MinimizeInferenceTime { .. } => "inference_time",
            OptimizationObjective::MinimizeTrainingTime { .. } => "training_time",
            OptimizationObjective::MaximizeRobustness { .. } => "robustness",
            OptimizationObjective::MaximizeInterpretability { .. } => "interpretability",
        }
    }
}

/// Common objective configurations
impl OptimizationObjective {
    /// Single accuracy objective
    pub fn accuracy_only() -> Vec<Self> {
        vec![OptimizationObjective::MaximizeAccuracy { weight: 1.0 }]
    }

    /// Balanced accuracy and efficiency
    pub fn balanced() -> Vec<Self> {
        vec![
            OptimizationObjective::MaximizeAccuracy { weight: 0.5 },
            OptimizationObjective::MinimizeInferenceTime { weight: 0.3 },
            OptimizationObjective::MinimizeComplexity { weight: 0.2 },
        ]
    }

    /// Quantum-focused objectives
    pub fn quantum_focused() -> Vec<Self> {
        vec![
            OptimizationObjective::MaximizeQuantumAdvantage { weight: 0.5 },
            OptimizationObjective::MaximizeAccuracy { weight: 0.3 },
            OptimizationObjective::MinimizeQuantumResources { weight: 0.2 },
        ]
    }

    /// Production-ready objectives
    pub fn production() -> Vec<Self> {
        vec![
            OptimizationObjective::MaximizeAccuracy { weight: 0.4 },
            OptimizationObjective::MaximizeRobustness { weight: 0.3 },
            OptimizationObjective::MinimizeInferenceTime { weight: 0.2 },
            OptimizationObjective::MaximizeInterpretability { weight: 0.1 },
        ]
    }

    /// Research objectives
    pub fn research() -> Vec<Self> {
        vec![
            OptimizationObjective::MaximizeQuantumAdvantage { weight: 0.4 },
            OptimizationObjective::MaximizeAccuracy { weight: 0.3 },
            OptimizationObjective::MaximizeInterpretability { weight: 0.2 },
            OptimizationObjective::MinimizeComplexity { weight: 0.1 },
        ]
    }

    /// Fast inference objectives
    pub fn fast_inference() -> Vec<Self> {
        vec![
            OptimizationObjective::MinimizeInferenceTime { weight: 0.5 },
            OptimizationObjective::MaximizeAccuracy { weight: 0.3 },
            OptimizationObjective::MinimizeComplexity { weight: 0.2 },
        ]
    }

    /// Resource-constrained objectives
    pub fn resource_constrained() -> Vec<Self> {
        vec![
            OptimizationObjective::MinimizeQuantumResources { weight: 0.4 },
            OptimizationObjective::MaximizeAccuracy { weight: 0.3 },
            OptimizationObjective::MinimizeComplexity { weight: 0.2 },
            OptimizationObjective::MinimizeTrainingTime { weight: 0.1 },
        ]
    }
}