குவாண்டம் நிகழ்வு இடம்பெயர்வு வழிகாட்டி

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

QuantumInstance பல காரணங்களுக்காக நிராகரிக்கப்படுகிறது: ஒருபுறம், execute() இன் செயல்பாடுகள் இப்போது பல்வேறு செயலாக்கங்களுக்கு வழங்கப்பட்டுள்ளன:mod:~qiskit.primitives அடிப்படை வகுப்புகள். மறுபுறம், ப்ரிமிடிவ்ஸ் மட்டத்தில் டிரான்ஸ்பிலேஷனை நேரடியாகச் செயல்படுத்துவதால், அல்காரிதம்கள் செயல்படுத்தலின் அந்த அம்சத்தை நிர்வகிக்க வேண்டிய அவசியமில்லை, இதனால் transpile() பணிப்பாய்வுக்கு இனி தேவைப்படாது. . விரும்பினால், தனிப்பயன் டிரான்ஸ்பிலேஷன் நடைமுறைகளை இன்னும் பயனர் மட்டத்தில் transpiler தொகுதி மூலம் செய்யலாம் (கீழே உள்ள அட்டவணையைப் பார்க்கவும்).

பின்வரும் அட்டவணை QuantumInstance வகுப்பிற்கான இடம்பெயர்வு மாற்றுகளை சுருக்கமாகக் கூறுகிறது:

QuantumInstance முறை	மாற்று
:meth:`. QuantumInstance.execute `	qiskit.primitives.Sampler.run() அல்லது qiskit.primitives.Estimator.run()
:meth:`. QuantumInstance.transpile `	:meth:` qiskit.compiler.transpile `
:meth:`. QuantumInstance.assemble `	:meth:` qiskit.compiler.assemble `

இந்த வழிகாட்டியின் மீதமுள்ளவை QuantumInstance.execute() முதல் primitives இடம்பெயர்வு பாதையில் கவனம் செலுத்தும்.

உள்ளடக்கம்

• உங்கள் பணிக்கான சரியான பழமையானதைத் தேர்ந்தெடுப்பது

• உங்கள் அமைப்புகளுக்குச் சரியான பழமையானதைத் தேர்ந்தெடுப்பது

• குறியீடு உதாரணங்கள்

Attention

கிஸ்கிட் ப்ரிமிட்டிவ்ஸின் பின்னணி

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

தற்போதைய ஆரம்பநிலைகளின் தொகுப்பில் இரண்டு வெவ்வேறு வகையான முதற்பொருள்கள் உள்ளன: மாதிரி மற்றும் மதிப்பீட்டாளர்.

Qiskit qiskit.primitives.Sampler மற்றும் qiskit.primitives.Estimator இல் குறிப்பு செயலாக்கங்களை வழங்குகிறது. கூடுதலாக, qiskit.primitives.BackendSampler மற்றும் ஒரு qiskit.primitives.BackendEstimator ஆகியவை ``backend.run()``க்கான ரேப்பர்கள் ஆகும், அவை ப்ரிமிட்டிவ் இடைமுகத்தைப் பின்பற்றுகின்றன.

வழங்குநர்கள் இந்த பழமையானவற்றை முறையே BaseSampler மற்றும் BaseEstimator ஆகியவற்றின் துணைப்பிரிவுகளாக செயல்படுத்தலாம். ஐபிஎம்மின் கிஸ்கிட் இயக்க நேரம் (qiskit_ibm_runtime) மற்றும் ஏர் (qiskit_aer.primitives) ஆகியவை ப்ரிமிட்டிவ்களின் சொந்த செயலாக்கத்திற்கான எடுத்துக்காட்டுகள்.

இந்த வழிகாட்டிப் பின்வரும் பெயரிடும் மரபைப் பயன்படுத்துகிறது:

• முதன்மைகள் - அடிப்படை வகுப்புகளைப் பயன்படுத்தி எந்த மாதிரி/மதிப்பீட்டாளர் செயல்படுத்தல் qiskit.primitives.BackendSampler மற்றும் ஒரு qiskit.primitives.BackendEstimator.

• குறிப்பு ப்ரிமிட்டிவ்ஸ் - qiskit.primitives.Sampler மற்றும் qiskit.primitives.Estimator ஆகியவை Qiskit உடன் வரும் குறிப்புச் செயலாக்கங்கள்.

• Aer Primitives - Aer பழமையான செயலாக்கங்கள்: class:qiskit_aer.primitives.Sampler மற்றும் qiskit_aer.primitives.Estimator.

• Qiskit Runtime Primitives - IBM's Qiskit Runtime primitive implementations: class:qiskit_ibm_runtime.Sampler and qiskit_ibm_runtime.Estimator.

• பின்னணி ப்ரிமிடிவ்ஸ் - qiskit.primitives.BackendSampler மற்றும் qiskit.primitives.BackendEstimator இன் நிகழ்வுகள். பழமையான இடைமுகங்களைச் செயல்படுத்த எந்தப் பின்தளத்தையும் இவை அனுமதிக்கின்றன

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

உங்கள் பணிக்கான சரியான பழமையானதைத் தேர்ந்தெடுப்பது

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

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

Note

பிரிமிடிவ்ஸ்களின் பங்கு இரண்டு மடங்கு. ஒருபுறம், அவை பின்தளங்கள் மற்றும் சிமுலேட்டர்களுக்கான அணுகல் புள்ளிகளாகச் செயல்படுகின்றன. மறுபுறம், அவை வரையறுக்கப்பட்ட பணிகளுடன் அல்காரிதம் சுருக்கங்கள்:

• `` மதிப்பீட்டாளர் `` சுற்றுகள் மற்றும் கவனிக்கக்கூடியவற்றை எடுத்து ** எதிர்பார்ப்பு மதிப்புகளை * * வழங்குகிறது.

• மாதிரி சுற்றுகளை எடுத்து, அவற்றை அளவிடுகிறது மற்றும் அவற்றின் அரை-நிகழ்தகவு விநியோகங்களை வழங்குகிறது.

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

1. உங்கள் அல்காரிதம் பயன்படுத்தும் குறைந்தபட்ச தகவல் அலகு என்ன?

   1. எதிர்பார்ப்பு மதிப்பு - உங்களுக்கு மதிப்பீட்டாளர் தேவைப்படும்

   2. நிகழ்தகவு விநியோகம் (சாதனத்தை மாதிரி எடுப்பதிலிருந்து) - உங்களுக்கு மாதிரி தேவைப்படும்

2. உங்கள் சுற்றுகளை எவ்வாறு இயக்க விரும்புகிறீர்கள்?

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

   1. விரைவான முன்மாதிரிக்கு உள்ளூர் ஸ்டேட்வெக்டர் சிமுலேட்டர்களைப் பயன்படுத்துதல்: குறிப்பு முதன்மைகள்

   2. சிறந்த அல்காரிதம் ட்யூனிங்கிற்காக உள்ளூர் சத்தமில்லாத உருவகப்படுத்துதல்களைப் பயன்படுத்துதல்: Aer Primitives

   3. இயக்கநேரம்-செயல்படுத்தப்பட்ட பின்தளங்களை அணுகுகிறது (அல்லது கிளவுட் சிமுலேட்டர்கள்): கிஸ்கிட் ரன்டைம் ப்ரிமிட்டிவ்ஸ்

   4. இயக்க நேர-இயக்கப்படாத பின்தளங்களை அணுகுகிறது : பின்புல முதன்மைகள்

விவாதிக்கக்கூடிய வகையில், மாதிரி என்பது QuantumInstance க்கு மிக நெருக்கமான பழமையானது, ஏனெனில் அவை இரண்டும் சுற்றுகளை இயக்கி ஒரு முடிவைத் தருகின்றன. இருப்பினும், QuantumInstance உடன், முடிவுத் தரவு பின்தளத்தைச் சார்ந்தது (அது ஸ்டேட்வெக்டர் உருவகப்படுத்துதல்களுக்கான எண்ணிக்கைகள் டிக்ட், ஒரு numpy.array போன்றவையாக இருக்கலாம்), Sampler அதன் SamplerResult ஐ இயல்பாக்கும் போது:class:~qiskit.result.QuasiDistribution பொருளை அதன் விளைவாக வரும் அரை-நிகழ்தகவுப் பரவலுடன் வழங்குகிறது.

மதிப்பீட்டாளர் என்பது எதிர்பார்ப்பு மதிப்புக் கணக்கீட்டிற்கான ஒரு குறிப்பிட்ட சுருக்கத்தை வழங்குகிறது, இது QuantumInstance மற்றும் அதனுடன் தொடர்புடைய முன் மற்றும் பிந்தைய செயலாக்க படிகள், பொதுவாக இது போன்ற கூடுதல் நூலகத்துடன் செய்யப்படுகிறது:mod:qiskit.opflow.

உங்கள் அமைப்புகளுக்குச் சரியான பழமையானதைத் தேர்ந்தெடுப்பது

குறிப்பிட்ட QuantumInstance அம்சங்கள் சில பழமையான செயலாக்கங்களில் மட்டுமே கிடைக்கும். பின்வரும் அட்டவணை மிகவும் பொதுவான QuantumInstance அமைப்புகளைச் சுருக்கமாகக் கூறுகிறது:

Attention

