Lokalny tryb testowania

Wersje pakietów

Kod na tej stronie został opracowany z użyciem poniższych wymagań. Zalecamy korzystanie z tych lub nowszych wersji.

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

Użyj lokalnego trybu testowania (dostępnego w qiskit-ibm-runtime w wersji 0.22.0 lub nowszej), aby testować programy przed ich dopracowaniem i wysłaniem na prawdziwy sprzęt kwantowy. Po zweryfikowaniu programu w lokalnym trybie testowania wystarczy zmienić nazwę Backend, aby uruchomić go na QPU.

uwaga

Obsługa trybu lokalnego dla prymitywu Executor została wprowadzona w qiskit-ibm-runtime v0.50.0.

Aby skorzystać z lokalnego trybu testowania, wskaż jeden z fałszywych backendów z qiskit_ibm_runtime.fake_provider lub podaj Backend Qiskit Aer podczas tworzenia instancji prymitywu IBM Quantum® albo Session.

• Fałszywe backendy: Fałszywe backendy z qiskit_ibm_runtime.fake_provider naśladują zachowanie QPU IBM® poprzez używanie migawek QPU. Migawki QPU zawierają ważne informacje o QPU, takie jak mapa sprzężeń, bazowe Gate'y i właściwości qubitów, co jest przydatne do testowania Transpilera i przeprowadzania symulacji QPU z szumem. Model szumu z migawki jest automatycznie stosowany podczas symulacji.

• Symulator Aer: Symulatory z Qiskit Aer zapewniają wydajniejszą symulację, która obsługuje większe Circuit i niestandardowe modele szumu. Podczas używania AerSimulator w lokalnym trybie testowania dostępna jest lista opcji metod symulacji. Zobacz przykład trybu symulacji Clifford, który pokazuje, jak efektywnie symulować Circuit Clifford z dużą liczbą Qubitów.

  Lista metod symulacji dostępnych w Qiskit Aer

  Więcej informacji znajdziesz w dokumentacji AerSimulator.

  • "automatic": Domyślna metoda symulacji. Automatycznie wybiera metodę symulacji na podstawie Circuit i modelu szumu.

  • "statevector": Gęsta symulacja wektora stanu, która może próbkować wyniki pomiarów z idealnych Circuit z wszystkimi pomiarami na końcu. W przypadku symulacji z szumem każde wykonanie (shot) próbkuje losowo wybrany Circuit z szumem z modelu szumu.

  • "density_matrix": Symulacja macierzy gęstości, która może próbkować wyniki pomiarów z zaszumionych Circuit z wszystkimi pomiarami na końcu.

  • "stabilizer": Wydajny symulator stanów stabilizatorowych Clifforda, który potrafi symulować zaszumione obwody Clifforda, jeśli wszystkie błędy w modelu szumu są również błędami Clifforda.

  • "extended_stabilizer": Przybliżony symulator dla Circuit Clifford + T, oparty na rozkładzie stanu na rangowany stan stabilizatora. Liczba składników rośnie wraz z liczbą bramek nie-Clifford (T).

  • "matrix_product_state": Symulator wektora stanu oparty na sieciach tensorowych, który używa reprezentacji Matrix Product State (MPS) dla stanu. Można go stosować z obcinaniem lub bez obcinania wymiarów wiązań MPS, w zależności od opcji symulatora. Domyślnie brak obcinania.

  • "unitary": Gęsta symulacja macierzy unitarnej idealnego Circuit. Symuluje macierz unitarną samego Circuit, a nie ewolucję początkowego stanu kwantowego. Ta metoda obsługuje tylko Gate'y; nie obsługuje pomiarów, resetowania ani szumu.

  • "superop": Gęsta symulacja macierzy superoperatora dla idealnego lub zaszumionego Circuit. Symuluje macierz superoperatora samego Circuit, a nie ewolucję początkowego stanu kwantowego. Ta metoda potrafi symulować idealne i zaszumione Gate'y oraz resety, ale nie obsługuje pomiarów.

  • "tensor_network": Symulacja oparta na sieciach tensorowych obsługująca zarówno wektor stanu, jak i macierz gęstości. Obecnie dostępna wyłącznie dla GPU i akcelerowana przy użyciu interfejsów API cuQuantum cuTensorNet.

Uwagi

• W lokalnym trybie testowania możesz podać wszystkie opcje IBM Quantum Compute. Dzięki klienckim Sampler i Estimator (wprowadzonym w qiskit-ibm-runtime v0.50.0) opcje tłumienia i mitygacji błędów są implementowane lokalnie, więc możesz testować różne metody mitygacji błędów lokalnie, zanim zużyjesz czas QPU. Przykład znajdziesz w sekcji Lokalne testowanie mitygacji błędów.

Wcześniej lokalne symulatory ignorowały wszystkie opcje poza shots w przypadku starszych (serwerowych) prymitywów, ponieważ to przetwarzanie odbywało się wyłącznie na serwerze.

