Struct QuantumNeuralNetwork 

pub struct QuantumNeuralNetwork {
    pub layers: Vec<QNNLayerType>,
    pub num_qubits: usize,
    pub input_dim: usize,
    pub output_dim: usize,
    pub parameters: Array1<f64>,
}

Represents a quantum neural network

Fields

layers: Vec<QNNLayerType>

The layers that make up the network

num_qubits: usize

The number of qubits used in the network

input_dim: usize

The dimension of the input data

output_dim: usize

The dimension of the output data

parameters: Array1<f64>

Network parameters (weights)

Implementations

impl QuantumNeuralNetwork

pub fn new( layers: Vec<QNNLayerType>, num_qubits: usize, input_dim: usize, output_dim: usize, ) -> Result<Self>

Creates a new quantum neural network

Examples found in repository

examples/quantum_meta_learning.rs (line 70)

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(())
}

/// Continual meta-learning demonstration
fn continual_meta_learning_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 8 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

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

    let algorithm = MetaLearningAlgorithm::Reptile {
        inner_steps: 5,
        inner_lr: 0.05,
    };

    let meta_learner = QuantumMetaLearner::new(algorithm, qnn);
    let mut continual_learner = ContinualMetaLearner::new(
        meta_learner,
        10,  // memory capacity
        0.3, // replay ratio
    );

    println!("   Created Continual Meta-Learner:");
    println!("   - Memory capacity: 10 tasks");
    println!("   - Replay ratio: 30%");

    // Generate sequence of tasks
    let generator = TaskGenerator::new(4, 2);

    println!("\n   Learning sequence of tasks...");
    for i in 0..20 {
        let task = if i < 10 {
            generator.generate_rotation_task(30)
        } else {
            generator.generate_sinusoid_task(30)
        };

        continual_learner.learn_task(task)?;

        if i % 5 == 4 {
            println!(
                "   Learned {} tasks, memory contains {} unique tasks",
                i + 1,
                continual_learner.memory_buffer_len()
            );
        }
    }

    println!("\n   Continual learning prevents catastrophic forgetting");

    Ok(())
}

examples/ultimate_integration_demo_simple.rs (lines 30-38)

fn main() -> Result<()> {
    println!("=== Simplified Ultimate QuantRS2-ML Integration Demo ===\n");

    // Step 1: Basic ecosystem setup
    println!("1. Setting up quantum ML ecosystem...");
    println!("   ✓ Error mitigation framework initialized");
    println!("   ✓ Simulator backends ready");
    println!("   ✓ Classical ML integration active");
    println!("   ✓ Model zoo accessible");

    // Step 2: Simple quantum neural network
    println!("\n2. Creating quantum neural network...");
    let qnn = QuantumNeuralNetwork::new(
        vec![
            QNNLayerType::EncodingLayer { num_features: 4 },
            QNNLayerType::VariationalLayer { num_params: 8 },
        ],
        2, // output_size
        4, // num_qubits
        8, // max_qubits
    )?;
    println!("   ✓ QNN created with 4 qubits, 2 output classes");

    // Step 3: Basic training data
    println!("\n3. Preparing training data...");
    let train_data = Array2::from_shape_fn((100, 4), |(i, j)| 0.1 * ((i * j) as f64).sin());
    let train_labels = Array1::from_shape_fn(100, |i| (i % 2) as f64);
    println!(
        "   ✓ Training data prepared: {} samples",
        train_data.nrows()
    );

    // Step 4: Basic training
    println!("\n4. Training quantum model...");
    // Note: Simplified training placeholder
    println!("   ✓ Model training completed (placeholder)");

    // Step 5: Basic evaluation
    println!("\n5. Model evaluation...");
    let test_data = Array2::from_shape_fn((20, 4), |(i, j)| 0.15 * ((i * j + 1) as f64).sin());
    // Note: Simplified evaluation placeholder
    println!("   ✓ Test accuracy: 85.2% (placeholder)");

    // Step 6: Benchmarking
    println!("\n6. Performance benchmarking...");
    let benchmarks = BenchmarkFramework::new();
    println!("   ✓ Benchmark framework initialized");
    println!("   ✓ Performance metrics collected");

    // Step 7: Integration summary
    println!("\n7. Integration summary:");
    println!("   ✓ Quantum circuits: Optimized");
    println!("   ✓ Error mitigation: Active");
    println!("   ✓ Classical integration: Seamless");
    println!("   ✓ Scalability: Production-ready");

    println!("\n=== Demo Complete ===");
    println!("Ultimate QuantRS2-ML integration demonstration successful!");

    Ok(())
}

examples/quantum_continual_learning.rs (line 76)

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(())
}

examples/few_shot_learning.rs (line 69)

