Mga input at output ng Estimator

Mga bersyon ng package

Ang code sa pahinang ito ay binuo gamit ang mga sumusunod na kinakailangan. Inirerekumenda naming gamitin ang mga bersyong ito o mas bago.

qiskit[all]~=2.4.0
qiskit-ibm-runtime~=0.46.1

Ang pahinang ito ay nagbibigay ng pangkalahatang-ideya ng mga input at output ng Qiskit Runtime Estimator primitive, na nagpapatupad ng mga workload sa mga compute resource ng IBM Quantum®. Binibigyang-daan ka ng Estimator na mahusay na tumukoy ng mga vectorized na workload sa pamamagitan ng paggamit ng isang istraktura ng data na tinatawag na Primitive Unified Bloc (PUB). Ginagamit ang mga ito bilang mga input sa method na run() para sa Estimator primitive, na nagpapatupad ng tinukoy na workload bilang isang job. Pagkatapos, pagkatapos makumpleto ang job, ang mga resulta ay ibinabalik sa isang format na nakasalalay sa parehong mga PUB na ginamit pati na rin sa mga runtime option na tinukoy mula sa primitive.

Mga input

Ang bawat PUB ay nasa format na ito:

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

Ang opsyonal na parameter values ay maaaring isang listahan o isang solong parameter. Ang mga elemento mula sa mga observable at mga halaga ng parameter ay pinagsama sa pamamagitan ng pagsunod sa mga panuntunan ng NumPy broadcasting tulad ng inilarawan sa paksa ng Mga input at output ng primitive, at isang tinatantyang expectation value ang ibinabalik para sa bawat elemento ng broadcasted na hugis.

impormasyon

Kung ang input ay naglalaman ng mga sukat, ang mga ito ay binabalewala.

Para sa Estimator primitive, ang isang PUB ay maaaring maglaman ng hindi hihigit sa apat na halaga:

Isang solong QuantumCircuit, na maaaring maglaman ng isa o higit pang mga object na Parameter
Isang listahan ng isa o higit pang mga observable, na nagtatakda ng mga expectation value na tatantiyahin, na nakaayos sa isang array (halimbawa, isang solong observable na kinakatawan bilang isang 0-d array, isang listahan ng mga observable bilang isang 1-d array, at iba pa). Ang data ay maaaring nasa anumang isa sa mga format na ObservablesArrayLike tulad ng Pauli, SparsePauliOp, PauliList, o str.
Mga commuting observable
- Ang mga commuting observable sa parehong PUB ay pinagsama gamit ang pamamaraang ito.
- Ang mga commuting observable sa iba't ibang PUB, kahit na mayroon silang parehong circuit, ay hindi tinatantya gamit ang parehong sukat. Ang bawat PUB ay kumakatawan sa isang iba't ibang batayan para sa sukat, at samakatuwid, kinakailangan ang mga hiwalay na sukat para sa bawat PUB.
- Para tiyaking ang mga commuting observable ay tinatantya gamit ang parehong sukat, grupuhin ang mga ito sa loob ng parehong PUB.
Isang koleksyon ng mga halaga ng parameter para i-bind ang circuit laban sa. Maaari itong tukuyin bilang isang solong array-like na object kung saan ang huling index ay sa mga object na Parameter ng circuit o tinanggal (o katumbas, itinakda sa None) kung ang circuit ay walang mga object na Parameter.
(Opsyonal) Isang target na katumpakan para sa mga expectation value na tatantiyahin

Ang sumusunod na code ay nagpapakita ng isang halimbawang set ng mga vectorized na input sa primitive na Estimator at isinasagawa ang mga ito sa isang IBM® backend bilang isang solong object na RuntimeJobV2.

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

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,
    EstimatorV2 as 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()

Mga output

Pagkatapos maipadala ang isa o higit pang PUB sa isang QPU para sa execution at matagumpay na makumpleto ang isang job, ang data ay ibinabalik bilang isang container object na PrimitiveResult na na-access sa pamamagitan ng pagtawag sa method na RuntimeJobV2.result().

Ang PrimitiveResult ay naglalaman ng isang iterable na listahan ng mga object na PubResult na naglalaman ng mga resulta ng execution para sa bawat PUB.

Ang bawat elemento ng listahang ito ay tumutugma sa bawat PUB na isinumite sa method na run() ng primitive (halimbawa, ang isang job na isinumite na may 20 PUB ay magbabalik ng isang object na PrimitiveResult na naglalaman ng listahan ng 20 object na PubResult, isa na tumutugma sa bawat PUB).

Ang bawat PubResult para sa Estimator primitive ay naglalaman ng kahit isang array ng mga expectation value (PubResult.data.evs) at mga kaugnay na standard deviation (alinman sa PubResult.data.stds o PubResult.data.ensemble_standard_error depende sa resilience_level na ginamit), ngunit maaari itong maglaman ng higit pang data depende sa mga opsyon ng error mitigation na tinukoy.

Ang bawat object na PubResult ay nagtataglay ng parehong attribute na data at metadata.

