Eksaktong simulasyon at simulasyong may ingay gamit ang Qiskit Aer primitives

Mga bersyon ng package

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na kinakailangan. Inirerekomenda namin ang paggamit ng mga bersyong ito o mas bago.

qiskit[all]~=2.3.0
qiskit-aer~=0.17

Ipinapakita ng Eksaktong simulasyon gamit ang Qiskit primitives kung paano gamitin ang mga reference primitive na kasama sa Qiskit para magsagawa ng eksaktong simulasyon ng mga quantum circuit. Ang mga kasalukuyang quantum processor ay may kasamang mga error, o ingay, kaya ang mga resulta ng eksaktong simulasyon ay hindi palaging katulad ng makukuha mo kapag nagpapatakbo ng mga circuit sa tunay na hardware. Bagama't ang mga reference primitive sa Qiskit ay hindi sumusuporta sa pag-model ng ingay, ang Qiskit Aer ay may kasamang mga implementasyon ng primitives na sumusuporta sa pag-model ng ingay. Ang Qiskit Aer ay isang mataas na performansyang quantum circuit simulator na maaari mong gamitin bilang kapalit ng mga reference primitive para sa mas magandang pagganap at mas maraming tampok. Ito ay bahagi ng Qiskit Ecosystem. Sa artikulong ito, ipinapakita namin ang paggamit ng mga Qiskit Aer primitive para sa eksaktong simulasyon at simulasyong may ingay.

Mga Tala

Kailangan ang qiskit-aer v0.14 o mas bago.
Bagama't ipinapatupad ng mga Qiskit Aer primitive ang mga interface ng primitive, hindi sila nagbibigay ng parehong mga opsyon gaya ng mga Qiskit Runtime primitive. Ang resilience level, halimbawa, ay hindi available sa mga Qiskit Aer primitive.
Tingnan ang dokumentasyon ng AerSimulator para sa mga detalye tungkol sa mga opsyon ng paraan ng simulasyon na sinusuportahan ng Aer.

Para tuklasin ang eksaktong simulasyon at simulasyong may ingay, gumawa ng halimbawang circuit sa walong qubit:

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-aer

from qiskit.circuit.library import efficient_su2

n_qubits = 8
circuit = efficient_su2(n_qubits)
circuit.draw("mpl")

Output of the previous code cell

Ang circuit na ito ay naglalaman ng mga parameter para kumatawan sa mga rotation angle para sa mga gate na $R_y$ at $R_z$ . Kapag sine-simulate ang circuit na ito, kailangan naming tukuyin ang mga eksplisitong halaga para sa mga parameter na ito. Sa susunod na cell, tinutukoy namin ang ilang halaga para sa mga parameter na ito at ginagamit ang Estimator primitive mula sa Qiskit Aer para kalkulahin ang eksaktong expectation value ng observable na $ZZ \cdots Z$ .

from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_aer import AerSimulator
from qiskit_aer.primitives import EstimatorV2 as Estimator

observable = SparsePauliOp("Z" * n_qubits)
params = [0.1] * circuit.num_parameters

exact_estimator = Estimator()
# The circuit needs to be transpiled to the AerSimulator target
pass_manager = generate_preset_pass_manager(3, AerSimulator())
isa_circuit = pass_manager.run(circuit)
pub = (isa_circuit, observable, params)
job = exact_estimator.run([pub])
result = job.result()
pub_result = result[0]
exact_value = float(pub_result.data.evs)
exact_value

0.8870140234256602

Ngayon, i-initialize natin ang isang noise model na naglalaman ng depolarizing error na 2% sa bawat CX gate. Sa praktika, ang error na nagmumula sa mga two-qubit gate, na CX gate dito, ang pinakamalaking pinagmumulan ng error kapag nagpapatakbo ng circuit. Tingnan ang Bumuo ng mga noise model para sa isang pangkalahatang-ideya ng pagbuo ng mga noise model sa Qiskit Aer.

Sa susunod na cell, nagtatayo kami ng Estimator na nagsasama ng noise model na ito at ginagamit ito para kalkulahin ang expectation value ng observable.

from qiskit_aer.noise import NoiseModel, depolarizing_error

noise_model = NoiseModel()
cx_depolarizing_prob = 0.02
noise_model.add_all_qubit_quantum_error(
    depolarizing_error(cx_depolarizing_prob, 2), ["cx"]
)

