Pagtatantya ng ground-state energy ng Heisenberg chain gamit ang VQE

Tantiya sa paggamit: 37 minuto sa isang Heron processor (PAALALA: Ito ay isang tantiya lamang. Maaaring mag-iba ang iyong runtime.)

Mga natuttunan

Pagkatapos makumpleto ang tutorial na ito, maaari kang umasa na maunawaan ang sumusunod na impormasyon:

• Paano i-model ang isang Heisenberg spin chain bilang isang quantum Hamiltonian gamit ang Qiskit
• Paano gamitin ang SPSA optimizer upang tantiyahin ang ground-state energy ng isang quantum system
• Paano magsagawa ng variational workflows sa IBM® quantum hardware gamit ang Qiskit Runtime primitives at sessions

Mga Paunang Kaalaman

Inirerekomenda na pamilyarisado ka sa mga paksang ito:

• Basics of quantum information
• Introduction to Qiskit patterns
• Variational algorithm design

Panimula

Ang Heisenberg spin chain ay isa sa mga pinaka-malawak na pinag-aralan na modelo sa condensed matter physics at quantum magnetism. Inilalarawan nito ang isang one-dimensional na lattice ng mga nakikipag-ugnayan na quantum spins, kung saan ang mga pinakamalapit na kapitbahay na spins ay naka-couple sa pamamagitan ng exchange interactions. Ang Hamiltonian para sa isotropic Heisenberg model na may external na magnetic field ay ibinibigay ng:

$H = \sum_{\langle i,j \rangle} \left( J_x X_i X_j + J_y Y_i Y_j + J_z Z_i Z_j \right) + \sum_{i} h_i Z_i,$

kung saan ang $X_i$, $Y_i$, at $Z_i$ ay ang mga Pauli operator na kumikilos sa site $i$, ang sum $\langle i,j \rangle$ ay tumatakbo sa mga nearest-neighbor pairs, ang $J_x = J_y = J_z = 0.5$ ay ang mga exchange coupling constants (isotropic sa tutorial na ito), at ang $h_i$ ay kumakatawan sa isang site-dependent na external magnetic field. Sa tutorial na ito, ang mga halaga ng magnetic field ay random na sinasample mula sa interval na $[-1, 1]$. Tandaan na sa implementasyon sa ibaba, ang set ng "nearest-neighbor" pairs ay tinutukoy ng native coupling ng hardware backend sa mga unang $N$ qubit, na maaaring hindi bumuo ng isang mahigpit na linear chain depende sa device topology.

Ang pag-unawa sa ground-state energy ng Hamiltonian na ito ay may pundamental na kahalagahan sa physics. Ang ground state ay nag-encode ng impormasyon tungkol sa mga quantum phase transitions, entanglement structure, at magnetic ordering. Sa klasikal na paraan, ang pagkalkula ng eksaktong ground-state energy ay nagiging intractable habang lumalaki ang bilang ng mga spin, dahil ang Hilbert space dimension ay exponentially na lumalaki bilang $2^N$ para sa $N$ spins. Ginagawa nitong natural na kandidato para sa quantum simulation.

Ang Variational Quantum Eigensolver (VQE) ay isang hybrid quantum-classical algorithm na dinisenyo upang tantiyahin ang ground-state energy ng isang Hamiltonian. Gumagana ito sa pamamagitan ng paghahanda ng isang parameterized quantum state $|\psi(\theta)\rangle$ (tinatawag na ansatz) sa isang quantum computer at pagsukat ng expectation value na $\langle \psi(\theta) | H | \psi(\theta) \rangle$. Ang isang classical optimizer ay paulit-ulit na inaayos ang mga parameter na $\theta$ upang i-minimize ang enerhiyang ito, na ginagamit ang variational principle na ginagarantiyahan na ang nasukat na enerhiya ay palaging isang upper bound sa tunay na ground-state energy.

Sa tutorial na ito, gagamitin natin ang efficient_su2 ansatz mula sa circuit library ng Qiskit, na nagtatayo ng mga layer ng single-qubit rotations at entangling gates. Ang optimization ay isinasagawa gamit ang Simultaneous Perturbation Stochastic Approximation (SPSA) algorithm, na angkop para sa maingay na quantum hardware dahil tinatantya nito ang mga gradient gamit lamang ang dalawang function evaluation bawat iteration anuman ang bilang ng mga parameter.

Mga Kinakailangan

Bago magsimula sa tutorial na ito, tiyaking mayroon kayong sumusunod na naka-install:

• Qiskit SDK v2.0 o mas bago, na may suporta sa visualization
• Qiskit Runtime v0.44 o mas bago (pip install qiskit-ibm-runtime)

