Intrările și ieșirile Estimator

Versiuni de pachete

Codul de pe această pagină a fost dezvoltat folosind următoarele cerințe. Recomandăm să folosești aceste versiuni sau mai noi.

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

Această pagină oferă o prezentare generală a intrărilor și ieșirilor primitivei Qiskit Runtime Estimator, care execută volumele de lucru pe resursele de calcul IBM Quantum®. Estimator îți permite să definești eficient volume de lucru vectorizate folosind o structură de date numită Primitive Unified Bloc (PUB). Acestea sunt folosite ca intrări pentru metoda run() a primitivei Estimator, care execută volumul de lucru definit ca un job. Apoi, după ce jobul s-a finalizat, rezultatele sunt returnate într-un format care depinde atât de PUB-urile utilizate, cât și de opțiunile de runtime specificate pentru primitivă.

Intrări

Fiecare PUB are acest format:

(<un singur circuit>, <unul sau mai mulți observabili>, <opțional una sau mai multe valori de parametri>, <precizie opțională>),

Opționalele valori de parametri pot fi o listă sau un singur parametru. Elementele din observabili și valorile de parametri sunt combinate urmând regulile de broadcasting NumPy descrise în subiectul Intrările și ieșirile primitivelor, iar o estimare a valorii de așteptare este returnată pentru fiecare element al formei broadcast.

info

Dacă intrarea conține măsurători, acestea sunt ignorate.

Pentru primitiva Estimator, un PUB poate conține cel mult patru valori:

Un singur QuantumCircuit, care poate conține unul sau mai multe obiecte Parameter
O listă cu unul sau mai mulți observabili, care specifică valorile de așteptare ce urmează a fi estimate, aranjate într-un tablou (de exemplu, un singur observabil reprezentat ca un tablou 0-d, o listă de observabili ca un tablou 1-d și altele). Datele pot fi în oricare dintre formatele ObservablesArrayLike, cum ar fi Pauli, SparsePauliOp, PauliList sau str.
Observabili comutanți
- Observabilii comutanți în același PUB sunt grupați împreună folosind această metodă.
- Observabilii comutanți în PUB-uri diferite, chiar dacă au același circuit, nu sunt estimați folosind aceeași măsurătoare. Fiecare PUB reprezintă o bază diferită de măsurare și, prin urmare, sunt necesare măsurători separate pentru fiecare PUB.
- Pentru a te asigura că observabilii comutanți sunt estimați folosind aceeași măsurătoare, grupează-i în același PUB.
O colecție de valori de parametri pentru a lega circuitul. Aceasta poate fi specificată ca un singur obiect de tip tablou unde ultimul index este pentru obiectele Parameter ale circuitului sau omisă (sau echivalent, setată la None) dacă circuitul nu are obiecte Parameter.
(Opțional) O precizie țintă pentru valorile de așteptare ce urmează a fi estimate

Codul următor demonstrează un exemplu de set vectorizat de intrări pentru primitiva Estimator și le execută pe un backend IBM® ca un singur obiect 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()

Ieșiri

După ce unul sau mai multe PUB-uri sunt trimise unui QPU pentru execuție și un job se finalizează cu succes, datele sunt returnate ca un obiect container PrimitiveResult accesat prin apelarea metodei RuntimeJobV2.result().

PrimitiveResult conține o listă iterabilă de obiecte PubResult care conțin rezultatele execuției pentru fiecare PUB.

Fiecare element al acestei liste corespunde fiecărui PUB trimis metodei run() a primitivei (de exemplu, un job trimis cu 20 de PUB-uri va returna un obiect PrimitiveResult care conține o listă de 20 de obiecte PubResult, câte unul corespunzând fiecărui PUB).

Fiecare PubResult pentru primitiva Estimator conține cel puțin un tablou de valori de așteptare (PubResult.data.evs) și deviații standard asociate (fie PubResult.data.stds, fie PubResult.data.ensemble_standard_error în funcție de resilience_level utilizat), dar poate conține mai multe date în funcție de opțiunile de atenuare a erorilor specificate.

Fiecare obiect PubResult posedă atât un atribut data, cât și un atribut metadata.

