Performs gradient-based deterministic optimization of generic real-valued functions.
Use this function to determine a choice of variables that minimizes the
value of a scalar real-valued cost function of those variables. You
express that cost function as a graph describing how the input variables
are transformed into the cost value.
Note that this function will pick a different initial guess for each optimization run.
You can provide initial values (or a list of them of the same length) for the
optimization variables in the graph, and the optimizer will start with those values.
If the optimization_count is larger than the number of provided initial
values, the optimizer will use random values after consuming all available initial
values.
See also
calculate_graph()
Notes
Given a cost function \(C(\mathbf v)\) of variables \(\mathbf v\), this
function computes an estimate \(\mathbf v_\mathrm{optimized}\) of
\(\mathrm{argmin}_{\mathbf v} C(\mathbf v)\), namely the choice of
variables \(\mathbf v\) that minimizes \(C(\mathbf v)\). The function
then calculates the values of arbitrary output functions
\(\{F_j(\mathbf v_\mathrm{optimized})\}\) with that choice of variables.
This function represents the cost and output functions as nodes of a
graph. This graph defines the input optimization variables \(\mathbf v\),
and how these variables are transformed into the corresponding cost and
output quantities. You build the graph from primitive nodes defined in
the
operations namespace of the Q-CTRL Python package.
Each such node, which can be identified by a name, represents a function
of the previous nodes in the graph (and thus, transitively, a function of
the input variables). You can use any named scalar real-valued node \(s\)
as the cost function, and any named nodes \(\{s_j\}\) as outputs.
After you provide a cost function \(C(\mathbf v)\) (via a graph), this
function runs an optimization process \(N\) times, each with random
initial variables, to identify \(N\) local minima of the cost function,
and then takes the variables corresponding to the best such minimum as
\(\mathbf v_\mathrm{optimized}\).
A common use-case for this function is to determine controls for a
quantum system that yield an optimal gate: the variables \(\mathbf v\)
parameterize the controls to be optimized, and the cost function
\(C(\mathbf v)\) is the operational infidelity describing the quality of
the resulting gate relative to a target gate. When combined with the node
definitions in the Q-CTRL Python package, which make it convenient to
define such cost functions, this function provides a highly configurable
framework for quantum control that encapsulates other common tools such
as gradient ascent pulse engineering and chopped random basis (CRAB)
optimization .
The optimizer will carry out the gradient-based optimization until it
converges to a minimum. You can set up early stop conditions such as a
target cost or a maximum number of cost evaluations via the target_cost
and max_iteration_count parameters. If both are provided, the optimizer
will terminate when either of the two conditions is satisfied.
References
Examples
See the How to optimize controls in D-dimensional systems using graphs
user guide.