Mga optimization loop

Sa araling ito, matututunan natin kung paano gamitin ang isang optimizer para iteratibong tuklasin ang mga parameterized quantum state ng ating ansatz:

• Mag-bootstrap ng optimization loop
• Unawain ang mga trade-off sa paggamit ng local at global na optimizer
• Tuklasin ang mga barren plateau at kung paano maiiwasan ang mga ito

Sa mataas na antas, ang mga optimizer ay sentral sa pagtuklas ng ating search space. Ginagamit ng optimizer ang mga ebalwasyon ng cost function para piliin ang susunod na hanay ng mga parameter sa isang variational loop, at inuulit ang proseso hanggang sa maabot nito ang isang stable na estado. Sa yugtong ito, ibinabalik ang isang optimal na hanay ng mga parameter value na $\vec\theta^*$.

Mga Local at Global na Optimizer

Una, i-set up natin ang ating problema bago tuklasin ang bawat klase ng optimizer. Magsisimula tayo sa isang circuit na may walong variational parameter:

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit scipy

from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit.library import TwoLocal
import numpy as np

theta_list = (2 * np.pi * np.random.rand(1, 8)).tolist()
observable = SparsePauliOp.from_list([("XX", 1), ("YY", -3)])

reference_circuit = QuantumCircuit(2)
reference_circuit.x(0)

variational_form = TwoLocal(
    2,
    rotation_blocks=["rz", "ry"],
    entanglement_blocks="cx",
    entanglement="linear",
    reps=1,
)
ansatz = reference_circuit.compose(variational_form)

ansatz.decompose().draw("mpl")

def cost_func_vqe(params, ansatz, hamiltonian, estimator):
    """Return estimate of energy from estimator

    Parameters:
        params (ndarray): Array of ansatz parameters
        ansatz (QuantumCircuit): Parameterized ansatz circuit
        hamiltonian (SparsePauliOp): Operator representation of Hamiltonian
        estimator (Estimator): Estimator primitive instance

    Returns:
        float: Energy estimate
    """
    pub = (ansatz, hamiltonian, params)
    cost = estimator.run([pub]).result()[0].data.evs
    return cost

from qiskit.primitives import StatevectorEstimator

estimator = StatevectorEstimator()

Mga Local na Optimizer

Ang mga local optimizer ay naghahanap ng punto na nagpapaliit ng cost function simula sa isang panimulang punto(s) na $C(\vec{\theta_0})$ at gumagalaw sa iba't ibang punto batay sa kanilang nakita sa rehiyon na kasalukuyan nilang sinusuri sa magkakasunod na iterasyon. Ibig sabihin, ang convergence ng mga algorithm na ito ay karaniwang mabilis, ngunit maaaring labis na nakasalalay sa panimulang punto. Hindi nakikita ng mga local optimizer ang lampas sa rehiyong kanilang sinusuri at maaaring lalo silang mahina sa mga local na minimum, nag-uulat ng convergence kapag natagpuan nila ito at binabalewala ang iba pang estado na may mas kanais-nais na ebalwasyon.

# SciPy minimizer routine
from scipy.optimize import minimize

x0 = np.ones(8)

result = minimize(
    cost_func_vqe, x0, args=(ansatz, observable, estimator), method="SLSQP"
)

result

message: Optimization terminated successfully
 success: True
  status: 0
     fun: -3.9999999964520634
       x: [ 1.000e+00  1.000e+00 -1.571e+00 -4.556e-05 -1.207e+00
           -1.935e+00  4.079e-01 -4.079e-01]
     nit: 12
     jac: [ 0.000e+00  0.000e+00 -7.957e-04  2.543e-04  1.381e-03
            1.381e-03  5.430e-04  5.431e-04]
    nfev: 112
    njev: 12

Mga Global na Optimizer

Ang mga global optimizer ay naghahanap ng punto na nagpapaliit ng cost function sa ilang rehiyon ng domain nito (ibig sabihin, non-local), sinusuri ito nang iteratibo (ibig sabihin, sa iterasyon $i$) sa isang hanay ng mga parameter vector na $\Theta_i := \\{ {\vec\theta_{i,j} | j \in \mathcal{J}_\text{opt}^i} \\}$ na tinutukoy ng optimizer. Dahil dito, hindi sila kasing kahinaan sa mga local na minimum at medyo independyente sa initialization, ngunit mas mabagal din sa pag-converge sa isang mungkahing solusyon.

