Dati in entrata e in uscita del programma di preventivazione

• Versioni del pacchetto

  Il codice presente in questa pagina è stato sviluppato sulla base dei seguenti requisiti. Si consiglia di utilizzare queste versioni o quelle più recenti.

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

Questa pagina offre una panoramica degli input e degli output della primitiva " IBM Quantum Estimator", che esegue carichi di lavoro sulle risorse di calcolo dell' IBM Quantum®. Estimator consente di definire in modo efficiente carichi di lavoro vettorializzati utilizzando una struttura dati denominata " Primitive Unified Bloc" ( PUB ). Vengono utilizzati come input per il metodo run() della primitiva Estimator, che esegue il carico di lavoro definito come un’attività. Una volta completata l'operazione, i risultati vengono restituiti in un formato che dipende sia dai PUB utilizzati sia dalle opzioni di esecuzione specificate nella primitiva.

Input

Ogni file « PUB » ha il seguente formato:

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

L'opzione parameter values può essere un elenco o un singolo parametro. Gli elementi provenienti dagli osservabili e i valori dei parametri vengono combinati seguendo le regole di diffusione descritte all'indirizzo NumPy, come illustrato nell'argomento "Ingressi e uscite primitivi ", e per ciascun elemento della struttura diffusa viene restituita una stima del valore atteso.

Per la primitiva Estimator, un oggetto di tipo « PUB » può contenere al massimo quattro valori:

• Un singolo elemento QuantumCircuit, che può contenere uno o più Parameter oggetti
• Un elenco di una o più grandezze osservabili, che specificano i valori attesi da stimare, organizzato in un array (ad esempio, una singola grandezza osservabile rappresentata come un array a 0 dimensioni, un elenco di grandezze osservabili come un array a 1 dimensione e così via). I dati possono essere in uno qualsiasi dei seguenti ObservablesArrayLike formati: Pauli SparsePauliOp, PauliList,, o str.
  Grandezze osservabili nel tragitto casa-lavoro

  • Con questo metodo, le grandezze osservabili correlate nello stesso sistema di riferimento ( PUB ) vengono raggruppate.
  • Le grandezze osservabili relative agli spostamenti casa-lavoro in diversi PUB, anche se appartengono allo stesso circuito, non vengono stimate utilizzando la stessa misurazione. Ogni PUB rappresenta una base di misurazione diversa; pertanto, per ogni PUB sono necessarie misurazioni separate.
  • Per garantire che le variabili relative agli spostamenti casa-lavoro vengano stimate utilizzando lo stesso metodo di misurazione, raggrupparle all’interno dello stesso « PUB ».
• Una raccolta di valori dei parametri a cui associare il circuito. Questo può essere specificato come un singolo oggetto di tipo array in cui l'ultimo indice indica il numero di oggetti del Parameter circuito, oppure può essere omesso (o, in modo equivalente, impostato a None) se il circuito non contiene Parameter oggetti.
• (Facoltativo) Una precisione target per i valori attesi da stimare

Il codice seguente mostra un esempio di insieme di input vettorializzati per la Estimator primitiva e li esegue su un backend IBM® e come un unico RuntimeJobV2 oggetto.

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

Dopo che uno o più PUB sono stati inviati a una QPU per l'esecuzione e un processo è stato completato con successo, i dati vengono restituiti sotto forma di un oggetto PrimitiveResult contenitore a cui si accede chiamando il RuntimeJobV2.result() metodo.

L'oggetto PrimitiveResult contiene un elenco iterabile di PubResult oggetti che contengono i risultati dell'esecuzione per ciascun PUB.

Ogni elemento di questo elenco corrisponde a ciascun PUB inviato al metodo della run() primitiva (ad esempio, un lavoro inviato con 20 PUB restituirà un PrimitiveResult oggetto contenente un elenco di 20 PubResult oggetti, uno per ciascun PUB ).

Ogni primitiva PubResult dello stimatore contiene almeno un array di valori attesi (PubResult.data.evs) e le relative deviazioni standard (o PubResult.data.stds o PubResult.data.ensemble_standard_error , a seconda del resilience_level utilizzato), ma può contenere ulteriori dati a seconda delle opzioni di mitigazione dell'errore specificate.

