Primitive Eingaben und Ausgaben

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

  qiskit[all]~=2.5.2
  

Diese Seite bietet einen Überblick über die Ein- und Ausgänge der Primitive „ Qiskit SDK “. Mit diesen Primitiven können Sie eine als „Primitive Unified Bloc“ ( PUB ) bezeichnete Datenstruktur nutzen, um vektorisierte Workloads effizient zu definieren. Diese PUBs sind die grundlegende Arbeitseinheit für die Ausführung von Workloads. Sie dienen als Eingaben für die Methode run() der Primitive „Sampler“ und „Estimator“, die die definierte Arbeitslast als Job ausführen. Nach Abschluss des Auftrags werden die Ergebnisse in einem Format zurückgegeben, das von den verwendeten PUBs und den gegebenenfalls angegebenen Optionen abhängt.

Übersicht über PUBs

Beim Aufruf einer Methode run() einer Primitive ist das wichtigste erforderliche Argument ein Array list aus einem oder mehreren Tupeln – eines für jeden Schaltkreis, der von der Primitive ausgeführt wird. Jedes dieser Tupel wird als „ PUB “ betrachtet, und die erforderlichen Elemente jedes Tupels in der Liste hängen von der verwendeten Primitivtyp ab. Die diesen Tupeln zugeführten Daten können zudem in verschiedenen Formen angeordnet werden, um durch Broadcasting Flexibilität bei der Arbeitslast zu gewährleisten – die Regeln hierfür werden in einem späteren Abschnitt beschrieben.

Schätzer PUB

Für das Primitiv Estimator sollte das Format von PUB höchstens vier Werte enthalten:

• Eine einzelne QuantumCircuit, die ein oder mehrere Objekte enthalten kann Parameter objekte enthalten kann
• Eine Liste von einer oder mehreren Beobachtungswerten, die die zu schätzenden Erwartungswerte angeben und in einem Array angeordnet sind (z. B. eine einzelne Beobachtungsgröße, die als 0-d-Array dargestellt wird, eine Liste von Beobachtungsgrößen als 1-d-Array und so weiter). Die Daten können in einem der Formate ObservablesArrayLike wie Pauli, SparsePauliOp, PauliList oder str vorliegen.
  Note

  Wenn Sie zwei Pendelbeobachtungen in verschiedenen PUBs, aber mit demselben Schaltkreis haben, werden diese nicht anhand derselben Messung geschätzt. Jede PUB stellt eine andere Messgrundlage dar, weshalb für jede PUB separate Messungen erforderlich sind. Um sicherzustellen, dass die Pendler-Beobachtungsgrößen anhand derselben Messung geschätzt werden, müssen sie innerhalb derselben „ PUB ” gruppiert werden.

• Eine Sammlung von Parameterwerten, an die der Stromkreis gebunden werden soll. Dies kann als einzelnes Array-ähnliches Objekt angegeben werden, wobei der letzte Index über die Parameter Objekte des Stromkreises ist, oder weggelassen (oder gleichwertig auf None gesetzt) werden, wenn der Stromkreis keine Parameter Objekte hat.
• (Optional) eine Zielgenauigkeit für die zu schätzenden Erwartungswerte

Sampler- PUB

Für das Sampler-Primitiv enthält das Format des Tupels PUB höchstens drei Werte:

• Ein Einzelobjekt QuantumCircuit, das ein oder mehrere Parameter Objekte enthalten kann Hinweis: Diese Schaltungen müssen außerdem Messanweisungen für jedes der zu messenden Qubits enthalten.
• Eine Sammlung von Parameterwerten zur Bindung der Schaltung an $\theta_k$ (nur erforderlich, wenn Parameter Objekte verwendet werden, die zur Laufzeit gebunden werden müssen)
• (Optional) eine Anzahl von Schüssen zur Messung des Stromkreises mit

Der folgende Code zeigt ein Beispiel für vektorisierte Eingaben für die Estimator Primitive.

from qiskit.circuit import (
    Parameter,
    QuantumCircuit,
    ClassicalRegister,
    QuantumRegister,
)
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives.containers import BitArray
from qiskit.primitives import StatevectorEstimator


import numpy as np

# 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 without providing a backend
pm = generate_preset_pass_manager(optimization_level=1)
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, 10),
        np.linspace(-4 * np.pi, 4 * np.pi, 10),
    ]
).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 = StatevectorEstimator()
estimator_pub = (transpiled_circuit, observables, params)

# Run the transpiled circuit
# using the set of parameters and observables.

job = estimator.run([estimator_pub])
result = job.result()

Rundfunkvorschriften

