Input dan output Estimator

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami menyarankan menggunakan versi ini atau yang lebih baru.

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

Halaman ini memberikan gambaran umum input dan output primitif Qiskit Runtime Estimator, yang mengeksekusi beban kerja pada sumber daya komputasi IBM Quantum®. Estimator memungkinkan kamu mendefinisikan beban kerja yang divektorisasi secara efisien menggunakan struktur data yang disebut Primitive Unified Bloc (PUB). PUB digunakan sebagai input ke metode run() untuk primitif Estimator, yang mengeksekusi beban kerja yang didefinisikan sebagai sebuah job. Kemudian, setelah job selesai, hasilnya dikembalikan dalam format yang bergantung pada PUB yang digunakan serta opsi runtime yang ditentukan dari primitif.

Input

Setiap PUB memiliki format ini:

(<circuit tunggal>, <satu atau lebih observable>, <opsional satu atau lebih nilai parameter>, <opsional presisi>),

Nilai parameter opsional bisa berupa daftar atau parameter tunggal. Elemen dari observable dan nilai parameter digabungkan dengan mengikuti aturan broadcasting NumPy seperti yang dijelaskan dalam topik Input dan output primitif, dan satu estimasi nilai ekspektasi dikembalikan untuk setiap elemen dari bentuk yang di-broadcast.

info

Jika input mengandung pengukuran, pengukuran tersebut diabaikan.

Untuk primitif Estimator, sebuah PUB dapat mengandung paling banyak empat nilai:

Satu QuantumCircuit tunggal, yang mungkin mengandung satu atau lebih objek Parameter
Daftar satu atau lebih observable, yang menentukan nilai ekspektasi yang akan diestimasi, disusun dalam sebuah array (misalnya, satu observable direpresentasikan sebagai array 0-d, daftar observable sebagai array 1-d, dan seterusnya). Datanya bisa dalam salah satu format ObservablesArrayLike seperti Pauli, SparsePauliOp, PauliList, atau str.
Observable yang komutasi
- Observable yang komutasi dalam PUB yang sama dikelompokkan bersama menggunakan metode ini.
- Observable yang komutasi dalam PUB yang berbeda, meskipun memiliki circuit yang sama, tidak diestimasi menggunakan pengukuran yang sama. Setiap PUB merepresentasikan basis yang berbeda untuk pengukuran, dan oleh karena itu, pengukuran terpisah diperlukan untuk setiap PUB.
- Untuk memastikan bahwa observable yang komutasi diestimasi menggunakan pengukuran yang sama, kelompokkan mereka dalam PUB yang sama.
Kumpulan nilai parameter untuk diikat ke circuit. Ini dapat ditentukan sebagai satu objek array-like di mana indeks terakhir adalah untuk objek Parameter circuit atau dihilangkan (atau setara, diatur ke None) jika circuit tidak memiliki objek Parameter.
(Opsional) Presisi target untuk nilai ekspektasi yang akan diestimasi

Kode berikut menunjukkan contoh set input yang divektorisasi ke primitif Estimator dan mengeksekusinya pada backend IBM® sebagai satu objek 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()

Output

Setelah satu atau lebih PUB dikirim ke QPU untuk eksekusi dan job berhasil diselesaikan, data dikembalikan sebagai objek kontainer PrimitiveResult yang diakses dengan memanggil metode RuntimeJobV2.result().

PrimitiveResult berisi daftar iterable dari objek PubResult yang berisi hasil eksekusi untuk setiap PUB.

Setiap elemen dari daftar ini sesuai dengan setiap PUB yang dikirimkan ke metode run() primitif (misalnya, job yang dikirim dengan 20 PUB akan mengembalikan objek PrimitiveResult yang berisi daftar 20 objek PubResult, satu sesuai dengan setiap PUB).

Setiap PubResult untuk primitif Estimator setidaknya mengandung array nilai ekspektasi (PubResult.data.evs) dan deviasi standar terkait (baik PubResult.data.stds atau PubResult.data.ensemble_standard_error tergantung pada resilience_level yang digunakan), tetapi dapat mengandung lebih banyak data tergantung pada opsi mitigasi error yang ditentukan.

Setiap objek PubResult memiliki atribut data dan metadata.

