Eingaben und Ausgaben des Schätzers

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen, diese Versionen oder neuere zu verwenden.

  qiskit[all]~=2.5.2
  qiskit-ibm-runtime~=0.47.0
  

Diese Seite bietet einen Überblick über die Ein- und Ausgänge der „ IBM Quantum “-Estimator-Primitive, die Workloads auf Rechenressourcen von „ IBM Quantum® “ ausführt. Mit Estimator können Sie vektorisierte Workloads mithilfe einer Datenstruktur namens „Primitive Unified Bloc“ ( PUB ) effizient definieren. Sie dienen als Eingaben für die Methode run() der „Estimator“-Primitive, die die definierte Arbeitslast als Job ausführt. Nachdem der Auftrag abgeschlossen ist, werden die Ergebnisse in einem Format zurückgegeben, das sowohl von den verwendeten PUBs als auch von den in der Primitive angegebenen Laufzeitoptionen abhängt.

Eingaben

Jede „ PUB “-Datei hat dieses Format:

(<single circuit>, <one or more observables>, <optional one or more parameter values>, <optional precision>),

Der optionale parameter values Parameter kann eine Liste oder ein einzelner Parameter sein. Elemente aus Observables und Parameterwerten werden gemäß den im Abschnitt „Primitive Eingaben und Ausgaben“ beschriebenen Broadcasting-Regeln für „ NumPy “ kombiniert, und für jedes Element der übertragenen Form wird eine Schätzung des Erwartungswerts zurückgegeben.

Bei der Primitive „Estimator“ kann ein „ PUB “ höchstens vier Werte enthalten:

• Ein Einzelobjekt QuantumCircuit, das ein oder mehrere Parameter Objekte enthalten kann
• Eine Liste aus einer oder mehreren Observablen, die die zu schätzenden Erwartungswerte angeben und in einem Array angeordnet sind (beispielsweise wird eine einzelne Observable als 0-d-Array dargestellt, eine Liste von Observablen als 1-d-Array usw.). Die Daten können in einem der folgenden ObservablesArrayLike Formate vorliegen: Pauli SparsePauliOp, PauliList,, oder str.
  Beobachtbare Pendlerdaten

  • Mit dieser Methode werden pendelnde Observables im selben PUB gruppiert.
  • Beobachtungsgrößen für den Pendelverkehr in verschiedenen PUBs werden nicht anhand derselben Messung geschätzt, selbst wenn sie denselben Schaltkreis haben. Jedes „ PUB “ stellt eine andere Bewertungsgrundlage dar, weshalb für jedes „ PUB “ separate Bewertungen erforderlich sind.
  • Um sicherzustellen, dass die Pendlerdaten anhand derselben Messung geschätzt werden, gruppieren Sie sie innerhalb desselben „ PUB “.
• Eine Sammlung von Parameterwerten, an die die Schaltung angepasst werden soll. Dies kann als einzelnes array-ähnliches Objekt angegeben werden, wobei der letzte Index die Anzahl der Parameter Schaltungsobjekte angibt, oder weggelassen werden (bzw. auf Nonegesetzt werden), wenn die Schaltung keine Parameter Objekte enthält.
• (Optional) Eine Zielgenauigkeit für die zu schätzenden Erwartungswerte

Der folgende Code zeigt ein Beispiel für eine Reihe vektorisierter Eingaben für die Estimator Primitive und führt diese auf einem „ IBM® “-Backend als ein einziges RuntimeJobV2 Objekt aus.

from qiskit.circuit import (
    Parameter,
    QuantumCircuit,
)
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp

from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator

import numpy as np

# Instantiate runtime service and get
# the least busy backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Define a circuit with two parameters.
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.ry(Parameter("a"), 0)
circuit.rz(Parameter("b"), 0)
circuit.cx(0, 1)
circuit.h(0)

# Transpile the circuit
pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
transpiled_circuit = pm.run(circuit)
layout = transpiled_circuit.layout

# Now define a sweep over parameter values, the last axis of dimension 2 is
# for the two parameters "a" and "b"
params = np.vstack(
    [
        np.linspace(-np.pi, np.pi, 100),
        np.linspace(-4 * np.pi, 4 * np.pi, 100),
    ]
).T

# Define three observables. The inner length-1 lists cause this array of
# observables to have shape (3, 1), rather than shape (3,) if they were
# omitted.
observables = [
    [SparsePauliOp(["XX", "IY"], [0.5, 0.5])],
    [SparsePauliOp("XX")],
    [SparsePauliOp("IY")],
]
# Apply the same layout as the transpiled circuit.
observables = [
    [observable.apply_layout(layout) for observable in observable_set]
    for observable_set in observables
]

