qrunch.tools.minimizers.every_nth_reminimizer

A minimizer that uses a ‘reminimizer’ every nth iteration and a standard ‘minimizer’ for all other iterations.

Classes

`EveryNthReminimizerMinimizer`	A minimizer that conditionally delegates to one of two sub-minimizers based on the iteration number.
`EveryNthReminimizerMinimizerCreator`	Creator for creating EveryNthReminimizerMinimizer.
`EveryNthReminimizerMinimizerOptions`	Options controlling `EveryNthReminimizerMinimizer`.

class EveryNthReminimizerMinimizer

Bases: Minimizer

A minimizer that conditionally delegates to one of two sub-minimizers based on the iteration number.

This minimizer acts as a switch. For most iterations, it uses a standard minimizer. However, at a specified frequency (every_nth_iteration), it switches to a reminimizer. This is useful for implementing complex optimization schedules, such as performing a more thorough or different style of optimization periodically. For example, one might use a fast local optimizer for most steps and a more global or exhaustive optimizer every N steps to escape local minima.

The default reminimizer is a CyclerMinimizer with FftMinimizer as minimizer, optimizing one variable at a time for one cycle.

The iteration argument passed to the minimize method is used to track the iteration count.

__init__(minimizer: Minimizer | None = None, reminimizer: Minimizer | None = None, options: EveryNthReminimizerMinimizerOptions | None = None) → None

Initialize a EveryNthReminimizerMinimizer.

Parameters:

minimizer (Minimizer | None) – Minimizer to use during normal iterations.
reminimizer (Minimizer | None) – Minimizer to use during every n’th iteration.
options (EveryNthReminimizerMinimizerOptions | None) – Options for the minimizer.

Return type:

None

minimize(function: Callable[[list[ndarray[Any, dtype[float64]]]], list[float]], initial_guess: ndarray[Any, dtype[float64]], iteration: int | None, bounds: tuple[float, float] | list[tuple[float, float]] | None = None, circuit: Circuit | None = None, operator: HermitianPauliSum | None = None) → MinimizerResult

Minimize the objective by delegating to either the main minimizer or the reminimizer.

The choice of which minimizer to use is determined by the iteration number and the every_nth_iteration option. If (iteration + 1) % every_nth_iteration == 0, the reminimizer is used. Otherwise, the standard minimizer is used.

Parameters:

function (Callable[[list[ndarray[Any, dtype[float64]]]], list[float]]) – Batch objective. Takes a list of parameter vectors and returns a list of floats with their objective values.
initial_guess (ndarray[Any, dtype[float64]]) – Single starting point for the optimization.
iteration (int | None) – The current iteration number. This determines which sub-minimizer is used. Must not be None.
bounds (tuple[float, float] | list[tuple[float, float]] | None) – Parameter bounds for the optimization.
circuit (Circuit | None) – The parameterized circuit, passed to the sub-minimizer.
operator (HermitianPauliSum | None) – The operator, passed to the sub-minimizer.

Return type:

MinimizerResult

class EveryNthReminimizerMinimizerCreator

Bases: object

Creator for creating EveryNthReminimizerMinimizer.

__init__() → None

Initialize the EveryNthReminimizerMinimizerCreator.

Return type:: None

create() → EveryNthReminimizerMinimizer

Create the EveryNthReminimizerMinimizer.

The minimizer optimizes the last N (most recently appended) parameters. Earlier parameters are held fixed. This pattern is useful in adaptive VQEs where new parameters are appended over time and, at certain stages, only the freshly introduced subset should be relaxed without disturbing the previously converged portion of the state.

Return type:: EveryNthReminimizerMinimizer

with_minimizer(minimizer: Minimizer | None) → Self

Set the minimizer to use for the EveryNthReminimizerMinimizer.

Parameters:: minimizer (Minimizer | None) – The minimizer to use.
Return type:: Self

with_options(options: EveryNthReminimizerMinimizerOptions | None) → Self

Set options for the EveryNthReminimizerMinimizer.

Parameters:: options (EveryNthReminimizerMinimizerOptions | None) – Options for the minimizer.
Return type:: Self

with_reminimizer(reminimizer: Minimizer | None) → Self

Set the reminimizer to use for the EveryNthReminimizerMinimizer.

Parameters:: reminimizer (Minimizer | None) – The reminimizer to use.
Return type:: Self

class EveryNthReminimizerMinimizerOptions

Bases: DataclassPublicAPI

Options controlling EveryNthReminimizerMinimizer.

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

Parameters:: every_nth_iteration – int, default=1 Frequency at which the reminimizer is used instead of the standard minimizer. When (iteration + 1) % every_nth_iteration == 0, the reminimizer is invoked. Set to 1 to use the reminimizer at every iteration (though this makes the standard minimizer unused).

__init__(*, every_nth_iteration: int = 10) → None

Parameters:: every_nth_iteration (int)
Return type:: None

static __new__(cls, *args: Any, **kwargs: Any) → Any

Parameters:

args (Any)
kwargs (Any)

Return type:

Any

every_nth_iteration: int = 10