Bootstrapping Optimization

Ang bootstrapping, o ang pagtatakda ng panimulang halaga para sa mga parameter na $\vec\theta$ batay sa naunang optimization, ay makakatulong sa ating optimizer na mas mabilis na mag-converge sa isang solusyon. Tinutukoy natin ito bilang ang panimulang punto na $\vec\theta_0$, at $|\psi(\vec\theta_0)\rangle = U_V(\vec\theta_0)|\rho\rangle$ bilang ang panimulang estado. Naiiba ang panimulang estadong ito mula sa ating reference state na $|\rho\rangle$, dahil ang una ay nakatuon sa mga panimulang parameter na itinakda sa ating optimization loop, habang ang huli ay nakatuon sa paggamit ng mga kilalang "reference" na solusyon. Maaaring magtagpo ang mga ito kung $U_V(\vec\theta_0) \equiv I$ (ibig sabihin, ang identity operation).

Kapag ang mga local optimizer ay nag-converge sa mga hindi optimal na local na minimum, maaari nating subukang i-bootstrap ang optimization nang globally at pinuhin ang convergence nang locally. Kahit na nangangailangan ito ng pag-set up ng dalawang variational workload, nagbibigay-daan ito sa optimizer na mahanap ang isang mas optimal na solusyon kaysa sa local optimizer lamang.

Mga Gradient-Based at Gradient-Free na Optimizer

Gradient-Based

Para sa ating cost function na $C(\vec\theta)$, kung mayroon tayong access sa gradient ng function na $\vec{\nabla} C(\vec\theta)$ simula sa isang panimulang punto, ang pinakasimpleng paraan para mabawasan ang function ay ang i-update ang mga parameter patungo sa direksyon ng pinakamabilis na pagbaba ng function. Ibig sabihin, ina-update natin ang mga parameter bilang $\vec\theta_{n+1} = \vec\theta_n - \eta \vec{\nabla} C(\vec\theta)$, kung saan ang $\eta$ ay ang learning rate — isang maliit, positibong hyperparameter na kumokontrol sa laki ng update. Patuloy nating ginagawa ito hanggang sa mag-converge tayo sa isang local minimum ng cost function na $C({\vec\theta^*})$. Maaari nating gamitin ang cost function na ito at isang optimizer para kalkulahin ang mga optimal na parameter

# SciPy minimizer routine
from scipy.optimize import minimize

x0 = np.ones(8)

result = minimize(
    cost_func_vqe, x0, args=(ansatz, observable, estimator), method="BFGS"
)

result

message: Optimization terminated successfully.
  success: True
   status: 0
      fun: -3.9999999999997025
        x: [ 1.000e+00  1.000e+00  1.571e+00  3.220e-07  2.009e-01
            -2.009e-01  6.342e-01 -6.342e-01]
      nit: 14
      jac: [-1.192e-07 -2.980e-08  8.345e-07  1.103e-06  5.960e-08
             0.000e+00 -5.960e-08  2.980e-08]
 hess_inv: [[ 1.000e+00  1.872e-10 ...  5.077e-05  3.847e-05]
            [ 1.872e-10  1.000e+00 ... -5.208e-05 -4.060e-05]
            ...
            [ 5.077e-05 -5.208e-05 ...  7.243e-01 -2.604e-01]
            [ 3.847e-05 -4.060e-05 ... -2.604e-01  8.179e-01]]
     nfev: 144
     njev: 16

Ang mga pangunahing disadvantage ng ganitong uri ng optimization ay ang bilis ng convergence, na maaaring napakabagal, at walang garantiya na maaabot ang optimal na solusyon.

Gradient-Free

