Mode pengujian lokal

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami menyarankan untuk menggunakan versi ini atau yang lebih baru.

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0
qiskit-aer~=0.17

Gunakan mode pengujian lokal (tersedia dengan qiskit-ibm-runtime v0.22.0 atau lebih baru) untuk menguji program sebelum menyempurnakannya dan mengirimkannya ke perangkat keras kuantum sungguhan. Setelah menggunakan mode pengujian lokal untuk memverifikasi programmu, satu-satunya yang perlu diubah adalah nama Backend untuk menjalankannya di QPU.

catatan

Dukungan mode lokal untuk primitif Executor diperkenalkan di qiskit-ibm-runtime v0.50.0.

Untuk menggunakan mode pengujian lokal, tentukan salah satu fake backend dari qiskit_ibm_runtime.fake_provider atau tentukan Backend Qiskit Aer saat membuat instance primitif IBM Quantum® atau sebuah Session.

• Fake backend: Fake backend di qiskit_ibm_runtime.fake_provider meniru perilaku QPU IBM® dengan menggunakan snapshot QPU. Snapshot QPU berisi informasi penting tentang QPU, seperti coupling map, basis Gate, dan properti qubit, yang berguna untuk menguji Transpiler dan melakukan simulasi dengan noise dari QPU. Model noise dari snapshot diterapkan secara otomatis selama simulasi.

• Simulator Aer: Simulator dari Qiskit Aer memberikan simulasi berkinerja lebih tinggi yang dapat menangani Circuit yang lebih besar dan model noise kustom. Daftar opsi metode simulasi tersedia saat kamu menggunakan AerSimulator dalam mode pengujian lokal. Lihat contoh mode simulasi Clifford, yang mendemonstrasikan cara mensimulasikan Circuit Clifford dengan jumlah qubit yang besar secara efisien.

  Daftar metode simulasi yang tersedia dari Qiskit Aer

  Lihat dokumentasi AerSimulator untuk informasi lebih lanjut.

  • "automatic": Metode simulasi default. Memilih metode simulasi secara otomatis, berdasarkan Circuit dan model noise.

  • "statevector": Simulasi statevector padat yang dapat mengambil sampel hasil pengukuran dari Circuit ideal dengan semua pengukuran di akhir Circuit. Untuk simulasi berderau, setiap shot mengambil sampel Circuit berderau secara acak dari model noise.

  • "density_matrix": Simulasi matriks densitas yang dapat mengambil sampel hasil pengukuran dari Circuit berderau dengan semua pengukuran di akhir Circuit.

  • "stabilizer": Simulator state stabilizer Clifford yang efisien yang dapat mensimulasikan Circuit Clifford berderau jika semua error dalam model noise juga merupakan error Clifford.

  • "extended_stabilizer": Simulator aproksimatif untuk Circuit Clifford + T berdasarkan dekomposisi state menjadi ranked-stabilizer state. Jumlah term bertambah seiring dengan jumlah Gate non-Clifford (T).

  • "matrix_product_state": Simulator statevector berbasis tensor-network yang menggunakan representasi Matrix Product State (MPS) untuk state. Ini dapat dilakukan dengan atau tanpa memotong dimensi bond MPS, tergantung pada opsi simulator. Perilaku default adalah tanpa pemotongan.

  • "unitary": Simulasi matriks uniter padat dari Circuit ideal. Ini mensimulasikan matriks uniter dari Circuit itu sendiri, bukan evolusi dari state kuantum awal. Metode ini hanya dapat mensimulasikan Gate; tidak mendukung pengukuran, reset, atau noise.

  • "superop": Simulasi matriks superoperator padat dari Circuit ideal atau berderau. Ini mensimulasikan matriks superoperator dari Circuit itu sendiri, bukan evolusi dari state kuantum awal. Metode ini dapat mensimulasikan Gate dan reset ideal maupun berderau, tetapi tidak mendukung pengukuran.

  • "tensor_network": Simulasi berbasis tensor-network yang mendukung statevector dan matriks densitas. Saat ini hanya tersedia untuk GPU dan dipercepat menggunakan API cuQuantum cuTensorNet.