சில சந்தர்ப்பங்களில், ஒரு அமைப்பு இடைமுகத்தின் மூலம் வெளிப்படாமல் இருக்கலாம், ஆனால் அதைச் செயல்படுத்த மாற்றுப் பாதை இருக்கலாம். தனிப்பயன் டிரான்ஸ்பைலர் பாஸ்களுக்கு இது பொருந்தும், இது ப்ரிமிட்டிவ்ஸ் இடைமுகம் மூலம் அமைக்க முடியாது, ஆனால் skip_transpilation=True விருப்பத்தை அமைத்தால், முன் டிரான்ஸ்பைல் சுற்றுகள் அனுப்பப்படும். மேலும் தகவலுக்கு, விரும்பிய பழமையான செயலாக்கத்தின் API குறிப்பு அல்லது மூலக் குறியீட்டைப் பார்க்கவும்.

குவாண்டம் இன்ஸ்டன்ஸ்	குறிப்பு முதன்மைகள்	ஏர் ப்ரிமிடிவ்ஸ்	கிஸ்கிட் ரன்டைம் ப்ரிமிடிவ்ஸ்	பின்தளத்தில் முதற்பொருள்கள்
பின்னணி என்பதைத் தேர்ந்தெடுக்கவும்	இல்லை	இல்லை	ஆம்	ஆம்
ஷாட்ஸ் அமைக்கவும்	ஆம்	ஆம்	ஆம்	ஆம்
சிமுலேட்டர் அமைப்புகள்: basis_gates, coupling_map, initial_layout, noise_model, backend_options	இல்லை	ஆம்	ஆம்	இல்லை (உள் பின்தளத்தில் இருந்து ஊகிக்கப்பட்டது)
டிரான்ஸ்பைலர் அமைப்புகள்: seed_transpiler, optimization_level	இல்லை	இல்லை	ஆம் (options வழியாக) (*)	ஆம் (.set_transpile_options() வழியாக)
வரம்பற்ற pass_manager என்பதை அமைக்கவும்	இல்லை	இல்லை	இல்லை (ஆனால் மாற்றம்_தவிர்க்கலாம்)	இல்லை (ஆனால் மாற்றம்_தவிர்க்கலாம்)
bound_pass_manager என்பதை அமைக்கவும்	இல்லை	இல்லை	இல்லை	ஆம்
பின்தளத்தில்_விருப்பங்கள் அமைக்கவும்: பொதுவானவை நினைவக மற்றும் மீஸ்_லெவல்	இல்லை	இல்லை	இல்லை (qubit_layout மட்டும்)	இல்லை
அளவீட்டுப் பிழைத் தணிப்பு: அளவீடு_பிழை_தணிப்பு_cls, cals_matrix_refresh_period, measurement_error_mitigation_shots, mit_pattern	இல்லை	இல்லை	மாதிரி இயல்புநிலை -> M3 (*)	இல்லை
வேலை நிர்வாகம்: job_callback, max_job_retries, timeout, wait	பொருந்தாது	பொருந்தாது	அமர்வுகள், திரும்பத் திரும்ப (**)	இல்லை

(*) Qiskit Runtime Primitives இல் பிழைத் தணிப்பு மற்றும் அமைப்பு விருப்பங்கள்பற்றிய கூடுதல் தகவலுக்கு, இந்த இணைப்பைப் பார்வையிடவும்..

(**) இயக்க நேர அமர்வுகள்பற்றிய கூடுதல் தகவலுக்கு, இது எப்படி ஐப் பார்வையிடவும்.

குறியீடு உதாரணங்கள்

எடுத்துக்காட்டு 1: சுற்றுச்சூழல் உள்ளமை சாம்பல்

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

குவாண்டம் நிகழ்வைப் பயன்படுத்தி உள்ளூர் உருவகப்படுத்துதல்களுக்கான ஒரே மாற்று ஏர் சிமுலேட்டர் பின்தளத்தைப் பயன்படுத்துவதாகும். உருவகப்படுத்துதல் முறை எதுவும் குறிப்பிடப்படவில்லை எனில், ஏர் சிமுலேட்டர் துல்லியமான உருவகப்படுத்துதலுக்கு (ஸ்டேட்வெக்டர்/ஸ்டெபிலைசர்) இயல்புநிலையாக இருக்கும், காட்சிகள் குறிப்பிடப்பட்டால், அது ஷாட் இரைச்சலைச் சேர்க்கும். QuantumInstance.execute() எண்களை ஹெக்ஸாடெசிமல் வடிவத்தில் வழங்கியது என்பதை நினைவில் கொள்ளவும்.

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.utils import QuantumInstance

circuit = QuantumCircuit(2)
circuit.x(0)
circuit.x(1)
circuit.measure_all()

simulator = AerSimulator()
qi = QuantumInstance(backend=simulator, shots=200)
result = qi.execute(circuit).results[0]
data = result.data
counts = data.counts

