Struct Adam 

pub struct Adam { /* private fields */ }

Adam optimizer

Implementations

impl Adam

pub fn new(learning_rate: f64) -> Self

Examples found in repository

examples/few_shot_learning.rs (line 114)

fn test_prototypical_networks(
    data: &Array2<f64>,
    labels: &Array1<usize>,
    qnn: QuantumNeuralNetwork,
) -> Result<()> {
    let mut learner = FewShotLearner::new(FewShotMethod::PrototypicalNetworks, qnn);

    // Generate episodes for training
    let num_episodes = 10;
    let mut episodes = Vec::new();

    for _ in 0..num_episodes {
        let episode = FewShotLearner::generate_episode(
            data, labels, 5, // 5-way
            3, // 3-shot
            5, // 5 query examples per class
        )?;
        episodes.push(episode);
    }

    // Train
    let mut optimizer = Adam::new(0.01);
    let accuracies = learner.train(&episodes, &mut optimizer, 20)?;

    // Print results
    println!("   Training completed:");
    println!("   - Initial accuracy: {:.2}%", accuracies[0] * 100.0);
    println!(
        "   - Final accuracy: {:.2}%",
        accuracies.last().unwrap() * 100.0
    );
    println!(
        "   - Improvement: {:.2}%",
        (accuracies.last().unwrap() - accuracies[0]) * 100.0
    );

    Ok(())
}

/// Test MAML
fn test_maml(data: &Array2<f64>, labels: &Array1<usize>, qnn: QuantumNeuralNetwork) -> Result<()> {
    let mut learner = FewShotLearner::new(
        FewShotMethod::MAML {
            inner_steps: 5,
            inner_lr: 0.01,
        },
        qnn,
    );

    // Generate meta-training tasks
    let num_tasks = 20;
    let mut tasks = Vec::new();

    for _ in 0..num_tasks {
        let task = FewShotLearner::generate_episode(
            data, labels, 3, // 3-way (fewer classes for MAML)
            5, // 5-shot
            5, // 5 query examples
        )?;
        tasks.push(task);
    }

    // Meta-train
    let mut meta_optimizer = Adam::new(0.001);
    let losses = learner.train(&tasks, &mut meta_optimizer, 10)?;

    println!("   Meta-training completed:");
    println!("   - Initial loss: {:.4}", losses[0]);
    println!("   - Final loss: {:.4}", losses.last().unwrap());
    println!(
        "   - Convergence rate: {:.2}%",
        (1.0 - losses.last().unwrap() / losses[0]) * 100.0
    );

    Ok(())
}

/// Compare performance across different K-shot values
fn compare_shot_performance(
    data: &Array2<f64>,
    labels: &Array1<usize>,
    qnn: QuantumNeuralNetwork,
) -> Result<()> {
    let k_values = vec![1, 3, 5, 10];

    for k in k_values {
        println!("\n   Testing {k}-shot learning:");

        let mut learner = FewShotLearner::new(FewShotMethod::PrototypicalNetworks, qnn.clone());

        // Generate episodes
        let mut episodes = Vec::new();
        for _ in 0..5 {
            let episode = FewShotLearner::generate_episode(
                data, labels, 3, // 3-way
                k, // k-shot
                5, // 5 query
            )?;
            episodes.push(episode);
        }

        // Quick training
        let mut optimizer = Adam::new(0.01);
        let accuracies = learner.train(&episodes, &mut optimizer, 10)?;

        println!(
            "     Final accuracy: {:.2}%",
            accuracies.last().unwrap() * 100.0
        );
    }

    Ok(())
}

examples/quantum_diffusion.rs (line 116)

fn train_diffusion_model() -> Result<()> {
    // Generate synthetic 2D data (two moons)
    let num_samples = 200;
    let data = generate_two_moons(num_samples);

    println!("   Generated {num_samples} samples of 2D two-moons data");

    // Create diffusion model
    let mut model = QuantumDiffusionModel::new(
        2,  // data dimension
        4,  // num qubits
        50, // timesteps
        NoiseSchedule::Cosine { s: 0.008 },
    )?;

    println!("   Created quantum diffusion model:");
    println!("   - Data dimension: 2");
    println!("   - Qubits: 4");
    println!("   - Timesteps: 50");
    println!("   - Schedule: Cosine");

    // Train model
    let mut optimizer = Adam::new(0.001);
    let epochs = 100;
    let batch_size = 32;

    println!("\n   Training for {epochs} epochs...");
    let losses = model.train(&data, &mut optimizer, epochs, batch_size)?;

    // Print training statistics
    println!("\n   Training Statistics:");
    println!("   - Initial loss: {:.4}", losses[0]);
    println!("   - Final loss: {:.4}", losses.last().unwrap());
    println!(
        "   - Improvement: {:.2}%",
        (1.0 - losses.last().unwrap() / losses[0]) * 100.0
    );

    Ok(())
}

