Langkau ke kandungan utama
Projek ini dalam fasa beta. Jumpa pepijat? Buat isu GitHub. Ada soalan atau idea? Tanya dalam Discussions — kami suka dengar maklum balas anda!
Bagaimana kualiti terjemahan pada halaman ini?

Input dan output Estimator

Versi pakej

Kod di halaman ini dibangunkan menggunakan keperluan berikut. Kami syorkan menggunakan versi ini atau yang lebih baru.

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

Halaman ini memberikan gambaran keseluruhan input dan output primitif Estimator IBM Quantum, yang melaksanakan beban kerja pada sumber pengiraan IBM Quantum®. Estimator membolehkan anda menentukan beban kerja tervektorkan dengan cekap menggunakan struktur data yang dipanggil Blok Bersatu Primitif (PUB). Ia digunakan sebagai input kepada kaedah run() untuk primitif Estimator, yang menjalankan beban kerja tersebut sebagai satu kerja (job). Kemudian, selepas kerja selesai, keputusan dikembalikan dalam format yang bergantung pada kedua-dua PUB yang digunakan serta pilihan runtime yang ditetapkan pada primitif.

Input​

Setiap PUB berada dalam format ini:

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

parameter values yang pilihan boleh menjadi senarai atau parameter tunggal. Elemen daripada observable dan nilai parameter digabungkan dengan mengikut peraturan broadcasting NumPy (penyebaran tatasusunan) seperti yang diterangkan dalam topik Input dan output primitif, dan satu anggaran nilai jangkaan dikembalikan untuk setiap elemen bentuk yang disebarkan.

maklumat

Jika input mengandungi ukuran, ia diabaikan.

Untuk primitif Estimator, PUB boleh mengandungi paling banyak empat nilai:

  • Satu QuantumCircuit tunggal, yang mungkin mengandungi satu atau lebih objek Parameter
  • Senarai satu atau lebih boleh pantau, yang menentukan nilai jangkaan yang perlu dianggarkan, disusun ke dalam tatasusunan (contohnya, boleh pantau tunggal yang diwakili sebagai tatasusunan 0-d, senarai boleh pantau sebagai tatasusunan 1-d, dan sebagainya). Data boleh berada dalam mana-mana format ObservablesArrayLike seperti Pauli, SparsePauliOp, PauliList, atau str.
    Boleh pantau yang saling kalis tukar tertib
    • Boleh pantau yang saling kalis tukar tertib dalam PUB yang sama dikumpulkan bersama menggunakan kaedah ini.
    • Boleh pantau yang saling kalis tukar tertib dalam PUB yang berbeza, walaupun mereka mempunyai litar yang sama, tidak dianggarkan menggunakan ukuran yang sama. Setiap PUB mewakili asas berbeza untuk ukuran, dan oleh itu, ukuran berasingan diperlukan untuk setiap PUB.
    • Untuk memastikan boleh pantau yang saling kalis tukar tertib dianggarkan menggunakan ukuran yang sama, kumpulkan mereka dalam PUB yang sama.
  • Koleksi nilai parameter untuk mengikat litar. Ini boleh ditentukan sebagai objek tunggal seperti tatasusunan di mana indeks terakhir adalah untuk objek Parameter litar atau dihilangkan (atau setaranya, ditetapkan kepada None) jika litar tidak mempunyai objek Parameter.
  • (Secara pilihan) Ketepatan sasaran untuk nilai jangkaan yang perlu dianggarkan

Kod berikut menunjukkan contoh set input tervektorkan kepada primitif Estimator dan melaksanakannya pada Backend IBM® sebagai satu objek RuntimeJobV2 tunggal.

# 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()

Output​

Selepas satu atau lebih PUB dihantar ke QPU untuk pelaksanaan dan kerja berjaya diselesaikan, data dikembalikan sebagai objek bekas PrimitiveResult yang diakses dengan memanggil kaedah RuntimeJobV2.result().

PrimitiveResult mengandungi senarai iterable objek PubResult yang mengandungi keputusan pelaksanaan untuk setiap PUB.

Setiap elemen senarai ini sepadan dengan setiap PUB yang dihantar kepada kaedah run() primitif (contohnya, kerja yang dihantar dengan 20 PUB akan mengembalikan objek PrimitiveResult yang mengandungi senarai 20 objek PubResult, satu sepadan dengan setiap PUB).

Setiap PubResult untuk primitif Estimator mengandungi sekurang-kurangnya tatasusunan nilai jangkaan (PubResult.data.evs) dan sisihan piawai yang berkaitan (sama ada PubResult.data.stds atau PubResult.data.ensemble_standard_error bergantung pada resilience_level yang digunakan), tetapi boleh mengandungi lebih banyak data bergantung pada pilihan pengurangan ralat yang ditentukan.

Setiap objek PubResult mempunyai atribut data dan metadata.

  • Atribut data adalah DataBin yang disesuaikan yang mengandungi nilai ukuran sebenar, sisihan piawai, dan sebagainya.
  • DataBin mempunyai pelbagai atribut bergantung pada bentuk atau struktur PUB yang berkaitan serta pilihan pengurangan ralat yang ditentukan oleh primitif yang digunakan untuk menghantar kerja (contohnya, ZNE atau PEC).
  • Atribut metadata mengandungi maklumat tentang runtime dan pilihan pengurangan ralat yang digunakan (dijelaskan kemudian dalam bahagian Metadata keputusan halaman ini).

Berikut adalah garis besar visual struktur data PrimitiveResult untuk output 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
    ├── ...
    ├── ...
    └── ...

