Guida rapida a Estimator

La primitiva Estimator calcola i valori attesi di una o più grandezze osservabili rispetto agli stati preparati dai circuiti quantistici. I circuiti possono essere parametrizzati, a condizione che i valori dei parametri vengano forniti anche come input alla primitiva.

Questa primitiva dispone di diverse tecniche integrate di mitigazione e soppressione degli errori, tra cui il disaccoppiamento dinamico, il Pauli-twirling, il gate-folding ZNE, il PEA e il PEC. Supporta inoltre un’opzione resilience_level che consente di configurare facilmente il compromesso tra costo e precisione.

I passaggi descritti in questa sezione spiegano come configurare Estimator, come esplorare le opzioni disponibili per la sua configurazione e come richiamarlo all'interno di un programma.

• 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
  

Procedura per l'utilizzo della primitiva Estimator

1. Inizializza l'account

Per prima cosa devi configurare il tuo account. È quindi possibile selezionare la QPU che si desidera utilizzare per calcolare il valore atteso.

Se non disponi già di un account, segui i passaggi indicati nella guida "Configurazione dell'account IBM Cloud ".

service = QiskitRuntimeService()
fractional_gate_backend = service.least_busy(use_fractional_gates=True)

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)

print(backend.name)

Output:

ibm_fez

2. Creare un circuito e un osservabile

Per la primitiva Estimator sono necessari almeno un circuito e un osservabile come input.

from qiskit.circuit.library import qaoa_ansatz
from qiskit.quantum_info import SparsePauliOp

entanglement = [tuple(edge) for edge in backend.coupling_map.get_edges()]
observable = SparsePauliOp.from_sparse_list(
    [("ZZ", [i, j], 0.5) for i, j in entanglement],
    num_qubits=backend.num_qubits,
)
circuit = qaoa_ansatz(observable, reps=2)
# The circuit is parametrized, so we will define the parameter values for execution
param_values = [0.1, 0.2, 0.3, 0.4]

Il circuito e l'osservabile devono essere trasformati in modo da utilizzare esclusivamente istruzioni supportate dalla QPU (circuiti denominati "architecture del set di istruzioni" o ISA ). Per farlo, usa il transpiler.

from qiskit.transpiler import generate_preset_pass_manager

pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pm.run(circuit)
isa_observable = observable.apply_layout(isa_circuit.layout)
print(f">>> Circuit ops (ISA): {isa_circuit.count_ops()}")

Output:

>>> Circuit ops (ISA): OrderedDict([('rz', 4472), ('sx', 1884), ('cz', 1120)])

3. Inizializzare lo stimatore " IBM Quantum "

Quando si avvia Estimator, utilizzare il parametro mode per specificare la modalità in cui si desidera che venga eseguito. I valori possibili sono batch, session, oppure backend oggetti, rispettivamente per le modalità di esecuzione in batch, in sessione e per job. Per ulteriori informazioni, consultare la sezione " Introduzione alle modalità di esecuzione del servizio di elaborazione di IBM Quantum ". Si noti che gli utenti di Open Plan non possono inviare lavori di sessione.

from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

4. Avviare Estimator e ottenere i risultati

Successivamente, richiamare il run() metodo per calcolare i valori attesi per i circuiti di ingresso e le grandezze osservabili. I set di parametri relativi al circuito, osservabili e opzionali vengono immessi sotto forma di tuple di blocchi unificati primitivi ( PUB ).

job = estimator.run([(isa_circuit, isa_observable, param_values)])
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")

Output:

>>> Job ID: d9mq9tnurbec73e67aj0
>>> Job Status: QUEUED

result = job.result()
print(f">>> {result}")
print(f"  > Expectation value: {result[0].data.evs}")
print(f"  > Metadata: {result[0].metadata}")

Output:

>>> PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(), dtype=float64>), stds=np.ndarray(<shape=(), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(), dtype=float64>)), 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})
  > Expectation value: 29.745702323497138
  > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

Passi successivi