examples/continuous_rl.rs (line 97)

fn train_qddpg_pendulum() -> Result<()> {
    let state_dim = 3;
    let action_dim = 1;
    let action_bounds = vec![(-2.0, 2.0)];
    let num_qubits = 4;
    let buffer_capacity = 10000;

    // Create QDDPG agent
    let mut agent = QuantumDDPG::new(
        state_dim,
        action_dim,
        action_bounds,
        num_qubits,
        buffer_capacity,
    )?;

    // Create environment
    let mut env = PendulumEnvironment::new();

    // Create optimizers
    let mut actor_optimizer = Adam::new(0.001);
    let mut critic_optimizer = Adam::new(0.001);

    // Train for a few episodes (reduced for demo)
    let episodes = 50;
    println!("   Training QDDPG for {episodes} episodes...");

    let rewards = agent.train(
        &mut env,
        episodes,
        &mut actor_optimizer,
        &mut critic_optimizer,
    )?;

    // Print training statistics
    let avg_initial = rewards[..10].iter().sum::<f64>() / 10.0;
    let avg_final = rewards[rewards.len() - 10..].iter().sum::<f64>() / 10.0;

    println!("\n   Training Statistics:");
    println!("   - Average initial reward: {avg_initial:.2}");
    println!("   - Average final reward: {avg_final:.2}");
    println!("   - Improvement: {:.2}", avg_final - avg_initial);

    // Test trained agent
    println!("\n   Testing trained agent...");
    test_trained_agent(&agent, &mut env)?;

    Ok(())
}

examples/quantum_meta_learning.rs (line 94)

fn maml_demo() -> Result<()> {
    // Create quantum model
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 12 },
        QNNLayerType::EntanglementLayer {
            connectivity: "circular".to_string(),
        },
        QNNLayerType::VariationalLayer { num_params: 12 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 3)?;

    // Create MAML learner
    let algorithm = MetaLearningAlgorithm::MAML {
        inner_steps: 5,
        inner_lr: 0.01,
        first_order: true, // Use first-order approximation for efficiency
    };

    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);

    println!("   Created MAML meta-learner:");
    println!("   - Inner steps: 5");
    println!("   - Inner learning rate: 0.01");
    println!("   - Using first-order approximation");

    // Generate tasks
    let generator = TaskGenerator::new(4, 3);
    let tasks: Vec<MetaTask> = (0..20)
        .map(|_| generator.generate_rotation_task(30))
        .collect();

    // Meta-train
    println!("\n   Meta-training on 20 rotation tasks...");
    let mut optimizer = Adam::new(0.001);
    meta_learner.meta_train(&tasks, &mut optimizer, 50, 5)?;

    // Test adaptation
    let test_task = generator.generate_rotation_task(20);
    println!("\n   Testing adaptation to new task...");

    let adapted_params = meta_learner.adapt_to_task(&test_task)?;
    println!("   Successfully adapted to new task");
    println!(
        "   Parameter adaptation magnitude: {:.4}",
        (&adapted_params - meta_learner.meta_params())
            .mapv(f64::abs)
            .mean()
            .unwrap()
    );

    Ok(())
}

