qrunch.chemistry.orbital_optimizers.newton_orbital_optimizer

Module containing an orbital optimizer implementation using Newton’s method.

Module Attributes

DEFAULT_OPTIONS

The default options for the Newton Orbital Optimizer Scipy minimizer.

Classes

`BasinHoppingOptions`	Options for SciPy basinhopping global optimization.
`NewtonMinimizerOptions`	The default options for SciPy minimizer.
`NewtonOrbitalOptimizer`	Implement a solver to find and apply Newton's method for orbital optimization.
`NewtonOrbitalOptimizerOrbitalOptimizerCreator`	Builder for the orbital optimizer algorithm using Newton's method.

class BasinHoppingOptions

Bases: DataclassPublicAPI

Options for SciPy basinhopping global optimization.

All fields are immutable (frozen=True) so an instance can be safely reused.

Parameters:

number_of_macro_iterations – How many basin hopping steps to perform. (default=3)
temperature – Controls accept probability for worse solutions. (default=0.01)
stepsize – Size of random displacement. (default=0.05)
number_of_successive_failures – Stop if no improvement after this many steps. (default=4)
seed – RNG seed for reproducibility. (default=None)
display – Verbosity. (default=True)
active – Activate Basin Hopping. (default=False)

__init__(*, number_of_macro_iterations: int = 3, temperature: float = 0.01, stepsize: float = 0.05, number_of_successive_failures: int = 4, seed: int | None = None, display: bool = True, active: bool = False) → None

Parameters:

number_of_macro_iterations (int)
temperature (float)
stepsize (float)
number_of_successive_failures (int)
seed (int | None)
display (bool)
active (bool)

Return type:

None

active: bool = False

display: bool = True

number_of_macro_iterations: int = 3

number_of_successive_failures: int = 4

seed: int | None = None

stepsize: float = 0.05

temperature: float = 0.01

DEFAULT_OPTIONS = NewtonMinimizerOptions(relative_error_tolerance=1e-05, max_iterations_per_parameter=10000, jacobian_step_size=1e-06, use_hessian_on_trialvector_for_single_step=False): The default options for the Newton Orbital Optimizer Scipy minimizer.

class NewtonMinimizerOptions

Bases: DataclassPublicAPI

The default options for SciPy minimizer.

Options controlling NewtonOrbitalOptimizer. All fields are immutable (frozen=True) so an instance can be safely reused.

Parameters:

relative_error_tolerance – Convergence tolerance (default=1.0e-5)
max_iterations_per_parameter – Maximum number of iterations per parameter. (default=10000)
jacobian_step_size – Jacobian step size (default=1e-6)
use_hessian_on_trialvector_for_single_step – If True, supply the Hessian-vector product (hessp) to SciPy instead of the full Hessian matrix (hess) for the single step procedure. This can be more efficient when the gradient calculator implements a direct Hessian-vector product. (default=False). In case the gradient calculator does not support Hessian-vector products for the given operator, we will fall back to using the full Hessian matrix even if this option is True, and log a warning.

__init__(*, relative_error_tolerance: float = 1e-05, max_iterations_per_parameter: int = 10000, jacobian_step_size: float = 1e-06, use_hessian_on_trialvector_for_single_step: bool = False) → None

Parameters:

relative_error_tolerance (float)
max_iterations_per_parameter (int)
jacobian_step_size (float)
use_hessian_on_trialvector_for_single_step (bool)

Return type:

None

jacobian_step_size: float = 1e-06

max_iterations_per_parameter: int = 10000

relative_error_tolerance: float = 1e-05

use_hessian_on_trialvector_for_single_step: bool = False

class NewtonOrbitalOptimizer

Bases: OrbitalOptimizerAlgorithm

Implement a solver to find and apply Newton’s method for orbital optimization.

__init__(gradient_calculator: GradientCalculator, shots: int | None = None, options: NewtonMinimizerOptions = NewtonMinimizerOptions(relative_error_tolerance=1e-05, max_iterations_per_parameter=10000, jacobian_step_size=1e-06, use_hessian_on_trialvector_for_single_step=False), basin_hopping_options: BasinHoppingOptions | None = None) → None

Initialize builder for the orbital optimizer.

Parameters:

gradient_calculator (GradientCalculator) – The object that can calculate gradients and Hessians.
shots (int | None) – Number of shots to use.
options (NewtonMinimizerOptions) – Options to pass to the minimizer.
basin_hopping_options (BasinHoppingOptions | None) – Options for basin-hopping global optimization.

Return type:

None

clear_cache() → None

Clear the cache of the underlying estimator.

Return type:: None

gradient_norm(operator: FermionHermitianSumProtocol | PairedHardcoreBosonHermitianSumProtocol, circuit: Circuit) → float | None

Compute the norm of the orbital-optimization gradient at zero rotation.

The gradient is evaluated at \(\\kappa = 0\), i.e. using the unrotated operator directly.

Parameters:

operator (FermionHermitianSumProtocol | PairedHardcoreBosonHermitianSumProtocol) – The operator whose expectation-value gradient should be computed.
circuit (Circuit) – The circuit ansatz with optimized parameters set.

Return type:

float | None

run(operator: T, circuit: Circuit) → OrbitalOptimizerResult[T]

Compute kappa analytically at zero kappa using Newton’s method.

The method uses the gradient and Hessian in from the gradient calculator.

Parameters:

operator (T) – The operator to rotate.
circuit (Circuit) – The circuit used to evaluate the operator.

Return type:

OrbitalOptimizerResult[T]

run_single_step(operator: T, circuit: Circuit) → OrbitalOptimizerResult[T]

Perform a single Newton-CG step (maxiter=1).

Parameters:

operator (T) – The operator to rotate.
circuit (Circuit) – The circuit used to evaluate the operator.

Return type:

OrbitalOptimizerResult[T]

class NewtonOrbitalOptimizerOrbitalOptimizerCreator

Bases: object

Builder for the orbital optimizer algorithm using Newton’s method.

__init__() → None

Initialize builder for the orbital optimizer.

Return type:: None

choose_gradient_calculator() → GradientCalculatorSubCreator[Self]

Choose gradient calculator to use for the orbital optimizer.

Return type:: GradientCalculatorSubCreator[Self]

create() → NewtonOrbitalOptimizer

Create an instance of NewtonOrbitalOptimizer.

Return type:: NewtonOrbitalOptimizer

with_basin_hopping_options(basin_hopping_options: BasinHoppingOptions) → Self

Set the basin-hopping options for global optimization.

Parameters:: basin_hopping_options (BasinHoppingOptions) – Options controlling the basin-hopping wrapper.
Return type:: Self

with_options(options: NewtonMinimizerOptions) → Self

Set the options to use for the orbital optimizer.

Parameters:: options (NewtonMinimizerOptions) – Options to pass to the minimizer
Return type:: Self

with_shots(shots: int | None) → Self

Set the number of shots to use when calling the gradient_calculator to compute the energy, gradient, etc.

Parameters:: shots (int | None) – Number of shots to use in the estimator. If None is given, the estimator is assumed to be exact (e.g. the excitation gate simulator).
Return type:: Self