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

//! Configuration types for quantum continual learning

use scirs2_core::ndarray::{Array1, Array2};
use std::collections::HashMap;

/// Continual learning strategies
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ContinualLearningStrategy {
    /// Elastic Weight Consolidation
    EWC,
    /// Synaptic Intelligence
    SI,
    /// Memory Aware Synapses
    MAS,
    /// Progressive Neural Networks
    Progressive,
    /// PackNet
    PackNet,
    /// Gradient Episodic Memory
    GEM,
    /// Averaged Gradient Episodic Memory
    AGEM,
    /// Experience Replay
    ExperienceReplay,
    /// Quantum Memory Consolidation
    QuantumMemoryConsolidation,
}

/// Memory types for continual learning
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MemoryType {
    /// Episodic memory
    Episodic,
    /// Semantic memory
    Semantic,
    /// Working memory
    Working,
    /// Quantum memory
    Quantum,
}

/// Task types
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum TaskType {
    /// Classification task
    Classification,
    /// Regression task
    Regression,
    /// Reinforcement learning task
    ReinforcementLearning,
    /// Unsupervised learning task
    Unsupervised,
    /// Quantum task
    Quantum,
}

/// Configuration for quantum continual learning
#[derive(Debug, Clone)]
pub struct QuantumContinualLearningConfig {
    /// Primary learning strategy
    pub strategy: ContinualLearningStrategy,
    /// Memory types to use
    pub memory_types: Vec<MemoryType>,
    /// Maximum number of tasks
    pub max_tasks: usize,
    /// Memory capacity
    pub memory_capacity: usize,
    /// Learning rate
    pub learning_rate: f64,
    /// Regularization strength
    pub regularization_strength: f64,
    /// Number of qubits for quantum operations
    pub num_qubits: usize,
    /// Random state for reproducibility
    pub random_state: Option<u64>,
}

/// Task configuration
#[derive(Debug, Clone)]
pub struct ContinualTask {
    /// Task identifier
    pub task_id: usize,
    /// Task type
    pub task_type: TaskType,
    /// Task name
    pub name: String,
    /// Task description
    pub description: String,
    /// Task-specific parameters
    pub parameters: HashMap<String, f64>,
}

/// Memory configuration
#[derive(Debug, Clone)]
pub struct MemoryConfig {
    /// Memory type
    pub memory_type: MemoryType,
    /// Capacity
    pub capacity: usize,
    /// Retention strategy
    pub retention_strategy: String,
    /// Quantum enhancement level
    pub quantum_enhancement: f64,
}

/// Evaluation configuration
#[derive(Debug, Clone)]
pub struct EvaluationConfig {
    /// Metrics to compute
    pub metrics: Vec<String>,
    /// Evaluation frequency
    pub eval_frequency: usize,
    /// Use validation set
    pub use_validation: bool,
    /// Forgetting measurement
    pub measure_forgetting: bool,
}

impl Default for QuantumContinualLearningConfig {
    fn default() -> Self {
        Self {
            strategy: ContinualLearningStrategy::EWC,
            memory_types: vec![MemoryType::Episodic, MemoryType::Semantic],
            max_tasks: 10,
            memory_capacity: 1000,
            learning_rate: 0.001,
            regularization_strength: 0.1,
            num_qubits: 4,
            random_state: None,
        }
    }
}