Die PUBs aggregieren Elemente aus mehreren Arrays (Observablen und Parameterwerte), indem sie denselben Übertragungsregeln folgen wie NumPy. In diesem Abschnitt werden diese Regeln kurz zusammengefasst. Eine ausführliche Erklärung finden Sie in der Dokumentation NumPy broadcasting rules.

Regeln:

• Die Eingabefelder müssen nicht die gleiche Anzahl von Dimensionen haben.
  • Das resultierende Array hat die gleiche Anzahl von Dimensionen wie das Eingabe-Array mit der größten Dimension.
  • Die Größe der einzelnen Dimensionen ist die größte Größe der entsprechenden Dimension.
  • Bei fehlenden Abmessungen wird angenommen, dass sie die Größe eins haben.
• Formvergleiche beginnen mit der ganz rechten Dimension und setzen sich nach links fort.
• Zwei Dimensionen sind kompatibel, wenn ihre Größen gleich sind oder wenn eine der beiden Dimensionen 1 ist.

Beispiele für Array-Paare, die senden:

A1     (1d array):      1
A2     (2d array):  3 x 5
Result (2d array):  3 x 5


A1     (3d array):  11 x 2 x 7
A2     (3d array):  11 x 1 x 7
Result (3d array):  11 x 2 x 7

Beispiele für Array-Paare, die nicht übertragen werden:

A1     (1d array):  5
A2     (1d array):  3

A1     (2d array):      2 x 1
# The following would work if the middle dimension were 2,
# instead of 5.
A2     (3d array):  6 x 5 x 4

Estimator gibt für jedes Element der übertragenen Form eine Schätzung des Erwartungswerts zurück.

Hier sind einige Beispiele für gängige Muster, die in Form von Array-Übertragungen ausgedrückt werden. Die dazugehörige visuelle Darstellung ist in der folgenden Abbildung zu sehen:

Parameterwertsätze werden durch n x m Arrays dargestellt, und beobachtbare Arrays werden durch eine oder mehrere einspaltige Arrays dargestellt. Für jedes Beispiel im vorangegangenen Code werden die Parameterwertsätze mit dem jeweiligen Beobachtungsfeld kombiniert, um die resultierenden Erwartungswertschätzungen zu erstellen.

• Beispiel 1 : (broadcast single observable) hat einen Parameterwertsatz, der ein Array 5x1 und ein Array 1x1 observables ist. Das eine Element im Beobachtungswerte-Array wird mit jedem Element im Parameterwertsatz kombiniert, um ein einziges 5x1 -Array zu erstellen, in dem jedes Element eine Kombination aus dem ursprünglichen Element im Parameterwertsatz und dem Element im Beobachtungswerte-Array ist.

• Beispiel 2 : (zip) hat einen 5x1 Parameterwertsatz und ein 5x1 Observables-Array. Die Ausgabe ist ein Array 5x1, in dem jedes Element eine Kombination aus dem n-ten Element im Parameterwertsatz und dem n-ten Element im Array Observables ist.

• Beispiel 3 : (outer/product) hat einen 1x6 Parameterwertsatz und ein 4x1 Observables-Array. Ihre Kombination führt zu einem Array 4x6, das durch Kombination jedes Elements im Parameterwertsatz mit jedem Element im Array Observables erstellt wird, so dass jeder Parameterwert zu einer ganzen Spalte in der Ausgabe wird.

• Beispiel 4 : (Standard- und Verallgemeinerung) hat ein Array mit 3x6 Parameterwerten und zwei Arrays mit 3x1 Beobachtungswerten. Diese werden kombiniert, um zwei 3x6 Ausgabefelder in ähnlicher Weise wie im vorherigen Beispiel zu erstellen.

# Broadcast single observable
parameter_values = np.random.uniform(size=(5,))  # shape (5,)
observables = SparsePauliOp("ZZZ")  # shape ()
# >> pub result has shape (5,)

# Zip
parameter_values = np.random.uniform(size=(5,))  # shape (5,)
observables = [
    SparsePauliOp(pauli) for pauli in ["III", "XXX", "YYY", "ZZZ", "XYZ"]
]  # shape (5,)
# >> pub result has shape (5,)

# Outer/Product
parameter_values = np.random.uniform(size=(1, 6))  # shape (1, 6)
observables = [
    [SparsePauliOp(pauli)] for pauli in ["III", "XXX", "YYY", "ZZZ"]
]  # shape (4, 1)
# >> pub result has shape (4, 6)