• Zaleca się zainstalowanie Qiskit Aer przed użyciem fałszywych backendów lub symulatorów Aer, uruchamiając pip install qiskit-aer. Fałszywe backendy używają symulatorów Aer pod spodem, jeśli są dostępne, aby skorzystać z ich wydajności.

Przykład fałszywych backendów

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

Przykłady AerSimulator

Przykład z Session, bez szumu:

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

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

ostrożnie

Na QPU może mieć wpływ wiele rodzajów szumu. Model szumu Qiskit Aer używany tutaj symuluje tylko niektóre z nich i w związku z tym jest prawdopodobnie mniej dotkliwy niż szum na prawdziwym QPU.

Szczegółowe informacje o tym, jakie błędy są uwzględniane podczas inicjalizacji modelu szumu z QPU, znajdziesz w dokumentacji API Aer NoiseModel.

Przykład z szumem:

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

Symulacja Clifforda

Ponieważ Circuit Clifford można efektywnie symulować z weryfikowalnymi wynikami, symulacja Clifford jest bardzo przydatnym narzędziem. Szczegółowy przykład znajdziesz w artykule Efektywna symulacja Circuit stabilizatora za pomocą prymitywów Qiskit Aer.

Przykład:

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

Lokalne testowanie mitygacji błędów

Dzięki klienckim Sampler i Estimator (wprowadzonym w qiskit-ibm-runtime v0.50.0) tłumienie i mitygacja błędów odbywają się po stronie klienta, a nie serwera. W rezultacie te opcje działają teraz w lokalnym trybie testowania, więc możesz eksperymentować z różnymi metodami mitygacji błędów na fałszywym backendzie, zanim zużyjesz czas QPU.

uwaga

W przypadku starszych serwerowych prymitywów ustawienie opcji takiej jak resilience.measure_mitigation na lokalnym symulatorze nie miało żadnego efektu, ponieważ przetwarzanie mitygacji odbywało się wyłącznie na serwerze. Prymitywy kliencie stosują to przetwarzanie lokalnie.

Zużycie pamięci i narzut czasu wykonania

Koszt lokalnej symulacji z szumem rośnie wykładniczo wraz z liczbą kubitów, a większość laptopów nie potrafi symulować więcej niż około 32 kubitów. Ponieważ metody tłumienia i mitygacji błędów działają teraz lokalnie, dodają dodatkowy narzut pamięci i czasu wykonania ponad podstawową symulację. Aby lokalne testy były wykonalne, użyj jednej z poniższych opcji:

• Mały fałszywy backend (taki jak FakeManilaV2, użyty poniżej).

• Symulator bezszumowy.

• Symulacja Clifforda, która skaluje się do dużej liczby kubitów.

Poniższy przykład włącza mitygację błędów pomiaru za pomocą Estimator i uruchamia go na fałszywym backendzie. Opcja measure_mitigation = True jest teraz stosowana do twoich obwodów lokalnie.

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

Testowanie lokalne w porównaniu z zadaniami dry-run

Tryb testowania lokalnego działa na twoim własnym komputerze. To dobry sposób na rozwijanie i debugowanie programu oraz sprawdzenie, jak może wyglądać wynik, ale nie podaje, ile naliczyłby rzeczywisty QPU ani czy usługa zaakceptuje zadanie.

W przeciwieństwie do testowania lokalnego zadanie dry-run uruchamia twoje zadanie przez IBM Quantum Compute Service na urządzeniu mock bez zużywania czasu QPU, dzięki czemu możesz zobaczyć liczbę jednostek zasobów (RU), które zadanie zużyłoby na rzeczywistym QPU. Na żądanie zapewnia też walidację po stronie usługi oraz harmonogram czasowy obwodu.

	Fake backend (testowanie lokalne)	Urządzenie mock (zadanie dry-run)
Gdzie działa	Lokalnie, na twoim komputerze	W chmurze, w IBM Quantum Compute Service
Konto i instancja	Niewymagane	Wymagane (Flex, Premium lub On-Prem)
Wyniki	Zaszumiona symulacja z użyciem migawkowego modelu szumu	Losowe dane o oczekiwanym schemacie. To nie jest symulacja
Zgłaszane zużycie	Brak	job.usage()
Walidacja zadania	Ograniczona do tego, co sprawdza klient	Wykonywana przez Quantum Compute, tak jak dla rzeczywistego zadania

Typowy przepływ pracy polega na iteracyjnym dopracowywaniu obwodów i wyników na fake backend, a następnie uruchomieniu zadania dry-run jako ostatniego sprawdzenia przed uruchomieniem na rzeczywistym QPU. Pełne porównanie znajdziesz w Mock devices compared to fake backends.

Następne kroki

Zalecenia

• Użyj klasy Neat, aby przeanalizować wpływ szumu na obciążenie Estimatora.
• Przejrzyj szczegółowe przykłady Samplera.
• Przejrzyj szczegółowe przykłady Estimatora.
• Ćwicz korzystanie z prymitywów, pracując nad lekcją funkcji kosztu w IBM Quantum Learning.
• Dowiedz się, jak transpilować lokalnie, w sekcji Transpilacja.
• Wypróbuj samouczek Porównaj ustawienia Transpilera.