Ejecutar tareas cuánticas durante una reserva

Tras obtener un ARN de reserva válido en Crear una reserva, puede crear tareas cuánticas para que se ejecuten durante la reserva. Estas tareas permanecen en ese QUEUED estado hasta que comience la reserva.

Puede crear tareas cuánticas utilizando Python SDKsBraket, QiskitPennyLane, o directamente con boto3 (trabajando con Boto3). Para utilizar las reservas, debes tener la versión 1.79.0 o superior de Amazon Braket. Python SDK Puedes actualizar el SDK, el Qiskit proveedor y el PennyLane plugin de Braket a la versión más reciente con el siguiente código.

pip install --upgrade amazon-braket-sdk amazon-braket-pennylane-plugin qiskit-braket-provider

Ejecuta tareas con el administrador de DirectReservation contexto

La forma recomendada de ejecutar una tarea dentro de la reserva programada es usar el administrador de DirectReservation contexto. Al especificar el dispositivo de destino y el ARN de reserva, el administrador de contexto garantiza que todas las tareas creadas en la with sentencia de Python se ejecuten con acceso exclusivo al dispositivo.

Primero, defina un circuito cuántico y el dispositivo. A continuación, utilice el contexto de reserva y ejecute la tarea.

from braket.aws import AwsDevice, DirectReservation
from braket.circuits import Circuit
from braket.devices import Devices

bell = Circuit().h(0).cnot(0, 1)
device = AwsDevice(Devices.IonQ.Aria1)

# run the circuit in a reservation
with DirectReservation(device, reservation_arn="<my_reservation_arn>"):
    task = device.run(bell, shots=100)

Puedes crear tareas cuánticas en una reserva mediante PennyLane Qiskit complementos, siempre que el DirectReservation contexto esté activo al crear tareas cuánticas. Por ejemplo, con el Qiskit-Braket proveedor, puede ejecutar las tareas de la siguiente manera.

from braket.devices import Devices
from braket.aws import DirectReservation
from qiskit import QuantumCircuit
from qiskit_braket_provider import BraketProvider


qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

aria = BraketProvider().get_backend("Aria 1")

# run the circuit in a reservation
with DirectReservation(Devices.IonQ.Aria1, reservation_arn="<my_reservation_arn>"):
    aria_task = aria.run(qc, shots=10)

Del mismo modo, el siguiente código ejecuta un circuito durante una reserva mediante el Braket-PennyLane complemento.

from braket.devices import Devices
from braket.aws import DirectReservation
import pennylane as qml


dev = qml.device("braket.aws.qubit", device_arn=Devices.IonQ.Aria1.value, wires=2, shots=10)

@qml.qnode(dev)
def bell_state():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.probs(wires=[0, 1])

# run the circuit in a reservation
with DirectReservation(Devices.IonQ.Aria1, reservation_arn="<my_reservation_arn>"):
    probs = bell_state()    

Configurar manualmente el contexto de la reserva

Como alternativa, puede configurar manualmente el contexto de la reserva con el siguiente código.

# set reservation context 
reservation = DirectReservation(device, reservation_arn="<my_reservation_arn>").start()

# run circuit during reservation
task = device.run(bell, shots=100)

Esto es ideal para los cuadernos de Jupyter, donde el contexto se puede ejecutar en la primera celda y todas las tareas subsiguientes se ejecutarán en la reserva.

Para volver al modo bajo demanda: reinicie el portátil Jupyter o llame a lo siguiente para volver a cambiar el contexto al modo bajo demanda.

reservation.stop()  # unset reservation context 

Pase explícitamente el ARN de reserva al crear la tarea

Otra forma de crear tareas durante una reserva consiste en pasar explícitamente el ARN de la reserva al llamar. device.run()

task = device.run(bell, shots=100, reservation_arn="<my_reservation_arn>")

Este método asocia directamente la tarea cuántica con el ARN de reserva, lo que garantiza que se ejecute durante el período reservado. Para esta opción, añada el ARN de reserva a cada tarea que vaya a ejecutar durante una reserva. Además, compruebe que las tareas se crearon Qiskit o PennyLane utilizan el ARN de reserva correcto. Debido a estas consideraciones adicionales, se recomiendan las dos formas anteriores.

Cuando utilices boto3 directamente, pasa el ARN de reserva como una asociación al crear una tarea.

import boto3

braket_client = boto3.client("braket")


kwargs["associations"] = [
    {
        "arn": "<my_reservation_arn>",
        "type": "RESERVATION_TIME_WINDOW_ARN",
    }
]

response = braket_client.create_quantum_task(**kwargs)