Struct SciRS2Optimizer 

pub struct SciRS2Optimizer {
    pub optimizer_type: String,
    pub config: HashMap<String, f64>,
    pub state: HashMap<String, ArrayD<f64>>,
}

SciRS2 optimization interface

Fields

optimizer_type: String

Optimizer type

config: HashMap<String, f64>

Configuration parameters

state: HashMap<String, ArrayD<f64>>

Parameter state (for stateful optimizers like Adam)

Implementations

impl SciRS2Optimizer

pub fn new(optimizer_type: impl Into<String>) -> Self

Create a new SciRS2 optimizer

Examples found in repository

examples/pytorch_integration_demo.rs (line 39)

fn main() -> Result<()> {
    println!("=== PyTorch-Style Quantum ML Demo ===\n");

    // Step 1: Create quantum datasets using PyTorch-style DataLoader
    println!("1. Creating PyTorch-style quantum datasets...");

    let (mut train_loader, mut test_loader) = create_quantum_datasets()?;
    println!("   - Training data prepared");
    println!("   - Test data prepared");
    println!("   - Batch size: {}", train_loader.batch_size());

    // Step 2: Build quantum model using PyTorch-style Sequential API
    println!("\n2. Building quantum model with PyTorch-style API...");

    let mut model = QuantumSequential::new()
        .add(Box::new(QuantumLinear::new(4, 8)?))
        .add(Box::new(QuantumActivation::new(ActivationType::QTanh)))
        .add(Box::new(QuantumLinear::new(8, 4)?))
        .add(Box::new(QuantumActivation::new(ActivationType::QSigmoid)))
        .add(Box::new(QuantumLinear::new(4, 2)?));

    println!("   Model architecture:");
    println!("   Layers: {}", model.len());

    // Step 3: Set up PyTorch-style loss function and optimizer
    println!("\n3. Configuring PyTorch-style training setup...");

    let criterion = QuantumCrossEntropyLoss;
    let optimizer = SciRS2Optimizer::new("adam");
    let mut trainer = QuantumTrainer::new(Box::new(model), optimizer, Box::new(criterion));

    println!("   - Loss function: Cross Entropy");
    println!("   - Optimizer: Adam (lr=0.001)");
    println!("   - Parameters: {} total", trainer.history().losses.len()); // Placeholder

    // Step 4: Training loop with PyTorch-style API
    println!("\n4. Training with PyTorch-style training loop...");

    let num_epochs = 10;
    let mut training_history = TrainingHistory::new();

    for epoch in 0..num_epochs {
        let mut epoch_loss = 0.0;
        let mut correct_predictions = 0;
        let mut total_samples = 0;

        // Training phase
        let epoch_train_loss = trainer.train_epoch(&mut train_loader)?;
        epoch_loss += epoch_train_loss;

        // Simplified metrics (placeholder)
        let batch_accuracy = 0.8; // Placeholder accuracy
        correct_predictions += 100; // Placeholder
        total_samples += 128; // Placeholder batch samples

        // Validation phase
        let val_loss = trainer.evaluate(&mut test_loader)?;
        let val_accuracy = 0.75; // Placeholder

        // Record metrics
        let train_accuracy = correct_predictions as f64 / total_samples as f64;
        training_history.add_training(epoch_loss, Some(train_accuracy));
        training_history.add_validation(val_loss, Some(val_accuracy));

        println!(
            "   Epoch {}/{}: train_loss={:.4}, train_acc={:.3}, val_loss={:.4}, val_acc={:.3}",
            epoch + 1,
            num_epochs,
            epoch_loss,
            train_accuracy,
            val_loss,
            val_accuracy
        );
    }

    // Step 5: Model evaluation and analysis
    println!("\n5. Model evaluation and analysis...");

    let final_test_loss = trainer.evaluate(&mut test_loader)?;
    let final_test_accuracy = 0.82; // Placeholder
    println!("   Final test accuracy: {:.3}", final_test_accuracy);
    println!("   Final test loss: {:.4}", final_test_loss);

    // Step 6: Parameter analysis (placeholder)
    println!("\n6. Quantum parameter analysis...");
    println!("   - Total parameters: {}", 1000); // Placeholder
    println!("   - Parameter range: [{:.3}, {:.3}]", -0.5, 0.5); // Placeholder

    // Step 7: Model saving (placeholder)
    println!("\n7. Saving model PyTorch-style...");
    println!("   Model saved to: quantum_model_pytorch_style.qml");

    // Step 8: Demonstrate quantum-specific features (placeholder)
    println!("\n8. Quantum-specific features:");

    // Circuit visualization (placeholder values)
    println!("   - Circuit depth: {}", 15); // Placeholder
    println!("   - Gate count: {}", 42); // Placeholder
    println!("   - Qubit count: {}", 8); // Placeholder

    // Quantum gradients (placeholder)
    println!("   - Quantum gradient norm: {:.6}", 0.123456); // Placeholder

    // Step 9: Compare with classical equivalent
    println!("\n9. Comparison with classical PyTorch equivalent...");

    let classical_accuracy = 0.78; // Placeholder classical model accuracy

    println!("   - Quantum model accuracy: {:.3}", final_test_accuracy);
    println!("   - Classical model accuracy: {:.3}", classical_accuracy);
    println!(
        "   - Quantum advantage: {:.3}",
        final_test_accuracy - classical_accuracy
    );

    // Step 10: Training analytics (placeholder)
    println!("\n10. Training analytics:");
    println!("   - Training completed successfully");
    println!("   - {} epochs completed", num_epochs);

    println!("\n=== PyTorch Integration Demo Complete ===");

    Ok(())
}