print("Counts: ", counts)
print("Data: ", data)
print("Result: ", result)

Counts: {'0x3': 200}
Data: ExperimentResultData(counts={'0x3': 200})
Result:  ExperimentResult(shots=200, success=True, meas_level=2, data=ExperimentResultData(counts={'0x3': 200}), header=QobjExperimentHeader(clbit_labels=[['meas', 0], ['meas', 1]], creg_sizes=[['meas', 2]], global_phase=0.0, memory_slots=2, metadata={}, n_qubits=2, name='circuit-99', qreg_sizes=[['q', 2]], qubit_labels=[['q', 0], ['q', 1]]), status=DONE, seed_simulator=2846213898, metadata={'parallel_state_update': 16, 'parallel_shots': 1, 'sample_measure_time': 0.00025145, 'noise': 'ideal', 'batched_shots_optimization': False, 'remapped_qubits': False, 'device': 'CPU', 'active_input_qubits': [0, 1], 'measure_sampling': True, 'num_clbits': 2, 'input_qubit_map': [[1, 1], [0, 0]], 'num_qubits': 2, 'method': 'stabilizer', 'fusion': {'enabled': False}}, time_taken=0.000672166)

முதன்மைகளைப் பயன்படுத்துதல்

ப்ரிமிடிவ்கள் உள்ளூர் உருவகப்படுத்துதலுக்கு இரண்டு மாற்றுகளை வழங்குகின்றன, ஒன்று குறிப்பு ப்ரிமிட்டிவ்ஸ் மற்றும் ஒன்று ஏர் ப்ரிமிட்டிவ்ஸ். மேலே குறிப்பிட்டுள்ளபடி மாதிரிக்கான QuantumInstance.execute() க்கு மிக நெருக்கமான மாற்று Sampler primitive ஆகும்.

அ. குறிப்பு முதற்பொருட்களைப் பயன்படுத்துதல்

qiskit.quantum_info தொகுதியைப் பயன்படுத்தி அடிப்படை உருவகப்படுத்துதல் செயல்படுத்தப்பட்டது. ஷாட்கள் குறிப்பிடப்பட்டால், முடிவுகளில் ஷாட் இரைச்சல் அடங்கும். இதன் விளைவாக வரும் அரை-நிகழ்தகவு விநியோகம் பிட்ஸ்ட்ரிங்ஸைப் பயன்படுத்தாது, ஆனால் மாநிலங்களை அடையாளம் காண ** முழு எண்கள்** என்பதை நினைவில் கொள்ளவும்.

from qiskit import QuantumCircuit
from qiskit.primitives import Sampler

circuit = QuantumCircuit(2)
circuit.x(0)
circuit.x(1)
circuit.measure_all()

sampler = Sampler()
result = sampler.run(circuit, shots=200).result()
quasi_dists = result.quasi_dists

print("Quasi-dists: ", quasi_dists)
print("Result: ", result)

Quasi-dists: [{3: 1.0}]
Result: SamplerResult(quasi_dists=[{3: 1.0}], metadata=[{'shots': 200}])

** ஆ. ஏர் ப்ரிமிட்டிவ்களைப் பயன்படுத்துதல்**

ஸ்டேட்வெக்டர் முறையைப் பின்பற்றும் ஏர் சிமுலேஷன். இது QuantumInstance எடுத்துக்காட்டுக்கு மிக நெருக்கமான மாற்றாக இருக்கும், ஏனெனில் அவை இரண்டும் ஒரே சிமுலேட்டரை அணுகுகின்றன. இந்த காரணத்திற்காக, வெளியீட்டு மெட்டாடேட்டா குவாண்டம் நிகழ்வின் வெளியீட்டிற்கு நெருக்கமாக உள்ளது. இதன் விளைவாக வரும் அரை-நிகழ்தகவு விநியோகம் பிட்ஸ்ட்ரிங்ஸைப் பயன்படுத்தாது, ஆனால் மாநிலங்களை அடையாளம் காண ** முழு எண்கள்** என்பதை நினைவில் கொள்ளவும்.

Note

qiskit.result.QuasiDistribution வகுப்பு qiskit.primitives.SamplerResult இன் ஒரு பகுதியாகத் திரும்பியது, முடிவு விசைகளை முழு எண்ணிலிருந்து பைனரி சரங்கள்/ஹெக்ஸாடெசிமலுக்கு மாற்றுவதற்கான இரண்டு முறைகளை வெளிப்படுத்துகிறது:

• :meth:` qiskit.result.QuasiDistribution.binary_probabilities `

• :meth:` qiskit.result.QuasiDistribution.hex_probabilities `

from qiskit import QuantumCircuit
from qiskit_aer.primitives import Sampler

circuit = QuantumCircuit(2)
circuit.x(0)
circuit.x(1)
circuit.measure_all()