noisy_estimator = Estimator(
    options=dict(backend_options=dict(noise_model=noise_model))
)
job = noisy_estimator.run([pub])
result = job.result()
pub_result = result[0]
noisy_value = float(pub_result.data.evs)
noisy_value

0.7247404214143528

Tulad ng makikita mo, ang expectation value sa presensya ng ingay ay malayo sa tamang halaga. Sa praktika, maaari kang gumamit ng iba't ibang teknik ng error mitigation para labanan ang mga epekto ng ingay, ngunit ang talakayan ng mga teknik na ito ay nasa labas ng saklaw ng artikulong ito.

Para makakuha ng magaspang na ideya kung paano nakakaapekto ang ingay sa panghuling resulta, isaalang-alang ang aming noise model, na nagdaragdag ng depolarizing error na 2% sa bawat CX gate. Ang depolarizing error na may probabilidad na $p$ ay tinukoy bilang isang quantum channel $E$ na may sumusunod na aksyon sa isang density matrix $\rho$ :

E(\rho) = (1 - p) \rho + p\frac{I}{2^n}

kung saan ang $n$ ay ang bilang ng qubit, sa kasong ito, 2. Ibig sabihin, sa probabilidad na $p$ , ang estado ay pinapalitan ng ganap na halo-halong estado, at ang estado ay napapanatili sa probabilidad na $1 - p$ . Pagkatapos ng $m$ na aplikasyon ng depolarizing channel, ang probabilidad na mapanatili ang estado ay magiging $(1 - p)^m$ . Kaya naman, inaasahan namin na ang probabilidad ng pagpapanatili ng tamang estado sa katapusan ng simulasyon ay bumaba nang exponential kasabay ng bilang ng mga CX gate sa aming circuit.

Bilangin natin ang bilang ng mga CX gate sa aming circuit at kalkulahin ang $(1 - p)^m$ . Tinatawag namin ang count_ops para makakuha ng dictionary na nag-map ng mga pangalan ng gate sa mga bilang, at kinukuha ang entry para sa CX gate.

cx_count = circuit.count_ops()["cx"]
(1 - cx_depolarizing_prob) ** cx_count

0.6542558123199923

Ang halagang ito, 65%, ay nagbibigay ng magaspang na pagtatantya ng probabilidad na ang aming panghuling estado ay tama. Ito ay isang konserbatibong pagtatantya dahil hindi nito isinasaalang-alang ang panimulang estado ng simulasyon.

Ipinapakita ng sumusunod na code cell kung paano gamitin ang Sampler primitive mula sa Qiskit Aer para mag-sample mula sa may-ingay na circuit. Kailangan naming magdagdag ng mga sukat sa circuit bago ito patakbuhin gamit ang Sampler primitive.

from qiskit_aer.primitives import SamplerV2 as Sampler

measured_circuit = circuit.copy()
measured_circuit.measure_all()

noisy_sampler = Sampler(
    options=dict(backend_options=dict(noise_model=noise_model))
)
# The circuit needs to be transpiled to the AerSimulator target
pass_manager = generate_preset_pass_manager(3, AerSimulator())
isa_circuit = pass_manager.run(measured_circuit)
pub = (isa_circuit, params, 100)
job = noisy_sampler.run([pub])
result = job.result()
pub_result = result[0]
pub_result.data.meas.get_counts()

{'00100000': 1,
 '00000000': 65,
 '10101000': 1,
 '10000000': 5,
 '00001000': 1,
 '00000110': 2,
 '11110010': 1,
 '00000011': 3,
 '01010000': 3,
 '11000000': 3,
 '01111000': 1,
 '01000000': 2,
 '00000010': 1,
 '01100000': 1,
 '00011000': 1,
 '00111100': 1,
 '00010100': 1,
 '00001111': 1,
 '00110000': 1,
 '01100101': 1,
 '00000100': 1,
 '10100000': 1,
 '00000001': 1,
 '11010000': 1}

Mga susunod na hakbang

Mga Rekomendasyon

Para mag-simulate ng maliliit at simpleng circuit, tingnan ang Eksaktong simulasyon gamit ang Qiskit primitives.
Suriin ang dokumentasyon ng Qiskit Aer.

Mga susunod na hakbang​

Mga susunod na hakbang