Mga Instance at Extension

Tatalakayin ng kabanatang ito ang ilang quantum variational algorithm, kasama ang mga sumusunod:

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

Sa pamamagitan ng mga algorithm na ito, matututunan natin ang ilang ideya sa disenyo na maaaring isama sa mga custom variational algorithm, tulad ng mga timbang (weights), mga parusa (penalties), over-sampling, at under-sampling. Hinihikayat namin kayo na mag-eksperimento sa mga konseptong ito at ibahagi ang inyong mga natuklasan sa komunidad.

Naaangkop ang Qiskit patterns framework sa lahat ng mga algorithm na ito — ngunit tahasang bibanggit lang natin ang mga hakbang sa unang halimbawa.

Variational Quantum Eigensolver (VQE)

Ang VQE ay isa sa mga pinaka-ginagamit na variational quantum algorithm, na nagtatakda ng template para sa ibang mga algorithm na maaaring itayo dito.

Hakbang 1: I-map ang mga klasikal na input sa quantum na problema

Teoretikal na layout

Simple ang layout ng VQE:

• I-prepare ang reference operators na $U_R$
  • Magsisimula tayo mula sa estado $|0\rangle$ at pupunta sa reference state na $|\rho\rangle$
• I-apply ang variational form na $U_V(\vec\theta_{i,j})$ para lumikha ng ansatz na $U_A(\vec\theta_{i,j})$
  • Pupunta tayo mula sa estado $|\rho\rangle$ patungo sa $U_V(\vec\theta_{i,j})|\rho\rangle = |\psi(\vec\theta_{i,j})\rangle$
• Mag-bootstrap sa $i=0$ kung mayroon kang katulad na problema (karaniwang nahahanap sa pamamagitan ng klasikal na simulation o sampling)
  • Bawat optimizer ay mag-bo-bootstrap nang iba-iba, na magreresulta sa isang paunang hanay ng mga parameter vector na $\Theta_0 := \\{ {\vec\theta_{0,j} | j \in \mathcal{J}_\text{opt}^0} \\}$ (halimbawa, mula sa isang paunang punto $\vec\theta_0$).
• Suriin ang cost function na $C(\vec\theta_{i,j}) := \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$ para sa lahat ng inihanda na estado sa isang quantum computer.
• Gumamit ng klasikal na optimizer para pumili ng susunod na hanay ng mga parameter na $\Theta_{i+1}$.
• Ulitin ang proseso hanggang maabot ang convergence.

Ito ay isang simpleng klasikal na optimization loop kung saan sinusuri natin ang cost function. Maaaring mangailangan ang ilang optimizer ng maraming evaluasyon para kalkulahin ang gradient, tukuyin ang susunod na iterasyon, o tasahin ang convergence.

Narito ang halimbawa para sa sumusunod na observable:

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

Implementasyon

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

Maaari nating gamitin ang cost function na ito para kalkulahin ang pinakamainam na mga parameter.

# 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

Hakbang 2: I-optimize ang problema para sa quantum execution

Pipili tayo ng least-busy na backend, at ia-import ang mga kinakailangang component mula sa 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')>

I-transpile natin ang Circuit gamit ang preset pass manager na may optimization level 3, at ia-apply natin ang kaukulang layout sa observable.

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)

Hakbang 3: I-execute gamit ang Qiskit Runtime primitives

Handa na tayong patakbuhin ang ating kalkulasyon sa IBM Quantum® hardware. Dahil napaka-iteratibo ng pag-minimize ng cost function, magsisimula tayo ng Runtime session. Sa ganitong paraan, isang beses lang tayong maghihintay sa pila. Kapag nagsimula nang tumakbo ang job, bawat iterasyon na may mga update sa mga parameter ay tatakbo agad.

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)

Hakbang 4: Post-process, ibalik ang resulta sa klasikal na format

Makikita natin na matagumpay na natapos ang minimization routine, ibig sabihin naabot natin ang default na toleransya ng COBYLA klasikal na optimizer. Kung kailangan ng mas tumpak na resulta, maaari tayong magtakda ng mas maliit na toleransya. Maaari ngang kailanganin ito, dahil ilang porsyentong kaibahan ang resulta kumpara sa resulta na nakuha ng simulator sa itaas.

