QESEM: Eine Qiskit Function von Qedma

Hinweis

Qiskit Functions sind ein experimentelles Feature, das ausschließlich Nutzern des IBM Quantum® Premium Plan, Flex Plan und On-Prem (über die IBM Quantum Platform API) Plan zur Verfügung steht. Sie befinden sich im Preview-Release-Status und können sich noch ändern.

Überblick

Obwohl Quantenprozessoren (QPUs) in den letzten Jahren erhebliche Fortschritte gemacht haben, bleiben Fehler durch Rauschen und Unvollkommenheiten in bestehender Hardware eine zentrale Herausforderung für Entwickler von Quantenalgorithmen. Da sich das Feld Quantenberechnungen im Utility-Maßstab nähert, die klassisch nicht mehr verifiziert werden können, gewinnen Lösungen zur fehlerfreien Berechnung mit garantierter Genauigkeit zunehmend an Bedeutung. Um dieser Herausforderung zu begegnen, hat Qedma Quantum Error Suppression and Error Mitigation (QESEM) entwickelt, das nahtlos in die IBM Quantum Platform als Qiskit Function integriert ist.

Mit QESEM kannst du Quantenschaltkreise auf verrauschten QPUs ausführen und hochgenaue, fehlerfreie Ergebnisse mit sehr effizienten QPU-Zeit-Overheads erzielen, die nahe an fundamentalen Grenzen liegen. Dazu nutzt QESEM eine Reihe proprietärer Methoden von Qedma zur Charakterisierung und Reduktion von Fehlern. Fehlerreduktionstechniken umfassen Gate-Optimierung, rauschbewusste Transpilation, Error Suppression (ES) und unbiasiertes Error Mitigation (EM). Durch diese Kombination charakterisierungsbasierter Methoden kannst du zuverlässige, fehlerfreie Ergebnisse für generische großvolumige Quantenschaltkreise erzielen und so Anwendungen erschließen, die sonst nicht realisierbar wären.

Eine vollständige Beschreibung der zugrunde liegenden Komponenten sowie eine Demonstration im Utility-Maßstab findest du im Artikel Reliable high-accuracy error mitigation for utility-scale quantum circuits.

Beschreibung

Du kannst die QESEM-Funktion von Qedma verwenden, um deine Schaltkreise mit Error Suppression und Mitigation einfach zu schätzen und auszuführen, größere Schaltkreisvolumen und höhere Genauigkeiten zu erreichen. Zur Nutzung von QESEM gibst du einen Quantenschaltkreis, eine Menge zu messender Observablen, eine Zielstatistikgenauigkeit für jede Observable und einen gewählten QPU an. Bevor du den Schaltkreis auf die Zielgenauigkeit ausführst, kannst du die erforderliche QPU-Zeit auf Basis einer analytischen Berechnung schätzen, die keine Schaltkreisausführung erfordert. Sobald du mit der QPU-Zeitschätzung zufrieden bist, kannst du den Schaltkreis mit QESEM ausführen.

Bei der Ausführung eines Schaltkreises führt QESEM ein auf deinen Schaltkreis zugeschnittenes Gerätcharakterisierungsprotokoll durch, das ein zuverlässiges Rauschmodell für die im Schaltkreis auftretenden Fehler liefert. Auf Basis der Charakterisierung implementiert QESEM zunächst eine rauschbewusste Transpilation, um den Eingangsschaltkreis auf eine Menge physikalischer Qubits und Gates abzubilden, die das Rauschen bezüglich der Zielobservable minimiert. Dazu gehören die nativ verfügbaren Gates (CX/CZ auf IBM®-Geräten) sowie zusätzliche, von QESEM optimierte Gates, die den erweiterten Gate-Satz von QESEM bilden. QESEM führt dann eine Reihe charakterisierungsbasierter ES- und EM-Schaltkreise auf dem QPU aus und erfasst deren Messergebnisse. Diese werden anschließend klassisch nachverarbeitet, um einen unverzerrten Erwartungswert und einen Fehlerbalken für jede Observable entsprechend der angeforderten Genauigkeit bereitzustellen.

