Migracja z symulatorów chmurowych do lokalnych symulatorów

W obliczeniach kwantowych wybór między symulatorami a sprzętem kwantowym ma kluczowe znaczenie dla postępu w tej dziedzinie. Choć symulatory są przydatne do testowania i debugowania, w obecnej erze użyteczności kwantowej rozwój kwantowy i postęp branży wymagają rzeczywistego sprzętu. W ramach przejścia do użyteczności kwantowej symulatory chmurowe IBM Quantum® zostały wycofane 15 maja 2024 roku. Ten przewodnik szczegółowo wyjaśnia to wycofanie oraz sposób migracji z symulatorów chmurowych, takich jak ibmq_qasm_simulator, do symulatorów lokalnych.

Dlaczego symulatory chmurowe są wycofywane?

Symulatory chmurowe są wycofywane z kilku powodów:

Symulatory mają ograniczenia

Symulatory mogą być przydatne, ale są zbyt ograniczone, aby używać ich do badań lub eksperymentów:

• Symulatory są wartościowe do zrozumienia małoskalowych QPU (jednostek przetwarzania kwantowego), jednak ich użyteczność wyczerpuje się przy około 50 Qubitach, nawet przy dostępie do wydajnych superkomputerów. To ograniczenie wynika z wykładniczego wzrostu zasobów obliczeniowych wymaganych do symulowania większych komputerów kwantowych (przeczytaj Massively parallel quantum computer simulator, eleven years later, aby poznać pełne wyjaśnienie). Eksploracja komputerów kwantowych o 100 Qubitach i więcej wymaga sprzętu.

• Choć niektóre symulatory oferują modele szumów, bardzo trudno jest uchwycić całą dynamikę prawdziwego QPU. Sprzęt kwantowy daje badaczom możliwość mierzenia się z wyzwaniami nieodłącznie związanymi z komputerami kwantowymi, takimi jak szum, błędy i dekoherencja, w realistycznym środowisku testowym.

Korzystanie ze sprzętu kwantowego buduje unikalne umiejętności

Praca ze sprzętem kwantowym rozwija umiejętności i doświadczenie nieosiągalne wyłącznie przez korzystanie z symulatorów:

• Bezpośrednia interakcja ze sprzętem kwantowym buduje umiejętności, ponieważ musisz implementować lub stosować techniki łagodzenia lub tłumienia błędów dla zapewnienia niezawodnych obliczeń.

• Praktyczne doświadczenie ze sprzętem kwantowym rozwija głębsze zrozumienie zjawisk kwantowych i sposobu dostosowywania algorytmów do charakterystyki procesorów kwantowych.

• Praca ze sprzętem kwantowym dostarcza praktycznych spostrzeżeń na temat wyzwań i możliwości obliczeń kwantowych, zwiększając zdolność deweloperów do napędzania innowacji w tej dziedzinie.

Algorytmy powinny być dostosowane do sprzętu kwantowego

Skuteczne algorytmy kwantowe muszą być dostosowane tak, aby wykorzystywać możliwości sprzętu kwantowego, optymalizując wydajność i efektywność.

• Sprzęt kwantowy zapewnia dokładniejsze odwzorowanie rzeczywistych QPU niż symulatory.

• Dostrajanie algorytmów pod sprzęt kwantowy polega na dostosowaniu ansatz, implementacji Circuit, parametrów i konfiguracji w celu maksymalizacji wydajności. Proces ten najlepiej osiąga się przez bezpośrednie eksperymenty ze sprzętem kwantowym.

Kiedy należy używać symulatorów?

Symulatory kwantowe powinny być używane do pomocy w tworzeniu i testowaniu programów przed ich dostrojeniem i wysłaniem na sprzęt kwantowy. Lokalne symulatory mogą to robić z dobrą wydajnością i efektywnością. Obwody Clifforda mogą być symulowane bardzo wydajnie, a wyniki mogą być weryfikowane, co jest użytecznym sposobem na zdobycie pewności co do eksperymentu.

uwaga