Ang halaga ng x na nakuha ay ang pinakamainam na hula sa kasalukuyan para sa mga parameter na nagpapaliit ng cost function. Kung nagtatasa para makakuha ng mas mataas na katumpakan, ang mga halagang iyon ay dapat gamitin kapalit ng x0 na unang ginamit (isang vector ng mga isa).

Sa huli, dapat nating tandaan na 96 beses na sinuri ang function sa proseso ng optimization. Maaaring mag-iba ito mula sa bilang ng mga optimization step, dahil ang ilang optimizer ay nangangailangan ng maraming evaluasyon ng function sa isang hakbang, tulad ng kapag tinatantiya ang gradient.

Subspace Search VQE (SSVQE)

Ang SSVQE ay isang variant ng VQE na nagpapahintulot sa pagkuha ng unang $k$ eigenvalue ng isang observable na $\hat{H}$ na may mga eigenvalue na $\{\lambda_0, \lambda_1,...,\lambda_{N-1}\}$, kung saan $N\geq k$. Nang walang pagkawala ng pangkalahatan, ipinapalagay natin na $\lambda_0<\lambda_1<...<\lambda_{N-1}$. Nagpapakilala ang SSVQE ng bagong ideya sa pamamagitan ng pagdaragdag ng mga timbang upang matulungang bigyang-priyoridad ang pag-optimize para sa term na may pinakamalaking timbang.

Para maipatupad ang algorithm na ito, kailangan natin ng $k$ na magkaparehong ortogonal na reference state na $\{ |\rho_j\rangle \}_{j=0}^{k-1}$, ibig sabihin $\langle \rho_j | \rho_l \rangle = \delta_{jl}$ para sa $j,l<k$. Ang mga estadong ito ay maaaring itayo gamit ang mga Pauli operator. Ang cost function ng algorithm na ito ay:

$$\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}$$

kung saan ang $w_j$ ay isang arbitraryong positibong numero na kung $j<l<k$ ay $w_j>w_l$, at ang $U_V(\vec{\theta})$ ay ang variational form na tinukoy ng gumagamit.

Ang SSVQE algorithm ay nakasalalay sa katotohanang ang mga eigenstate na naaayon sa iba't ibang eigenvalue ay magkaparehong ortogonal. Partikular, ang inner product ng $U_V(\vec{\theta})|\rho_j\rangle$ at $U_V(\vec{\theta})|\rho_l\rangle$ ay maaaring ipahayag bilang:

$$\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}$$

Ang unang pagkakapantay-pantay ay totoo dahil ang $U_{V}(\vec{\theta})$ ay isang quantum operator at samakatuwid ay unitary. Ang huling pagkakapantay-pantay ay totoo dahil sa ortogonalidad ng mga reference state na $|\rho_j\rangle$. Ang katotohanang napapanatili ang ortogonalidad sa pamamagitan ng mga unitary transformation ay malalim na nauugnay sa prinsipyo ng pangangalaga ng impormasyon, gaya ng ipinapahayag sa quantum information science. Sa pananaw na ito, ang mga non-unitary transformation ay kumakatawan sa mga proseso kung saan ang impormasyon ay nawawala o naiiniksyon.

Tinutulungan ng mga timbang $w_j$ na matiyak na lahat ng estado ay mga eigenstate. Kung sapat na magkaiba ang mga timbang, ang term na may pinakamalaking timbang (ibig sabihin, $w_0$) ay mabibigyan ng priyoridad sa panahon ng optimization kaysa sa iba. Bilang resulta, ang resultang estado $U_{V}(\vec{\theta})|\rho_0 \rangle$ ay magiging eigenstate na naaayon sa $\lambda_0$. Dahil ang $\{ U_{V}(\vec{\theta})|\rho_j\rangle \}_{j=0}^{k-1}$ ay magkaparehong ortogonal, ang natitirang mga estado ay magiging ortogonal dito at, samakatuwid, nakapaloob sa subspace na naaayon sa mga eigenvalue na $\{\lambda_1,...,\lambda_{N-1}\}$.

