Mod ujian tempatan

Versi pakej

Kod dalam halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan penggunaan versi ini atau lebih baru.

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

Gunakan mod ujian tempatan (tersedia dengan qiskit-ibm-runtime v0.22.0 atau lebih baru) untuk menguji program sebelum menala-halusnya dan menghantar ke perkakasan kuantum sebenar. Selepas menggunakan mod ujian tempatan untuk mengesahkan program anda, satu-satunya perubahan yang perlu anda lakukan ialah menukar nama backend untuk menjalankannya pada QPU.

nota

Sokongan mod tempatan untuk primitif Executor diperkenalkan dalam qiskit-ibm-runtime v0.50.0.

Untuk menggunakan mod ujian tempatan, tentukan salah satu backend palsu daripada qiskit_ibm_runtime.fake_provider atau tentukan backend Qiskit Aer semasa menginisialisasi primitif IBM Quantum® atau sesi.

• Backend palsu: Backend palsu dalam qiskit_ibm_runtime.fake_provider meniru tingkah laku QPU IBM® dengan menggunakan syot kilat QPU. Syot kilat QPU mengandungi maklumat penting tentang QPU, seperti peta gandingan, get asas, dan sifat qubit, yang berguna untuk menguji transpiler dan melakukan simulasi berbising bagi QPU. Model hingar daripada syot kilat digunakan secara automatik semasa simulasi.

• Simulator Aer: Simulator daripada Qiskit Aer menyediakan simulasi berprestasi lebih tinggi yang boleh mengendalikan litar yang lebih besar dan model hingar kustom. Senarai pilihan kaedah simulasi tersedia apabila anda menggunakan AerSimulator dalam mod ujian tempatan. Lihat contoh mod simulasi Clifford, yang menunjukkan cara mensimulasikan litar Clifford dengan bilangan qubit yang besar secara cekap.

  Senarai kaedah simulasi yang tersedia daripada Qiskit Aer

  Lihat dokumentasi AerSimulator untuk maklumat lanjut.

  • "automatic": Kaedah simulasi lalai. Pilih kaedah simulasi secara automatik, berdasarkan Circuit dan model hingar.

  • "statevector": Simulasi vektor keadaan padat yang boleh mengambil sampel hasil pengukuran daripada litar ideal dengan semua pengukuran di penghujung litar. Untuk simulasi berbising, setiap tembakan mengambil sampel litar berbising secara rawak daripada model hingar.

  • "density_matrix": Simulasi matriks ketumpatan yang boleh mengambil sampel hasil pengukuran daripada litar berbising dengan semua pengukuran di penghujung litar.

  • "stabilizer": Simulator keadaan penstabil Clifford yang cekap yang boleh mensimulasikan litar Clifford berbising jika semua ralat dalam model hingar juga merupakan ralat Clifford.

  • "extended_stabilizer": Simulator anggaran untuk Circuit Clifford + T berdasarkan penguraian keadaan kepada keadaan penstabil berperingkat. Bilangan sebutan bertambah dengan bilangan get bukan-Clifford (T).

  • "matrix_product_state": Simulator vektor keadaan rangkaian tensor yang menggunakan perwakilan Keadaan Hasil Darab Matriks (MPS) untuk keadaan. Ini boleh dilakukan dengan atau tanpa memotong dimensi ikatan MPS, bergantung pada pilihan simulator. Tingkah laku lalai adalah tanpa pemotongan.

  • "unitary": Simulasi matriks unitari padat bagi litar ideal. Ini mensimulasikan matriks unitari litar itu sendiri, bukan evolusi keadaan kuantum awal. Kaedah ini hanya boleh mensimulasikan get; ia tidak menyokong pengukuran, penetapan semula, atau hingar.

  • "superop": Simulasi matriks superoperator padat bagi litar ideal atau berbising. Ini mensimulasikan matriks superoperator litar itu sendiri, bukan evolusi keadaan kuantum awal. Kaedah ini boleh mensimulasikan get dan penetapan semula ideal dan berbising, tetapi tidak menyokong pengukuran.

  • "tensor_network": Simulasi berasaskan rangkaian tensor yang menyokong vektor keadaan dan matriks ketumpatan. Buat masa ini, kaedah ini hanya tersedia untuk GPU dan dipercepatkan dengan menggunakan API cuQuantum cuTensorNet.

Nota

• Anda boleh menentukan semua pilihan IBM Quantum Compute dalam mod ujian tempatan. Dengan Sampler dan Estimator sisi klien (diperkenalkan dalam qiskit-ibm-runtime v0.50.0), pilihan penindasan dan mitigasi ralat dilaksanakan secara tempatan, jadi anda boleh menguji pelbagai kaedah mitigasi ralat secara tempatan sebelum menggunakan masa QPU. Lihat Uji mitigasi ralat secara tempatan untuk contoh.

Sebelum ini, simulator tempatan mengabaikan semua pilihan kecuali shots dengan primitif legasi (sisi pelayan), kerana pemprosesan itu hanya berlaku pada pelayan.

• Adalah disyorkan untuk memasang Qiskit Aer sebelum menggunakan Backend palsu atau simulator Aer dengan menjalankan pip install qiskit-aer. Backend palsu menggunakan simulator Aer di sebalik tabir jika tersedia, untuk memanfaatkan prestasinya.

