TaskGenerator

quantrs2_ml::meta_learning

Struct TaskGenerator 

Source 
pub struct TaskGenerator { /* private fields */ }
Expand description

Task generator for meta-learning experiments

Implementations§

Source§

impl TaskGenerator

Source

pub fn new(feature_dim: usize, num_classes: usize) -> Self

Create new task generator

Examples found in repository?
examples/quantum_meta_learning.rs (line 80)
49fn maml_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: 12 },
58        QNNLayerType::MeasurementLayer {
59            measurement_basis: "computational".to_string(),
60        },
61    ];
62
63    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 3)?;
64
65    // Create MAML learner
66    let algorithm = MetaLearningAlgorithm::MAML {
67        inner_steps: 5,
68        inner_lr: 0.01,
69        first_order: true, // Use first-order approximation for efficiency
70    };
71
72    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
73
74    println!("   Created MAML meta-learner:");
75    println!("   - Inner steps: 5");
76    println!("   - Inner learning rate: 0.01");
77    println!("   - Using first-order approximation");
78
79    // Generate tasks
80    let generator = TaskGenerator::new(4, 3);
81    let tasks: Vec<MetaTask> = (0..20)
82        .map(|_| generator.generate_rotation_task(30))
83        .collect();
84
85    // Meta-train
86    println!("\n   Meta-training on 20 rotation tasks...");
87    let mut optimizer = Adam::new(0.001);
88    meta_learner.meta_train(&tasks, &mut optimizer, 50, 5)?;
89
90    // Test adaptation
91    let test_task = generator.generate_rotation_task(20);
92    println!("\n   Testing adaptation to new task...");
93
94    let adapted_params = meta_learner.adapt_to_task(&test_task)?;
95    println!("   Successfully adapted to new task");
96    println!(
97        "   Parameter adaptation magnitude: {:.4}",
98        (&adapted_params - meta_learner.meta_params())
99            .mapv(f64::abs)
100            .mean()
101            .unwrap()
102    );
103
104    Ok(())
105}
106
107/// Reptile algorithm demonstration
108fn reptile_demo() -> Result<()> {
109    let layers = vec![
110        QNNLayerType::EncodingLayer { num_features: 2 },
111        QNNLayerType::VariationalLayer { num_params: 8 },
112        QNNLayerType::MeasurementLayer {
113            measurement_basis: "Pauli-Z".to_string(),
114        },
115    ];
116
117    let qnn = QuantumNeuralNetwork::new(layers, 4, 2, 2)?;
118
119    let algorithm = MetaLearningAlgorithm::Reptile {
120        inner_steps: 10,
121        inner_lr: 0.1,
122    };
123
124    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
125
126    println!("   Created Reptile meta-learner:");
127    println!("   - Inner steps: 10");
128    println!("   - Inner learning rate: 0.1");
129
130    // Generate sinusoid tasks
131    let generator = TaskGenerator::new(2, 2);
132    let tasks: Vec<MetaTask> = (0..15)
133        .map(|_| generator.generate_sinusoid_task(40))
134        .collect();
135
136    println!("\n   Meta-training on 15 sinusoid tasks...");
137    let mut optimizer = Adam::new(0.001);
138    meta_learner.meta_train(&tasks, &mut optimizer, 30, 3)?;
139
140    println!("   Reptile training complete");
141
142    // Analyze task similarities
143    println!("\n   Task parameter statistics:");
144    for (i, task) in tasks.iter().take(3).enumerate() {
145        if let Some(amplitude) = task.metadata.get("amplitude") {
146            if let Some(phase) = task.metadata.get("phase") {
147                println!("   Task {i}: amplitude={amplitude:.2}, phase={phase:.2}");
148            }
149        }
150    }
151
152    Ok(())
153}
154
155/// `ProtoMAML` demonstration
156fn protomaml_demo() -> Result<()> {
157    let layers = vec![
158        QNNLayerType::EncodingLayer { num_features: 8 },
159        QNNLayerType::VariationalLayer { num_params: 16 },
160        QNNLayerType::EntanglementLayer {
161            connectivity: "full".to_string(),
162        },
163        QNNLayerType::MeasurementLayer {
164            measurement_basis: "computational".to_string(),
165        },
166    ];
167
168    let qnn = QuantumNeuralNetwork::new(layers, 4, 8, 16)?;
169
170    let algorithm = MetaLearningAlgorithm::ProtoMAML {
171        inner_steps: 5,
172        inner_lr: 0.01,
173        proto_weight: 0.5, // Weight for prototype regularization
174    };
175
176    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
177
178    println!("   Created ProtoMAML meta-learner:");
179    println!("   - Combines MAML with prototypical networks");
180    println!("   - Prototype weight: 0.5");
181
182    // Generate classification tasks
183    let generator = TaskGenerator::new(8, 4);
184    let tasks: Vec<MetaTask> = (0..10)
185        .map(|_| generator.generate_rotation_task(50))
186        .collect();
187
188    println!("\n   Meta-training on 4-way classification tasks...");
189    let mut optimizer = Adam::new(0.001);
190    meta_learner.meta_train(&tasks, &mut optimizer, 40, 2)?;
191
192    println!("   ProtoMAML leverages both gradient-based and metric-based learning");
193
194    Ok(())
195}
196
197/// Meta-SGD demonstration
198fn metasgd_demo() -> Result<()> {
199    let layers = vec![
200        QNNLayerType::EncodingLayer { num_features: 4 },
201        QNNLayerType::VariationalLayer { num_params: 12 },
202        QNNLayerType::MeasurementLayer {
203            measurement_basis: "Pauli-XYZ".to_string(),
204        },
205    ];
206
207    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 3)?;
208
209    let algorithm = MetaLearningAlgorithm::MetaSGD { inner_steps: 3 };
210
211    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
212
213    println!("   Created Meta-SGD learner:");
214    println!("   - Learns per-parameter learning rates");
215    println!("   - Inner steps: 3");
216
217    // Generate diverse tasks
218    let generator = TaskGenerator::new(4, 3);
219    let mut tasks = Vec::new();
220
221    // Mix different task types
222    for i in 0..12 {
223        if i % 2 == 0 {
224            tasks.push(generator.generate_rotation_task(30));
225        } else {
226            tasks.push(generator.generate_sinusoid_task(30));
227        }
228    }
229
230    println!("\n   Meta-training on mixed task distribution...");
231    let mut optimizer = Adam::new(0.0005);
232    meta_learner.meta_train(&tasks, &mut optimizer, 50, 4)?;
233
234    if let Some(lr) = meta_learner.per_param_lr() {
235        println!("\n   Learned per-parameter learning rates:");
236        println!(
237            "   - Min LR: {:.4}",
238            lr.iter().copied().fold(f64::INFINITY, f64::min)
239        );
240        println!(
241            "   - Max LR: {:.4}",
242            lr.iter().copied().fold(f64::NEG_INFINITY, f64::max)
243        );
244        println!("   - Mean LR: {:.4}", lr.mean().unwrap());
245    }
246
247    Ok(())
248}
249
250/// ANIL demonstration
251fn anil_demo() -> Result<()> {
252    let layers = vec![
253        QNNLayerType::EncodingLayer { num_features: 6 },
254        QNNLayerType::VariationalLayer { num_params: 12 },
255        QNNLayerType::EntanglementLayer {
256            connectivity: "circular".to_string(),
257        },
258        QNNLayerType::VariationalLayer { num_params: 12 },
259        QNNLayerType::VariationalLayer { num_params: 6 }, // Final layer (adapted)
260        QNNLayerType::MeasurementLayer {
261            measurement_basis: "computational".to_string(),
262        },
263    ];
264
265    let qnn = QuantumNeuralNetwork::new(layers, 4, 6, 2)?;
266
267    let algorithm = MetaLearningAlgorithm::ANIL {
268        inner_steps: 10,
269        inner_lr: 0.1,
270    };
271
272    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
273
274    println!("   Created ANIL (Almost No Inner Loop) learner:");
275    println!("   - Only adapts final layer during inner loop");
276    println!("   - More parameter efficient than MAML");
277    println!("   - Inner steps: 10");
278
279    // Generate binary classification tasks
280    let generator = TaskGenerator::new(6, 2);
281    let tasks: Vec<MetaTask> = (0..15)
282        .map(|_| generator.generate_rotation_task(40))
283        .collect();
284
285    println!("\n   Meta-training on binary classification tasks...");
286    let mut optimizer = Adam::new(0.001);
287    meta_learner.meta_train(&tasks, &mut optimizer, 40, 5)?;
288
289    println!("   ANIL reduces computational cost while maintaining performance");
290
291    Ok(())
292}
293
294/// Continual meta-learning demonstration
295fn continual_meta_learning_demo() -> Result<()> {
296    let layers = vec![
297        QNNLayerType::EncodingLayer { num_features: 4 },
298        QNNLayerType::VariationalLayer { num_params: 8 },
299        QNNLayerType::MeasurementLayer {
300            measurement_basis: "computational".to_string(),
301        },
302    ];
303
304    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
305
306    let algorithm = MetaLearningAlgorithm::Reptile {
307        inner_steps: 5,
308        inner_lr: 0.05,
309    };
310
311    let meta_learner = QuantumMetaLearner::new(algorithm, qnn);
312    let mut continual_learner = ContinualMetaLearner::new(
313        meta_learner,
314        10,  // memory capacity
315        0.3, // replay ratio
316    );
317
318    println!("   Created Continual Meta-Learner:");
319    println!("   - Memory capacity: 10 tasks");
320    println!("   - Replay ratio: 30%");
321
322    // Generate sequence of tasks
323    let generator = TaskGenerator::new(4, 2);
324
325    println!("\n   Learning sequence of tasks...");
326    for i in 0..20 {
327        let task = if i < 10 {
328            generator.generate_rotation_task(30)
329        } else {
330            generator.generate_sinusoid_task(30)
331        };
332
333        continual_learner.learn_task(task)?;
334
335        if i % 5 == 4 {
336            println!(
337                "   Learned {} tasks, memory contains {} unique tasks",
338                i + 1,
339                continual_learner.memory_buffer_len()
340            );
341        }
342    }
343
344    println!("\n   Continual learning prevents catastrophic forgetting");
345
346    Ok(())
347}
348
349/// Task distribution analysis
350fn task_distribution_demo() -> Result<()> {
351    println!("   Analyzing task distributions...\n");
352
353    let generator = TaskGenerator::new(4, 3);
354
355    // Generate multiple tasks and analyze their properties
356    let mut rotation_tasks = Vec::new();
357    let mut sinusoid_tasks = Vec::new();
358
359    for _ in 0..50 {
360        rotation_tasks.push(generator.generate_rotation_task(20));
361        sinusoid_tasks.push(generator.generate_sinusoid_task(20));
362    }
363
364    // Analyze rotation tasks
365    println!("   Rotation Task Distribution:");
366    let angles: Vec<f64> = rotation_tasks
367        .iter()
368        .filter_map(|t| t.metadata.get("rotation_angle").copied())
369        .collect();
370
371    if !angles.is_empty() {
372        let mean_angle = angles.iter().sum::<f64>() / angles.len() as f64;
373        println!("   - Mean rotation angle: {mean_angle:.2} rad");
374        println!(
375            "   - Angle range: [{:.2}, {:.2}] rad",
376            angles.iter().copied().fold(f64::INFINITY, f64::min),
377            angles.iter().copied().fold(f64::NEG_INFINITY, f64::max)
378        );
379    }
380
381    // Analyze sinusoid tasks
382    println!("\n   Sinusoid Task Distribution:");
383    let amplitudes: Vec<f64> = sinusoid_tasks
384        .iter()
385        .filter_map(|t| t.metadata.get("amplitude").copied())
386        .collect();
387
388    if !amplitudes.is_empty() {
389        let mean_amp = amplitudes.iter().sum::<f64>() / amplitudes.len() as f64;
390        println!("   - Mean amplitude: {mean_amp:.2}");
391        println!(
392            "   - Amplitude range: [{:.2}, {:.2}]",
393            amplitudes.iter().copied().fold(f64::INFINITY, f64::min),
394            amplitudes.iter().copied().fold(f64::NEG_INFINITY, f64::max)
395        );
396    }
397
398    // Compare task complexities
399    println!("\n   Task Complexity Comparison:");
400    println!(
401        "   - Rotation tasks: {} training samples each",
402        rotation_tasks[0].train_data.len()
403    );
404    println!(
405        "   - Sinusoid tasks: {} training samples each",
406        sinusoid_tasks[0].train_data.len()
407    );
408    println!("   - Both use binary classification for simplicity");
409
410    Ok(())
411}
Source