Pag-set up

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

import numpy as np
import matplotlib.pyplot as plt
from typing import Sequence

from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import BaseEstimatorV2
from qiskit.circuit.library import XGate
from qiskit.circuit.library import efficient_su2
from qiskit.transpiler import PassManager
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler.passes.scheduling import (
    ALAPScheduleAnalysis,
    PadDynamicalDecoupling,
)
from qiskit_ibm_runtime import QiskitRuntimeService, Session, EstimatorV2

def visualize_results(results):
    plt.plot(results["cost_history"], lw=2)
    plt.xlabel("Number of function evaluations")
    plt.ylabel("Energy")
    plt.show()

Maliit na halimbawa

Sa seksyong ito, lalakad tayo sa bawat hakbang ng Qiskit pattern sa maliit na sukat, ipinaliwanag ang mga pangunahing bahagi habang binubuo natin ang workflow.

Hakbang 1: I-map ang classical inputs sa isang quantum problem

• Input: Bilang ng mga spin
• Output: Ansatz at Hamiltonian na nagmo-model ng Heisenberg chain

Bumuo ng ansatz at Hamiltonian na nagmo-model ng 10-spin Heisenberg chain. Sa hakbang na ito, magtatayo tayo ng isang 10-spin Heisenberg Hamiltonian sa coupling map ng pinaka-hindi abala na backend at ihahanda ang efficient_su2 ansatz.

num_spins = 10
ansatz = efficient_su2(num_qubits=num_spins, reps=2)

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

coupling = backend.target.build_coupling_map()
reduced_coupling = coupling.reduce(list(range(num_spins)))

edge_list = reduced_coupling.graph.edge_list()
ham_list = []

for edge in edge_list:
    ham_list.append(("ZZ", edge, 0.5))
    ham_list.append(("YY", edge, 0.5))
    ham_list.append(("XX", edge, 0.5))

for qubit in reduced_coupling.physical_qubits:
    ham_list.append(("Z", [qubit], np.random.random() * 2 - 1))

hamiltonian = SparsePauliOp.from_sparse_list(ham_list, num_qubits=num_spins)

ansatz.draw("mpl", style="iqp")

Hakbang 2: I-optimize ang problem para sa quantum hardware execution

• Input: Abstract circuit, observable
• Output: Target circuit at observable, na-optimize para sa napiling QPU

Gamitin ang generate_preset_pass_manager function mula sa Qiskit upang awtomatikong makagawa ng optimization routine para sa ating circuit na nauugnay sa napiling QPU. Pipiliin natin ang optimization_level=3, na nagbibigay ng pinakamataas na antas ng optimization sa mga preset pass managers. Isasama rin natin ang ALAPScheduleAnalysis at PadDynamicalDecoupling scheduling passes upang pigilan ang mga decoherence errors.

target = backend.target
pm = generate_preset_pass_manager(optimization_level=3, target=target)
pm.scheduling = PassManager(
    [
        ALAPScheduleAnalysis(durations=target.durations()),
        PadDynamicalDecoupling(
            durations=target.durations(),
            dd_sequence=[XGate(), XGate()],
            pulse_alignment=target.pulse_alignment,
        ),
    ]
)
isa_ansatz = pm.run(ansatz)
isa_observable = hamiltonian.apply_layout(isa_ansatz.layout)
isa_ansatz.draw("mpl", scale=0.6, style="iqp", fold=-1, idle_wires=False)

Hakbang 3: Magsagawa gamit ang Qiskit primitives

• Input: Target circuit at observable
• Output: Mga resulta ng optimization

Paliitan ang tinantyang ground-state energy ng system sa pamamagitan ng pag-optimize ng mga circuit parameters. Gamitin ang Estimator primitive mula sa Qiskit Runtime upang suriin ang cost function sa panahon ng optimization.

Dahil na-optimize na natin ang circuit para sa backend sa Hakbang 2, maiwasan natin ang transpilation sa Runtime server sa pamamagitan ng pagtatakda ng skip_transpilation=True at pagpasa ng optimized circuit. Para sa demo na ito, magpapatakbo tayo sa isang QPU gamit ang qiskit-ibm-runtime primitives. Upang magpatakbo gamit ang qiskit statevector-based primitives, palitan ang bloke ng code na gumagamit ng Qiskit Runtime primitives ng commented block.

Sa tutorial na ito, gagamitin natin ang Simultaneous Perturbation Stochastic Approximation (SPSA), na isang gradient-based optimizer. Susunod, bibigyan natin ng maikling panimula dito, at ibibigay ang code para ipatupad ang SPSA gamit ang Qiskit v2.0.

Panimula sa SPSA