# Standard nd generalization
parameter_values = np.random.uniform(size=(3, 6))  # shape (3, 6)
observables = [
    [
        [SparsePauliOp(["XII"])],
        [SparsePauliOp(["IXI"])],
        [SparsePauliOp(["IIX"])],
    ],
    [
        [SparsePauliOp(["ZII"])],
        [SparsePauliOp(["IZI"])],
        [SparsePauliOp(["IIZ"])],
    ],
]  # shape (2, 3, 1)
# >> pub result has shape (2, 3, 6)

a = SparsePauliOp("Z") # shape ()
b = SparsePauliOp("IIIIZXYIZ") # shape ()
c = SparsePauliOp.from_list(["XX", "XY", "IZ"]) # shape ()

list1 = SparsePauliOp.from_list(["XX", "XY", "IZ"])
    # list1 has shape ()
list2 = [SparsePauliOp("XX"), SparsePauliOp("XY"), SparsePauliOp("IZ")]
    # list2 has shape (3, )

Übersicht über primitive Ausgaben

Sobald eine oder mehrere PUBs zur Ausführung an eine QPU gesendet wurden und ein Job erfolgreich abgeschlossen wurde, werden die Daten als PrimitiveResult Container-Objekt zurückgegeben. Das PrimitiveResult enthält eine iterierbare Liste von PubResult Objekten, die die Ausführungsergebnisse für jeden PUB enthalten. Wenn beispielsweise ein Job mit 20 PUBs übermittelt wird, wird ein PrimitiveResult Objekt zurückgegeben, das eine Liste mit 20 PubResultsElementen enthält, wobei jedes Element einem „ PUB “ entspricht.

Jedes dieser PubResult Objekte verfügt sowohl über ein data als auch über ein optionales metadata Attribut. Das data Attribut ist ein benutzerdefiniertes DataBin Feld, das im Fall des Schätzers die Schätzungen der Erwartungswerte und im Fall des Abtasters Stichproben des Schaltungsausgangs enthält.

Das data Attribut kann auch andere implementierungsspezifische Informationen enthalten, wie beispielsweise Standardabweichungen. Das metadata Attribut kann zusätzliche implementierungsspezifische Informationen über die Ausführung des zugehörigen „ PUB “ enthalten.

Nachfolgend finden Sie eine Übersicht über die Datenstruktur von PrimitiveResult :

└── PrimitiveResult
    ├── PubResult[0]
    │   ├── metadata
    │   └── data  ## In the form of a DataBin object,
    |       |     ## which includes data such as the following:
    │       ├── 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,
    |       |     ## which includes data such as the following:
    |       ├── 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
    ├── ...
    ├── ...
    └── ...

└── PrimitiveResult
    ├── PubResult[0]
    │   ├── metadata
    │   └── data  ## In the form of a DataBin object
    │       ├── NAME_OF_CLASSICAL_REGISTER
    │       │   └── BitArray of count data for first PUB (default is 'meas')
    |       |
    │       └── NAME_OF_ANOTHER_CLASSICAL_REGISTER
    │           └── BitArray of count data (exists only if more than one
    |                 ClassicalRegister was specified in the circuit)
    ├── PubResult[1]
    |   ├── metadata
    |   └── data  ## In the form of a DataBin object
    |       └── NAME_OF_CLASSICAL_REGISTER
    |           └── BitArray of count data for second PUB
    ├── ...
    ├── ...
    └── ...

Ausgabe des Schätzers

Wie bereits erwähnt, hängen die von PubResult der Estimator-Primitive zurückgegebenen Daten von der jeweiligen Implementierung ab. Beispielsweise könnte es ein Array aus Erwartungswerten (PubResult.data.evs) und den dazugehörigen Standardabweichungen (PubResult.data.stds) enthalten.

Der folgende Codeschnipsel beschreibt das Format PrimitiveResult (und das zugehörige PubResult) für den oben erstellten Auftrag.

print(
    f"The result of the submitted job had {len(result)} PUB and "
    f"has a value:\n {result}\n"
)
print(
    f"The associated PubResult of this job has the following data bins:"
    f"\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)."
)

print(
    f"The expectation values measured from this PUB are: \n{result[0].data.evs}"
)

Output:

The result of the submitted job had 1 PUB and has a value:
 PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(3, 10), dtype=float64>), stds=np.ndarray(<shape=(3, 10), dtype=float64>), shape=(3, 10)), metadata={'target_precision': 0.0, 'circuit_metadata': {}})], metadata={'version': 2})

The associated PubResult of this job has the following data bins:
 DataBin(evs=np.ndarray(<shape=(3, 10), dtype=float64>), stds=np.ndarray(<shape=(3, 10), dtype=float64>), shape=(3, 10))