# if no Noise Model provided, the aer primitives
# perform an exact (statevector) simulation
sampler = Sampler()
result = sampler.run(circuit, shots=200).result()
quasi_dists = result.quasi_dists
# convert keys to binary bitstrings
binary_dist = quasi_dists[0].binary_probabilities()

print("Quasi-dists: ", quasi_dists)
print("Result: ", result)
print("Binary quasi-dist: ", binary_dist)

Quasi-dists: [{3: 1.0}]
Result: SamplerResult(quasi_dists=[{3: 1.0}], metadata=[{'shots': 200, 'simulator_metadata': {'parallel_state_update': 16, 'parallel_shots': 1, 'sample_measure_time': 9.016e-05, 'noise': 'ideal', 'batched_shots_optimization': False, 'remapped_qubits': False, 'device': 'CPU', 'active_input_qubits': [0, 1], 'measure_sampling': True, 'num_clbits': 2, 'input_qubit_map': [[1, 1], [0, 0]], 'num_qubits': 2, 'method': 'statevector', 'fusion': {'applied': False, 'max_fused_qubits': 5, 'threshold': 14, 'enabled': True}}}])
Binary quasi-dist:  {'11': 1.0}

எடுத்துக்காட்டு 2: நிலை சத்தம் உருவகப்படுத்துதலுடன் எதிர்பார்ப்பு மதிப்பைக் கணக்கிடுதல்

இந்த எடுத்துக்காட்டில் QuantumInstance.execute() க்கு நேரடி அழைப்பு இல்லை என்றாலும், இது ஒரு QuantumInstance-லிருந்து ஒரு :mod:`~qiskit.primitives க்கு இடம்பெயர்வது எப்படி என்பதைக் காட்டுகிறது. `-அடிப்படையிலான பணிப்பாய்வு.

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

குவாண்டம் நிகழ்வுடன் எதிர்பார்ப்பு மதிப்புகளைக் கணக்கிடுவதற்கான மிகவும் பொதுவான பயன்பாடு opflow நூலகத்துடன் இணைந்து பயன்படுத்தப்பட்டது. opflow இடம்பெயர்வு வழிகாட்டி இல் கூடுதல் தகவலைப் பார்க்கலாம்.

from qiskit import QuantumCircuit
from qiskit.opflow import StateFn, PauliSumOp, PauliExpectation, CircuitSampler
from qiskit.utils import QuantumInstance
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel
from qiskit_ibm_provider import IBMProvider

# Define problem using opflow
op = PauliSumOp.from_list([("XY",1)])
qc = QuantumCircuit(2)
qc.x(0)
qc.x(1)

state = StateFn(qc)
measurable_expression = StateFn(op, is_measurement=True).compose(state)
expectation = PauliExpectation().convert(measurable_expression)

# Define Quantum Instance with noisy simulator
provider = IBMProvider()
device = provider.get_backend("ibmq_manila")
noise_model = NoiseModel.from_backend(device)
coupling_map = device.configuration().coupling_map

backend = AerSimulator()
qi = QuantumInstance(backend=backend, shots=1024,
                    seed_simulator=42, seed_transpiler=42,
                    coupling_map=coupling_map, noise_model=noise_model)

# Run
sampler = CircuitSampler(qi).convert(expectation)
expectation_value = sampler.eval().real

print(expectation_value)

-0.04687500000000008

முதன்மைகளைப் பயன்படுத்துதல்

ப்ரிமிடிவ்கள் இப்போது ஒற்றை மதிப்பீட்டாளர் இல் ஓப்ஃப்ளோ மற்றும் குவாண்டம் நிகழ்வு செயல்பாடுகளின் கலவையை அனுமதிக்கின்றன. இந்த வழக்கில், உள்ளூர் இரைச்சல் உருவகப்படுத்துதலுக்கு, இது ஏர் மதிப்பீட்டாளராக இருக்கும்.

from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_aer.noise import NoiseModel
from qiskit_aer.primitives import Estimator
from qiskit_ibm_provider import IBMProvider

# Define problem
op = SparsePauliOp("XY")
qc = QuantumCircuit(2)
qc.x(0)
qc.x(1)

# Define Aer Estimator with noisy simulator
device = provider.get_backend("ibmq_manila")
noise_model = NoiseModel.from_backend(device)
coupling_map = device.configuration().coupling_map

# if Noise Model provided, the aer primitives
# perform a "qasm" simulation
estimator = Estimator(
           backend_options={ # method chosen automatically to match options
               "coupling_map": coupling_map,
               "noise_model": noise_model,
           },
           run_options={"seed": 42, "shots": 1024},
          transpile_options={"seed_transpiler": 42},
       )

# Run
expectation_value = estimator.run(qc, op).result().values

print(expectation_value)

