Migrace na lokální simulátory

V kvantovém výpočetnictví je volba mezi simulátory a kvantovým hardwarem klíčová pro pokrok v oboru. Přestože jsou simulátory užitečné pro testování a ladění, v této éře kvantové užitečnosti vyžaduje kvantový vývoj a průmyslový pokrok skutečný hardware. V rámci přechodu ke kvantové užitečnosti byly cloudové simulátory IBM Quantum® vyřazeny z provozu 15. května 2024. Tento průvodce podrobněji vysvětluje toto vyřazení a popisuje, jak migrovat z cloudových simulátorů, jako je ibmq_qasm_simulator, na lokální simulátory.

Proč jsou cloudové simulátory vyřazovány z provozu?

Cloudové simulátory jsou vyřazovány z provozu z několika důvodů:

Simulátory mají omezení

Simulátory mohou být užitečné, ale jsou příliš omezené pro použití ve výzkumu nebo experimentování:

• Simulátory jsou cenné pro pochopení malých QPU (kvantových procesorových jednotek), ale jejich užitečnost se vyčerpá přibližně u 50 qubitů, a to i s přístupem k výkonným superpočítačům. Tato hranice plyne z exponenciálního nárůstu výpočetních zdrojů potřebných pro simulaci větších kvantových počítačů (podrobné vysvětlení najdeš v Massively parallel quantum computer simulator, eleven years later). Zkoumání kvantových počítačů se 100 a více qubity vyžaduje hardware.

• Některé simulátory sice nabízejí šumové modely, ale zachytit celou dynamiku reálného QPU je velmi obtížný problém. Kvantový hardware nabízí výzkumníkům možnost čelit výzvám kvantových počítačů, jako je šum, chyby a dekoherence, v realistickém testovacím prostředí.

Používání kvantového hardwaru buduje jedinečné dovednosti

Interakce s kvantovým hardwarem rozvíjí dovednosti a zkušenosti, které nelze získat pouze používáním simulátorů:

• Přímá interakce s kvantovým hardwarem rozvíjí dovednosti, protože musíš implementovat nebo používat techniky potlačování či zmírňování chyb pro spolehlivý výpočet.

• Praktická zkušenost s kvantovým hardwarem rozvíjí hlubší pochopení kvantových jevů a toho, jak přizpůsobit algoritmy charakteristikám kvantových procesorů.

• Práce s kvantovým hardwarem přináší praktické poznatky o výzvách a příležitostech kvantového výpočetnictví, čímž posiluje schopnost vývojářů prosazovat inovace v oboru.

Algoritmy by měly být přizpůsobeny kvantovému hardwaru

Úspěšné kvantové algoritmy musí být přizpůsobeny tak, aby využívaly možnosti kvantového hardwaru, a optimalizovaly tak výkon a efektivitu.

• Kvantový hardware poskytuje přesnější reprezentaci reálných QPU než simulátory.

• Doladění algoritmů pro kvantový hardware zahrnuje úpravy ansatzu, implementací Circuit, parametrů a konfigurace za účelem maximalizace výkonu. Nejlépe se to podaří přímým experimentováním s kvantovým hardwarem.

Kdy by se měly simulátory používat?

Kvantové simulátory by se měly používat k vývoji a testování programů, než je doladíš a odešleš na kvantový hardware. Lokální simulátory to zvládají s dobrým výkonem a efektivitou. Cliffordovy obvody lze simulovat velmi efektivně a výsledky lze ověřit, což je užitečný způsob, jak získat důvěru v experiment.

poznámka

Lokální testovací režim nemá vestavěné potlačování ani zmírňování chyb. Tyto možnosti musíš zadat explicitně. Podrobnosti najdeš v části Konfigurace zmírňování chyb.

Migrace na lokální simulátory

S qiskit-ibm-runtime 0.22.0 nebo novějším můžeš použít lokální testovací režim jako náhradu za cloudové simulátory. Podle svých potřeb můžeš lokální testovací režim využít několika způsoby. Začni tím, že zadáš jeden z falešných backendů v qiskit_ibm_runtime.fake_provider nebo zadáš Backend Qiskit Aer při vytváření instance primitivu nebo Session.

Pokyny pro výběr simulátoru

Při výběru simulátoru ti pomůže následující tabulka.

Simulátor	Falešné backendy	AerSimulator	Cliffordova simulace
Účel	Napodobuje konkrétní QPU IBM® pomocí snímků	Univerzální, vysoce výkonná simulace	Efektivní simulace pro Cliffordovy obvody
Šumový model	Automaticky aplikuje šumový model ze snímků QPU	Vlastní nebo na základě kalibračních dat reálného QPU	Ideální pro simulace bez šumu
Velikost Circuit	Omezena možnostmi napodobovaného QPU	Zvládá větší Circuit	Vhodné pro velmi velké Circuit (stovky qubitů)
Výsledky	Střední doba běhu pro testy specifické pro QPU	Kratší doba běhu pro širokou škálu simulací	Extrémně rychlé, vhodné pro stabilizátorové Circuit
Případ užití	Testování Transpiler a chování specifického pro QPU	Obecný vývoj, vlastní šumové modely	Velké stabilizátorové Circuit, korekce chyb

poznámka

Pro většinu uživatelů je AerSimulator dobrou volbou díky své flexibilitě a výkonu. Pokud však tvoje práce cílí na konkrétní QPU, falešný Backend může být lepší volbou.

Tyto simulátory běží na tvém vlastním počítači, takže ti nemohou říct, co by za skutečné QPU bylo účtováno ani zda služba job přijme. Chceš-li zjistit počet resource units (RU), které by job spotřeboval na skutečném QPU, spolu s validací na straně služby, spusť dry-run job bez spotřeby času QPU.

Falešné backendy

Falešné backendy napodobují chování QPU IBM pomocí snímků. Snímky 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í Transpiler a provádění simulací QPU se šumem. Šumový model ze snímku je během simulace aplikován automaticky.

Příklad:

from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit_ibm_runtime import QiskitRuntimeService

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

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

service = QiskitRuntimeService()

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

AerSimulator

Lokální testovací režim můžeš použít se simulátory z Qiskit Aer, které poskytují vysoce výkonnou simulaci schopnou zvládnout větší Circuit a vlastní šumové modely. Podporuje také režim Cliffordovy simulace, který dokáže efektivně simulovat Cliffordovy Circuit s velkým počtem qubitů.

Příklad se Session, bez šumu:

pozor

Následující blok kódu vrátí chybu pro uživatele na Open Plan, protože používá Session. Úlohy na Open Plan mohou běžet pouze v job mode nebo batch mode.

from qiskit_aer import AerSimulator
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import Session, QiskitRuntimeService

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

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

service = QiskitRuntimeService()

# 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()
    result = sampler.run([isa_qc]).result()

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

Příklad se šumem:

from qiskit_aer import AerSimulator
from qiskit.circuit.library import RealAmplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

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

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

service = QiskitRuntimeService()

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

# Specify a QPU to use for the noise model
real_backend = service.backend("ibm_brisbane")
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 části Efektivní simulace stabilizátorových Circuit s primitivy Qiskit Aer.

Příklad:

import numpy as np
from qiskit.circuit.library import EfficientSU2
from qiskit_ibm_runtime import QiskitRuntimeService

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

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

service = QiskitRuntimeService()

n_qubits = 500  # <---- note this uses 500 qubits!
circuit = EfficientSU2(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_circuit = pm.run(circuit)
sampler = Sampler(mode=aer_sim)
result = sampler.run([(isa_circuit, params)]).result()