Ang Simultaneous Perturbation Stochastic Approximation (SPSA) [1] ay isang optimization algorithm na nagta-tantya ng buong gradient vector gamit lamang ang dalawang function call sa bawat iteration. Hayaan ang $f:\mathbb{R}^p\rightarrow \mathbb{R}$ na maging cost function na may $p$ na mga parameter na ie-optimize, at $x_i\in \mathbb{R}^p$ ang parameter vector sa $i^{th}$ hakbang ng iteration. Upang makalkula ang gradient, isang random vector $\Delta_i$ ng laki $p$ ang nililikha, kung saan ang bawat elemento $\Delta_{ij}$, $\forall$ $j\in \{1,2,...,p\}$, ay uniformly na sinasample mula sa $\{-1, 1\}$. Susunod, ang bawat elemento ng random vector $\Delta_i$ ay pinaramihin ng maliit na halaga $c_i$ upang makagawa ng random perturbation. Ang gradient ay tinatantya bilang

$[\nabla f(x_i)]_j \approx \frac{f(x_i + c_i \Delta_i) - f(x_i - c_i \Delta_i)}{2c_i\Delta_{ij}}.$

Sa isang kahulugan, dahil ang random perturbation ay inilalapat sa panahon ng gradient estimation, inaasahang matatanggap at matutugunan ang maliliit na paglihis sa eksaktong mga halaga ng $f$ na nagmumula sa ingay. Sa katunayan, ang SPSA ay partikular na kilala sa pagiging matibay laban sa ingay, at nangangailangan lamang ng dalawang hardware call para sa bawat iteration. Samakatuwid, isa ito sa mga lubos na ginusting optimizer para sa pagpapatupad ng variational algorithms.

Sa tutorial na ito, ang mga hyperparameter para sa $i^{th}$ iteration, $a_i$ at $c_i$, ay kinakalkula bilang

$a_i = \frac{a}{(A + i + 1)^\alpha} \quad \text{and} \quad c_i = \frac{c}{(i+1)^\gamma},$

kung saan ang mga constant na halaga ay $A = 30$, $\alpha = 0.9$, $a = 0.3$, $c = 0.1$, at $\gamma = 0.4$. Ang mga halagang ito ay kinuha mula sa [2]. Ang angkop na pag-tune ng mga hyperparameter ay kinakailangan upang makuha ang magandang pagganap mula sa SPSA.

def spsa(
    fun, x0, args=(), A=30, alpha=0.9, a=0.3, c=0.1, gamma=0.4, maxiter=100
):
    nparams = len(x0)
    x = np.copy(x0)

    for i in range(maxiter):
        a_i = a / (A + i + 1) ** alpha
        c_i = c / (i + 1) ** gamma
        delta_i = np.random.choice([-1, 1], nparams)

        # two hardware calls
        eval_1 = fun(x + c_i * delta_i, *args)
        eval_2 = fun(x - c_i * delta_i, *args)

        # compute the gradient and update the parameters
        grad = (eval_1 - eval_2) / (2 * c_i) * np.reciprocal(delta_i)
        x = x - a_i * grad

    return x

def cost_func(
    params: Sequence,
    ansatz: QuantumCircuit,
    hamiltonian: SparsePauliOp,
    estimator: BaseEstimatorV2,
    cost_history_dict: dict,
) -> float:
    """Ground state energy evaluation."""
    energy = (
        estimator.run([(ansatz, hamiltonian, [params])]).result()[0].data.evs
    )

    cost_history_dict["iters"] += 1
    cost_history_dict["prev_vector"] = list(params)
    cost_history_dict["cost_history"].append(float(energy[0]))

    print(
        f"Fx Iters. done: {cost_history_dict['iters']} [Current cost: {round(energy[0], 5)}]",
        end="\r",
    )

    return energy

def solve(x0, isa_ansatz, isa_observable, maxiter=150):
    cost_history_dict = {
        "prev_vector": None,
        "iters": 0,
        "cost_history": [],
        "y_min": None,
    }

    # Evaluate the problem using a QPU via Qiskit IBM Runtime
    with Session(backend=backend) as session:
        estimator = EstimatorV2(mode=session)
        estimator.skip_transpilation = True
        estimator.options.environment.job_tags = ["TUT_HSVQE"]
        x_opt = spsa(
            cost_func,
            x0=x0,
            args=(isa_ansatz, isa_observable, estimator, cost_history_dict),
            maxiter=maxiter,
        )

        y_min = cost_func(
            x_opt, isa_ansatz, isa_observable, estimator, cost_history_dict
        )

    return y_min, cost_history_dict

np.random.seed(42)
num_params = ansatz.num_parameters
params = 2 * np.pi * np.random.random(num_params)