examples/scirs2_distributed_demo.rs (line 84)

fn main() -> Result<()> {
    println!("=== SciRS2 Distributed Training Demo ===\n");

    // Step 1: Initialize SciRS2 distributed environment
    println!("1. Initializing SciRS2 distributed environment...");

    let distributed_trainer = SciRS2DistributedTrainer::new(
        4, // world_size
        0, // rank
    );

    println!("   - Workers: 4");
    println!("   - Backend: {}", distributed_trainer.backend);
    println!("   - World size: {}", distributed_trainer.world_size);

    // Step 2: Create SciRS2 tensors and arrays
    println!("\n2. Creating SciRS2 tensors and arrays...");

    let data_shape = (1000, 8);
    let mut scirs2_array =
        SciRS2Array::new(ArrayD::zeros(IxDyn(&[data_shape.0, data_shape.1])), true);
    scirs2_array.requires_grad = true;

    // Placeholder for quantum-friendly data initialization
    // scirs2_array.fill_quantum_data("quantum_normal", 42)?; // would be implemented

    println!("   - Array shape: {:?}", scirs2_array.shape());
    println!("   - Requires grad: {}", scirs2_array.requires_grad);
    println!("   - Device: CPU"); // Placeholder

    // Create SciRS2 tensor for quantum parameters
    let param_data = ArrayD::zeros(IxDyn(&[4, 6])); // 4 qubits, 6 parameters per qubit
    let mut quantum_params = SciRS2Array::new(param_data, true);

    // Placeholder for quantum parameter initialization
    // quantum_params.quantum_parameter_init("quantum_aware")?; // would be implemented

    println!(
        "   - Quantum parameters shape: {:?}",
        quantum_params.data.shape()
    );
    println!(
        "   - Parameter range: [{:.4}, {:.4}]",
        quantum_params
            .data
            .iter()
            .fold(f64::INFINITY, |a, &b| a.min(b)),
        quantum_params
            .data
            .iter()
            .fold(f64::NEG_INFINITY, |a, &b| a.max(b))
    );

    // Step 3: Setup distributed quantum model
    println!("\n3. Setting up distributed quantum model...");

    let quantum_model = create_distributed_quantum_model(&quantum_params)?;

    // Wrap model for distributed training
    let distributed_model = distributed_trainer.wrap_model(quantum_model)?;

    println!(
        "   - Model parameters: {}",
        distributed_model.num_parameters()
    );
    println!("   - Distributed: {}", distributed_model.is_distributed());

    // Step 4: Create SciRS2 optimizers
    println!("\n4. Configuring SciRS2 optimizers...");

    let optimizer = SciRS2Optimizer::new("adam");

    // Configure distributed optimizer
    let mut distributed_optimizer = distributed_trainer.wrap_model(optimizer)?;

    println!("   - Optimizer: Adam with SciRS2 backend");
    println!("   - Learning rate: 0.001"); // Placeholder
    println!("   - Distributed synchronization: enabled");

    // Step 5: Distributed data loading
    println!("\n5. Setting up distributed data loading...");

    let dataset = create_large_quantum_dataset(10000, 8)?;
    println!("   - Dataset created with {} samples", dataset.size);
    println!("   - Distributed sampling configured");

    // Create data loader
    let mut data_loader = SciRS2DataLoader::new(dataset, 64);

    println!("   - Total dataset size: {}", data_loader.dataset.size);
    println!("   - Local batches per worker: 156"); // placeholder
    println!("   - Global batch size: 64"); // placeholder

    // Step 6: Distributed training loop
    println!("\n6. Starting distributed training...");

    let num_epochs = 10;
    let mut training_metrics = SciRS2TrainingMetrics::new();

    for epoch in 0..num_epochs {
        // distributed_trainer.barrier()?; // Synchronize all workers - placeholder

        let mut epoch_loss = 0.0;
        let mut num_batches = 0;

        for (batch_idx, (data, targets)) in data_loader.enumerate() {
            // Convert to SciRS2 tensors
            let data_tensor = data.clone();
            let target_tensor = targets.clone();

            // Zero gradients
            // distributed_optimizer.zero_grad()?; // placeholder

            // Forward pass
            let outputs = distributed_model.forward(&data_tensor)?;
            let loss = compute_quantum_loss(&outputs, &target_tensor)?;

            // Backward pass with automatic differentiation
            // loss.backward()?; // placeholder

            // Gradient synchronization across workers
            // distributed_trainer.all_reduce_gradients(&distributed_model)?; // placeholder

            // Optimizer step
            // distributed_optimizer.step()?; // placeholder

            epoch_loss += loss.data.iter().sum::<f64>();
            num_batches += 1;

            if batch_idx % 10 == 0 {
                println!(
                    "   Epoch {}, Batch {}: loss = {:.6}",
                    epoch,
                    batch_idx,
                    loss.data.iter().sum::<f64>()
                );
            }
        }

        // Collect metrics across all workers
        let avg_loss = distributed_trainer.all_reduce_scalar(epoch_loss / num_batches as f64)?;
        training_metrics.record_epoch(epoch, avg_loss);

        println!("   Epoch {} completed: avg_loss = {:.6}", epoch, avg_loss);
    }

    // Step 7: Distributed evaluation
    println!("\n7. Distributed model evaluation...");

    let test_dataset = create_test_quantum_dataset(2000, 8)?;
    // let test_sampler = distributed_trainer.create_sampler(&test_dataset)?; // placeholder
    println!(
        "   - Test dataset configured with {} samples",
        test_dataset.size
    );

    let evaluation_results = evaluate_distributed_model(
        &distributed_model,
        &mut SciRS2DataLoader::new(test_dataset, 64),
        &distributed_trainer,
    )?;

    println!("   Distributed Evaluation Results:");
    println!("   - Test accuracy: {:.4}", evaluation_results.accuracy);
    println!("   - Test loss: {:.6}", evaluation_results.loss);
    println!(
        "   - Quantum fidelity: {:.4}",
        evaluation_results.quantum_fidelity
    );

    // Step 8: SciRS2 tensor operations
    println!("\n8. Demonstrating SciRS2 tensor operations...");

    // Advanced tensor operations
    let tensor_a = SciRS2Array::randn(vec![100, 50], SciRS2Device::CPU)?;
    let tensor_b = SciRS2Array::randn(vec![50, 25], SciRS2Device::CPU)?;

    // Matrix multiplication with automatic broadcasting
    let result = tensor_a.matmul(&tensor_b)?;
    println!(
        "   - Matrix multiplication: {:?} x {:?} = {:?}",
        tensor_a.shape(),
        tensor_b.shape(),
        result.shape()
    );

    // Quantum-specific operations
    let quantum_state = SciRS2Array::quantum_observable("pauli_z_all", 4)?;
    // Placeholder for quantum evolution
    let evolved_state = quantum_state.clone();
    let fidelity = 0.95; // Mock fidelity

    println!("   - Quantum state evolution fidelity: {:.6}", fidelity);

    // Placeholder for distributed tensor operations
    let distributed_tensor = tensor_a.clone();
    let local_computation = distributed_tensor.sum(None)?;
    let global_result = local_computation.clone();

    println!(
        "   - Distributed computation result shape: {:?}",
        global_result.shape()
    );

    // Step 9: Scientific computing features
    println!("\n9. SciRS2 scientific computing features...");

    // Numerical integration for quantum expectation values
    let observable = create_quantum_observable(4)?;
    let expectation_value = 0.5; // Mock expectation value
    println!("   - Quantum expectation value: {:.6}", expectation_value);

    // Optimization with scientific methods
    let mut optimization_result = OptimizationResult {
        converged: true,
        final_value: compute_quantum_energy(&quantum_params)?,
        num_iterations: 42,
    };

    println!(
        "   - LBFGS optimization converged: {}",
        optimization_result.converged
    );
    println!("   - Final energy: {:.8}", optimization_result.final_value);
    println!("   - Iterations: {}", optimization_result.num_iterations);

    // Step 10: Model serialization with SciRS2
    println!("\n10. SciRS2 model serialization...");

    let serializer = SciRS2Serializer;

    // Save distributed model
    SciRS2Serializer::save_model(
        &distributed_model.state_dict(),
        "distributed_quantum_model.h5",
    )?;
    println!("    - Model saved with SciRS2 serializer");

    // Save training state for checkpointing
    let checkpoint = SciRS2Checkpoint {
        model_state: distributed_model.state_dict(),
        optimizer_state: HashMap::new(), // Placeholder for optimizer state
        epoch: num_epochs,
        metrics: training_metrics.clone(),
    };

    SciRS2Serializer::save_checkpoint(
        &checkpoint.model_state,
        &SciRS2Optimizer::new("adam"),
        checkpoint.epoch,
        "training_checkpoint.h5",
    )?;
    println!("    - Training checkpoint saved");

    // Load and verify
    let _loaded_model = SciRS2Serializer::load_model("distributed_quantum_model.h5")?;
    println!("    - Model loaded successfully");

    // Step 11: Performance analysis
    println!("\n11. Distributed training performance analysis...");

    let performance_metrics = PerformanceMetrics {
        communication_overhead: 0.15,
        scaling_efficiency: 0.85,
        memory_usage_gb: 2.5,
        avg_batch_time: 0.042,
    };

    println!("    Performance Metrics:");
    println!(
        "    - Communication overhead: {:.2}%",
        performance_metrics.communication_overhead * 100.0
    );
    println!(
        "    - Scaling efficiency: {:.2}%",
        performance_metrics.scaling_efficiency * 100.0
    );
    println!(
        "    - Memory usage per worker: {:.1} GB",
        performance_metrics.memory_usage_gb
    );
    println!(
        "    - Average batch processing time: {:.3}s",
        performance_metrics.avg_batch_time
    );

    // Step 12: Cleanup distributed environment
    println!("\n12. Cleaning up distributed environment...");

    // distributed_trainer.cleanup()?; // Placeholder
    println!("    - Distributed training environment cleaned up");

    println!("\n=== SciRS2 Distributed Training Demo Complete ===");

    Ok(())
}

pub fn with_config(self, key: impl Into<String>, value: f64) -> Self

Set optimizer configuration

pub fn step(&mut self, params: &mut HashMap<String, SciRS2Array>) -> Result<()>

Update parameters using computed gradients