Note

இந்தப் பக்கம் tutorials/algorithms/04_vqe_advanced.ipynb இல் இருந்து உருவாக்கப்பட்டது.

மேம்பட்ட VQE விருப்பங்கள்¶

முதல் அல்காரிதம் டுடோரியலில், அடிப்படை VQE அல்காரிதம் அமைப்பது எப்படி என்பதை நீங்கள் கற்றுக்கொண்டீர்கள். இப்போது, Qiskit இன் மாறுபாடு அல்காரிதம்களின் முழு அளவிலான திறன்களை ஆராய்வதற்கான மேம்பட்ட உள்ளமைவு அளவுருக்களை எவ்வாறு வழங்குவது என்பதை நீங்கள் பார்க்கலாம்: VQE <https://qiskit.org/documentation/stubs/qiskit.algorithms.minimum_eigensolvers.html>. __, QAOA மற்றும் VQD மற்றவற்றுடன். குறிப்பாக, ஒருங்கிணைப்பு மற்றும் தனிப்பயன் இனிஷியல் பாயிண்ட்கள் மற்றும் கிரேடியன்ட்களின் பயன்பாட்டைக் கண்காணிக்க கால்பேக் அமைப்பது எப்படி என்பதை இந்த டுடோரியல் விவரிக்கும்.

திரும்பஅழை¶

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

தேர்ந்தெடுக்கப்பட்ட உகப்பாக்கிகள் மூலம் தரை நிலை ஆற்றலுக்கான ஒருங்கிணைப்புப் பாதையைத் திட்டமிட, VQE இல் அழைப்புகளை எவ்வாறு மேம்படுத்துவது என்பதை இந்தப் பிரிவு விளக்குகிறது.

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

[1]:

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),
    ]
)

அடுத்த படி, VQE``க்குள் எதிர்பார்ப்பு மதிப்புகளின் மதிப்பீட்டிற்கான தேர்வின் ``மதிப்பீட்டாளர் ஐ உடனடியாகச் செய்வது. எளிமைக்காக, இயல்புநிலை Qiskit Terra நிறுவலுடன் அனுப்பப்பட்ட qiskit.primitives.Estimator ஐ நீங்கள் தேர்ந்தெடுக்கலாம்.

[2]:

from qiskit.primitives import Estimator

estimator = Estimator()

நீங்கள் இப்போது VQE கால்பேக் மூலம் ஆப்டிமைசர்களின் தொகுப்பை ஒப்பிட்டுப் பார்க்கத் தயாராக உள்ளீர்கள். H2 ஹாமில்டோனியனின் குறைந்தபட்ச ஆற்றலை மிக எளிதாகக் கண்டறிய முடியும், எனவே அதிகபட்ச எண்ணிக்கையிலான மறு செய்கைகள் (maxiter) மிகப் பெரியதாக இருக்க வேண்டியதில்லை. தேர்ந்தெடுக்கப்பட்ட சோதனை அலைச் செயல்பாடாக (அதாவது ansatz) நீங்கள் மீண்டும் TwoLocal ஐப் பயன்படுத்தலாம்.

[3]:

import numpy as np
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.utils import algorithm_globals

# we will iterate over these different optimizers
optimizers = [COBYLA(maxiter=80), L_BFGS_B(maxiter=60), SLSQP(maxiter=60)]
converge_counts = np.empty([len(optimizers)], dtype=object)
converge_vals = np.empty([len(optimizers)], dtype=object)

for i, optimizer in enumerate(optimizers):
    print("\rOptimizer: {}        ".format(type(optimizer).__name__), end="")
    algorithm_globals.random_seed = 50
    ansatz = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz")

    counts = []
    values = []

    def store_intermediate_result(eval_count, parameters, mean, std):
        counts.append(eval_count)
        values.append(mean)

    vqe = VQE(estimator, ansatz, optimizer, callback=store_intermediate_result)
    result = vqe.compute_minimum_eigenvalue(operator=H2_op)
    converge_counts[i] = np.asarray(counts)
    converge_vals[i] = np.asarray(values)

print("\rOptimization complete      ");

Optimization complete

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

[4]:

import pylab

pylab.rcParams["figure.figsize"] = (12, 8)
for i, optimizer in enumerate(optimizers):
    pylab.plot(converge_counts[i], converge_vals[i], label=type(optimizer).__name__)
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Energy convergence for various optimizers")
pylab.legend(loc="upper right");

../../_images/tutorials_algorithms_02_vqe_advanced_options_10_0.png

இறுதியாக, மேலே உள்ள சிக்கல் பாரம்பரியமாக இன்னும் எளிதில் தீர்க்கக்கூடியதாக இருப்பதால், தீர்வுக்கான குறிப்பு மதிப்பைக் கணக்கிட NumPyMinimumEigensolver ஐப் பயன்படுத்தலாம்.

