Lokaler Testmodus

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

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

Verwenden Sie den lokalen Testmodus (verfügbar ab qiskit-ibm-runtime v0.22.0 ), um Programme zu testen, bevor Sie sie feinabstimmen und an echte Quantenhardware senden. Nachdem Sie Ihr Programm im lokalen Testmodus überprüft haben, müssen Sie nur noch den Namen des Backends ändern, um es auf einer QPU auszuführen.

Um den lokalen Testmodus zu verwenden, geben Sie eines der simulierten Backends aus an oder qiskit_ibm_runtime.fake_provider legen Sie beim Instanziieren einer „ IBM Quantum® “-Primitive oder einer Sitzung ein Qiskit Aer-Backend fest.

• Gefälschte Backends : Die gefälschten Backends in qiskit_ibm_runtime.fake_provider imitieren das Verhalten von IBM® QPUs, indem sie QPU-Snapshots verwenden. Die QPU-Snapshots enthalten wichtige Informationen über die QPU, wie z. B. die Kopplungskarte, Basisgatter und Qubit-Eigenschaften, die für das Testen des Transpilers und die Durchführung von verrauschten Simulationen der QPU nützlich sind. Das Rauschmodell aus dem Schnappschuss wird bei der Simulation automatisch angewendet.

• Aer-Simulator : Die Simulatoren von Qiskit Aer bieten eine leistungsstärkere Simulation, die größere Schaltungen und benutzerdefinierte Rauschmodelle verarbeiten kann. Eine Liste von Simulationsmethoden ist verfügbar, wenn Sie AerSimulator im lokalen Testmodus verwenden. Siehe das Beispiel für den Clifford-Simulationsmodus, das zeigt, wie man Clifford-Schaltungen mit einer großen Anzahl von Qubits effizient simulieren kann.

  • Liste der in Qiskit Aer verfügbaren Simulationsmethoden

    Weitere Informationen finden Sie in der AerSimulator dokumentation für weitere Informationen.

    • "automatic": Standard-Simulationsmethode. Wählen Sie die Simulationsmethode automatisch auf der Grundlage des Schaltungs- und Rauschmodells.

    • "statevector": Eine dichte Zustandsvektorsimulation, die Messergebnisse von idealen Schaltkreisen mit allen Messungen am Ende des Schaltkreises erfassen kann. Bei verrauschten Simulationen wird bei jedem Schuss ein zufällig abgetasteter verrauschter Schaltkreis aus dem Rauschmodell abgetastet.

    • "density_matrix": Eine Dichtematrixsimulation, die Messergebnisse von verrauschten Schaltkreisen mit allen Messungen am Ende des Schaltkreises erfassen kann.

    • "stabilizer": Ein effizienter Clifford-Stabilisator-Zustandssimulator, der verrauschte Clifford-Schaltungen simulieren kann, wenn alle Fehler im Rauschmodell auch Clifford-Fehler sind.

    • "extended_stabilizer": Ein annähernder Simulator für Clifford + T-Schaltungen, der auf der Zerlegung des Zustands in einen Rang-Stabilisator-Zustand beruht. Die Anzahl der Terme wächst mit der Anzahl der Nicht-Clifford (T)-Gatter.

    • "matrix_product_state": Ein Tensornetz-Zustandsvektor-Simulator, der eine Matrix-Produkt-Zustandsdarstellung (MPS) für den Zustand verwendet. Je nach den Optionen des Simulators kann dies mit oder ohne Abschneiden der MPS-Bindungsdimensionen erfolgen. Das Standardverhalten ist keine Trunkierung.

    • "unitary": Simulation einer idealen Schaltung mit einer dichten unitären Matrix. Dies simuliert die unitäre Matrix des Schaltkreises selbst und nicht die Entwicklung eines anfänglichen Quantenzustands. Diese Methode kann nur Gatter simulieren; sie unterstützt keine Messung, kein Reset und kein Rauschen.

    • "superop": Eine dichte Superoperator-Matrix-Simulation einer idealen oder verrauschten Schaltung. Dies simuliert die Superoperatormatrix des Schaltkreises selbst und nicht die Entwicklung eines anfänglichen Quantenzustands. Mit dieser Methode können ideale und verrauschte Gatter und Rücksetzungen simuliert werden, aber es sind keine Messungen möglich.

    • "tensor_network": Eine auf einem Tensornetz basierende Simulation, die sowohl den Zustandsvektor als auch die Dichtematrix unterstützt. Derzeit ist dies nur für GPU verfügbar und wird durch die Verwendung von cuQuantum cuTensorNet APIs beschleunigt.

Beispiel für gefälschte Backends

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 Sitzungen, ohne Lärm:

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, geben Sie eine QPU (Quanten-Hardware) an und übermitteln sie an Aer. Aer erstellt ein Rauschmodell auf der Grundlage der Kalibrierungsdaten von dieser QPU und instanziiert ein Aer-Backend mit diesem Modell. Wenn Sie möchten, können Sie auch ein Geräuschmodell erstellen.

Beispiel mit Lärm:

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-Schaltungen effizient und mit überprüfbaren Ergebnissen simuliert werden können, ist die Clifford-Simulation ein sehr nützliches Werkzeug. Ein ausführliches Beispiel finden Sie unter Effiziente Simulation von Stabilisierungsschaltungen mit Qiskit Aer-Primitiven.

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

Fehlerbehebung lokal testen

Mit den clientseitigen Funktionen und Sampler Estimator (eingeführt in v0.50.0qiskit-ibm-runtime ) erfolgen die Unterdrückung und Abmilderung von Fehlern auf dem Client statt auf dem Server. Daher werden diese Optionen nun im lokalen Testmodus wirksam, sodass Sie mit verschiedenen Methoden zur Fehlerminderung an einem simulierten Backend experimentieren können, bevor Sie QPU-Zeit investieren.

Im folgenden Beispiel wird die Minderung von Messfehlern aktiviert und Estimator auf einem simulierten Backend ausgeführt. Die Option measure_mitigation = True wird nun lokal auf Ihre Schaltkreise 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