And this DataBin has attributes: dict_keys(['evs', 'stds'])
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).
The expectation values measured from this PUB are: 
[[ 3.06161700e-16  4.52395120e-01  4.36594428e-01  2.16506351e-01
   6.33718361e-01 -6.33718361e-01 -2.16506351e-01 -4.36594428e-01
  -4.52395120e-01 -3.06161700e-16]
 [ 1.22464680e-16  6.42787610e-01  9.84807753e-01  8.66025404e-01
   3.42020143e-01 -3.42020143e-01 -8.66025404e-01 -9.84807753e-01
  -6.42787610e-01 -1.22464680e-16]
 [ 4.89858720e-16  2.62002630e-01 -1.11618897e-01 -4.33012702e-01
   9.25416578e-01 -9.25416578e-01  4.33012702e-01  1.11618897e-01
  -2.62002630e-01 -4.89858720e-16]]

Sampler-Ausgabe

Wenn ein Sampler-Job erfolgreich abgeschlossen wurde, enthält das zurückgegebene PrimitiveResult Objekt eine Liste von SamplerPubResults, eine pro PUB. Die Datenbehälter dieser SamplerPubResult Objekte sind diktatähnliche Objekte, die jeweils BitArray einen ClassicalRegister im Schaltkreis enthalten.

Die Klasse BitArray ist ein Container für geordnete Schussdaten. Genauer gesagt, speichert es die abgetasteten Bitstrings als Bytes in einem zweidimensionalen Array. Die linke Achse dieses Feldes verläuft über geordnete Schüsse, die rechte Achse über Bytes.

Betrachten wir als erstes Beispiel die folgende Zehn-Qubit-Schaltung:

from qiskit.primitives import StatevectorSampler

# generate a ten-qubit GHZ circuit
circuit = QuantumCircuit(10)
circuit.h(0)
circuit.cx(range(0, 9), range(1, 10))

# append measurements with the `measure_all` method
circuit.measure_all()

# transpile the circuit
transpiled_circuit = pm.run(circuit)

sampler = StatevectorSampler()

# run the Sampler job and retrieve the results

job = sampler.run([transpiled_circuit])
result = job.result()

# the data bin contains one BitArray
data = result[0].data
print(f"Databin: {data}\n")

# to access the BitArray, use the key "meas", which is the default name of
# the classical register when this is added by the `measure_all` method
array = data.meas
print(f"BitArray: {array}\n")
print(f"The shape of register `meas` is {data.meas.array.shape}.\n")
print(f"The bytes in register `alpha`, shot by shot:\n{data.meas.array}\n")

Output:

Databin: DataBin(meas=BitArray(<shape=(), num_shots=1024, num_bits=10>))

BitArray: BitArray(<shape=(), num_shots=1024, num_bits=10>)

The shape of register `meas` is (1024, 2).

The bytes in register `alpha`, shot by shot:
[[  3 255]
 [  0   0]
 [  3 255]
 ...
 [  0   0]
 [  3 255]
 [  0   0]]

Manchmal kann es praktisch sein, Daten aus dem Byte-Format in Bitstrings BitArray umzuwandeln. Die get_count Methode gibt ein Wörterbuch zurück, in dem Bitstrings der Häufigkeit ihres Auftretens zugeordnet sind.

# optionally convert the native BitArray format to a dictionary format
counts = data.meas.get_counts()
print(f"Counts: {counts}")

Output:

Counts: {'1111111111': 484, '0000000000': 540}

Wenn eine Schaltung mehr als ein klassisches Register enthält, werden die Ergebnisse in verschiedenen BitArray Objekten gespeichert. Das folgende Beispiel modifiziert den vorherigen Ausschnitt, indem es das klassische Register in zwei separate Register aufteilt:

# generate a ten-qubit GHZ circuit with two classical registers
circuit = QuantumCircuit(
    qreg := QuantumRegister(10),
    alpha := ClassicalRegister(1, "alpha"),
    beta := ClassicalRegister(9, "beta"),
)
circuit.h(0)
circuit.cx(range(0, 9), range(1, 10))

# append measurements with the `measure_all` method
circuit.measure([0], alpha)
circuit.measure(range(1, 10), beta)

# transpile the circuit
transpiled_circuit = pm.run(circuit)

# run the Sampler job and retrieve the results

job = sampler.run([transpiled_circuit])
result = job.result()

# the data bin contains two BitArrays, one per register, and can be accessed
# as attributes using the registers' names
data = result[0].data
print(f"BitArray for register 'alpha': {data.alpha}")
print(f"BitArray for register 'beta': {data.beta}")