[5]:

from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit.opflow import PauliSumOp

numpy_solver = NumPyMinimumEigensolver()
result = numpy_solver.compute_minimum_eigenvalue(operator=PauliSumOp(H2_op))
ref_value = result.eigenvalue.real
print(f"Reference value: {ref_value:.5f}")

Reference value: -1.85728

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

[6]:

pylab.rcParams["figure.figsize"] = (12, 8)
for i, optimizer in enumerate(optimizers):
    pylab.plot(
        converge_counts[i],
        abs(ref_value - converge_vals[i]),
        label=type(optimizer).__name__,
    )
pylab.xlabel("Eval count")
pylab.ylabel("Energy difference from solution reference value")
pylab.title("Energy convergence for various optimizers")
pylab.yscale("log")
pylab.legend(loc="upper right");

../../_images/tutorials_algorithms_02_vqe_advanced_options_14_0.png

க்ரேடியன்ட்டுகள்¶

கிஸ்கிட்டின் மாறுபாடு அல்காரிதம்களில், வழங்கப்பட்ட உகப்பாக்கி சாய்வு அடிப்படையிலான நுட்பத்தைப் பயன்படுத்தினால், இயல்புநிலை சாய்வு முறை வரையறுக்கப்பட்ட வேறுபாடுகளாக இருக்கும். இருப்பினும், இந்த வகுப்புகள் கிரேடியன்ட் அளவுரு வழியாக தனிப்பயன் சாய்வுகளை அனுப்புவதற்கான விருப்பத்தை உள்ளடக்கியது, இது Qiskit இன் கிரேடியன்ட் ஃப்ரேம்வொர்க், இது முதற்பொருள்களின் பயன்பாட்டை முழுமையாக ஆதரிக்கிறது. VQE பணிப்பாய்வுகளில் தனிப்பயன் சாய்வுகளை எவ்வாறு பயன்படுத்துவது என்பதை இந்தப் பிரிவு காட்டுகிறது.

முதல் படி, தொடர்புடைய பழமையான மற்றும் பழமையான சாய்வு இரண்டையும் துவக்க வேண்டும்:

[7]:

from qiskit.algorithms.gradients import FiniteDiffEstimatorGradient

estimator = Estimator()
gradient = FiniteDiffEstimatorGradient(estimator, epsilon=0.01)

இப்போது, மேலே உள்ள FiniteDiffEstimatorGradient ஐப் பயன்படுத்தி SLSQP இயக்கத்தை நீங்கள் ஆய்வு செய்யலாம்:

[8]:

algorithm_globals.random_seed = 50
ansatz = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz")

optimizer = SLSQP(maxiter=100)

counts = []
values = []


def store_intermediate_result(eval_count, parameters, mean, std):
    counts.append(eval_count)
    values.append(mean)


vqe = VQE(
    estimator, ansatz, optimizer, callback=store_intermediate_result, gradient=gradient
)

result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"Value using Gradient: {result.eigenvalue.real:.5f}")

Value using Gradient: -1.85728

[9]:

pylab.rcParams["figure.figsize"] = (12, 8)
pylab.plot(counts, values, label=type(optimizer).__name__)
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Energy convergence using Gradient")
pylab.legend(loc="upper right");

../../_images/tutorials_algorithms_02_vqe_advanced_options_19_0.png

ஆரம்ப புள்ளி¶

இயல்பாக, தேர்வுமுறையானது ansatz வரையறுக்கப்பட்ட எல்லைக்குள் ஒரு சீரற்ற புள்ளியில் தொடங்குகிறது. initial_point விருப்பம், ansatz அளவுருக்களின் எண்ணிக்கையுடன் பொருந்தக்கூடிய மதிப்புகளின் தனிப்பயன் பட்டியலுடன் இந்தப் புள்ளியை மேலெழுத அனுமதிக்கிறது.

நீங்கள் ஆச்சரியப்படலாம்… தனிப்பயன் ஆரம்ப புள்ளியை ஏன் அமைக்க வேண்டும்? சரி, சிக்கலுக்கான நியாயமான தொடக்க புள்ளியை நீங்கள் யூகித்தால் அல்லது முந்தைய பரிசோதனையின் தகவலை அறிந்திருந்தால் இந்த விருப்பம் பயனுள்ளதாக இருக்கும்.

இந்த அம்சத்தை நிரூபிக்க, எங்கள் முந்தைய VQE ரன் முடிவுகளைப் பார்ப்போம்:

[10]:

print(result)
cost_function_evals = result.cost_function_evals