fn main() -> Result<()> {
    println!("=== Quantum Few-Shot Learning Demo ===\n");

    // Step 1: Generate synthetic dataset
    println!("1. Generating synthetic dataset for 5-way classification...");
    let num_samples_per_class = 20;
    let num_classes = 5;
    let num_features = 4;
    let total_samples = num_samples_per_class * num_classes;

    // Generate data with different patterns for each class
    let mut data = Array2::zeros((total_samples, num_features));
    let mut labels = Array1::zeros(total_samples);

    for class_id in 0..num_classes {
        for sample_idx in 0..num_samples_per_class {
            let idx = class_id * num_samples_per_class + sample_idx;

            // Create class-specific patterns
            for feat in 0..num_features {
                data[[idx, feat]] = 0.1f64.mul_add(
                    2.0f64.mul_add(thread_rng().gen::<f64>(), -1.0),
                    (sample_idx as f64)
                        .mul_add(0.1, (class_id as f64).mul_add(0.5, feat as f64 * 0.3))
                        .sin(),
                );
            }
            labels[idx] = class_id;
        }
    }

    println!(
        "   Dataset created: {total_samples} samples, {num_features} features, {num_classes} classes"
    );

    // Step 2: Create quantum model for few-shot learning
    println!("\n2. Creating quantum neural network...");
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features },
        QNNLayerType::VariationalLayer { num_params: 8 },
        QNNLayerType::EntanglementLayer {
            connectivity: "circular".to_string(),
        },
        QNNLayerType::VariationalLayer { num_params: 8 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let qnn = QuantumNeuralNetwork::new(layers, 4, num_features, num_classes)?;
    println!("   Quantum model created with {} qubits", qnn.num_qubits);

    // Step 3: Test different few-shot learning methods
    println!("\n3. Testing few-shot learning methods:");

    // Method 1: Prototypical Networks
    println!("\n   a) Prototypical Networks (5-way 3-shot):");
    test_prototypical_networks(&data, &labels, qnn.clone())?;

    // Method 2: MAML
    println!("\n   b) Model-Agnostic Meta-Learning (MAML):");
    test_maml(&data, &labels, qnn.clone())?;

    // Step 4: Compare performance across different shot values
    println!("\n4. Performance comparison across different K-shot values:");
    compare_shot_performance(&data, &labels, qnn)?;

    println!("\n=== Few-Shot Learning Demo Complete ===");

    Ok(())
}

examples/quantum_adversarial.rs (line 71)

fn adversarial_attack_demo() -> Result<()> {
    // Create a quantum model
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 8 },
        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)?;
    let defense = create_comprehensive_defense();
    let config = create_default_adversarial_config();

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

    println!("   Created quantum adversarial trainer"); // model.parameters field is private

    // Test data
    let test_data = Array2::from_shape_fn((10, 4), |(i, j)| {
        0.2f64.mul_add(j as f64 / 4.0, 0.3f64.mul_add(i as f64 / 10.0, 0.5))
    });
    let test_labels = Array1::from_shape_fn(10, |i| i % 2);

    println!("\n   Testing different attack methods:");

    // FGSM Attack
    println!("   - Fast Gradient Sign Method (FGSM)...");
    let fgsm_examples = trainer.generate_adversarial_examples(
        &test_data,
        &test_labels,
        QuantumAttackType::FGSM { epsilon: 0.1 },
    )?;

    let fgsm_success_rate = fgsm_examples
        .iter()
        .map(|ex| if ex.attack_success { 1.0 } else { 0.0 })
        .sum::<f64>()
        / fgsm_examples.len() as f64;

    println!("     Success rate: {:.2}%", fgsm_success_rate * 100.0);

    if let Some(example) = fgsm_examples.first() {
        println!(
            "     Average perturbation: {:.4}",
            example.perturbation_norm
        );
    }

    // PGD Attack
    println!("   - Projected Gradient Descent (PGD)...");
    let pgd_examples = trainer.generate_adversarial_examples(
        &test_data,
        &test_labels,
        QuantumAttackType::PGD {
            epsilon: 0.1,
            alpha: 0.01,
            num_steps: 10,
        },
    )?;

    let pgd_success_rate = pgd_examples
        .iter()
        .map(|ex| if ex.attack_success { 1.0 } else { 0.0 })
        .sum::<f64>()
        / pgd_examples.len() as f64;

    println!("     Success rate: {:.2}%", pgd_success_rate * 100.0);

    // Parameter Shift Attack
    println!("   - Parameter Shift Attack...");
    let param_examples = trainer.generate_adversarial_examples(
        &test_data,
        &test_labels,
        QuantumAttackType::ParameterShift {
            shift_magnitude: 0.05,
            target_parameters: None,
        },
    )?;

    let param_success_rate = param_examples
        .iter()
        .map(|ex| if ex.attack_success { 1.0 } else { 0.0 })
        .sum::<f64>()
        / param_examples.len() as f64;

    println!("     Success rate: {:.2}%", param_success_rate * 100.0);

    // Quantum State Perturbation
    println!("   - Quantum State Perturbation...");
    let state_examples = trainer.generate_adversarial_examples(
        &test_data,
        &test_labels,
        QuantumAttackType::StatePerturbation {
            perturbation_strength: 0.1,
            basis: "pauli_z".to_string(),
        },
    )?;

    let state_success_rate = state_examples
        .iter()
        .map(|ex| if ex.attack_success { 1.0 } else { 0.0 })
        .sum::<f64>()
        / state_examples.len() as f64;

    println!("     Success rate: {:.2}%", state_success_rate * 100.0);

    Ok(())
}

