Lokální testovací režim

Verze balíčků

Kód na této stránce byl vyvinut s použitím následujících požadavků. Doporučujeme používat tyto nebo novější verze.

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

Používej lokální testovací režim (dostupný od qiskit-ibm-runtime v0.22.0 nebo novějšího) k testování programů před jejich doladěním a odesláním na skutečný kvantový hardware. Po ověření programu v lokálním testovacím režimu stačí pouze změnit název Backend, aby program běžel na QPU.

poznámka

Podpora lokálního režimu pro primitivum Executor byla zavedena v qiskit-ibm-runtime v0.50.0.

Chceš-li použít lokální testovací režim, zadej jeden z fake backendů z qiskit_ibm_runtime.fake_provider nebo zadej Backend Qiskit Aer při vytváření instance primitivu IBM Quantum® nebo Session.

• Fake backends: Fake backends v qiskit_ibm_runtime.fake_provider napodobují chování IBM® QPU pomocí snímků QPU. Snímky QPU obsahují důležité informace o QPU, jako je mapa propojení, základní Gate a vlastnosti Qubitů, které jsou užitečné pro testování Transpileru a provádění simulací QPU s šumem. Model šumu ze snímku je během simulace aplikován automaticky.

• Simulátor Aer: Simulátory z Qiskit Aer poskytují výkonnější simulaci, která zvládne větší Circuit a vlastní modely šumu. Při použití AerSimulator v lokálním testovacím režimu jsou k dispozici různé možnosti metod simulace. Viz příklad simulačního režimu Clifford, který ukazuje, jak efektivně simulovat Cliffordovy Circuit s velkým počtem Qubitů.

  Seznam simulačních metod dostupných v Qiskit Aer

  Více informací najdeš v dokumentaci AerSimulator.

  • "automatic": Výchozí simulační metoda. Simulační metoda se vybírá automaticky na základě Circuit a modelu šumu.

  • "statevector": Hustá simulace stavového vektoru, která může vzorkovat výsledky měření z ideálních Circuit s veškerými měřeními na konci Circuit. Pro simulace se šumem se v každém shotu vzorkuje náhodně vybraný zašuměný Circuit z modelu šumu.

  • "density_matrix": Simulace matice hustoty, která může vzorkovat výsledky měření ze zašuměných Circuit s veškerými měřeními na konci Circuit.

  • "stabilizer": Efektivní simulátor Cliffordova stabilizátorového stavu, který dokáže simulovat zašuměné Cliffordovy Circuit, pokud jsou všechny chyby v modelu šumu také Cliffordovy chyby.

  • "extended_stabilizer": Přibližný simulátor pro Clifford + T Circuit založený na rozkladu stavu na kombinaci stabilizátorových stavů (s danou hodností rozkladu). Počet členů roste s počtem non-Cliffordových (T) Gate.

  • "matrix_product_state": Simulátor stavového vektoru založený na tenzorových sítích, který stav reprezentuje jako maticový součinový stav (MPS). Lze to provádět s oříznutím nebo bez oříznutí dimenzí vazby MPS v závislosti na nastavení simulátoru. Výchozí chování je bez oříznutí.

  • "unitary": Hustá simulace unitární matice ideálního Circuit. Tato metoda simuluje unitární matici samotného Circuit, nikoli vývoj počátečního kvantového stavu. Tato metoda dokáže simulovat pouze Gate; nepodporuje měření, reset ani šum.

  • "superop": Hustá simulace matice superoperátoru ideálního nebo zašuměného Circuit. Tato metoda simuluje matici superoperátoru samotného Circuit, nikoli vývoj počátečního kvantového stavu. Tato metoda dokáže simulovat ideální i zašuměné Gate a resety, ale nepodporuje měření.

  • "tensor_network": Simulace na bázi tenzorové sítě, která podporuje jak stavový vektor, tak matici hustoty. V současnosti je k dispozici pouze pro GPU a je akcelerována pomocí API cuQuantum cuTensorNet.

Poznámky

• V lokálním testovacím režimu můžeš zadat všechny možnosti IBM Quantum Compute. S klientskými primitivy Sampler a Estimator (zavedenými v qiskit-ibm-runtime v0.50.0) jsou možnosti potlačení a zmírnění chyb implementovány lokálně, takže můžeš různé metody zmírnění chyb otestovat lokálně, než vyčerpáš čas na QPU. Příklad najdeš v části Lokální test zmírnění chyb.

Dříve lokální simulátory u starších (serverových) primitiv ignorovaly všechny možnosti kromě shots, protože toto zpracování probíhalo pouze na serveru.