{   'aux_operators_evaluated': None,
    'cost_function_evals': 9,
    'eigenvalue': -1.8572750175655812,
    'optimal_circuit': <qiskit.circuit.library.n_local.two_local.TwoLocal object at 0x13ef7dd20>,
    'optimal_parameters': {   ParameterVectorElement(θ[0]): 4.296519450348719,
                              ParameterVectorElement(θ[3]): 6.092947832767056,
                              ParameterVectorElement(θ[1]): 4.426962358395531,
                              ParameterVectorElement(θ[7]): 0.36021017470898664,
                              ParameterVectorElement(θ[4]): -2.598326651673288,
                              ParameterVectorElement(θ[5]): 1.5683250498282322,
                              ParameterVectorElement(θ[2]): 0.5470777607659094,
                              ParameterVectorElement(θ[6]): -4.717616147449751},
    'optimal_point': array([ 4.29651945,  4.42696236,  0.54707776,  6.09294783, -2.59832665,
        1.56832505, -4.71761615,  0.36021017]),
    'optimal_value': -1.8572750175655812,
    'optimizer_evals': None,
    'optimizer_result': <qiskit.algorithms.optimizers.optimizer.OptimizerResult object at 0x13010b6a0>,
    'optimizer_time': 0.3502693176269531}

இப்போது நாம் மேலே உள்ள முடிவிலிருந்து optimal_point -ஐ எடுத்து இங்கே initial point ஆகப் பயன்படுத்தலாம்.

குறிப்பு: `initial_point என்பது இப்போது VQE வகுப்பின் முக்கிய வார்த்தைகள் மட்டுமேயான வாதமாகும் (அதாவது, இது keyword=value தொடரியலைப் பின்பற்றி அமைக்கப்பட வேண்டும்).

[11]:

initial_pt = result.optimal_point

estimator1 = Estimator()
gradient1 = FiniteDiffEstimatorGradient(estimator, epsilon=0.01)
ansatz1 = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz")
optimizer1 = SLSQP(maxiter=1000)

vqe1 = VQE(
    estimator1, ansatz1, optimizer1, gradient=gradient1, initial_point=initial_pt
)
result1 = vqe1.compute_minimum_eigenvalue(operator=H2_op)
print(result1)

cost_function_evals1 = result1.cost_function_evals
print()

{   'aux_operators_evaluated': None,
    'cost_function_evals': 1,
    'eigenvalue': -1.8572750175655812,
    'optimal_circuit': <qiskit.circuit.library.n_local.two_local.TwoLocal object at 0x1411b9780>,
    'optimal_parameters': {   ParameterVectorElement(θ[0]): 4.296519450348719,
                              ParameterVectorElement(θ[1]): 4.426962358395531,
                              ParameterVectorElement(θ[4]): -2.598326651673288,
                              ParameterVectorElement(θ[5]): 1.5683250498282322,
                              ParameterVectorElement(θ[3]): 6.092947832767056,
                              ParameterVectorElement(θ[2]): 0.5470777607659094,
                              ParameterVectorElement(θ[6]): -4.717616147449751,
                              ParameterVectorElement(θ[7]): 0.36021017470898664},
    'optimal_point': array([ 4.29651945,  4.42696236,  0.54707776,  6.09294783, -2.59832665,
        1.56832505, -4.71761615,  0.36021017]),
    'optimal_value': -1.8572750175655812,
    'optimizer_evals': None,
    'optimizer_result': <qiskit.algorithms.optimizers.optimizer.OptimizerResult object at 0x1411e3f10>,
    'optimizer_time': 0.05097508430480957}

[12]:

print(
    f"cost_function_evals is {cost_function_evals1} with initial point versus {cost_function_evals} without it."
)

cost_function_evals is 1 with initial point versus 9 without it.

cost_function_evals ஐப் பார்ப்பதன் மூலம், அல்காரிதம் வேகமாக ஒன்றிணைவதற்கு ஆரம்பப் புள்ளி எவ்வாறு உதவியது என்பதை நீங்கள் கவனிக்கலாம் (வெறும் 1 மறு செய்கையில், நாங்கள் ஏற்கனவே உகந்த தீர்வை வழங்கியுள்ளோம்).

This can be particularly useful in cases where we have two closely related problems, and the solution to one problem can be used to guess the other’s. A good example might be plotting dissociation profiles in chemistry, where we change the inter-atomic distances of a molecule and compute its minimum eigenvalue for each distance. When the distance changes are small, we expect the solution to still be close to the prior one. Thus, a popular technique is to simply use the optimal point from one solution as the starting point for the next step. There also exist more complex techniques, where we can apply extrapolation to compute an initial position based on prior solution(s) rather than directly use the prior solution.

[13]:

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 Nov 18 01:08:34 2022 CET

This code is a part of Qiskit

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.