Inicio rápido con Estimator

La primitiva Estimator calcula los valores de expectación para uno o más observables con respecto a los estados preparados por circuits cuánticos. Los circuits pueden estar parametrizados, siempre que los valores de los parámetros también se proporcionen como entrada a la primitiva.

Esta primitiva tiene varias técnicas de mitigación y supresión de errores integradas, incluyendo desacoplamiento dinámico, Pauli-twirling, ZNE por plegado de gates, PEA y PEC. También admite una opción resilience_level que te permite configurar fácilmente el equilibrio entre costo y precisión. Los pasos de este tema describen cómo configurar Estimator, explorar las opciones que puedes usar para configurarlo e invocarlo en un programa.

Versiones de paquetes

El código de esta página fue desarrollado con los siguientes requisitos. Recomendamos usar estas versiones o más recientes.

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

Pasos para usar la primitiva Estimator

1. Inicializar la cuenta

Primero necesitas inicializar tu cuenta. Luego puedes seleccionar la QPU que quieres usar para calcular el valor de expectación.

Sigue los pasos en Configurar tu cuenta de IBM Cloud si aún no tienes una cuenta.

Gates fraccionales

Para usar los gates fraccionales recientemente admitidos, establece use_fractional_gates=True al solicitar un backend a una instancia de QiskitRuntimeService. Por ejemplo:

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

Esta es una función experimental y podría cambiar en el 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. Crear un circuit y un observable

Necesitas al menos un circuit y un observable como entradas para 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]

El circuit y el observable deben transformarse para usar solo instrucciones admitidas por la QPU (a estos se les llama circuits de arquitectura de conjunto de instrucciones (ISA)). Usa el transpilador para hacer esto.

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. Inicializar el Estimator de IBM Quantum

Cuando inicializas Estimator, usa el parámetro mode para especificar el modo en que quieres que se ejecute. Los valores posibles son objetos batch, session o backend para el modo de ejecución por lote, sesión y trabajo, respectivamente. Para más información, consulta Introducción a los modos de ejecución de IBM Quantum Compute Service. Ten en cuenta que los usuarios del Plan Open no pueden enviar trabajos de sesión.

from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

4. Invocar Estimator y obtener resultados

A continuación, invoca el método run() para calcular los valores de expectación para los circuits y observables de entrada. El circuit, el observable y los conjuntos opcionales de valores de parámetros se ingresan como tuplas de bloque unificado primitivo (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}

Próximos pasos

Recomendaciones

• Aprende a probar localmente antes de ejecutar en computadoras cuánticas.
• Revisa ejemplos detallados.
• Practica con las primitivas trabajando en la lección de función de costo en IBM Quantum Learning.
• Aprende a transpilar localmente en la sección Transpilar.
• Prueba la guía Comparar configuraciones del transpilador.
• Aprende a usar las opciones de las primitivas.
• Consulta la API de opciones de Estimator.