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.4.0
qiskit-ibm-runtime~=0.46.1

Halaman ini memberikan gambaran keseluruhan input dan output primitif Estimator Qiskit Runtime, 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 melaksanakan beban kerja yang ditentukan sebagai kerja. Kemudian, selepas kerja selesai, keputusan dikembalikan dalam format yang bergantung pada kedua-dua PUB yang digunakan serta pilihan runtime yang ditentukan dari primitif.

Input

Setiap PUB berada dalam format ini:

(<litar tunggal>, <satu atau lebih boleh pantau>, <nilai parameter pilihan satu atau lebih>, <ketepatan pilihan>),

nilai parameter pilihan boleh berupa senarai atau parameter tunggal. Elemen dari boleh pantau dan nilai parameter digabungkan dengan mengikuti peraturan penyiaran NumPy seperti yang diterangkan dalam topik Input dan output primitif, dan satu anggaran nilai jangkaan dikembalikan untuk setiap elemen bentuk yang disiarkan.

info

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 bertukar ganti
- Boleh pantau yang bertukar ganti dalam PUB yang sama dikumpulkan bersama menggunakan kaedah ini.
- Boleh pantau yang bertukar ganti 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 bertukar ganti 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 set contoh input tervektorkan untuk primitif Estimator dan melaksanakannya 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

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 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.        ]]

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 $\mathcal{O}$ . Tanpa ZNE, Anda boleh menganggap setiap tembakan pelaksanaan Estimator sebagai menyediakan anggaran titik bagi nilai jangkaan $\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 $\sigma_{\mathcal{O}}$ adalah sisihan piawai anggaran nilai jangkaan dan $N_{shots}$ adalah bilangan tembakan):

$\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 $\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

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

di mana $\sigma_{\mathcal{O}}$ adalah sisihan piawai O_twirls dan $N_{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.

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,

Input​

Output​

Bagaimana primitif Estimator mengira ralat​

Metadata keputusan​

Input

Output

Bagaimana primitif Estimator mengira ralat

Metadata keputusan