/// Reptile algorithm demonstration
fn reptile_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 2 },
        QNNLayerType::VariationalLayer { num_params: 8 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "Pauli-Z".to_string(),
        },
    ];

    let qnn = QuantumNeuralNetwork::new(layers, 4, 2, 2)?;

    let algorithm = MetaLearningAlgorithm::Reptile {
        inner_steps: 10,
        inner_lr: 0.1,
    };

    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);

    println!("   Created Reptile meta-learner:");
    println!("   - Inner steps: 10");
    println!("   - Inner learning rate: 0.1");

    // Generate sinusoid tasks
    let generator = TaskGenerator::new(2, 2);
    let tasks: Vec<MetaTask> = (0..15)
        .map(|_| generator.generate_sinusoid_task(40))
        .collect();

    println!("\n   Meta-training on 15 sinusoid tasks...");
    let mut optimizer = Adam::new(0.001);
    meta_learner.meta_train(&tasks, &mut optimizer, 30, 3)?;

    println!("   Reptile training complete");

    // Analyze task similarities
    println!("\n   Task parameter statistics:");
    for (i, task) in tasks.iter().take(3).enumerate() {
        if let Some(amplitude) = task.metadata.get("amplitude") {
            if let Some(phase) = task.metadata.get("phase") {
                println!("   Task {i}: amplitude={amplitude:.2}, phase={phase:.2}");
            }
        }
    }

    Ok(())
}

/// `ProtoMAML` demonstration
fn protomaml_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 8 },
        QNNLayerType::VariationalLayer { num_params: 16 },
        QNNLayerType::EntanglementLayer {
            connectivity: "full".to_string(),
        },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let qnn = QuantumNeuralNetwork::new(layers, 4, 8, 16)?;

    let algorithm = MetaLearningAlgorithm::ProtoMAML {
        inner_steps: 5,
        inner_lr: 0.01,
        proto_weight: 0.5, // Weight for prototype regularization
    };

    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);

    println!("   Created ProtoMAML meta-learner:");
    println!("   - Combines MAML with prototypical networks");
    println!("   - Prototype weight: 0.5");

    // Generate classification tasks
    let generator = TaskGenerator::new(8, 4);
    let tasks: Vec<MetaTask> = (0..10)
        .map(|_| generator.generate_rotation_task(50))
        .collect();

    println!("\n   Meta-training on 4-way classification tasks...");
    let mut optimizer = Adam::new(0.001);
    meta_learner.meta_train(&tasks, &mut optimizer, 40, 2)?;

    println!("   ProtoMAML leverages both gradient-based and metric-based learning");

    Ok(())
}

/// Meta-SGD demonstration
fn metasgd_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 12 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "Pauli-XYZ".to_string(),
        },
    ];

    let qnn = QuantumNeuralNetwork::new(layers, 4, 4, 3)?;

    let algorithm = MetaLearningAlgorithm::MetaSGD { inner_steps: 3 };

    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);

    println!("   Created Meta-SGD learner:");
    println!("   - Learns per-parameter learning rates");
    println!("   - Inner steps: 3");

    // Generate diverse tasks
    let generator = TaskGenerator::new(4, 3);
    let mut tasks = Vec::new();

    // Mix different task types
    for i in 0..12 {
        if i % 2 == 0 {
            tasks.push(generator.generate_rotation_task(30));
        } else {
            tasks.push(generator.generate_sinusoid_task(30));
        }
    }

    println!("\n   Meta-training on mixed task distribution...");
    let mut optimizer = Adam::new(0.0005);
    meta_learner.meta_train(&tasks, &mut optimizer, 50, 4)?;

    if let Some(lr) = meta_learner.per_param_lr() {
        println!("\n   Learned per-parameter learning rates:");
        println!(
            "   - Min LR: {:.4}",
            lr.iter().copied().fold(f64::INFINITY, f64::min)
        );
        println!(
            "   - Max LR: {:.4}",
            lr.iter().copied().fold(f64::NEG_INFINITY, f64::max)
        );
        println!("   - Mean LR: {:.4}", lr.mean().unwrap());
    }

    Ok(())
}

/// ANIL demonstration
fn anil_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 6 },
        QNNLayerType::VariationalLayer { num_params: 12 },
        QNNLayerType::EntanglementLayer {
            connectivity: "circular".to_string(),
        },
        QNNLayerType::VariationalLayer { num_params: 12 },
        QNNLayerType::VariationalLayer { num_params: 6 }, // Final layer (adapted)
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let qnn = QuantumNeuralNetwork::new(layers, 4, 6, 2)?;

    let algorithm = MetaLearningAlgorithm::ANIL {
        inner_steps: 10,
        inner_lr: 0.1,
    };

    let mut meta_learner = QuantumMetaLearner::new(algorithm, qnn);

    println!("   Created ANIL (Almost No Inner Loop) learner:");
    println!("   - Only adapts final layer during inner loop");
    println!("   - More parameter efficient than MAML");
    println!("   - Inner steps: 10");

    // Generate binary classification tasks
    let generator = TaskGenerator::new(6, 2);
    let tasks: Vec<MetaTask> = (0..15)
        .map(|_| generator.generate_rotation_task(40))
        .collect();

    println!("\n   Meta-training on binary classification tasks...");
    let mut optimizer = Adam::new(0.001);
    meta_learner.meta_train(&tasks, &mut optimizer, 40, 5)?;

    println!("   ANIL reduces computational cost while maintaining performance");

    Ok(())
}

