Von Cloud-Simulatoren zu lokalen Simulatoren migrieren

Im Quantencomputing ist die Wahl zwischen Simulatoren und echter Quantenhardware entscheidend für den Fortschritt im Bereich. Simulatoren sind zwar nützlich zum Testen und Debuggen, aber in diesem Zeitalter des Quanten-Nutzens erfordern Quantenentwicklung und branchenweiter Fortschritt echte Hardware. Im Rahmen des Übergangs zur Quantennutzung wurden die IBM Quantum® Cloud-Simulatoren am 15. Mai 2024 eingestellt. Diese Anleitung erläutert die Einstellung genauer und erklärt, wie du von Cloud-basierten Simulatoren wie ibmq_qasm_simulator zu lokalen Simulatoren migrierst.

Warum werden die Cloud-Simulatoren eingestellt?

Die Cloud-Simulatoren werden aus mehreren Gründen eingestellt:

Simulatoren haben Einschränkungen

Simulatoren können nützlich sein, sind aber zu eingeschränkt für Forschung oder Experimente:

• Simulatoren sind wertvoll, um kleine QPUs (Quantenprozessoren) zu verstehen, ihre Nützlichkeit stößt jedoch bei etwa 50 Qubits an ihre Grenzen – selbst mit Zugang zu leistungsstarken Supercomputern. Diese Obergrenze entsteht durch das exponentielle Wachstum der benötigten Rechenressourcen für die Simulation größerer Quantencomputer (zur vollständigen Erklärung siehe Massively parallel quantum computer simulator, eleven years later). Das Erforschen von Quantencomputern mit 100 oder mehr Qubits erfordert Hardware.

• Während manche Simulatoren Rauschmodelle anbieten, ist es sehr schwierig, die gesamte Dynamik eines realen QPUs zu erfassen. Quantenhardware bietet Forschenden die Möglichkeit, sich den Herausforderungen echter Quantencomputer zu stellen – wie Rauschen, Fehler und Dekohärenz – in einer realistischen Testumgebung.

Die Arbeit mit Quantenhardware entwickelt einzigartige Fähigkeiten

Die direkte Interaktion mit Quantenhardware fördert Fähigkeiten und Erfahrungen, die allein mit Simulatoren nicht erreichbar sind:

• Die direkte Arbeit mit Quantenhardware baut Fähigkeiten auf, weil du Fehlerminderungs- oder Fehlerunterdrückungstechniken implementieren oder einsetzen musst, um verlässliche Berechnungen zu erhalten.

• Praktische Erfahrung mit Quantenhardware entwickelt ein tieferes Verständnis von Quantenphänomenen und wie man Algorithmen an die Eigenschaften von Quantenprozessoren anpasst.

• Die Arbeit mit Quantenhardware liefert praktische Einblicke in die Herausforderungen und Möglichkeiten des Quantencomputings und verbessert die Fähigkeit von Entwicklerinnen und Entwicklern, Innovationen in diesem Bereich voranzutreiben.

Algorithmen sollten für Quantenhardware angepasst werden

Erfolgreiche Quantenalgorithmen müssen so angepasst werden, dass sie die Möglichkeiten von Quantenhardware nutzen und Leistung sowie Effizienz optimieren.

• Quantenhardware bietet eine genauere Darstellung realer QPUs als Simulatoren.

• Die Feinabstimmung von Algorithmen für Quantenhardware umfasst die Anpassung von Ansatz, Circuit-Implementierungen, Parametern und Konfiguration, um die Leistung zu maximieren. Dieser Prozess lässt sich am besten durch direkte Experimente mit Quantenhardware erreichen.

Wann sollten Simulatoren eingesetzt werden?

Quantensimulatoren sollten genutzt werden, um Programme zu entwickeln und zu testen, bevor sie feinabgestimmt und an Quantenhardware gesendet werden. Lokale Simulatoren können das mit guter Leistung und Effizienz. Clifford-Circuits lassen sich sehr effizient simulieren und die Ergebnisse können verifiziert werden – das ist eine nützliche Methode, um Vertrauen in ein Experiment zu gewinnen.

hinweis

Der lokale Testmodus hat keine eingebaute Fehlerunterdrückung oder Fehlerminderung. Stattdessen musst du diese Optionen explizit angeben. Weitere Details findest du unter Fehlerminderung für Qiskit Runtime konfigurieren.

Zu lokalen Simulatoren migrieren

Ab qiskit-ibm-runtime 0.22.0 kannst du den lokalen Testmodus verwenden, um Cloud-Simulatoren zu ersetzen. Je nach deinen Anforderungen gibt es mehrere Möglichkeiten, den lokalen Testmodus zu nutzen. Gib zunächst einen der Fake Backends aus qiskit_ibm_runtime.fake_provider an oder wähle einen Qiskit-Aer-Backend, wenn du ein Primitive oder eine Session instanziierst.

Hilfe bei der Wahl eines Simulators

Nutze die folgende Tabelle, um einen geeigneten Simulator auszuwählen.

Simulator	Fake Backends	AerSimulator	Clifford-Simulation
Zweck	Ahmt spezifische IBM® QPUs mithilfe von Snapshots nach	Allgemeine, hochperformante Simulation	Effiziente Simulation für Clifford-Circuits
Rauschmodell	Wendet automatisch das Rauschmodell aus QPU-Snapshots an	Benutzerdefiniert oder basierend auf echten QPU-Kalibrationsdaten	Ideal für rauschfreie Simulationen
Circuit-Größe	Begrenzt auf die Möglichkeiten des nachgeahmten QPU	Kann größere Circuits verarbeiten	Geeignet für sehr große Circuits (hunderte Qubits)
Ergebnisse	Moderate Laufzeit für QPU-spezifische Tests	Kürzere Laufzeit für ein breites Spektrum an Simulationen	Extrem schnell, geeignet für Stabilizer-Circuits
Anwendungsfall	Testen des Transpilers und QPU-spezifischen Verhaltens	Allgemeine Entwicklung, benutzerdefinierte Rauschmodelle	Große Stabilizer-Circuits, Fehlerkorrektur

hinweis

Für die meisten Nutzerinnen und Nutzer ist AerSimulator aufgrund seiner Flexibilität und Leistung eine gute Wahl. Wenn deine Arbeit jedoch auf einen bestimmten QPU abzielt, ist ein Fake Backend möglicherweise die bessere Wahl.

Fake Backends

Die Fake Backends ahmen das Verhalten von IBM QPUs mithilfe von Snapshots nach. Die Snapshots enthalten wichtige Informationen über den QPU, wie die Coupling Map, Basis-Gates und Qubit-Eigenschaften, die beim Testen des Transpilers und beim Durchführen verrauschter Simulationen des QPU nützlich sind. Das Rauschmodell aus dem Snapshot wird während der Simulation automatisch angewendet.

Beispiel:

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

Du kannst den lokalen Testmodus mit Simulatoren von Qiskit Aer verwenden, der leistungsstärkere Simulationen bietet, die größere Circuits und benutzerdefinierte Rauschmodelle verarbeiten kann. Er unterstützt auch den Clifford-Simulationsmodus, der Clifford-Circuits mit einer großen Anzahl von Qubits effizient simulieren kann.

Beispiel mit Sessions, ohne Rauschen:

vorsicht

Der folgende Code-Block gibt für Nutzerinnen und Nutzer des Open Plans einen Fehler zurück, da er Sessions verwendet. Workloads im Open Plan können nur im Job-Modus oder Batch-Modus ausgeführt werden.

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

Um mit Rauschen zu simulieren, gib einen QPU (Quantenhardware) an und übergib ihn an Aer. Aer erstellt ein Rauschmodell auf Basis der Kalibrationsdaten dieses QPUs und instanziiert einen Aer-Backend mit diesem Modell. Falls du möchtest, kannst du auch ein Rauschmodell selbst erstellen.

Beispiel mit Rauschen:

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

Clifford-Simulation

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

Beispiel:

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