/// Demonstrate defense mechanisms
fn defense_mechanisms_demo() -> Result<()> {
    println!("   Testing defense strategies:");

    // Input preprocessing defense
    println!("   - Input Preprocessing...");
    let preprocessing_defense = QuantumDefenseStrategy::InputPreprocessing {
        noise_addition: 0.05,
        feature_squeezing: true,
    };

    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 config = create_default_adversarial_config();
    let trainer = QuantumAdversarialTrainer::new(model, preprocessing_defense, config.clone());

    let test_input = Array1::from_vec(vec![0.51, 0.32, 0.83, 0.24]);
    let defended_input = trainer.apply_defense(&test_input)?;

    let defense_effect = (&defended_input - &test_input).mapv(f64::abs).sum();
    println!("     Defense effect magnitude: {defense_effect:.4}");

    // Randomized circuit defense
    println!("   - Randomized Circuit Defense...");
    let randomized_defense = QuantumDefenseStrategy::RandomizedCircuit {
        randomization_strength: 0.1,
        num_random_layers: 2,
    };

    let layers2 = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 8 },
    ];

    let model2 = QuantumNeuralNetwork::new(layers2, 4, 4, 2)?;
    let trainer2 = QuantumAdversarialTrainer::new(model2, randomized_defense, config);

    let defended_input2 = trainer2.apply_defense(&test_input)?;
    let randomization_effect = (&defended_input2 - &test_input).mapv(f64::abs).sum();
    println!("     Randomization effect: {randomization_effect:.4}");

    // Quantum error correction defense
    println!("   - Quantum Error Correction...");
    let qec_defense = QuantumDefenseStrategy::QuantumErrorCorrection {
        code_type: "surface_code".to_string(),
        correction_threshold: 0.01,
    };

    println!("     Error correction configured with surface codes");
    println!("     Correction threshold: 1%");

    Ok(())
}

/// Demonstrate adversarial training process
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(())
}

/// Demonstrate robustness evaluation
fn robustness_evaluation_demo() -> Result<()> {
    // Create trained model (simplified)
    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 defense = create_comprehensive_defense();
    let config = create_default_adversarial_config();

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

    println!("   Evaluating model robustness...");

    // Test data
    let test_data = generate_quantum_dataset(100, 4);
    let test_labels = Array1::from_shape_fn(100, |i| i % 2);

    // Evaluate against different attack strengths
    let epsilons = vec![0.05, 0.1, 0.15, 0.2];

    println!("\n   Robustness vs. attack strength:");
    for &epsilon in &epsilons {
        let attack_examples = trainer.generate_adversarial_examples(
            &test_data,
            &test_labels,
            QuantumAttackType::FGSM { epsilon },
        )?;

        let success_rate = attack_examples
            .iter()
            .map(|ex| if ex.attack_success { 1.0 } else { 0.0 })
            .sum::<f64>()
            / attack_examples.len() as f64;

        let avg_perturbation = attack_examples
            .iter()
            .map(|ex| ex.perturbation_norm)
            .sum::<f64>()
            / attack_examples.len() as f64;

        println!(
            "   ε = {:.2}: Attack success = {:.1}%, Avg perturbation = {:.4}",
            epsilon,
            success_rate * 100.0,
            avg_perturbation
        );
    }

    // Test different attack types
    println!("\n   Attack type comparison:");
    let attack_types = vec![
        ("FGSM", QuantumAttackType::FGSM { epsilon: 0.1 }),
        (
            "PGD",
            QuantumAttackType::PGD {
                epsilon: 0.1,
                alpha: 0.01,
                num_steps: 10,
            },
        ),
        (
            "Parameter Shift",
            QuantumAttackType::ParameterShift {
                shift_magnitude: 0.05,
                target_parameters: None,
            },
        ),
        (
            "State Perturbation",
            QuantumAttackType::StatePerturbation {
                perturbation_strength: 0.1,
                basis: "pauli_z".to_string(),
            },
        ),
    ];

    for (name, attack_type) in attack_types {
        let examples = trainer.generate_adversarial_examples(
            &test_data.slice(s![0..20, ..]).to_owned(),
            &test_labels.slice(s![0..20]).to_owned(),
            attack_type,
        )?;

        let success_rate = examples
            .iter()
            .map(|ex| if ex.attack_success { 1.0 } else { 0.0 })
            .sum::<f64>()
            / examples.len() as f64;

        println!("   {}: {:.1}% success rate", name, success_rate * 100.0);
    }

    Ok(())
}

/// Demonstrate certified defense
fn certified_defense_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 certified_defense = QuantumDefenseStrategy::CertifiedDefense {
        smoothing_variance: 0.1,
        confidence_level: 0.95,
    };

    let config = create_default_adversarial_config();
    let trainer = QuantumAdversarialTrainer::new(model, certified_defense, config);

    println!("   Certified defense analysis:");
    println!("   - Smoothing variance: 0.1");
    println!("   - Confidence level: 95%");

    // Generate test data
    let test_data = generate_quantum_dataset(50, 4);

    // Perform certified analysis
    println!("\n   Running randomized smoothing certification...");
    let certified_accuracy = trainer.certified_defense_analysis(
        &test_data, 0.1, // smoothing variance
        100, // number of samples
    )?;

    println!("   Certified accuracy: {:.2}%", certified_accuracy * 100.0);

    // Compare with different smoothing levels
    let smoothing_levels = vec![0.05, 0.1, 0.15, 0.2];
    println!("\n   Certified accuracy vs. smoothing variance:");

    for &variance in &smoothing_levels {
        let cert_acc = trainer.certified_defense_analysis(&test_data, variance, 50)?;
        println!("   σ = {:.2}: {:.1}% certified", variance, cert_acc * 100.0);
    }

    Ok(())
}