Contoh backend palsu

# 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-contoh AerSimulator

Contoh dengan sesi, tanpa hingar:

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 hingar, tentukan QPU (perkakasan kuantum) dan hantar ke Aer. Aer akan membina model hingar berdasarkan data penentukuran daripada QPU tersebut, dan menginisialisasi Backend Aer dengan model itu. Jika anda lebih suka, anda boleh membina model hingar.

awas

QPU boleh dipengaruhi oleh pelbagai jenis hingar. Model hingar Qiskit Aer yang digunakan di sini hanya mensimulasikan sebahagian daripadanya dan oleh itu kemungkinan kurang teruk berbanding hingar pada QPU sebenar.

Untuk butiran tentang ralat yang disertakan apabila menginisialisasi model hingar daripada QPU, lihat rujukan API Aer NoiseModel.

Contoh dengan hingar:

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

Oleh kerana litar Clifford boleh disimulasikan secara cekap dengan hasil yang boleh disahkan, simulasi Clifford adalah alat yang sangat berguna. Untuk contoh yang mendalam, lihat Simulasi cekap litar penstabil 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 ralat secara tempatan

Dengan Sampler dan Estimator sisi klien (diperkenalkan dalam qiskit-ibm-runtime v0.50.0), penindasan dan mitigasi ralat berlaku pada klien dan bukannya pada pelayan. Akibatnya, pilihan ini kini berkesan dalam mod ujian tempatan, jadi anda boleh mencuba pelbagai kaedah mitigasi ralat pada Backend palsu sebelum menggunakan masa QPU.

nota

Dengan primitif legasi sisi pelayan, menetapkan pilihan seperti resilience.measure_mitigation pada simulator tempatan tidak memberi kesan, kerana pemprosesan mitigasi hanya berjalan pada pelayan. Primitif sisi klien menerapkan pemprosesan itu secara tempatan.

Pertimbangan overhed memori dan masa jalan

Kos simulasi berbising tempatan bertambah secara eksponen dengan bilangan qubit, dan kebanyakan komputer riba tidak dapat mensimulasikan melebihi kira-kira 32 qubit. Oleh kerana kaedah penindasan dan mitigasi ralat kini berjalan secara tempatan, ia menambah overhed memori dan masa jalan lagi di atas simulasi asas. Untuk memastikan ujian tempatan boleh diurus, gunakan salah satu daripada yang berikut:

• Backend palsu yang kecil (seperti FakeManilaV2, yang digunakan di bawah).

• Simulator tanpa hingar.

• Simulasi Clifford, yang boleh diskalakan kepada bilangan qubit yang besar.

Contoh berikut menghidupkan mitigasi ralat pengukuran dengan Estimator dan menjalankannya pada Backend palsu. Pilihan measure_mitigation = True kini diterapkan pada litar anda secara tempatan.

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

Ujian setempat berbanding job dry-run

Mod ujian setempat berjalan pada mesin anda sendiri. Ia cara yang baik untuk membangunkan dan menyahpepijat atur cara serta melihat rupa output yang mungkin dihasilkan, tetapi ia tidak dapat memberitahu anda berapa yang akan dicaj oleh QPU sebenar atau sama ada perkhidmatan akan menerima job tersebut.

Tidak seperti ujian setempat, job dry-run menjalankan beban kerja anda melalui IBM Quantum Compute Service pada peranti mock tanpa menggunakan masa QPU, supaya anda dapat melihat bilangan unit sumber (RU) yang akan dikenakan oleh job tersebut pada QPU sebenar. Ia juga menyediakan pengesahan di pihak perkhidmatan dan jadual masa litar apabila diminta.

	Fake backend (ujian setempat)	Peranti mock (job dry-run)
Tempat ia berjalan	Secara setempat, pada mesin anda	Awan, pada IBM Quantum Compute Service
Akaun dan instans	Tidak diperlukan	Diperlukan (Flex, Premium, atau On-Prem)
Keputusan	Simulasi berhingar menggunakan model hingar snapshot	Data rawak dengan skema yang dijangka. Bukan simulasi
Penggunaan dilaporkan	Tiada	job.usage()
Pengesahan job	Terhad kepada apa yang disemak oleh klien	Dilakukan oleh Quantum Compute, sama seperti job sebenar

Aliran kerja biasa ialah mengulang litar dan keputusan dengan fake backend, kemudian menjalankan job dry-run sebagai semakan terakhir sebelum anda menjalankan pada QPU sebenar. Untuk perbandingan penuh, lihat Peranti mock berbanding fake backend.

Langkah seterusnya

Cadangan

• Gunakan kelas Neat untuk menganalisis kesan hingar pada beban kerja Estimator.
• Semak contoh-contoh Sampler yang terperinci.
• Semak contoh-contoh Estimator yang terperinci.
• Amalkan dengan primitif melalui pelajaran Fungsi kos dalam IBM Quantum Learning.
• Pelajari cara mentranspil secara tempatan dalam bahagian Transpil.
• Cuba tutorial Bandingkan tetapan Transpiler.