Ang mga gradient-free optimization algorithm ay hindi nangangailangan ng impormasyon ng gradient at maaaring maging kapaki-pakinabang sa mga sitwasyon kung saan ang pagkalkula ng gradient ay mahirap, mahal, o masyadong maingay. Mas matatag din ang mga ito sa paghahanap ng mga global optima, habang ang mga gradient-based na pamamaraan ay karaniwang nag-converge sa mga local optima. Tuklasin natin ang ilang pagkakataon kung saan ang isang gradient-free optimizer ay makakatulong na maiwasan ang mga barren plateau. Gayunpaman, nangangailangan ang mga gradient-free na pamamaraan ng mas mataas na computational resources, lalo na para sa mga problemang may mataas na dimensyon na search space.

Narito ang isang halimbawa na gumagamit ng COBYLA optimizer sa halip:

# SciPy minimizer routine
from scipy.optimize import minimize

x0 = np.ones(8)

result = minimize(
    cost_func_vqe, x0, args=(ansatz, observable, estimator), method="COBYLA"
)

result

message: Optimization terminated successfully.
 success: True
  status: 1
     fun: -3.999999973369678
       x: [ 1.631e+00  1.492e+00  1.571e+00  3.142e+00  1.375e+00
           -1.767e+00  1.484e+00  1.658e+00]
    nfev: 137
   maxcv: 0.0

Mga Barren Plateau

Sa totoo lang, ang cost landscape ay maaaring maging medyo kumplikado, tulad ng ipinapakita ng mga burol at lambak sa halimbawa sa ibaba. Ang optimization method ay gumagabay sa atin sa cost landscape, naghahanap ng minimum, tulad ng ipinapakita ng mga itim na tuldok at linya. Makikita natin na dalawa sa tatlong paghahanap ay nagtatapos sa isang local na minimum ng landscape, sa halip na isang global na minimum.

Anuman ang uri ng optimization method na ginamit, kung ang cost landscape ay medyo flat, maaaring mahirap para sa method na matukoy ang tamang direksyon ng paghahanap. Ang senaryong ito ay tinutukoy bilang isang barren plateau, kung saan ang cost landscape ay unti-unting nagiging mas flat (at sa gayon mas mahirap tukuyin ang direksyon patungo sa minimum). Para sa malawak na hanay ng mga parameterized quantum circuit, ang posibilidad na ang gradient sa anumang makatwirang direksyon ay hindi zero sa ilang nakapirming katumpakan ay exponentially bumababa habang tumataas ang bilang ng mga qubit.

Habang ang larangang ito ay nasa aktibong pananaliksik pa rin, mayroon kaming ilang rekomendasyon para mapabuti ang performance ng optimization:

• Bootstrapping ay makakatulong sa optimization loop na maiwasan ang mabitin sa isang parameter space kung saan maliit ang gradient.
• Pag-eeksperimento sa hardware-efficient ansatz: Dahil gumagamit tayo ng maingay na quantum system bilang isang black-box oracle, ang kalidad ng mga ebalwasyong iyon ay maaaring makaapekto sa performance ng optimizer. Ang paggamit ng hardware-efficient ansatz, tulad ng EfficientSU2, ay maaaring maiwasan ang paggawa ng exponentially maliit na mga gradient.
• Pag-eeksperimento sa error suppression at error mitigation: Ang mga Qiskit Runtime primitive ay nagbibigay ng simpleng interface para mag-eksperimento sa iba't ibang halaga para sa optimization_level at resilience_setting, ayon sa pagkakasunod. Makakatulong ito na mabawasan ang epekto ng ingay at gawing mas mahusay ang proseso ng optimization.
• Pag-eeksperimento sa mga gradient-free optimizer: Hindi tulad ng mga gradient-based optimization algorithm, ang mga optimizer tulad ng COBYLA ay hindi umaasa sa impormasyon ng gradient para i-optimize ang mga parameter at samakatuwid ay hindi gaanong maaapektuhan ng barren plateau.

Buod

Sa araling ito, natutunang tukuyin ang iyong optimization loop:

• Mag-bootstrap ng optimization loop
• Unawain ang mga trade-off sa paggamit ng local at global na optimizer
• Tuklasin ang mga barren plateau at kung paano maiiwasan ang mga ito

Kumpleto na ang ating mataas na antas na variational workload:

Susunod, tutuklasin natin ang mga tiyak na variational algorithm na may framework na ito sa isip.