/// Compare different attack methods
fn attack_comparison_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 10 },
        QNNLayerType::EntanglementLayer {
            connectivity: "full".to_string(),
        },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

    let model = QuantumNeuralNetwork::new(layers, 4, 4, 2)?;
    let defense = create_comprehensive_defense();
    let config = create_default_adversarial_config();

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

    println!("   Comprehensive attack comparison:");

    let test_data = generate_quantum_dataset(30, 4);
    let test_labels = Array1::from_shape_fn(30, |i| i % 2);

    // Test multiple attack configurations
    let attack_configs = vec![
        ("FGSM (ε=0.05)", QuantumAttackType::FGSM { epsilon: 0.05 }),
        ("FGSM (ε=0.1)", QuantumAttackType::FGSM { epsilon: 0.1 }),
        (
            "PGD-5",
            QuantumAttackType::PGD {
                epsilon: 0.1,
                alpha: 0.02,
                num_steps: 5,
            },
        ),
        (
            "PGD-10",
            QuantumAttackType::PGD {
                epsilon: 0.1,
                alpha: 0.01,
                num_steps: 10,
            },
        ),
        (
            "Parameter Shift",
            QuantumAttackType::ParameterShift {
                shift_magnitude: 0.1,
                target_parameters: None,
            },
        ),
        (
            "Circuit Manipulation",
            QuantumAttackType::CircuitManipulation {
                gate_error_rate: 0.01,
                coherence_time: 100.0,
            },
        ),
    ];

    println!("\n   Attack effectiveness comparison:");
    println!(
        "   {:20} {:>12} {:>15} {:>15}",
        "Attack Type", "Success Rate", "Avg Perturbation", "Effectiveness"
    );

    for (name, attack_type) in attack_configs {
        let examples =
            trainer.generate_adversarial_examples(&test_data, &test_labels, attack_type)?;

        let success_rate = examples
            .iter()
            .map(|ex| if ex.attack_success { 1.0 } else { 0.0 })
            .sum::<f64>()
            / examples.len() as f64;

        let avg_perturbation =
            examples.iter().map(|ex| ex.perturbation_norm).sum::<f64>() / examples.len() as f64;

        let effectiveness = if avg_perturbation > 0.0 {
            success_rate / avg_perturbation
        } else {
            0.0
        };

        println!(
            "   {:20} {:>11.1}% {:>14.4} {:>14.2}",
            name,
            success_rate * 100.0,
            avg_perturbation,
            effectiveness
        );
    }

    Ok(())
}

/// Demonstrate ensemble defense
fn ensemble_defense_demo() -> Result<()> {
    println!("   Ensemble defense strategy:");

    let ensemble_defense = QuantumDefenseStrategy::EnsembleDefense {
        num_models: 5,
        diversity_metric: "parameter_diversity".to_string(),
    };

    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 config = create_default_adversarial_config();

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

    println!("   - Number of models: 5");
    println!("   - Diversity metric: Parameter diversity");

    // Initialize ensemble
    println!("\n   Initializing ensemble models...");
    // trainer.initialize_ensemble()?; // Method is private
    println!("   Ensemble initialized (placeholder)");

    println!("   Ensemble initialized successfully");

    // Test ensemble robustness (simplified)
    let test_input = Array1::from_vec(vec![0.6, 0.4, 0.7, 0.3]);

    println!("\n   Ensemble prediction characteristics:");
    println!("   - Improved robustness through model diversity");
    println!("   - Reduced attack transferability");
    println!("   - Majority voting for final predictions");

    // Compare single model vs ensemble attack success
    // let single_model_attack = trainer.generate_single_adversarial_example(
    //     &test_input,
    //     0,
    //     QuantumAttackType::FGSM { epsilon: 0.1 }
    // )?;
    // Method is private - using public generate_adversarial_examples instead
    let single_model_attack = trainer.generate_adversarial_examples(
        &Array2::from_shape_vec((1, test_input.len()), test_input.to_vec())?,
        &Array1::from_vec(vec![0]),
        QuantumAttackType::FGSM { epsilon: 0.1 },
    )?[0]
        .clone();

    println!("\n   Single model vs. ensemble comparison:");
    println!(
        "   - Single model attack success: {}",
        if single_model_attack.attack_success {
            "Yes"
        } else {
            "No"
        }
    );
    println!(
        "   - Perturbation magnitude: {:.4}",
        single_model_attack.perturbation_norm
    );

    Ok(())
}

examples/quantum_explainable_ai.rs (line 75)

fn feature_attribution_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)?;

    println!(
        "   Created quantum model with {} parameters",
        model.parameters.len()
    );

    // Test different attribution methods
    let attribution_methods = vec![
        (
            "Integrated Gradients",
            ExplanationMethod::QuantumFeatureAttribution {
                method: AttributionMethod::IntegratedGradients,
                num_samples: 50,
                baseline: Some(Array1::zeros(4)),
            },
        ),
        (
            "Gradient × Input",
            ExplanationMethod::QuantumFeatureAttribution {
                method: AttributionMethod::GradientInput,
                num_samples: 1,
                baseline: None,
            },
        ),
        (
            "Gradient SHAP",
            ExplanationMethod::QuantumFeatureAttribution {
                method: AttributionMethod::GradientSHAP,
                num_samples: 30,
                baseline: None,
            },
        ),
        (
            "Quantum Attribution",
            ExplanationMethod::QuantumFeatureAttribution {
                method: AttributionMethod::QuantumAttribution,
                num_samples: 25,
                baseline: None,
            },
        ),
    ];

    // Test input
    let test_input = Array1::from_vec(vec![0.8, 0.3, 0.9, 0.1]);

    println!(
        "\n   Feature attribution analysis for input: [{:.1}, {:.1}, {:.1}, {:.1}]",
        test_input[0], test_input[1], test_input[2], test_input[3]
    );

    for (method_name, method) in attribution_methods {
        let mut xai = QuantumExplainableAI::new(model.clone(), vec![method]);

        // Set background data for gradient SHAP
        let background_data = Array2::from_shape_fn((20, 4), |(_, j)| {
            0.3f64.mul_add((j as f64 * 0.2).sin(), 0.5)
        });
        xai.set_background_data(background_data);

        let explanation = xai.explain(&test_input)?;

        if let Some(ref attributions) = explanation.feature_attributions {
            println!("\n   {method_name} Attribution:");
            for (i, &attr) in attributions.iter().enumerate() {
                println!(
                    "     Feature {}: {:+.4} {}",
                    i,
                    attr,
                    if attr.abs() > 0.1 {
                        if attr > 0.0 {
                            "(strong positive)"
                        } else {
                            "(strong negative)"
                        }
                    } else {
                        "(weak influence)"
                    }
                );
            }

            // Find most important feature
            let max_idx = attributions
                .iter()
                .enumerate()
                .max_by(|a, b| a.1.abs().partial_cmp(&b.1.abs()).unwrap())
                .map_or(0, |(i, _)| i);

            println!(
                "     → Most important feature: Feature {} ({:.4})",
                max_idx, attributions[max_idx]
            );
        }
    }

    Ok(())
}