QESEM hat nachweislich hochgenaue Ergebnisse für eine Vielzahl von Quantenanwendungen und bei den größten heute erreichbaren Schaltkreisvolumen geliefert. QESEM bietet die folgenden nutzerorientierten Features, die im nachfolgenden Benchmarks-Abschnitt demonstriert werden:

• Garantierte Genauigkeit: QESEM liefert unverzerrte Schätzungen für Erwartungswerte von Observablen. Die EM-Methode ist mit theoretischen Garantien ausgestattet, die – zusammen mit Qedmas modernster Charakterisierung – sicherstellen, dass die Mitigation bis zur nutzerdefinierten Genauigkeit gegen die rauschfreie Schaltkreisausgabe konvergiert. Im Gegensatz zu vielen heuristischen EM-Methoden, die anfällig für systematische Fehler oder Verzerrungen sind, ist QESEMs garantierte Genauigkeit entscheidend für zuverlässige Ergebnisse bei generischen Quantenschaltkreisen und Observablen.
• Skalierbarkeit auf große QPUs: Die QPU-Zeit von QESEM hängt vom Schaltkreisvolumen ab, ist aber ansonsten unabhängig von der Anzahl der Qubits. Qedma hat QESEM auf den größten heute verfügbaren Quantengeräten demonstriert, darunter die IBM Quantum 127-Qubit Eagle- und 133-Qubit Heron-Geräte.
• Anwendungsunabhängig: QESEM wurde für eine Vielzahl von Anwendungen demonstriert, darunter Hamiltonian Simulation, VQE, QAOA und Amplitudenabschätzung. Nutzer können beliebige Quantenschaltkreise und Observablen eingeben und genaue, fehlerfreie Ergebnisse erhalten. Die einzigen Einschränkungen werden durch die Hardware-Spezifikationen und die zugewiesene QPU-Zeit bestimmt, die die zugänglichen Schaltkreisvolumen und Ausgabegenauigkeiten festlegen. Im Gegensatz dazu sind viele Fehlerreduktionstechniken anwendungsspezifisch oder beinhalten unkontrollierte Heuristiken, die sie für generische Quantenschaltkreise und Anwendungen ungeeignet machen.
• Erweiterter Gate-Satz: QESEM unterstützt Gates mit gebrochenen Winkeln und stellt Qedma-optimierte $Rzz(\theta)$-Gates mit gebrochenen Winkeln auf IBM Quantum Eagle-Geräten bereit. Dieser erweiterte Gate-Satz ermöglicht eine effizientere Kompilierung und erschließt Schaltkreisvolumen, die um einen Faktor von bis zu 2 größer sind als bei der Standard-CX/CZ-Kompilierung.
• Multibasige Observablen: QESEM unterstützt Eingabe-Observablen, die aus vielen nicht-kommutierenden Pauli-Strings bestehen, wie generische Hamiltonians. Die Wahl der Messbasen und die Optimierung der QPU-Ressourcenallokation (Shots und Schaltkreise) wird dann automatisch von QESEM durchgeführt, um die erforderliche QPU-Zeit für die angeforderte Genauigkeit zu minimieren. Diese Optimierung, die Hardware-Fidelities und Ausführungsraten berücksichtigt, ermöglicht es dir, tiefere Schaltkreise auszuführen und höhere Genauigkeiten zu erzielen.

Benchmarks

QESEM wurde für eine große Bandbreite von Anwendungsfällen getestet. Die folgenden Beispiele können dir helfen, einzuschätzen, welche Arten von Workloads du mit QESEM ausführen kannst.

Eine wichtige Kennzahl zur Quantifizierung der Schwierigkeit von sowohl Error Mitigation als auch klassischer Simulation für einen gegebenen Schaltkreis und eine Observable ist das aktive Volumen: die Anzahl der CNOT-Gates, die die Observable im Schaltkreis beeinflussen. Das aktive Volumen hängt von der Schaltkreistiefe und -breite, dem Gewicht der Observable und der Schaltkreisstruktur ab, die den Lichtkegel der Observable bestimmt. Weitere Details findest du im Vortrag vom 2024 IBM Quantum Summit. QESEM bietet besonders großen Mehrwert im Hochvolumenbereich und liefert zuverlässige Ergebnisse für generische Schaltkreise und Observablen.