examples/quantum_adversarial.rs (line 280)

fn adversarial_training_demo() -> Result<()> {
    // Create model and trainer
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 12 },
        QNNLayerType::EntanglementLayer {
            connectivity: "circular".to_string(),
        },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;

    let defense = QuantumDefenseStrategy::AdversarialTraining {
        attack_types: vec![
            QuantumAttackType::FGSM { epsilon: 0.08 },
            QuantumAttackType::PGD {
                epsilon: 0.08,
                alpha: 0.01,
                num_steps: 7,
            },
        ],
        adversarial_ratio: 0.4,
    };

    let mut config = create_default_adversarial_config();
    config.epochs = 20; // Reduced for demo
    config.eval_interval = 5;

    let mut trainer = QuantumAdversarialTrainer::new(model, defense, config);

    println!("   Adversarial training configuration:");
    println!("   - Attack types: FGSM + PGD");
    println!("   - Adversarial ratio: 40%");
    println!("   - Training epochs: 20");

    // Generate synthetic training data
    let train_data = generate_quantum_dataset(200, 4);
    let train_labels = Array1::from_shape_fn(200, |i| i % 2);

    let val_data = generate_quantum_dataset(50, 4);
    let val_labels = Array1::from_shape_fn(50, |i| i % 2);

    // Train with adversarial examples
    println!("\n   Starting adversarial training...");
    let mut optimizer = Adam::new(0.001);
    let losses = trainer.train(
        &train_data,
        &train_labels,
        &val_data,
        &val_labels,
        &mut optimizer,
    )?;

    println!("   Training completed!");
    println!("   Final loss: {:.4}", losses.last().unwrap_or(&0.0));

    // Show final robustness metrics
    let metrics = trainer.get_robustness_metrics();
    println!("\n   Final robustness metrics:");
    println!("   - Clean accuracy: {:.3}", metrics.clean_accuracy);
    println!("   - Robust accuracy: {:.3}", metrics.robust_accuracy);
    println!(
        "   - Attack success rate: {:.3}",
        metrics.attack_success_rate
    );

    Ok(())
}

examples/quantum_continual_learning.rs (line 95)

fn ewc_demo() -> Result<()> {
    // Create quantum model
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 12 },
        QNNLayerType::EntanglementLayer {
            connectivity: "circular".to_string(),
        },
        QNNLayerType::VariationalLayer { num_params: 8 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;

    // Create EWC strategy
    let strategy = ContinualLearningStrategy::ElasticWeightConsolidation {
        importance_weight: 1000.0,
        fisher_samples: 200,
    };

    let mut learner = QuantumContinualLearner::new(model, strategy);

    println!("   Created EWC continual learner:");
    println!("   - Importance weight: 1000.0");
    println!("   - Fisher samples: 200");

    // Generate task sequence
    let tasks = generate_task_sequence(3, 100, 4);

    println!("\n   Learning sequence of {} tasks...", tasks.len());

    let mut optimizer = Adam::new(0.001);
    let mut task_accuracies = Vec::new();

    for (i, task) in tasks.iter().enumerate() {
        println!("   \n   Training on {}...", task.task_id);

        let metrics = learner.learn_task(task.clone(), &mut optimizer, 30)?;
        task_accuracies.push(metrics.current_accuracy);

        println!("   - Current accuracy: {:.3}", metrics.current_accuracy);

        // Evaluate forgetting on previous tasks
        if i > 0 {
            let all_accuracies = learner.evaluate_all_tasks()?;
            let avg_prev_accuracy = all_accuracies
                .iter()
                .take(i)
                .map(|(_, &acc)| acc)
                .sum::<f64>()
                / i as f64;

            println!("   - Average accuracy on previous tasks: {avg_prev_accuracy:.3}");
        }
    }

    // Final evaluation
    let forgetting_metrics = learner.get_forgetting_metrics();
    println!("\n   EWC Results:");
    println!(
        "   - Average accuracy: {:.3}",
        forgetting_metrics.average_accuracy
    );
    println!(
        "   - Forgetting measure: {:.3}",
        forgetting_metrics.forgetting_measure
    );
    println!(
        "   - Continual learning score: {:.3}",
        forgetting_metrics.continual_learning_score
    );

    Ok(())
}

