Zum Hauptinhalt springen
Dieses Projekt befindet sich in der Beta-Phase. Einen Fehler gefunden? GitHub Issue erstellen. Frage oder Idee? In Discussions fragen — wir freuen uns über dein Feedback!
Wie ist die Übersetzungsqualität auf dieser Seite?

Lokaler Testmodus

Package versions

Der Code auf dieser Seite wurde mit den folgenden Paketversionen entwickelt. Wir empfehlen, diese oder neuere Versionen zu verwenden.

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

Verwende den lokalen Testmodus (verfügbar ab qiskit-ibm-runtime v0.22.0) um Programme zu testen, bevor du sie feinjustierst und an echte Quantenhardware sendest. Nachdem du deinen Code im lokalen Testmodus verifiziert hast, musst du lediglich den Backend-Namen ändern, um ihn auf einem QPU auszuführen.

hinweis

Die Unterstützung des lokalen Modus für das Executor Primitive wurde in qiskit-ibm-runtime v0.50.0 eingeführt.

Um den lokalen Testmodus zu nutzen, gib eines der Fake Backends aus qiskit_ibm_runtime.fake_provider an oder verwende ein Qiskit Aer Backend, wenn du ein IBM Quantum® Primitive oder eine Session instanziierst.

  • Fake Backends: Die Fake Backends in qiskit_ibm_runtime.fake_provider ahmen das Verhalten von IBM® QPUs mithilfe von QPU-Snapshots nach. Die QPU-Snapshots enthalten wichtige Informationen über den QPU, wie z. B. die Coupling Map, Basis-Gates und Qubit-Eigenschaften – nützlich zum Testen des Transpilers und für verrauschte Simulationen des QPU. Das Rauschmodell aus dem Snapshot wird während der Simulation automatisch angewendet.

  • Aer-Simulator: Simulatoren aus Qiskit Aer bieten leistungsstärkere Simulationen, die größere Circuits und benutzerdefinierte Rauschmodelle verarbeiten können. Im lokalen Testmodus stehen dir verschiedene Simulationsmethoden zur Verfügung, wenn du AerSimulator verwendest. Sieh dir das Clifford-Simulationsmodus-Beispiel an, das zeigt, wie Clifford-Circuits mit einer großen Anzahl an Qubits effizient simuliert werden können.

    Liste der von Qiskit Aer verfügbaren Simulationsmethoden

    Weitere Informationen findest du in der AerSimulator-Dokumentation.

    • "automatic": Standard-Simulationsmethode. Wählt die Simulationsmethode automatisch basierend auf Circuit und Rauschmodell aus.

    • "statevector": Eine dichte Zustandsvektor-Simulation, die Messergebnisse aus idealen Circuits mit allen Messungen am Ende des Circuits sampeln kann. Bei verrauschten Simulationen wird für jeden Shot ein zufällig ausgewählter verrauschter Circuit aus dem Rauschmodell gesampelt.

    • "density_matrix": Eine Dichtematrix-Simulation, die Messergebnisse aus verrauschten Circuits mit allen Messungen am Ende des Circuits sampeln kann.

    • "stabilizer": Ein effizienter Clifford-Stabilizer-Zustandssimulator, der verrauschte Clifford-Circuits simulieren kann, wenn alle Fehler im Rauschmodell ebenfalls Clifford-Fehler sind.

    • "extended_stabilizer": Ein approximativer Simulator für Clifford-+T-Circuits, der auf der Zerlegung des Zustands in einen Rang-Stabilizer-Zustand basiert. Die Anzahl der Terme wächst mit der Anzahl der Nicht-Clifford-Gates (T).

    • "matrix_product_state": Ein Tensor-Netzwerk-Zustandsvektorsimulator, der eine Matrix Product State (MPS)-Darstellung für den Zustand verwendet. Dies kann – je nach Simulatoroptionen – mit oder ohne Abschneiden der MPS-Bond-Dimensionen erfolgen. Standardmäßig wird nicht abgeschnitten.

    • "unitary": Eine dichte unitäre Matrixsimulation eines idealen Circuits. Diese simuliert die unitäre Matrix des Circuits selbst und nicht die Entwicklung eines Anfangszustands. Diese Methode kann nur Gates simulieren; sie unterstützt keine Messungen, Resets oder Rauschen.

    • "superop": Eine dichte Superoperator-Matrixsimulation eines idealen oder verrauschten Circuits. Diese simuliert die Superoperatormatrix des Circuits selbst und nicht die Entwicklung eines Anfangszustands. Diese Methode kann ideale und verrauschte Gates sowie Resets simulieren, unterstützt jedoch keine Messungen.

    • "tensor_network": Eine Simulation auf Basis eines Tensornetzwerks, die sowohl Zustandsvektor als auch Dichtematrix unterstützt. Dies ist derzeit nur für GPU verfügbar und wird durch die Verwendung der cuQuantum cuTensorNet-APIs beschleunigt.