[-0.04101562]

எடுத்துக்காட்டு 3: பிழைத் தணிப்புடன் IBM பின்தளத்தில் சர்க்யூட் மாதிரி

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

QuantumInstance இடைமுகமானது, முறை, மேட்ரிக்ஸ் புதுப்பிப்பு காலம் அல்லது தணிப்பு முறை போன்ற அளவீட்டுப் பிழைத் தணிப்பு அமைப்புகளை உள்ளமைக்க அனுமதித்தது. இந்தக் கட்டமைப்பு இனி primitives இடைமுகத்தில் கிடைக்காது.

from qiskit import QuantumCircuit
from qiskit.utils import QuantumInstance
from qiskit.utils.mitigation import CompleteMeasFitter
from qiskit_ibm_provider import IBMProvider

circuit = QuantumCircuit(2)
circuit.x(0)
circuit.x(1)
circuit.measure_all()

provider = IBMProvider()
backend = provider.get_backend("ibmq_montreal")

qi = QuantumInstance(
    backend=backend,
    shots=4000,
    measurement_error_mitigation_cls=CompleteMeasFitter,
    cals_matrix_refresh_period=0,
)

result = qi.execute(circuit).results[0].data
print(result)

ExperimentResultData(counts={'11': 4000})

முதன்மைகளைப் பயன்படுத்துதல்

Qiskit Runtime Primitives ஆனது resilience_level விருப்பத்துடன் எளிதாக இயக்கக்கூடிய பிழைத் தணிப்பு முறைகளின் தொகுப்பை வழங்குகிறது. இருப்பினும், இவை கட்டமைக்க முடியாதவை. மாதிரியின் resilience_level=1 என்பது குவாண்டம் நிகழ்வின் அளவீட்டுப் பிழைத் தணிப்பு செயலாக்கத்திற்கு மிக நெருக்கமான மாற்றாகும், ஆனால் இது 1-1 மாற்றாக இல்லை.

Qiskit Runtime Primitives இல் உள்ள பிழைத் தணிப்பு விருப்பங்களைப் பற்றிய கூடுதல் தகவலுக்கு, பின்வரும் `இணைப்பைப் பார்க்கவும்.<https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.options.Options.html#qiskit_ibm_runtime.options.Options>`_.

from qiskit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options

circuit = QuantumCircuit(2)
circuit.x(0)
circuit.x(1)
circuit.measure_all()

service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend("ibmq_montreal")

options = Options(resilience_level = 1) # 1 = measurement error mitigation
sampler = Sampler(session=backend, options=options)

# Run
result = sampler.run(circuit, shots=4000).result()
quasi_dists = result.quasi_dists

print("Quasi dists: ", quasi_dists)

Quasi dists: [{2: 0.0008492371522941081, 3: 0.9968874384378738, 0: -0.0003921227905920063,
         1: 0.002655447200424097}]

எடுத்துக்காட்டு 4: தனிப்பயன் மற்றும் வரம்பற்ற பாஸ் மேலாளர்களுடன் சுற்று மாதிரி

டிரான்ஸ்பிலேஷன் மேலாண்மையானது குவாண்டம் இன்ஸ்டன்ஸ் மற்றும் ப்ரிமிட்டிவ்ஸ் ஆகியவற்றுக்கு இடையே வேறுபட்டது.

குவாண்டம் நிகழ்வு உங்களை அனுமதித்தது:

• . execute() இன் போது அழைக்கப்படும் பிணைக்கப்பட்ட மற்றும் வரம்பற்ற பாஸ் மேலாளர்களை வரையறுக்கவும்.

• குறிப்பிட்ட பாஸ் மேலாளருடன் அதன் .ட்ரான்ஸ்பைல்() முறையை வெளிப்படையாக அழைக்கவும்.

எனினும்:

• குவாண்டம் நிகழ்வு அளவுருக் குவாண்டம் சுற்றுகளில் அளவுருப் பிணைப்புகளை நிர்வகிக்கவில்லை. இதன் பொருள் bound_pass_manager அமைக்கப்பட்டால், QuantumInstance.execute() க்கு அனுப்பப்பட்ட சர்க்யூட் எந்த இலவச அளவுருக்களையும் கொண்டிருக்க முடியாது.

மறுபுறம், பழமையானவற்றைப் பயன்படுத்தும்போது:

• அவர்களின் டிரான்ஸ்பிலேஷன் வழக்கத்தை நீங்கள் வெளிப்படையாக அணுக முடியாது.

• தனிப்பயன் டிரான்ஸ்பிலேஷன் பாஸ்களை ஏர், ரன்டைம் மற்றும் பேக்எண்ட் ப்ரிமிடிவ்களுக்குப் பயன்படுத்துவதற்கான வழிமுறையானது, உள்நாட்டில் முன்கூட்டியே டிரான்ஸ்பைல் செய்து, அதற்குரிய பழமையானதில் skip_transpilation=True ஐ அமைப்பதாகும்.

