Loop optimasi

Dalam pelajaran ini, kita akan belajar cara menggunakan sebuah optimizer untuk mengeksplorasi state kuantum terparameter dari ansatz kita secara iteratif:

• Bootstrap loop optimasi
• Memahami trade-off saat menggunakan optimizer lokal dan global
• Mengeksplorasi barren plateau dan cara menghindarinya

Secara tingkat tinggi, optimizer adalah pusat dari eksplorasi ruang pencarian kita. Optimizer menggunakan evaluasi fungsi biaya untuk memilih sekumpulan parameter berikutnya dalam loop variasional, dan mengulangi proses sampai mencapai state stabil. Pada tahap ini, sekumpulan nilai parameter optimal $\vec\theta^*$ dikembalikan.

Optimizer Lokal dan Global

Kita akan menyiapkan masalah kita terlebih dahulu sebelum mengeksplorasi setiap kelas optimizer. Kita akan mulai dengan Circuit yang berisi delapan parameter variasional:

# 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()

Optimizer Lokal

Optimizer lokal mencari titik yang meminimalkan fungsi biaya dimulai dari titik awal $C(\vec{\theta_0})$ dan berpindah ke titik berbeda berdasarkan apa yang diamati di wilayah yang sedang dievaluasi pada iterasi yang berurutan. Ini berarti konvergensi algoritma-algoritma ini biasanya cepat, tetapi bisa sangat bergantung pada titik awal. Optimizer lokal tidak bisa melihat melampaui wilayah tempat mereka mengevaluasi dan bisa sangat rentan terhadap minimum lokal, melaporkan konvergensi saat mereka menemukannya dan mengabaikan state lain dengan evaluasi yang lebih menguntungkan.

# 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

Optimizer Global

Optimizer global mencari titik yang meminimalkan fungsi biaya di beberapa wilayah domain-nya (yaitu, non-lokal), mengevaluasinya secara iteratif (yaitu, pada iterasi $i$) di atas sekumpulan vektor parameter $\Theta_i := \\{ {\vec\theta_{i,j} | j \in \mathcal{J}_\text{opt}^i} \\}$ yang ditentukan oleh optimizer. Ini membuat mereka kurang rentan terhadap minimum lokal dan agak independen dari inisialisasi, tetapi juga jauh lebih lambat untuk konvergen ke solusi yang diusulkan.

Bootstrap Optimasi

Bootstrapping, atau menetapkan nilai awal untuk parameter $\vec\theta$ berdasarkan optimasi sebelumnya, bisa membantu optimizer kita konvergen pada solusi lebih cepat. Kita menyebut ini sebagai initial point $\vec\theta_0$, dan $|\psi(\vec\theta_0)\rangle = U_V(\vec\theta_0)|\rho\rangle$ sebagai initial state. Initial state ini berbeda dari reference state kita $|\rho\rangle$, karena yang pertama berfokus pada parameter awal yang ditetapkan selama loop optimasi kita, sementara yang kedua berfokus pada penggunaan solusi "referensi" yang diketahui. Keduanya bisa bertepatan jika $U_V(\vec\theta_0) \equiv I$ (yaitu, operasi identitas).

Ketika optimizer lokal konvergen ke minimum lokal yang tidak optimal, kita bisa mencoba melakukan bootstrap optimasi secara global dan menyempurnakan konvergensi secara lokal. Meskipun ini memerlukan pengaturan dua beban kerja variasional, ini memungkinkan optimizer menemukan solusi yang lebih optimal dibandingkan optimizer lokal saja.

Optimizer Berbasis-Gradien dan Bebas-Gradien

Berbasis-Gradien

Untuk fungsi biaya kita $C(\vec\theta)$, jika kita memiliki akses ke gradien fungsi $\vec{\nabla} C(\vec\theta)$ dimulai dari titik awal, cara paling sederhana untuk meminimalkan fungsi ini adalah dengan memperbarui parameter ke arah penurunan terjal dari fungsi. Yaitu, kita memperbarui parameter sebagai $\vec\theta_{n+1} = \vec\theta_n - \eta \vec{\nabla} C(\vec\theta)$, di mana $\eta$ adalah learning rate - sebuah hyperparameter kecil dan positif yang mengontrol ukuran pembaruan. Kita terus melakukan ini sampai konvergen ke sebuah minimum lokal dari fungsi biaya, $C({\vec\theta^*})$. Kita bisa menggunakan fungsi biaya ini dan sebuah optimizer untuk menghitung parameter optimal

# 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

Kerugian utama dari jenis optimasi ini adalah kecepatan konvergensi yang bisa sangat lambat, dan tidak ada jaminan untuk mencapai solusi optimal.

Bebas-Gradien

Algoritma optimasi bebas-gradien tidak memerlukan informasi gradien dan bisa berguna dalam situasi di mana menghitung gradien sulit, mahal, atau terlalu berisik. Mereka juga cenderung lebih andal dalam menemukan optima global, sedangkan metode berbasis-gradien cenderung konvergen ke optima lokal. Kita akan mengeksplorasi beberapa kasus di mana optimizer bebas-gradien bisa membantu menghindari barren plateau. Namun, metode bebas-gradien memerlukan sumber daya komputasi yang lebih tinggi, terutama untuk masalah dengan ruang pencarian berdimensi tinggi.

Berikut contoh yang menggunakan optimizer COBYLA sebagai gantinya:

# 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

Barren Plateau

Faktanya, lanskap biaya bisa sangat rumit, seperti yang ditunjukkan oleh bukit dan lembah dalam contoh di bawah ini. Metode optimasi mengantar kita mengelilingi lanskap biaya, mencari minimum, seperti yang ditunjukkan oleh titik dan garis hitam. Kita bisa melihat bahwa dua dari tiga pencarian berakhir di minimum lokal dari lanskap, bukan minimum global.

Terlepas dari jenis metode optimasi yang digunakan, jika lanskap biaya relatif datar, bisa menjadi tantangan bagi metode untuk menentukan arah pencarian yang tepat. Skenario ini disebut sebagai barren plateau, di mana lanskap biaya menjadi semakin datar (dan dengan demikian semakin sulit untuk menentukan arah ke minimum). Untuk berbagai Circuit kuantum terparameter, probabilitas bahwa gradien ke arah mana pun yang wajar bukan nol dengan presisi tetap tertentu menurun secara eksponensial seiring bertambahnya jumlah Qubit.

Meskipun bidang ini masih dalam penelitian aktif, kami memiliki beberapa rekomendasi untuk meningkatkan performa optimasi:

• Bootstrapping bisa membantu loop optimasi menghindari terjebak dalam ruang parameter di mana gradien kecil.
• Bereksperimen dengan ansatz yang efisien-perangkat-keras: Karena kita menggunakan sistem kuantum yang berisik sebagai oracle black-box, kualitas evaluasi tersebut bisa mempengaruhi performa optimizer. Menggunakan ansatz yang efisien-perangkat-keras, seperti EfficientSU2, bisa menghindari terbentuknya gradien yang sangat kecil secara eksponensial.
• Bereksperimen dengan penekanan error dan mitigasi error: Primitif Qiskit Runtime menyediakan antarmuka sederhana untuk bereksperimen dengan berbagai nilai optimization_level dan resilience_setting, masing-masing. Ini bisa mengurangi dampak noise dan membuat proses optimasi lebih efisien.
• Bereksperimen dengan optimizer bebas-gradien: Tidak seperti algoritma optimasi berbasis-gradien, optimizer seperti COBYLA tidak mengandalkan informasi gradien untuk mengoptimalkan parameter dan oleh karena itu lebih kecil kemungkinannya terpengaruh oleh barren plateau.

Ringkasan

Dengan pelajaran ini, kamu telah belajar cara mendefinisikan loop optimasimu:

• Bootstrap loop optimasi
• Memahami trade-off saat menggunakan optimizer lokal dan global
• Mengeksplorasi barren plateau dan cara menghindarinya

Beban kerja variasional tingkat tinggi kita sudah lengkap:

Selanjutnya, kita akan mengeksplorasi algoritma variasional spesifik dengan kerangka ini dalam pikiran.