Lokal na testing mode

Package versions

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na requirements. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago pa.

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

Gamitin ang lokal na testing mode (available sa qiskit-ibm-runtime v0.22.0 o mas bago) para subukan ang mga programa bago i-fine-tune at ipadala sa tunay na quantum hardware. Pagkatapos gamitin ang lokal na testing mode para i-verify ang iyong programa, ang kailangan mo lang baguhin ay ang pangalan ng backend para patakbuhin ito sa isang QPU.

tala

Ipinakilala ang suporta sa local mode para sa Executor primitive sa qiskit-ibm-runtime v0.50.0.

Para gamitin ang lokal na testing mode, tukuyin ang isa sa mga fake backend mula sa qiskit_ibm_runtime.fake_provider o tukuyin ang isang Qiskit Aer backend kapag nag-instantiate ng IBM Quantum® primitive o session.

• Mga fake backend: Ang mga fake backend sa qiskit_ibm_runtime.fake_provider ay ginagaya ang mga gawi ng IBM® QPU sa pamamagitan ng paggamit ng mga QPU snapshot. Ang mga QPU snapshot ay naglalaman ng mahahalagang impormasyon tungkol sa QPU, tulad ng coupling map, basis gates, at mga katangian ng qubit, na kapaki-pakinabang sa pagsubok ng transpiler at pagsasagawa ng maingay na simulation ng QPU. Ang noise model mula sa snapshot ay awtomatikong inilalapat sa panahon ng simulation.

• Aer simulator: Ang mga simulator mula sa Qiskit Aer ay nagbibigay ng mas mataas na performance na simulation na kayang hawakan ang mas malalaking circuit at custom na noise model. Makikita ang listahan ng mga opsyon sa simulation method kapag ginamit mo ang AerSimulator sa lokal na testing mode. Tingnan ang halimbawa ng Clifford simulation mode, na nagpapakita kung paano mahusay na mag-simulate ng mga Clifford circuit na may malaking bilang ng qubit.

  Listahan ng mga paraan ng simulation na available mula sa Qiskit Aer

  Tingnan ang dokumentasyon ng AerSimulator para sa karagdagang impormasyon.

  • "automatic": Default na simulation method. Awtomatikong pinipili ang simulation method batay sa circuit at noise model.

  • "statevector": Isang masinsinang statevector simulation na kayang mag-sample ng mga resulta ng pagsukat mula sa mga ideal na circuit na may lahat ng pagsukat sa dulo ng circuit. Para sa maingay na simulation, bawat shot ay nag-sa-sample ng random na maingay na circuit mula sa noise model.

  • "density_matrix": Isang density matrix simulation na kayang mag-sample ng mga resulta ng pagsukat mula sa mga maingay na circuit na may lahat ng pagsukat sa dulo ng circuit.

  • "stabilizer": Isang mahusay na Clifford stabilizer state simulator na kayang mag-simulate ng maingay na Clifford circuit kung lahat ng error sa noise model ay Clifford error din.

  • "extended_stabilizer": Isang approximate simulator para sa mga Clifford + T circuit batay sa pag-decompose ng state sa isang ranked-stabilizer state. Lumalaki ang bilang ng termino habang dumarami ang mga non-Clifford (T) gate.

  • "matrix_product_state": Isang tensor-network statevector simulator na gumagamit ng Matrix Product State (MPS) na representasyon para sa state. Magagawa ito nang may o walang pag-truncate ng MPS bond dimensions, depende sa mga opsyon ng simulator. Ang default na gawi ay walang truncation.

  • "unitary": Isang masinsinang unitary matrix simulation ng isang ideal na circuit. Sine-simulate nito ang unitary matrix ng circuit mismo, sa halip na ang ebolusyon ng isang paunang quantum state. Ang method na ito ay kayang mag-simulate lamang ng mga gate; hindi ito sumusuporta sa pagsukat, reset, o noise.

  • "superop": Isang masinsinang superoperator matrix simulation ng isang ideal o maingay na circuit. Sine-simulate nito ang superoperator matrix ng circuit mismo, sa halip na ang ebolusyon ng isang paunang quantum state. Ang method na ito ay kayang mag-simulate ng ideal at maingay na gate at reset, ngunit hindi ito sumusuporta sa mga pagsukat.

  • "tensor_network": Isang tensor-network-based simulation na sumusuporta sa parehong statevector at density matrix. Sa kasalukuyan, available lamang ito para sa GPU at pinabilis gamit ang cuQuantum cuTensorNet API.

Mga Tala