Output:

BitArray for register 'alpha': BitArray(<shape=(), num_shots=1024, num_bits=1>)
BitArray for register 'beta': BitArray(<shape=(), num_shots=1024, num_bits=9>)

Nutzung von BitArray Objekten für eine performante Nachbearbeitung

Da Arrays im Vergleich zu Wörterbüchern in der Regel eine bessere Leistung bieten, ist es ratsam, die Nachbearbeitung direkt an den BitArray Objekten vorzunehmen und nicht an Wörterbüchern mit Zählungen. Die BitArray Klasse bietet eine Reihe von Methoden zur Durchführung einiger gängiger Nachbearbeitungsvorgänge:

print(f"The shape of register `alpha` is {data.alpha.array.shape}.")
print(f"The bytes in register `alpha`, shot by shot:\n{data.alpha.array}\n")

print(f"The shape of register `beta` is {data.beta.array.shape}.")
print(f"The bytes in register `beta`, shot by shot:\n{data.beta.array}\n")

# post-select the bitstrings of `beta` based on having sampled "1" in `alpha`
mask = data.alpha.array == "0b1"
ps_beta = data.beta[mask[:, 0]]
print(f"The shape of `beta` after post-selection is {ps_beta.array.shape}.")
print(f"The bytes in `beta` after post-selection:\n{ps_beta.array}")

# get a slice of `beta` to retrieve the first three bits
beta_sl_bits = data.beta.slice_bits([0, 1, 2])
print(
    f"The shape of `beta` after bit-wise slicing is {beta_sl_bits.array.shape}."
)
print(f"The bytes in `beta` after bit-wise slicing:\n{beta_sl_bits.array}\n")

# get a slice of `beta` to retrieve the bytes of the first five shots
beta_sl_shots = data.beta.slice_shots([0, 1, 2, 3, 4])
print(
    f"The shape of `beta` after shot-wise slicing is {beta_sl_shots.array.shape}."
)
print(
    f"The bytes in `beta` after shot-wise slicing:\n{beta_sl_shots.array}\n"
)

# calculate the expectation value of diagonal operators on `beta`
ops = [SparsePauliOp("ZZZZZZZZZ"), SparsePauliOp("IIIIIIIIZ")]
exp_vals = data.beta.expectation_values(ops)
for o, e in zip(ops, exp_vals):
    print(f"Exp. val. for observable `{o}` is: {e}")

# concatenate the bitstrings in `alpha` and `beta` to "merge" the results
# of the two registers
merged_results = BitArray.concatenate_bits([data.alpha, data.beta])
print(f"\nThe shape of the merged results is {merged_results.array.shape}.")
print(f"The bytes of the merged results:\n{merged_results.array}\n")

Output:

The shape of register `alpha` is (1024, 1).
The bytes in register `alpha`, shot by shot:
[[1]
 [1]
 [0]
 ...
 [1]
 [0]
 [1]]

The shape of register `beta` is (1024, 2).
The bytes in register `beta`, shot by shot:
[[  1 255]
 [  1 255]
 [  0   0]
 ...
 [  1 255]
 [  0   0]
 [  1 255]]

The shape of `beta` after post-selection is (0, 2).
The bytes in `beta` after post-selection:
[]
The shape of `beta` after bit-wise slicing is (1024, 1).
The bytes in `beta` after bit-wise slicing:
[[7]
 [7]
 [0]
 ...
 [7]
 [0]
 [7]]

The shape of `beta` after shot-wise slicing is (5, 2).
The bytes in `beta` after shot-wise slicing:
[[  1 255]
 [  1 255]
 [  0   0]
 [  0   0]
 [  1 255]]

Exp. val. for observable `SparsePauliOp(['ZZZZZZZZZ'],
              coeffs=[1.+0.j])` is: -0.02734375
Exp. val. for observable `SparsePauliOp(['IIIIIIIIZ'],
              coeffs=[1.+0.j])` is: -0.02734375

The shape of the merged results is (1024, 2).
The bytes of the merged results:
[[  3 255]
 [  3 255]
 [  0   0]
 ...
 [  3 255]
 [  0   0]
 [  3 255]]

Ergebnis-Metadaten

Zusätzlich zu den Ausführungsergebnissen enthalten die PrimitiveResult Objekte PubResult und ein optionales Metadatenattribut zu dem übermittelten Auftrag. Die zurückgegebenen Metadaten (sofern vorhanden) sind implementierungsspezifisch.

# 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:
'version' : 2,

The metadata of the PubResult result is:
'shots' : 1024,
'circuit_metadata' : {},

Nächste Schritte