# Estimate the expectation value for all 300 combinations of observables
# and parameter values, where the pub result will have shape (3, 100).
#
# This shape is due to our array of parameter bindings having shape
# (100, 2), combined with our array of observables having shape (3, 1).
estimator_pub = (transpiled_circuit, observables, params)

# Instantiate the new Estimator object, then run the transpiled circuit
# using the set of parameters and observables.
estimator = Estimator(mode=backend)
job = estimator.run([estimator_pub])
result = job.result()

Ausgaben

Nachdem ein oder mehrere PUBs zur Ausführung an eine QPU gesendet wurden und ein Job erfolgreich abgeschlossen wurde, werden die Daten als PrimitiveResult Containerobjekt zurückgegeben, auf das durch Aufruf der RuntimeJobV2.result() Methode zugegriffen wird.

Das PrimitiveResult enthält eine iterierbare Liste von PubResult Objekten, die die Ausführungsergebnisse für jeden PUB enthalten.

Jedes Element dieser Liste entspricht einem einzelnen „ PUB “, das an die Methode run() der Primitive übergeben wurde (ein Job, der beispielsweise mit 20 PUBs übergeben wurde, gibt ein PrimitiveResult Objekt zurück, das eine Liste mit 20 PubResult Objekten enthält, wobei jedes Objekt einem einzelnen „ PUB “ entspricht).

Jede PubResult für die Estimator-Primitive enthält mindestens ein Array mit Erwartungswerten (PubResult.data.evs) und den zugehörigen Standardabweichungen (entweder PubResult.data.stds oder, PubResult.data.ensemble_standard_error je nach dem resilience_level verwendeten ), kann aber je nach den angegebenen Optionen zur Fehlerminderung weitere Daten enthalten.

Jedes PubResult Objekt verfügt sowohl über ein data als auch über ein metadata Attribut.

• Das data Attribut ist ein benutzerdefiniertes DataBin Feld, das die tatsächlichen Messwerte, Standardabweichungen usw. enthält.
• Die DataBin verfügt über verschiedene Attribute, die von der Form oder Struktur des zugehörigen „ PUB “ sowie von den Optionen zur Fehlerbehebung abhängen, die durch die zur Übermittlung des Auftrags verwendete Primitive festgelegt wurden (z. B. ZNE oder PEC ).
• Das metadata Attribut enthält Informationen zur Laufzeit und zu den verwendeten Optionen zur Fehlerbehebung (dies wird später im Abschnitt „Ergebnis-Metadaten“ auf dieser Seite erläutert).

Im Folgenden finden Sie eine grafische Darstellung der PrimitiveResult Datenstruktur für die Ausgabe des Schätzers:

└── PrimitiveResult
    ├── PubResult[0]
    │   ├── metadata
    │   └── data  ## In the form of a DataBin object
    │       ├── evs
    │       │   └── List of estimated expectation values in the shape
    |       |         specified by the first pub
    │       └── stds
    │           └── List of calculated standard deviations in the
    |                 same shape as above
    ├── PubResult[1]
    |   ├── metadata
    |   └── data  ## In the form of a DataBin object
    |       ├── evs
    |       │   └── List of estimated expectation values in the shape
    |       |        specified by the second pub
    |       └── stds
    |           └── List of calculated standard deviations in the
    |                same shape as above
    ├── ...
    ├── ...
    └── ...

Einfach ausgedrückt: Eine einzelne Funktion gibt ein PrimitiveResult Objekt zurück und enthält eine Liste mit einem oder mehreren PubResult Objekten. Diese PubResult Objekte speichern dann die Messdaten für jeden „ PUB “, der an den Job übermittelt wurde.

Der folgende Codeausschnitt beschreibt das Format PrimitiveResult (und die zugehörigen Elemente PubResult) für den oben erstellten Auftrag.

print(
    f"The result of the submitted job had {len(result)} "
    f"PUBs and has a value:\n {result}\n"
)
print(
    "The associated PubResult of this job has the following data bins:\n "
    "{result[0].data}\n"
)
print(f"And this DataBin has attributes: {result[0].data.keys()}")
print(
    "Recall that this shape is due to our array of parameter binding sets"
    "having shape (100, 2), where 2 is the number of parameters in the "
    "circuit, combined with our array of observables having shape (3, 1). \n"
)
with np.printoptions(threshold=200):
    print(
        "The expectation values measured from this PUB are: \n"
        "{result[0].data.evs}\n"
    )

Output:

