Note

இந்தப் பக்கம் tutorials/algorithms/09_IQPE.ipynb இலிருந்து உருவாக்கப்பட்டது.

மாறுபாடு குவாண்டம் பணவாட்டம் (VQD) அல்காரிதம்

This notebook demostrates how to use Qiskit’s implementation of the Variational Quantum Deflation (VQD) algorithm for computing higher energy states of a Hamiltonian, as introduced in this reference paper.

அறிமுகம்

VQD என்பது ஒரு குவாண்டம் அல்காரிதம் ஆகும், இது கொடுக்கப்பட்ட அமைப்பின் ஹாமில்டோனியன் H இன் k ஐஜென் மதிப்புகளைக் கண்டறிய மாறுபாடு நுட்பத்தைப் பயன்படுத்துகிறது.

மாற்றியமைக்கப்பட்ட செலவுச் செயல்பாட்டை மேம்படுத்துவதன் மூலம் பொதுமைப்படுத்தப்பட்ட ஹாமில்டோனியர்களின் உற்சாகமான நிலை ஆற்றல்களை அல்காரிதம் கணக்கிடுகிறது. ஒவ்வொரு தொடர்ச்சியான ஐகேன் மதிப்பும், முன்னர் கணக்கிடப்பட்ட அனைத்து ஐகேன்ஸ்டேட்டுகளுடனும் ஒரு மேலெழுதல் சொல்லை அறிமுகப்படுத்துவதன் மூலம் மீண்டும் மீண்டும் கணக்கிடப்படுகிறது, அவை குறைக்கப்பட வேண்டும். இது அதிக ஆற்றல் ஐகேன்ஸ்டேட்டுகள் இருப்பதை உறுதி செய்கிறது.

VQDக்கான முழுமையான வேலை உதாரணம்

VQD பணிப்பாய்வுக்கான முதல் படி ஒரு குவிட் ஆபரேட்டர், அன்சாட்ஸ் மற்றும் ஆப்டிமைசரை உருவாக்குவதாகும். இந்த எடுத்துக்காட்டில், நீங்கள் H2 மூலக்கூறைப் பயன்படுத்தலாம், முந்தைய VQE டுடோரியல்களை நீங்கள் முடித்திருந்தால் இது ஏற்கனவே நன்கு தெரிந்திருக்கும்:

from qiskit.quantum_info import SparsePauliOp

H2_op = SparsePauliOp.from_list(
    [
        ("II", -1.052373245772859),
        ("IZ", 0.39793742484318045),
        ("ZI", -0.39793742484318045),
        ("ZZ", -0.01128010425623538),
        ("XX", 0.18093119978423156),
    ]
)

எடுத்துக்காட்டாக, மூன்று குவிட்களுடன் TwoLocal ansatz ஐ அமைக்கலாம், மேலும் தேர்வுமுறை முறையாக SLSQP என்பதைத் தேர்வுசெய்யலாம்.

from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import SLSQP

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

optimizer = SLSQP()
ansatz.decompose().draw('mpl')

The next step of the workflow is to define the required primitives for running VQD. This algorithm requires two different primitive instances: one Estimator for computing the expectation values for the "VQE part" of the algorithm, and one Sampler. The sampler will be passed along to the StateFidelity subroutine that will be used to compute the cost for higher energy states. There are several methods that you can use to compute state fidelities, but to keep things simple, you can use the ComputeUncompute method already available in qiskit.algorithm.state_fidelities.

from qiskit.primitives import Sampler, Estimator
from qiskit.algorithms.state_fidelities import ComputeUncompute

estimator = Estimator()
sampler = Sampler()
fidelity = ComputeUncompute(sampler)

VQD அல்காரிதத்தை அமைப்பதற்கு, இரண்டு கூடுதல் உள்ளீடுகளை வரையறுப்பது முக்கியம்: கணக்கிடுவதற்கான ஆற்றல் நிலைகளின் எண்ணிக்கை (k) மற்றும் அசல் VQD தாளில் வரையறுக்கப்பட்ட betas. இந்த எடுத்துக்காட்டில், நிலைகளின் எண்ணிக்கை (k) மூன்றாக அமைக்கப்படும், இது இரண்டு உற்சாகமான நிலைகள் தரை நிலைக்கு கூடுதலாக கணக்கிடப்படும் என்பதைக் குறிக்கிறது.

