Simulasi tepat dan berbising dengan primitif Qiskit Aer

Versi pakej

Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan penggunaan versi ini atau yang lebih baharu.

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

Simulasi tepat dengan primitif Qiskit SDK menunjukkan cara menggunakan primitif rujukan yang disertakan dengan Qiskit untuk melakukan simulasi tepat bagi Circuit kuantum. Pemproses kuantum sedia ada mengalami ralat, atau hingar, jadi keputusan simulasi tepat tidak semestinya mencerminkan keputusan yang dijangkakan apabila menjalankan Circuit pada perkakasan sebenar. Walaupun primitif rujukan dalam Qiskit tidak menyokong pemodelan hingar, Qiskit Aer menyertakan pelaksanaan primitif yang menyokong pemodelan hingar. Qiskit Aer ialah simulator Circuit kuantum berprestasi tinggi yang boleh anda gunakan sebagai pengganti primitif rujukan untuk prestasi yang lebih baik dan lebih banyak ciri. Ia ialah sebahagian daripada Ekosistem Qiskit. Dalam artikel ini, kami menunjukkan penggunaan primitif Qiskit Aer untuk simulasi tepat dan berbising.

Nota

qiskit-aer v0.14 atau lebih baharu diperlukan.
Walaupun primitif Qiskit Aer melaksanakan antara muka primitif, ia tidak menyediakan pilihan yang sama seperti primitif IBM Quantum. Tahap ketahanan, sebagai contoh, tidak tersedia dengan primitif Qiskit Aer.
Lihat dokumentasi AerSimulator untuk butiran tentang pilihan kaedah simulasi yang disokong Aer.

Untuk meneroka simulasi tepat dan berbising, cipta Circuit contoh pada lapan qubit:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_aer": "qiskit-aer"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit.circuit.library import efficient_su2

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

Output of the previous code cell

Circuit ini mengandungi parameter untuk mewakili sudut putaran bagi gate $R_y$ dan $R_z$ . Apabila mensimulasikan Circuit ini, kita perlu menentukan nilai eksplisit untuk parameter-parameter ini. Dalam sel seterusnya, kita menentukan beberapa nilai untuk parameter ini dan menggunakan primitif Estimator daripada Qiskit Aer untuk mengira nilai jangkaan tepat bagi boleh cerapan $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

Sekarang, mari inisialisasi model hingar yang menyertakan ralat depolarizing sebanyak 2% pada setiap gate CX. Dalam praktiknya, ralat yang timbul daripada gate dua qubit, yang merupakan gate CX di sini, adalah sumber ralat dominan apabila menjalankan Circuit. Lihat Bina model hingar untuk gambaran keseluruhan tentang membina model hingar dalam Qiskit Aer.

Dalam sel seterusnya, kami membina Estimator yang menggabungkan model hingar ini dan menggunakannya untuk mengira nilai jangkaan bagi boleh cerapan.

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

Seperti yang dapat dilihat, nilai jangkaan dengan kehadiran hingar adalah jauh daripada nilai yang betul. Dalam praktiknya, anda boleh menggunakan pelbagai teknik pengurangan ralat untuk mengatasi kesan hingar, tetapi perbincangan tentang teknik-teknik ini adalah di luar skop artikel ini.

Untuk mendapat gambaran kasar tentang bagaimana hingar mempengaruhi keputusan akhir, pertimbangkan model hingar kita, yang menambahkan ralat depolarizing sebanyak 2% kepada setiap gate CX. Ralat depolarizing dengan kebarangkalian $p$ ditakrifkan sebagai saluran kuantum $E$ yang mempunyai tindakan berikut pada matriks ketumpatan $\rho$ :

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

dengan $n$ ialah bilangan qubit, iaitu 2 dalam kes ini. Iaitu, dengan kebarangkalian $p$ , keadaan digantikan dengan keadaan campuran sepenuhnya, dan keadaan dipelihara dengan kebarangkalian $1 - p$ . Selepas $m$ penggunaan saluran depolarizing, kebarangkalian keadaan dipelihara ialah $(1 - p)^m$ . Oleh itu, kita jangkakan kebarangkalian mengekalkan keadaan yang betul pada akhir simulasi akan menurun secara eksponen dengan bilangan gate CX dalam Circuit kita.

Mari hitung bilangan gate CX dalam Circuit kita dan kira $(1 - p)^m$ . Kita panggil count_ops untuk mendapatkan kamus yang memetakan nama gate kepada kiraan, dan dapatkan semula entri untuk gate CX.

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

0.6542558123199923

Nilai ini, 65%, memberikan anggaran kasar tentang kebarangkalian keadaan akhir kita adalah betul. Ia adalah anggaran konservatif kerana ia tidak mengambil kira keadaan awal simulasi.

Sel kod berikut menunjukkan cara menggunakan primitif Sampler daripada Qiskit Aer untuk mengambil sampel daripada Circuit berbising. Kita perlu menambah pengukuran kepada Circuit sebelum menjalankannya dengan primitif Sampler.

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()

{'01100000': 2,
 '00000010': 3,
 '00000000': 58,
 '00110000': 1,
 '00100000': 2,
 '01000000': 5,
 '00010100': 2,
 '11110000': 1,
 '11000000': 3,
 '10000000': 3,
 '10101000': 1,
 '00111100': 1,
 '00101000': 1,
 '01010000': 3,
 '01111000': 2,
 '10000101': 1,
 '00000001': 2,
 '00000100': 2,
 '10100101': 1,
 '11100000': 1,
 '00011000': 2,
 '00001000': 1,
 '00001111': 1,
 '00000011': 1}

Langkah seterusnya

Cadangan

Untuk mensimulasikan Circuit kecil yang mudah, lihat Simulasi tepat dengan primitif Qiskit SDK.
Semak dokumentasi Qiskit Aer.

Langkah seterusnya​

Langkah seterusnya