pub fn generate_sinusoid_task(&self, num_samples: usize) -> MetaTask

Generate sinusoid regression task

Examples found in repository?
examples/quantum_meta_learning.rs (line 133)
108fn reptile_demo() -> Result<()> {
109    let layers = vec![
110        QNNLayerType::EncodingLayer { num_features: 2 },
111        QNNLayerType::VariationalLayer { num_params: 8 },
112        QNNLayerType::MeasurementLayer {
113            measurement_basis: "Pauli-Z".to_string(),
114        },
115    ];
116
117    let qnn = QuantumNeuralNetwork::new(layers, 4, 2, 2)?;
118
119    let algorithm = MetaLearningAlgorithm::Reptile {
120        inner_steps: 10,
121        inner_lr: 0.1,
122    };
123
124    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
125
126    println!("   Created Reptile meta-learner:");
127    println!("   - Inner steps: 10");
128    println!("   - Inner learning rate: 0.1");
129
130    // Generate sinusoid tasks
131    let generator = TaskGenerator::new(2, 2);
132    let tasks: Vec<MetaTask> = (0..15)
133        .map(|_| generator.generate_sinusoid_task(40))
134        .collect();
135
136    println!("\n   Meta-training on 15 sinusoid tasks...");
137    let mut optimizer = Adam::new(0.001);
138    meta_learner.meta_train(&tasks, &mut optimizer, 30, 3)?;
139
140    println!("   Reptile training complete");
141
142    // Analyze task similarities
143    println!("\n   Task parameter statistics:");
144    for (i, task) in tasks.iter().take(3).enumerate() {
145        if let Some(amplitude) = task.metadata.get("amplitude") {
146            if let Some(phase) = task.metadata.get("phase") {
147                println!("   Task {i}: amplitude={amplitude:.2}, phase={phase:.2}");
148            }
149        }
150    }
151
152    Ok(())
153}
154
155/// `ProtoMAML` demonstration
156fn protomaml_demo() -> Result<()> {
157    let layers = vec![
158        QNNLayerType::EncodingLayer { num_features: 8 },
159        QNNLayerType::VariationalLayer { num_params: 16 },
160        QNNLayerType::EntanglementLayer {
161            connectivity: "full".to_string(),
162        },
163        QNNLayerType::MeasurementLayer {
164            measurement_basis: "computational".to_string(),
165        },
166    ];
167
168    let qnn = QuantumNeuralNetwork::new(layers, 4, 8, 16)?;
169
170    let algorithm = MetaLearningAlgorithm::ProtoMAML {
171        inner_steps: 5,
172        inner_lr: 0.01,
173        proto_weight: 0.5, // Weight for prototype regularization
174    };
175
176    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
177
178    println!("   Created ProtoMAML meta-learner:");
179    println!("   - Combines MAML with prototypical networks");
180    println!("   - Prototype weight: 0.5");
181
182    // Generate classification tasks
183    let generator = TaskGenerator::new(8, 4);
184    let tasks: Vec<MetaTask> = (0..10)
185        .map(|_| generator.generate_rotation_task(50))
186        .collect();
187
188    println!("\n   Meta-training on 4-way classification tasks...");
189    let mut optimizer = Adam::new(0.001);
190    meta_learner.meta_train(&tasks, &mut optimizer, 40, 2)?;
191
192    println!("   ProtoMAML leverages both gradient-based and metric-based learning");
193
194    Ok(())
195}
196
197/// Meta-SGD demonstration
198fn metasgd_demo() -> Result<()> {
199    let layers = vec![
200        QNNLayerType::EncodingLayer { num_features: 4 },
201        QNNLayerType::VariationalLayer { num_params: 12 },
202        QNNLayerType::MeasurementLayer {
203            measurement_basis: "Pauli-XYZ".to_string(),
204        },
205    ];
206
207    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 3)?;
208
209    let algorithm = MetaLearningAlgorithm::MetaSGD { inner_steps: 3 };
210
211    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
212
213    println!("   Created Meta-SGD learner:");
214    println!("   - Learns per-parameter learning rates");
215    println!("   - Inner steps: 3");
216
217    // Generate diverse tasks
218    let generator = TaskGenerator::new(4, 3);
219    let mut tasks = Vec::new();
220
221    // Mix different task types
222    for i in 0..12 {
223        if i % 2 == 0 {
224            tasks.push(generator.generate_rotation_task(30));
225        } else {
226            tasks.push(generator.generate_sinusoid_task(30));
227        }
228    }
229
230    println!("\n   Meta-training on mixed task distribution...");
231    let mut optimizer = Adam::new(0.0005);
232    meta_learner.meta_train(&tasks, &mut optimizer, 50, 4)?;
233
234    if let Some(lr) = meta_learner.per_param_lr() {
235        println!("\n   Learned per-parameter learning rates:");
236        println!(
237            "   - Min LR: {:.4}",
238            lr.iter().copied().fold(f64::INFINITY, f64::min)
239        );
240        println!(
241            "   - Max LR: {:.4}",
242            lr.iter().copied().fold(f64::NEG_INFINITY, f64::max)
243        );
244        println!("   - Mean LR: {:.4}", lr.mean().unwrap());
245    }
246
247    Ok(())
248}
249
250/// ANIL demonstration
251fn anil_demo() -> Result<()> {
252    let layers = vec![
253        QNNLayerType::EncodingLayer { num_features: 6 },
254        QNNLayerType::VariationalLayer { num_params: 12 },
255        QNNLayerType::EntanglementLayer {
256            connectivity: "circular".to_string(),
257        },
258        QNNLayerType::VariationalLayer { num_params: 12 },
259        QNNLayerType::VariationalLayer { num_params: 6 }, // Final layer (adapted)
260        QNNLayerType::MeasurementLayer {
261            measurement_basis: "computational".to_string(),
262        },
263    ];
264
265    let qnn = QuantumNeuralNetwork::new(layers, 4, 6, 2)?;
266
267    let algorithm = MetaLearningAlgorithm::ANIL {
268        inner_steps: 10,
269        inner_lr: 0.1,
270    };
271
272    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
273
274    println!("   Created ANIL (Almost No Inner Loop) learner:");
275    println!("   - Only adapts final layer during inner loop");
276    println!("   - More parameter efficient than MAML");
277    println!("   - Inner steps: 10");
278
279    // Generate binary classification tasks
280    let generator = TaskGenerator::new(6, 2);
281    let tasks: Vec<MetaTask> = (0..15)
282        .map(|_| generator.generate_rotation_task(40))
283        .collect();
284
285    println!("\n   Meta-training on binary classification tasks...");
286    let mut optimizer = Adam::new(0.001);
287    meta_learner.meta_train(&tasks, &mut optimizer, 40, 5)?;
288
289    println!("   ANIL reduces computational cost while maintaining performance");
290
291    Ok(())
292}
293
294/// Continual meta-learning demonstration
295fn continual_meta_learning_demo() -> Result<()> {
296    let layers = vec![
297        QNNLayerType::EncodingLayer { num_features: 4 },
298        QNNLayerType::VariationalLayer { num_params: 8 },
299        QNNLayerType::MeasurementLayer {
300            measurement_basis: "computational".to_string(),
301        },
302    ];
303
304    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
305
306    let algorithm = MetaLearningAlgorithm::Reptile {
307        inner_steps: 5,
308        inner_lr: 0.05,
309    };
310
311    let meta_learner = QuantumMetaLearner::new(algorithm, qnn);
312    let mut continual_learner = ContinualMetaLearner::new(
313        meta_learner,
314        10,  // memory capacity
315        0.3, // replay ratio
316    );
317
318    println!("   Created Continual Meta-Learner:");
319    println!("   - Memory capacity: 10 tasks");
320    println!("   - Replay ratio: 30%");
321
322    // Generate sequence of tasks
323    let generator = TaskGenerator::new(4, 2);
324
325    println!("\n   Learning sequence of tasks...");
326    for i in 0..20 {
327        let task = if i < 10 {
328            generator.generate_rotation_task(30)
329        } else {
330            generator.generate_sinusoid_task(30)
331        };
332
333        continual_learner.learn_task(task)?;
334
335        if i % 5 == 4 {
336            println!(
337                "   Learned {} tasks, memory contains {} unique tasks",
338                i + 1,
339                continual_learner.memory_buffer_len()
340            );
341        }
342    }
343
344    println!("\n   Continual learning prevents catastrophic forgetting");
345
346    Ok(())
347}
348
349/// Task distribution analysis
350fn task_distribution_demo() -> Result<()> {
351    println!("   Analyzing task distributions...\n");
352
353    let generator = TaskGenerator::new(4, 3);
354
355    // Generate multiple tasks and analyze their properties
356    let mut rotation_tasks = Vec::new();
357    let mut sinusoid_tasks = Vec::new();
358
359    for _ in 0..50 {
360        rotation_tasks.push(generator.generate_rotation_task(20));
361        sinusoid_tasks.push(generator.generate_sinusoid_task(20));
362    }
363
364    // Analyze rotation tasks
365    println!("   Rotation Task Distribution:");
366    let angles: Vec<f64> = rotation_tasks
367        .iter()
368        .filter_map(|t| t.metadata.get("rotation_angle").copied())
369        .collect();
370
371    if !angles.is_empty() {
372        let mean_angle = angles.iter().sum::<f64>() / angles.len() as f64;
373        println!("   - Mean rotation angle: {mean_angle:.2} rad");
374        println!(
375            "   - Angle range: [{:.2}, {:.2}] rad",
376            angles.iter().copied().fold(f64::INFINITY, f64::min),
377            angles.iter().copied().fold(f64::NEG_INFINITY, f64::max)
378        );
379    }
380
381    // Analyze sinusoid tasks
382    println!("\n   Sinusoid Task Distribution:");
383    let amplitudes: Vec<f64> = sinusoid_tasks
384        .iter()
385        .filter_map(|t| t.metadata.get("amplitude").copied())
386        .collect();
387
388    if !amplitudes.is_empty() {
389        let mean_amp = amplitudes.iter().sum::<f64>() / amplitudes.len() as f64;
390        println!("   - Mean amplitude: {mean_amp:.2}");
391        println!(
392            "   - Amplitude range: [{:.2}, {:.2}]",
393            amplitudes.iter().copied().fold(f64::INFINITY, f64::min),
394            amplitudes.iter().copied().fold(f64::NEG_INFINITY, f64::max)
395        );
396    }
397
398    // Compare task complexities
399    println!("\n   Task Complexity Comparison:");
400    println!(
401        "   - Rotation tasks: {} training samples each",
402        rotation_tasks[0].train_data.len()
403    );
404    println!(
405        "   - Sinusoid tasks: {} training samples each",
406        sinusoid_tasks[0].train_data.len()
407    );
408    println!("   - Both use binary classification for simplicity");
409
410    Ok(())
411}
Source