Catatan

• Kamu bisa menentukan semua opsi IBM Quantum Compute dalam mode pengujian lokal. Dengan Sampler dan Estimator sisi klien (diperkenalkan di qiskit-ibm-runtime v0.50.0), opsi penekanan dan mitigasi error diimplementasikan secara lokal, jadi kamu bisa menguji berbagai metode mitigasi error secara lokal sebelum memakai waktu QPU. Lihat Uji mitigasi error secara lokal untuk contohnya.

Sebelumnya, simulator lokal mengabaikan semua opsi kecuali shots pada primitif lama (sisi server), karena pemrosesan itu hanya terjadi di server.

• Disarankan untuk menginstal Qiskit Aer sebelum menggunakan fake backend atau simulator Aer dengan menjalankan pip install qiskit-aer. Fake backend menggunakan simulator Aer di balik layar jika tersedia, untuk memanfaatkan kinerjanya.

Contoh fake backend

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

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_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 import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using FakeManilaV2
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)

# You can use a fixed seed to get fixed results.
options = {"simulator": {"seed_simulator": 42}}
sampler = Sampler(mode=fake_manila, options=options)

result = sampler.run([isa_qc]).result()

Contoh AerSimulator

Contoh dengan Session, tanpa noise:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import Session

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using AerSimulator.
# Session syntax is supported but ignored because local mode doesn't support sessions.
aer_sim = AerSimulator()
pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
with Session(backend=aer_sim) as session:
    sampler = Sampler(mode=session)
    result = sampler.run([isa_qc]).result()

Untuk mensimulasikan dengan noise, tentukan QPU (perangkat keras kuantum) dan kirimkan ke Aer. Aer membangun model noise berdasarkan data kalibrasi dari QPU tersebut, dan membuat instance Backend Aer dengan model itu. Jika kamu mau, kamu bisa membangun model noise sendiri.

perhatian

QPU dapat dipengaruhi oleh berbagai jenis noise. Model noise Qiskit Aer yang digunakan di sini hanya mensimulasikan sebagian dari noise tersebut dan oleh karena itu kemungkinan besar tidak separah noise pada QPU sungguhan.

Untuk detail tentang error apa saja yang disertakan saat menginisialisasi model noise dari QPU, lihat referensi API Aer NoiseModel.

Contoh dengan noise:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

service = QiskitRuntimeService()

# Specify a QPU to use for the noise model
real_backend = service.least_busy(operational=True, simulator=False)
aer = AerSimulator.from_backend(real_backend)

# Run the Sampler job locally using AerSimulator.
pm = generate_preset_pass_manager(backend=aer, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer)
result = sampler.run([isa_qc]).result()

Simulasi Clifford

Karena Circuit Clifford dapat disimulasikan secara efisien dengan hasil yang dapat diverifikasi, simulasi Clifford adalah alat yang sangat berguna. Untuk contoh yang lebih mendalam, lihat Simulasi efisien Circuit stabilizer dengan primitif Qiskit Aer.

Contoh:

import numpy as np
from qiskit.circuit.library import efficient_su2

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

n_qubits = 500  # <---- note this uses 500 qubits!
circuit = efficient_su2(n_qubits)
circuit.measure_all()

rng = np.random.default_rng(1234)
params = rng.choice(
    [0, np.pi / 2, np.pi, 3 * np.pi / 2],
    size=circuit.num_parameters,
)

# Tell Aer to use the stabilizer (Clifford) simulation method
aer_sim = AerSimulator(method="stabilizer")

pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer_sim)
result = sampler.run([isa_qc]).result()

Uji mitigasi error secara lokal

Dengan Sampler dan Estimator sisi klien (diperkenalkan di qiskit-ibm-runtime v0.50.0), penekanan dan mitigasi error terjadi di klien, bukan di server. Akibatnya, opsi-opsi ini sekarang berlaku dalam mode pengujian lokal, jadi kamu bisa bereksperimen dengan berbagai metode mitigasi error di fake backend sebelum memakai waktu QPU.