Sa paglalapat ng parehong argumento sa natitirang mga term, ang susunod na priyoridad ay ang term na may timbang $w_1$, kaya ang $U_{V}(\vec{\theta})|\rho_1 \rangle$ ay magiging eigenstate na naaayon sa $\lambda_1$, at ang ibang mga term ay mananatili sa eigenspace ng $\{\lambda_2,...,\lambda_{N-1}\}$.

Sa pamamagitan ng inductive reasoning, natutukoy natin na ang $U_{V}(\vec{\theta})|\rho_j \rangle$ ay magiging isang tinatayang eigenstate ng $\lambda_j$ para sa $0\leq j < k.$

Teoretikal na layout

Ang SSVQE ay maaaring ibuod tulad ng sumusunod:

• Maghanda ng ilang reference state sa pamamagitan ng pag-apply ng unitary U_R sa k iba't ibang computational basis state
  • Ang algorithm na ito ay nangangailangan ng paggamit ng $k$ magkaparehong ortogonal na reference state na $\{ |\rho_j\rangle \}_{j=0}^{k-1}$, tulad na $\langle \rho_j | \rho_l \rangle = \delta_{jl}$ para sa $j,l<k$.
• I-apply ang variational form na $U_V(\vec\theta_{i,j})$ sa bawat reference state, na nagbubunga sa sumusunod na ansatz na $U_A(\vec\theta_{i,j})$.
• Mag-bootstrap sa $i=0$ kung mayroon kang katulad na problema (karaniwang nahahanap sa pamamagitan ng klasikal na simulation o sampling).
• Suriin ang cost function na $C(\vec\theta_{i,j}) := \sum_{j=0}^{k-1} w_j \langle \psi_{j}(\vec{\theta}) | \hat{H} | \psi_{j}(\vec{\theta}) \rangle$ para sa lahat ng inihanda na estado sa isang quantum computer.
  • Maaari itong hatiin sa pagkalkula ng expectation value para sa isang observable na $\langle \psi_{j}(\vec{\theta}) | \hat{H} | \psi_{j}(\vec{\theta}) \rangle$ at pagpaparami ng resultang iyon sa $w_j$.
  • Pagkatapos, ibinabalik ng cost function ang kabuuan ng lahat ng weighted expectation value.
• Gumamit ng klasikal na optimizer para tukuyin ang susunod na hanay ng mga parameter na $\Theta_{i+1}$.
• Ulitin ang mga hakbang sa itaas hanggang maabot ang convergence.

Muling itatayo mo ang cost function ng SSVQE sa assessment, ngunit mayroon kaming sumusunod na snippet para gabayan ang iyong solusyon:

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)

Ang VQD ay isang iteratibong pamamaraan na nagpapalawak ng VQE para makuha ang unang $k$ eigenvalue ng isang observable na $\hat{H}$ na may mga eigenvalue na $\{\lambda_0, \lambda_1,...,\lambda_{N-1}\}$, kung saan $N\geq k$, sa halip na ang una lamang. Para sa natitirang bahagi ng seksyong ito, ipapalagay natin, nang walang pagkawala ng pangkalahatan, na $\lambda_0\leq\lambda_1\leq...\leq\lambda_{N-1}$. Nagpapakilala ang VQD ng konsepto ng penalty cost para gabayan ang proseso ng optimization.