• தனிப்பயன் கட்டுப்பட்ட டிரான்ஸ்பைலர் பாஸ் மேலாளரை தற்போது ஏற்கும் ஒரே முதற்பொருள்கள் BackendSampler அல்லது BackendEstimator. bound_pass_manager வரையறுக்கப்பட்டால், skip_transpilation=True விருப்பம் இல்லை இந்த பிணைப்பு பாஸைத் தவிர்க்கும்.

Attention

Estimator primitive உடன் skip_transpilation=True ஐ அமைக்கும்போது கவனம் தேவை. ஆபரேட்டர் மற்றும் சர்க்யூட் அளவு ஆகியவை மதிப்பீட்டாளருடன் பொருந்த வேண்டும் என்பதால், தனிப்பயன் டிரான்ஸ்பிலேஷன் சர்க்யூட் அளவை மாற்றினால், ஆபரேட்டரை மதிப்பீட்டாளருக்கு அனுப்பும் முன் மாற்றியமைக்க வேண்டும், ஏனெனில் அது கருத்தில் கொள்ள வேண்டிய செயலில் உள்ள குவிட்களை அடையாளம் காண தற்போது எந்த வழிமுறையும் இல்லை.

ப்ரிமிட்டிவ்கள் do அளவுரு பிணைப்புகளைக் கையாளுகின்றன என்பதை நினைவில் கொள்ளவும், அதாவது bound_pass_manager ஒரு BackendSampler அல்லது BackendEstimator இல் வரையறுக்கப்பட்டிருந்தாலும் , Quantum Instance பணிப்பாய்வுகளில் எதிர்பார்க்கப்படும் அளவுருக்களை நீங்கள் கைமுறையாக ஒதுக்க வேண்டியதில்லை.

QuantumInstance க்கு இரண்டு-நிலை டிரான்ஸ்பிலேஷனைச் சேர்ப்பதற்கு ஊக்கமளித்த யூஸ்-கேஸ் CircuitSampler வகுப்புடன் இயங்கும் துடிப்பு-திறமையான டிரான்ஸ்பிலேஷன் பாஸ்களை அனுமதிப்பதாகும். பின்வரும் உதாரணம் இந்த குறிப்பிட்ட பயன்பாட்டு வழக்கை நகர்த்துவதைக் காட்டுகிறது, அங்கு QuantumInstance.execute() முறையானது CircuitSampler மூலம் பேட்டைக்கு கீழ் அழைக்கப்படுகிறது.

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

from qiskit.circuit.library.standard_gates.equivalence_library import StandardEquivalenceLibrary as std_eqlib
from qiskit.circuit.library import RealAmplitudes
from qiskit.opflow import CircuitSampler, StateFn
from qiskit.providers.fake_provider import FakeBelem
from qiskit.transpiler import PassManager, PassManagerConfig, CouplingMap
from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
from qiskit.transpiler.passes import (
    Collect2qBlocks, ConsolidateBlocks, Optimize1qGatesDecomposition,
    RZXCalibrationBuilderNoEcho, UnrollCustomDefinitions, BasisTranslator
)
from qiskit.transpiler.passes.optimization.echo_rzx_weyl_decomposition import EchoRZXWeylDecomposition
from qiskit.utils import QuantumInstance

# Define backend
backend = FakeBelem()

# Build the pass manager for the parameterized circuit
rzx_basis = ['rzx', 'rz', 'x', 'sx']
coupling_map = CouplingMap(backend.configuration().coupling_map)
config = PassManagerConfig(basis_gates=rzx_basis, coupling_map=coupling_map)
pre = level_1_pass_manager(config)
inst_map = backend.defaults().instruction_schedule_map

# Build a pass manager for the CX decomposition (works only on bound circuits)
post = PassManager([
    # Consolidate consecutive two-qubit operations.
    Collect2qBlocks(),
    ConsolidateBlocks(basis_gates=['rz', 'sx', 'x', 'rxx']),

    # Rewrite circuit in terms of Weyl-decomposed echoed RZX gates.
    EchoRZXWeylDecomposition(inst_map),

    # Attach scaled CR pulse schedules to the RZX gates.
    RZXCalibrationBuilderNoEcho(inst_map),

    # Simplify single-qubit gates.
    UnrollCustomDefinitions(std_eqlib, rzx_basis),
    BasisTranslator(std_eqlib, rzx_basis),
    Optimize1qGatesDecomposition(rzx_basis),
])

# Instantiate qi
quantum_instance = QuantumInstance(backend, pass_manager=pre, bound_pass_manager=post)

