Source code for qrisp.algorithms.qaoa.qaoa_problem

"""
********************************************************************************
* Copyright (c) 2025 the Qrisp authors
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the Eclipse
* Public License, v. 2.0 are satisfied: GNU General Public License, version 2
* with the GNU Classpath Exception which is
* available at https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
********************************************************************************
"""

import time

import numpy as np
from scipy.optimize import minimize
from sympy import Symbol

from qrisp import QuantumArray, h, x
from qrisp.algorithms.qaoa.qaoa_benchmark_data import QAOABenchmark

import jax
import jax.numpy as jnp
from qrisp.jasp import check_for_tracing_mode, sample, jrange
from qrisp.jasp.optimization_tools.optimize import minimize as jasp_minimize


[docs] class QAOAProblem: r""" Central structure to facilitate treatment of QAOA problems. This class encapsulates the cost operator, mixer operator, and classical cost function for a specific QAOA problem instance. It also provides methods to set the initial state preparation function, classical cost post-processing function, and optimizer for the problem. For a quick demonstration, we import the relevant functions from already implemented problem instances: :: from networkx import Graph G = Graph() G.add_edges_from([[0,3],[0,4],[1,3],[1,4],[2,3],[2,4]]) from qrisp.qaoa import (QAOAProblem, create_maxcut_cost_operator, create_maxcut_cl_cost_function, RX_mixer) maxcut_instance = QAOAProblem(cost_operator = create_maxcut_cost_operator(G), mixer = RX_mixer, cl_cost_function = create_maxcut_cl_cost_function(G)) from qrisp import QuantumVariable res = maxcut_instance.run(QuantumVariable(5), depth = 4, max_iter = 25) print(res) #Yields: {'11100': 0.2847, '00011': 0.2847, '10000': 0.0219, '01000': 0.0219, '00100': 0.0219, '11011': 0.0219, '10111': 0.0219, '01111': 0.0219, '00010': 0.02, '11110': 0.02, '00001': 0.02, '11101': 0.02, '00000': 0.0173, '11111': 0.0173, '10010': 0.0143, '01010': 0.0143, '11010': 0.0143, '00110': 0.0143, '10110': 0.0143, '01110': 0.0143, '10001': 0.0143, '01001': 0.0143, '11001': 0.0143, '00101': 0.0143, '10101': 0.0143, '01101': 0.0143, '11000': 0.0021, '10100': 0.0021, '01100': 0.0021, '10011': 0.0021, '01011': 0.0021, '00111': 0.0021} For an in-depth tutorial, make sure to check out :ref:`MaxCutQAOA`! Parameters ---------- cost_operator : callable A function receiving a :ref:`QuantumVariable` or :ref:`QuantumArray` and parameter $\gamma$. This function performs the application of the cost operator. mixer : callable A function receiving a :ref:`QuantumVariable` or :ref:`QuantumArray` and parameter $\beta$. This function performs the application mixing operator. cl_cost_function : callable The classical cost function for the specific QAOA problem instance, which takes a dictionary of measurement results as input. init_function : callable, optional A function receiving a :ref:`QuantumVariable` or :ref:`QuantumArray` for preparing the inital state. By default, the uniform superposition state $\ket{+}^n$ is prepared. callback : bool, optional If ``True``, intermediate results are stored. The default is ``False``. """ def __init__( self, cost_operator, mixer, cl_cost_function, init_function=None, callback=False ): self.cost_operator = cost_operator self.mixer = mixer self.cl_cost_function = cl_cost_function self.init_function = init_function # parameters for callback self.callback = callback self.optimization_params = [] self.optimization_costs = [] def set_callback(self): """ Sets ``callback=True`` for saving intermediate results. """ self.callback = True
[docs] def set_init_function(self, init_function): """ Set the initial state preparation function for the QAOA problem. Parameters ---------- init_function : function The initial state preparation function for the specific QAOA problem instance. """ self.init_function = init_function
def computeParams(self, p, dt): """ Compute the angle parameters gamma and beta based on the given inputs. Used for the TQA warm starting the initial parameters for QAOA. Parameters ---------- p : int The number of partitions for the time interval. dt : float The time step. Returns ------- np.array A concatenated numpy array of gamma and beta values. """ if check_for_tracing_mode(): import jax.numpy as jnp else: import numpy as jnp t = (jnp.arange(1, p + 1) - 0.5) / p gamma = t * dt beta = (1 - t) * dt return jnp.concatenate((gamma, beta))
[docs] def compile_circuit(self, qarg, depth, init_type="random"): """ Compiles the circuit that is evaluated by the :meth:`run <qrisp.qaoa.QAOAProblem.run>` method. Parameters ---------- qarg : :ref:`QuantumVariable` or :ref:`QuantumArray` The argument to which the QAOA circuit is applied. depth : int The amount of QAOA layers. init_type : string, optional Specifies the way the initial optimization parameters are chosen. Available are ``random`` and ``tqa``. The default is ``random``: The parameters are initialized uniformly at random in the interval $[0,\pi/2]$. For ``tqa``, the parameters are chosen based on the `Trotterized Quantum Annealing <https://quantum-journal.org/papers/q-2021-07-01-491/>`_ protocol. If ``tqa`` is chosen, and no ``init_function`` for the :ref:`QAOAProblem` is specified, the $\ket{-}^n$ state is prepared (the ground state for the X mixer). Returns ------- compiled_qc : :ref:`QuantumCircuit` The parametrized, compiled quantum circuit without measurements. list[sympy.Symbol] A list of the parameters that appear in ``compiled_qc``. Examples -------- We create a MaxCut instance and compile the circuit: >>> from networkx import Graph >>> G = Graph([(0,1),(1,2),(2,0)]) >>> from qrisp.qaoa import maxcut_problem >>> from qrisp import QuantumVariable >>> p = 5 >>> qaoa_instance = maxcut_problem(G) >>> qarg = QuantumVariable(len(G)) >>> qrisp_qc, symbols = qaoa_instance.compile_circuit(qarg, p) >>> print(qrisp_qc) ┌───┐┌────────┐┌────────┐ » qarg_dupl.0: ┤ H ├┤ gphase ├┤ gphase ├──■────────────────────■──» ├───┤└────────┘└────────┘┌─┴─┐┌──────────────┐ │ » qarg_dupl.1: ┤ H ├────────────────────┤ X ├┤ P(2*gamma_0) ├──┼──» ├───┤ └───┘└──────────────┘┌─┴─┐» qarg_dupl.2: ┤ H ├─────────────────────────────────────────┤ X ├» └───┘ └───┘» « ┌──────────────┐ ┌────────┐ » «qarg_dupl.0: ───────■────────────────────■──┤ Rx(2*beta_0) ├───┤ gphase ├───» « ┌─┴─┐ ┌────────┐ │ └──────────────┘ └────────┘ » «qarg_dupl.1: ─────┤ X ├──────┤ gphase ├──┼─────────■────────────────────────» « ┌────┴───┴─────┐└────────┘┌─┴─┐ ┌─┴─┐ ┌──────────────┐» «qarg_dupl.2: ┤ P(2*gamma_0) ├──────────┤ X ├─────┤ X ├──────┤ P(2*gamma_0) ├» « └──────────────┘ └───┘ └───┘ └──────────────┘» « ┌────────┐ » «qarg_dupl.0: ┤ gphase ├──────────────────■────────────────────■──» « └────────┘┌──────────────┐┌─┴─┐┌──────────────┐ │ » «qarg_dupl.1: ────■─────┤ Rx(2*beta_0) ├┤ X ├┤ P(2*gamma_1) ├──┼──» « ┌─┴─┐ ├──────────────┤└───┘└──────────────┘┌─┴─┐» «qarg_dupl.2: ──┤ X ├───┤ Rx(2*beta_0) ├─────────────────────┤ X ├» « └───┘ └──────────────┘ └───┘» « ┌──────────────┐ ┌────────┐ » «qarg_dupl.0: ───────■────────────────────■──┤ Rx(2*beta_1) ├───┤ gphase ├───» « ┌─┴─┐ ┌────────┐ │ └──────────────┘ └────────┘ » «qarg_dupl.1: ─────┤ X ├──────┤ gphase ├──┼─────────■────────────────────────» « ┌────┴───┴─────┐└────────┘┌─┴─┐ ┌─┴─┐ ┌──────────────┐» «qarg_dupl.2: ┤ P(2*gamma_1) ├──────────┤ X ├─────┤ X ├──────┤ P(2*gamma_1) ├» « └──────────────┘ └───┘ └───┘ └──────────────┘» « ┌────────┐ » «qarg_dupl.0: ┤ gphase ├──────────────────■────────────────────■──» « └────────┘┌──────────────┐┌─┴─┐┌──────────────┐ │ » «qarg_dupl.1: ────■─────┤ Rx(2*beta_1) ├┤ X ├┤ P(2*gamma_2) ├──┼──» « ┌─┴─┐ ├──────────────┤└───┘└──────────────┘┌─┴─┐» «qarg_dupl.2: ──┤ X ├───┤ Rx(2*beta_1) ├─────────────────────┤ X ├» « └───┘ └──────────────┘ └───┘» « ┌──────────────┐ ┌────────┐ » «qarg_dupl.0: ───────■────────────────────■──┤ Rx(2*beta_2) ├───┤ gphase ├───» « ┌─┴─┐ ┌────────┐ │ └──────────────┘ └────────┘ » «qarg_dupl.1: ─────┤ X ├──────┤ gphase ├──┼─────────■────────────────────────» « ┌────┴───┴─────┐└────────┘┌─┴─┐ ┌─┴─┐ ┌──────────────┐» «qarg_dupl.2: ┤ P(2*gamma_2) ├──────────┤ X ├─────┤ X ├──────┤ P(2*gamma_2) ├» « └──────────────┘ └───┘ └───┘ └──────────────┘» « ┌────────┐ » «qarg_dupl.0: ┤ gphase ├──────────────────■────────────────────■──» « └────────┘┌──────────────┐┌─┴─┐┌──────────────┐ │ » «qarg_dupl.1: ────■─────┤ Rx(2*beta_2) ├┤ X ├┤ P(2*gamma_3) ├──┼──» « ┌─┴─┐ ├──────────────┤└───┘└──────────────┘┌─┴─┐» «qarg_dupl.2: ──┤ X ├───┤ Rx(2*beta_2) ├─────────────────────┤ X ├» « └───┘ └──────────────┘ └───┘» « ┌──────────────┐ ┌────────┐ » «qarg_dupl.0: ───────■────────────────────■──┤ Rx(2*beta_3) ├───┤ gphase ├───» « ┌─┴─┐ ┌────────┐ │ └──────────────┘ └────────┘ » «qarg_dupl.1: ─────┤ X ├──────┤ gphase ├──┼─────────■────────────────────────» « ┌────┴───┴─────┐└────────┘┌─┴─┐ ┌─┴─┐ ┌──────────────┐» «qarg_dupl.2: ┤ P(2*gamma_3) ├──────────┤ X ├─────┤ X ├──────┤ P(2*gamma_3) ├» « └──────────────┘ └───┘ └───┘ └──────────────┘» « ┌────────┐ » «qarg_dupl.0: ┤ gphase ├──────────────────■────────────────────■──» « └────────┘┌──────────────┐┌─┴─┐┌──────────────┐ │ » «qarg_dupl.1: ────■─────┤ Rx(2*beta_3) ├┤ X ├┤ P(2*gamma_4) ├──┼──» « ┌─┴─┐ ├──────────────┤└───┘└──────────────┘┌─┴─┐» «qarg_dupl.2: ──┤ X ├───┤ Rx(2*beta_3) ├─────────────────────┤ X ├» « └───┘ └──────────────┘ └───┘» « ┌──────────────┐ » «qarg_dupl.0: ───────■────────────────────■──┤ Rx(2*beta_4) ├────────────────» « ┌─┴─┐ ┌────────┐ │ └──────────────┘ » «qarg_dupl.1: ─────┤ X ├──────┤ gphase ├──┼─────────■────────────────────────» « ┌────┴───┴─────┐└────────┘┌─┴─┐ ┌─┴─┐ ┌──────────────┐» «qarg_dupl.2: ┤ P(2*gamma_4) ├──────────┤ X ├─────┤ X ├──────┤ P(2*gamma_4) ├» « └──────────────┘ └───┘ └───┘ └──────────────┘» « «qarg_dupl.0: ───────────────────── « ┌──────────────┐ «qarg_dupl.1: ──■──┤ Rx(2*beta_4) ├ « ┌─┴─┐├──────────────┤ «qarg_dupl.2: ┤ X ├┤ Rx(2*beta_4) ├ « └───┘└──────────────┘ """ temp = list(qarg.qs.data) # Define QAOA angle parameters gamma and beta for QAOA circuit gamma = [Symbol("gamma_" + str(i)) for i in range(depth)] beta = [Symbol("beta_" + str(i)) for i in range(depth)] # Prepare initial state - if no init_function is specified, prepare uniform superposition if self.init_function is not None: self.init_function(qarg) elif ( init_type == "tqa" ): # Prepare the ground state (eigenvalue -1) of the X mixer x(qarg) h(qarg) else: h(qarg) # Apply p layers of phase separators and mixers for i in range(depth): self.cost_operator(qarg, gamma[i]) self.mixer(qarg, beta[i]) # Compile quantum circuit with intended measurements if isinstance(qarg, QuantumArray): intended_measurement_qubits = sum([list(qv) for qv in qarg.flatten()], []) else: intended_measurement_qubits = list(qarg) compiled_qc = qarg.qs.compile(intended_measurements=intended_measurement_qubits) qarg.qs.data = temp return compiled_qc, gamma + beta
def optimization_routine( self, qarg_prep, depth, mes_kwargs, init_type, init_point, optimizer, options ): """ Wrapper subroutine for the optimization method used in QAOA. The initial values are set and the optimization via ``COBYLA`` is conducted here. Parameters ---------- qarg_prep : callable A function returning a :ref:`QuantumVariable` or :ref:`QuantumArray` to which the QAOA circuit is applied. depth : int The amont of QAOA layers. symbols : list The list of symbols used in the quantum circuit. mes_kwargs : dict, optional The keyword arguments for the measurement function. Default is an empty dictionary, as defined in previous functions. init_type : string, optional Specifies the way the initial optimization parameters are chosen. Available are ``random`` and ``tqa``. The default is ``random``. init_point : ndarray, shape (n,), optional Specifies the initial optimization parameters. optimizer : str, optional Specifies the `SciPy optimization routine <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html>`_. Available are, e.g., ``COBYLA``, ``COBYQA``, ``Nelder-Mead``. The Default is ``COBYLA``. In tracing mode (i.e. Jasp) Jax-traceable :ref:`optimization routines <optimization_tools>` must be utilized. Available are ``SPSA``. The Default is ``SPSA``. options : dict A dictionary of solver options. Returns ------- ndarray, shape (n,) The optimized parameters of the problem instance. float or jax.Array The expectation value of the classical cost function for the optimized parameters. """ if check_for_tracing_mode(): # Define optimization wrapper function to be minimized using QAOA def optimization_wrapper(theta, state_prep, mes_kwargs): """ Wrapper function for the optimization method used in QAOA. This function calculates the value of the classical cost function. Parameters ---------- theta : jax.Array The array of angle parameters gamma and beta for the QAOA circuit. state_prep : callable A function returning a :ref:`QuantumVariable` or :ref:`QuantumArray`. The expectation of the classical cost function from the state of this QuantumVariable will be measured. The state preparation function can only take classical values as arguments. This is because a quantum value would need to be copied for each sampling iteration, which is prohibited by the no-cloning theorem. mes_kwargs : dict The keyword arguments for the sample function. Returns ------- float The expected value of the classical cost function. """ res_sample = sample(state_prep, shots=mes_kwargs["shots"])(theta) cl_cost = self.cl_cost_function(res_sample) return cl_cost def tqa_angles(p, state_prep, mes_kwargs, steps=10): """ Compute the optimal parameters for the Trotterized Quantum Annealing (`TQA <https://quantum-journal.org/papers/q-2021-07-01-491/>`_) algorithm. The function first creates a linspace array `dt` from 0.1 to 1 with `steps` steps. Then for each `dt_` in `dt`, it computes the parameters `x` using the `computeParams` function and calculates the energy `energy_` using the `optimization_wrapper` function. The energy values are stored in the `energy` list. The `dt_max` corresponding to the minimum energy is found and used to compute the optimal parameters which are returned. Parameters ---------- p : int The number of partitions for the time interval. state_prep : callable A function returning a :ref:`QuantumVariable` or :ref:`QuantumArray`. mes_kwargs : dict The measurement keyword arguments. steps : int, optional The number of steps for the linspace function, default is 10. Returns ------- jax.Array A concatenated jax.numpy array of optimal gamma and beta values. """ dt = jnp.linspace(0.1, 1, steps) energy = jnp.array([0.0] * steps) for i in range(steps): theta = self.computeParams(p, dt[i]) energy_ = optimization_wrapper(theta, state_prep, mes_kwargs) energy = energy.at[i].set(energy_) idx = jnp.argmin(energy) dt_max = dt[idx] return self.computeParams(p, dt_max) else: # Define optimization wrapper function to be minimized using QAOA def optimization_wrapper(theta, qarg, qc, symbols, mes_kwargs): """ Wrapper function for the optimization method used in QAOA. This function calculates the value of the classical cost function. Parameters ---------- theta : list The list of angle parameters gamma and beta for the QAOA circuit. qarg : :ref:`QuantumVariable` or :ref:`QuantumArray` The quantum argument to which the quantum circuit is applied. qc : :ref:`QuantumCircuit` The compiled quantum circuit. symbols : list The list of symbols used in the quantum circuit. mes_kwargs : dict The keyword arguments for the measurement function. Returns ------- float The expected value of the classical cost function. """ subs_dic = {symbols[i]: theta[i] for i in range(len(symbols))} res_dic = qarg.get_measurement( subs_dic=subs_dic, precompiled_qc=qc, **mes_kwargs ) cl_cost = self.cl_cost_function(res_dic) if self.callback: self.optimization_costs.append(cl_cost) return cl_cost def tqa_angles(p, qarg, qc, symbols, mes_kwargs, steps=10): """ Compute the optimal parameters for the Trotterized Quantum Annealing (`TQA <https://quantum-journal.org/papers/q-2021-07-01-491/>`_) algorithm. The function first creates a linspace array `dt` from 0.1 to 1 with `steps` steps. Then for each `dt_` in `dt`, it computes the parameters `x` using the `computeParams` function and calculates the energy `energy_` using the `optimization_wrapper` function. The energy values are stored in the `energy` list. The `dt_max` corresponding to the minimum energy is found and used to compute the optimal parameters which are returned. Parameters ---------- p : int The number of partitions for the time interval. qarg : :ref:`QuantumVariable` or :ref:`QuantumArray` The quantum argument to which the quantum circuit is applied. qc : :ref:`QuantumCircuit` The quantum circuit for the specific problem instance. symbols : list The list of symbols in the quantum circuit. mes_kwargs : dict The measurement keyword arguments. steps : int, optional The number of steps for the linspace function, default is 10. Returns ------- np.array A concatenated numpy array of optimal gamma and beta values. """ dt = np.linspace(0.1, 1, steps) energy = [] for dt_ in dt: theta = self.computeParams(p, dt_) energy_ = optimization_wrapper(theta, qarg, qc, symbols, mes_kwargs) energy.append(energy_) idx = np.argmin(energy) dt_max = dt[idx] return self.computeParams(p, dt_max) if check_for_tracing_mode(): def state_prep(theta): qarg = qarg_prep() # Prepare initial state - if no init_function is specified, prepare uniform superposition if self.init_function is not None: self.init_function(qarg) elif ( init_type == "tqa" ): # Prepare the ground state (eigenvalue -1) of the X mixer x(qarg) h(qarg) else: h(qarg) # Apply p layers of phase separators and mixers for i in jrange(depth): self.cost_operator(qarg, theta[i]) self.mixer(qarg, theta[i + depth]) return qarg else: qarg = qarg_prep() compiled_qc, symbols = self.compile_circuit(qarg, depth, init_type) # Initialization for optimization parameters if init_point is None: if init_type == "random": # Random initialization if check_for_tracing_mode(): key = jax.random.key(11) init_point = ( jax.random.uniform(key=key, shape=(2 * depth,)) * jnp.pi / 2 ) else: init_point = np.random.rand(2 * depth) * np.pi / 2 elif init_type == "tqa": # TQA initialization if check_for_tracing_mode(): init_point = tqa_angles(depth, state_prep, mes_kwargs) else: init_point = tqa_angles( depth, qarg, compiled_qc, symbols, mes_kwargs ) else: raise Exception( f"Parameter initialization method {init_type} is not available." ) if check_for_tracing_mode(): res_sample = jasp_minimize( optimization_wrapper, init_point, method=optimizer, options=options, args=( state_prep, mes_kwargs, ), ) return res_sample.x, res_sample.fun else: res_sample = minimize( optimization_wrapper, init_point, method=optimizer, options=options, args=(qarg, compiled_qc, symbols, mes_kwargs), ) return res_sample.x, res_sample.fun
[docs] def run( self, qarg, depth, mes_kwargs={}, max_iter=50, init_type="random", init_point=None, optimizer="COBYLA", options={}, ): """ Run the specific QAOA problem instance with given quantum arguments, depth of QAOA circuit, measurement keyword arguments (mes_kwargs) and maximum iterations for optimization (max_iter). Parameters ---------- qarg : :ref:`QuantumVariable` or :ref:`QuantumArray` or callable The argument to which the QAOA circuit is applied, or a function returning a :ref:`QuantumVariable` or :ref:`QuantumArray` to which the QAOA circuit is applied. depth : int The amount of QAOA layers. mes_kwargs : dict, optional The keyword arguments for the measurement function. Default is an empty dictionary. max_iter : int, optional The maximum number of iterations for the optimization method. Default is 50. init_type : string, optional Specifies the way the initial optimization parameters are chosen. Available are ``random`` and ``tqa``. The default is ``random``: The parameters are initialized uniformly at random in the interval $[0,\pi/2]$. For ``tqa``, the parameters are chosen based on the `Trotterized Quantum Annealing <https://quantum-journal.org/papers/q-2021-07-01-491/>`_ protocol. If ``tqa`` is chosen, and no ``init_function`` for the :ref:`QAOAProblem` is specified, the $\ket{-}^n$ state is prepared (the ground state for the X mixer). init_point : ndarray, shape (n,), optional Specifies the initial optimization parameters. optimizer : str, optional Specifies the `SciPy optimization routine <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html>`_. Available are, e.g., ``COBYLA``, ``COBYQA``, ``Nelder-Mead``. The Default is ``COBYLA``. In tracing mode (i.e. Jasp) Jax-traceable :ref:`optimization routines <optimization_tools>` must be utilized. Available are ``COBYLA``, ``SPSA``. options : dict A dictionary of solver options. Returns ------- dict or jax.Array The optimal result after running QAOA problem for a specific problem instance. It contains the measurement results after applying the optimal QAOA circuit to the quantum argument. """ if callable(qarg): qarg_prep = qarg else: if isinstance(qarg, QuantumArray): template = qarg.qtype.template() shape = qarg.shape def qarg_prep(): return QuantumArray(qtype=template.construct(), shape=shape) else: template = qarg.template() def qarg_prep(): return template.construct() # Set default options options["maxiter"] = max_iter if not "shots" in mes_kwargs: mes_kwargs["shots"] = 5000 # Delete callback self.optimization_params = [] self.optimization_costs = [] opt_theta, opt_res = self.optimization_routine( qarg_prep, depth, mes_kwargs, init_type, init_point, optimizer, options ) def state_prep(theta): qarg = qarg_prep() # Prepare initial state - if no init_function is specified, prepare uniform superposition if self.init_function is not None: self.init_function(qarg) elif ( init_type == "tqa" ): # Prepare the ground state (eigenvalue -1) of the X mixer x(qarg) h(qarg) else: h(qarg) # Apply p layers of phase separators and mixers for i in jrange(depth): self.cost_operator(qarg, theta[i]) self.mixer(qarg, theta[i + depth]) return qarg if check_for_tracing_mode(): res_sample = sample(state_prep, shots=mes_kwargs["shots"])(opt_theta) else: qarg = state_prep(opt_theta) res_sample = qarg.get_measurement(**mes_kwargs) return res_sample
[docs] def train_function( self, qarg, depth, mes_kwargs={}, max_iter=50, init_type="random", init_point=None, optimizer="COBYLA", options={}, ): r""" This function allows for training of a circuit with a given ``QAOAProblem`` instance. It returns a function that can be applied to a ``QuantumVariable``, such that it represents a solution to the problem instance. When applied to a ``QuantumVariable``, the function therefore prepares the state .. math:: \ket{\psi_p}=U_M(B,\beta_p)U_P(C,\gamma_p)\dotsb U_M(B,\beta_1)U_P(C,\gamma_1)\ket{\psi_0} with optimized parameters $\gamma, \beta$. Parameters ---------- qarg : :ref:`QuantumVariable` or :ref:`QuantumArray` or callable The argument to which the QAOA circuit is applied, or a function returning a :ref:`QuantumVariable` or :ref:`QuantumArray` to which the QAOA circuit is applied. depth : int The amount of QAOA layers. mes_kwargs : dict, optional The keyword arguments for the measurement function. Default is an empty dictionary. max_iter : int, optional The maximum number of iterations for the optimization method. Default is 50. init_type : string, optional Specifies the way the initial optimization parameters are chosen. Available are ``random`` and ``tqa``. The default is ``random``: The parameters are initialized uniformly at random in the interval $[0,\pi/2]$. For ``tqa``, the parameters are chosen based on the `Trotterized Quantum Annealing <https://quantum-journal.org/papers/q-2021-07-01-491/>`_ protocol. If ``tqa`` is chosen, and no ``init_function`` for the :ref:`QAOAProblem` is specified, the $\ket{-}^n$ state is prepared (the ground state for the X mixer). init_point : ndarray, shape (n,), optional Specifies the initial optimization parameters. optimizer : str, optional Specifies the `SciPy optimization routine <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html>`_. Available are, e.g., ``COBYLA``, ``COBYQA``, ``Nelder-Mead``. The Default is ``COBYLA``. In tracing mode (i.e. Jasp) Jax-traceable :ref:`optimization routines <optimization_tools>` must be utilized. Available are ``COBYLA``, ``SPSA``. options : dict A dictionary of solver options. Returns ------- circuit_generator : function A function that can be applied to a ``QuantumVariable`` , with optimized parameters for the problem instance. The ``QuantumVariable`` then represents a solution of the problem. Examples -------- We create a :ref:`MaxIndepSet <maxIndepSetQAOA>` instance and train a ciruit with the :ref:`QAOAProblem` instance. :: from qrisp import QuantumVariable from qrisp.qaoa import QAOAProblem, RZ_mixer, create_max_indep_set_cl_cost_function, create_max_indep_set_mixer, max_indep_set_init_function import networkx as nx import matplotlib.pyplot as plt G = nx.erdos_renyi_graph(9, 0.5, seed = 133) qaoa_instance = QAOAProblem(cost_operator=RZ_mixer, mixer=create_max_indep_set_mixer(G), cl_cost_function=create_max_indep_set_cl_cost_function(G), init_function=max_indep_set_init_function) # create a blueprint-qv to train the circuit with the problem instance qarg = QuantumVariable(G.number_of_nodes()) training_func = qaoa_instance.train_function(qarg, depth=5) # apply the trained function to a new qv qarg_trained = QuantumVariable(G.number_of_nodes()) training_func(qarg_trained) # get the measurement results opt_res = qarg_trained.get_measurement() cl_cost = create_max_indep_set_cl_cost_function(G) print("5 most likely solutions") max_five = sorted(opt_res.items(), key=lambda item: item[1], reverse=True)[:5] for res, prob in max_five: print([index for index, value in enumerate(res) if value == '1'], prob, cl_cost({res : 1})) """ if callable(qarg): qarg_prep = qarg else: if isinstance(qarg, QuantumArray): template = qarg.qtype.template() shape = qarg.shape def qarg_prep(): return QuantumArray(qtype=template.construct(), shape=shape) else: template = qarg.template() def qarg_prep(): return template.construct() # Set default options options["maxiter"] = max_iter if not "shots" in mes_kwargs: mes_kwargs["shots"] = 5000 opt_theta, opt_res = self.optimization_routine( qarg_prep, depth, mes_kwargs, init_type, init_point, optimizer, options ) def circuit_generator(qarg_gen): # Prepare initial state - if no init_function is specified, prepare uniform superposition if self.init_function is not None: self.init_function(qarg_gen) elif ( init_type == "tqa" ): # Prepare the ground state (eigenvalue -1) of the X mixer x(qarg_gen) h(qarg_gen) else: h(qarg_gen) for i in jrange(depth): self.cost_operator(qarg_gen, opt_theta[i]) self.mixer(qarg_gen, opt_theta[i + depth]) return circuit_generator
[docs] def benchmark( self, qarg, depth_range, shot_range, iter_range, optimal_solution, repetitions=1, mes_kwargs={}, init_type="random", optimizer="COBYLA", options={}, ): """ This method enables convenient data collection regarding performance of the implementation. Parameters ---------- qarg : :ref:`QuantumVariable` or :ref:`QuantumArray` or callable The argument to which the QAOA circuit is applied, or a function returning a :ref:`QuantumVariable` or :ref:`QuantumArray` to which the QAOA circuit is applied. Compare to the :meth:`.run <qrisp.qaoa.QAOAProblem.run>` method. depth_range : list[int] A list of integers indicating, which depth parameters should be explored. Depth means the amount of QAOA layers. shot_range : list[int] A list of integers indicating, which shots parameters should be explored. Shots means the amount of repetitions, the backend performs per iteration. iter_range : list[int] A list of integers indicating, what iterations parameter should be explored. Iterations means the amount of backend calls, the optimizer is allowed to do. optimal_solution : - The optimal solution to the problem. Should have the same type as the keys of the result of ``qarg.get_measurement()``. repetitions : int, optional The amount of repetitions, each parameter constellation should go though. Can be used to get a better statistical significance. The default is 1. mes_kwargs : dict, optional The keyword arguments, that are used for the ``qarg.get_measurement``. The default is {}. init_type : string, optional Specifies the way the initial optimization parameters are chosen. Available are ``random`` and ``tqa``. The default is ``random``: The parameters are initialized uniformly at random in the interval $[0,\pi/2]$. For ``tqa``, the parameters are chosen based on the `Trotterized Quantum Annealing <https://quantum-journal.org/papers/q-2021-07-01-491/>`_ protocol. If ``tqa`` is chosen, and no ``init_function`` for the :ref:`QAOAProblem` is specified, the $\ket{-}^n$ state is prepared (the ground state for the X mixer). optimizer : str, optional Specifies the `SciPy optimization routine <https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html>`_. Available are, e.g., ``COBYLA``, ``COBYQA``, ``Nelder-Mead``. The Default is ``COBYLA``. options : dict A dictionary of solver options. Returns ------- :ref:`QAOABenchmark` The results of the benchmark. Examples -------- We create a MaxCut instance and benchmark several parameters :: from qrisp import * from networkx import Graph G = Graph() G.add_edges_from([[0,3],[0,4],[1,3],[1,4],[2,3],[2,4]]) from qrisp.qaoa import maxcut_problem max_cut_instance = maxcut_problem(G) benchmark_data = max_cut_instance.benchmark(QuantumVariable(5), depth_range = [3,4,5], shot_range = [5000, 10000], iter_range = [25, 50], optimal_solution = "11100", repetitions = 2 ) We can investigate the data by calling ``visualize``: :: benchmark_data.visualize() .. image:: benchmark_plot.png The :ref:`QAOABenchmark` class contains a variety of methods to help you drawing conclusions from the collected data. Make sure to check them out! """ if callable(qarg): qarg_prep = qarg else: if isinstance(qarg, QuantumArray): template = qarg.qtype.template() shape = qarg.shape def qarg_prep(): return QuantumArray(qtype=template.construct(), shape=shape) else: template = qarg.template() def qarg_prep(): return template.construct() data_dict = { "layer_depth": [], "circuit_depth": [], "qubit_amount": [], "shots": [], "iterations": [], "counts": [], "runtime": [], "cl_cost": [], } for p in depth_range: for s in shot_range: for it in iter_range: for k in range(repetitions): start_time = time.time() temp_mes_kwargs = dict(mes_kwargs) temp_mes_kwargs["shots"] = s counts = self.run( qarg_prep, depth=p, max_iter=it, mes_kwargs=temp_mes_kwargs, init_type=init_type, optimizer=optimizer, options=options, ) final_time = time.time() - start_time compiled_qc, _ = self.compile_circuit(qarg_prep(), depth=p) data_dict["layer_depth"].append(p) data_dict["circuit_depth"].append(compiled_qc.depth()) data_dict["qubit_amount"].append(compiled_qc.num_qubits()) data_dict["shots"].append(s) data_dict["iterations"].append(it) data_dict["counts"].append(counts) data_dict["runtime"].append(final_time) return QAOABenchmark(data_dict, optimal_solution, self.cl_cost_function)
[docs] def visualize_cost(self): """ Visualizes the cost during the optimization process. Can only be used if ``callback=True``. """ import matplotlib.pyplot as plt if not self.callback: raise Exception( "Visualization can only be performed for a QAOA instance with callback=True" ) x = list(range(len(self.optimization_costs))) y = self.optimization_costs plt.scatter( x, y, color="#20306f", marker="o", linestyle="solid", linewidth=1, label="QAOA cost", ) plt.xlabel("Iterations", fontsize=15, color="#444444") plt.ylabel("Cost", fontsize=15, color="#444444") plt.tick_params(axis="both", labelsize=12) plt.legend(fontsize=12, labelcolor="#444444") plt.grid() plt.show()