Nagpapakilala ang VQD ng isang penalty term, na tinutukoy bilang $\beta$, para balansehin ang kontribusyon ng bawat overlap term sa cost. Ang penalty term na ito ay nagsisilbing parusa sa proseso ng optimization kung hindi nakamit ang ortogonalidad. Ipinapataw natin ang hadlang na ito dahil ang mga eigenstate ng isang observable, o isang Hermitian operator, na naaayon sa iba't ibang eigenvalue ay palaging magkaparehong ortogonal, o maaaring gawing ganoon sa kaso ng degeneracy o mga paulit-ulit na eigenvalue. Kaya, sa pamamagitan ng pagpapatupad ng ortogonalidad sa eigenstate na naaayon sa $\lambda_0$, epektibo tayong nag-o-optimize sa subspace na naaayon sa natitirang mga eigenvalue na $\{\lambda_1, \lambda_2,..., \lambda_{N-1}\}$. Dito, ang $\lambda_1$ ay ang pinakamababang eigenvalue mula sa natitirang mga eigenvalue at, samakatuwid, ang pinakamainam na solusyon ng bagong problema ay maaaring makuha gamit ang variational theorem.

Ang pangkalahatang ideya sa likod ng VQD ay ang paggamit ng VQE gaya ng dati para makuha ang pinakamababang eigenvalue na $\lambda_0 := C_0(\vec\theta^0) \equiv C_\text{VQE}(\vec\theta^0)$ kasama ang kaukulang (tinatayang) eigenstate na $|\psi(\vec{\theta^0})\rangle$ para sa ilang pinakamainam na parameter vector na $\vec{\theta^0}$. Pagkatapos, para makuha ang susunod na eigenvalue na $\lambda_1 > \lambda_0$, sa halip na i-minimize ang cost function na $C_0(\vec{\theta}) := \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$, ino-optimize natin ang:

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

Ang positibong halaga ng $\beta_0$ ay dapat na mas malaki kaysa $\lambda_1-\lambda_0$.