Atribut data adalah DataBin yang dikustomisasi dan berisi nilai pengukuran aktual, deviasi standar, dan sebagainya.
DataBin memiliki berbagai atribut tergantung pada bentuk atau struktur PUB terkait serta opsi mitigasi error yang ditentukan oleh primitif yang digunakan untuk mengirimkan job (misalnya, ZNE atau PEC).
Atribut metadata berisi informasi tentang runtime dan opsi mitigasi error yang digunakan (dijelaskan kemudian di bagian Metadata hasil di halaman ini).

Berikut adalah garis besar visual dari 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
    ├── ...
    ├── ...
    └── ...

Sederhananya, satu job mengembalikan objek PrimitiveResult dan berisi daftar satu atau lebih objek PubResult. Objek PubResult ini kemudian menyimpan data pengukuran untuk setiap PUB yang dikirimkan ke job.

Cuplikan kode di bawah ini menjelaskan format PrimitiveResult (dan PubResult terkait) untuk job yang dibuat 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 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.        ]]

Cara primitif Estimator menghitung error

Selain estimasi rata-rata observable yang diteruskan dalam PUB input (field evs dari DataBin), Estimator juga berusaha memberikan estimasi error yang terkait dengan nilai ekspektasi tersebut. Semua kueri Estimator akan mengisi field stds dengan kuantitas seperti standard error of the mean untuk setiap nilai ekspektasi, tetapi beberapa opsi mitigasi error menghasilkan informasi tambahan, seperti ensemble_standard_error.

Pertimbangkan satu observable $\mathcal{O}$ . Tanpa adanya ZNE, kamu bisa menganggap setiap shot eksekusi Estimator sebagai memberikan estimasi titik dari nilai ekspektasi $\langle \mathcal{O} \rangle$ . Jika estimasi titik ada dalam vektor Os, maka nilai yang dikembalikan dalam ensemble_standard_error setara dengan berikut (di mana $\sigma_{\mathcal{O}}$ adalah deviasi standar estimasi nilai ekspektasi dan $N_{shots}$ adalah jumlah shot):

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

yang memperlakukan semua shot sebagai bagian dari satu ensemble. Jika kamu meminta gate twirling (twirling.enable_gates = True), kamu dapat mengurutkan estimasi titik dari $\langle \mathcal{O} \rangle$ ke dalam set yang berbagi twirl yang sama. Sebut set estimasi ini O_twirls, dan ada num_randomizations (jumlah twirl) dari mereka. Maka stds adalah standard error of the mean dari O_twirls, seperti

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

di mana $\sigma_{\mathcal{O}}$ adalah deviasi standar dari O_twirls dan $N_{twirls}$ adalah jumlah twirl. Ketika kamu tidak mengaktifkan twirling, stds dan ensemble_standard_error adalah sama.

Jika kamu mengaktifkan ZNE, maka stds yang dijelaskan di atas menjadi bobot dalam regresi non-linear ke model ekstrapolator. Apa yang akhirnya dikembalikan dalam stds dalam kasus ini adalah ketidakpastian dari model fit yang dievaluasi pada faktor noise nol. Ketika ada fit yang buruk, atau ketidakpastian besar dalam fit, stds yang dilaporkan bisa menjadi sangat besar. Ketika ZNE diaktifkan, pub_result.data.evs_noise_factors dan pub_result.data.stds_noise_factors juga diisi, sehingga kamu dapat melakukan ekstrapolasi sendiri.

Metadata hasil

Selain hasil eksekusi, baik objek PrimitiveResult maupun PubResult berisi atribut metadata tentang job yang dikirimkan. Metadata yang mengandung informasi untuk semua PUB yang dikirimkan (seperti berbagai opsi runtime yang tersedia) dapat ditemukan di PrimitiveResult.metatada, sementara metadata khusus untuk setiap PUB ditemukan di PubResult.metadata.

catatan

Di field metadata, implementasi primitif dapat mengembalikan informasi apapun tentang eksekusi yang relevan bagi mereka, dan tidak ada pasangan kunci-nilai yang dijamin oleh primitif dasar. Dengan demikian, metadata yang dikembalikan mungkin berbeda dalam implementasi primitif yang berbeda.

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

Input​

Output​

Cara primitif Estimator menghitung error​

Metadata hasil​

Input

Output

Cara primitif Estimator menghitung error

Metadata hasil