/// Demonstrate Experience Replay
fn experience_replay_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 8 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;

    let strategy = ContinualLearningStrategy::ExperienceReplay {
        buffer_size: 500,
        replay_ratio: 0.3,
        memory_selection: MemorySelectionStrategy::Random,
    };

    let mut learner = QuantumContinualLearner::new(model, strategy);

    println!("   Created Experience Replay learner:");
    println!("   - Buffer size: 500");
    println!("   - Replay ratio: 30%");
    println!("   - Selection: Random");

    // Generate diverse tasks
    let tasks = generate_diverse_tasks(4, 80, 4);

    println!("\n   Learning {} diverse tasks...", tasks.len());

    let mut optimizer = Adam::new(0.002);

    for (i, task) in tasks.iter().enumerate() {
        println!("   \n   Learning {}...", task.task_id);

        let metrics = learner.learn_task(task.clone(), &mut optimizer, 25)?;

        println!("   - Task accuracy: {:.3}", metrics.current_accuracy);

        // Show memory buffer status
        println!("   - Memory buffer usage: replay experiences stored");

        if i > 0 {
            let all_accuracies = learner.evaluate_all_tasks()?;
            let retention_rate = all_accuracies.values().sum::<f64>() / all_accuracies.len() as f64;
            println!("   - Average retention: {retention_rate:.3}");
        }
    }

    let final_metrics = learner.get_forgetting_metrics();
    println!("\n   Experience Replay Results:");
    println!(
        "   - Final average accuracy: {:.3}",
        final_metrics.average_accuracy
    );
    println!(
        "   - Forgetting reduction: {:.3}",
        1.0 - final_metrics.forgetting_measure
    );

    Ok(())
}

/// Demonstrate Progressive Networks
fn progressive_networks_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 6 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;

    let strategy = ContinualLearningStrategy::ProgressiveNetworks {
        lateral_connections: true,
        adaptation_layers: 2,
    };

    let mut learner = QuantumContinualLearner::new(model, strategy);

    println!("   Created Progressive Networks learner:");
    println!("   - Lateral connections: enabled");
    println!("   - Adaptation layers: 2");

    // Generate related tasks for transfer learning
    let tasks = generate_related_tasks(3, 60, 4);

    println!("\n   Learning {} related tasks...", tasks.len());

    let mut optimizer = Adam::new(0.001);
    let mut learning_speeds = Vec::new();

    for (i, task) in tasks.iter().enumerate() {
        println!("   \n   Adding column for {}...", task.task_id);

        let start_time = std::time::Instant::now();
        let metrics = learner.learn_task(task.clone(), &mut optimizer, 20)?;
        let learning_time = start_time.elapsed();

        learning_speeds.push(learning_time);

        println!("   - Task accuracy: {:.3}", metrics.current_accuracy);
        println!("   - Learning time: {learning_time:.2?}");

        if i > 0 {
            let speedup = learning_speeds[0].as_secs_f64() / learning_time.as_secs_f64();
            println!("   - Learning speedup: {speedup:.2}x");
        }
    }

    println!("\n   Progressive Networks Results:");
    println!("   - No catastrophic forgetting (by design)");
    println!("   - Lateral connections enable knowledge transfer");
    println!("   - Model capacity grows with new tasks");

    Ok(())
}