catatan

Dengan primitif lama sisi server, mengatur opsi seperti resilience.measure_mitigation pada simulator lokal tidak berpengaruh, karena pemrosesan mitigasi hanya berjalan di server. Primitif sisi klien menerapkan pemrosesan itu secara lokal.

Pertimbangan overhead memori dan runtime

Biaya simulasi berderau lokal tumbuh secara eksponensial terhadap jumlah qubit, dan sebagian besar laptop tidak bisa mensimulasikan lebih dari sekitar 32 qubit. Karena metode penekanan dan mitigasi error sekarang berjalan secara lokal, metode ini menambah overhead memori dan runtime di atas simulasi dasar. Agar pengujian lokal tetap terkelola, gunakan salah satu dari berikut:

• Fake backend kecil (seperti FakeManilaV2, yang dipakai di bawah).

• Simulator tanpa noise.

• Simulasi Clifford, yang bisa diskalakan ke jumlah qubit yang besar.

Contoh berikut mengaktifkan mitigasi error pengukuran dengan Estimator dan menjalankannya di fake backend. Opsi measure_mitigation = True sekarang diterapkan ke Circuit kamu secara lokal.

from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager

# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

observable = SparsePauliOp("ZZ")

# Transpile the circuit and observable for the fake backend
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)
isa_observable = observable.apply_layout(isa_qc.layout)

# Run the Estimator job locally using FakeManilaV2
estimator = Estimator(mode=fake_manila)

# With the client-side Estimator, this option takes effect locally
estimator.options.resilience.measure_mitigation = True

result = estimator.run([(isa_qc, isa_observable)]).result()

Pengujian lokal dibandingkan dengan dry-run job

Mode pengujian lokal berjalan di mesinmu sendiri. Ini cara yang bagus untuk mengembangkan dan men-debug program serta melihat seperti apa kira-kira outputnya, tetapi tidak bisa memberi tahu berapa biaya yang akan dikenakan QPU sungguhan atau apakah layanan akan menerima job tersebut.

Berbeda dengan pengujian lokal, sebuah dry-run job menjalankan workload-mu lewat IBM Quantum Compute Service pada sebuah mock device tanpa menggunakan waktu QPU, sehingga kamu bisa melihat jumlah resource unit (RU) yang akan dikenakan job tersebut di QPU sungguhan. Ia juga menyediakan validasi di sisi layanan dan jadwal waktu circuit jika diminta.

	Fake backend (pengujian lokal)	Mock device (dry-run job)
Tempat berjalan	Lokal, di mesinmu	Cloud, di IBM Quantum Compute Service
Akun dan instance	Tidak diperlukan	Diperlukan (Flex, Premium, atau On-Prem)
Hasil	Simulasi noisy dengan snapshot model noise	Data acak dengan skema yang diharapkan. Bukan simulasi
Penggunaan dilaporkan	Tidak ada	job.usage()
Validasi job	Terbatas pada yang diperiksa client	Dilakukan oleh Quantum Compute, sama seperti job sungguhan

Alur kerja yang umum adalah beriterasi pada circuit dan hasil dengan fake backend, lalu menjalankan dry-run job sebagai pemeriksaan terakhir sebelum menjalankan di QPU sungguhan. Untuk perbandingan lengkap, lihat Mock device dibandingkan dengan fake backend.

Langkah berikutnya

Rekomendasi

• Gunakan kelas Neat untuk menganalisis dampak noise pada beban kerja Estimator.
• Tinjau contoh Sampler secara detail.
• Tinjau contoh Estimator secara detail.
• Berlatih dengan primitif melalui pelajaran fungsi biaya di IBM Quantum Learning.
• Pelajari cara melakukan transpilasi secara lokal di bagian Transpile.
• Coba tutorial Bandingkan pengaturan Transpiler.