அல்காரிதம்கள் இடம்பெயர்வு வழிகாட்டி#

TL;DR#

qiskit.algorithms தொகுதியானது சுற்றுச் செயல்பாட்டிற்கு, primitives ஐப் பயன்படுத்த முழுமையாக மறுவடிவமைக்கப்பட்டுள்ளது, இது இப்போது நிறுத்தப்பட்டுள்ளது.

3 வகையான மறுசீரமைப்பு உள்ளன:

  1. primitives ஐ ஆதரிக்கப் புதிய இடத்தில் அல்காரிதம்கள் மறுசீரமைக்கப்பட்டது. இந்த அல்காரிதம்கள் QuantumInstance-அடிப்படையிலான அதே வகுப்புப் பெயர்களைக் கொண்டுள்ளன, ஆனால் அவை புதிய துணைத் தொகுப்பில் உள்ளன.

    Attention

    இறக்குமதி பாதைகளில் கவனமாக இருங்கள்!! மரபு வழிமுறைகள் இன்னும் நேரடியாக qiskit.algorithms இலிருந்து இறக்குமதி செய்யப்படுகின்றன. மரபு இறக்குமதிகள் அகற்றப்படும் வரை, மறுசீரமைக்கப்பட்ட அல்காரிதங்களுக்கு இந்த வசதியான இறக்குமதி கிடைக்காது. எனவே, மறுசீரமைக்கப்பட்ட அல்காரிதங்களை இறக்குமதி செய்ய, நீங்கள் எப்போதும் முழு இறக்குமதி பாதையைக் குறிப்பிட வேண்டும் (எ.கா., qiskit.algorithms.eigensolvers இறக்குமதி VQD)

  2. அல்காரிதம்கள் QuantumInstance மற்றும் primitives இரண்டையும் ஆதரிக்கும் இடத்தில் (ஒரே பெயர்வெளி) மறுசீரமைக்கப்பட்டது. எதிர்காலத்தில், QuantumInstance பயன்பாடு அகற்றப்படும்.

  3. நீக்கப்பட்ட அல்காரிதம்கள் இப்போது qiskit.algorithms இலிருந்து முற்றிலும் அகற்றப்பட்டுள்ளன. இவை தற்போது பயன்பாடுகளுக்கான கட்டுமானத் தொகுதிகளாக செயல்படாத வழிமுறைகள். அவர்களின் முக்கிய மதிப்பு கல்வி, மேலும் கிஸ்கிட் பாடப்புத்தகத்தில் பயிற்சிகளாக வைக்கப்படும். பின்வரும் இணைப்புகளில் நீங்கள் பயிற்சிகளைப் பார்க்கலாம்:

இந்த இடம்பெயர்வு வழிகாட்டியின் மீதமுள்ளவை qiskit.algorithms க்குள் இடம்பெயர்வு மாற்றுகளுடன் கூடிய அல்காரிதங்களில் கவனம் செலுத்தும், அதாவது, மறுசீரமைப்பு வகை 1 மற்றும் 2 இன் கீழ் இருக்கும்.

பின்னணி#

Back to TL;DR

தி qiskit.algorithms தொகுதி முதலில் மேல் கட்டப்பட்டது qiskit.opflow நூலகம் மற்றும் QuantumInstance பயன்பாடு. :mod: இன் வளர்ச்சி ~qiskit.primitives ஒரு உயர்-நிலை செயல்படுத்தல் முன்னுதாரணத்தை அறிமுகப்படுத்தியது Estimator கவனிக்கக்கூடியவற்றிற்கான எதிர்பார்ப்பு மதிப்புகளை கணக்கிடுவதற்கு, மற்றும் ``Sampler``சுற்றுகளை செயல்படுத்துவதற்கு மற்றும் நிகழ்தகவு பகிர்வுகள் திரும்பும். இந்த கருவிகள் மறுசீரமைக்க அனுமதிக்கப்படுகின்றன தி qiskit.algorithms module, மற்றும் இரண்டையும் நிராகரிக்கவும் qiskit.opflow மற்றும் QuantumInstance.

Attention

qiskit.opflow இலிருந்து மாறுவது, சிக்கல் அமைப்பின் ஒரு பகுதியாக அல்காரிதம் எடுக்கும் வகுப்புகளைப் பாதிக்கிறது. கட்டைவிரல் விதியாக, பெரும்பாலான qiskit.opflow சார்புகள் நேரடி qiskit.quantum_info மாற்றீட்டைக் கொண்டுள்ளன. ஒரு பொதுவான உதாரணம் வகுப்பு qiskit.opflow.PauliSumOp, ஹாமில்டோனியர்களை வரையறுக்கப் பயன்படுகிறது (உதாரணமாக, VQE இல் செருகுவதற்கு), அதை qiskit.quantum_info.SparsePauliOp மூலம் மாற்றலாம். மற்ற opflow பொருட்களை எவ்வாறு நகர்த்துவது என்பது பற்றிய தகவலுக்கு, நீங்கள் Opflow இடம்பெயர்வு வழிகாட்டி ஐப் பார்க்கவும்.

மேலும் பின்னணி மற்றும் விரிவான இடம்பெயர்வு படிகளுக்கு, பார்க்கவும்:

உங்கள் அல்காரிதத்திற்கான பழமையான உள்ளமைவை எவ்வாறு தேர்வு செய்வது#

Back to TL;DR

:mod:` qiskit.algorithms ` இல் வகுப்புகள் :class:` qiskit.primitive.BaseSampler ` or class: `qiskit.primitive.BaseEstimator `.

பழமையான வகை தெரிந்தவுடன், உங்கள் விஷயத்தில் சிறப்பாகச் சரிசெய்யும் பழமையான செயலாக்கங்களுக்கு இடையே நீங்கள் தேர்வு செய்யலாம். உதாரணத்திற்கு:

  1. விரைவான நெறிமுறைகளுக்காக, நீங்கள் ப்ரெம்மியர் * * * சேர்க்கப்பட்ட ஆதாரங்களின் ** குறிப்பு முறைமையைப் பயன்படுத்த முடியும்: :class:` qiskit.primitives.Sampler ` and :class:` qiskit.primitives.Estimator `.

  2. சிறந்த அல்காரிதம் ட்யூனிங்கிற்காக, ** Aer இல் உள்ள பழமையான செயல்படுத்தல்**: qiskit_aer.primitives.Sampler மற்றும் qiskit_aer.primitives.Estimator போன்ற உள்ளூர் சிமுலேட்டர்.

  3. குவாண்டம் வன்பொருளை இயக்க நீங்கள்:

    • IBM's Qiskit Runtime service போன்ற சொந்த பழமையான செயலாக்கங்களுடன் சேவைகளை அணுகவும்:class:qiskit_ibm_runtime.Sampler மற்றும் qiskit_ibm_runtime.Estimator

    • Backend Primitives (BackendSampler மற்றும் BackendEstimator) மூலம் எந்தப் பின்முனையையும் மடக்குங்கள். இந்த ரேப்பர்கள், Backend.run() ஐ மட்டுமே ஆதரிக்கும் பின்தளத்தின் மேல் ஒரு பழமையான இடைமுகத்தைச் செயல்படுத்துகின்றன.

மேலும் விரிவான தகவல் மற்றும் எடுத்துக்காட்டுகளுக்கு, குறிப்பாக Backend Primitives பயன்பாடுகுறித்து, குவாண்டம் நிகழ்வு இடம்பெயர்வு வழிகாட்டி ஐப் பார்க்கவும்.

