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.

Nuova implementazione di Estimator

Nuove implementazioni delle interfacce Qiskit SamplerV2 ed EstimatorV2 sono state introdotte in qiskit-ibm-runtime v0.50.0. Queste primitive lato client eseguono sul client la maggior parte della pre- e post-elaborazione e delegano l'esecuzione alla primitiva Executor. L'esecuzione lato client offre maggiore trasparenza, feedback di debug più rapido e controllo più fine.

Poiché implementano la stessa API, queste primitive lato client sono in gran parte sostituti immediati delle primitive legacy lato server, con l'unica modifica costituita dall'istruzione di importazione. Consulta Migra da Sampler ed Estimator lato server a lato client per maggiori informazioni.

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

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.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

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.

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import 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

Consigli

• Scopri come testare localmente prima di eseguire su computer quantistici.
• Consulta esempi dettagliati.
• Fai pratica con le primitive svolgendo 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.