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.46.1

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 — required packages for this notebook
!pip install -q qiskit-ibm-runtime

# Initialize your account
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

service.backends()

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

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_boston')>,
 <IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>,
 <IBMBackend('ibm_miami')>]

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.backend("ibm_fez")

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

Name: ibm_fez
Version: 1.3.37
No. of 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 Revisionsversionsnummer wird für Korrekturen inkrementiert, die den vorhandenen kompilierten Circuit nicht unterbrechen.

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
Beispieländerungen	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 Genauigkeiten
Umsiedlung der QPU an einen neuen Standort, wenn sich daraus erhebliche Verhaltensänderungen ergeben	Auslassen 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
Single-Qubit-Gates	`RZ`, `SX`, `X`, `ID`, `delay`
Two-Qubit-Gates	`CZ`, `ECR`
Fraktionale Gates	`RX` (Single-Qubit), `RZZ` (Two-Qubit)
Nicht-unitäre Anweisungen	`measure`, `reset`, `measure_*`, `delay`
Kontrollfluss	`if_else` (klassisches Feedforward)

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("ibm_kingston")

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

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.backend("ibm_fez")

backend.qubit_properties(1)

QubitProperties(t1=0.00018243651954462543, t2=0.00020405172321184844, frequency=None)

# Retrieve qubit properties
qubit_index = 126  # 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")

Qubit 126 Properties:
  T1: 0.0001248478211384773 seconds
  T2: 7.96150033446492e-05 seconds
  Readout Error: 0.0244140625
  P(0 | 1): 0.029052734375
  P(1 | 0): 0.019775390625
  Readout Length: 1.56e-06 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 Qubits 1 und 0 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 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 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 Single-Qubit-Cliffords und Two-Qubit-Gates, und daher enthält der endgültige 2Q-Fehlerwert den Fehler der Schicht der Single-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 Prozessteilbarkeit 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 IBM Quantum Platform hat die detaillierte Informationskarte jeder QPU einen Abschnitt namens „Zwei-Qubit-Gate-Fehler (geschichtet)", der die erweiterte Ansicht des niedrigsten Zwei-Qubit-Gate-Fehlers (geschichtet) 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 Teilmenge 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 in den endlich-dauernden diskreten Ein-Qubit-Gates, 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 wird daher als denselben Fehler wie diese Gates aufweisend gemeldet.

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. Als alle 0 gemeldet, da diese in Software durchgeführt 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 Messteilbarkeit.

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 (1) vorbereitet und die Wahrscheinlichkeit einer Ausgabe im Zustand 1 (0) 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"

Single-Qubit-Gate-Länge

Dauer einer Single-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 Two-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. Das Verstehen dieses Parameters ist entscheidend für die Optimierung der Circuit-Ausführung, insbesondere wenn Zwischenkreis-Messungen einbezogen werden.

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ü

backend.target["cz"][(1, 0)]

InstructionProperties(duration=6.8e-08, error=0.010202155482934266)

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

InstructionProperties(duration=1.56e-06, error=0.025634765625)

Weitere Eigenschaften

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 die Paare von Qubits angibt, die Two-Qubit-Gate-Operationen zwischen ihnen unterstützen. Dies wird auch als Kopplungskarte oder Konnektivität bezeichnet. Qubits werden als Kreise dargestellt und die unterstützten Two-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​