Avvio rapido con Estimator

La primitiva Estimator calcola i valori di aspettazione per uno o più osservabili rispetto agli stati preparati da circuiti quantistici. I circuiti possono essere parametrizzati, purché i valori dei parametri siano forniti anche come input alla primitiva.

Questa primitiva dispone di diverse tecniche integrate di mitigazione e soppressione degli errori, tra cui il decoupling dinamico, il Pauli-twirling, ZNE con gate-folding, PEA e PEC. Supporta inoltre un'opzione resilience_level che ti consente di configurare facilmente il compromesso costo-accuratezza. I passaggi in questo argomento descrivono come configurare Estimator, esplorare le opzioni che puoi usare per configurarlo e invocarlo in un programma.

Versioni dei pacchetti

Il codice in questa pagina è stato sviluppato con i seguenti requisiti. Ti consigliamo di utilizzare queste versioni o versioni più recenti.

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

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-runtime

Passaggi per utilizzare la primitiva Estimator

1. Inizializza l'account

Prima devi inizializzare il tuo account. Puoi quindi selezionare la QPU che desideri utilizzare per calcolare il valore di aspettazione.

Segui i passaggi in Configura il tuo account IBM Cloud se non hai già un account.

gate frazionari

Per utilizzare i gate frazionari supportati di recente, imposta use_fractional_gates=True quando richiedi un backend da un'istanza di QiskitRuntimeService. Ad esempio:

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

Questa è una funzionalità sperimentale e potrebbe cambiare in futuro.

from qiskit_ibm_runtime import QiskitRuntimeService

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

print(backend.name)

ibm_fez

2. Crea un circuito e un osservabile

Hai bisogno di almeno un circuito e un osservabile come input per la primitiva Estimator.

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 per usare solo le istruzioni supportate dalla QPU (chiamati circuiti instruction set architecture (ISA)). Usa il Transpiler per farlo.

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

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

3. Inizializza l'IBM Quantum Estimator

Quando inizializzi Estimator, usa il parametro mode per specificare la modalità in cui vuoi che venga eseguito. I valori possibili sono oggetti batch, session o backend per la modalità di esecuzione batch, session e job rispettivamente. Per ulteriori informazioni, consulta Introduzione alle modalità di esecuzione di IBM Quantum Compute Service. Nota che gli utenti del piano Open non possono inviare job di Session.

from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

4. Invoca Estimator e ottieni i risultati

Poi, invoca il metodo run() per calcolare i valori di aspettazione per i circuiti di input e gli osservabili. Il circuito, l'osservabile e i set opzionali di valori dei parametri vengono passati come tuple primitive unified bloc (PUB).

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

>>> Job ID: dab7lfurrl7c7386gjn0

>>> Job Status: QUEUED

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

>>> 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: 28.60306448415693
  > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

Passi successivi

Raccomandazioni

• Scopri come testare localmente prima di eseguire su computer quantistici.
• Consulta esempi dettagliati.
• Fai pratica con le primitive lavorando attraverso la lezione sulle funzioni di costo in IBM Quantum Learning.
• Scopri come effettuare la transpilazione localmente nella sezione Transpila.
• Prova la guida Confronta le impostazioni del Transpiler.
• Scopri come utilizzare le opzioni delle primitive.
• Visualizza l'API per le opzioni di Estimator.