/// Demonstrate Learning without Forgetting
fn lwf_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 10 },
        QNNLayerType::EntanglementLayer {
            connectivity: "circular".to_string(),
        },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;

    let strategy = ContinualLearningStrategy::LearningWithoutForgetting {
        distillation_weight: 0.5,
        temperature: 3.0,
    };

    let mut learner = QuantumContinualLearner::new(model, strategy);

    println!("   Created Learning without Forgetting learner:");
    println!("   - Distillation weight: 0.5");
    println!("   - Temperature: 3.0");

    // Generate task sequence
    let tasks = generate_task_sequence(4, 70, 4);

    println!("\n   Learning with knowledge distillation...");

    let mut optimizer = Adam::new(0.001);
    let mut distillation_losses = Vec::new();

    for (i, task) in tasks.iter().enumerate() {
        println!("   \n   Learning {}...", task.task_id);

        let metrics = learner.learn_task(task.clone(), &mut optimizer, 25)?;

        println!("   - Task accuracy: {:.3}", metrics.current_accuracy);

        if i > 0 {
            // Simulate distillation loss tracking
            let distillation_loss = 0.3f64.mul_add(fastrand::f64(), 0.1);
            distillation_losses.push(distillation_loss);
            println!("   - Distillation loss: {distillation_loss:.3}");

            let all_accuracies = learner.evaluate_all_tasks()?;
            let stability = all_accuracies
                .values()
                .map(|&acc| if acc > 0.6 { 1.0 } else { 0.0 })
                .sum::<f64>()
                / all_accuracies.len() as f64;

            println!("   - Knowledge retention: {:.1}%", stability * 100.0);
        }
    }

    println!("\n   LwF Results:");
    println!("   - Knowledge distillation preserves previous task performance");
    println!("   - Temperature scaling provides soft targets");
    println!("   - Balances plasticity and stability");

    Ok(())
}

/// Demonstrate Parameter Isolation
fn parameter_isolation_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 16 },
        QNNLayerType::EntanglementLayer {
            connectivity: "full".to_string(),
        },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;

    let strategy = ContinualLearningStrategy::ParameterIsolation {
        allocation_strategy: ParameterAllocationStrategy::Masking,
        growth_threshold: 0.8,
    };

    let mut learner = QuantumContinualLearner::new(model, strategy);

    println!("   Created Parameter Isolation learner:");
    println!("   - Allocation strategy: Masking");
    println!("   - Growth threshold: 0.8");

    // Generate tasks with different requirements
    let tasks = generate_varying_complexity_tasks(3, 90, 4);

    println!("\n   Learning with parameter isolation...");

    let mut optimizer = Adam::new(0.001);
    let mut parameter_usage = Vec::new();

    for (i, task) in tasks.iter().enumerate() {
        println!("   \n   Allocating parameters for {}...", task.task_id);

        let metrics = learner.learn_task(task.clone(), &mut optimizer, 30)?;

        // Simulate parameter usage tracking
        let used_params = 16 * (i + 1) / tasks.len(); // Gradually use more parameters
        parameter_usage.push(used_params);

        println!("   - Task accuracy: {:.3}", metrics.current_accuracy);
        println!("   - Parameters allocated: {}/{}", used_params, 16);
        println!(
            "   - Parameter efficiency: {:.1}%",
            used_params as f64 / 16.0 * 100.0
        );

        if i > 0 {
            let all_accuracies = learner.evaluate_all_tasks()?;
            let interference = 1.0
                - all_accuracies
                    .values()
                    .take(i)
                    .map(|&acc| if acc > 0.7 { 1.0 } else { 0.0 })
                    .sum::<f64>()
                    / i as f64;

            println!("   - Task interference: {:.1}%", interference * 100.0);
        }
    }

    println!("\n   Parameter Isolation Results:");
    println!("   - Dedicated parameters prevent interference");
    println!("   - Scalable to many tasks");
    println!("   - Maintains task-specific knowledge");

    Ok(())
}