Anwendung	Anzahl Qubits	Gerät	Schaltkreisbeschreibung	Genauigkeit	Gesamtzeit	Runtime-Nutzung
VQE-Schaltkreis	8	Eagle (r3)	21 Gesamtschichten, 9 Messbasen, 1D-Kette	98%	35 Min.	14 Min.
Kicked Ising	28	Eagle (r3)	3 einzigartige Schichten x 3 Schritte, 2D Heavy-Hex-Topologie	97%	22 Min.	4 Min.
Kicked Ising	28	Eagle (r3)	3 einzigartige Schichten x 8 Schritte, 2D Heavy-Hex-Topologie	97%	116 Min.	23 Min.
Trotterisierte Hamiltonian-Simulation	40	Eagle (r3)	2 einzigartige Schichten x 10 Trotter-Schritte, 1D-Kette	97%	3 Std.	25 Min.
Trotterisierte Hamiltonian-Simulation	119	Eagle (r3)	3 einzigartige Schichten x 9 Trotter-Schritte, 2D Heavy-Hex-Topologie	95%	6,5 Std.	45 Min.
Kicked Ising	136	Heron (r2)	3 einzigartige Schichten x 15 Schritte, 2D Heavy-Hex-Topologie	99%	52 Min.	9 Min.

Die Genauigkeit wird hier relativ zum Idealwert der Observable gemessen: $\frac{\langle O \rangle_{ideal} - \epsilon}{\langle O \rangle_{ideal}}$, wobei „$\epsilon$" die absolute Präzision der Mitigation (vom Nutzer festgelegt) ist und $\langle O \rangle_{ideal}$ den Erwartungswert des rauschfreien Schaltkreises bezeichnet. „Runtime-Nutzung" misst die Nutzung des Benchmarks im Batch-Modus (Summe der Nutzung einzelner Jobs), während „Gesamtzeit" die Nutzung im Session-Modus (Experiment-Wandzeit) misst, die zusätzliche klassische und Kommunikationszeiten einschließt. QESEM ist für die Ausführung in beiden Modi verfügbar, sodass Nutzer ihre verfügbaren Ressourcen optimal nutzen können.

Die 28-Qubit Kicked-Ising-Schaltkreise simulieren den von Shinjo et al. untersuchten Discrete Time Quasicrystal (siehe arXiv 2403.16718 und Q2B24 Tokyo) auf drei verbundenen Schleifen von ibm_kawasaki. Die hier verwendeten Schaltkreisparameter sind $(\theta_x, \theta_z) = (0.9 \pi, 0)$ mit einem ferromagnetischen Anfangszustand $| \psi_0 \rangle = | 0 \rangle ^{\otimes n}$. Die gemessene Observable ist der Absolutbetrag der Magnetisierung $M = |\frac{1}{28} \sum_{i=0}^{27} \langle Z_i \rangle|$. Das Kicked-Ising-Experiment im Utility-Maßstab wurde auf den 136 besten Qubits von ibm_fez ausgeführt; dieser spezifische Benchmark wurde beim Clifford-Winkel $(\theta_x, \theta_z) = (\pi, 0)$ ausgeführt, bei dem das aktive Volumen mit der Schaltkreistiefe langsam wächst – was zusammen mit den hohen Geräte-Fidelities eine hohe Genauigkeit bei kurzer Laufzeit ermöglicht.

Trotterisierte Hamiltonian-Simulations-Schaltkreise gelten für ein Transverse-Field-Ising-Modell bei gebrochenen Winkeln: $(\theta_{zz}, \theta_x) = (\pi / 4, \pi /8)$ und $(\theta_{zz}, \theta_x) = (\pi / 6, \pi / 8)$ entsprechend (siehe Q2B24 Tokyo). Der Schaltkreis im Utility-Maßstab wurde auf den 119 besten Qubits von ibm_brisbane ausgeführt, während das 40-Qubit-Experiment auf der besten verfügbaren Kette ausgeführt wurde. Die Genauigkeit wird für die Magnetisierung angegeben; hochgenaue Ergebnisse wurden auch für höhergewichtige Observablen erzielt.