Ogni PubResult oggetto possiede sia un attributo data che un metadata attributo.

• L'attributo data è un campo personalizzato DataBin che contiene i valori effettivi delle misurazioni, le deviazioni standard e così via.
• Il DataBin presenta diverse caratteristiche a seconda della forma o della struttura dell' PUB a associata, nonché delle opzioni di mitigazione degli errori specificate dalla primitiva utilizzata per inviare il lavoro (ad esempio, ZNE o PEC ).
• L'attributo metadata contiene informazioni relative alle opzioni di esecuzione e di mitigazione degli errori utilizzate (come spiegato più avanti nella sezione "Metadati del risultato" di questa pagina).

Di seguito è riportata una rappresentazione schematica della struttura PrimitiveResult dei dati relativa all'output dello Stima:

└── 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
    ├── ...
    ├── ...
    └── ...

In parole povere, un singolo job restituisce un PrimitiveResult oggetto e contiene un elenco di uno o più PubResult oggetti. Questi PubResult oggetti memorizzano quindi i dati di misurazione relativi a ciascun « PUB » inviato al processo.

Il frammento di codice riportato di seguito descrive il PrimitiveResult formato (e i relativi PubResult) del processo creato in precedenza.

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"
    )

Output:

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}

Come la primitiva Estimator calcola l'errore

Oltre alla stima della media delle grandezze osservabili passate nei PUB di input (il evs campo del DataBin), Estimator cerca anche di fornire una stima dell'errore associato a tali valori attesi. Tutte le query di Estimator inseriranno nel stds campo un valore pari all'errore standard della media per ciascun valore atteso, ma alcune opzioni di mitigazione dell'errore forniscono ulteriori informazioni, come ad esempio ensemble_standard_error.

Si consideri un singolo osservabile $\mathcal{O}$. In assenza di ZNE, si può pensare che ogni iterazione dell'esecuzione dello stimatore fornisca una stima puntuale del valore atteso $\langle \mathcal{O} \rangle$. Se le stime puntuali sono contenute in un vettore Os, allora il valore restituito in ensemble_standard_error è equivalente al seguente (dove $\sigma_{\mathcal{O}}$ è la deviazione standard della stima del valore atteso e $N_{shots}$ è il numero di iterazioni):

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

che considera tutte le inquadrature come parte di un unico insieme. Se hai richiesto il "gate twirling" (twirling.enable_gates = True), puoi raggruppare le stime puntuali di $\langle \mathcal{O} \rangle$ in insiemi che condividono un "twirl" comune. Chiamiamo queste serie di stime O_twirls, e ce ne sono num_randomizations (numero di giri). Allora stds è l'errore standard della media di O_twirls, come in

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

dove $\sigma_{\mathcal{O}}$ è la deviazione standard di O_twirls e $N_{twirls}$ è il numero di rotazioni. Quando non si attiva l'effetto rotatorio, stds e ensemble_standard_error sono uguali.

Se si abilita ZNE, i stds parametri sopra descritti diventano i pesi in una regressione non lineare applicata a un modello di estrapolazione. Ciò che viene infine restituito in questo stds caso è l'incertezza del modello di adattamento valutata con un fattore di rumore pari a zero. Quando l'adattamento è inadeguato o presenta un elevato grado di incertezza, il valore riportato stds può diventare molto elevato. Quando ZNE è abilitato, pub_result.data.evs_noise_factors anche e pub_result.data.stds_noise_factors vengono compilati, in modo da poter effettuare la propria estrapolazione.

Metadati dei risultati

Oltre ai risultati dell'esecuzione, entrambi gli PrimitiveResult oggetti PubResult e contengono un attributo di metadati relativo al processo inviato. I metadati contenenti le informazioni relative a tutti i PUB inviati (come le varie opzioni di esecuzione disponibili) sono disponibili nel file PrimitiveResult.metatada, mentre i metadati specifici per ciascun PUB si trovano nel file PubResult.metadata.

# 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},")

Output:

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,