Ang attribute na data ay isang customized na DataBin na naglalaman ng aktwal na mga halaga ng sukat, mga standard deviation, at iba pa.
Ang DataBin ay may iba't ibang attribute depende sa hugis o istruktura ng kaugnay na PUB pati na rin sa mga opsyon ng error mitigation na tinukoy ng primitive na ginamit para isumite ang job (halimbawa, ZNE o PEC).
Ang attribute na metadata ay naglalaman ng impormasyon tungkol sa mga opsyon ng runtime at error mitigation na ginamit (na ipinaliwanag sa ibang pagkakataon sa seksyon ng Metadata ng resulta ng pahinang ito).

Ang sumusunod ay isang visual na balangkas ng istraktura ng data ng PrimitiveResult para sa output ng Estimator:

└── 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
    ├── ...
    ├── ...
    └── ...

Sa simpleng salita, ang isang job ay nagbabalik ng isang object na PrimitiveResult at naglalaman ng listahan ng isa o higit pang object na PubResult. Ang mga object na PubResult na ito ay nag-iimbak ng data ng sukat para sa bawat PUB na isinumite sa job.

Ang sumusunod na snippet ng code ay naglalarawan ng format ng PrimitiveResult (at kaugnay na PubResult) para sa job na nilikha sa itaas.

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"
    )

The result of the submitted job had 1 PUB 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:
 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))

And this DataBin has attributes: dict_keys(['evs', 'stds', 'ensemble_standard_error'])
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: 
[[-0.00369065  0.15107692  0.30110431 ... -0.30159536 -0.15431523
   0.00576586]
 [ 0.00601655  0.04412133  0.1253447  ... -0.12434194 -0.04662823
   0.01153171]
 [-0.01339784  0.2580325   0.47686391 ... -0.47884878 -0.26200223
   0.        ]]

Kung paano kinakalkula ng Estimator primitive ang error

Bukod sa tinatantyang mean ng mga observable na ipinasa sa mga input PUB (ang field na evs ng DataBin), sinisikap din ng Estimator na maghatid ng tinatantya ng error na nauugnay sa mga expectation value na iyon. Ang lahat ng query ng Estimator ay magpupuno ng field na stds na may isang dami na katulad ng standard error ng mean para sa bawat expectation value, ngunit ang ilang opsyon ng error mitigation ay nagpo-produce ng karagdagang impormasyon, tulad ng ensemble_standard_error.

Isaalang-alang ang isang solong observable na $\mathcal{O}$ . Sa kawalan ng ZNE, maaari mong isipin ang bawat shot ng Estimator execution bilang nagbibigay ng isang point estimate ng expectation value na $\langle \mathcal{O} \rangle$ . Kung ang mga pointwise estimate ay nasa isang vector na Os, ang halagang ibinabalik sa ensemble_standard_error ay katumbas ng sumusunod (kung saan ang $\sigma_{\mathcal{O}}$ ay ang standard deviation ng expectation value estimate at ang $N_{shots}$ ay ang bilang ng mga shot):

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

na tinatrato ang lahat ng shot bilang bahagi ng isang solong ensemble. Kung humiling ka ng gate twirling (twirling.enable_gates = True), maaari mong pagbukud-bukurin ang mga pointwise estimate ng $\langle \mathcal{O} \rangle$ sa mga set na nagbabahagi ng karaniwang twirl. Tawagan ang mga set ng mga estimate na ito na O_twirls, at mayroong num_randomizations (bilang ng mga twirl) ng mga ito. Kung gayon ang stds ay ang standard error ng mean ng O_twirls, tulad ng

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

kung saan ang $\sigma_{\mathcal{O}}$ ay ang standard deviation ng O_twirls at ang $N_{twirls}$ ay ang bilang ng mga twirl. Kapag hindi mo pinagana ang twirling, ang stds at ensemble_standard_error ay pantay.

Kung pine-enable mo ang ZNE, ang stds na inilarawan sa itaas ay nagiging mga timbang sa isang non-linear regression sa isang extrapolator model. Ang sa wakas ay ibinabalik sa stds sa kasong ito ay ang kawalan ng katiyakan ng fit model na sinusuri sa noise factor na zero. Kapag mayroon pang masamang fit, o malaking kawalan ng katiyakan sa fit, ang na-report na stds ay maaaring maging napaka-malaki. Kapag pinagana ang ZNE, ang pub_result.data.evs_noise_factors at pub_result.data.stds_noise_factors ay napupuno rin, para maaari kang gumawa ng sarili mong extrapolation.

Metadata ng resulta

Bukod sa mga resulta ng execution, parehong ang mga object na PrimitiveResult at PubResult ay naglalaman ng isang attribute ng metadata tungkol sa job na isinumite. Ang metadata na naglalaman ng impormasyon para sa lahat ng isinumiteng PUB (tulad ng iba't ibang mga opsyon ng runtime na available) ay matatagpuan sa PrimitiveResult.metatada, habang ang metadata na tukoy sa bawat PUB ay matatagpuan sa PubResult.metadata.

tala

Sa field ng metadata, ang mga implementasyon ng primitive ay maaaring magbalik ng anumang impormasyon tungkol sa execution na may kaugnayan sa kanila, at walang mga pares ng key-value na ginagarantiyahan ng base primitive. Kaya, ang ibinalik na metadata ay maaaring iba sa iba't ibang implementasyon ng primitive.

# 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},")

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,

Mga input​

Mga output​

Kung paano kinakalkula ng Estimator primitive ang error​

Metadata ng resulta​

Mga input

Mga output

Kung paano kinakalkula ng Estimator primitive ang error

Metadata ng resulta