Lokalny tryb testowania nie ma wbudowanego tłumienia ani łagodzenia błędów. Zamiast tego musisz określić te opcje jawnie. Szczegóły znajdziesz w Configure error mitigation for Qiskit Runtime.

Migracja do lokalnych symulatorów

W qiskit-ibm-runtime w wersji 0.22.0 lub nowszej możesz używać lokalnego trybu testowania zamiast symulatorów chmurowych. W zależności od potrzeb istnieje kilka sposobów korzystania z lokalnego trybu testowania. Na początek określ jeden z fałszywych Backend'ów z qiskit_ibm_runtime.fake_provider lub wskaż Backend Qiskit Aer podczas tworzenia instancji prymitywu lub Session.

Wskazówki dotyczące wyboru symulatora

Skorzystaj z poniższej tabeli, aby wybrać odpowiedni symulator.

Symulator	Fałszywe Backend'y	AerSimulator	Symulacja Clifforda
Przeznaczenie	Naśladuje konkretne QPU IBM® za pomocą migawek	Ogólna, wydajna symulacja	Wydajna symulacja dla Circuit Clifforda
Model szumów	Automatycznie stosuje model szumów z migawek QPU	Niestandardowy lub oparty na danych kalibracyjnych rzeczywistego QPU	Idealny do symulacji bez szumów
Rozmiar Circuit	Ograniczony do możliwości naśladowanego QPU	Obsługuje większe Circuit	Odpowiedni dla bardzo dużych Circuit (setki Qubitów)
Wyniki	Umiarkowany czas działania dla testów specyficznych dla QPU	Krótszy czas działania dla szerokiego zakresu symulacji	Bardzo szybki, odpowiedni dla Circuit stabilizatorowych
Przypadek użycia	Testowanie Transpilatora i zachowania specyficznego dla QPU	Ogólny rozwój, niestandardowe modele szumów	Duże Circuit stabilizatorowe, korekcja błędów

uwaga

Dla większości użytkowników AerSimulator jest dobrym wyborem ze względu na elastyczność i wydajność. Jednak jeśli twoja praca jest ukierunkowana na konkretny QPU, fałszywy Backend może być lepszym wyborem.

Fałszywe Backend'y

Fałszywe Backend'y naśladują zachowania QPU IBM za pomocą migawek. Migawki zawierają ważne informacje o QPU, takie jak mapa sprzężeń, Gate'y bazowe i właściwości Qubitów, które są przydatne do testowania Transpilatora i wykonywania zaszumionych symulacji QPU. Model szumów z migawki jest automatycznie stosowany podczas symulacji.

Przykład:

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 SamplerV2 as Sampler, QiskitRuntimeService

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

Możesz używać lokalnego trybu testowania z symulatorami z Qiskit Aer, który zapewnia wydajniejszą symulację mogącą obsłużyć większe Circuit i niestandardowe modele szumów. Obsługuje również tryb symulacji Clifforda, który może wydajnie symulować Circuit Clifforda z dużą liczbą Qubitów.

Przykład z Session, bez szumów:

ostrożnie

Poniższy blok kodu zwróci błąd dla użytkowników planu Open Plan, ponieważ używa Session. Zadania w planie Open Plan mogą być uruchamiane tylko w trybie zadaniowym lub trybie wsadowym.

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, SamplerV2 as Sampler, QiskitRuntimeService

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

Aby symulować z szumem, wskaż QPU (sprzęt kwantowy) i prześlij go do Aer. Aer buduje model szumów na podstawie danych kalibracyjnych z tego QPU i tworzy instancję Backend'u Aer z tym modelem. Jeśli wolisz, możesz zbudować model szumów.

Przykład z szumem:

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, SamplerV2 as 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()

Symulacja Clifforda

Ponieważ Circuit Clifforda mogą być symulowane wydajnie z weryfikowalnymi wynikami, symulacja Clifforda jest bardzo przydatnym narzędziem. Szczegółowy przykład znajdziesz w Efficient simulation of stabilizer circuits with Qiskit Aer primitives.

Przykład:

import numpy as np
from qiskit.circuit.library import EfficientSU2
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as 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()