/// Demonstrate comprehensive task sequence evaluation
fn task_sequence_demo() -> Result<()> {
    println!("   Comprehensive continual learning evaluation...");

    // Compare different strategies
    let strategies = vec![
        (
            "EWC",
            ContinualLearningStrategy::ElasticWeightConsolidation {
                importance_weight: 500.0,
                fisher_samples: 100,
            },
        ),
        (
            "Experience Replay",
            ContinualLearningStrategy::ExperienceReplay {
                buffer_size: 300,
                replay_ratio: 0.2,
                memory_selection: MemorySelectionStrategy::Random,
            },
        ),
        (
            "Quantum Regularization",
            ContinualLearningStrategy::QuantumRegularization {
                entanglement_preservation: 0.1,
                parameter_drift_penalty: 0.5,
            },
        ),
    ];

    // Generate challenging task sequence
    let tasks = generate_challenging_sequence(5, 60, 4);

    println!(
        "\n   Comparing strategies on {} challenging tasks:",
        tasks.len()
    );

    for (strategy_name, strategy) in strategies {
        println!("\n   --- {strategy_name} ---");

        let layers = vec![
            QNNLayerType::EncodingLayer { num_features: 4 },
            QNNLayerType::VariationalLayer { num_params: 8 },
            QNNLayerType::MeasurementLayer {
                measurement_basis: "computational".to_string(),
            },
        ];

        let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
        let mut learner = QuantumContinualLearner::new(model, strategy);
        let mut optimizer = Adam::new(0.001);

        for task in &tasks {
            learner.learn_task(task.clone(), &mut optimizer, 20)?;
        }

        let final_metrics = learner.get_forgetting_metrics();
        println!(
            "   - Average accuracy: {:.3}",
            final_metrics.average_accuracy
        );
        println!(
            "   - Forgetting measure: {:.3}",
            final_metrics.forgetting_measure
        );
        println!(
            "   - CL score: {:.3}",
            final_metrics.continual_learning_score
        );
    }

    Ok(())
}

/// Demonstrate forgetting analysis
fn forgetting_analysis_demo() -> Result<()> {
    println!("   Detailed forgetting analysis...");

    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 12 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;

    let strategy = ContinualLearningStrategy::ElasticWeightConsolidation {
        importance_weight: 1000.0,
        fisher_samples: 150,
    };

    let mut learner = QuantumContinualLearner::new(model, strategy);

    // Create tasks with increasing difficulty
    let tasks = generate_increasing_difficulty_tasks(4, 80, 4);

    println!("\n   Learning tasks with increasing difficulty...");

    let mut optimizer = Adam::new(0.001);
    let mut accuracy_matrix = Vec::new();

    for (i, task) in tasks.iter().enumerate() {
        println!(
            "   \n   Learning {} (difficulty level {})...",
            task.task_id,
            i + 1
        );

        learner.learn_task(task.clone(), &mut optimizer, 25)?;

        // Evaluate on all tasks learned so far
        let all_accuracies = learner.evaluate_all_tasks()?;
        let mut current_row = Vec::new();

        for j in 0..=i {
            let task_id = &tasks[j].task_id;
            let accuracy = all_accuracies.get(task_id).unwrap_or(&0.0);
            current_row.push(*accuracy);
        }

        accuracy_matrix.push(current_row.clone());

        // Print current performance
        for (j, &acc) in current_row.iter().enumerate() {
            println!("   - Task {}: {:.3}", j + 1, acc);
        }
    }

    println!("\n   Forgetting Analysis Results:");

    // Compute backward transfer
    for i in 1..accuracy_matrix.len() {
        for j in 0..i {
            let current_acc = accuracy_matrix[i][j];
            let original_acc = accuracy_matrix[j][j];
            let forgetting = (original_acc - current_acc).max(0.0);

            if forgetting > 0.1 {
                println!("   - Significant forgetting detected for Task {} after learning Task {}: {:.3}",
                    j + 1, i + 1, forgetting);
            }
        }
    }

    // Compute average forgetting
    let mut total_forgetting = 0.0;
    let mut num_comparisons = 0;

    for i in 1..accuracy_matrix.len() {
        for j in 0..i {
            let current_acc = accuracy_matrix[i][j];
            let original_acc = accuracy_matrix[j][j];
            total_forgetting += (original_acc - current_acc).max(0.0);
            num_comparisons += 1;
        }
    }

    let avg_forgetting = if num_comparisons > 0 {
        total_forgetting / f64::from(num_comparisons)
    } else {
        0.0
    };

    println!("   - Average forgetting: {avg_forgetting:.3}");

    // Compute final average accuracy
    if let Some(final_row) = accuracy_matrix.last() {
        let final_avg = final_row.iter().sum::<f64>() / final_row.len() as f64;
        println!("   - Final average accuracy: {final_avg:.3}");
        println!(
            "   - Continual learning effectiveness: {:.1}%",
            (1.0 - avg_forgetting) * 100.0
        );
    }

    Ok(())
}

Additional examples can be found in:

• examples/transfer_learning.rs

Trait Implementations

impl Optimizer for Adam

fn step( &mut self, params: &mut HashMap<String, f64>, gradients: &HashMap<String, f64>, )

Update parameters given gradients

fn reset(&mut self)

Reset optimizer state