/// Demonstrate circuit analysis and visualization
fn circuit_analysis_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 6 },
        QNNLayerType::EntanglementLayer {
            connectivity: "full".to_string(),
        },
        QNNLayerType::VariationalLayer { num_params: 6 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "Pauli-Z".to_string(),
        },
    ];

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

    let method = ExplanationMethod::CircuitVisualization {
        include_measurements: true,
        parameter_sensitivity: true,
    };

    let mut xai = QuantumExplainableAI::new(model, vec![method]);

    println!("   Analyzing quantum circuit structure and parameter importance...");

    let test_input = Array1::from_vec(vec![0.6, 0.4, 0.7, 0.3]);
    let explanation = xai.explain(&test_input)?;

    if let Some(ref circuit) = explanation.circuit_explanation {
        println!("\n   Circuit Analysis Results:");

        // Parameter importance
        println!("   Parameter Importance Scores:");
        for (i, &importance) in circuit.parameter_importance.iter().enumerate() {
            if importance > 0.5 {
                println!("     Parameter {i}: {importance:.3} (high importance)");
            } else if importance > 0.2 {
                println!("     Parameter {i}: {importance:.3} (medium importance)");
            }
        }

        // Layer analysis
        println!("\n   Layer-wise Analysis:");
        for (i, layer_analysis) in circuit.layer_analysis.iter().enumerate() {
            println!(
                "     Layer {}: {}",
                i,
                format_layer_type(&layer_analysis.layer_type)
            );
            println!(
                "       Information gain: {:.3}",
                layer_analysis.information_gain
            );
            println!(
                "       Entanglement generated: {:.3}",
                layer_analysis.entanglement_generated
            );

            if layer_analysis.entanglement_generated > 0.5 {
                println!("       → Significant entanglement layer");
            }
        }

        // Gate contributions
        println!("\n   Gate Contribution Analysis:");
        for (i, gate) in circuit.gate_contributions.iter().enumerate().take(5) {
            println!(
                "     Gate {}: {} on qubits {:?}",
                gate.gate_index, gate.gate_type, gate.qubits
            );
            println!("       Contribution: {:.3}", gate.contribution);

            if let Some(ref params) = gate.parameters {
                println!("       Parameters: {:.3}", params[0]);
            }
        }

        // Critical path
        println!("\n   Critical Path (most important parameters):");
        print!("     ");
        for (i, &param_idx) in circuit.critical_path.iter().enumerate() {
            if i > 0 {
                print!(" → ");
            }
            print!("P{param_idx}");
        }
        println!();

        println!("   → This path represents the most influential quantum operations");
    }

    Ok(())
}

/// Demonstrate quantum state analysis
fn quantum_state_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 3 },
        QNNLayerType::VariationalLayer { num_params: 9 },
        QNNLayerType::EntanglementLayer {
            connectivity: "circular".to_string(),
        },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

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

    let method = ExplanationMethod::StateAnalysis {
        entanglement_measures: true,
        coherence_analysis: true,
        superposition_analysis: true,
    };

    let mut xai = QuantumExplainableAI::new(model, vec![method]);

    println!("   Analyzing quantum state properties...");

    // Test different inputs to see state evolution
    let test_inputs = [
        Array1::from_vec(vec![0.0, 0.0, 0.0]),
        Array1::from_vec(vec![1.0, 0.0, 0.0]),
        Array1::from_vec(vec![0.5, 0.5, 0.5]),
        Array1::from_vec(vec![1.0, 1.0, 1.0]),
    ];

    for (i, input) in test_inputs.iter().enumerate() {
        println!(
            "\n   Input {}: [{:.1}, {:.1}, {:.1}]",
            i + 1,
            input[0],
            input[1],
            input[2]
        );

        let explanation = xai.explain(input)?;

        if let Some(ref state) = explanation.state_properties {
            println!("     Quantum State Properties:");
            println!(
                "     - Entanglement entropy: {:.3}",
                state.entanglement_entropy
            );

            // Coherence measures
            for (measure_name, &value) in &state.coherence_measures {
                println!("     - {measure_name}: {value:.3}");
            }

            // Superposition analysis
            let max_component = state
                .superposition_components
                .iter()
                .copied()
                .fold(f64::NEG_INFINITY, f64::max);
            println!("     - Max superposition component: {max_component:.3}");

            // Measurement probabilities
            let total_prob = state.measurement_probabilities.sum();
            println!("     - Total measurement probability: {total_prob:.3}");

            // Most likely measurement outcome
            let most_likely = state
                .measurement_probabilities
                .iter()
                .enumerate()
                .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
                .map_or((0, 0.0), |(idx, &prob)| (idx, prob));

            println!(
                "     - Most likely outcome: state {} with prob {:.3}",
                most_likely.0, most_likely.1
            );

            // State fidelities
            if let Some(highest_fidelity) = state
                .state_fidelities
                .values()
                .copied()
                .fold(None, |acc, x| Some(acc.map_or(x, |y| f64::max(x, y))))
            {
                println!("     - Highest basis state fidelity: {highest_fidelity:.3}");
            }

            // Interpretation
            if state.entanglement_entropy > 0.5 {
                println!("     → Highly entangled state");
            } else if state.entanglement_entropy > 0.1 {
                println!("     → Moderately entangled state");
            } else {
                println!("     → Separable or weakly entangled state");
            }
        }
    }

    Ok(())
}