pub fn generate_rotation_task(&self, num_samples: usize) -> MetaTask

Generate classification task with rotated features

Examples found in repository?
examples/quantum_meta_learning.rs (line 82)
49fn maml_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: 12 },
58        QNNLayerType::MeasurementLayer {
59            measurement_basis: "computational".to_string(),
60        },
61    ];
62
63    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 3)?;
64
65    // Create MAML learner
66    let algorithm = MetaLearningAlgorithm::MAML {
67        inner_steps: 5,
68        inner_lr: 0.01,
69        first_order: true, // Use first-order approximation for efficiency
70    };
71
72    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
73
74    println!("   Created MAML meta-learner:");
75    println!("   - Inner steps: 5");
76    println!("   - Inner learning rate: 0.01");
77    println!("   - Using first-order approximation");
78
79    // Generate tasks
80    let generator = TaskGenerator::new(4, 3);
81    let tasks: Vec<MetaTask> = (0..20)
82        .map(|_| generator.generate_rotation_task(30))
83        .collect();
84
85    // Meta-train
86    println!("\n   Meta-training on 20 rotation tasks...");
87    let mut optimizer = Adam::new(0.001);
88    meta_learner.meta_train(&tasks, &mut optimizer, 50, 5)?;
89
90    // Test adaptation
91    let test_task = generator.generate_rotation_task(20);
92    println!("\n   Testing adaptation to new task...");
93
94    let adapted_params = meta_learner.adapt_to_task(&test_task)?;
95    println!("   Successfully adapted to new task");
96    println!(
97        "   Parameter adaptation magnitude: {:.4}",
98        (&adapted_params - meta_learner.meta_params())
99            .mapv(f64::abs)
100            .mean()
101            .unwrap()
102    );
103
104    Ok(())
105}
106
107/// Reptile algorithm demonstration
108fn reptile_demo() -> Result<()> {
109    let layers = vec![
110        QNNLayerType::EncodingLayer { num_features: 2 },
111        QNNLayerType::VariationalLayer { num_params: 8 },
112        QNNLayerType::MeasurementLayer {
113            measurement_basis: "Pauli-Z".to_string(),
114        },
115    ];
116
117    let qnn = QuantumNeuralNetwork::new(layers, 4, 2, 2)?;
118
119    let algorithm = MetaLearningAlgorithm::Reptile {
120        inner_steps: 10,
121        inner_lr: 0.1,
122    };
123
124    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
125
126    println!("   Created Reptile meta-learner:");
127    println!("   - Inner steps: 10");
128    println!("   - Inner learning rate: 0.1");
129
130    // Generate sinusoid tasks
131    let generator = TaskGenerator::new(2, 2);
132    let tasks: Vec<MetaTask> = (0..15)
133        .map(|_| generator.generate_sinusoid_task(40))
134        .collect();
135
136    println!("\n   Meta-training on 15 sinusoid tasks...");
137    let mut optimizer = Adam::new(0.001);
138    meta_learner.meta_train(&tasks, &mut optimizer, 30, 3)?;
139
140    println!("   Reptile training complete");
141
142    // Analyze task similarities
143    println!("\n   Task parameter statistics:");
144    for (i, task) in tasks.iter().take(3).enumerate() {
145        if let Some(amplitude) = task.metadata.get("amplitude") {
146            if let Some(phase) = task.metadata.get("phase") {
147                println!("   Task {i}: amplitude={amplitude:.2}, phase={phase:.2}");
148            }
149        }
150    }
151
152    Ok(())
153}
154
155/// `ProtoMAML` demonstration
156fn protomaml_demo() -> Result<()> {
157    let layers = vec![
158        QNNLayerType::EncodingLayer { num_features: 8 },
159        QNNLayerType::VariationalLayer { num_params: 16 },
160        QNNLayerType::EntanglementLayer {
161            connectivity: "full".to_string(),
162        },
163        QNNLayerType::MeasurementLayer {
164            measurement_basis: "computational".to_string(),
165        },
166    ];
167
168    let qnn = QuantumNeuralNetwork::new(layers, 4, 8, 16)?;
169
170    let algorithm = MetaLearningAlgorithm::ProtoMAML {
171        inner_steps: 5,
172        inner_lr: 0.01,
173        proto_weight: 0.5, // Weight for prototype regularization
174    };
175
176    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
177
178    println!("   Created ProtoMAML meta-learner:");
179    println!("   - Combines MAML with prototypical networks");
180    println!("   - Prototype weight: 0.5");
181
182    // Generate classification tasks
183    let generator = TaskGenerator::new(8, 4);
184    let tasks: Vec<MetaTask> = (0..10)
185        .map(|_| generator.generate_rotation_task(50))
186        .collect();
187
188    println!("\n   Meta-training on 4-way classification tasks...");
189    let mut optimizer = Adam::new(0.001);
190    meta_learner.meta_train(&tasks, &mut optimizer, 40, 2)?;
191
192    println!("   ProtoMAML leverages both gradient-based and metric-based learning");
193
194    Ok(())
195}
196
197/// Meta-SGD demonstration
198fn metasgd_demo() -> Result<()> {
199    let layers = vec![
200        QNNLayerType::EncodingLayer { num_features: 4 },
201        QNNLayerType::VariationalLayer { num_params: 12 },
202        QNNLayerType::MeasurementLayer {
203            measurement_basis: "Pauli-XYZ".to_string(),
204        },
205    ];
206
207    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 3)?;
208
209    let algorithm = MetaLearningAlgorithm::MetaSGD { inner_steps: 3 };
210
211    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
212
213    println!("   Created Meta-SGD learner:");
214    println!("   - Learns per-parameter learning rates");
215    println!("   - Inner steps: 3");
216
217    // Generate diverse tasks
218    let generator = TaskGenerator::new(4, 3);
219    let mut tasks = Vec::new();
220
221    // Mix different task types
222    for i in 0..12 {
223        if i % 2 == 0 {
224            tasks.push(generator.generate_rotation_task(30));
225        } else {
226            tasks.push(generator.generate_sinusoid_task(30));
227        }
228    }
229
230    println!("\n   Meta-training on mixed task distribution...");
231    let mut optimizer = Adam::new(0.0005);
232    meta_learner.meta_train(&tasks, &mut optimizer, 50, 4)?;
233
234    if let Some(lr) = meta_learner.per_param_lr() {
235        println!("\n   Learned per-parameter learning rates:");
236        println!(
237            "   - Min LR: {:.4}",
238            lr.iter().copied().fold(f64::INFINITY, f64::min)
239        );
240        println!(
241            "   - Max LR: {:.4}",
242            lr.iter().copied().fold(f64::NEG_INFINITY, f64::max)
243        );
244        println!("   - Mean LR: {:.4}", lr.mean().unwrap());
245    }
246
247    Ok(())
248}
249
250/// ANIL demonstration
251fn anil_demo() -> Result<()> {
252    let layers = vec![
253        QNNLayerType::EncodingLayer { num_features: 6 },
254        QNNLayerType::VariationalLayer { num_params: 12 },
255        QNNLayerType::EntanglementLayer {
256            connectivity: "circular".to_string(),
257        },
258        QNNLayerType::VariationalLayer { num_params: 12 },
259        QNNLayerType::VariationalLayer { num_params: 6 }, // Final layer (adapted)
260        QNNLayerType::MeasurementLayer {
261            measurement_basis: "computational".to_string(),
262        },
263    ];
264
265    let qnn = QuantumNeuralNetwork::new(layers, 4, 6, 2)?;
266
267    let algorithm = MetaLearningAlgorithm::ANIL {
268        inner_steps: 10,
269        inner_lr: 0.1,
270    };
271
272    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);
273
274    println!("   Created ANIL (Almost No Inner Loop) learner:");
275    println!("   - Only adapts final layer during inner loop");
276    println!("   - More parameter efficient than MAML");
277    println!("   - Inner steps: 10");
278
279    // Generate binary classification tasks
280    let generator = TaskGenerator::new(6, 2);
281    let tasks: Vec<MetaTask> = (0..15)
282        .map(|_| generator.generate_rotation_task(40))
283        .collect();
284
285    println!("\n   Meta-training on binary classification tasks...");
286    let mut optimizer = Adam::new(0.001);
287    meta_learner.meta_train(&tasks, &mut optimizer, 40, 5)?;
288
289    println!("   ANIL reduces computational cost while maintaining performance");
290
291    Ok(())
292}
293
294/// Continual meta-learning demonstration
295fn continual_meta_learning_demo() -> Result<()> {
296    let layers = vec![
297        QNNLayerType::EncodingLayer { num_features: 4 },
298        QNNLayerType::VariationalLayer { num_params: 8 },
299        QNNLayerType::MeasurementLayer {
300            measurement_basis: "computational".to_string(),
301        },
302    ];
303
304    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
305
306    let algorithm = MetaLearningAlgorithm::Reptile {
307        inner_steps: 5,
308        inner_lr: 0.05,
309    };
310
311    let meta_learner = QuantumMetaLearner::new(algorithm, qnn);
312    let mut continual_learner = ContinualMetaLearner::new(
313        meta_learner,
314        10,  // memory capacity
315        0.3, // replay ratio
316    );
317
318    println!("   Created Continual Meta-Learner:");
319    println!("   - Memory capacity: 10 tasks");
320    println!("   - Replay ratio: 30%");
321
322    // Generate sequence of tasks
323    let generator = TaskGenerator::new(4, 2);
324
325    println!("\n   Learning sequence of tasks...");
326    for i in 0..20 {
327        let task = if i < 10 {
328            generator.generate_rotation_task(30)
329        } else {
330            generator.generate_sinusoid_task(30)
331        };
332
333        continual_learner.learn_task(task)?;
334
335        if i % 5 == 4 {
336            println!(
337                "   Learned {} tasks, memory contains {} unique tasks",
338                i + 1,
339                continual_learner.memory_buffer_len()
340            );
341        }
342    }
343
344    println!("\n   Continual learning prevents catastrophic forgetting");
345
346    Ok(())
347}
348
349/// Task distribution analysis
350fn task_distribution_demo() -> Result<()> {
351    println!("   Analyzing task distributions...\n");
352
353    let generator = TaskGenerator::new(4, 3);
354
355    // Generate multiple tasks and analyze their properties
356    let mut rotation_tasks = Vec::new();
357    let mut sinusoid_tasks = Vec::new();
358
359    for _ in 0..50 {
360        rotation_tasks.push(generator.generate_rotation_task(20));
361        sinusoid_tasks.push(generator.generate_sinusoid_task(20));
362    }
363
364    // Analyze rotation tasks
365    println!("   Rotation Task Distribution:");
366    let angles: Vec<f64> = rotation_tasks
367        .iter()
368        .filter_map(|t| t.metadata.get("rotation_angle").copied())
369        .collect();
370
371    if !angles.is_empty() {
372        let mean_angle = angles.iter().sum::<f64>() / angles.len() as f64;
373        println!("   - Mean rotation angle: {mean_angle:.2} rad");
374        println!(
375            "   - Angle range: [{:.2}, {:.2}] rad",
376            angles.iter().copied().fold(f64::INFINITY, f64::min),
377            angles.iter().copied().fold(f64::NEG_INFINITY, f64::max)
378        );
379    }
380
381    // Analyze sinusoid tasks
382    println!("\n   Sinusoid Task Distribution:");
383    let amplitudes: Vec<f64> = sinusoid_tasks
384        .iter()
385        .filter_map(|t| t.metadata.get("amplitude").copied())
386        .collect();
387
388    if !amplitudes.is_empty() {
389        let mean_amp = amplitudes.iter().sum::<f64>() / amplitudes.len() as f64;
390        println!("   - Mean amplitude: {mean_amp:.2}");
391        println!(
392            "   - Amplitude range: [{:.2}, {:.2}]",
393            amplitudes.iter().copied().fold(f64::INFINITY, f64::min),
394            amplitudes.iter().copied().fold(f64::NEG_INFINITY, f64::max)
395        );
396    }
397
398    // Compare task complexities
399    println!("\n   Task Complexity Comparison:");
400    println!(
401        "   - Rotation tasks: {} training samples each",
402        rotation_tasks[0].train_data.len()
403    );
404    println!(
405        "   - Sinusoid tasks: {} training samples each",
406        sinusoid_tasks[0].train_data.len()
407    );
408    println!("   - Both use binary classification for simplicity");
409
410    Ok(())
411}

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

Source§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
Source§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
Source§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
Source§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V