Contoh dan perluasan

Bab ini akan merangkumi beberapa algoritma variasi kuantum, termasuk

• Variational Quantum Eigensolver (VQE)
• Subspace Search VQE (SSVQE)
• Variational Quantum Deflation (VQD)
• Quantum Sampling Regression (QSR)

Dengan menggunakan algoritma-algoritma ini, kita akan mempelajari beberapa idea reka bentuk yang boleh digabungkan ke dalam algoritma variasi tersuai, seperti pemberat, penalti, over-sampling, dan under-sampling. Kami menggalakkan kamu untuk bereksperimen dengan konsep-konsep ini dan berkongsi penemuan kamu dengan komuniti.

Rangka kerja corak Qiskit terpakai untuk semua algoritma ini — tetapi kita hanya akan menyebut langkah-langkah secara eksplisit dalam contoh pertama sahaja.

Variational Quantum Eigensolver (VQE)

VQE adalah salah satu algoritma kuantum variasi yang paling banyak digunakan, membentuk templat untuk algoritma-algoritma lain dibina di atasnya.

Langkah 1: Petakan input klasik kepada masalah kuantum

Susun atur teori

Susun atur VQE adalah mudah:

• Sediakan operator rujukan $U_R$
  • Kita bermula dari keadaan $|0\rangle$ dan pergi ke keadaan rujukan $|\rho\rangle$
• Gunakan bentuk variasi $U_V(\vec\theta_{i,j})$ untuk mencipta ansatz $U_A(\vec\theta_{i,j})$
  • Kita pergi dari keadaan $|\rho\rangle$ kepada $U_V(\vec\theta_{i,j})|\rho\rangle = |\psi(\vec\theta_{i,j})\rangle$
• Bootstrap pada $i=0$ jika kita mempunyai masalah yang serupa (biasanya ditemui melalui simulasi atau pensampelan klasik)
  • Setiap pengoptimum akan di-bootstrap secara berbeza, menghasilkan set vektor parameter awal $\Theta_0 := \\{ {\vec\theta_{0,j} | j \in \mathcal{J}_\text{opt}^0} \\}$ (contohnya, dari titik awal $\vec\theta_0$).
• Nilaikan fungsi kos $C(\vec\theta_{i,j}) := \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$ untuk semua keadaan yang disediakan pada komputer kuantum.
• Gunakan pengoptimum klasik untuk memilih set parameter seterusnya $\Theta_{i+1}$.
• Ulang proses sehingga penumpuan dicapai.

Ini adalah gelung pengoptimuman klasik mudah di mana kita menilai fungsi kos. Sesetengah pengoptimum mungkin memerlukan pelbagai penilaian untuk mengira kecerunan, menentukan lelaran seterusnya, atau menilai penumpuan.

Berikut adalah contoh untuk pemerhatian berikut:

$$\hat{O}_1 = 2 II - 2 XX + 3 YY - 3 ZZ,$$