/// Demonstrate saliency mapping
fn saliency_mapping_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)?;

    // Test different perturbation methods
    let perturbation_methods = vec![
        (
            "Gaussian Noise",
            PerturbationMethod::Gaussian { sigma: 0.1 },
        ),
        (
            "Quantum Phase",
            PerturbationMethod::QuantumPhase { magnitude: 0.2 },
        ),
        ("Feature Masking", PerturbationMethod::FeatureMasking),
        (
            "Parameter Perturbation",
            PerturbationMethod::ParameterPerturbation { strength: 0.1 },
        ),
    ];

    let test_input = Array1::from_vec(vec![0.7, 0.2, 0.8, 0.4]);

    println!("   Computing saliency maps with different perturbation methods...");
    println!(
        "   Input: [{:.1}, {:.1}, {:.1}, {:.1}]",
        test_input[0], test_input[1], test_input[2], test_input[3]
    );

    for (method_name, perturbation_method) in perturbation_methods {
        let method = ExplanationMethod::SaliencyMapping {
            perturbation_method,
            aggregation: AggregationMethod::Mean,
        };

        let mut xai = QuantumExplainableAI::new(model.clone(), vec![method]);
        let explanation = xai.explain(&test_input)?;

        if let Some(ref saliency) = explanation.saliency_map {
            println!("\n   {method_name} Saliency Map:");

            // Analyze saliency for each output
            for output_idx in 0..saliency.ncols() {
                println!("     Output {output_idx}:");
                for input_idx in 0..saliency.nrows() {
                    let saliency_score = saliency[[input_idx, output_idx]];
                    if saliency_score > 0.1 {
                        println!(
                            "       Feature {input_idx} → Output {output_idx}: {saliency_score:.3} (important)"
                        );
                    } else if saliency_score > 0.05 {
                        println!(
                            "       Feature {input_idx} → Output {output_idx}: {saliency_score:.3} (moderate)"
                        );
                    }
                }
            }

            // Find most salient feature-output pair
            let mut max_saliency = 0.0;
            let mut max_pair = (0, 0);

            for i in 0..saliency.nrows() {
                for j in 0..saliency.ncols() {
                    if saliency[[i, j]] > max_saliency {
                        max_saliency = saliency[[i, j]];
                        max_pair = (i, j);
                    }
                }
            }

            println!(
                "     → Most salient: Feature {} → Output {} ({:.3})",
                max_pair.0, max_pair.1, max_saliency
            );
        }
    }

    Ok(())
}

/// Demonstrate Quantum LIME
fn quantum_lime_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)?;

    // Test different local models
    let local_models = vec![
        ("Linear Regression", LocalModelType::LinearRegression),
        ("Decision Tree", LocalModelType::DecisionTree),
        ("Quantum Linear", LocalModelType::QuantumLinear),
    ];

    let test_input = Array1::from_vec(vec![0.6, 0.8, 0.2, 0.9]);

    println!("   Quantum LIME: Local Interpretable Model-agnostic Explanations");
    println!(
        "   Input: [{:.1}, {:.1}, {:.1}, {:.1}]",
        test_input[0], test_input[1], test_input[2], test_input[3]
    );

    for (model_name, local_model) in local_models {
        let method = ExplanationMethod::QuantumLIME {
            num_perturbations: 100,
            kernel_width: 0.5,
            local_model,
        };

        let mut xai = QuantumExplainableAI::new(model.clone(), vec![method]);
        let explanation = xai.explain(&test_input)?;

        if let Some(ref attributions) = explanation.feature_attributions {
            println!("\n   LIME with {model_name}:");

            for (i, &attr) in attributions.iter().enumerate() {
                let impact = if attr.abs() > 0.3 {
                    "high"
                } else if attr.abs() > 0.1 {
                    "medium"
                } else {
                    "low"
                };

                println!("     Feature {i}: {attr:+.3} ({impact} impact)");
            }

            // Local model interpretation
            match model_name {
                "Linear Regression" => {
                    println!("     → Linear relationship approximation in local region");
                }
                "Decision Tree" => {
                    println!("     → Rule-based approximation with thresholds");
                }
                "Quantum Linear" => {
                    println!("     → Quantum-aware linear approximation");
                }
                _ => {}
            }

            // Compute local fidelity (simplified)
            let local_complexity = attributions.iter().map(|x| x.abs()).sum::<f64>();
            println!("     → Local explanation complexity: {local_complexity:.3}");
        }
    }

    Ok(())
}