betas செலவுச் செயல்பாட்டிற்கான ஒவ்வொரு ஒன்றுடன் ஒன்று காலத்தின் பங்களிப்பைச் சமன் செய்கிறது, மேலும் அவை VQD கட்டுமானத்தில் விருப்ப வாதமாகும். பயனரால் அமைக்கப்படவில்லை எனில், SparsePauliOp வகையின் உள்ளீட்டு ஆபரேட்டர்களுக்கு அவை தானாக மதிப்பீடு செய்யப்படலாம். உங்கள் சொந்த betas அமைக்க விரும்பினால், k நீள மதிப்புகளின் பட்டியலை வழங்க வேண்டும்.

k = 3
betas = [33, 33, 33]

You are almost ready to run the VQD algorithm, but let’s define a callback first to store intermediate values:

counts = []
values = []
steps = []

def callback(eval_count, params, value, meta, step):
    counts.append(eval_count)
    values.append(value)
    steps.append(step)

VQD அல்காரிதத்தை இயக்க நீங்கள் கிட்டத்தட்ட தயாராகிவிட்டீர்கள், ஆனால் இடைநிலை மதிப்புகளைச் சேமிப்பதற்காக முதலில் திரும்ப அழைப்பை வரையறுப்போம்.

from qiskit.algorithms.eigensolvers import VQD

vqd = VQD(estimator, fidelity, ansatz, optimizer, k=k, betas=betas, callback=callback)
result = vqd.compute_eigenvalues(operator = H2_op)
vqd_values = result.optimal_values

VQD முடிவின் ஒரு பகுதியாக நீங்கள் மூன்று நிலை ஆற்றல்களைக் காணலாம்:

print(vqd_values)

[-1.85727464 -1.2445845  -0.88272229]

மேலும் ஒவ்வொரு மாநிலத்திற்கும் ஆற்றல் ஒருங்கிணைப்பைத் திட்டமிட, கால்பேக் மூலம் சேமிக்கப்பட்ட மதிப்புகளைப் பயன்படுத்தலாம்:

import numpy as np
import pylab

pylab.rcParams["figure.figsize"] = (12, 8)

steps = np.asarray(steps)
counts = np.asarray(counts)
values = np.asarray(values)

for i in range(1,4):
    _counts = counts[np.where(steps == i)]
    _values = values[np.where(steps == i)]
    pylab.plot(_counts, _values, label=f"State {i-1}")

pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Energy convergence for each computed state")
pylab.legend(loc="upper right");

இந்த மூலக்கூறை NumPyEigensolver வகுப்பைப் பயன்படுத்தி சரியாகத் தீர்க்க முடியும், இது நீங்கள் VQD முடிவுடன் ஒப்பிடக்கூடிய ஒரு குறிப்பு மதிப்பைக் கொடுக்கும்:

from qiskit.algorithms.eigensolvers import NumPyEigensolver
from qiskit.opflow import PauliSumOp

exact_solver = NumPyEigensolver(k=3)
exact_result = exact_solver.compute_eigenvalues(PauliSumOp(H2_op))
ref_values = exact_result.eigenvalues

Let’s see a comparison of the exact result with the previously computed VQD eigenvalues:

print(f"Reference values: {ref_values}")
print(f"VQD values: {vqd_values}")

Reference values: [-1.85727503 -1.24458455 -0.88272215]
VQD values: [-1.85727464 -1.2445845  -0.88272229]

நீங்கள் பார்க்க முடியும் என, VQD இன் முடிவு சரியான தீர்விலிருந்து மதிப்புகளுடன் பொருந்துகிறது, மேலும் உற்சாகமான நிலைகளைக் கணக்கிட VQE ஐ நீட்டிக்கிறது.

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
qiskit-terra	0.22.2
qiskit-aer	0.11.1
qiskit-ignis	0.7.1
qiskit-ibmq-provider	0.19.2
qiskit	0.39.2
System information
Python version	3.10.2
Python compiler	Clang 13.0.0 (clang-1300.0.29.30)
Python build	v3.10.2:a58ebcc701, Jan 13 2022 14:50:16
OS	Darwin
CPUs	8
Memory (Gb)	64.0
Fri Dec 09 14:27:13 2022 CET

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.