# Define parametrized circuit and parameter values
qc = RealAmplitudes(2)
print(qc.decompose())
param_dict = {p: 0.5 for p in qc.parameters}

# Instantiate CircuitSampler
sampler = CircuitSampler(quantum_instance)

# Run
quasi_dists = sampler.convert(StateFn(qc), params=param_dict).sample()
print("Quasi-dists: ", quasi_dists)

     ┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
q_0: ┤ Ry(θ[0]) ├──■──┤ Ry(θ[2]) ├──■──┤ Ry(θ[4]) ├──■──┤ Ry(θ[6]) ├
     ├──────────┤┌─┴─┐├──────────┤┌─┴─┐├──────────┤┌─┴─┐├──────────┤
q_1: ┤ Ry(θ[1]) ├┤ X ├┤ Ry(θ[3]) ├┤ X ├┤ Ry(θ[5]) ├┤ X ├┤ Ry(θ[7]) ├
     └──────────┘└───┘└──────────┘└───┘└──────────┘└───┘└──────────┘
Quasi-dists: {'11': 0.443359375, '10': 0.21875, '01': 0.189453125, '00': 0.1484375}

முதன்மைகளைப் பயன்படுத்துதல்

பின்புல மாதிரியுடன் பணிப்பாய்வு எவ்வாறு மாறுகிறது என்பதைப் பார்ப்போம்:

from qiskit.circuit.library.standard_gates.equivalence_library import StandardEquivalenceLibrary as std_eqlib
from qiskit.circuit.library import RealAmplitudes
from qiskit.primitives import BackendSampler
from qiskit.providers.fake_provider import FakeBelem
from qiskit.transpiler import PassManager, PassManagerConfig, CouplingMap
from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
from qiskit.transpiler.passes import (
    Collect2qBlocks, ConsolidateBlocks, Optimize1qGatesDecomposition,
    RZXCalibrationBuilderNoEcho, UnrollCustomDefinitions, BasisTranslator
)
from qiskit.transpiler.passes.optimization.echo_rzx_weyl_decomposition import EchoRZXWeylDecomposition

# Define backend
backend = FakeBelem()

# Build the pass manager for the parameterized circuit
rzx_basis = ['rzx', 'rz', 'x', 'sx']
coupling_map = CouplingMap(backend.configuration().coupling_map)
config = PassManagerConfig(basis_gates=rzx_basis, coupling_map=coupling_map)
pre = level_1_pass_manager(config)

# Build a pass manager for the CX decomposition (works only on bound circuits)
inst_map = backend.defaults().instruction_schedule_map
post = PassManager([
    # Consolidate consecutive two-qubit operations.
    Collect2qBlocks(),
    ConsolidateBlocks(basis_gates=['rz', 'sx', 'x', 'rxx']),

    # Rewrite circuit in terms of Weyl-decomposed echoed RZX gates.
    EchoRZXWeylDecomposition(inst_map),

    # Attach scaled CR pulse schedules to the RZX gates.
    RZXCalibrationBuilderNoEcho(inst_map),

    # Simplify single-qubit gates.
    UnrollCustomDefinitions(std_eqlib, rzx_basis),
    BasisTranslator(std_eqlib, rzx_basis),
    Optimize1qGatesDecomposition(rzx_basis),
])

# Define parametrized circuit and parameter values
qc = RealAmplitudes(2)
qc.measure_all() # add measurements!
print(qc.decompose())

# Instantiate backend sampler with skip_transpilation
sampler = BackendSampler(backend=backend, skip_transpilation=True, bound_pass_manager=post)

# Run unbound transpiler pass
transpiled_circuit = pre.run(qc)

# Run sampler
quasi_dists = sampler.run(transpiled_circuit, [[0.5] * len(qc.parameters)]).result().quasi_dists
print("Quasi-dists: ", quasi_dists)

        ┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐ ░ ┌─┐
   q_0: ┤ Ry(θ[0]) ├──■──┤ Ry(θ[2]) ├──■──┤ Ry(θ[4]) ├──■──┤ Ry(θ[6]) ├─░─┤M├───
        ├──────────┤┌─┴─┐├──────────┤┌─┴─┐├──────────┤┌─┴─┐├──────────┤ ░ └╥┘┌─┐
   q_1: ┤ Ry(θ[1]) ├┤ X ├┤ Ry(θ[3]) ├┤ X ├┤ Ry(θ[5]) ├┤ X ├┤ Ry(θ[7]) ├─░──╫─┤M├
        └──────────┘└───┘└──────────┘└───┘└──────────┘└───┘└──────────┘ ░  ║ └╥┘
meas: 2/═══════════════════════════════════════════════════════════════════╩══╩═
                                                                           0  1
Quasi-dists:  [{1: 0.18359375, 2: 0.2333984375, 0: 0.1748046875, 3: 0.408203125}]