Der VQE-Schaltkreis wurde zusammen mit Forschern des Center for Quantum Technology and Applications am Deutschen Elektronen-Synchrotron (DESY) entwickelt. Die Zielobservable war hier ein Hamiltonian, der aus einer großen Anzahl nicht-kommutierender Pauli-Strings besteht, was QESEMs optimierte Leistung für multibasige Observablen unterstreicht. Die Mitigation wurde auf einen klassisch optimierten Ansatz angewendet; obwohl diese Ergebnisse noch unveröffentlicht sind, werden Ergebnisse gleicher Qualität für verschiedene Schaltkreise mit ähnlichen strukturellen Eigenschaften erzielt.

Erste Schritte

Authentifiziere dich mit deinem IBM Quantum Platform API-Schlüssel und wähle die QESEM Qiskit 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 qiskit qiskit-ibm-catalog qiskit-ibm-runtime

import qiskit

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

qesem_function = catalog.load("qedma/qesem")

Beispiel

Um loszulegen, probiere dieses grundlegende Beispiel zur Schätzung der erforderlichen QPU-Zeit für die Ausführung von QESEM für ein gegebenes pub:

# This cell is hidden from users
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend_name = service.least_busy().name

circ = qiskit.QuantumCircuit(5)
circ.cx(0, 1)
circ.cx(2, 3)
circ.cx(1, 2)
circ.cx(3, 4)

avg_magnetization = qiskit.quantum_info.SparsePauliOp.from_sparse_list(
    [("Z", [q], 1 / 5) for q in range(5)], num_qubits=5
)
other_observable = qiskit.quantum_info.SparsePauliOp.from_sparse_list(
    [("ZZ", [0, 1], 1.0), ("XZ", [1, 4], 0.5)], num_qubits=5
)

time_estimation_job = qesem_function.run(
    pubs=[(circ, [avg_magnetization, other_observable])],
    options={
        "estimate_time_only": "analytical",
    },
    backend_name=backend_name,  # E.g. "ibm_fez"
)

time_estimate_result = time_estimation_job.result()

Das folgende Beispiel führt einen QESEM-Job aus:

sample_job = qesem_function.run(
    pubs=[(circ, [avg_magnetization, other_observable])],
    backend_name=backend_name,  # E.g. "ibm_fez"
)

Du kannst die vertrauten Qiskit Serverless APIs verwenden, um den Status deines Qiskit Function Workloads zu prüfen oder Ergebnisse abzurufen:

print(sample_job.status())
result = sample_job.result()

Funktionsparameter

Name	Typ	Beschreibung	Erforderlich	Standard	Beispiel
pubs	EstimatorPubLike	Dies ist die Haupteingabe. Das Pub enthält 2–4 Elemente: einen Schaltkreis, eine oder mehrere Observablen, 0 oder einen einzelnen Satz von Parameterwerten und eine optionale Präzision. Wenn keine Präzision angegeben wurde, wird default_precision aus options verwendet.	Ja	N/A	[(circuit, [obs1,obs2,obs3], parameter_values, 0.03)]
backend_name	string	Name des zu verwendenden Backends	Nein	QESEM wählt das am wenigsten ausgelastete Gerät laut IBM	"ibm_fez"
instance	string	Der Cloud-Ressourcenname der zu verwendenden Instanz in diesem Format	Nein	N/A	"CRN"
options	dictionary	Eingabeoptionen. Weitere Details findest du im Abschnitt Optionen.	Nein	Siehe den Abschnitt Optionen für Details.	{ default_precision = 0.03, "max_execution_time" = 3600, "transpilation_level" = 0}

Optionen

