Guía rápida de Estimator

La primitiva Estimator calcula los valores esperados de una o varias variables observables con respecto a los estados generados por circuitos cuánticos. Los circuitos se pueden parametrizar, siempre y cuando los valores de los parámetros también se proporcionen como entrada a la primitiva.

Esta primitiva cuenta con varias técnicas integradas de mitigación y supresión de errores, entre las que se incluyen el desacoplamiento dinámico, el «Pauli-twirling», el «gate-folding ZNE», el PEA y el PEC. Además, incluye una resilience_level opción que permite configurar fácilmente el equilibrio entre coste y precisión.

Los pasos de este tema describen cómo instalar Estimator, explorar las opciones disponibles para configurarlo y ejecutarlo en un programa.

• Versiones del paquete

  El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos. Recomendamos utilizar estas versiones o posteriores.

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

Pasos para utilizar la primitiva «Estimator»

1. Inicializar la cuenta

Dado que Qiskit Runtime es un servicio gestionado, primero debe configurar su cuenta. A continuación, puedes seleccionar la QPU que deseas utilizar para calcular el valor esperado.

Sigue los pasos que se indican en la sección «Configurar tu cuenta de IBM Cloud » si aún no tienes una cuenta.

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_marrakesh

2. Crea un circuito y una variable observable

Necesitas al menos un circuito y una variable 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 circuito y la variable observable deben transformarse para que utilicen únicamente instrucciones compatibles con la QPU (lo que se conoce como circuitos de arquitectura de conjunto de instrucciones, o ISA ). Para ello, utiliza el transpilador.

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. Inicializar el estimador « Qiskit Runtime »

Al iniciar Estimator, utiliza el mode parámetro para especificar el modo en el que deseas que se ejecute. Los valores posibles son batch, session, u backend objetos para los modos de ejecución por lotes, por sesión y por trabajo, respectivamente. Para obtener más información, consulte la sección «Introducción a los modos de ejecución de Qiskit Runtime ». Ten en cuenta que los usuarios de Open Plan no pueden enviar trabajos de sesión.

from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

4. Ejecuta Estimator y obtén los resultados

A continuación, invoca el run() método para calcular los valores esperados de los circuitos de entrada y las observables. Los conjuntos de valores de los parámetros de circuito, observables y opcionales se introducen como tuplas de bloques unificados primitivos ( 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: d9bjisbv6alc73ct56dg

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

Próximos pasos