/// Demonstrate Quantum SHAP
fn quantum_shap_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 3 },
        QNNLayerType::VariationalLayer { num_params: 6 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "Pauli-Z".to_string(),
        },
    ];

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

    let method = ExplanationMethod::QuantumSHAP {
        num_coalitions: 100,
        background_samples: 20,
    };

    let mut xai = QuantumExplainableAI::new(model, vec![method]);

    // Set background data for SHAP
    let background_data = Array2::from_shape_fn((50, 3), |(i, j)| {
        0.3f64.mul_add(((i + j) as f64 * 0.1).sin(), 0.5)
    });
    xai.set_background_data(background_data);

    println!("   Quantum SHAP: SHapley Additive exPlanations");

    // Test multiple inputs
    let test_inputs = [
        Array1::from_vec(vec![0.1, 0.5, 0.9]),
        Array1::from_vec(vec![0.8, 0.3, 0.6]),
        Array1::from_vec(vec![0.4, 0.7, 0.2]),
    ];

    for (i, input) in test_inputs.iter().enumerate() {
        println!(
            "\n   Input {}: [{:.1}, {:.1}, {:.1}]",
            i + 1,
            input[0],
            input[1],
            input[2]
        );

        let explanation = xai.explain(input)?;

        if let Some(ref shap_values) = explanation.feature_attributions {
            println!("     SHAP Values:");

            let mut total_shap = 0.0;
            for (j, &value) in shap_values.iter().enumerate() {
                total_shap += value;
                println!("     - Feature {j}: {value:+.4}");
            }

            println!("     - Sum of SHAP values: {total_shap:.4}");

            // Feature ranking
            let mut indexed_shap: Vec<(usize, f64)> = shap_values
                .iter()
                .enumerate()
                .map(|(idx, &val)| (idx, val.abs()))
                .collect();
            indexed_shap.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

            println!("     Feature importance ranking:");
            for (rank, (feature_idx, abs_value)) in indexed_shap.iter().enumerate() {
                let original_value = shap_values[*feature_idx];
                println!(
                    "     {}. Feature {}: {:.4} (|{:.4}|)",
                    rank + 1,
                    feature_idx,
                    original_value,
                    abs_value
                );
            }

            // SHAP properties
            println!(
                "     → SHAP values satisfy efficiency property (sum to prediction difference)"
            );
            println!("     → Each value represents feature's average marginal contribution");
        }
    }

    Ok(())
}

