pub fn generate_task_sequence(
num_tasks: usize,
samples_per_task: usize,
feature_dim: usize,
) -> Vec<ContinualTask>Expand description
Helper function to generate synthetic task sequence
Examples found in repository?
examples/quantum_continual_learning.rs (line 78)
49fn ewc_demo() -> Result<()> {
50 // Create quantum model
51 let layers = vec![
52 QNNLayerType::EncodingLayer { num_features: 4 },
53 QNNLayerType::VariationalLayer { num_params: 12 },
54 QNNLayerType::EntanglementLayer {
55 connectivity: "circular".to_string(),
56 },
57 QNNLayerType::VariationalLayer { num_params: 8 },
58 QNNLayerType::MeasurementLayer {
59 measurement_basis: "computational".to_string(),
60 },
61 ];
62
63 let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
64
65 // Create EWC strategy
66 let strategy = ContinualLearningStrategy::ElasticWeightConsolidation {
67 importance_weight: 1000.0,
68 fisher_samples: 200,
69 };
70
71 let mut learner = QuantumContinualLearner::new(model, strategy);
72
73 println!(" Created EWC continual learner:");
74 println!(" - Importance weight: 1000.0");
75 println!(" - Fisher samples: 200");
76
77 // Generate task sequence
78 let tasks = generate_task_sequence(3, 100, 4);
79
80 println!("\n Learning sequence of {} tasks...", tasks.len());
81
82 let mut optimizer = Adam::new(0.001);
83 let mut task_accuracies = Vec::new();
84
85 for (i, task) in tasks.iter().enumerate() {
86 println!(" \n Training on {}...", task.task_id);
87
88 let metrics = learner.learn_task(task.clone(), &mut optimizer, 30)?;
89 task_accuracies.push(metrics.current_accuracy);
90
91 println!(" - Current accuracy: {:.3}", metrics.current_accuracy);
92
93 // Evaluate forgetting on previous tasks
94 if i > 0 {
95 let all_accuracies = learner.evaluate_all_tasks()?;
96 let avg_prev_accuracy = all_accuracies
97 .iter()
98 .take(i)
99 .map(|(_, &acc)| acc)
100 .sum::<f64>()
101 / i as f64;
102
103 println!(
104 " - Average accuracy on previous tasks: {:.3}",
105 avg_prev_accuracy
106 );
107 }
108 }
109
110 // Final evaluation
111 let forgetting_metrics = learner.get_forgetting_metrics();
112 println!("\n EWC Results:");
113 println!(
114 " - Average accuracy: {:.3}",
115 forgetting_metrics.average_accuracy
116 );
117 println!(
118 " - Forgetting measure: {:.3}",
119 forgetting_metrics.forgetting_measure
120 );
121 println!(
122 " - Continual learning score: {:.3}",
123 forgetting_metrics.continual_learning_score
124 );
125
126 Ok(())
127}
128
129/// Demonstrate Experience Replay
130fn experience_replay_demo() -> Result<()> {
131 let layers = vec![
132 QNNLayerType::EncodingLayer { num_features: 4 },
133 QNNLayerType::VariationalLayer { num_params: 8 },
134 QNNLayerType::MeasurementLayer {
135 measurement_basis: "computational".to_string(),
136 },
137 ];
138
139 let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
140
141 let strategy = ContinualLearningStrategy::ExperienceReplay {
142 buffer_size: 500,
143 replay_ratio: 0.3,
144 memory_selection: MemorySelectionStrategy::Random,
145 };
146
147 let mut learner = QuantumContinualLearner::new(model, strategy);
148
149 println!(" Created Experience Replay learner:");
150 println!(" - Buffer size: 500");
151 println!(" - Replay ratio: 30%");
152 println!(" - Selection: Random");
153
154 // Generate diverse tasks
155 let tasks = generate_diverse_tasks(4, 80, 4);
156
157 println!("\n Learning {} diverse tasks...", tasks.len());
158
159 let mut optimizer = Adam::new(0.002);
160
161 for (i, task) in tasks.iter().enumerate() {
162 println!(" \n Learning {}...", task.task_id);
163
164 let metrics = learner.learn_task(task.clone(), &mut optimizer, 25)?;
165
166 println!(" - Task accuracy: {:.3}", metrics.current_accuracy);
167
168 // Show memory buffer status
169 println!(" - Memory buffer usage: replay experiences stored");
170
171 if i > 0 {
172 let all_accuracies = learner.evaluate_all_tasks()?;
173 let retention_rate = all_accuracies.values().sum::<f64>() / all_accuracies.len() as f64;
174 println!(" - Average retention: {:.3}", retention_rate);
175 }
176 }
177
178 let final_metrics = learner.get_forgetting_metrics();
179 println!("\n Experience Replay Results:");
180 println!(
181 " - Final average accuracy: {:.3}",
182 final_metrics.average_accuracy
183 );
184 println!(
185 " - Forgetting reduction: {:.3}",
186 1.0 - final_metrics.forgetting_measure
187 );
188
189 Ok(())
190}
191
192/// Demonstrate Progressive Networks
193fn progressive_networks_demo() -> Result<()> {
194 let layers = vec![
195 QNNLayerType::EncodingLayer { num_features: 4 },
196 QNNLayerType::VariationalLayer { num_params: 6 },
197 QNNLayerType::MeasurementLayer {
198 measurement_basis: "computational".to_string(),
199 },
200 ];
201
202 let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
203
204 let strategy = ContinualLearningStrategy::ProgressiveNetworks {
205 lateral_connections: true,
206 adaptation_layers: 2,
207 };
208
209 let mut learner = QuantumContinualLearner::new(model, strategy);
210
211 println!(" Created Progressive Networks learner:");
212 println!(" - Lateral connections: enabled");
213 println!(" - Adaptation layers: 2");
214
215 // Generate related tasks for transfer learning
216 let tasks = generate_related_tasks(3, 60, 4);
217
218 println!("\n Learning {} related tasks...", tasks.len());
219
220 let mut optimizer = Adam::new(0.001);
221 let mut learning_speeds = Vec::new();
222
223 for (i, task) in tasks.iter().enumerate() {
224 println!(" \n Adding column for {}...", task.task_id);
225
226 let start_time = std::time::Instant::now();
227 let metrics = learner.learn_task(task.clone(), &mut optimizer, 20)?;
228 let learning_time = start_time.elapsed();
229
230 learning_speeds.push(learning_time);
231
232 println!(" - Task accuracy: {:.3}", metrics.current_accuracy);
233 println!(" - Learning time: {:.2?}", learning_time);
234
235 if i > 0 {
236 let speedup = learning_speeds[0].as_secs_f64() / learning_time.as_secs_f64();
237 println!(" - Learning speedup: {:.2}x", speedup);
238 }
239 }
240
241 println!("\n Progressive Networks Results:");
242 println!(" - No catastrophic forgetting (by design)");
243 println!(" - Lateral connections enable knowledge transfer");
244 println!(" - Model capacity grows with new tasks");
245
246 Ok(())
247}
248
249/// Demonstrate Learning without Forgetting
250fn lwf_demo() -> Result<()> {
251 let layers = vec![
252 QNNLayerType::EncodingLayer { num_features: 4 },
253 QNNLayerType::VariationalLayer { num_params: 10 },
254 QNNLayerType::EntanglementLayer {
255 connectivity: "circular".to_string(),
256 },
257 QNNLayerType::MeasurementLayer {
258 measurement_basis: "computational".to_string(),
259 },
260 ];
261
262 let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
263
264 let strategy = ContinualLearningStrategy::LearningWithoutForgetting {
265 distillation_weight: 0.5,
266 temperature: 3.0,
267 };
268
269 let mut learner = QuantumContinualLearner::new(model, strategy);
270
271 println!(" Created Learning without Forgetting learner:");
272 println!(" - Distillation weight: 0.5");
273 println!(" - Temperature: 3.0");
274
275 // Generate task sequence
276 let tasks = generate_task_sequence(4, 70, 4);
277
278 println!("\n Learning with knowledge distillation...");
279
280 let mut optimizer = Adam::new(0.001);
281 let mut distillation_losses = Vec::new();
282
283 for (i, task) in tasks.iter().enumerate() {
284 println!(" \n Learning {}...", task.task_id);
285
286 let metrics = learner.learn_task(task.clone(), &mut optimizer, 25)?;
287
288 println!(" - Task accuracy: {:.3}", metrics.current_accuracy);
289
290 if i > 0 {
291 // Simulate distillation loss tracking
292 let distillation_loss = 0.1 + 0.3 * fastrand::f64();
293 distillation_losses.push(distillation_loss);
294 println!(" - Distillation loss: {:.3}", distillation_loss);
295
296 let all_accuracies = learner.evaluate_all_tasks()?;
297 let stability = all_accuracies
298 .values()
299 .map(|&acc| if acc > 0.6 { 1.0 } else { 0.0 })
300 .sum::<f64>()
301 / all_accuracies.len() as f64;
302
303 println!(" - Knowledge retention: {:.1}%", stability * 100.0);
304 }
305 }
306
307 println!("\n LwF Results:");
308 println!(" - Knowledge distillation preserves previous task performance");
309 println!(" - Temperature scaling provides soft targets");
310 println!(" - Balances plasticity and stability");
311
312 Ok(())
313}