Lumaktaw sa pangunahing nilalaman
Ang proyektong ito ay nasa beta. Nakakita ng bug? Mag-bukas ng GitHub issue. May tanong o ideya? Magtanong sa Discussions — gusto naming marinig ang iyong feedback!
Gaano kaganda ang kalidad ng pagsasalin sa pahinang ito?

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.5.2
qiskit-ibm-runtime~=0.47.0

Ang pahinang ito ay nagbibigay ng pangkalahatang-ideya ng mga input at output ng IBM Quantum 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 data structure 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. Kapag nakumpleto na ang job, ibinabalik ang mga resulta sa isang format na nakasalalay sa parehong mga PUB na ginamit pati na rin sa mga runtime option na itinakda 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 na ibi-bind sa circuit. 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

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

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")
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()

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 istruktura 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 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}

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 magbigay ng pagtatantya 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 O\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 ⟨O⟩\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 σO\sigma_{\mathcal{O}} ay ang standard deviation ng expectation value estimate at ang NshotsN_{shots} ay ang bilang ng mga shot):

σONshots,\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 ⟨O⟩\langle \mathcal{O} \rangle sa mga set na nagbabahagi ng karaniwang twirl. Tawagin nating O_twirls ang mga set ng estimate na ito, 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

σONtwirls,\frac{ \sigma_{\mathcal{O}} }{ \sqrt{N_{twirls}} },

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

Kung pinagana 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 hindi maganda ang 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.

Isinusumite ng client-side Estimator ang workload nito bilang job ng Executor. Ang metadata ng pinagbabatayang resulta ng Executor, na kinabibilangan ng impormasyon sa execution timing na tinatawag na execution spans, ay available sa ilalim ng key na "executor" ng PrimitiveResult.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,

Tingnan ang execution spans​

Tumatakbo ang client-side Estimator bilang Executor job, na nagpapatakbo ng gawain nito sa QPU sa mga chunk. Ang timing ng bawat chunk ay nasa result.metadata["executor"].chunk_timing, isang listahan ng mga object na ChunkSpan. Ang bawat ChunkSpan ay may mga timestamp na start at stop at isang listahan ng parts, kung saan ang bawat part ay nagbibigay ng item index (idx_item) at ang bilang ng mga configuration mula sa item na iyon (size) na tumakbo sa chunk.

Ang idx_item ay ang index ng isang item sa Executor program na binubuo ng Estimator mula sa iyong mga PUB. Hindi ito kinakailangang tumugma sa isang PUB index, dahil maaaring magdagdag ang Estimator ng mga program item, depende sa mga opsyon sa error mitigation. Halimbawa, nagdadagdag ito ng mga measurement-error calibration circuit kapag naka-enable ang TREX.

Para i-visualize ang mga timing, ipasa ang listahan sa draw_chunk_timings, tulad ng ipinapakita sa sumusunod na halimbawa.

Para malaman kung ano ang ibig sabihin ng mga chunk timestamp, kung paano basahin ang plot, at kung bakit maaaring lumitaw ang mga puwang sa pagitan ng mga chunk, tingnan ang View execution spans sa guide na Executor inputs and outputs.

from qiskit_ibm_runtime.visualization import draw_chunk_timings

# Note the "executor" key: the timing comes from the underlying Executor job
chunk_timing = result.metadata["executor"].chunk_timing

for idx, span in enumerate(chunk_timing):
    duration = (span.stop - span.start).total_seconds()
    print(f"Chunk {idx}: {span.start} to {span.stop} ({duration:.3f} s)")
    for part in span.parts:
        print(f"  Item {part.idx_item}: {part.size} configurations")

fig = draw_chunk_timings(chunk_timing, names="Estimator job")

# Uncomment the following line to display the figure
# fig.show(renderer="notebook")

# Save to a file
# fig.write_html("chunk_timings.html")
Chunk 0: 2026-11-06 01:39:01.509471+00:00 to 2026-11-06 01:39:35.171288+00:00 (33.662 s)
  Item 0: 800 configurations
  Item 1: 4 configurations
Chunk 1: 2026-11-06 01:39:48.299074+00:00 to 2026-11-06 01:40:21.826190+00:00 (33.527 s)
  Item 0: 800 configurations
  Item 1: 4 configurations
Chunk 2: 2026-11-06 01:40:22.855454+00:00 to 2026-11-06 01:40:53.781896+00:00 (30.926 s)
  Item 0: 800 configurations
  Item 1: 4 configurations
Chunk 3: 2026-11-06 01:40:54.993867+00:00 to 2026-11-06 01:41:26.068319+00:00 (31.074 s)
  Item 0: 800 configurations
  Item 1: 4 configurations
Chunk 4: 2026-11-06 01:41:41.019968+00:00 to 2026-11-06 01:42:15.956573+00:00 (34.937 s)
  Item 0: 800 configurations
  Item 1: 4 configurations
Chunk 5: 2026-11-06 01:42:47.834717+00:00 to 2026-11-06 01:43:21.436255+00:00 (33.602 s)
  Item 0: 800 configurations
  Item 1: 4 configurations
Chunk 6: 2026-11-06 01:43:22.698235+00:00 to 2026-11-06 01:43:53.647547+00:00 (30.949 s)
  Item 0: 800 configurations
  Item 1: 4 configurations
Chunk 7: 2026-11-06 01:43:54.710995+00:00 to 2026-11-06 01:44:25.762574+00:00 (31.052 s)
  Item 0: 800 configurations
  Item 1: 4 configurations
Pinagmulan: Dokumentasyon ng IBM Quantum — na-update noong Nob 7, 2026
Bersyong Ingles sa doQumentation — na-update noong Nob 7, 2026
Isyu sa site o pagsasalin?Isyu sa nilalaman? I-edit sa IBM Quantum docs