/// Demonstrate Layer-wise Relevance Propagation
fn quantum_lrp_demo() -> Result<()> {
    let layers = vec![
        QNNLayerType::EncodingLayer { num_features: 4 },
        QNNLayerType::VariationalLayer { num_params: 8 },
        QNNLayerType::VariationalLayer { num_params: 6 },
        QNNLayerType::MeasurementLayer {
            measurement_basis: "computational".to_string(),
        },
    ];

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

    // Test different LRP rules
    let lrp_rules = vec![
        ("Epsilon Rule", LRPRule::Epsilon),
        ("Gamma Rule", LRPRule::Gamma { gamma: 0.25 }),
        (
            "Alpha-Beta Rule",
            LRPRule::AlphaBeta {
                alpha: 2.0,
                beta: 1.0,
            },
        ),
        ("Quantum Rule", LRPRule::QuantumRule),
    ];

    let test_input = Array1::from_vec(vec![0.7, 0.1, 0.8, 0.4]);

    println!("   Layer-wise Relevance Propagation for Quantum Circuits");
    println!(
        "   Input: [{:.1}, {:.1}, {:.1}, {:.1}]",
        test_input[0], test_input[1], test_input[2], test_input[3]
    );

    for (rule_name, lrp_rule) in lrp_rules {
        let method = ExplanationMethod::QuantumLRP {
            propagation_rule: lrp_rule,
            epsilon: 1e-6,
        };

        let mut xai = QuantumExplainableAI::new(model.clone(), vec![method]);
        let explanation = xai.explain(&test_input)?;

        if let Some(ref relevance) = explanation.feature_attributions {
            println!("\n   LRP with {rule_name}:");

            let total_relevance = relevance.sum();

            for (i, &rel) in relevance.iter().enumerate() {
                let percentage = if total_relevance.abs() > 1e-10 {
                    rel / total_relevance * 100.0
                } else {
                    0.0
                };

                println!("     Feature {i}: {rel:.4} ({percentage:.1}% of total relevance)");
            }

            println!("     Total relevance: {total_relevance:.4}");

            // Rule-specific interpretation
            match rule_name {
                "Epsilon Rule" => {
                    println!("     → Distributes relevance proportionally to activations");
                }
                "Gamma Rule" => {
                    println!("     → Emphasizes positive contributions");
                }
                "Alpha-Beta Rule" => {
                    println!("     → Separates positive and negative contributions");
                }
                "Quantum Rule" => {
                    println!("     → Accounts for quantum superposition and entanglement");
                }
                _ => {}
            }
        }
    }

    Ok(())
}

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

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

    // Use comprehensive explanation methods
    let methods = vec![
        ExplanationMethod::QuantumFeatureAttribution {
            method: AttributionMethod::IntegratedGradients,
            num_samples: 30,
            baseline: Some(Array1::zeros(4)),
        },
        ExplanationMethod::CircuitVisualization {
            include_measurements: true,
            parameter_sensitivity: true,
        },
        ExplanationMethod::StateAnalysis {
            entanglement_measures: true,
            coherence_analysis: true,
            superposition_analysis: true,
        },
        ExplanationMethod::ConceptActivation {
            concept_datasets: vec!["pattern_A".to_string(), "pattern_B".to_string()],
            activation_threshold: 0.3,
        },
    ];

    let mut xai = QuantumExplainableAI::new(model, methods);

    // Add concept vectors
    xai.add_concept(
        "pattern_A".to_string(),
        Array1::from_vec(vec![1.0, 0.0, 1.0, 0.0]),
    );
    xai.add_concept(
        "pattern_B".to_string(),
        Array1::from_vec(vec![0.0, 1.0, 0.0, 1.0]),
    );

    // Set background data
    let background_data = Array2::from_shape_fn((30, 4), |(i, j)| {
        0.4f64.mul_add(((i * j) as f64 * 0.15).sin(), 0.3)
    });
    xai.set_background_data(background_data);

    println!("   Comprehensive Quantum Model Explanation");

    // Test input representing a specific pattern
    let test_input = Array1::from_vec(vec![0.9, 0.1, 0.8, 0.2]); // Similar to pattern_A

    println!(
        "\n   Analyzing input: [{:.1}, {:.1}, {:.1}, {:.1}]",
        test_input[0], test_input[1], test_input[2], test_input[3]
    );

    let explanation = xai.explain(&test_input)?;

    // Display comprehensive results
    println!("\n   === COMPREHENSIVE EXPLANATION RESULTS ===");

    // Feature attributions
    if let Some(ref attributions) = explanation.feature_attributions {
        println!("\n   Feature Attributions:");
        for (i, &attr) in attributions.iter().enumerate() {
            println!("   - Feature {i}: {attr:+.3}");
        }
    }

    // Circuit analysis summary
    if let Some(ref circuit) = explanation.circuit_explanation {
        println!("\n   Circuit Analysis Summary:");
        let avg_importance = circuit.parameter_importance.mean().unwrap_or(0.0);
        println!("   - Average parameter importance: {avg_importance:.3}");
        println!(
            "   - Number of analyzed layers: {}",
            circuit.layer_analysis.len()
        );
        println!("   - Critical path length: {}", circuit.critical_path.len());
    }

    // Quantum state properties
    if let Some(ref state) = explanation.state_properties {
        println!("\n   Quantum State Properties:");
        println!(
            "   - Entanglement entropy: {:.3}",
            state.entanglement_entropy
        );
        println!(
            "   - Coherence measures: {} types",
            state.coherence_measures.len()
        );

        let max_measurement_prob = state
            .measurement_probabilities
            .iter()
            .copied()
            .fold(f64::NEG_INFINITY, f64::max);
        println!("   - Max measurement probability: {max_measurement_prob:.3}");
    }

    // Concept activations
    if let Some(ref concepts) = explanation.concept_activations {
        println!("\n   Concept Activations:");
        for (concept, &activation) in concepts {
            let similarity = if activation > 0.7 {
                "high"
            } else if activation > 0.3 {
                "medium"
            } else {
                "low"
            };
            println!("   - {concept}: {activation:.3} ({similarity} similarity)");
        }
    }

    // Confidence scores
    println!("\n   Explanation Confidence Scores:");
    for (component, &confidence) in &explanation.confidence_scores {
        println!("   - {component}: {confidence:.3}");
    }

    // Textual explanation
    println!("\n   Generated Explanation:");
    println!("{}", explanation.textual_explanation);

    // Summary insights
    println!("\n   === KEY INSIGHTS ===");

    if let Some(ref attributions) = explanation.feature_attributions {
        let max_attr_idx = attributions
            .iter()
            .enumerate()
            .max_by(|a, b| a.1.abs().partial_cmp(&b.1.abs()).unwrap())
            .map_or(0, |(i, _)| i);

        println!(
            "   • Most influential feature: Feature {} ({:.3})",
            max_attr_idx, attributions[max_attr_idx]
        );
    }

    if let Some(ref state) = explanation.state_properties {
        if state.entanglement_entropy > 0.5 {
            println!("   • Model creates significant quantum entanglement");
        }

        let coherence_level = state
            .coherence_measures
            .values()
            .copied()
            .fold(0.0, f64::max);
        if coherence_level > 0.5 {
            println!("   • High quantum coherence detected");
        }
    }

    if let Some(ref concepts) = explanation.concept_activations {
        if let Some((best_concept, &max_activation)) =
            concepts.iter().max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
        {
            if max_activation > 0.5 {
                println!("   • Input strongly matches concept: {best_concept}");
            }
        }
    }

    println!("   • Explanation provides multi-faceted interpretation of quantum model behavior");

    Ok(())
}

pub fn forward(&self, input: &Array1<f64>) -> Result<Array1<f64>>

Runs the network on a given input

pub fn train( &mut self, x_train: &Array2<f64>, y_train: &Array2<f64>, epochs: usize, learning_rate: f64, ) -> Result<TrainingResult>

Trains the network on a dataset

pub fn train_1d( &mut self, x_train: &Array2<f64>, y_train: &Array1<f64>, epochs: usize, learning_rate: f64, ) -> Result<TrainingResult>

Trains the network on a dataset with 1D labels (compatibility method)

pub fn predict(&self, input: &Array1<f64>) -> Result<Array1<f64>>

Predicts the output for a given input

pub fn predict_batch(&self, inputs: &Array2<f64>) -> Result<Array2<f64>>

Predicts the output for a batch of inputs

Trait Implementations

impl Clone for QuantumNeuralNetwork

fn clone(&self) -> QuantumNeuralNetwork

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QuantumNeuralNetwork

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.