Ringkasnya, satu kerja mengembalikan objek PrimitiveResult dan mengandungi senarai satu atau lebih objek PubResult. Objek PubResult ini kemudian menyimpan data ukuran untuk setiap PUB yang dihantar kepada kerja.

Petikan kod di bawah menerangkan format PrimitiveResult (dan PubResult yang berkaitan) untuk kerja yang dicipta di atas.

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}

Bagaimana primitif Estimator mengira ralat​

Selain anggaran min boleh pantau yang dihantar dalam PUB input (medan evs dalam DataBin), Estimator juga cuba menyampaikan anggaran ralat yang berkaitan dengan nilai jangkaan tersebut. Semua pertanyaan Estimator akan mengisi medan stds dengan kuantiti seperti ralat piawai min untuk setiap nilai jangkaan, tetapi sesetengah pilihan pengurangan ralat menghasilkan maklumat tambahan, seperti ensemble_standard_error.

Pertimbangkan boleh pantau tunggal O\mathcal{O}. Tanpa ZNE, anda boleh menganggap setiap tembakan pelaksanaan Estimator sebagai menyediakan anggaran titik bagi nilai jangkaan ⟨O⟩\langle \mathcal{O} \rangle. Jika anggaran titik berada dalam vektor Os, maka nilai yang dikembalikan dalam ensemble_standard_error adalah bersamaan dengan berikut (di mana σO\sigma_{\mathcal{O}} adalah sisihan piawai anggaran nilai jangkaan dan NshotsN_{shots} adalah bilangan tembakan):

σONshots,\frac{ \sigma_{\mathcal{O}} }{ \sqrt{N_{shots}} },

yang menganggap semua tembakan sebagai sebahagian daripada satu ensemble. Jika Anda meminta twirling get (twirling.enable_gates = True), Anda boleh menyisih anggaran titik ⟨O⟩\langle \mathcal{O} \rangle ke dalam set yang berkongsi twirl yang sama. Panggil set anggaran ini O_twirls, dan terdapat num_randomizations (bilangan twirl) daripadanya. Kemudian stds adalah ralat piawai min O_twirls, seperti dalam

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

di mana σO\sigma_{\mathcal{O}} adalah sisihan piawai O_twirls dan NtwirlsN_{twirls} adalah bilangan twirl. Apabila Anda tidak mengaktifkan twirling, stds dan ensemble_standard_error adalah sama.

Jika Anda mengaktifkan ZNE, maka stds yang diterangkan di atas menjadi pemberat dalam regresi bukan-linear kepada model ekstrapolator. Apa yang akhirnya dikembalikan dalam stds dalam kes ini adalah ketidakpastian model padanan yang dinilai pada faktor hingar sifar. Apabila terdapat padanan yang lemah, atau ketidakpastian yang besar dalam padanan, stds yang dilaporkan boleh menjadi sangat besar. Apabila ZNE diaktifkan, pub_result.data.evs_noise_factors dan pub_result.data.stds_noise_factors juga diisi, supaya Anda boleh melakukan ekstrapolasi sendiri.

Metadata keputusan​

Selain keputusan pelaksanaan, kedua-dua objek PrimitiveResult dan PubResult mengandungi atribut metadata tentang kerja yang dihantar. Metadata yang mengandungi maklumat untuk semua PUB yang dihantar (seperti pelbagai pilihan runtime yang tersedia) boleh didapati dalam PrimitiveResult.metatada, manakala metadata khusus untuk setiap PUB terdapat dalam PubResult.metadata.

Estimator sisi klien menghantar beban kerjanya sebagai job Executor. Metadata keputusan Executor yang mendasarinya, yang termasuk maklumat masa pelaksanaan yang dipanggil execution spans, tersedia di bawah kunci "executor" bagi PrimitiveResult.metadata.

nota

Dalam medan metadata, implementasi primitif boleh mengembalikan sebarang maklumat tentang pelaksanaan yang relevan kepada mereka, dan tiada pasangan kunci-nilai yang dijamin oleh primitif asas. Oleh itu, metadata yang dikembalikan mungkin berbeza dalam implementasi primitif yang berbeza.

# 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,

Lihat execution spans​

Estimator sisi klien berjalan sebagai job Executor, yang melaksanakan kerjanya pada QPU dalam chunk. Masa setiap chunk berada dalam result.metadata["executor"].chunk_timing, iaitu senarai objek ChunkSpan. Setiap ChunkSpan mempunyai cap masa start dan stop serta senarai parts, di mana setiap bahagian memberikan indeks item (idx_item) dan bilangan konfigurasi daripada item tersebut (size) yang dijalankan dalam chunk itu.

idx_item ialah indeks sesuatu item dalam program Executor yang dibina oleh Estimator daripada PUB anda. Ia tidak semestinya sepadan dengan indeks PUB, kerana Estimator boleh menambah item program, bergantung pada pilihan mitigasi ralat. Contohnya, ia menambah litar kalibrasi ralat pengukuran apabila TREX didayakan.

Untuk memvisualisasikan masa, hantar senarai tersebut kepada draw_chunk_timings, seperti yang ditunjukkan dalam contoh berikut.

Untuk mempelajari maksud cap masa chunk, cara membaca plot, dan sebab jurang boleh muncul antara chunk, lihat Lihat execution spans dalam panduan input dan output Executor.

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
Sumber: Dokumentasi IBM Quantum — dikemas kini 7 Nov 2026
Versi bahasa Inggeris di doQumentation — dikemas kini 7 Nov 2026
Masalah laman web atau terjemahan?Masalah kandungan? Sunting di IBM Quantum docs