Pelaksanaan

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-ibm-runtime 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([("II", 2), ("XX", -2), ("YY", 3), ("ZZ", -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(parameters, 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
    """

    estimator_job = estimator.run([(ansatz, hamiltonian, [parameters])])
    estimator_result = estimator_job.result()[0]

    cost = estimator_result.data.evs[0]
    return cost

from qiskit.primitives import StatevectorEstimator

estimator = StatevectorEstimator()

Kita boleh menggunakan fungsi kos ini untuk mengira parameter optimum

# 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: -5.999999982445723
       x: [ 1.741e+00  9.606e-01  1.571e+00  2.115e-05  1.899e+00
            1.243e+00  6.063e-01  6.063e-01]
    nfev: 136
   maxcv: 0.0

Langkah 2: Optimumkan masalah untuk pelaksanaan kuantum

Kita akan memilih Backend yang paling tidak sibuk, dan mengimport komponen yang diperlukan dari qiskit_ibm_runtime.

from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit_ibm_runtime import Session, EstimatorOptions
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
print(backend)

<IBMBackend('ibm_brisbane')>

Kita akan men-transpil Circuit menggunakan preset pass manager dengan tahap pengoptimuman 3, dan kita akan menggunakan susun atur yang sepadan kepada pemerhatian.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
isa_ansatz = pm.run(ansatz)
isa_observable = observable.apply_layout(layout=isa_ansatz.layout)

Langkah 3: Laksanakan menggunakan primitif Qiskit Runtime

Kita kini bersedia untuk menjalankan pengiraan kita pada perkakasan IBM Quantum®. Oleh kerana pengecilan fungsi kos sangat berulang, kita akan memulakan Session Runtime. Dengan cara ini, kita hanya perlu menunggu dalam giliran sekali sahaja. Setelah kerja mula berjalan, setiap lelaran dengan kemas kini parameter akan berjalan serta-merta.

x0 = np.ones(8)

estimator_options = EstimatorOptions(resilience_level=1, default_shots=10_000)

with Session(backend=backend) as session:
    estimator = Estimator(mode=session, options=estimator_options)

    result = minimize(
        cost_func_vqe,
        x0,
        args=(isa_ansatz, isa_observable, estimator),
        method="COBYLA",
        options={"maxiter": 200, "disp": True},
    )
session.close()
print(result)

Langkah 4: Pasca-proses, kembalikan hasil dalam format klasik

Kita dapat melihat bahawa rutin pengecilan berjaya ditamatkan, bermakna kita telah mencapai tolerans lalai pengoptimum klasik COBYLA. Jika kita memerlukan hasil yang lebih tepat, kita boleh menentukan tolerans yang lebih kecil. Ini mungkin memang berlaku, memandangkan hasilnya berbeza beberapa peratus berbanding dengan hasil yang diperoleh oleh simulator di atas.

Nilai x yang diperoleh adalah tekaan terbaik semasa untuk parameter yang meminimumkan fungsi kos. Jika berulang untuk mendapatkan ketepatan yang lebih tinggi, nilai-nilai tersebut harus digunakan sebagai ganti x0 yang digunakan pada mulanya (vektor satu).

Akhirnya, kita perhatikan bahawa fungsi itu dinilai sebanyak 96 kali dalam proses pengoptimuman. Itu mungkin berbeza daripada bilangan langkah pengoptimuman, kerana sesetengah pengoptimum memerlukan pelbagai penilaian fungsi dalam satu langkah, seperti ketika menganggar kecerunan.

Subspace Search VQE (SSVQE)

SSVQE adalah varian VQE yang membolehkan mendapatkan $k$ nilai eigen pertama bagi pemerhatian $\hat{H}$ dengan nilai eigen $\{\lambda_0, \lambda_1,...,\lambda_{N-1}\}$, di mana $N\geq k$. Tanpa kehilangan keumuman, kita andaikan bahawa $\lambda_0<\lambda_1<...<\lambda_{N-1}$. SSVQE memperkenalkan idea baharu dengan menambah pemberat untuk membantu mengutamakan pengoptimuman bagi sebutan dengan pemberat terbesar.

Untuk melaksanakan algoritma ini, kita memerlukan $k$ keadaan rujukan yang saling ortogon $\{ |\rho_j\rangle \}_{j=0}^{k-1}$, bermakna $\langle \rho_j | \rho_l \rangle = \delta_{jl}$ untuk $j,l<k$. Keadaan-keadaan ini boleh dibina menggunakan operator Pauli. Fungsi kos algoritma ini kemudian adalah:

$$\begin{aligned} C(\vec{\theta}) & := \sum_{j=0}^{k-1} w_j \langle \rho_j | U_{V}^{\dagger}(\vec{\theta})\hat{H} U_{V}(\vec{\theta})|\rho_j \rangle \\[1mm] & := \sum_{j=0}^{k-1} w_j \langle \psi_{j}(\vec{\theta}) | \hat{H} | \psi_{j}(\vec{\theta}) \rangle \\[1mm] \end{aligned}$$

di mana $w_j$ adalah nombor positif sewenang-wenangnya sedemikian sehingga jika $j<l<k$ maka $w_j>w_l$, dan $U_V(\vec{\theta})$ adalah bentuk variasi yang ditentukan pengguna.

Algoritma SSVQE bergantung pada fakta bahawa keadaan eigen yang sepadan dengan nilai eigen yang berbeza adalah saling ortogon. Khususnya, hasil darab dalam $U_V(\vec{\theta})|\rho_j\rangle$ dan $U_V(\vec{\theta})|\rho_l\rangle$ boleh dinyatakan sebagai:

$$\begin{aligned} \langle \rho_j | U_{V}^{\dagger}(\vec{\theta})U_{V}(\vec{\theta})|\rho_l \rangle & = \langle \rho_j | I |\rho_l \rangle \\[1mm] & = \langle \rho_j | \rho_l \rangle \\[1mm] & = \delta_{jl} \end{aligned}$$

Kesamaan pertama berlaku kerana $U_{V}(\vec{\theta})$ adalah operator kuantum dan oleh itu adalah unitary. Kesamaan terakhir berlaku kerana ortogonaliti keadaan rujukan $|\rho_j\rangle$. Fakta bahawa ortogonaliti dipelihara melalui transformasi unitary berkait rapat dengan prinsip pemuliharaan maklumat, seperti yang dinyatakan dalam sains maklumat kuantum. Dari pandangan ini, transformasi bukan-unitary mewakili proses di mana maklumat sama ada hilang atau disuntik.

Pemberat $w_j$ membantu memastikan semua keadaan adalah keadaan eigen. Jika pemberat cukup berbeza, sebutan dengan pemberat terbesar (iaitu, $w_0$) akan diberi keutamaan semasa pengoptimuman berbanding yang lain. Akibatnya, keadaan yang terhasil $U_{V}(\vec{\theta})|\rho_0 \rangle$ akan menjadi keadaan eigen yang sepadan dengan $\lambda_0$. Kerana $\{ U_{V}(\vec{\theta})|\rho_j\rangle \}_{j=0}^{k-1}$ adalah saling ortogon, keadaan-keadaan selebihnya akan ortogon kepadanya dan, oleh itu, terkandung dalam subruang yang sepadan dengan nilai eigen $\{\lambda_1,...,\lambda_{N-1}\}$.

Menggunakan hujah yang sama untuk selebihnya sebutan-sebutan, keutamaan seterusnya ialah sebutan dengan pemberat $w_1$, jadi $U_{V}(\vec{\theta})|\rho_1 \rangle$ akan menjadi keadaan eigen yang sepadan dengan $\lambda_1$, dan sebutan-sebutan lain akan terkandung dalam ruang eigen bagi $\{\lambda_2,...,\lambda_{N-1}\}$.

Dengan penaakulan secara aruhan, kita simpulkan bahawa $U_{V}(\vec{\theta})|\rho_j \rangle$ akan menjadi keadaan eigen anggaran bagi $\lambda_j$ untuk $0\leq j < k.$

Susun atur teori

SSVQE boleh diringkaskan seperti berikut:

• Sediakan beberapa keadaan rujukan dengan menggunakan unitary U_R kepada k keadaan asas pengiraan yang berbeza
  • Algoritma ini memerlukan penggunaan $k$ keadaan rujukan yang saling ortogon $\{ |\rho_j\rangle \}_{j=0}^{k-1}$, sedemikian sehingga $\langle \rho_j | \rho_l \rangle = \delta_{jl}$ untuk $j,l<k$.
• Gunakan bentuk variasi $U_V(\vec\theta_{i,j})$ kepada setiap keadaan rujukan, menghasilkan ansatz berikut $U_A(\vec\theta_{i,j})$.
• Bootstrap pada $i=0$ jika masalah yang serupa tersedia (biasanya ditemui melalui simulasi atau pensampelan klasik).
• Nilaikan fungsi kos $C(\vec\theta_{i,j}) := \sum_{j=0}^{k-1} w_j \langle \psi_{j}(\vec{\theta}) | \hat{H} | \psi_{j}(\vec{\theta}) \rangle$ untuk semua keadaan yang disediakan pada komputer kuantum.
  • Ini boleh dipisahkan kepada pengiraan nilai jangkaan bagi pemerhatian $\langle \psi_{j}(\vec{\theta}) | \hat{H} | \psi_{j}(\vec{\theta}) \rangle$ dan darab keputusan itu dengan $w_j$.
  • Selepas itu, fungsi kos mengembalikan jumlah semua nilai jangkaan berpemberat.
• Gunakan pengoptimum klasik untuk menentukan set parameter seterusnya $\Theta_{i+1}$.
• Ulang langkah-langkah di atas sehingga penumpuan dicapai.

Kamu akan membina semula fungsi kos SSVQE dalam penilaian, tetapi kami mempunyai petikan berikut untuk memotivasikan penyelesaian kamu:

import numpy as np

def cost_func_ssvqe(
    params, initialized_anastz_list, weights, ansatz, hamiltonian, estimator
):
    # """Return estimate of energy from estimator

    # Parameters:
    #     params (ndarray): Array of ansatz parameters
    #     initialized_anastz_list (list QuantumCircuit): Array of initialised ansatz with reference
    #     weights (list): List of weights
    #     ansatz (QuantumCircuit): Parameterized ansatz circuit
    #     hamiltonian (SparsePauliOp): Operator representation of Hamiltonian
    #     estimator (Estimator): Estimator primitive instance

    # Returns:
    #     float: Weighted energy estimate
    # """

    energies = []

    # Define SSVQE

    weighted_energy_sum = np.dot(energies, weights)
    return weighted_energy_sum

Variational Quantum Deflation (VQD)

VQD adalah kaedah berulang yang melanjutkan VQE untuk mendapatkan $k$ nilai eigen pertama bagi pemerhatian $\hat{H}$ dengan nilai eigen $\{\lambda_0, \lambda_1,...,\lambda_{N-1}\}$, di mana $N\geq k$, bukan hanya yang pertama sahaja. Untuk selebihnya bahagian ini, kita akan andaikan, tanpa kehilangan keumuman, bahawa $\lambda_0\leq\lambda_1\leq...\leq\lambda_{N-1}$. VQD memperkenalkan konsep kos penalti untuk membimbing proses pengoptimuman.

VQD memperkenalkan sebutan penalti, ditandai sebagai $\beta$, untuk mengimbangi sumbangan setiap sebutan pertindanan kepada kos. Sebutan penalti ini berfungsi untuk menghukum proses pengoptimuman jika ortogonaliti tidak dicapai. Kita mengenakan kekangan ini kerana keadaan eigen bagi pemerhatian, atau operator Hermitian, yang sepadan dengan nilai eigen yang berbeza sentiasa saling ortogon, atau boleh dibuat sedemikian dalam kes keterulangan atau nilai eigen berulang. Oleh itu, dengan menguatkuasakan ortogonaliti dengan keadaan eigen yang sepadan dengan $\lambda_0$, kita sebenarnya mengoptimumkan ke atas subruang yang sepadan dengan nilai eigen selebihnya $\{\lambda_1, \lambda_2,..., \lambda_{N-1}\}$. Di sini, $\lambda_1$ adalah nilai eigen terendah daripada nilai eigen selebihnya dan, oleh itu, penyelesaian optimum bagi masalah baharu boleh diperoleh menggunakan teorem variasi.

Idea umum di sebalik VQD adalah menggunakan VQE seperti biasa untuk mendapatkan nilai eigen terendah $\lambda_0 := C_0(\vec\theta^0) \equiv C_\text{VQE}(\vec\theta^0)$ bersama-sama dengan keadaan eigen (anggaran) yang sepadan $|\psi(\vec{\theta^0})\rangle$ untuk beberapa vektor parameter optimum $\vec{\theta^0}$. Kemudian, untuk mendapatkan nilai eigen seterusnya $\lambda_1 > \lambda_0$, bukannya meminimumkan fungsi kos $C_0(\vec{\theta}) := \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$, kita mengoptimumkan:

$$C_1(\vec{\theta}) := C_0(\vec{\theta})+ \beta_0 |\langle \psi(\vec{\theta})| \psi(\vec{\theta^0})\rangle |^2$$

Nilai positif $\beta_0$ seharusnya lebih besar daripada $\lambda_1-\lambda_0$.

Ini memperkenalkan fungsi kos baharu yang boleh dilihat sebagai masalah terkekang, di mana kita meminimumkan $C_\text{VQE}(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$ tertakluk kepada kekangan bahawa keadaan mestilah ortogon kepada $|\psi(\vec{\theta^0})\rangle$ yang diperoleh sebelum ini, dengan $\beta_0$ bertindak sebagai sebutan penalti jika kekangan tidak dipenuhi.

Sebagai alternatif, masalah baharu ini boleh ditafsirkan sebagai menjalankan VQE pada pemerhatian baharu:

$$\hat{H_1} := \hat{H} + \beta_0 |\psi(\vec{\theta^0})\rangle \langle \psi(\vec{\theta^0})| \quad \Rightarrow \quad C_1(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H_1} | \psi(\vec{\theta})\rangle,$$

Dengan mengandaikan bahawa penyelesaian kepada masalah baharu adalah $|\psi(\vec{\theta^1})\rangle$, nilai jangkaan bagi $\hat{H}$ (bukan $\hat{H_1}$) haruslah $\langle \psi(\vec{\theta^1}) | \hat{H} | \psi(\vec{\theta^1})\rangle = \lambda_1$. Untuk mendapatkan nilai eigen ketiga $\lambda_2$, fungsi kos yang perlu dioptimumkan adalah:

$$C_2(\vec{\theta}) := C_1(\vec{\theta}) + \beta_1 |\langle \psi(\vec{\theta})| \psi(\vec{\theta^1})\rangle |^2$$

di mana $\beta_1$ adalah pemalar positif yang cukup besar untuk menguatkuasakan ortogonaliti keadaan penyelesaian kepada kedua-dua $|\psi(\vec{\theta^0})\rangle$ dan $|\psi(\vec{\theta^1})\rangle$. Ini menghukum keadaan dalam ruang carian yang tidak memenuhi keperluan ini, secara berkesan menyekat ruang carian. Oleh itu, penyelesaian optimum bagi masalah baharu haruslah keadaan eigen yang sepadan dengan $\lambda_2$.

Seperti kes sebelumnya, masalah baharu ini juga boleh ditafsirkan sebagai VQE dengan pemerhatian:

$$\hat{H_2} := \hat{H_1} + \beta_1 |\psi(\vec{\theta^1})\rangle \langle \psi(\vec{\theta^1})| \quad \Rightarrow \quad C_2(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H_2} | \psi(\vec{\theta})\rangle.$$

Jika penyelesaian kepada masalah baharu ini adalah $|\psi(\vec{\theta^2})\rangle$, nilai jangkaan bagi $\hat{H}$ (bukan $\hat{H_2}$) haruslah $\langle \psi(\vec{\theta^2}) | \hat{H} | \psi(\vec{\theta^2})\rangle = \lambda_2$. Secara analog, untuk mendapatkan nilai eigen ke-$k$ iaitu $\lambda_{k-1}$, kamu akan meminimumkan fungsi kos:

$$C_{k-1}(\vec{\theta}) := C_{k-2}(\vec{\theta}) + \beta_{k-2} |\langle \psi(\vec{\theta})| \psi(\vec{\theta^{k-2}})\rangle |^2,$$

Ingat bahawa kita mendefinisikan $\vec{\theta^j}$ sedemikian sehingga $\langle \psi(\vec{\theta^j}) | \hat{H} | \psi(\vec{\theta^j})\rangle = \lambda_j, \forall j<k$. Masalah ini bersamaan dengan meminimumkan $C(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$ tetapi dengan kekangan bahawa keadaan mestilah ortogon kepada $|\psi(\vec{\theta^j})\rangle ; \forall j \in {0, \cdots, k-1}$, dengan itu menyekat ruang carian kepada subruang yang sepadan dengan nilai eigen $\{\lambda_{k-1},\cdots,\lambda_{N-1}\}$.

Masalah ini bersamaan dengan VQE dengan pemerhatian:

$$\hat{H}_{k-1} := \hat{H}_{k-2} + \beta_{k-2} |\psi(\vec{\theta^{k-2}})\rangle \langle \psi(\vec{\theta^{k-2}})| \quad \Rightarrow \quad C_{k-1}(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H}_{k-1} | \psi(\vec{\theta})\rangle,$$

Seperti yang kamu dapat lihat dari proses ini, untuk mendapatkan nilai eigen ke-$k$, kamu memerlukan keadaan eigen (anggaran) bagi $k-1$ nilai eigen sebelumnya, jadi kamu perlu menjalankan VQE sebanyak $k$ kali. Oleh itu, fungsi kos VQD adalah seperti berikut:

$$C_k(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle + \sum_{j=0}^{k-1}\beta_j |\langle \psi(\vec{\theta})| \psi(\vec{\theta^j})\rangle |^2$$

Susun atur teori

Susun atur VQD boleh diringkaskan seperti berikut:

• Sediakan operator rujukan $U_R$
• Gunakan bentuk variasi $U_V(\vec\theta_{i,j})$ kepada keadaan rujukan, mencipta ansatz berikut $U_A(\vec\theta_{i,j})$
• Bootstrap pada $i=0$ jika kita mempunyai masalah yang serupa (biasanya ditemui melalui simulasi atau pensampelan klasik).
• Nilaikan fungsi kos $C_k(\vec{\theta})$, yang melibatkan pengiraan $k$ keadaan teruja dan tatasusunan $\beta$ yang mentakrifkan penalti pertindanan untuk setiap sebutan pertindanan.
  • Kira nilai jangkaan bagi pemerhatian $\langle \psi_{j}(\vec{\theta}) | \hat{H} | \psi_{j}(\vec{\theta}) \rangle$ untuk setiap $k$
  • Kira penalti $\sum_{j=0}^{k-1}\beta_j |\langle \psi(\vec{\theta})| \psi(\vec{\theta^j})\rangle |^2$.
  • Fungsi kos kemudian harus mengembalikan jumlah kedua-dua sebutan ini
• Gunakan pengoptimum klasik untuk memilih set parameter seterusnya $\Theta_{i+1}$.
• Ulang proses ini sehingga penumpuan dicapai.

Pelaksanaan

Untuk pelaksanaan ini, kita akan membuat fungsi untuk penalti pertindihan. Penalti ini akan digunakan dalam fungsi kos pada setiap lelaran. Proses ini akan diulang untuk setiap keadaan teruja.

from qiskit.circuit.library import TwoLocal

ansatz = TwoLocal(2, rotation_blocks=["ry", "rz"], entanglement_blocks="cz", reps=1)

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

Pertama, kita akan menyediakan fungsi yang mengira kesetiaan keadaan — peratusan pertindihan antara dua keadaan yang akan kita gunakan sebagai penalti untuk VQD:

import numpy as np

def calculate_overlaps(ansatz, prev_circuits, parameters, sampler):
    def create_fidelity_circuit(circuit_1, circuit_2):
        """
        Constructs the list of fidelity circuits to be evaluated.
        These circuits represent the state overlap between pairs of input circuits,
        and their construction depends on the fidelity method implementations.
        """

        if len(circuit_1.clbits) > 0:
            circuit_1.remove_final_measurements()
        if len(circuit_2.clbits) > 0:
            circuit_2.remove_final_measurements()

        circuit = circuit_1.compose(circuit_2.inverse())
        circuit.measure_all()
        return circuit

    overlaps = []

    for prev_circuit in prev_circuits:
        fidelity_circuit = create_fidelity_circuit(ansatz, prev_circuit)
        sampler_job = sampler.run([(fidelity_circuit, parameters)])
        meas_data = sampler_job.result()[0].data.meas

        counts_0 = meas_data.get_int_counts().get(0, 0)
        shots = meas_data.num_shots
        overlap = counts_0 / shots
        overlaps.append(overlap)

    return np.array(overlaps)

Tiba masanya untuk menulis fungsi kos VQD. Seperti sebelum ini ketika kita mengira hanya keadaan asas, kita akan menentukan keadaan tenaga terendah menggunakan primitif Estimator. Namun, seperti yang diterangkan di atas, kita kini akan menambah penalti untuk memastikan ortogonaliti keadaan bertenaga lebih tinggi. Iaitu, bagi setiap keadaan teruja baharu, satu penalti ditambah untuk sebarang pertindihan antara keadaan variasi semasa dan eigenstate bertenaga lebih rendah yang telah dijumpai.

def cost_func_vqd(
    parameters, ansatz, prev_states, step, betas, estimator, sampler, hamiltonian
):
    estimator_job = estimator.run([(ansatz, hamiltonian, [parameters])])

    total_cost = 0

    if step > 1:
        overlaps = calculate_overlaps(ansatz, prev_states, parameters, sampler)
        total_cost = np.sum(
            [np.real(betas[state] * overlap) for state, overlap in enumerate(overlaps)]
        )

    estimator_result = estimator_job.result()[0]

    value = estimator_result.data.evs[0] + total_cost

    return value

Perhatikan terutamanya bahawa fungsi kos di atas merujuk kepada fungsi calculate_overlaps, yang sebenarnya mencipta Circuit kuantum baharu. Jika kita ingin menjalankan pada perkakasan sebenar, Circuit baharu itu juga perlu ditranspilasi, sebaik-baiknya dengan cara yang optimum, untuk dijalankan pada Backend yang kita pilih. Perhatikan bahawa transpilasi belum dibina ke dalam fungsi calculate_overlaps atau cost_func_vqd. Sila cuba ubah suai kod sendiri untuk membina transpilasi tambahan (dan bersyarat) ini — tetapi ini juga akan dilakukan untuk anda dalam pelajaran seterusnya.

Dalam pelajaran ini, kita akan menjalankan algoritma VQD menggunakan Statevector Sampler dan Statevector Estimator:

from qiskit.primitives import StatevectorEstimator as Estimator

sampler = Sampler()
estimator = Estimator()

Kita akan memperkenalkan pemerhatian yang perlu dianggarkan. Dalam pelajaran seterusnya kita akan menambah konteks fizikal kepada ini, seperti keadaan teruja molekul. Mungkin berguna untuk memikirkan pemerhatian ini sebagai Hamiltonian bagi suatu sistem yang boleh mempunyai keadaan teruja, walaupun pemerhatian ini tidak dipilih untuk sepadan dengan mana-mana molekul atau atom tertentu.

from qiskit.quantum_info import SparsePauliOp

observable = SparsePauliOp.from_list([("II", 2), ("XX", -2), ("YY", 3), ("ZZ", -3)])

Di sini, kita menetapkan jumlah keadaan yang ingin dikira (keadaan asas dan keadaan teruja, k), serta penalti (betas) untuk pertindihan antara vektor keadaan yang sepatutnya ortogonal. Akibat memilih betas yang terlalu tinggi atau terlalu rendah akan diterokai sedikit dalam pelajaran seterusnya. Buat masa ini, kita akan menggunakan nilai yang diberikan di bawah sahaja. Kita akan bermula dengan menggunakan semua sifar sebagai parameter kita. Dalam pengiraan anda sendiri, anda mungkin ingin menggunakan parameter permulaan yang lebih bijak berdasarkan pengetahuan anda tentang sistem atau pengiraan sebelumnya.

k = 3
betas = [33, 33, 33]
x0 = np.zeros(8)

Kita kini boleh menjalankan pengiraan:

from scipy.optimize import minimize

prev_states = []
prev_opt_parameters = []
eigenvalues = []

for step in range(1, k + 1):
    if step > 1:
        prev_states.append(ansatz.assign_parameters(prev_opt_parameters))

    result = minimize(
        cost_func_vqd,
        x0,
        args=(ansatz, prev_states, step, betas, estimator, sampler, observable),
        method="COBYLA",
        options={
            "maxiter": 200,
        },
    )
    print(result)

    prev_opt_parameters = result.x
    eigenvalues.append(result.fun)

message: Optimization terminated successfully.
 success: True
  status: 1
     fun: -5.999999979545955
       x: [-5.150e-01 -5.452e-02 -1.571e+00 -2.853e-05  2.671e-01
           -2.672e-01 -8.509e-01 -8.510e-01]
    nfev: 131
   maxcv: 0.0
 message: Optimization terminated successfully.
 success: True
  status: 1
     fun: 4.024550284767612
       x: [-3.745e-01  1.041e+00  8.637e-01  1.202e+00 -8.847e-02
            1.181e-02  7.611e-01 -3.006e-01]
    nfev: 110
   maxcv: 0.0
 message: Optimization terminated successfully.
 success: True
  status: 1
     fun: 5.608925562838559
       x: [-2.670e-01  1.280e+00  1.070e+00 -8.031e-01 -1.524e-01
           -6.956e-02  7.018e-01  1.514e+00]
    nfev: 90
   maxcv: 0.0

Nilai yang kita perolehi daripada fungsi kos adalah lebih kurang -6.00, 4.02, dan 5.61. Perkara penting tentang keputusan ini ialah nilai fungsi semakin meningkat. Jika kita mendapat keadaan teruja pertama yang lebih rendah tenaganya daripada pengiraan awal tanpa kekangan bagi keadaan asas, itu akan menunjukkan terdapat ralat di suatu tempat dalam kod kita.

Nilai x adalah parameter yang menghasilkan vektor keadaan yang sepadan dengan setiap kos (tenaga) ini.

Akhir sekali, kita perhatikan bahawa ketiga-tiga penganggitan minimum telah menumpu dalam toleransi lalai pengoptimum klasik (di sini COBYLA). Ia memerlukan 131, 110, dan 90 penilaian fungsi masing-masing.

Regresi Pensampelan Kuantum (QSR)

Salah satu isu utama dengan VQE ialah banyaknya panggilan kepada komputer kuantum yang diperlukan untuk mendapatkan parameter bagi setiap langkah, contohnya $k$, $k-1$, dan seterusnya. Ini amat bermasalah apabila akses kepada peranti kuantum mempunyai giliran. Walaupun Session boleh digunakan untuk mengumpulkan pelbagai panggilan berulang, pendekatan alternatif ialah menggunakan pensampelan. Dengan memanfaatkan lebih banyak sumber klasik, kita boleh melengkapkan keseluruhan proses pengoptimuman dalam satu panggilan sahaja. Di sinilah Regresi Pensampelan Kuantum memainkan peranannya. Memandangkan akses kepada komputer kuantum masih merupakan komoditi tawaran rendah/permintaan tinggi, kita mendapati pertukaran ini adalah mungkin dan mudah untuk banyak kajian semasa. Pendekatan ini memanfaatkan semua keupayaan klasik yang ada sambil masih menangkap banyak mekanisme dalaman dan sifat intrinsik pengiraan kuantum yang tidak muncul dalam simulasi.

Idea di sebalik QSR ialah fungsi kos $C(\theta) := \langle \psi(\theta) | \hat{H} | \psi(\theta)\rangle$ boleh dinyatakan sebagai siri Fourier dengan cara berikut:

$$\begin{aligned} C(\vec{\theta}) & := \langle \psi(\theta) | \hat{H} | \psi(\theta)\rangle \\[1mm] & := a_0 + \sum_{k=1}^S[a_k\cos(k\theta)+ b_k\sin(k\theta)] \\[1mm] \end{aligned}$$

Bergantung pada kekerapan dan lebar jalur fungsi asal, set $S$ mungkin terhingga atau tak terhingga. Untuk tujuan perbincangan ini, kita akan menganggapnya tak terhingga. Langkah seterusnya ialah mengsampel fungsi kos $C(\theta)$ beberapa kali untuk mendapatkan pekali Fourier $\{a_0, a_k, b_k\}_{k=1}^S$. Khususnya, oleh kerana kita mempunyai $2S+1$ yang tidak diketahui, kita perlu mengsampel fungsi kos sebanyak $2S+1$ kali.

Jika kita kemudian mengsampel fungsi kos untuk $2S+1$ nilai parameter $\{\theta_1,...,\theta_{2S+1}\}$, kita boleh mendapatkan sistem berikut:

$$\begin{pmatrix} 1 & \cos(\theta_1) & \sin(\theta_1) & \cos(2\theta_1) & ... & \sin(S\theta_1) \\ 1 & \cos(\theta_2) & \sin(\theta_2) & \cos(2\theta_2) & \cdots & \sin(S\theta_2)\\ \vdots & \vdots & \vdots & \vdots & \ddots & \vdots\\ 1 & \cos(\theta_{2S+1}) & \sin(\theta_{2S+1}) & \cos(2\theta_{2S+1}) & \cdots & \sin(S\theta_{2S+1}) \end{pmatrix} \begin{pmatrix} a_0 \\ a_1 \\ b_1 \\ a_2 \\ \vdots \\ b_S \end{pmatrix} = \begin{pmatrix} C(\theta_1) \\ C(\theta_2) \\ \vdots \\ C(\theta_{2S+1}) \end{pmatrix},$$

yang akan kita tulis semula sebagai

$$Fa=c.$$

Dalam amalan, sistem ini biasanya tidak konsisten kerana nilai fungsi kos $c$ tidak tepat. Oleh itu, biasanya adalah idea yang baik untuk menormalkannya dengan mendarabkan dengan $F^\dagger$ di sebelah kiri, yang menghasilkan:

$$F^\dagger Fa = F^\dagger c.$$

Sistem baharu ini sentiasa konsisten, dan penyelesaiannya adalah penyelesaian kuasa dua terkecil bagi masalah asal. Jika kita mempunyai $k$ parameter dan bukannya satu sahaja, dan setiap parameter $\theta^i$ mempunyai $S_i$ sendiri untuk $i \in {1,...,k}$, maka jumlah sampel yang diperlukan ialah:

$$T=\prod_{i=1}^k(2S_i+1)\leq \prod_{i=1}^k(2S_{max}+1) = (2S_{max}+1)^n,$$

di mana $S_{\max} = \max_i(S_i)$. Tambahan pula, melaraskan $S_{\max}$ sebagai parameter boleh ditala (dan bukannya menyimpulkannya) membuka kemungkinan baharu, seperti:

• Pensampelan berlebihan untuk meningkatkan ketepatan.
• Pensampelan kurang untuk meningkatkan prestasi dengan mengurangkan overhed masa jalan atau menghapuskan minimum tempatan.

Susun atur teori

Susun atur QSR boleh dirumuskan seperti berikut:

• Sediakan pengendali rujukan $U_R$.
  • Kita akan pergi dari keadaan $|0\rangle$ ke keadaan rujukan $|\rho\rangle$
• Gunakan bentuk variasi $U_V(\vec\theta_{i,j})$ untuk mencipta ansatz $U_A(\vec\theta_{i,j})$.
  • Tentukan lebar jalur yang berkaitan dengan setiap parameter dalam ansatz. Batas atas sudah mencukupi.
• Bootstrap pada $i=0$ jika kita mempunyai masalah yang serupa (biasanya dijumpai melalui simulasi klasik atau pensampelan).
• Sampel fungsi kos $C(\vec\theta) := a_0 + \sum_{k=1}^S[a_k\cos(k\theta)+ b_k\sin(k\theta)]$ sekurang-kurangnya $T$ kali.
  • $T=\prod_{i=1}^k(2S_i+1)\leq \prod_{i=1}^k(2S_{max}+1) = (2S_{max}+1)^n$
  • Tentukan sama ada perlu pensampelan berlebihan/kurang untuk mengimbangi kelajuan vs ketepatan dengan melaraskan $T$.
• Kira pekali Fourier daripada sampel (iaitu, selesaikan sistem persamaan linear yang dinormalkan).
• Selesaikan minimum global bagi fungsi regresi yang terhasil pada mesin klasik.

Ringkasan

Dengan pelajaran ini, anda telah belajar tentang pelbagai contoh variasi yang tersedia:

• Susun atur umum
• Memperkenalkan pemberat dan penalti untuk melaraskan fungsi kos
• Meneroka pensampelan kurang vs pensampelan berlebihan untuk menukar kelajuan vs ketepatan

Idea-idea ini boleh disesuaikan untuk membentuk algoritma variasi tersuai yang sesuai dengan masalah anda. Kami menggalakkan anda berkongsi hasil anda dengan komuniti. Pelajaran seterusnya akan meneroka cara menggunakan algoritma variasi untuk menyelesaikan suatu aplikasi.