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 tayong 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 — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "scipy": "scipy"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

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 IBM Quantum 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 ortogonal sa isa't isa 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 ortogonal sa isa't isa. 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 ortogonal sa isa't isa, 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$ na ortogonal sa isa't isa 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.

VQD introduces a penalty term, denoted as $\beta$, to balance the contribution of each overlap term to the cost. This penalty term serves to penalize the optimization process if orthogonality is not achieved. We impose this constraint because the eigenstates of an observable, or a Hermitian operator, corresponding to different eigenvalues are always mutually orthogonal, or can be made to be so in the case of degeneracy or repeated eigenvalues. Thus, by enforcing orthogonality with the eigenstate corresponding to $\lambda_0$, we are effectively optimizing over the subspace that corresponds to the rest of the eigenvalues $\{\lambda_1, \lambda_2,..., \lambda_{N-1}\}$. Here, $\lambda_1$ is the lowest eigenvalue from the rest of the eigenvalues and, therefore, the optimal solution of the new problem can be obtained using the variational theorem.

Ang pangkalahatang ideya sa likod ng VQD ay gamitin ang VQE gaya ng dati upang 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 optimal na parameter vector na $\vec{\theta^0}$. Pagkatapos, upang 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$, mag-o-optimize tayo:

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

Ang positibong value na $\beta_0$ ay dapat mas malaki kaysa sa $\lambda_1-\lambda_0$.

Ipinapakilala nito ang isang bagong cost function na maaaring ituring bilang isang constrained problem, kung saan mini-minimize natin ang $C_\text{VQE}(\vec{\theta}) = \langle \psi(\vec{\theta}) | \hat{H} | \psi(\vec{\theta})\rangle$ na napapailalim sa constraint na dapat orthogonal ang estado sa naunang nakuhang $|\psi(\vec{\theta^0})\rangle$, na kung saan ang $\beta_0$ ay kumikilos bilang isang penalty term kung hindi natutugunan ang constraint.

Bilang alternatibo, ang bagong problemang ito ay maaaring bigyang-kahulugan 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 expected value ng $\hat{H}$ (hindi $\hat{H_1}$) ay dapat na $\langle \psi(\vec{\theta^1}) | \hat{H} | \psi(\vec{\theta^1})\rangle = \lambda_1$. Upang makuha ang ikatlong eigenvalue na $\lambda_2$, ang cost function na io-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 malaki nang sapat upang ipatupad ang orthogonality 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 requirement na ito, epektibong ihinihigpit ang search space. Kaya, ang optimal na solusyon ng bagong problema ay dapat ang eigenstate na kaukulan sa $\lambda_2$.

Tulad ng naunang kaso, ang bagong problemang ito ay maaari ring bigyang-kahulugan 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 expected value 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, upang makuha ang ika-$k$ na eigenvalue na $\lambda_{k-1}$, mini-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}$ sa paraang $\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 constraint na dapat orthogonal ang estado sa $|\psi(\vec{\theta^j})\rangle ; \forall j \in {0, \cdots, k-1}$, na sa gayon ay naghihigpit sa search space patungo sa subspace na naaayon sa mga eigenvalue na $\{\lambda_{k-1},\cdots,\lambda_{N-1}\}$.

Ang problemang ito ay katumbas ng isang 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,$$

Tulad ng makikita mo sa proseso, upang makuha ang ika-$k$ na eigenvalue, kailangan mo ng (approximate) mga eigenstate ng naunang $k-1$ eigenvalue, kaya kailangan mong patakbuhin ang VQE nang kabuuang $k$ na beses. Kaya, 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 tayong 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 classical optimizer upang piliin ang susunod na set 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 tayong katulad na problema (karaniwang nahahanap sa pamamagitan ng klasikal na simulation o sampling).

• Kunin ang sample ng 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$ na 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.