Option	Auswahlmöglichkeiten	Beschreibung	Standard
estimate_time_only	"analytical" / "empirical" / None	Wenn gesetzt, berechnet der QESEM-Job nur die QPU-Zeitschätzung. Weitere Details siehe unten. Wenn None gesetzt ist, wird der Schaltkreis mit QESEM ausgeführt.	None
default_precision	0 < float	Gilt für pubs ohne Präzisionsangabe. Die Präzision gibt den akzeptablen Fehler bei den Erwartungswerten der Observablen als Absolutwert an. Das heißt, die QPU-Laufzeit für die Mitigation wird so bestimmt, dass Ausgabewerte für alle relevanten Observablen innerhalb eines 1σ-Konfidenzintervalls der Zielpräzision liegen. Wenn mehrere Observablen angegeben werden, läuft die Mitigation, bis die Zielpräzision für jede Eingabeobservable erreicht ist.	0.02
max_execution_time	0 < integer < 28.800 (8 Stunden)	Ermöglicht es dir, die QPU-Zeit in Sekunden für den gesamten QESEM-Prozess zu begrenzen. Weitere Details unten.	3.600 (eine Stunde)
transpilation_level	0 / 1	Siehe Beschreibung unten	1
execution_mode	"session" / "batch"	Siehe folgende Beschreibung	„batch"

vorsicht

Die QPU-Zeitschätzung variiert von Backend zu Backend. Stelle daher bei der Ausführung der QESEM-Funktion sicher, dass du dasselbe Backend verwendest, das bei der Ermittlung der QPU-Zeitschätzung ausgewählt wurde.

hinweis

QESEM beendet seine Ausführung, wenn entweder die Zielpräzision oder max_execution_time erreicht wird – je nachdem, was zuerst eintritt.

• estimate_time_only – Dieses Flag ermöglicht es Nutzern, eine Schätzung der für die Ausführung des Schaltkreises mit QESEM erforderlichen QPU-Zeit zu erhalten.

  • Wenn auf "analytical" gesetzt, wird eine obere Schranke der QPU-Zeit berechnet, ohne QPU-Nutzung zu verbrauchen. Diese Schätzung hat eine Auflösung von 30 Minuten (z. B. 30 Minuten, 60 Minuten, 90 Minuten usw.). Sie ist typischerweise pessimistisch und kann nur für einzelne Pauli-Observablen oder Summen von Paulis ohne überschneidende Träger erhalten werden (z. B. Z0+Z1). Sie ist in erster Linie nützlich, um die Komplexitätsniveaus verschiedener vom Nutzer bereitgestellter Parameter (Schaltkreis, Genauigkeit usw.) zu vergleichen.
  • Um eine genauere QPU-Zeitschätzung zu erhalten, setze dieses Flag auf "empirical". Obwohl diese Option die Ausführung einer kleinen Anzahl von Schaltkreisen erfordert, liefert sie eine deutlich genauere QPU-Zeitschätzung. Diese Schätzung hat eine Auflösung von 5 Minuten (z. B. 20 Minuten, 25 Minuten, 30 Minuten usw.). Der Nutzer kann die empirische Zeitschätzung im Batch- oder Session-Modus ausführen. Weitere Details findest du in der Beschreibung von execution_mode. Im Batch-Modus verbraucht die empirische Zeitschätzung beispielsweise weniger als 10 Minuten QPU-Zeit.

• max_execution_time: Ermöglicht es dir, die QPU-Zeit in Sekunden für den gesamten QESEM-Prozess zu begrenzen. Da die endgültig benötigte QPU-Zeit zur Erreichung der Zielgenauigkeit dynamisch während des QESEM-Jobs bestimmt wird, kannst du mit diesem Parameter die Kosten des Experiments begrenzen. Wenn die dynamisch bestimmte QPU-Zeit kürzer als die vom Nutzer zugewiesene Zeit ist, hat dieser Parameter keinen Einfluss auf das Experiment. Der Parameter max_execution_time ist besonders nützlich, wenn die von QESEM vor dem Job bereitgestellte analytische Zeitschätzung zu pessimistisch ist und der Nutzer trotzdem einen Mitigation-Job starten möchte. Nach Erreichen des Zeitlimits sendet QESEM keine neuen Schaltkreise mehr. Bereits gesendete Schaltkreise laufen weiter (die Gesamtzeit kann das Limit daher um bis zu 30 Minuten überschreiten), und der Nutzer erhält die verarbeiteten Ergebnisse der bis dahin ausgeführten Schaltkreise. Wenn du ein QPU-Zeitlimit unterhalb der analytischen Zeitschätzung anwenden möchtest, wende dich an Qedma, um eine Schätzung der innerhalb des Zeitlimits erreichbaren Genauigkeit zu erhalten.