Hinweise
  • Du kannst alle IBM Quantum Compute-Optionen im lokalen Testmodus angeben. Mit dem clientseitigen Sampler und Estimator (eingeführt in qiskit-ibm-runtime v0.50.0) werden Optionen zur Fehlerunterdrückung und Fehlerminderung lokal umgesetzt, sodass du verschiedene Fehlerminderungsmethoden lokal testen kannst, bevor du QPU-Zeit einsetzt. Ein Beispiel findest du unter Fehlerminderung lokal testen.

Zuvor ignorierten lokale Simulatoren bei den älteren (serverseitigen) Primitives alle Optionen außer shots, weil diese Verarbeitung nur auf dem Server stattfand.

  • Es wird empfohlen, Qiskit Aer vor der Verwendung von Fake Backends oder Aer-Simulatoren zu installieren, indem du pip install qiskit-aer ausführst. Die Fake Backends verwenden intern Aer-Simulatoren, sofern verfügbar, um deren Leistungsvorteile zu nutzen.

Fake-Backends-Beispiel​

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

AerSimulator-Beispiele​

Beispiel mit Sessions, ohne Rauschen:

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

Um mit Rauschen zu simulieren, gib einen QPU (Quantenhardware) an und übergib ihn an Aer. Aer erstellt dann ein Rauschmodell basierend auf den Kalibrierungsdaten dieses QPU und instantiiert ein Aer-Backend mit diesem Modell. Falls du es vorziehst, kannst du auch ein Rauschmodell selbst erstellen.

vorsicht

Ein QPU kann von verschiedenen Arten von Rauschen betroffen sein. Das hier verwendete Qiskit Aer-Rauschmodell simuliert nur einen Teil davon und ist daher wahrscheinlich weniger stark ausgeprägt als das Rauschen auf einem echten QPU.

Einzelheiten dazu, welche Fehler beim Initialisieren eines Rauschmodells aus einem QPU berücksichtigt werden, findest du in der Aer NoiseModel API-Referenz.

Beispiel mit Rauschen:

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

Clifford-Simulation​

Da Clifford-Circuits effizient mit verifizierbaren Ergebnissen simuliert werden können, ist die Clifford-Simulation ein sehr nützliches Werkzeug. Ein ausführlicheres Beispiel findest du unter Effiziente Simulation von Stabilizer-Circuits mit Qiskit Aer Primitives.

Beispiel:

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

Fehlerminderung lokal testen​

Beim clientseitigen Sampler und Estimator (eingeführt in qiskit-ibm-runtime v0.50.0) erfolgen Fehlerunterdrückung und Fehlerminderung auf dem Client statt auf dem Server. Dadurch wirken diese Optionen jetzt auch im lokalen Testmodus, sodass du mit verschiedenen Fehlerminderungsmethoden auf einem Fake Backend experimentieren kannst, bevor du QPU-Zeit einsetzt.

hinweis

Bei den älteren serverseitigen Primitives hatte das Setzen einer Option wie resilience.measure_mitigation auf einem lokalen Simulator keine Wirkung, weil die Fehlerminderungsverarbeitung nur auf dem Server lief. Die clientseitigen Primitives wenden diese Verarbeitung lokal an.

Überlegungen zu Speicher- und Laufzeitaufwand

Die Kosten einer lokalen verrauschten Simulation wachsen exponentiell mit der Qubit-Anzahl, und die meisten Laptops können nicht mehr als etwa 32 Qubits simulieren. Da Methoden zur Fehlerunterdrückung und Fehlerminderung jetzt lokal laufen, verursachen sie zusätzlichen Speicher- und Laufzeitaufwand on top der Basissimulation. Damit lokales Testen handhabbar bleibt, verwende eine der folgenden Möglichkeiten:

  • Ein kleines Fake Backend (etwa FakeManilaV2, das unten verwendet wird).

  • Ein rauschfreier Simulator.

  • Clifford-Simulation, die auf eine große Anzahl von Qubits skaliert.

Das folgende Beispiel schaltet die Messfehlerminderung mit Estimator ein und führt sie auf einem Fake Backend aus. Die Option measure_mitigation = True wird jetzt lokal auf deine Circuits angewendet.

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

Nächste Schritte​

Empfehlungen
Quelle: IBM Quantum-Dokumentation — aktualisiert 30. Sept. 2026
Englische Version auf doQumentation — aktualisiert 30. Sept. 2026
Problem mit Website oder Übersetzung?Inhaltliches Problem? Auf IBM Quantum docs bearbeiten