Nagpapakilala ito ng bagong cost function na maaaring tingnan bilang isang constrained problem, kung saan ini-minimize natin ang $C_\text{VQE}(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$ alinsunod sa hadlang na ang estado ay dapat na ortogonal sa dating nakuhang $|\psi(\vec{\theta^0})\rangle$, na ang $\beta_0$ ay gumaganap bilang penalty term kung hindi natutupad ang hadlang.

Bilang kahalili, ang bagong problemang ito ay maaaring interpretahin bilang pagpapatakbo ng VQE sa bagong observable:

$$\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,$$

Ipagpalagay na ang solusyon sa bagong problema ay $|\psi(\vec{\theta^1})\rangle$, ang inaasahang halaga ng $\hat{H}$ (hindi $\hat{H_1}$) ay dapat na $\langle \psi(\vec{\theta^1}) | \hat{H} | \psi(\vec{\theta^1})\rangle = \lambda_1$.

Para makuha ang ikatlong eigenvalue na $\lambda_2$, ang cost function na ia-optimize ay:

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

kung saan ang $\beta_1$ ay isang positibong constant na sapat na malaki para ipatupad ang ortogonalidad ng solution state sa parehong $|\psi(\vec{\theta^0})\rangle$ at $|\psi(\vec{\theta^1})\rangle$. Pinaparusahan nito ang mga estado sa search space na hindi nakakatugon sa kinakailangang ito, na epektibong pinipigilan ang search space. Kaya naman, ang pinakamainam na solusyon ng bagong problema ay dapat na ang eigenstate na naaayon sa $\lambda_2$.

Tulad ng nakaraang kaso, ang bagong problemang ito ay maaari ring interpretahin bilang VQE na may observable:

$$\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.$$

Kung ang solusyon sa bagong problemang ito ay $|\psi(\vec{\theta^2})\rangle$, ang inaasahang halaga ng $\hat{H}$ (hindi $\hat{H_2}$) ay dapat na $\langle \psi(\vec{\theta^2}) | \hat{H} | \psi(\vec{\theta^2})\rangle = \lambda_2$.

Sa katulad na paraan, para makuha ang $k$-th eigenvalue na $\lambda_{k-1}$, ii-minimize mo ang cost function:

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

Tandaan na tinukoy natin ang $\vec{\theta^j}$ upang $\langle \psi(\vec{\theta^j}) | \hat{H} | \psi(\vec{\theta^j})\rangle = \lambda_j, \forall j<k$. Ang problemang ito ay katumbas ng pag-minimize ng $C(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$ ngunit may hadlang na ang estado ay dapat na ortogonal sa $|\psi(\vec{\theta^j})\rangle ; \forall j \in {0, \cdots, k-1}$, na epektibong nagpipigil ng search space sa subspace na naaayon sa mga eigenvalue na $\{\lambda_{k-1},\cdots,\lambda_{N-1}\}$.

Ang problemang ito ay katumbas ng VQE na may observable:

$$\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,$$

Gaya ng makikita mo mula sa proseso, para makuha ang $k$-th eigenvalue, kailangan mo ang (tinatayang) mga eigenstate ng nakaraang $k-1$ eigenvalue, kaya kailangang patakbuhin ang VQE ng $k$ beses. Samakatuwid, ang cost function ng VQD ay ang sumusunod:

$$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$$

Teoretikal na layout

Ang layout ng VQD ay maaaring ibuod tulad ng sumusunod:

• Maghanda ng reference operator na $U_R$
• I-apply ang variational form na $U_V(\vec\theta_{i,j})$ sa reference state, na lumilikha ng mga sumusunod na ansatze na $U_A(\vec\theta_{i,j})$
• Mag-bootstrap sa $i=0$ kung mayroon kang katulad na problema (karaniwang nahahanap sa pamamagitan ng klasikal na simulation o sampling).
• Suriin ang cost function na $C_k(\vec{\theta})$, na kinabibilangan ng pagkalkula ng $k$ excited state at isang array ng mga $\beta$ na tumutukoy sa overlap penalty para sa bawat overlap term.
  • Kalkulahin ang expectation value para sa isang observable na $\langle \psi_{j}(\vec{\theta}) | \hat{H} | \psi_{j}(\vec{\theta}) \rangle$ para sa bawat $k$
  • Kalkulahin ang penalty na $\sum_{j=0}^{k-1}\beta_j |\langle \psi(\vec{\theta})| \psi(\vec{\theta^j})\rangle |^2$.
  • Ang cost function ay dapat na ibalik ang kabuuan ng dalawang term na ito
• Gumamit ng klasikal na optimizer para pumili ng susunod na hanay ng mga parameter na $\Theta_{i+1}$.
• Ulitin ang prosesong ito hanggang maabot ang convergence.

Implementasyon

Para sa implementasyong ito, gagawa tayo ng function para sa isang overlap penalty. Gagamitin ang penalty na ito sa cost function sa bawat iterasyon. Ang prosesong ito ay uulitin para sa bawat excited state.

from qiskit.circuit.library import TwoLocal

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

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

Una, mag-se-set up tayo ng function na nagkalkula ng state fidelity — isang porsyento ng overlap sa pagitan ng dalawang estado na gagamitin natin bilang penalty para sa 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)

Oras na para isulat ang cost function ng VQD. Gaya ng dati nang kinalkula natin ang ground state lamang, tutukuyin natin ang pinakamababang energy state gamit ang Estimator primitive. Gayunpaman, gaya ng inilarawan sa itaas, magdadagdag na tayo ng penalty term para matiyak ang ortogonalidad ng mga higher-energy state. Ibig sabihin, para sa bawat bagong excited state, idinaragdag ang isang penalty para sa anumang overlap sa pagitan ng kasalukuyang variational state at ng mga lower-energy eigenstate na nahanap na.

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

Dapat pansinin na ang cost function sa itaas ay tumutukoy sa function na calculate_overlaps, na lumilikha ng bagong quantum circuit. Kung gusto nating patakbuhin sa tunay na hardware, ang bagong circuit na iyon ay kailangang i-transpile rin, sana sa pinakamainam na paraan, para patakbuhin sa backend na ating pipiliin. Tandaan na ang transpilation ay hindi pa nakabuilt-in sa mga function na calculate_overlaps o cost_func_vqd. Huwag mag-atubiling subukan na baguhin ang code mismo para isama ang karagdagang (at conditional) transpilation na ito — ngunit gagawin din ito para sa iyo sa susunod na aralin.

Sa araling ito, patatakbuhin natin ang VQD algorithm gamit ang Statevector Sampler at Statevector Estimator:

from qiskit.primitives import StatevectorEstimator as Estimator

sampler = Sampler()
estimator = Estimator()

Magpapakilala tayo ng isang observable na ie-estimate. Sa susunod na aralin, magdadagdag tayo ng ilang pisikal na konteksto dito, tulad ng excited state ng isang molekula. Maaaring makatulong na isiping ang observable na ito bilang Hamiltonian ng isang sistema na maaaring magkaroon ng mga excited state, kahit na ang observable na ito ay hindi pinili para tumugma sa anumang partikular na molekula o atom.

from qiskit.quantum_info import SparsePauliOp

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

Dito, itinatakda natin ang kabuuang bilang ng mga estado na gustong kalkulahin (ground state at excited state, k), at ang mga parusa (betas) para sa overlap sa pagitan ng mga statevector na dapat na ortogonal. Ang mga kahihinatnan ng pagpili ng masyadong mataas o masyadong mababang betas ay matutuklasan nang kaunti sa susunod na aralin. Sa ngayon, gagamit lang tayo ng mga ibinigay sa ibaba. Magsisimula tayo sa paggamit ng lahat ng zero bilang ating mga parameter. Sa iyong sariling mga kalkulasyon, maaaring gusto mong gumamit ng mas matalinong panimulang parameter batay sa iyong kaalaman sa sistema o sa mga nakaraang kalkulasyon.

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

Maaari na tayong patakbuhin ang kalkulasyon:

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

Ang mga halagang nakuha namin mula sa cost function ay humigit-kumulang -6.00, 4.02, at 5.61. Ang mahalagang bagay tungkol sa mga resultang ito ay ang pagtaas ng mga function value. Kung nakakuha tayo ng unang excited state na mas mababa sa enerhiya kaysa sa ating paunang, unconstrained na kalkulasyon ng ground state, ito ay magpapahiwatig ng isang pagkakamali sa ating code.

Ang mga halaga ng x ay ang mga parameter na nagbunga ng statevector na naaayon sa bawat isa sa mga cost (enerhiya) na ito.

Sa huli, dapat nating tandaan na ang lahat ng tatlong minimization ay nagconverge sa loob ng default na toleransya ng klasikal na optimizer (dito COBYLA). Nangangailangan ang mga ito ng 131, 110, at 90 na evaluasyon ng function, ayon sa pagkakasunod.

Quantum Sampling Regression (QSR)

Isa sa mga pangunahing isyu sa VQE ay ang maraming tawag sa isang quantum computer na kinakailangan para makuha ang mga parameter para sa bawat hakbang, halimbawa, $k$, $k-1$, at iba pa. Lalo itong nagiging problema kapag ang access sa mga quantum device ay nasa pila. Habang maaaring gamitin ang Session para pagsamahin ang maraming iteratibong tawag, ang isang alternatibong pamamaraan ay ang paggamit ng sampling. Sa pamamagitan ng paggamit ng mas maraming klasikal na mapagkukunan, maaari nating makumpleto ang buong proseso ng optimization sa isang tawag lamang. Dito pumapasok ang Quantum Sampling Regression. Dahil ang access sa mga quantum computer ay isang mababang-alok/mataas-demand na kalakal, natutuklasan namin na ang trade-off na ito ay parehong posible at maginhawa para sa maraming kasalukuyang pag-aaral. Ang pamamaraang ito ay gumagamit ng lahat ng magagamit na klasikal na kakayahan habang nino-capture pa rin ang marami sa mga panloob na mekanismo at likas na katangian ng mga quantum computation na hindi lumalabas sa simulation.

Ang ideya sa likod ng QSR ay ang cost function na $C(\theta) := \langle \psi(\theta) | \hat{H} | \psi(\theta)\rangle$ ay maaaring ipahayag bilang isang Fourier series sa sumusunod na paraan:

$$\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}$$

