Note
இந்த பக்கம் tutorials/algorithms/04_vqe_advanced.ipynb இலிருந்து உருவாக்கப்பட்டது.
மேம்பட்ட VQE பயன்பாடு¶
மேலும் மேம்பட்ட VQE திறன்களை பயன்படுத்துவதற்கு பல ஆர்குமென்ட் இருக்கிறது. இந்த பயிற்சிகள் initial_point, expectation மற்றும் gradient போன்ற ஆர்குமென்ட்களை உள்ளடக்கும்.
மேட்ரிக்ஸ் தயாரிப்பு நிலை முறையுடன் (Matrix Product State method) Aer பயன்படுத்துவது போன்ற மேம்பட்ட சிமுலேட்டர் பயன்பாட்டையும் இது உள்ளடக்கும்.
[1]:
from qiskit import Aer
from qiskit.opflow import X, Z, I
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
மற்ற VQE வழிமுறைகளின் பயிற்சிகளில் பயன்படுத்தப்படும் அதே ஆபரேட்டரை இங்கே பயன்படுத்துவோம்.
[2]:
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
ஆரம்ப புள்ளி¶
initial_point ஆர்குமென்ட் கொடுக்கப்பட்ட புள்ளியில் தேர்வுமுறை தொடங்க அனுமதிக்கிறது, அங்கு புள்ளி என்பது அன்சட்ஸ் (ansatz) உள்ளமைக்கும் ஆர்குமென்ட்களின் பட்டியல். இயல்பாக தொடக்க புள்ளி None அதாவது VQE ஒன்றைத் தேர்ந்தெடுக்கும். இந்த வழக்கில் தேர்வு என்னவென்றால், வழங்கப்பட்ட அன்சட்ஸுக்கு வழங்கப்பட்ட ஆரம்ப நிலையின் அடிப்படையில் விருப்பமான புள்ளி இருந்தால், இது தேர்வு செய்யப்படும், இல்லையெனில் அன்சட்ஸின் எந்த எல்லைகளுக்கும் பொருந்தக்கூடிய ஒரு சீரற்ற ஆரம்ப புள்ளி தேர்வு செய்யப்படும். ஒரு ஆரம்ப புள்ளி வழங்கப்பட்டால், அது முன்னுரிமை எடுக்கும் மற்றும் பயன்படுத்தப்படும் - குறிப்பாக இது அன்சட்ஸ் சுற்றுகளில் உள்ள ஆர்குமென்ட்களின் எண்ணிக்கையுடன் நீளத்துடன் பொருந்த வேண்டும்.
ஆரம்ப புள்ளியை ஏன் பயன்படுத்த வேண்டும்? சிக்கலுக்கான ஒரு நியாயமான தொடக்கப் புள்ளியை நீங்கள் யூகித்திருந்தால் அல்லது முந்தைய பரிசோதனையிலிருந்து தகவல் இருந்தால் ஒருவேளை ஒரு காரணமாக இருக்கலாம்.
பயன்பாட்டை நிரூபிக்க, முதலில் வழிமுறைகள் முன்னுரை பயிற்சிகள் இருந்து ஒரு தீர்வின் உகந்த புள்ளியைப் பெறுவதற்கான முதல் வேலை உதாரணத்தை மீண்டும் செய்வோம்.
[3]:
seed = 50
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('statevector_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)
optimizer_evals = result.optimizer_evals
{ 'aux_operator_eigenvalues': None,
'cost_function_evals': 65,
'eigenstate': array([ 9.54859564e-05+0.j, -9.93766269e-01+0.j, 1.11483597e-01+0.j,
1.76972625e-05+0.j]),
'eigenvalue': -1.8572750175780233,
'optimal_parameters': { ParameterVectorElement(θ[3]): 6.092947703759512,
ParameterVectorElement(θ[2]): 0.5470754201428533,
ParameterVectorElement(θ[1]): 4.426962028746158,
ParameterVectorElement(θ[4]): -2.5983257006415026,
ParameterVectorElement(θ[5]): 1.5683259438037993,
ParameterVectorElement(θ[6]): -4.717618238771348,
ParameterVectorElement(θ[7]): 0.3602072544539939,
ParameterVectorElement(θ[0]): 4.2965202693703635},
'optimal_point': array([ 4.29652027, 4.42696203, 0.54707542, 6.0929477 , -2.5983257 ,
1.56832594, -4.71761824, 0.36020725]),
'optimal_value': -1.8572750175780233,
'optimizer_evals': 65,
'optimizer_time': 0.08263611793518066}
இப்போது நாம் மேலே உள்ள முடிவிலிருந்து optimal_point -ஐ எடுத்து இங்கே initial point ஆக பயன்படுத்தலாம்.
[4]:
initial_pt = result.optimal_point
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('statevector_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, initial_point=initial_pt, quantum_instance=qi)
result1 = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result1)
optimizer_evals1 = result1.optimizer_evals
print()
print(f'optimizer_evals is {optimizer_evals1} with initial point versus {optimizer_evals} without it.')
{ 'aux_operator_eigenvalues': None,
'cost_function_evals': 9,
'eigenstate': array([ 9.54859564e-05+0.j, -9.93766269e-01+0.j, 1.11483597e-01+0.j,
1.76972625e-05+0.j]),
'eigenvalue': -1.8572750175780233,
'optimal_parameters': { ParameterVectorElement(θ[3]): 6.092947703759512,
ParameterVectorElement(θ[6]): -4.717618238771348,
ParameterVectorElement(θ[5]): 1.5683259438037993,
ParameterVectorElement(θ[1]): 4.426962028746158,
ParameterVectorElement(θ[2]): 0.5470754201428533,
ParameterVectorElement(θ[7]): 0.3602072544539939,
ParameterVectorElement(θ[4]): -2.5983257006415026,
ParameterVectorElement(θ[0]): 4.2965202693703635},
'optimal_point': array([ 4.29652027, 4.42696203, 0.54707542, 6.0929477 , -2.5983257 ,
1.56832594, -4.71761824, 0.36020725]),
'optimal_value': -1.8572750175780233,
'optimizer_evals': 9,
'optimizer_time': 0.027410030364990234}
optimizer_evals is 9 with initial point versus 65 without it.
ஆரம்ப புள்ளி வழங்கப்படாதபோது (முன்னிருப்பு - None) ஒரு தொடர்பின்றி எடுக்கப்பட்ட மதிப்பிலிருந்து தொடங்கியபோது, optimizer_evals உடன் அந்த முடிவு மிக விரைவாக வந்துள்ளது என்பதை இங்கே காண்கிறோம்.
எடுத்துக்காட்டுகளுக்கு இது பயனுள்ளதாக இருக்கும் இடத்தில், ஒரு பிரச்சினைக்கான தீர்வை மிக நெருக்கமான ஒத்த பிரச்சினைக்கான தீர்வுக்கான யூகத்திற்கு பயன்படுத்தலாம். வேதியியல் மிகச் சிறந்த எடுத்துக்காட்டு, அங்கு ஒரு விலகல் சுயவிவரத்தைத் திட்டமிட மூலக்கூறின் இடை-அணு தூரத்தை (களை) மாற்றுகிறோம். தூர மாற்றங்கள் சிறியதாக இருக்கும்போது, தீர்வு இன்னும் முந்தையதை அருகில் இருக்கும் என்று எதிர்பார்க்கிறோம். ஒரு நுட்பம் ஒரு தீர்விலிருந்து உகந்த புள்ளியை அடுத்த கட்டத்திற்கான தொடக்க புள்ளியாகப் பயன்படுத்துவது. இப்போது மிகவும் சிக்கலான நுட்பங்கள் சாத்தியமானவை, அவை முந்தைய தீர்வை நேரடியாகப் பயன்படுத்துவதற்குப் பதிலாக முந்தைய தீர்வை (களை) அடிப்படையாகக் கொண்டு ஒரு ஆரம்ப நிலையை கணக்கிட சில விரிவாக்கங்களைச் செய்கின்றன.
எதிர்பார்ப்பு¶
VQE பணிபுரியும் ஹாமில்டோனிய ஆபரேட்டரின் ஆற்றல் அளவுருவாக்கப்பட்ட அன்சாட்ஸுடன் மதிப்பீடு செய்யும்போது எதிர்பார்ப்பு மதிப்பு. எதிர்பார்ப்பு மதிப்பைக் கணக்கிட VQE ஒரு expectation ஆப்ஜெக்டின் உதாரணத்தைப் பயன்படுத்துகிறது. அத்தகைய நிகழ்வு expectation பராமீட்டர் வழியாக வழங்கப்படலாம் அல்லது இயல்புநிலை வழக்கில், அது None என்ற மதிப்பைக் கொண்டிருக்கலாம், VQE ExpectationFactory வழங்கப்பட்ட பின்தளத்தில் அடிப்படையில் ஒரு பொருத்தமான நிகழ்வை உருவாக்க உதவும்.
பெரும்பாலான சந்தர்ப்பங்களில் VQE ஒரு பொருத்தமான உதாரணத்தை உருவாக்க அனுமதித்தால் போதுமானது. இருப்பினும், Qiskit Aer aer_சிமுலேட்டர் ஒரு ஸ்னாப்ஷாட் அறிவுறுத்தலை ஆதரிக்கிறது, இது ஆபரேட்டர் எதிர்பார்ப்பு கணக்கீட்டுடன் இணைந்து பயன்படுத்தப்படலாம். பயன்படுத்தினால், விளைவு சிறந்தது, அதாவது ஸ்டேட்வெக்டர் சிமுலேட்டரைப் போன்றது, மற்றும் இரைச்சல் செலுத்தல் இல்லை. மக்கள் பொதுவாக aer_சிமுலேட்டர் -ஐ குறைவான இரைச்சல் செலுத்தல் (மாதிரிகள் இரைச்சல்) தேர்வு செய்வதால், மேலும் உண்மையான சாதன விளைவுகளைப் போலவே இருக்க வேண்டும் என்பதால், VQE இல் include_custom பிளாக் உள்ளது, இது எதிர்பார்ப்பு செயல்திறனுக்கு அனுப்பப்படுகிறது. Aer பிளவு சிமுலேட்டரைப் பயன்படுத்தும் போது, இது True என அமைக்கப்பட்டால், செயல்திறன் ஸ்னாப்ஷாட் வழிமுறைகளைப் பயன்படுத்தும் AerPauliExpectation ஐத் தரும், False, முன்னிருப்பு, என அமைக்கப்பட்டால் வழக்கமான PauliExpectation ஐத் தரும்.
பின்வரும் எடுத்துக்காட்டு include_custom=True ஐக் காட்டுகிறது, அங்கு விளைவு, ஸ்டேட்வெக்டர் சிமுலேட்டருடன் பொருந்துகிறது. உண்மையில் statevector_simulator-ஐ நேரடியாகப் பயன்படுத்துவதை விட இதைச் செய்வது நல்லது/வேகமாக இருக்கும். ஏனென்றால், பின்வரும் சந்தர்ப்பத்தில், ஹாமில்டோனியன் Paulis தொகையாக இருக்கும்போது அது மேட்ரிக்ஸ் வடிவமாக மாற்றப்பட வேண்டும், மேலும் include_custom உண்மை எனும்போது செய்யப்படும் ஸ்னாப்ஷாட் வழிமுறைகளைப் பயன்படுத்தும்போது இது தவிர்க்கப்படுகிறது.
[5]:
from qiskit import Aer
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('aer_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi, include_custom=True)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
optimal_value1 = result.optimal_value
print(result)
{ 'aux_operator_eigenvalues': None,
'cost_function_evals': 65,
'eigenstate': {'01': 0.9921567416492215, '10': 0.125},
'eigenvalue': -1.8572750175807682,
'optimal_parameters': { ParameterVectorElement(θ[0]): 4.296520300933687,
ParameterVectorElement(θ[4]): -2.598325866938012,
ParameterVectorElement(θ[3]): 6.092947713510392,
ParameterVectorElement(θ[1]): 4.426962159645716,
ParameterVectorElement(θ[2]): 0.5470752986013949,
ParameterVectorElement(θ[6]): -4.717618259450455,
ParameterVectorElement(θ[5]): 1.5683258132970883,
ParameterVectorElement(θ[7]): 0.3602071559531031},
'optimal_point': array([ 4.2965203 , 4.42696216, 0.5470753 , 6.09294771, -2.59832587,
1.56832581, -4.71761826, 0.36020716]),
'optimal_value': -1.8572750175807682,
'optimizer_evals': 65,
'optimizer_time': 0.17621898651123047}
உங்களுக்கு இங்கே சந்தேகம் இருந்தால் மீண்டும் aer_simulator உள்ளது, ஆனால் include_custom முன்னிருப்பு தவறுக்கு விடப்பட்டுள்ளது. தேர்வுமுறை திடீரென முடிந்தது, இரைச்சல் செலுத்தல் SLSQP ஆப்டிமைசெர் குழப்புவதால் இருக்கலாம்.
[6]:
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('aer_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
optimal_value = result.optimal_value
print('The optimal value can be seen to be wrong too, i.e. '
f'{optimal_value:.3f} versus the correct {optimal_value1:.3f}.')
print()
print(result)
The optimal value can be seen to be wrong too, i.e. -1.074 versus the correct -1.857.
{ 'aux_operator_eigenvalues': None,
'cost_function_evals': 9,
'eigenstate': { '00': 0.7781187248742958,
'01': 0.4881406047441659,
'10': 0.39404750665370286,
'11': 0.03125},
'eigenvalue': -1.0741921795698932,
'optimal_parameters': { ParameterVectorElement(θ[0]): 3.611860069224077,
ParameterVectorElement(θ[7]): 0.6984088030463615,
ParameterVectorElement(θ[3]): 5.949536809130025,
ParameterVectorElement(θ[2]): 0.6019852007557844,
ParameterVectorElement(θ[6]): -5.466043598406607,
ParameterVectorElement(θ[1]): 4.19301252102391,
ParameterVectorElement(θ[4]): -3.3070470445355764,
ParameterVectorElement(θ[5]): 1.8462931831829383},
'optimal_point': array([ 3.61186007, 4.19301252, 0.6019852 , 5.94953681, -3.30704704,
1.84629318, -5.4660436 , 0.6984088 ]),
'optimal_value': -1.0741921795698932,
'optimizer_evals': 9,
'optimizer_time': 0.07421207427978516}
சத்தம் அதிகமான சூழலில் வேலை செய்ய வடிவமைக்கப்பட்ட SPSA க்கு ஆப்டிமைசரை மாற்றுவதால் நம்மால் ஒரு சிறந்த முடிவைப் பெற முடிகிறது. இரைச்சல் முடிவை பாதித்திருந்தாலும், அது அவ்வளவு துல்லியமாக இல்லை.
[7]:
from qiskit.algorithms.optimizers import SPSA
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('aer_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SPSA(maxiter=100)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)
{ 'aux_operator_eigenvalues': None,
'cost_function_evals': 200,
'eigenstate': {'01': 0.993140536379419, '10': 0.11692679333668567},
'eigenvalue': -1.8618521132262453,
'optimal_parameters': { ParameterVectorElement(θ[4]): -2.3482177711024588,
ParameterVectorElement(θ[2]): -0.23941337071033308,
ParameterVectorElement(θ[7]): 0.22755580746001913,
ParameterVectorElement(θ[3]): 6.6402821272229335,
ParameterVectorElement(θ[6]): -4.707529314643045,
ParameterVectorElement(θ[1]): 3.325806567734803,
ParameterVectorElement(θ[5]): 3.0118347096051314,
ParameterVectorElement(θ[0]): 3.676715527111659},
'optimal_point': array([ 3.67671553, 3.32580657, -0.23941337, 6.64028213, -2.34821777,
3.01183471, -4.70752931, 0.22755581]),
'optimal_value': -1.8618521132262453,
'optimizer_evals': 200,
'optimizer_time': 1.2898402214050293}
மேலே குறிப்பிட்டுள்ளபடி, ஒரு எதிர்பார்ப்பு பொருள் வெளிப்படையாகக் கொடுக்க முடியும் (ஆகவே, உள் ExpectationFactory மற்றும் include_custom ஒருபோதும் பயன்படுத்தப்படுவதில்லை/தேவையில்லை. கீழே நாம் ஒரு AerPauliExpectation ஐ உருவாக்கி இதை VQE-க்கு அனுப்புகிறோம். மேலே include_custom உண்மை என அமைத்து, VQE அதன் சொந்த எதிர்பார்ப்பு பொருள் உருவாக்க அனுமதிக்கிறோம்.
[8]:
from qiskit.opflow import AerPauliExpectation
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('aer_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi,
expectation=AerPauliExpectation())
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)
{ 'aux_operator_eigenvalues': None,
'cost_function_evals': 65,
'eigenstate': {'01': 0.9921567416492215, '10': 0.125},
'eigenvalue': -1.8572750175807682,
'optimal_parameters': { ParameterVectorElement(θ[3]): 6.092947713510392,
ParameterVectorElement(θ[7]): 0.3602071559531031,
ParameterVectorElement(θ[6]): -4.717618259450455,
ParameterVectorElement(θ[4]): -2.598325866938012,
ParameterVectorElement(θ[5]): 1.5683258132970883,
ParameterVectorElement(θ[0]): 4.296520300933687,
ParameterVectorElement(θ[1]): 4.426962159645716,
ParameterVectorElement(θ[2]): 0.5470752986013949},
'optimal_point': array([ 4.2965203 , 4.42696216, 0.5470753 , 6.09294771, -2.59832587,
1.56832581, -4.71761826, 0.36020716]),
'optimal_value': -1.8572750175807682,
'optimizer_evals': 65,
'optimizer_time': 0.20196986198425293}
இயல்பாக, PauliExpectation பொருளில்உதாரணம், include_custom தவறானது (அல்லது Aer aer_simulator அல்லது ஒரு உண்மையான சாதனத்தைப் பயன்படுத்தும் போது) Paulis பயணத் தொகுப்புகளாகக் குழுவாகக் கொண்டிருக்கும். எதிர்பார்ப்பைக் கணக்கிடுவதற்கு இது குறைந்த சர்க்யூட்களை இயக்குவதால் இது திறமையானது. இருப்பினும், சில காரணங்களால் நீங்கள் ஒவ்வொரு Pauli-க்கும் ஒரு சர்க்யூட் இயக்க விரும்பினால், PauliExpectation -ஐ உருவாக்கும்போது குழுவாக்கத்தை அணைக்க முடியும். கீழே காட்டப்பட்டுள்ளபடி இந்த வழியில் செயல்பட நீங்கள் VQE க்கு இதுபோன்ற எதிர்பார்ப்பு நிகழ்வில் வெளிப்படையாக அனுப்ப வேண்டும்.
[9]:
from qiskit.opflow import PauliExpectation
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('aer_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SPSA(maxiter=100)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi,
expectation=PauliExpectation(group_paulis=False))
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)
{ 'aux_operator_eigenvalues': None,
'cost_function_evals': 200,
'eigenstate': {'01': 0.9916644782889019, '10': 0.1288470508005519},
'eigenvalue': -1.8649830308114583,
'optimal_parameters': { ParameterVectorElement(θ[5]): 2.9887235542230144,
ParameterVectorElement(θ[0]): 3.6833958480452034,
ParameterVectorElement(θ[1]): 3.3827104248942383,
ParameterVectorElement(θ[7]): 0.18495131387681946,
ParameterVectorElement(θ[6]): -4.76651492079903,
ParameterVectorElement(θ[2]): -0.2651696479429452,
ParameterVectorElement(θ[3]): 6.699789960055848,
ParameterVectorElement(θ[4]): -2.282559635034206},
'optimal_point': array([ 3.68339585, 3.38271042, -0.26516965, 6.69978996, -2.28255964,
2.98872355, -4.76651492, 0.18495131]),
'optimal_value': -1.8649830308114583,
'optimizer_evals': 200,
'optimizer_time': 2.700853109359741}
க்ரேடியன்ட்டு¶
க்ரேடியன்ட்டு அடிப்படையிலான நுட்பத்தைப் பயன்படுத்தும் ஆப்டிமைசர்கள் பயனர் வரையறுக்கப்பட்ட கிரேடியன்டுடன் வழங்கப்படலாம், அவை முன்னிருப்பு க்ரேடியன்ட்டு கணக்கீட்டிற்குப் பதிலாகப் பயன்படுத்தப்படும், இது பொதுவாக எளிய வரையறுக்கப்பட்ட வேறுபாட்டால் செய்யப்படுகிறது. க்ரேடியன்ட்டு அதன் gradient ஆர்குமென்ட் வழியாக மறைமுகமாக ஆப்டிமைசர் வழியாக தேர்ச்சி பெறுகிறது.
gradient வழங்கப்பட்ட பயனரின் பயன்பாடு Monitoring VQE Convergence பயிற்சிகளில் காண்பிக்கப்படுவதால், நான் உங்களை அங்கேயே குறிப்பிடுவேன். Gradients framework பயிற்சிகளில் க்ரேடியன்ட்டுகளைப் பற்றி அதிகம் உள்ளது.
குவாண்டம் உதாரணம் மற்றும் மேம்பட்ட சிமுலேஷன்¶
aer_simulator_statevector ஒரு aer_simulator அல்லது உண்மையான சாதன பின்தளத்தில் இருந்து உருவாக்கப்பட்ட ஒரு QuantumInstance கடத்துவதை நீங்கள் அறிந்திருக்கலாம், பொருந்தும் போது Aer-இன் மேம்பட்ட சிமுலேஷன் பயன்முறைகளையும் பயன்படுத்தலாம். உதாரணமாக, Aer Matrix Product நிலை முறையை நாம் எளிதாகப் பயன்படுத்தலாம், இது அதிக எண்ணிக்கையிலான க்யூபிட்களுக்கு அளவிடக்கூடிய ஆற்றலைக் கொண்டுள்ளது.
[10]:
algorithm_globals.random_seed = seed
from qiskit.providers.aer import QasmSimulator
quantum_instance = QuantumInstance(QasmSimulator(method='matrix_product_state'), shots=1)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi, include_custom=True)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)
{ 'aux_operator_eigenvalues': None,
'cost_function_evals': 65,
'eigenstate': {'01': 0.9921567416492215, '10': 0.125},
'eigenvalue': -1.8572750175807682,
'optimal_parameters': { ParameterVectorElement(θ[2]): 0.5470752986013949,
ParameterVectorElement(θ[3]): 6.092947713510392,
ParameterVectorElement(θ[5]): 1.5683258132970883,
ParameterVectorElement(θ[7]): 0.3602071559531031,
ParameterVectorElement(θ[4]): -2.598325866938012,
ParameterVectorElement(θ[1]): 4.426962159645716,
ParameterVectorElement(θ[6]): -4.717618259450455,
ParameterVectorElement(θ[0]): 4.296520300933687},
'optimal_point': array([ 4.2965203 , 4.42696216, 0.5470753 , 6.09294771, -2.59832587,
1.56832581, -4.71761826, 0.36020716]),
'optimal_value': -1.8572750175807682,
'optimizer_evals': 65,
'optimizer_time': 0.2019951343536377}
[11]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
Version Information
| Qiskit Software | Version |
|---|---|
| Qiskit | None |
| Terra | 0.18.0.dev0+5920b66 |
| Aer | 0.9.0 |
| Ignis | 0.7.0.dev0+8195559 |
| Aqua | None |
| IBM Q Provider | None |
| System information | |
| Python | 3.8.8 (default, Apr 13 2021, 12:59:45) [Clang 10.0.0 ] |
| OS | Darwin |
| CPUs | 2 |
| Memory (Gb) | 12.0 |
| Thu May 27 11:03:27 2021 EDT | |
This code is a part of Qiskit
© Copyright IBM 2017, 2021.
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.
[ ]: