Orbit – eine Qiskit Function von Quantum Elements

Hinweis

Qiskit Functions sind eine experimentelle Funktion, die nur Nutzern des IBM Quantum® Premium Plan, Flex Plan und On-Prem Plan (über die IBM Quantum Platform API) zur Verfügung steht. Sie befinden sich im Vorschau-Status und können sich daher ändern.

Überblick

Quantenhardware entwickelt sich stetig weiter, doch Rauschen und Dekohärenz schränken weiterhin die Tiefe und Zuverlässigkeit praktischer Quanten-Circuits ein. Unter den verfügbaren Ansätzen können drei komplementäre Techniken diese Einschränkungen erheblich mindern: dynamische Entkopplung (DD), optimierte Transpilation und Messfehlerminderung (MEM). Optimierte Transpilation reduziert die Circuit-Tiefe und richtet Circuits besser an der Konnektivität der Ziel-Hardware aus, DD unterdrückt Rauschen während Leerlaufzeiten durch sorgfältig gestaltete Steuersequenzen, und MEM reduziert die Auswirkungen von Auslesefehlern und kann während der Nachverarbeitung angewendet werden.

Die Auswahl einer effektiven DD-Strategie ist besonders anspruchsvoll, da zahlreiche Sequenzfamilien verfügbar sind und eine Sequenz, die für einen Circuit oder eine Rauschumgebung gut funktioniert, für eine andere möglicherweise nicht gut funktioniert. Die Vorteile von Transpilation, DD und MEM hängen vom Problem, der Hardware und der Workload ab; einzeln oder in Kombination eingesetzt, können sie die Leistung verbessern, sind jedoch nicht in jeder Konfiguration universell von Vorteil.

Orbit, eine von Quantum Elements entwickelte Qiskit Function, kombiniert alle drei Komponenten nahtlos zu einem einheitlichen Workflow und macht sie einfach nutzbar, um die Circuit-Ausführung auf IBM Quantum-Hardware zu verbessern. In seiner primären Form wendet Orbit automatisch aktive Fehlerunterdrückungsstrategien an, die Quantenzustände während Leerlaufzeiten schützen, während die ursprüngliche Circuit-Logik erhalten bleibt. Bemerkenswert ist, dass dies ohne zusätzliche Quanten- oder klassische Vorverarbeitungszeit geschieht, wodurch unnötige zusätzliche Kosten oder Wartezeiten innerhalb des Workflows vermieden werden.

Anstatt als Black Box zu funktionieren, ermöglicht Orbit Nutzern, seine Optimierungskomponenten für ein bestimmtes Experiment zu bewerten und fein abzustimmen. Nutzer können optimierte Transpilation, DD und MEM unabhängig voneinander aktivieren oder deaktivieren, die automatisierte DD-Auswahl mit benutzerdefinierten Sequenzen vergleichen und mehrere Konfigurationen innerhalb desselben Workflows ausführen. Durch den Vergleich jeder Konfiguration mit dem unveränderten Circuit können Nutzer feststellen, welche Techniken messbare Vorteile für ihren Circuit und ihr Backend bieten, Wechselwirkungen zwischen den verschiedenen Optimierungsmethoden identifizieren und die Konfiguration auswählen, die ihr experimentelles Ziel am besten unterstützt. Dieser Prozess hilft Nutzern zu verstehen, woher Leistungsgewinne stammen, und fundiertere Entscheidungen bei der Optimierung von Quanten-Circuits für eine bestimmte Workload zu treffen.

Beschreibung

Orbit wurde entwickelt, um die Ausführung von Quanten-Circuits auf IBM Quantum-Backends zu verbessern. Im automatisierten Modus können Nutzer nahtlos robuste DD-Sequenzen höherer Ordnung anwenden, ohne sie manuell auswählen oder konfigurieren zu müssen. Fortgeschrittene Nutzer können stattdessen mit verfügbaren Sequenzen höherer Ordnung experimentieren, um den Ansatz zu identifizieren und zu optimieren, der die beste Leistung für einen bestimmten Circuit liefert.

Orbit bietet außerdem sofortiges MEM, ohne dass die zusätzlichen Jobs erforderlich sind, die typischerweise für separate Kalibrierungs- und Minderungs-Workflows benötigt werden. Für Workloads, bei denen die Transpilation die Circuit-Struktur nicht verändern soll, wie beispielsweise Quantenfehlerkorrektur-Circuits mit Mid-Circuit-Messungen oder dynamische Circuits, kann Orbit DD und MEM anwenden, ohne die bestehende Transpilationsstrategie des Nutzers zu beeinträchtigen. Für Nutzer, die noch keinen bevorzugten Ansatz haben, enthält Orbit außerdem einen integrierten Transpiler, um Circuits für die Ziel-Hardware zu optimieren, bevor Techniken zur Fehlerunterdrückung und Auslesefehlerminderung angewendet werden.

Im Gegensatz zu Ansätzen, die auf zusätzlichem Circuit-Sampling, Extrapolation oder umfangreicher klassischer Nachverarbeitung beruhen, konzentriert sich Orbit auf die Unterdrückung von Fehlern während der Ausführung. Die Function ist so konzipiert, dass sie nur geringen Overhead verursacht, während die ursprüngliche Circuit-Logik erhalten bleibt. Nutzer können den resultierenden Circuit überprüfen und Orbit-optimierte Ausführungen direkt mit Standardausführungen vergleichen.

Ein praktischer Orbit-Workflow sieht wie folgt aus:

Definiere einen Quanten-Circuit und wähle Orbit über den Qiskit Functions Catalog aus.
Füge den Circuit ohne Orbit mithilfe des 'Raw'-Modus hinzu, um eine Baseline mit dem unveränderten Circuit zu erstellen.
Wähle aus, welche Optimierungsstrategien angewendet werden sollen, einschließlich automatisierter oder benutzerdefinierter DD-Sequenzen, MEM und optimierter Transpilation.
Aktiviere oder deaktiviere einzelne Methoden, oder reiche mehrere Konfigurationen ein, um ihre einzelnen und kombinierten Effekte zu bewerten.

Orbit ist besonders nützlich für Circuits mit Leerlaufzeiten oder Scheduling-Lücken, in denen Qubits nicht aktiv an Gates beteiligt sind. Es unterstützt statische und dynamische Circuits, einschließlich Workflows mit Mid-Circuit-Messungen und fehlertoleranten Quantencomputing-Experimenten. Typische Anwendungen umfassen Quantenfehlerkorrektur, Surface-Code-Experimente auf quadratischen und Heavy-Hex-Gittern, orakelbasierte Algorithmen wie Bernstein-Vazirani, Fourier-Transformations-Circuits, variationelle Quantenalgorithmen, Hamiltonian-Simulation, Benchmarking-Experimente und hardwarebewusste Circuit-Optimierung.

Mit Blick auf die Ära der Fehlertoleranz ist Orbit auch mit fehlertoleranten Quantencomputing-Workflows kompatibel, da es sich nahtlos mit Quantenfehlerkorrektur kombinieren lässt. Langfristig weist Orbit auf dynamische Entkopplung auf logischer Ebene [1] als zukunftsweisenden Weg zum Schutz logischer Qubits hin. Im folgenden Beispiel wurden zwei logische Qubits verschränkt, um unter Quantenfehlererkennung einen logischen Bell-Zustand zu erzeugen. Quantenfehlererkennung allein führte dazu, dass die Bell-Zustand-Treue über mehrere zehn Mikrosekunden auf etwa 44 % abfiel, während QED in Kombination mit Orbit-artigem Schutz die Treue des logischen Bell-Zustands nahe am oberen Ende der Skala hielt und im selben Zeitfenster etwa 95,3 % erreichte. Orbit Quantum Circuit Development Platform

Benchmarks

Die folgenden Ergebnisse fassen repräsentative Orbit-Durchläufe auf IBM Quantum-Hardware zusammen. Wie bei anderen Hardware-Benchmarks hängen die Ergebnisse vom gewählten Gerät, dem Kalibrierungszustand, dem Circuit und den Ausführungseinstellungen ab.

Beispiel	Metrik	Qubits	QPU	Weitere Details	Orbit-Verbesserung
Bernstein–Vazirani	Treue des versteckten Bitstrings	26 60 70	Heron r3	Unverändert vs. vollständiges Orbit, Nur Transpilation vs. vollständiges Orbit, Nur vollständiges Orbit	75x 66x N/A
QFT (unitär)	Treue	10	Heron r2 Heron r3	Orbit vs. unverändert: ~44 % vs. ~35 % ~67 % vs. ~61 %	1.26x 1.09x
QFT (dynamische Circuits)	Treue	10 20	Heron r3	Orbit vs. unverändert: ~55 % vs. ~2 % ~10 % vs. ~0 %	27.51x N/A
Bell-Zustand über große Distanz (dynamische Circuits)	Treue	30 60	Heron r2	N/A	1.78x 1.11x
Surface-Code (quadratisches Gitter)	Logische Fehlerwahrscheinlichkeit	25	Nighthawk r1	1 Runde 5 Runden 10 Runden	1.01x 1.15x 1.12x
Surface-Code (Heavy-Hex)	Logische Fehlerwahrscheinlichkeit	65	Heron r3	1 Runde 5 Runden 10 Runden	4.11x 2.04x 1.39x
VQE	Absoluter Fehler relativ zur idealen Energie	8	Heron r3	Orbit vs. unverändert: 56mHa vs. 1342 mHa	24x
QAOA	Erfolgswahrscheinlichkeit	5	Heron r2	N/A	1.46x
`[[4,2,2]]`-Code (Fehlerunterdrückung auf logischer Ebene)	Logische Treue des verschränkten Bell-Zustands	4	Heron r2	Durchschnittliche Treue über 55 μs	1.63x

Metrikdefinitionen

Treue des versteckten Bitstrings (Bernstein–Vazirani): Wahrscheinlichkeit, den korrekten versteckten Bitstring zu messen. Diese Metrik gibt an, wie zuverlässig der Algorithmus die beabsichtigte Lösung wiederfindet, wenn die Circuit-Größe zunimmt. Die Tabelle zeigt die drei größten versteckten Bitstrings, die unter drei verschiedenen Konfigurationen erfolgreich ausgewertet wurden: (i) unveränderte Circuits ohne Orbit, die 26 Qubits erreichten; (ii) Circuits nur mit Transpilation, die 60 Qubits erreichten; und (iii) Circuits mit dem vollständigen Orbit-Workflow, die 70 Qubits erreichten. Für die unveränderten Circuits (i) stellt der Verbesserungsfaktor den durch DD und MEM erzielten Leistungsgewinn im Vergleich zu den unveränderten Circuits dar. Für die Konfiguration mit ausschließlich Transpilation (ii) stellt er die Verbesserung dar, die durch das Hinzufügen von DD und MEM zu den optimal transpilierten Circuits erzielt wird. Für die vollständige Orbit-Konfiguration (iii) wird kein Basis-Verbesserungsfaktor angegeben, da eine von null verschiedene Erfolgswahrscheinlichkeit nur erzielt wurde, wenn alle Orbit-Komponenten (Transpilation, DD und MEM) aktiviert waren. Ein veranschaulichendes Beispiel wird unten bereitgestellt.
Treue der Quanten-Fourier-Transformation: Für sowohl die unitäre als auch die dynamische Circuit-Implementierung der QFT [2] misst die Treue die Übereinstimmung zwischen der experimentell implementierten Transformation und dem idealen QFT-Prozess über 20 verschiedene Eingangszustände. Dynamische Circuits enthalten erhebliche Leerlaufzeiten aufgrund von Mid-Circuit-Messungen und klassischem Feedforward, während der dynamische Entkopplung Dekohärenz unterdrücken kann. Die berichtete Verbesserung vergleicht die mit Orbit erzielte Treue mit der unveränderten Treue.
Bell-Zustand-Präparation über große Distanz: Erzeugung eines Bell-Zustands mithilfe dynamischer Circuits und Feedforward-Operationen zwischen zwei Qubits, die durch bis zu 60 dazwischenliegende Qubits getrennt sind, wodurch effiziente Verschränkung über große Distanzen auf lokal verbundener Quantenhardware demonstriert wird [3]. Orbit identifiziert das beste Qubit-Routing, erhält die Qubits während der Feedforward-Messungen und wendet MEM an, um Auslesefehler zu mindern.
Logische Fehlerwahrscheinlichkeit des Surface-Codes: Für den Heavy-Hex-Surface-Code [4] und den Surface-Code mit quadratischem Gitter [5] wurden Quantenspeicher-Experimente durchgeführt, bei denen ein codierter logischer Zustand über wiederholte Runden der Fehlerkorrektur erhalten blieb. Die logische Fehlerwahrscheinlichkeit misst die Wahrscheinlichkeit, dass akkumulierte Fehler dazu führen, dass die codierte Information falsch wiederhergestellt wird (ein niedrigerer Fehler ist besser). Die berichtete Verbesserung vergleicht die logische Fehlerwahrscheinlichkeit unveränderter Circuits mit der mit Orbit erzielten.
VQE-Absolutfehler: Verwendung von VQE mit einem optimierten unitären Coupled-Cluster-Ansatz zur Schätzung der Grundzustandsenergie von LiH [6]. Die gemessene Energie wird mit der entsprechenden idealen Energie verglichen, die aus dem rauschfreien Circuit ermittelt wurde. Die Metrik ist die absolute Differenz zwischen der gemessenen und der idealen Energie (niedrigere Werte sind besser). Die berichtete Verbesserung ist:

\text{Improvement factor} = \frac{|E_{\mathrm{raw}}-E_{\mathrm{ideal}}|} {|E_{\mathrm{Orbit}}-E_{\mathrm{ideal}}|}.

Werte größer als eins zeigen an, dass Orbit den Energiefehler im Vergleich zur Ausführung ohne dynamische Entkopplung verringert.

QAOA-Erfolgswahrscheinlichkeit: Wahrscheinlichkeit, eine Bitfolge zu messen, die einer optimalen Lösung des auf dem Butterfly-Graphen definierten Optimierungsproblems entspricht. Die berichtete Verbesserung vergleicht die mit Orbit erzielte Erfolgswahrscheinlichkeit mit der aus den unveränderten Circuits erzielten.
Logische Treue: Im logischen [[4,2,2]]-Experiment zur dynamischen Entkopplung [1] wurden zwei logische Qubits in vier physische Qubits kodiert und als verschränkter logischer Bell-Zustand präpariert. Die logische Treue misst die Übereinstimmung zwischen dem wiederhergestellten kodierten Zustand und dem angestrebten logischen Bell-Zustand. Die berichtete Verbesserung vergleicht die durchschnittliche logische Treue, die mit Orbit und Fehlererkennung (Fähigkeit des Codes) erzielt wurde, mit der, die bei alleiniger Verwendung des Codes erzielt wurde.

Erste Schritte

Authentifiziere dich mit deinem IBM Quantum Platform API-Schlüssel und wähle die Orbit-Function wie folgt aus. Dieses Snippet setzt voraus, dass du dein Konto bereits in deiner lokalen Umgebung gespeichert hast.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib qiskit qiskit-ibm-catalog

from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit import QuantumCircuit

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# Verify that you have access to the function.
catalog.list()

[QiskitFunction(quantum-elements/orbit)]

# Load the function.
orbit = catalog.load("quantum-elements/orbit")

Beispiel

Das folgende Beispiel erstellt einen Bernstein-Vazirani-Circuit und übermittelt ihn in einem Job auf zwei Arten an Orbit: Raw-Ausführung und Orbit-Standardeinstellungen.

Verwende dieses Muster, wenn du einen direkten Vergleich zwischen Raw und Orbit anstellen möchtest.

Einen Bernstein-Vazirani-Circuit erstellen

Wähle die verborgene Bitfolge und erstelle den logischen Circuit. Das zusätzliche Qubit ist das Oracle-Ziel, während die Eingabe-Qubits gemessen werden.

def create_bv_circuit(hidden_bitstring: str) -> QuantumCircuit:
    width = len(hidden_bitstring)
    circuit = QuantumCircuit(width + 1, width)

    circuit.x(width)
    circuit.h(range(width + 1))

    for input_qubit, bit in enumerate(reversed(hidden_bitstring)):
        if bit == "1":
            circuit.cx(input_qubit, width)

    circuit.barrier()
    circuit.h(range(width + 1))
    circuit.measure(range(width), range(width))
    return circuit

circuit_width = 50
hidden_bitstring = "1" * circuit_width
shots = 4096

bv_circuit = create_bv_circuit(hidden_bitstring)
bv_circuit.count_ops()

OrderedDict([('h', 102),
             ('cx', 50),
             ('measure', 50),
             ('x', 1),
             ('barrier', 1)])

Den Orbit-Workload vorbereiten

Erstelle einen Sampler-PUB und dupliziere ihn dann für die beiden Vergleichsmodi. Orbit empfängt den logischen Circuit und ordnet ihn während der Ausführung dem ausgewählten Backend zu.

base_pub = (bv_circuit, None, shots)
comparison_labels = ["raw", "orbit"]
pubs = [base_pub] * len(comparison_labels)

Raw- und Orbit-Standardausführung durchführen

pub_options weist den ersten PUB dem Raw-Modus zu, der die Orbit-Optimierung, DD und MEM überspringt, und weist den zweiten PUB den Orbit-Standardeinstellungen zu, die optimierte Transpilation, automatisches Einfügen dynamischer Entkopplung (DD) und Messfehlerminderung (MEM) umfassen.

backend_name = "ibm_kingston"

job = orbit.run(
    primitive="sampler",
    pubs=pubs,
    backend_name=backend_name,
    options={
        "pub_options": [
            {"mode": "raw"},
            {"mode": "orbit"},
        ],
        "save_backend_info": True,
    },
)

# Check the job ID and status
print(job.job_id)
print(job.status())

c0f1b99c-8dfa-4ebb-9560-d9a37c990acc
QUEUED

Rufe das Ergebnis ab und vergleiche die Raw- und die Orbit-optimierten Circuits anhand der Counts. Bei Sampler-Ergebnissen liefert get_counts() auf dem zurückgegebenen klassischen Register das Ausgabe-Histogramm. Wenn MEM für den Orbit-PUB erfolgreich ist, ist dieses Histogramm bereits MEM-korrigiert; die nicht korrigierten Counts bleiben in den Orbit-Metadaten unter measurementErrorMitigation["rawCounts"] verfügbar.

def extract_counts(pub_result) -> dict[str, int]:
    data = getattr(pub_result, "data", None)
    if data is None:
        raise TypeError("pub_result.data is missing")

    for name in dir(data):
        if name.startswith("_"):
            continue
        register = getattr(data, name)
        get_counts = getattr(register, "get_counts", None)
        if callable(get_counts):
            counts = get_counts()
            if counts:
                return counts

    raise TypeError(
        "No classical register with get_counts() found in pub_result.data"
    )

result = job.result()
if len(result) != len(comparison_labels):
    raise RuntimeError(
        f"Expected {len(comparison_labels)} PUB results, received {len(result)}."
    )

comparison_counts = {
    label: extract_counts(pub_result)
    for label, pub_result in zip(comparison_labels, result, strict=True)
}
correct_counts = {
    label: counts.get(hidden_bitstring, 0)
    for label, counts in comparison_counts.items()
}

print(
    {
        "hidden_bitstring": hidden_bitstring,
        "correct_counts": correct_counts,
        "shots": shots,
    }
)

{'hidden_bitstring': '11111111111111111111111111111111111111111111111111', 'correct_counts': {'raw': 0, 'orbit': 184}, 'shots': 4096}

Stelle einen visuellen Vergleich der Raw- und der Orbit-optimierten Circuits an.

import matplotlib.pyplot as plt

labels = list(correct_counts)
values = list(correct_counts.values())
fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.bar(labels, values, width=0.55)
ax.bar_label(bars, labels=[f"{value:g}" for value in values], padding=3)
ax.set_xlabel("Circuit execution mode")
ax.set_ylabel("Correct hidden-bitstring count")
ax.set_title(f"{circuit_width}-qubit Bernstein-Vazirani on {backend_name}")
ax.set_ylim(0, max(1, 1.15 * max(values)))
ax.grid(axis="y", alpha=0.25)
fig.tight_layout()
plt.show()

Ausgabe der vorherigen Codezelle

Support erhalten

Wende dich an den Quantum Elements-Support: info@quantumelements.ai

Achte darauf, folgende Informationen anzugeben:

Qiskit Function-Job-ID (qiskit-ibm-catalog), job.job_id
Backend-Name
Für den Raw- und den Orbit-Modus verwendete pub_options von Orbit
Eine detaillierte Beschreibung des Problems
Alle relevanten Fehlermeldungen oder -codes
Schritte zur Reproduktion des Problems

Nächste Schritte

Empfehlungen

Probiere ein anderes Backend, eine andere Qubit-Anzahl oder eine andere verborgene Bitfolge aus.
Lies unser Tutorial zur Quanten-Fourier-Transformation, um zu erfahren, wie du orbit-fähige benutzerdefinierte DD-Strategien definierst und DD auf dynamische Circuits mit Mid-Circuit-Messungen und Feedforward-Operationen anwendest.
Besuche die API-Referenz für eine detaillierte Beschreibung aller Orbit-Optionen.

Überblick​

Beschreibung​

Benchmarks​

Metrikdefinitionen​

Erste Schritte​

Beispiel​

Einen Bernstein-Vazirani-Circuit erstellen​

Den Orbit-Workload vorbereiten​

Raw- und Orbit-Standardausführung durchführen​

Support erhalten​

Nächste Schritte​

Referenzen​