இந்த வழிகாட்டியில், எந்தப் பழமையான இறக்குமதியை நீங்கள் தேர்ந்தெடுக்க வேண்டும் என்பதைத் தீர்மானிக்கும் அல்காரிதங்களுக்கான 3 வெவ்வேறு பொதுவான உள்ளமைவுகளை நாங்கள் உள்ளடக்குவோம்:

  1. ஸ்டேட்வெக்டர் சிமுலேட்டருடன் ஒரு அல்காரிதத்தை இயக்குதல் (அதாவது qiskit.opflow's legacy MatrixExpectation) ஐப் பயன்படுத்தி, ஷாட் இரைச்சல் இல்லாமல் சிறந்த முடிவை நீங்கள் விரும்பினால்:

    • இயல்புநிலை உள்ளமைவுடன் குறிப்பு முதன்மைகள் (QAOA உதாரணத்தைப் பார்க்கவும்):

    from qiskit.primitives import Sampler, Estimator

    • ஸ்டேட்வெக்டர் சிமுலேட்டருடன் ஏர் ப்ரிமிடிவ்ஸ் ** (பார்க்க ` QAOA ` _ உதாரணம்):

    from qiskit_aer.primitives import Sampler, Estimator

sampler = Sampler(backend_options={"method": "statevector"})
estimator = Estimator(backend_options={"method": "statevector"})

  2. ஷாட் இரைச்சலுடன் சிமுலேட்டர்/சாதனத்தைப் பயன்படுத்தி அல்காரிதத்தை இயக்குதல் (அதாவது qiskit.opflow's மரபு PauliExpectation ஐப் பயன்படுத்துதல்):

    • குறிப்பு முதன்மைகள் ** காட்சிகளுடன்** (VQE எடுத்துக்காட்டுகளைப் பார்க்கவும்):

    from qiskit.primitives import Sampler, Estimator

sampler = Sampler(options={"shots": 100})
estimator = Estimator(options={"shots": 100})

# or...
sampler = Sampler()
job = sampler.run(circuits, shots=100)

estimator = Estimator()
job = estimator.run(circuits, observables, shots=100)

    • இயல்புநிலை உள்ளமைவுடன் கூடிய ஏர் ப்ரிமிடிவ்ஸ் (VQE எடுத்துக்காட்டுகளைப் பார்க்கவும்):

    from qiskit_aer.primitives import Sampler, Estimator

    • ஐபிஎம்மின் கிஸ்கிட் இயக்க நேர ப்ரிமிடிவ்ஸ் இயல்புநிலை உள்ளமைவுடன் ('VQD`_ உதாரணத்தைப் பார்க்கவும்):

    from qiskit_ibm_runtime import Sampler, Estimator

3. Running an algorithm on an Aer simulator using a custom instruction (i.e., using qiskit.opflow's legacy AerPauliExpectation):

  • ஷாட்ஸ்=ஒன்றுமில்லை, தோராயம்=உண்மை உடன் ஏர் ப்ரிமிடிவ்ஸ் (TrotterQRTE உதாரணத்தைப் பார்க்கவும்):

from qiskit_aer.primitives import Sampler, Estimator

sampler = Sampler(run_options={"approximation": True, "shots": None})
estimator = Estimator(run_options={"approximation": True, "shots": None})

குறைந்தபட்ச ஈஜென்சொல்வர்கள்#

Back to TL;DR

குறைந்தபட்ச eigensolver அல்காரிதம்கள் மேலே பட்டியலிடப்பட்டுள்ள முதல் வகை மறுசீரமைப்பைச் சேர்ந்தவை (அல்காரிதம்கள் primitives ஐ ஆதரிக்க புதிய இடத்தில் மறுசீரமைக்கப்பட்டது). QuantumInstance என்பதற்குப் பதிலாக, qiskit.algorithms.minimum_eigensolvers இப்போது Sampler அல்லது Estimator primitive, அல்காரிதம் சார்ந்தது. மரபு வகுப்புகளை இன்னும் qiskit.algorithms.minimum_eigen_solvers இல் காணலாம்.

Attention

:mod:`qiskit.algorithms.minimum_eigensolvers' வகுப்புகளுக்கு, இறக்குமதி பாதையைப் பொறுத்து, நீங்கள் பழமையான அடிப்படையிலான அல்லது குவாண்டம்-உதாரண அடிப்படையிலான செயல்படுத்தலை அணுகலாம். வகுப்பின் பெயர் மாறாததால், நீங்கள் கூடுதல் கவனமாக இருக்க வேண்டும்.

  • பழைய இறக்குமதி (குவாண்டம் நிகழ்வு அடிப்படையிலானது): ``qiskit.algorithms இலிருந்து VQE, QAOA, NumPyMinimumEigensolver"

  • புதிய இறக்குமதி (Primitives அடிப்படையில்): ``qiskit.algorithms.minimum_eigensolvers இலிருந்து VQE, SamplingVQE, QAOA, NumPyMinimumEigensolver"

VQE#

பாரம்பரியம் qiskit.algorithms.minimum_eigen_solvers.VQE வகுப்பு இப்போது பயன்பாட்டு வழக்கின்படி பிரிக்கப்பட்டுள்ளது:

  • பொதுவான-நோக்கமான ஹாமிலோனியர்கள், நீங்கள் Estimator-அடிப்படை :class:` qiskit.algorithms.minimum_eigensolvers.VQE` வகுப்பு பயன்படுத்த முடியும்.

  • உங்களிடம் மூலைவிட்ட ஹாமில்டோனியன் இருந்தால், மற்றும் நிலையின் மாதிரியை அல்காரிதம் திரும்பப் பெற விரும்பினால், நீங்கள் புதிய மாதிரி அடிப்படையிலான qiskit.algorithms.minimum_eigensolvers.SamplingVQE அல்காரிதத்தைப் பயன்படுத்தலாம். பாரம்பரியம் VQE உடன் CVaRExpectation ஐப் பயன்படுத்தி இது முன்னர் உணரப்பட்டது.

Note

QuantumInstance என்பதற்குப் பதிலாக Estimator நிகழ்வை எடுத்துக்கொள்வதோடு, புதிய VQE கையொப்பம் உள்ளது. பின்வரும் மாற்றங்களுக்கு உட்பட்டது:

  1. expectation` மற்றும் ``include_custom அளவுருக்கள் அகற்றப்பட்டன, ஏனெனில் இந்தச் செயல்பாடு இப்போது Estimator அளவில் வரையறுக்கப்பட்டுள்ளது.

  2. கிரேடியன்ட் அளவுரு இப்போது மரபு qiskit.opflow.gradients.Gradient வகுப்பிற்குப் பதிலாக qiskit.algorithms.gradients இலிருந்து ஒரு பழமையான-அடிப்படையிலான சாய்வு வகுப்பின் உதாரணத்தை எடுத்துக்கொள்கிறது.

  3. max_evals_grouped அளவுரு அகற்றப்பட்டது, ஏனெனில் இது ஆப்டிமைசர் வகுப்பில் நேரடியாக அமைக்கப்படலாம்.

  4. மதிப்பிடுபவர், ansatz மற்றும் ஆப்டிமைசர் ஆகியவை நிலைப்பாட்டில் வரையறுக்கப்படக்கூடிய ஒரே அளவுருக்கள் (மற்றும் இந்த வரிசையில்), மற்ற அனைத்தும் முக்கிய வார்த்தைகள் மட்டுமே.

Note

புதிய VQEResult வகுப்பில் மாநிலம் சேர்க்கப்படவில்லை, ஏனெனில் இந்த வெளியீடு மூலைவிட்ட ஆபரேட்டர்களுக்கு மட்டுமே பயனுள்ளதாக இருக்கும். இருப்பினும், இது புதிய SamplingVQEResult.

VQE எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit.library import TwoLocal
from qiskit.opflow import PauliSumOp
from qiskit.utils import QuantumInstance
from qiskit_aer import AerSimulator

ansatz = TwoLocal(2, 'ry', 'cz')
opt = SPSA(maxiter=50)

# shot-based simulation
backend = AerSimulator()
qi = QuantumInstance(backend=backend, shots=2048, seed_simulator=42)
vqe = VQE(ansatz, optimizer=opt, quantum_instance=qi)

hamiltonian = PauliSumOp.from_list([("XX", 1), ("XY", 1)])
result = vqe.compute_minimum_eigenvalue(hamiltonian)

print(result.eigenvalue)

(-0.9775390625+0j)

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit.algorithms.minimum_eigensolvers import VQE  # new import!!!
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit.library import TwoLocal
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import Estimator
from qiskit_aer.primitives import Estimator as AerEstimator

ansatz = TwoLocal(2, 'ry', 'cz')
opt = SPSA(maxiter=50)

# shot-based simulation
estimator = Estimator(options={"shots": 2048})
vqe = VQE(estimator, ansatz, opt)

# another option
aer_estimator = AerEstimator(run_options={"shots": 2048, "seed": 42})
vqe = VQE(aer_estimator, ansatz, opt)

hamiltonian = SparsePauliOp.from_list([("XX", 1), ("XY", 1)])
result = vqe.compute_minimum_eigenvalue(hamiltonian)

print(result.eigenvalue)

-0.986328125
VQE விண்ணப்பிக்கும் CVaR (SamplingVQE) எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.opflow import PauliSumOp, CVaRExpectation
from qiskit.utils import QuantumInstance
from qiskit_aer import AerSimulator

ansatz = TwoLocal(2, 'ry', 'cz')
opt = SLSQP(maxiter=50)

# shot-based simulation
backend = AerSimulator()
qi = QuantumInstance(backend=backend, shots=2048)
expectation = CVaRExpectation(alpha=0.2)
vqe = VQE(ansatz, optimizer=opt, expectation=expectation, quantum_instance=qi)

# diagonal Hamiltonian
hamiltonian = PauliSumOp.from_list([("ZZ",1), ("IZ", -0.5), ("II", 0.12)])
result = vqe.compute_minimum_eigenvalue(hamiltonian)

print(result.eigenvalue.real)

-1.38

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit.algorithms.minimum_eigensolvers import SamplingVQE # new import!!!
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit.library import TwoLocal
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import Sampler
from qiskit_aer.primitives import Sampler as AerSampler

ansatz = TwoLocal(2, 'ry', 'cz')
opt = SPSA(maxiter=50)

# shot-based simulation
sampler = Sampler(options={"shots": 2048})
vqe = SamplingVQE(sampler, ansatz, opt, aggregation=0.2)

# another option
aer_sampler = AerSampler(run_options={"shots": 2048, "seed": 42})
vqe = SamplingVQE(aer_sampler, ansatz, opt, aggregation=0.2)

# diagonal Hamiltonian
hamiltonian = SparsePauliOp.from_list([("ZZ",1), ("IZ", -0.5), ("II", 0.12)])
result = vqe.compute_minimum_eigenvalue(hamiltonian)

print(result.eigenvalue.real)

-1.38

முழுமையான குறியீடு எடுத்துக்காட்டுகளுக்கு, பின்வரும் மேம்படுத்தப்பட்ட பயிற்சிகளைப் பார்க்கவும்:

QAOA#

மரபு qiskit.algorithms.minimum_eigen_solvers.QAOA வகுப்பு நீட்டிக்கப் பயன்படுத்தப்பட்டது qiskit.algorithms.minimum_eigen_solvers.VQE, ஆனால் இப்போது, qiskit.algorithms.minimum_eigensolvers.QAOA நீட்டிக்கிறது qiskit.algorithms.minimum_eigensolvers.SamplingVQE. இந்த காரணத்திற்காக, புதிய QAOA மூலைவிட்ட ஆபரேட்டர்களை மட்டுமே ஆதரிக்கிறது.

Note

மேலும் :mod:` ~ qiskit.primitives.Sampler s பதிலாக :class: ~ qiskit.utils.QuantumInstance , புதிய :class: ~ qiskit.algorithms.minimum_eigensolvers.QAOA ` கையெழுத்து பின்வரும் மாற்றங்களைக் கொண்டுள்ளது:

  1. expectation மற்றும் include_custom அளவுருக்கள் அகற்றப்பட்டன. பதிலுக்கு, ஒருங்கிணைத்தல் அளவுரு சேர்க்கப்பட்டது (இது தனிப்பயன் எதிர்பார்ப்பு மூலம் வரையறுக்கப்பட்டது).

  2. கிரேடியன்ட் அளவுரு இப்போது மரபு qiskit.opflow.gradients.Gradient வகுப்பிற்குப் பதிலாக qiskit.algorithms.gradients இலிருந்து ஒரு பழமையான-அடிப்படையிலான சாய்வு வகுப்பின் உதாரணத்தை எடுத்துக்கொள்கிறது.

  3. max_evals_grouped அளவுரு அகற்றப்பட்டது, ஏனெனில் இது ஆப்டிமைசர் வகுப்பில் நேரடியாக அமைக்கப்படலாம்.

  4. ` ` sampler ` ` மற்றும் ` ` optimizer ` ` ஒரே அளபுருக்கள் மட்டுமே வரையறுக்கப்படலாம் (மற்றும் இந்த வரிசையில்), அனைத்து மற்றவர்கள் விசைவார்த்தை மட்டுமே.

Note

மூலைவிட்டம் அல்லாத ஆபரேட்டரில் QAOAஐ இயக்க விரும்பினால், qiskit.algorithms.minimum_eigensolvers.VQE உடன் QAOAAnsatz ஐப் பயன்படுத்தலாம், ஆனால் எந்த நிலை முடிவும் இருக்காது என்பதை நினைவில் கொள்ளவும். உங்கள் பயன்பாட்டிற்கு இறுதி நிகழ்தகவு விநியோகம் தேவைப்பட்டால், நீங்கள் ஒரு மாதிரி ஐ உடனடியாகச் செய்து VQE க்குப் பிறகு உகந்த சுற்றுடன் இயக்கலாம்.

QAOA எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

from qiskit.algorithms import QAOA
from qiskit.algorithms.optimizers import COBYLA
from qiskit.opflow import PauliSumOp
from qiskit.utils import QuantumInstance
from qiskit_aer import AerSimulator

# exact statevector simulation
backend = AerSimulator()
qi = QuantumInstance(backend=backend, shots=None,
        seed_simulator = 42, seed_transpiler = 42,
        backend_options={"method": "statevector"})

optimizer = COBYLA()
qaoa = QAOA(optimizer=optimizer, reps=2, quantum_instance=qi)

# diagonal operator
qubit_op = PauliSumOp.from_list([("ZIII", 1),("IZII", 1), ("IIIZ", 1), ("IIZI", 1)])
result = qaoa.compute_minimum_eigenvalue(qubit_op)

print(result.eigenvalue.real)

-4.0

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit.algorithms.minimum_eigensolvers import QAOA
from qiskit.algorithms.optimizers import COBYLA
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import Sampler
from qiskit_aer.primitives import Sampler as AerSampler

# exact statevector simulation
sampler = Sampler()

# another option
sampler = AerSampler(backend_options={"method": "statevector"},
                     run_options={"shots": None, "seed": 42})

optimizer = COBYLA()
qaoa = QAOA(sampler, optimizer, reps=2)

# diagonal operator
qubit_op = SparsePauliOp.from_list([("ZIII", 1),("IZII", 1), ("IIIZ", 1), ("IIZI", 1)])
result = qaoa.compute_minimum_eigenvalue(qubit_op)

print(result.eigenvalue)

-3.999999832366272

முழுமையான குறியீடு எடுத்துக்காட்டுகளுக்கு, பின்வரும் மேம்படுத்தப்பட்ட பயிற்சிகளைப் பார்க்கவும்:

நம்பைமினிமம்ஐகேன்சல்வர்#

இது ஒரு கிளாசிக்கல் தீர்வு என்பதால், பழைய மற்றும் புதிய செயலாக்கத்திற்கு இடையே பணிப்பாய்வு மாறவில்லை. இருப்பினும் இறக்குமதியானது qiskit.algorithms.minimum_eigen_solvers.NumPyMinimumEigensolver இலிருந்து qiskit.algorithms.minimum_eigensolvers.NumPyMinimumEigensolver என மாற்றப்பட்டுள்ளது.

நம்பைமினிமம்ஐகேன்சல்வர் எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

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

solver = NumPyMinimumEigensolver()

hamiltonian = PauliSumOp.from_list([("XX", 1), ("XY", 1)])
result = solver.compute_minimum_eigenvalue(hamiltonian)

print(result.eigenvalue)

-1.4142135623730958

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit.quantum_info import SparsePauliOp

solver = NumPyMinimumEigensolver()

hamiltonian = SparsePauliOp.from_list([("XX", 1), ("XY", 1)])
result = solver.compute_minimum_eigenvalue(hamiltonian)

print(result.eigenvalue)

-1.414213562373095

முழுமையான குறியீடு எடுத்துக்காட்டுகளுக்கு, பின்வரும் மேம்படுத்தப்பட்ட பயிற்சிகளைப் பார்க்கவும்:

ஐகென்சால்வர்#

Back to TL;DR

Eigensolver அல்காரிதம்களும் முதல் வகை மறுசீரமைப்பைச் சேர்ந்தவை (அல்காரிதம்கள் primitives ஐ ஆதரிக்க ஒரு புதிய இடத்தில் மறுசீரமைக்கப்பட்டது). Sampler அல்லது QuantumInstance, qiskit.algorithms.eigensolvers இப்போது துவக்கப்பட்டுள்ளது. qiskit.primitives.Estimator` primitive, அல்லது ** a primitive-based subroutine**, அல்காரிதம் சார்ந்தது. மரபு வகுப்புகளை இன்னும் qiskit.algorithms.eigen_solvers இல் காணலாம்.

Attention

:mod:`qiskit.algorithms.eigensolvers' வகுப்புகளுக்கு, இறக்குமதி பாதையைப் பொறுத்து, நீங்கள் பழமையான அடிப்படையிலான அல்லது குவாண்டம்-உதாரண அடிப்படையிலான செயல்படுத்தலை அணுகலாம். வகுப்பின் பெயர் மாறாததால், நீங்கள் கூடுதல் கவனமாக இருக்க வேண்டும்.

  • பழைய இறக்குமதி பாதை (குவாண்டம் நிகழ்வு): qiskit.algorithms இலிருந்து VQD, NumPyEigensolver இறக்குமதி செய்க

  • புதிய இறக்குமதி பாதை (Primitives): qiskit.algorithms.eigensolvers இறக்குமதி VQD, NumPyEigensolver

VQD#

புதிய qiskit.algorithms.eigensolvers.VQD வகுப்பானது QuantumInstance என்பதற்குப் பதிலாக Estimator primitive இன் உதாரணத்துடன் துவக்கப்பட்டது. இது தவிர, இது mod:qiskit.algorithms.state_fidelities இலிருந்து மாநில நம்பகத்தன்மை வகுப்பின் உதாரணத்தை எடுத்துக்கொள்கிறது, அதாவது Sampler-அடிப்படையிலான கணக்கிடப்படாதது.

Note

QuantumInstance என்பதற்குப் பதிலாக Estimator நிகழ்வை எடுத்துக்கொள்வதோடு, புதிய VQD கையொப்பம் உள்ளது. பின்வரும் மாற்றங்களுக்கு உட்பட்டது:

  1. expectation` மற்றும் ``include_custom அளவுருக்கள் அகற்றப்பட்டன, ஏனெனில் இந்தச் செயல்பாடு இப்போது Estimator அளவில் வரையறுக்கப்பட்டுள்ளது.

  2. தனிப்பயன் fidelity அளவுரு சேர்க்கப்பட்டது, மேலும் தனிப்பயன் கிரேடியன்ட் அளவுரு அகற்றப்பட்டது, ஏனெனில் qiskit.algorithms.gradients இல் உள்ள தற்போதைய வகுப்புகள் மாநில நம்பக சாய்வுகளைக் கையாள முடியாது.

  3. max_evals_grouped அளவுரு அகற்றப்பட்டது, ஏனெனில் இது ஆப்டிமைசர் வகுப்பில் நேரடியாக அமைக்கப்படலாம்.

  4. மதிப்பிடுபவர், விசுவாசம், ansatz மற்றும் உகப்பாக்கி ஆகியவை நிலைப்பாட்டில் வரையறுக்கப்படக்கூடிய ஒரே அளவுருக்கள் (மற்றும் இந்த வரிசையில்), மற்ற அனைத்தும் முக்கிய வார்த்தைகள் மட்டுமே.

Note

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

VQD எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

from qiskit import IBMQ
from qiskit.algorithms import VQD
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.opflow import PauliSumOp
from qiskit.utils import QuantumInstance

ansatz = TwoLocal(3, rotation_blocks=["ry", "rz"], entanglement_blocks="cz", reps=1)
optimizer = SLSQP(maxiter=10)
hamiltonian = PauliSumOp.from_list([("XXZ", 1), ("XYI", 1)])

# example executing in cloud simulator
provider = IBMQ.load_account()
backend = provider.get_backend("ibmq_qasm_simulator")
qi = QuantumInstance(backend=backend)

vqd = VQD(ansatz, k=3, optimizer=optimizer, quantum_instance=qi)
result = vqd.compute_eigenvalues(operator=hamiltonian)

print(result.eigenvalues)

[ 0.01765114+0.0e+00j -0.58507654+0.0e+00j -0.15003642-2.8e-17j]

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit_ibm_runtime import Sampler, Estimator, QiskitRuntimeService, Session
from qiskit.algorithms.eigensolvers import VQD
from qiskit.algorithms.optimizers import SLSQP
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.circuit.library import TwoLocal
from qiskit.quantum_info import SparsePauliOp

ansatz = TwoLocal(3, rotation_blocks=["ry", "rz"], entanglement_blocks="cz", reps=1)
optimizer = SLSQP(maxiter=10)
hamiltonian = SparsePauliOp.from_list([("XXZ", 1), ("XYI", 1)])

# example executing in cloud simulator
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend("ibmq_qasm_simulator")

with Session(service=service, backend=backend) as session:
    estimator = Estimator()
    sampler = Sampler()
    fidelity = ComputeUncompute(sampler)
    vqd = VQD(estimator, fidelity, ansatz, optimizer, k=3)
    result = vqd.compute_eigenvalues(operator=hamiltonian)

print(result.eigenvalues)

[ 0.01765114+0.0e+00j -0.58507654+0.0e+00j -0.15003642-2.8e-17j]

முழுமையான குறியீடு எடுத்துக்காட்டுகளுக்கு, பின்வரும் மேம்படுத்தப்பட்ட டுடோரியலைப் பார்க்கவும்:

நம்பைஐகேன்சால்வர்#

அதன் குறைந்தபட்ச eigensolver எண்ணைப் போலவே, இது ஒரு கிளாசிக்கல் தீர்வு என்பதால், பழைய மற்றும் புதிய செயலாக்கத்திற்கு இடையே பணிப்பாய்வு மாறவில்லை. இருப்பினும் இறக்குமதியானது புதிய இடைமுகங்கள் மற்றும் முடிவு வகுப்புகளுக்கு இணங்க qiskit.algorithms.eigen_solvers.NumPyEigensolver இலிருந்து qiskit.algorithms.eigensolvers.MinimumEigensolver ஆக மாற்றப்பட்டுள்ளது.

நம்பைஐகேன்சல்வர் எடுத்துக்காட்டு

**[Legacy]: **

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

solver = NumPyEigensolver(k=2)

hamiltonian = PauliSumOp.from_list([("XX", 1), ("XY", 1)])
result = solver.compute_eigenvalues(hamiltonian)

print(result.eigenvalues)

[-1.41421356 -1.41421356]

**[Updated]: **

from qiskit.algorithms.eigensolvers import NumPyEigensolver
from qiskit.quantum_info import SparsePauliOp

solver = NumPyEigensolver(k=2)

hamiltonian = SparsePauliOp.from_list([("XX", 1), ("XY", 1)])
result = solver.compute_eigenvalues(hamiltonian)

print(result.eigenvalues)

[-1.41421356 -1.41421356]

டைம் எவால்வர்ஸ்#

Back to TL;DR

டைம் எவால்வர்கள் என்பது முதல் வகை மறுசீரமைப்பிற்கு உட்பட்ட கடைசி அல்காரிதம்களின் குழுவாகும் (அல்காரிதம்கள் புதிய இடத்தில் மறுசீரமைக்கப்பட்டது primitives). QuantumInstance என்பதற்குப் பதிலாக, qiskit.algorithms.time_evolvers ஆனது இப்போது Estimator primitive இன் நிகழ்வைப் பயன்படுத்தி துவக்கப்படுகிறது. மரபு வகுப்புகளை இன்னும் qiskit.algorithms.evolvers இல் காணலாம்.

இடம்பெயர்வுக்கு மேல், மாரியல் குவாண்டம் டைம் எவல்யூஷன் (VarQTE) தீர்வுகளை உள்ளடக்கும் வகையில் தொகுதி கணிசமாக விரிவுபடுத்தப்பட்டுள்ளது.

TrotterQRTE#

Attention

qiskit.algorithms.time_evolvers.TrotterQRTE வகுப்பிற்கு, இறக்குமதி பாதையைப் பொறுத்து, நீங்கள் பழமையான அடிப்படையிலான அல்லது குவாண்டம்-உதாரண அடிப்படையிலான செயல்படுத்தலை அணுகலாம். வகுப்பின் பெயர் மாறாததால், நீங்கள் கூடுதல் கவனமாக இருக்க வேண்டும்.

  • பழைய இறக்குமதி பாதை (குவாண்டம் நிகழ்வு): qiskit.algorithms இறக்குமதி TrotterQRTE

  • புதிய இறக்குமதி பாதை (Primitives): qiskit.algorithms.time_evolvers இறக்குமதி TrotterQRTE

Note

QuantumInstance என்பதற்குப் பதிலாக Estimator நிகழ்வை எடுத்துக்கொள்வதோடு, புதிய VQD கையொப்பம் உள்ளது. பின்வரும் மாற்றங்களுக்கு உட்பட்டது:

  1. எதிர்பார்ப்பு அளவுரு அகற்றப்பட்டது, ஏனெனில் இந்தச் செயல்பாடு இப்போது `` மதிப்பீட்டாளர்`` அளவில் வரையறுக்கப்பட்டுள்ளது.

  2. முழு பரிணாம நேரத்தைப் பிரிக்கும் படிகளின் எண்ணிக்கையை வரையறுக்க அனுமதிக்க, num_timesteps அளவுருக்கள் சேர்க்கப்பட்டுள்ளன.

TrotterQRTE எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

from qiskit.algorithms import EvolutionProblem, TrotterQRTE
from qiskit.circuit import QuantumCircuit
from qiskit.opflow import PauliSumOp, AerPauliExpectation
from qiskit.utils import QuantumInstance
from qiskit_aer import AerSimulator

operator = PauliSumOp.from_list([("X", 1),("Z", 1)])
initial_state = QuantumCircuit(1) # zero
time = 1
evolution_problem = EvolutionProblem(operator, 1, initial_state)

# Aer simulator using custom instruction
backend = AerSimulator()
quantum_instance = QuantumInstance(backend=backend)
expectation = AerPauliExpectation()

# LieTrotter with 1 rep
trotter_qrte = TrotterQRTE(expectation=expectation, quantum_instance=quantum_instance)
evolved_state = trotter_qrte.evolve(evolution_problem).evolved_state

print(evolved_state)

CircuitStateFn(
   ┌─────────────────────┐
q: ┤ exp(-it (X + Z))(1) ├
   └─────────────────────┘
)

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit.algorithms.time_evolvers import TimeEvolutionProblem, TrotterQRTE  # note new import!!!
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_aer.primitives import Estimator as AerEstimator

operator = SparsePauliOp.from_list([("X", 1),("Z", 1)])
initial_state = QuantumCircuit(1) # zero
time = 1
evolution_problem = TimeEvolutionProblem(operator, 1, initial_state)

# Aer simulator using custom instruction
estimator = AerEstimator(run_options={"approximation": True, "shots": None})

# LieTrotter with 1 rep
trotter_qrte = TrotterQRTE(estimator=estimator)
evolved_state = trotter_qrte.evolve(evolution_problem).evolved_state

print(evolved_state.decompose())

   ┌───────────┐┌───────────┐
q: ┤ exp(it X) ├┤ exp(it Z) ├
   └───────────┘└───────────┘

அலைவீச்சு பெருக்கிகள்#

Back to TL;DR

அலைவீச்சு பெருக்கி வழிமுறைகள் இரண்டாவது வகை மறுசீரமைப்பைச் சேர்ந்தவை (அல்காரிதம்கள் இன்-இடத்தில் மறுசீரமைக்கப்பட்டவை). ஒரு QuantumInstance என்பதற்குப் பதிலாக, qiskit.algorithms.amplitude_amplifiers இப்போது ஏதேனும் "சாம்ப்ளர்" பழமையான நிகழ்வைப் பயன்படுத்தி துவக்கப்படுகிறது எ.கா. Sampler.

Note

முழு :mod:`qiskit.algorithms.amplitude_amplifiers' தொகுதி மறுவடிவமைக்கப்பட்டுள்ளது. இறக்குமதி பாதைகளை மாற்ற வேண்டிய அவசியமில்லை.

கிராவர் எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

from qiskit.algorithms import Grover
from qiskit.utils import QuantumInstance

qi = QuantumInstance(backend=backend)
grover = Grover(quantum_instance=qi)

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit.algorithms import Grover
from qiskit.primitives import Sampler

grover = Grover(sampler=Sampler())

முழுமையான குறியீடு எடுத்துக்காட்டுகளுக்கு, பின்வரும் மேம்படுத்தப்பட்ட பயிற்சிகளைப் பார்க்கவும்:

அலைவீச்சு மதிப்பீட்டாளர்கள்#

Back to TL;DR

வீச்சு பெருக்கிகளைப் போலவே, அலைவீச்சு மதிப்பீட்டாளர்களும் இரண்டாவது வகை மறுசீரமைப்பைச் சேர்ந்தவை (அல்காரிதம்ஸ் இன்-பிளேஸ் மறுசீரமைப்பு). ஒரு QuantumInstance என்பதற்குப் பதிலாக, qiskit.algorithms.amplitude_estimators என்பது இப்போது ஏதேனும் "மாதிரி" பழமையான நிகழ்வைப் பயன்படுத்தி துவக்கப்படுகிறது எ.கா. Sampler.

Note

முழு :mod:`qiskit.algorithms.amplitude_estimators' தொகுதி மறுவடிவமைக்கப்பட்டுள்ளது. இறக்குமதி பாதைகளை மாற்ற வேண்டிய அவசியமில்லை.

IAE எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

from qiskit.algorithms import IterativeAmplitudeEstimation
from qiskit.utils import QuantumInstance

qi = QuantumInstance(backend=backend)
iae = IterativeAmplitudeEstimation(
    epsilon_target=0.01,  # target accuracy
    alpha=0.05,  # width of the confidence interval
    quantum_instance=qi
)

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit.algorithms import IterativeAmplitudeEstimation
from qiskit.primitives import Sampler

iae = IterativeAmplitudeEstimation(
    epsilon_target=0.01,  # target accuracy
    alpha=0.05,  # width of the confidence interval
    sampler=Sampler()
)

முழுமையான குறியீடு எடுத்துக்காட்டுகளுக்கு, பின்வரும் மேம்படுத்தப்பட்ட பயிற்சிகளைப் பார்க்கவும்:

கட்ட மதிப்பீட்டாளர்கள்#

Back to TL;DR

இறுதியாக, கட்ட மதிப்பீட்டாளர்கள் என்பது முதல் வகை மறுசீரமைப்பிற்கு (அல்காரிதம்ஸ் ரீஃபாக்டார்ட் இன்-பிளேஸ்) உள்ள கடைசி அல்காரிதம் ஆகும். ஒரு QuantumInstance என்பதற்குப் பதிலாக, qiskit.algorithms.phase_estimators இப்போது ஏதேனும் "மாதிரி" பழமையான நிகழ்வைப் பயன்படுத்தி துவக்கப்படுகிறது எ.கா. Sampler.

Note

முழு :mod:`qiskit.algorithms.phase_estimators' தொகுதி மறுவடிவமைக்கப்பட்டுள்ளது. இறக்குமதி பாதைகளை மாற்ற வேண்டிய அவசியமில்லை.

IPE எடுத்துக்காட்டு

[Legacy] குவாண்டம் நிகழ்வைப் பயன்படுத்துதல்:

from qiskit.algorithms import IterativePhaseEstimation
from qiskit.utils import QuantumInstance

qi = QuantumInstance(backend=backend)
ipe = IterativePhaseEstimation(
    num_iterations=num_iter,
    quantum_instance=qi
)

[Updated] முதற்பொருள்களைப் பயன்படுத்துதல்:

from qiskit.algorithms import IterativePhaseEstimation
from qiskit.primitives import Sampler

ipe = IterativePhaseEstimation(
    num_iterations=num_iter,
    sampler=Sampler()
)

முழுமையான குறியீடு எடுத்துக்காட்டுகளுக்கு, பின்வரும் மேம்படுத்தப்பட்ட பயிற்சிகளைப் பார்க்கவும்: