Backend-Details anzeigen

Paketversionen

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

qiskit-ibm-runtime~=0.47.0

Diese Seite erklärt, wie du Informationen über deine verfügbaren Backends findest.

Backends auflisten oder filtern

Verfügbare Backends anzeigen

Du kannst entweder Qiskit oder IBM Quantum Platform verwenden, um eine Liste der dir verfügbaren Backends anzuzeigen oder nach einem bestimmten Backend zu suchen.

QPU-Namen

QPUs, die auf IBM Cloud® gehostet werden, haben Namen, die mit ibm_* beginnen. Alle QPUs erhalten einen Städtenamen – zum Beispiel ibm_kingston. Dieser Name gibt nicht an, wo die eigentliche QPU gehostet wird.

Backends mit Qiskit anzeigen
Backends auf IBM Quantum Platform anzeigen

Verwende die Methode QiskitRuntimeService.backends(), wie im nächsten Codeblock gezeigt. Diese Methode gibt eine Liste von IBMBackend-Instanzen zurück.

Um den folgenden Code auszuführen, stelle sicher, dass du dich bereits beim Dienst authentifiziert hast. Weitere Details findest du unter Dein IBM Cloud-Konto einrichten.

Um nach einem bestimmten Backend zu suchen, verwende die Methode QiskitRuntimeService.backend() (beachte, dass dies der Singular ist: backend), die den Namen des Backends als Eingabeparameter nimmt und eine IBMBackend-Instanz zurückgibt, die dieses bestimmte Backend repräsentiert:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"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")

# Initialize your account
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

service.backends()

[<IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>]

service.backend("ibm_fez")

<IBMBackend('ibm_fez')>

# Optionally pass in an instance, region, or both, to
# further filter the backends.
service = QiskitRuntimeService()

service.backends(simulator=False, operational=True, min_num_qubits=100)

[<IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>]

hinweis

Wenn du bei einer bestimmten Instanz oder Region angemeldet bist oder wenn du den Dienst mit einer bestimmten Instanz oder Region durch die Verwendung von QiskitRuntimeService() initialisiert hast, werden nur die Backends zurückgegeben, die dir auf dieser Instanz oder Region verfügbar sind.

Backends filtern

Nach Eigenschaften mit Qiskit filtern
Nach Eigenschaften auf IBM Quantum Platform filtern

Du kannst die verfügbaren Backends nach ihrer Konfiguration oder ihrem Status filtern. Für allgemeinere Filter setze das filters-Argument auf eine Funktion, die ein Backend-Objekt akzeptiert und True zurückgibt, wenn es deinen Kriterien entspricht. Weitere Details findest du in der API-Dokumentation.

Der folgende Code gibt nur Backends zurück, die diese Kriterien erfüllen und dir auf deiner aktuell ausgewählten Instanz verfügbar sind:

Sind echte Quantengeräte (simulator=False)
Sind aktuell in Betrieb (operational=True)
Haben mindestens hundert Qubits (min_num_qubits=100)

Eine ähnliche Methode ist QiskitRuntimeService.least_busy(), die dieselben Filter wie backends() akzeptiert, aber das Backend zurückgibt, das den Filtern entspricht und die wenigsten Jobs in der Warteschlange hat:

service.least_busy(operational=True, min_num_qubits=100)

<IBMBackend('ibm_fez')>

Statische Backend-Informationen

Einige Informationen über ein Backend ändern sich nicht regelmäßig, wie z. B. sein Name, seine Version, die Anzahl der Qubits, sein Prozessortyp (der Vogelname der Familie, der die Topologie und die ungefähre Qubit-Anzahl angibt) sowie die unterstützten Funktionstypen. Diese Informationen sind als Attribute des backend-Objekts verfügbar. Eine vollständige Liste der Attribute findest du in der IBMBackend-API-Dokumentation. Weitere Informationen zur Versionierung findest du im Abschnitt QPU-Versionierung weiter unten.

Die Region eines Backends (der Standort des Rechenzentrums, in dem deine Daten und Experimente gehostet und verarbeitet werden) ist in seiner detaillierten Informationskarte auf der Compute-Ressourcen-Seite auf IBM Quantum Platform aufgeführt.

Backend-Informationen mit Qiskit anzeigen
Backend-Informationen auf IBM Quantum Platform anzeigen

backend = service.least_busy(operational=True, simulator=False)

print(
    f"Name: {backend.name}\n"
    f"Version: {backend.backend_version}\n"
    f"No. of programmable qubits: {backend.num_qubits}\n"
    f"Processor type: {backend.processor_type}\n"
)

Name: ibm_fez
Version: 1.3.37
No. of programmable qubits: 156
Processor type: {'family': 'Heron', 'revision': '2'}

QPU-Versionierung

Jede QPU hat eine Versionsnummer in der Form X.Y.Z (Major.Minor.Revision). Ein Circuit, der für eine bestimmte Versionsnummer kompiliert wurde, ist garantiert auf dieser QPU ausführbar. Wenn sich die Revisionsnummer ändert, läuft der Circuit weiterhin. Wenn sich die Major- oder Minor-Nummer ändert, ist der Circuit nicht garantiert ausführbar, obwohl dies möglich sein kann.

Die Revisionsnummer wird bei Korrekturen erhöht, die den bereits kompilierten Circuit nicht unbrauchbar machen.

Das frühere Codebeispiel in diesem Abschnitt zeigt, wie du die Version eines Backends findest. Auf IBM Quantum Platform kannst du die Version auf der detaillierten Informationskarte einer QPU anzeigen (klicke auf den QPU-Namen in der Compute-Ressourcen-Tabelle, um die Karte zu öffnen).

Die Bedingungen, unter denen sich eine Versions- oder Revisionsnummer ändern kann, sind in der folgenden Tabelle aufgeführt.

Major-Version	Minor-Version	Revisions-Version
Austausch des Chips (Sample-Wechsel)	Aufwärm-/Abkühlzyklen	QPU-Software-Updates
Wesentliche Änderungen an der Steuerelektronik	Austausch einiger Elektronikkomponenten, wenn der Ersatz den Betrieb merklich beeinflusst	Manuelle Kalibrierungen zur Verbesserung der Treue
Verlegung der QPU an einen neuen Standort, wenn sich daraus erhebliche Verhaltensänderungen ergeben	Vorübergehendes Deaktivieren eines Gates für eine gewisse Zeitdauer aufgrund von Kalibrierungsproblemen, und Korrekturen können nicht ohne Weiteres in Software vorgenommen werden	Kleine Elektronikänderungen, die den Betrieb nicht beeinflussen
	Änderung der Richtung eines CNOT-Gates

Unterstützte Anweisungen

Jede Prozessorfamilie unterstützt nativ eine begrenzte Menge von Anweisungen. Diese Menge umfasst Ein- und Zwei-Qubit-Gates sowie nicht-unitäre Operationen wie Messen und Zurücksetzen. Jedes Gate im Circuit muss (vom Transpiler) in die Elemente des unterstützten Anweisungssatzes einer QPU übersetzt werden, bevor es auf der QPU ausgeführt werden kann.

Du kannst die unterstützten Anweisungssätze für eine QPU mit Qiskit anzeigen. Die IBM Quantum Platform-Seite für Compute-Ressourcen listet nur die unterstützten unitären Gates (Basis-Gates) für eine QPU auf.

Unterstützte Anweisungen mit Qiskit finden
Basis-Gates auf IBM Quantum Platform finden

Tabelle der unterstützten Anweisungen

Operationskategorie	Name
Ein-Qubit-Gates	`RZ`, `SX`, `X`, `XSlow`, `ID`, `delay`
Zwei-Qubit-Gates	`CZ`, `ECR`
Fraktionale Gates	`RX` (Ein-Qubit), `RZZ` (Zwei-Qubit)
Nicht-unitäre Anweisungen	`measure`, `reset`, `measure_`, `reset_`, `measure_reset*`, `delay`
Kontrollfluss	`if_else` (klassisches Feedforward)

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

print(f"Backend: {backend.name}")
print(f"    Processor type: {backend.processor_type}")
print(f"    Supported instructions: {backend.supported_instructions}")

Backend: ibm_kingston

Processor type: {'family': 'Heron', 'revision': '2'}
    Supported instructions: ['cz', 'id', 'delay', 'measure', 'measure_2', 'reset', 'rz', 'sx', 'x', 'if_else', 'store']

Dynamische Backend-Informationen

Backends haben auch Eigenschaften, die sich bei jeder Kalibrierung des Backends ändern, wie z. B. die Qubit-Lebensdauer und Operationsfehlerraten. Backend-Eigenschaften werden nach Abschluss der Kalibrierungssequenz aktualisiert. Diese Eigenschaften können bei der Optimierung von Quantencircuits oder zur Konstruktion von Rauschmodellen für einen klassischen Simulator verwendet werden. Weitere Informationen findest du im Leitfaden Kalibrierungsjobs.

Auf IBM Quantum Platform kannst du Kalibrierungsdaten als CSV-Datei herunterladen. Klicke auf eine QPU auf der Compute-Ressourcen-Seite, um ihre detaillierte Informationskarte anzuzeigen, und klicke dann auf das Download-Symbol in der oberen rechten Ecke des Abschnitts „Kalibrierungsdaten".

Historische Daten abrufen

Du kannst historische Backend-Eigenschaftsdaten in Qiskit mit dem folgenden Code abrufen:

backend.properties(datetime=<datetime>)

Qubit-Eigenschaften

Zur Liste der Qubit-Eigenschaften springen

backend.properties().qubit_property() gibt Informationen über die physischen Attribute der Qubits zurück. Es enthält ein Dictionary mit verschiedenen Eigenschaften des Qubits, jeweils zusammen mit seinem Wert und dem Zeitstempel der letzten Kalibrierung.

Die folgenden Codebeispiele zeigen, wie man alle Eigenschaften auflistet oder bestimmte Eigenschaften eines bestimmten Qubits abruft.

Qubit-Eigenschaften anzeigen

T1 (Relaxationszeit)

Die $T_1$ -Zeit gibt die durchschnittliche Dauer an, die ein Qubit in seinem angeregten Zustand $|1\rangle$ verbleibt, bevor es aufgrund von Energierelaxation in seinen Grundzustand $|0\rangle$ zerfällt. Dieser Parameter wird verwendet, um das Energierelaxationsverhalten des Qubits zu charakterisieren, und wird in Sekunden (s) ausgedrückt.

Mit Qiskit anzeigen	`backend.properties().t1(<qubit>)`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten": Qubit-Dropdown-Menü; den $T_1$ -Median-Wert im Abschnitt „Details" finden

T2 (Dephasing-Zeit)

Die $T_2$ -Zeit bezeichnet die Zeitskala, über die ein Qubit die Phasenkohärenz einer Superposition zwischen den Zuständen $|0\rangle$ und $|1\rangle$ aufrechterhalten kann. Sie berücksichtigt sowohl Energierelaxation als auch reine Dephasierungsprozesse und gibt Einblick in die Kohärenzeigenschaften des Qubits. $T_2$ wird aus einer Hahn-Echo-Sequenz ermittelt.

Mit Qiskit anzeigen	`backend.properties().t2(<qubit>)`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten", Qubit-Dropdown-Menü; den $T_2$ -Median-Wert im Abschnitt „Details" finden

# fundamental physical properties of qubit 1

backend = service.least_busy(operational=True, simulator=False)

backend.qubit_properties(1)

QubitProperties(t1=0.00022010760855770256, t2=0.0002363339150114578, frequency=None)

# Retrieve qubit properties
qubit_index = backend.num_qubits - 1  # Replace with your qubit index
qubit_props = backend.properties().qubit_property(qubit_index)

# Access specific properties
t1 = qubit_props.get("T1", (None,))[0]
t2 = qubit_props.get("T2", (None,))[0]
readout_error = qubit_props.get("readout_error", (None,))[0]
prob_meas0_prep1 = qubit_props.get("prob_meas0_prep1", (None,))[0]
prob_meas1_prep0 = qubit_props.get("prob_meas1_prep0", (None,))[0]
readout_length = qubit_props.get("readout_length", (None,))[0]

print(f"Qubit {qubit_index} Properties:")
print(f"  T1: {t1} seconds")
print(f"  T2: {t2} seconds")
print(f"  Readout Error: {readout_error}")
print(f"  P(0 | 1): {prob_meas0_prep1}")
print(f"  P(1 | 0): {prob_meas1_prep0}")
print(f"  Readout Length: {readout_length} seconds")

Anweisungseigenschaften

Zur Liste der Anweisungseigenschaften springen

Das Attribut backend.target ist ein qiskit.transpiler.Target-Objekt: ein Objekt, das alle Informationen enthält, die zum Transpilieren eines Circuits für dieses Backend benötigt werden. Dies umfasst Anweisungsfehler und -dauern. Zum Beispiel ruft die folgende Zelle die Eigenschaften für ein cz-Gate ab, das zwischen einem verbundenen Qubit-Paar wirkt.

Die folgende Zelle zeigt die Eigenschaften für eine Messoperation (einschließlich des Auslesefehlers) auf Qubit 0.

Anweisungseigenschaften anzeigen

prob-meas0-prep1

Dieser Parameter gibt die Wahrscheinlichkeit an, ein Qubit im Zustand $|0\rangle$ zu messen, wenn es im Zustand $|1\rangle$ vorbereitet werden sollte, bezeichnet als $P(0 | 1)$ . Er spiegelt Fehler bei der Zustandsvorbereitung und -messung (SPAM) wider, insbesondere Messfehler in supraleitenden Qubits.

Mit Qiskit anzeigen	`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten": Qubit-Dropdown-Menü

prob-meas1-prep0

Ähnlich stellt dieser Parameter die Wahrscheinlichkeit dar, ein Qubit im Zustand $|1\rangle$ zu messen, wenn es im Zustand $|0\rangle$ vorbereitet werden sollte, bezeichnet als $P(1 | 0)$ . Wie prob_meas0_prep1 spiegelt er SPAM-Fehler wider, wobei Messfehler der vorherrschende Beitrag in supraleitenden Qubits sind.

Mit Qiskit anzeigen	`backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten": Qubit-Dropdown-Menü

2Q-Fehler (Heron und Nighthawk: CZ, Eagle: ECR)

Der Zwei-Qubit-Fehler pro Kante aus derselben Messbatch, die zur Berechnung des 2Q-Median-Fehlers verwendet wird. 2Q-Fehler (bester) bezieht sich auf den niedrigsten Zwei-Qubit-Fehler auf einer beliebigen Kante des Geräts, ebenfalls aus dieser Messbatch.

Mit Qiskit anzeigen	`backend.target['<instruction>'][<qubit 1>, <qubit 2>]`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierung": Bewege den Mauszeiger über die Qubit-Verbindung in der Kartenansicht oder finde den Wert in der Tabellenansicht unter der Spalte „CZ-Fehler" (Heron und Nighthawk) oder „ECR-Fehler" (Eagle); finde den Wert für 2Q-Fehler (bester) im Abschnitt „Details"

Median-2Q-Fehler (Heron: CZ, Eagle: ECR)

Durchschnittliche Gate-Treue der Zwei-Qubit-Operation aus dem randomisierten Benchmarking. Gemessen in „Isolation": Batches mit einem Mindestabstand von zwei Qubits zwischen Kanten. Dieses randomisierte Benchmarking verwendet abwechselnde Schichten von Ein-Qubit-Cliffords und Zwei-Qubit-Gates, und daher enthält der endgültige 2Q-Fehlerwert den Fehler der Schicht der Ein-Qubit-Cliffords.

Mit Qiskit berechnen	Folge dem Beispiel in diesem Qiskit Community GitHub-Notebook
Auf IBM Quantum Platform anzeigen	Abschnitt „Details"; finde auch Daten pro Kante im Abschnitt „Kalibrierungsdaten"

2Q-Fehler (geschichtet)

Durchschnittlicher Fehler pro geschichtetem Gate (EPLG) in einer Kette von 100 Qubits. Der durchschnittliche EPLG misst den durchschnittlichen Gate-Fehler in einer geschichteten Kette von $N$ Qubits ( $N$ =100 hier). Er wird aus einer ähnlichen Größe abgeleitet, die als Schichttreue (LF) bekannt ist, wobei EPLG $_{100}$ = 4/5(1-LF $^{\frac{1}{99}}$ ) und die Schichttreue die Prozesstreue der geschichteten Kette von $N$ Qubits ist. Weitere Details findest du in der Veröffentlichung Benchmarking quantum processor performance at scale. Beachte, dass EPLG in der Veröffentlichung für den Prozessfehler definiert ist, aber aus Gründen der Konsistenz mit den einzeln gemeldeten Gate-Fehlern wird hier der durchschnittliche Gate-Fehler angegeben, daher der Faktor 4/5.

Auf der IBM Quantum Platform hat die detaillierte Informationskarte jeder QPU einen Abschnitt namens „Zwei-Qubit-Gate-Fehler (geschichtet)“, der die erweiterte Ansicht des niedrigsten two-qubit gate error (layered) als Funktion der Anzahl der Qubits in der Kette zeigt. Der endgültige Wert bei Kettenlänge 100 ist der im Abschnitt „Details“ angezeigte Wert. In der Praxis werden sechs 100-Qubit-Ketten (vorab ausgewählt basierend auf erwarteter optimaler Leistung) gemessen, und der für die Anzahl der Qubits N gemeldete Wert ist der niedrigste Fehler, der in einer Teilkette der Länge N gefunden wurde, indem über die sechs 100-Qubit-Ketten gesucht wurde.

Mit Qiskit berechnen	Folge dem Beispiel in diesem Qiskit Community GitHub-Notebook
Auf IBM Quantum Platform anzeigen	Abschnitt „Details" und eine erweiterte Ansicht im Abschnitt „Zwei-Qubit-Gate-Fehler (geschichtet)"

RZZ-Fehler (Heron)

Fehler im RZZ-Gate, gemittelt über die RZZ-Winkel unter Verwendung einer Variante des randomisierten Benchmarkings für beliebige unitäre Transformationen.

Mit Qiskit anzeigen	Wichtig: Stelle sicher, dass du `use_fractional_gates=True` gesetzt hast, wenn du das Backend lädst, dann kannst du `backend.target['rzz'][<qubit 1>, <qubit 2>]` verwenden
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierung": Wähle RZZ im Verbindungs-Dropdown-Menü und bewege den Mauszeiger über die Qubit-Verbindung in der Kartenansicht. Du kannst auch „RZZ-Fehler" im Dropdown-Menü „Graphausgabe" in der Graphansicht auswählen, oder den Wert in der Tabellenansicht unter der Spalte „RZZ-Fehler" finden

ID-Fehler / √x (sx)-Fehler / Pauli-X-Fehler / RX-Fehler

Fehler der diskreten Ein-Qubit-Gates endlicher Dauer, gemessen aus dem randomisierten Benchmarking. Die randomisierte Benchmarking-Sequenz umfasst SX-, ID- und X-Gates, und es wird angenommen, dass ihre Fehler gleich sind. Das ID-Gate ist eine Verzögerung von einer Dauer, die der Dauer der √X- und X-Gates entspricht. Das RX-Gate hat ebenfalls dieselbe Dauer wie die √X- und X-Gates mit variabler Amplitude, und daher wird für es derselbe Fehler wie für diese Gates angegeben.

Mit Qiskit anzeigen	`backend.target['<instruction>'][<qubit 1>, ]`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierung": Qubit-Dropdown-Menü

SX-Fehler (Median)

Durchschnittliche Gate-Treue des √X (SX)-Gates aus dem randomisierten Benchmarking, gleichzeitig auf allen Qubits gemessen. Die randomisierte Benchmarking-Sequenz umfasst SX-, ID- und X-Gates, und es wird angenommen, dass ihre Fehler gleich sind.

Auf IBM Quantum Platform anzeigen	Abschnitt „Details"

Z-Achsen-Rotation (RZ)-Fehler

Fehler im virtuellen RZ-Gate. Wird durchgehend als 0 angegeben, da diese Gates in Software umgesetzt werden.

Mit Qiskit anzeigen	`backend.target['<instruction>'][<qubit 1>, ]`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierung": Verbindungs-Dropdown-Menü

Auslesefehler

Der Auslesefehler quantifiziert die durchschnittliche Wahrscheinlichkeit, den Zustand eines Qubits falsch zu messen. Er wird üblicherweise als Mittelwert von prob_meas0_prep1 und prob_meas1_prep0 berechnet und bietet eine einzelne Kennzahl für die Messtreue.

Mit Qiskit anzeigen	`backend.properties().readout_error(<qubit>)`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten": Qubit-Dropdown-Menü

Auslesefehler (Median)

Treue der Ausleseoperation. Der Auslesefehler wird gemessen, indem das Qubit im Zustand $|0\rangle$ ( $|1\rangle$ ) vorbereitet und die Wahrscheinlichkeit einer Ausgabe im Zustand $|1\rangle$ ( $|0\rangle$ ) gemessen wird. Der gemeldete Wert ist der Durchschnitt dieser beiden Fehler. Der Median wird über alle Qubits berechnet.

Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten": Abschnitt „Details"

Ein-Qubit-Gate-Länge

Dauer einer Ein-Qubit-Gate-Operation. Beachte, dass die auf IBM Quantum Platform angezeigten Werte in Nanosekunden angegeben sind. In Qiskit zurückgegebene Werte sind in Sekunden.

Mit Qiskit anzeigen	`backend.target['<instruction>'][<qubit 1>, ].duration`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierung": Qubit-Dropdown-Menü

Gate-Länge (2Q-Gates)

Dauer der Zwei-Qubit-Gate-Operation. Beachte, dass die auf IBM Quantum Platform angezeigten Werte in Nanosekunden angegeben sind. In Qiskit zurückgegebene Werte sind in Sekunden.

Mit Qiskit anzeigen	`backend.target['<instruction>'][<qubit 1>, <qubit 2> ].duration`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierung": Qubit-Dropdown-Menü

Ausleselänge

Die Ausleselänge gibt die Dauer der Ausleseoperation für ein Qubit an. Sie misst die Zeit vom Beginn des Messpulses bis zum Abschluss der Signaldigitalisierung, nach der das System für die nächste Operation bereit ist. Diesen Parameter zu verstehen ist entscheidend, um die Circuit-Ausführung zu optimieren – besonders, wenn du Mid-Circuit-Messungen verwendest.

Mit Qiskit anzeigen	Für `measure`: `backend.properties().readout_length(<qubit>)` Für `measure_2`: `backend.target['measure_2'][<qubit 1>, ].duration`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten": Qubit-Dropdown-Menü

Initialisierungsfehler

Der Initialisierungsfehler quantifiziert den Prozentsatz der Population im Zustand $|1\rangle$ nach der Standard-Rep-Delay und dem Qubit-Initialisierungsverfahren, wenn das vorherige Experiment das Qubit im Zustand $|1\rangle$ vorbereitet hat. Beachte, dass sich dies subtil von der Größe prob_meas1_prep0 unterscheidet, die den Prozentsatz der Messungen misst, die dem Zustand $|1\rangle$ zugeordnet werden. Letztere ist eine Messung sowohl des Initialisierungsfehlers als auch des Verfahrens zur Unterscheidung zwischen den Zuständen $|0\rangle$ und $|1\rangle$ . Im Grenzfall einer perfekten Messung sind die beiden Größen gleich.

Mit Qiskit anzeigen	`backend.properties().qubit_property(<qubit>, 'init_error')`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten": Qubit-Dropdown-Menü

# Get the cz gate properties for a connected pair of qubits
# (the first edge in this backend's coupling map)
edge = next(iter(backend.target["cz"]))
backend.target["cz"][edge]

backend.target["measure"][(0,)]

InstructionProperties(duration=1.66e-06, error=0.0126953125)

Weitere Eigenschaften

Maximale Circuits pro Sekunde (MCPS)

Maximale Circuits pro Sekunde (MCPS) umfasst Messung, Reset und Reinitialisierung eines Circuits mit einem Hadamard-Gate und einer einzelnen Messung.

Mit Qiskit anzeigen	`mcps = backend.configuration().mcps`
Auf IBM Quantum Platform anzeigen	Abschnitt „Details"

CLOPS (oder CLOPS_h)

Circuit-Schicht-Operationen pro Sekunde (CLOPS) ist ein Maß dafür, wie viele Schichten eines 100×100-Circuits (hardware-orientierter Circuit) eine QPU pro Zeiteinheit ausführen kann.

Mit Qiskit berechnen	Den CLOPS-Code in der Qiskit Community GitHub-Seite finden
Auf IBM Quantum Platform anzeigen	Abschnitt „Details"

Status

Mit BackendStatus kannst du den QPU-Status (z. B. Active, Paused, Offline) sowie die Anzahl der ausstehenden Jobs finden.

Mit Qiskit anzeigen	`print(backend.status().status_msg)`, `print(backend.status().pending_jobs)`
Auf IBM Quantum Platform anzeigen	Abschnitt „Details"

Topologiediagramm oder Kopplungskarte

Ein Diagramm, das angibt, zwischen welchen Qubit-Paaren Zwei-Qubit-Gate-Operationen möglich sind. Dies wird auch als Kopplungskarte oder Konnektivität bezeichnet. Qubits werden als Kreise dargestellt und die unterstützten Zwei-Qubit-Gate-Operationen werden als Linien angezeigt, die die Qubits verbinden.

Mit Qiskit anzeigen	`from qiskit.visualization import plot_gate_map` dann `plot_gate_map(backend)`
Auf IBM Quantum Platform anzeigen	Abschnitt „Kalibrierungsdaten"; klicke auf „Erweitern" für eine größere Ansicht

Was bedeutet `error = 1`?

Wenn das Benchmarking eines Qubits oder einer Kante über mehrere Tage hinweg nicht erfolgreich ist, sei es aufgrund schlechter Datenqualität oder anderer interner Faktoren, wird der gemeldete Fehlerwert als veraltet betrachtet und als 1 gemeldet. Dies ist kein Hinweis darauf, dass das Qubit oder die Kante unbedingt nicht funktioniert oder dass der Fehler 1 ist; vielmehr gilt der Fehler als undefiniert, und du solltest beim Betrieb dieses Qubits oder Gates mit Vorsicht vorgehen.

Nächste Schritte

Empfehlungen

Lerne, wie du Rauschmodelle erstellst, um verrauschte klassische Simulation durchzuführen.
Lies das Thema Transpiler-Stufen, um zu erfahren, wie der Transpiler Backend-Eigenschaften zur Circuit-Optimierung nutzt.
Sieh dir die QiskitRuntime Backend-API-Referenz an.

Backends auflisten oder filtern​

Verfügbare Backends anzeigen​

Backends filtern​

Statische Backend-Informationen​

QPU-Versionierung​

Unterstützte Anweisungen​

Tabelle der unterstützten Anweisungen​

Dynamische Backend-Informationen​

Qubit-Eigenschaften​

Qubit-Eigenschaften anzeigen​

Anweisungseigenschaften​

Anweisungseigenschaften anzeigen​

Weitere Eigenschaften​

Nächste Schritte​