Inicio rápido con Estimator
El primitivo 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 al primitivo.
Este primitivo 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.4.0
qiskit-ibm-runtime~=0.46.1
# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-runtime
```json
{/*Verified the v2 examples 2/29/24 - updated 10/29/24*/}
## Pasos para usar el primitivo Estimator \{#steps-to-use-the-estimator-primitive}
### 1. Inicializar la cuenta \{#1-initialize-the-account}
Dado que Qiskit Runtime es un servicio gestionado, primero debes 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](cloud-setup) si aún no tienes una cuenta.
:::note[Gates fraccionales]
Para usar los [gates fraccionales](/guides/fractional-gates) recientemente admitidos, establece `use_fractional_gates=True` al solicitar un backend a una instancia de `QiskitRuntimeService`. Por ejemplo:
```python
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 el primitivo 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 (denominadas 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 Qiskit Runtime
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 Qiskit Runtime. 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: d82869ntjchs73bnokog
>>> 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: 30.60337496305257
> Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}
Próximos pasos
- Aprende a probar localmente antes de ejecutar en computadoras cuánticas.
- Revisa ejemplos detallados.
- Practica con los primitivos 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 los primitivos.
- Ve la API para las opciones de Estimator.
- Lee Migrar a primitivos V2.