Struct HybridQuantumClassical 

pub struct HybridQuantumClassical<A: Float + ScalarOperand + Debug> { /* private fields */ }

Hybrid quantum-classical optimizer.

HybridQuantumClassical blends quantum-inspired exploration with classical refinement, much in the spirit of variational hybrid algorithms. The first switch_step updates are produced by a QuantumAnnealing instance that performs broad exploration of the loss landscape. Subsequent updates are produced by an Adam instance whose state is implicitly warm-started by the best parameters discovered by the annealer.

Examples

use optirs_core::quantum_inspired::HybridQuantumClassical;
use optirs_core::optimizers::Optimizer;
use scirs2_core::ndarray::Array1;

let mut optimizer: HybridQuantumClassical<f64> =
    HybridQuantumClassical::new(0.05, 50);

let params = Array1::from_vec(vec![1.0, -1.0, 0.5]);
let grads = Array1::from_vec(vec![0.1, -0.2, 0.05]);
let _ = optimizer.step(&params, &grads).expect("step failed");

Implementations

impl<A> HybridQuantumClassical<A>

where A: Float + ScalarOperand + Debug + Send + Sync,

pub fn new(learning_rate: A, switch_step: usize) -> Self

Create a new hybrid optimizer with default sub-optimizer settings.

pub fn with_quantum(self, quantum: QuantumAnnealing<A>) -> Self

Replace the underlying quantum annealer.

pub fn with_classical(self, classical: Adam<A>) -> Self

Replace the underlying classical optimizer.

pub fn with_quantum_config<F>(self, f: F) -> Self

where F: FnOnce(QuantumAnnealing<A>) -> QuantumAnnealing<A>,

Configure the quantum annealer via a builder closure.

pub fn with_classical_config<F>(self, f: F) -> Self

where F: FnOnce(Adam<A>) -> Adam<A>,

Configure the classical optimizer via a builder closure.

pub fn phase(&self) -> OptimizationPhase

Returns the current optimization phase.

pub fn switch_step(&self) -> usize

Returns the configured switch step.

pub fn current_step(&self) -> usize

Returns the current step counter.

pub fn warmed_up(&self) -> bool

Returns whether the warm-start handoff has fired.

pub fn learning_rate(&self) -> A

Returns the current learning rate, choosing the relevant sub-optimizer based on the current phase.

pub fn set_lr(&mut self, learning_rate: A)

Set the learning rate on both the quantum annealer and the classical optimizer simultaneously.

pub fn quantum(&self) -> &QuantumAnnealing<A>

Returns an immutable reference to the underlying quantum annealer.

pub fn classical(&self) -> &Adam<A>

Returns an immutable reference to the underlying classical optimizer.

pub fn quantum_mut(&mut self) -> &mut QuantumAnnealing<A>

Returns a mutable reference to the underlying quantum annealer.

pub fn classical_mut(&mut self) -> &mut Adam<A>

Returns a mutable reference to the underlying classical optimizer.

Trait Implementations

impl<A: Debug + Float + ScalarOperand + Debug> Debug for HybridQuantumClassical<A>

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

Formats the value using the given formatter.

impl<A, D> Optimizer<A, D> for HybridQuantumClassical<A>

where A: Float + ScalarOperand + Debug + Send + Sync, D: Dimension,

fn step( &mut self, params: &Array<A, D>, gradients: &Array<A, D>, ) -> Result<Array<A, D>>

Updates parameters using the given gradients

fn get_learning_rate(&self) -> A

Gets the current learning rate

fn set_learning_rate(&mut self, learning_rate: A)

Sets a new learning rate

fn step_list( &mut self, params_list: &[&Array<A, D>], gradients_list: &[&Array<A, D>], ) -> Result<Vec<Array<A, D>>>

Updates multiple parameter arrays at once