Depende sa periodicity at bandwidth ng orihinal na function, ang set na $S$ ay maaaring finite o infinite. Para sa layunin ng talakayan na ito, ipapalagay natin na ito ay infinite. Ang susunod na hakbang ay ang pag-sample ng cost function na $C(\theta)$ nang maraming beses para makuha ang mga Fourier coefficient na $\{a_0, a_k, b_k\}_{k=1}^S$. Partikular, dahil mayroon kaming $2S+1$ na hindi kilala, kakailanganing i-sample ang cost function nang $2S+1$ beses.

Kung mag-sample tayo ng cost function para sa $2S+1$ na halaga ng parameter na $\{\theta_1,...,\theta_{2S+1}\}$, maaari tayong makakuha ng sumusunod na sistema:

$$\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},$$

na isusulat natin bilang

$$Fa=c.$$

Sa practice, ang sistemang ito ay kadalasang hindi consistent dahil ang mga halaga ng cost function na $c$ ay hindi eksaktong tumpak. Samakatuwid, kadalasang magandang ideya na i-normalize ang mga ito sa pamamagitan ng pagpaparami ng $F^\dagger$ sa kaliwa, na nagbubunga ng:

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

Ang bagong sistemang ito ay palaging consistent, at ang solusyon nito ay isang least-squares na solusyon sa orihinal na problema. Kung mayroon tayong $k$ na parameter sa halip na isa lamang, at ang bawat parameter na $\theta^i$ ay may sariling $S_i$ para sa $i \in {1,...,k}$, ang kabuuang bilang ng mga kinakailangang sample ay:

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