• Maaari mong tukuyin ang lahat ng opsyon ng IBM Quantum Compute sa lokal na testing mode. Sa client-side na Sampler at Estimator (ipinakilala sa qiskit-ibm-runtime v0.50.0), lokal na ini-implement ang mga opsyon sa error suppression at mitigation, kaya maaari mong subukan nang lokal ang iba't ibang paraan ng error mitigation bago gumamit ng oras ng QPU. Tingnan ang Test error mitigation locally para sa halimbawa.

Dati, binabalewala ng mga lokal na simulator ang lahat ng opsyon maliban sa shots sa mga legacy (server-side) na primitive, dahil sa server lamang nangyayari ang prosesong iyon.

• Inirerekomenda na i-install mo ang Qiskit Aer bago gamitin ang mga fake backend o Aer simulator sa pamamagitan ng pagpapatakbo ng pip install qiskit-aer. Ang mga fake backend ay gumagamit ng mga Aer simulator sa likod ng eksena kung available, para mapakinabangan ang kanilang performance.

Halimbawa ng mga 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()

Mga halimbawa ng AerSimulator

Halimbawa na may mga session, walang 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()

Para mag-simulate na may noise, tukuyin ang isang QPU (quantum hardware) at isumite ito sa Aer. Nagtatayo ang Aer ng noise model batay sa calibration data mula sa QPU na iyon, at nag-i-instantiate ng Aer backend na may modelong iyon. Kung gusto mo, maaari kang gumawa ng noise model.

babala

Ang isang QPU ay maaaring maapektuhan ng iba't ibang uri ng noise. Ang Qiskit Aer noise model na ginagamit dito ay nag-si-simulate lamang ng ilan sa mga ito at samakatuwid ay malamang na hindi kasing grabe ng noise sa isang tunay na QPU.

Para sa mga detalye kung aling mga error ang kasama kapag nagsi-initialize ng noise model mula sa isang QPU, tingnan ang Aer NoiseModel API reference.

Halimbawa na may 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()

Simulation ng Clifford

Dahil ang mga Clifford circuit ay maaaring mahusay na ma-simulate na may mga nabeberipikang resulta, ang Clifford simulation ay isang napaka-kapaki-pakinabang na kasangkapan. Para sa isang malalim na halimbawa, tingnan ang Mahusay na simulation ng mga stabilizer circuit gamit ang mga Qiskit Aer primitive.

Halimbawa:

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

Subukan nang lokal ang error mitigation

Sa client-side na Sampler at Estimator (ipinakilala sa qiskit-ibm-runtime v0.50.0), nangyayari ang error suppression at mitigation sa client sa halip na sa server. Dahil dito, may epekto na ang mga opsyong ito sa lokal na testing mode, kaya maaari kang mag-eksperimento sa iba't ibang paraan ng error mitigation sa isang fake backend bago gumamit ng oras ng QPU.

tala

Sa mga legacy na server-side primitive, walang epekto ang pagtatakda ng opsyon tulad ng resilience.measure_mitigation sa isang lokal na simulator, dahil sa server lamang tumatakbo ang mitigation processing. Lokal na inilalapat ng mga client-side na primitive ang prosesong iyon.

Mga konsiderasyon sa memory at runtime overhead

Ang gastos ng lokal na maingay na simulation ay lumalaki nang exponential kasabay ng bilang ng qubit, at karamihan ng laptop ay hindi kayang mag-simulate nang lampas sa humigit-kumulang 32 qubit. Dahil lokal nang tumatakbo ang mga paraan ng error suppression at mitigation, nagdaragdag ang mga ito ng karagdagang memory at runtime overhead bukod sa base na simulation. Para manatiling kayang gawin ang lokal na testing, gumamit ng isa sa mga sumusunod:

• Isang maliit na fake backend (tulad ng FakeManilaV2, na ginamit sa ibaba).

• Isang noiseless na simulator.

• Clifford simulation, na nag-i-scale sa malaking bilang ng qubit.

Binubuksan ng sumusunod na halimbawa ang measurement error mitigation gamit ang Estimator at pinapatakbo ito sa isang fake backend. Lokal na inilalapat na ngayon sa iyong mga circuit ang opsyong measure_mitigation = True.

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

Mga susunod na hakbang

Mga Rekomendasyon

• Gamitin ang klase ng Neat para suriin ang epekto ng noise sa isang Estimator workload.
• Suriin ang mga detalyadong halimbawa ng Sampler.
• Suriin ang mga detalyadong halimbawa ng Estimator.
• Mag-practice gamit ang mga primitive sa pamamagitan ng pagtatapos ng aralin sa Cost function sa IBM Quantum Learning.
• Alamin kung paano mag-transpile nang lokal sa seksyong Transpile.
• Subukan ang tutorial na Ihambing ang mga setting ng transpiler.