• transpilation_level: Nachdem ein Schaltkreis an QESEM übergeben wurde, erstellt es automatisch mehrere alternative Schaltkreis-Transpilationen und wählt diejenige aus, die die QPU-Zeit minimiert. Beispielsweise könnten alternative Transpilationen Qedma-optimierte RZZ-Gates mit gebrochenen Winkeln verwenden, um die Schaltkreistiefe zu reduzieren. Natürlich sind alle Transpilationen äquivalent zum Eingangsschaltkreis hinsichtlich ihrer idealen Ausgabe. Um mehr Kontrolle über die Schaltkreis-Transpilation zu haben, setze das Transpilationsniveau in den options. Während "transpilation_level": 1 dem oben beschriebenen Standardverhalten entspricht, beinhaltet "transpilation_level": 0 nur minimale Änderungen am ursprünglichen Schaltkreis; zum Beispiel die „Layerification" – die Organisation von Schaltkreisoperationen in Schichten simultaner Zwei-Qubit-Gates. Beachte, dass automatisches Hardware-Mapping auf hochfidelity Qubits in jedem Fall angewendet wird.

transpilation_level	Beschreibung
1	Standard-QESEM-Transpilation. Erstellt mehrere alternative Transpilationen und wählt diejenige aus, die die QPU-Zeit minimiert. Barriers können im Layerification-Schritt modifiziert werden.
0	Minimale Transpilation: der mitigierte Schaltkreis wird dem Eingangsschaltkreis strukturell ähnlich sein. Schaltkreise in Level 0 sollten der Gerätekonnektivität entsprechen und in folgenden Gates spezifiziert sein: CX, Rzz(α) und standardmäßige Einzel-Qubit-Gates (U, x, sx, rz usw.). Barriers werden im Layerification-Schritt respektiert.

• execution_mode – Der Nutzer kann wählen, den QESEM-Job entweder in einer dedizierten IBM-Session oder über mehrere IBM-Batches auszuführen:
  • Session-Modus: Sessions sind kostspieliger, führen aber zu kürzeren Wartezeiten bis zum Ergebnis. Sobald die Session beginnt, ist der QPU exklusiv für den QESEM-Job reserviert. Die Nutzungsberechnung umfasst sowohl die auf dem QPU verbrachte Zeit als auch die zugehörigen klassischen Berechnungen (durchgeführt von QESEM und IBM). Die QESEM Qiskit Function übernimmt das automatische Erstellen und Schließen der Session. Für Nutzer mit unbegrenztem Zugang zu QPUs (z. B. On-Premises-Setups) wird empfohlen, den Session-Modus für eine schnellere QESEM-Ausführung zu verwenden.
  • Batch-Modus: Im Batch-Modus wird der QPU während klassischer Berechnungen freigegeben, was zu geringerer QPU-Nutzung führt. Da Batch-Jobs typischerweise einen längeren Zeitraum umspannen, besteht ein höheres Risiko von Hardware-Drifts; QESEM enthält Maßnahmen zur Erkennung und Kompensation von Drifts und behält so die Zuverlässigkeit über ausgedehnte Ausführungen bei.

hinweis

Barrier-Operationen werden typischerweise verwendet, um die Schichten von Zwei-Qubit-Gates in Quantenschaltkreisen zu spezifizieren. In Level 0 bewahrt QESEM die durch Barriers spezifizierten Schichten. In Level 1 werden die durch Barriers spezifizierten Schichten als eine Transpilationsalternative bei der Minimierung der QPU-Zeit berücksichtigt.

Ausgaben

Die Ausgabe einer Circuit-Funktion ist ein PrimitiveResult, das zwei Felder enthält:

• Ein PubResult-Objekt. Es kann direkt aus dem PrimitiveResult indexiert werden.

• Metadaten auf Job-Ebene.

Jedes PubResult enthält ein data- und ein metadata-Feld.