Dito itinatakda natin ang maxiter = 50. Tandaan na dahil ang bawat iteration ay nangangailangan ng dalawang tawag sa function upang makalkula ang gradient, ang kabuuang bilang ng mga function call ay magiging $2 \times \text{maxiter}$. Ang maxiter ay maaaring taasan sa anumang mas mataas na halaga para sa mas mahusay na energy estimation.

maxiter = 50
spsa_min, spsa_history = solve(
    params, isa_ansatz, isa_observable, maxiter=maxiter
)

Fx Iters. done: 101 [Current cost: -3.03843]

Hakbang 4: I-post-process at ibalik ang resulta sa nais na classical format

• Input: Mga tantiya ng ground-state energy sa panahon ng optimization
• Output: Tinantyang ground-state energy

print(f"Estimated ground state energy: {spsa_min}")

Estimated ground state energy: [-3.03842968]

results = {
    "spsa": spsa_history,
}

visualize_results(spsa_history)

Halimbawa sa malaking sukat na hardware

Ang isang halimbawa ng malaking sukat na hardware ay hindi kasama sa tutorial na ito. Habang lumalaki ang bilang ng mga qubit, nararamdaman ng VQE ang malalaking hamon dahil sa barren plateau na penomenon: ang gradient ng cost function ay exponentially na nawawala kasabay ng laki ng system, na ginagawang praktikal na hindi posible ang optimization para sa malalaking circuit. Kasama ang hardware noise, ang ibig sabihin nito ay ang pag-scale ng VQE sa mas malalaking spin chains ay hindi nagbibigay ng maaasahang reproducible na mga resulta. Para sa mga diskarteng lumalagpas sa mga limitasyong ito, tingnan ang seksyong Mga Susunod na Hakbang sa ibaba.

Hamon

Ngayon na mayroon kang gumaganang VQE na implementasyon para sa Heisenberg chain, subukan ang mga sumusunod:

1. Mag-eksperimento sa ansatz depth: Baguhin ang parameter na reps sa efficient_su2 (halimbawa, subukan ang reps=1 at reps=3). Paano nakakaapekto ang ansatz depth sa tinantyang ground-state energy at bilis ng convergence? Kailan mo maobserbahan ang diminishing returns o instability?
2. I-tune ang mga SPSA hyperparameter: Ayusin ang mga parameter ng learning rate schedule (a, c, alpha, gamma, A) at obserbahan kung paano sila nakakaapekto sa convergence. Makakakita ka ba ng configuration na mas mabilis ang convergence kaysa sa mga default na ginamit dito?
3. Ikumpara ang mga coupling topology: Sa halip na gamitin ang native coupling map ng backend, subukan ang pagbuo ng isang simpleng nearest-neighbor linear chain at ikumpara ang mga resulta. Paano nakakaapekto ang connectivity ng pisikal na hardware sa transpiled circuit depth at final energy estimate?

Mga Sanggunian

[1] Spall, J. C. (2002). Implementation of the simultaneous perturbation algorithm for stochastic optimization. IEEE Transactions on Aerospace and Electronic Systems, 34(3), 817-823.

[2] Sahin, M. Emre, et al. (2025). Qiskit Machine Learning: an open-source library for quantum machine learning tasks at scale on quantum hardware and classical simulators. arXiv:2505.17756.

Mga Susunod na Hakbang

Mga Rekomendasyon

Kung nahanap mong kawili-wili ang gawaing ito, maaaring interesado ka sa sumusunod na materyal:

• Subukan ang Sample-based Quantum Diagonalization (SQD): Tulad ng ipinapakita sa tutorial na ito, nahaharap ang VQE sa mga hamon sa sukat dahil sa mga barren plateau at mataas na measurement overhead. Nagbuo ang IBM ng Sample-based Quantum Diagonalization (SQD) bilang isang mas scalable na alternatibo. Hindi tulad ng VQE, ang SQD ay ganap na umiiwas sa variational optimization; sa halip, ang isang quantum computer ay nagge-generate ng mga sample at ang isang classical computer ay nag-project ng Hamiltonian sa isang subspace na sinasaklaw ng mga sample na iyon at dine-diagonalize ito. Nagbibigay ito ng upper bound sa ground-state energy na may mas kaunting measurement at walang susceptibility sa mga barren plateau. Sundan ang SQD tutorial upang makita ang diskarteng ito sa aksyon.
• Tuklasin ang kurso ng Quantum Diagonalization Algorithms: Palalimin ang iyong pag-unawa sa parehong VQE at SQD, kasama ang kanilang mga trade-off, sa kursong Quantum diagonalization algorithms sa IBM Quantum Learning.