Atributul data este un DataBin personalizat care conține valorile efective ale măsurătorilor, deviațiile standard și altele.
DataBin are diverse atribute în funcție de forma sau structura PUB-ului asociat, precum și de opțiunile de atenuare a erorilor specificate de primitiva folosită pentru a trimite jobul (de exemplu, ZNE sau PEC).
Atributul metadata conține informații despre opțiunile de runtime și de atenuare a erorilor utilizate (explicate ulterior în secțiunea Metadatele rezultatelor de pe această pagină).

Următoarea este o schiță vizuală a structurii de date PrimitiveResult pentru ieșirea 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
    ├── ...
    ├── ...
    └── ...

Pe scurt, un singur job returnează un obiect PrimitiveResult și conține o listă cu unul sau mai multe obiecte PubResult. Aceste obiecte PubResult stochează apoi datele de măsurare pentru fiecare PUB trimis jobului.

Fragmentul de cod de mai jos descrie formatul PrimitiveResult (și PubResult asociat) pentru jobul creat mai sus.

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

Cum calculează primitiva Estimator eroarea

Pe lângă estimarea mediei observabililor transmiși în PUB-urile de intrare (câmpul evs al DataBin), Estimator încearcă, de asemenea, să furnizeze o estimare a erorii asociate cu acele valori de așteptare. Toate interogările Estimator vor popula câmpul stds cu o cantitate similară erorii standard a mediei pentru fiecare valoare de așteptare, dar unele opțiuni de atenuare a erorilor produc informații suplimentare, cum ar fi ensemble_standard_error.

Consideră un singur observabil $\mathcal{O}$ . În absența ZNE, poți considera fiecare shot al execuției Estimator ca furnizând o estimare punctuală a valorii de așteptare $\langle \mathcal{O} \rangle$ . Dacă estimările punctuale se află într-un vector Os, atunci valoarea returnată în ensemble_standard_error este echivalentă cu următoarea formulă (în care $\sigma_{\mathcal{O}}$ este deviația standard a estimării valorii de așteptare și $N_{shots}$ este numărul de shot-uri):

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

care tratează toate shot-urile ca parte a unui singur ansamblu. Dacă ai solicitat twirling de porți (twirling.enable_gates = True), poți sorta estimările punctuale ale $\langle \mathcal{O} \rangle$ în seturi care împărtășesc un twirl comun. Numește aceste seturi de estimări O_twirls, și există num_randomizations (numărul de twirl-uri) dintre ele. Atunci stds este eroarea standard a mediei lui O_twirls, astfel:

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

unde $\sigma_{\mathcal{O}}$ este deviația standard a O_twirls și $N_{twirls}$ este numărul de twirl-uri. Când nu activezi twirling-ul, stds și ensemble_standard_error sunt egale.

Dacă activezi ZNE, atunci stds descrise mai sus devin ponderi într-o regresie neliniară față de un model extrapolator. Ceea ce este returnat în final în stds în acest caz este incertitudinea modelului de fit evaluat la un factor de zgomot de zero. Când există un fit slab sau o incertitudine mare în fit, stds raportate pot deveni foarte mari. Când ZNE este activat, pub_result.data.evs_noise_factors și pub_result.data.stds_noise_factors sunt, de asemenea, populate, astfel încât poți efectua propria extrapolare.

Metadatele rezultatelor

Pe lângă rezultatele execuției, atât obiectele PrimitiveResult, cât și PubResult conțin un atribut de metadate despre jobul care a fost trimis. Metadatele care conțin informații pentru toate PUB-urile trimise (cum ar fi diversele opțiuni de runtime disponibile) pot fi găsite în PrimitiveResult.metatada, în timp ce metadatele specifice fiecărui PUB se află în PubResult.metadata.

notă

În câmpul de metadate, implementările primitive pot returna orice informații despre execuție care sunt relevante pentru ele, și nu există perechi cheie-valoare garantate de primitiva de bază. Astfel, metadatele returnate ar putea fi diferite în implementări diferite ale primitivei.

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

Intrări​

Ieșiri​

Cum calculează primitiva Estimator eroarea​

Metadatele rezultatelor​

Intrări

Ieșiri

Cum calculează primitiva Estimator eroarea

Metadatele rezultatelor