The result of the submitted job had 1 PUBs and has a value:
 PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(3, 100), dtype=float64>), stds=np.ndarray(<shape=(3, 100), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(3, 100), dtype=float64>), shape=(3, 100)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})

The associated PubResult of this job has the following data bins:
 {result[0].data}

And this DataBin has attributes: dict_keys(['evs', 'stds', 'ensemble_standard_error'])
Recall that this shape is due to our array of parameter binding setshaving shape (100, 2), where 2 is the number of parameters in the circuit, combined with our array of observables having shape (3, 1). 

The expectation values measured from this PUB are: 
{result[0].data.evs}

Wie die Estimator-Primitive den Fehler berechnet

Neben der Schätzung des Mittelwerts der in den Eingabe-PUBs übergebenen Observablen (dem evs Feld von DataBin) versucht der Schätzer auch, eine Schätzung des mit diesen Erwartungswerten verbundenen Fehlers zu liefern. Alle Abfragen im Estimator füllen das stds Feld mit einem Wert wie dem Standardfehler des Mittelwerts für jeden Erwartungswert, doch einige Optionen zur Fehlerminderung liefern zusätzliche Informationen, wie zum Beispiel ensemble_standard_error.

Betrachten wir eine einzelne beobachtbare Größe $\mathcal{O}$. Ohne ZNE kann man sich jeden Durchlauf der Schätzerausführung so vorstellen, dass er eine Punktschätzung des Erwartungswerts $\langle \mathcal{O} \rangle$ liefert. Liegen die Punktschätzungen in einem Vektor Os, so entspricht der ensemble_standard_error in zurückgegebene Wert dem Folgenden (wobei $\sigma_{\mathcal{O}}$ die Standardabweichung der Erwartungswertschätzung und $N_{shots}$ die Anzahl der Durchläufe ist):

$\frac{ \sigma_{\mathcal{O}} }{ \sqrt{N_{shots}} },$

das alle Aufnahmen als Teil eines einzigen Ensembles behandelt. Wenn Sie „Gate Twirling“ (twirling.enable_gates = True) angefordert haben, können Sie die punktweisen Schätzungen von $\langle \mathcal{O} \rangle$ in Gruppen sortieren, die einen gemeinsamen Twirl aufweisen. Bezeichnen wir diese Schätzungssätze O_twirlsals und es gibt num_randomizations (Anzahl der Drehungen) davon. Dann stds ist der Standardfehler des Mittelwerts von O_twirls, wie in

$\frac{ \sigma_{\mathcal{O}} }{ \sqrt{N_{twirls}} },$

wobei $\sigma_{\mathcal{O}}$ die Standardabweichung von O_twirls und $N_{twirls}$ die Anzahl der Drehungen ist. Wenn Sie das Drehen nicht aktivieren, sind stds ensemble_standard_error und gleich.

Wenn Sie ZNE aktivieren, werden die oben stds beschriebenen Werte zu Gewichten in einer nichtlinearen Regression für ein Extrapolationsmodell. Was in diesem stds Fall schließlich zurückgegeben wird, ist die Unsicherheit des Anpassungsmodells, bewertet bei einem Rauschfaktor von Null. Wenn die Anpassung schlecht ist oder große Unsicherheiten bei der Anpassung bestehen, kann der stds angegebene Wert sehr groß werden. Wenn ZNE aktiviert ist, werden pub_result.data.evs_noise_factors auch pub_result.data.stds_noise_factors und ausgefüllt, sodass Sie Ihre eigene Hochrechnung vornehmen können.

Metadaten zum Ergebnis

Zusätzlich zu den Ausführungsergebnissen enthalten sowohl das PrimitiveResult als auch PubResult das Objekt ein Metadatenattribut zu dem übermittelten Auftrag. Die Metadaten, die Informationen zu allen eingereichten PUBs enthalten (wie beispielsweise die verschiedenen verfügbaren Laufzeitoptionen ), finden Sie in der PrimitiveResult.metatada, während die für jede einzelne „ PUB “ spezifischen Metadaten in der zu finden PubResult.metadata sind.

# Print out the results metadata
print("The metadata of the PrimitiveResult is:")
for key, val in result.metadata.items():
    print(f"'{key}' : {val},")

print("\nThe metadata of the PubResult result is:")
for key, val in result[0].metadata.items():
    print(f"'{key}' : {val},")

Output:

The metadata of the PrimitiveResult is:
'dynamical_decoupling' : {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'},
'twirling' : {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'},
'resilience' : {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False},
'version' : 2,

The metadata of the PubResult result is:
'shots' : 4096,
'target_precision' : 0.015625,
'circuit_metadata' : {},
'resilience' : {},
'num_randomizations' : 32,