Guía rápida de Executor

• 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.4.0
  qiskit-ibm-runtime~=0.46.1
  samplomatic~=0.18.0
  

Al igual que la primitiva Sampler, Executor toma muestras de los registros de salida de las ejecuciones de circuitos cuánticos, pero no cuenta con ningún mecanismo integrado de supresión o mitigación de errores. Más bien, forma parte del modelo de ejecución dirigida, que proporciona los elementos necesarios para reflejar las intenciones del diseño en el lado del cliente y traslada la costosa generación de variantes de circuitos al lado del servidor. El ejecutor sigue las instrucciones proporcionadas en las anotaciones y opciones de los circuitos, genera y asigna los valores de los parámetros, ejecuta los circuitos asignados en el hardware y devuelve los resultados de la ejecución y los metadatos. No toma ninguna decisión por ti de forma implícita y te ofrece un control total y total transparencia.

Antes de empezar

Algunos de los ejemplos de código de esta página utilizan samplex, que forma parte del paquete Samplomatic. Por lo tanto, antes de ejecutar esos bloques de código, debes instalar Samplomatic, tal y como se muestra en el siguiente bloque de código. Para obtener más información, consulta la documentación de Samplomatic.

pip install samplomatic

# For visualization support, include the visualization dependencies.
# pip install samplomatic[vis]

Pasos para utilizar la primitiva Executor

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 guía «Configurar tu cuenta de IBM Cloud® » si aún no tienes una cuenta.

from qiskit_ibm_runtime import QiskitRuntimeService, Executor
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from samplomatic.transpiler import generate_boxing_pass_manager
from samplomatic import build

# Initialize the service and choose a backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

print(backend)

Output:

<IBMBackend('ibm_fez')>

2. Crear y compilar un circuito

Se necesita al menos un circuito para utilizar la primitiva Executor. Opcionalmente, puede tener parámetros.

# Generate the circuit
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.h(1)
circuit.cz(0, 1)
circuit.h(1)

# Using `measure_all` automatically creates the necessary
# classical registers.
circuit.measure_all()

Es necesario modificar el circuito para que utilice ú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.

# Transpile the circuit
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=0
)
isa_circuit = preset_pass_manager.run(circuit)

3. Inicializar un objeto QuantumProgram

Inicializa un QuantumProgram con tu carga de trabajo. A QuantumProgram está compuesto por QuantumProgramItems. Por lo general, cada elemento consta de un circuito, un conjunto de valores de parámetros y, en algunos casos, un mecanismo samplex para aleatorizar el contenido del circuito. Para obtener más información, consulta «Entradas y salidas del ejecutor ».

La siguiente celda inicializa un QuantumProgram y especifica que se realicen 25 disparos. A continuación, añade el circuito de destino compilado.

# Initialize an empty program
program = QuantumProgram(shots=25)

# Append the circuit to the program
program.append_circuit_item(isa_circuit)

4. Opcional: Agrupa las puertas y las mediciones en recuadros con anotaciones

Agrupar las instrucciones en bloques y añadirles comentarios es la forma principal de expresar lo que quieres hacer. En el siguiente ejemplo, utilizamos generate_boxing_pass_manager y sus parámetros de giro para agrupar puertas de dos qubits y mediciones en recuadros y aplicar la anotación de giro.

# Generate a boxing pass manager to group gates
# and measurements into boxes and add
# a`Twirl` annotation.
boxes_pm = generate_boxing_pass_manager(
    # Add gate twirling
    enable_gates=True,
    # Add measurement twirling
    enable_measures=True,
)

boxed_circuit = boxes_pm.run(isa_circuit)
boxed_circuit.draw("mpl", idle_wires=False)

Output:

5. Opcional: Crea un circuito de referencia y un samplex, y añádelos al programa

A continuación, utiliza el método de construcción «Samplomatic» para generar el circuito de referencia y el par de samplex. El circuito modelo es estructuralmente equivalente al circuito original. Sin embargo, sus puertas de un solo qubit se sustituyen por puertas parametrizadas con el fin de implementar las anotaciones prescritas (rotación de puertas y mediciones, en este ejemplo). El samplex codifica toda la información necesaria para generar parámetros aleatorios para el circuito de plantilla.

Una vez generados el circuito de plantilla y el par de muestras, utiliza el append_samplex_item método para añadir el par al programa.

Consulte la documentación de la API de Samplomatic para obtener información detallada sobre samplomatic.samplex.Samplex y sus argumentos.

# Build the template circuit and the samplex
template_circuit, samplex = build(boxed_circuit)

# Append the template circuit and samplex as a `samplex_item`
program.append_samplex_item(
    template_circuit,
    samplex=samplex,
    shape=(num_randomizations := 20,),
)

6. Ejecutar el programa y obtener los resultados

Ejecuta el QuantumProgram en un backend de IBM® utilizando la Executor primitiva con las opciones predeterminadas. Consulte las opciones de Executor para conocer las opciones disponibles.

# Initialize an Executor with the default options
executor = Executor(mode=backend)

# Submit the job
job = executor.run(program)
job

Output:

<RuntimeJobV2('d8286580bvlc73d1vmsg', 'executor')>

# Retrieve the result
result = job.result()

El resultado es de tipo QuantumProgramResult. Consulta «Entradas y salidas de Executor» para obtener más información sobre el objeto de resultado.

Próximos pasos