kung saan ang $S_{\max} = \max_i(S_i)$. Higit pa rito, ang pag-aayos ng $S_{\max}$ bilang isang tuneable parameter (sa halip na i-infer ito) ay nagbubukas ng mga bagong posibilidad, tulad ng:

• Over-sampling para mapabuti ang katumpakan.
• Under-sampling para palakasin ang performance sa pamamagitan ng pagbabawas ng runtime overhead o pag-aalis ng mga local minima.

Teoretikal na layout

Ang layout ng QSR ay maaaring ibuod tulad ng sumusunod:

• Maghanda ng reference operators na $U_R$.
  • Pupunta tayo mula sa estado $|0\rangle$ patungo sa reference state na $|\rho\rangle$
• I-apply ang variational form na $U_V(\vec\theta_{i,j})$ para lumikha ng ansatz na $U_A(\vec\theta_{i,j})$.
  • Tukuyin ang bandwidth na nauugnay sa bawat parameter sa ansatz. Sapat ang isang upper bound.
• Mag-bootstrap sa $i=0$ kung mayroon kang katulad na problema (karaniwang nahahanap sa pamamagitan ng klasikal na simulation o sampling).
• I-sample ang cost function na $C(\vec\theta) := a_0 + \sum_{k=1}^S[a_k\cos(k\theta)+ b_k\sin(k\theta)]$ nang hindi bababa sa $T$ beses.
  • $T=\prod_{i=1}^k(2S_i+1)\leq \prod_{i=1}^k(2S_{max}+1) = (2S_{max}+1)^n$
  • Magpasya kung mag-over-sample o mag-under-sample para balansehin ang bilis kumpara sa katumpakan sa pamamagitan ng pag-aayos ng $T$.
• Kalkulahin ang mga Fourier coefficient mula sa mga sample (ibig sabihin, lutasin ang normalized na linear system ng mga equation).
• Lutasin ang pandaigdigang minimum ng resultang regression function sa isang klasikal na makina.

Buod

Sa araling ito, natuto ka tungkol sa maraming variational instance na magagamit:

• Pangkalahatang layout
• Pagpapakilala ng mga timbang at parusa para ayusin ang cost function
• Pagtuklas ng under-sampling kumpara sa over-sampling para i-trade-off ang bilis kumpara sa katumpakan

Ang mga ideyang ito ay maaaring iangkop para makabuo ng custom variational algorithm na angkop sa iyong problema. Hinihikayat namin kayo na ibahagi ang inyong mga resulta sa komunidad. Tutuklasin ng susunod na aralin kung paano gamitin ang variational algorithm para malutas ng isang application.