• Před použitím fake backends nebo simulátorů Aer se doporučuje nainstalovat Qiskit Aer spuštěním pip install qiskit-aer. Fake backends pod kapotou používají simulátory Aer, pokud jsou dostupné, aby využily jejich výkon.

Příklad s fake backends

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

Příklady s AerSimulator

Příklad se Session, bez šumu:

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

Chceš-li simulovat se šumem, zadej QPU (kvantový hardware) a odešli ho do Aer. Aer sestaví model šumu na základě kalibračních dat z tohoto QPU a vytvoří instanci Aer Backend s tímto modelem. Pokud chceš, můžeš si sestavit vlastní model šumu.

pozor

Na QPU může působit různé druhy šumu. Model šumu Qiskit Aer použitý zde simuluje pouze část z nich, a proto bude pravděpodobně méně závažný než šum na skutečném QPU.

Podrobnosti o tom, jaké chyby jsou zahrnuty při inicializaci modelu šumu z QPU, najdeš v referenci API Aer NoiseModel.

Příklad se šumem:

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

Cliffordova simulace

Protože Cliffordovy Circuit lze efektivně simulovat s ověřitelnými výsledky, je Cliffordova simulace velmi užitečným nástrojem. Podrobný příklad najdeš v Efektivní simulace stabilizátorových Circuit s primitivy Qiskit Aer.

Příklad:

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

Lokální test zmírnění chyb

S klientskými primitivy Sampler a Estimator (zavedenými v qiskit-ibm-runtime v0.50.0) probíhá potlačení a zmírnění chyb na klientovi, nikoli na serveru. Díky tomu se tyto možnosti nyní uplatní i v lokálním testovacím režimu, takže můžeš experimentovat s různými metodami zmírnění chyb na fake backendu, než začneš využívat čas na QPU.

poznámka

U starších serverových primitiv nemělo nastavení možnosti jako resilience.measure_mitigation na lokálním simulátoru žádný účinek, protože zpracování zmírnění běželo pouze na serveru. Klientská primitiva toto zpracování aplikují lokálně.

Úvahy o paměťové a časové režii

Náklady lokální zašuměné simulace rostou exponenciálně s počtem qubitů a většina notebooků nedokáže simulovat více než zhruba 32 qubitů. Protože se potlačení a zmírnění chyb nyní spouští lokálně, přidávají další paměťovou a časovou režii nad rámec základní simulace. Aby bylo lokální testování zvládnutelné, použij jednu z následujících možností:

• Malý fake backend (například FakeManilaV2, použitý níže).

• Simulátor bez šumu.

• Cliffordova simulace, která se škáluje na velký počet qubitů.

Následující příklad zapíná zmírnění chyb měření pomocí Estimator a spouští ho na fake backendu. Možnost measure_mitigation = True se nyní na tvé obvody aplikuje lokálně.

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

Lokální testování ve srovnání s dry-run joby

Režim lokálního testování běží na tvém vlastním počítači. Je to dobrý způsob, jak vyvíjet a ladit program a vidět, jak může výstup vypadat, ale neřekne ti, co by za skutečné QPU bylo účtováno ani zda služba job přijme.

Na rozdíl od lokálního testování dry-run job provede tvou úlohu přes IBM Quantum Compute Service na mock zařízení bez spotřeby jakéhokoli času QPU, takže můžeš vidět počet resource units (RU), které by job spotřeboval na skutečném QPU. Na požádání také poskytuje validaci na straně služby a časový plán Circuit.

	Fake Backend (lokální testování)	Mock zařízení (dry-run job)
Kde běží	Lokálně, na tvém počítači	V cloudu, na IBM Quantum Compute Service
Účet a instance	Nejsou vyžadovány	Vyžadovány (Flex, Premium nebo On-Prem)
Výsledky	Zašuměná simulace pomocí snímku modelu šumu	Náhodná data s očekávaným schématem. Nejde o simulaci
Hlášené využití	Žádné	job.usage()
Validace jobu	Omezena na to, co kontroluje klient	Provádí Quantum Compute, stejně jako u skutečného jobu

Běžný postup je iterovat nad Circuit a výsledky s fake Backend a poté spustit dry-run job jako poslední kontrolu před spuštěním na skutečném QPU. Úplné srovnání najdeš v části Mock zařízení ve srovnání s fake Backend.

Další kroky

Doporučení

• Použij třídu Neat k analýze dopadu šumu na pracovní zátěž Estimatoru.
• Prostuduj si podrobné příklady Sampleru.
• Prostuduj si podrobné příklady Estimatoru.
• Procvič si primitivy v lekci Funkce nákladů v IBM Quantum Learning.
• Nauč se transpilovat lokálně v sekci Transpilace.
• Vyzkoušej tutoriál Porovnání nastavení Transpileru.