• Das data-Feld enthält mindestens ein Array von Erwartungswerten (PubResult.data.evs) und ein Array von Standardfehlern (PubResult.data.stds). Je nach verwendeten Optionen kann es weitere Daten enthalten.

• Das metadata-Feld enthält Metadaten auf PUB-Ebene (PubResult.metadata).

Das folgende Code-Snippet zeigt, wie die QPU-Zeitschätzung abgerufen wird (wenn estimate_time_only gesetzt ist):

print(
    f"The estimated QPU time for this PUB is: \n{time_estimate_result[0].metadata}"
)

Das folgende Code-Snippet demonstriert, wie die Mitigationsergebnisse (wenn estimate_time_only nicht gesetzt ist) und Ausführungsmetriken abgerufen werden. Diese enthalten wesentliche Daten, die ein tieferes Verständnis davon ermöglichen, wie verschiedene Parameter die QESEM-Ausführung beeinflussen. Sie können auch relevant sein, wenn du einen Artikel auf Basis deiner Forschung verfasst.

results = result[0]
print(f"Mitigated expectation values: \n{results.data.evs}")
print(f"Mitigated error-bar: \n{results.data.stds}")
noisy_results = results.metadata["noisy_results"]
print(f"Noisy expectation values: \n{noisy_results.evs}")
print(f"Noisy error-bar: \n{noisy_results.stds}")
print(f"Total QPU time: \n {results.metadata['total_qpu_time']}")
print(
    f"Gates fidelity measured during the experiment: \n {results.metadata['gate_fidelities']}"
)
print(
    f"Total shots / mitigation shots: \n {results.metadata['total_shots']} / {results.metadata['mitigation_shots']}"
)
print("Transpiled circuits:")
for i, circuit in enumerate(results.metadata["transpiled_circs"]):
    print(f"Circuit {i}:")
    print(f"  Circuit: \n {circuit['circuit']}")
    print(f"  Qubit mapping: \n {circuit['qubit_map']}")
    print(f"  Measurement bases: \n {circuit['num_measurement_bases']}")

Fehlermeldungen abrufen

Wenn der Status deines Workloads ERROR ist, verwende job.result(), um die Fehlermeldung wie folgt abzurufen:

print(sample_job.result())

PrimitiveResult([PubResult(data=DataBin(), metadata={'time_estimation_sec': 12600})], metadata={})

Support erhalten

Das Qedma-Support-Team ist für dich da! Wenn du auf Probleme stößt oder Fragen zur Verwendung der QESEM Qiskit Function hast, zögere nicht, uns zu kontaktieren. Unser kompetentes und freundliches Support-Team steht dir bei technischen Anliegen oder Fragen jeder Art zur Verfügung.

Du kannst uns für Unterstützung unter support@qedma.com per E-Mail erreichen. Bitte gib so viele Details wie möglich zum aufgetretenen Problem an, damit wir dir schnell und präzise helfen können. Du kannst auch deinen dedizierten Qedma-POC-Ansprechpartner per E-Mail oder Telefon kontaktieren.

Um uns zu ermöglichen, dir effizienter zu helfen, stelle uns bitte folgende Informationen bereit, wenn du uns kontaktierst:

• Eine detaillierte Beschreibung des Problems
• Die Job-ID
• Alle relevanten Fehlermeldungen oder -codes

Wir sind bestrebt, dir prompten und effektiven Support zu bieten, damit du mit unserer Qiskit Function die bestmögliche Erfahrung machst.

Wir sind stets bestrebt, unser Produkt zu verbessern, und freuen uns über deine Vorschläge! Wenn du Ideen hast, wie wir unsere Dienste oder Features verbessern können, sende uns deine Gedanken an support@qedma.com

Nächste Schritte

Empfehlungen

• Zugang zu Qedma QESEM beantragen
• Lies Bauman, N. P., et al. (2025). Coupled Cluster Downfolding Theory in Simulations of Chemical Systems on Quantum Hardware. arXiv preprint arXiv:2507.01199.
• Lies Aharonov, D., et al. (2025). Reliable high-accuracy error mitigation for utility-scale quantum circuits. arXiv preprint arXiv:2508.10997.