Executando tarefas quânticas durante uma reserva

Depois de obter uma reserva válida em ARN Criar uma reserva, você pode criar tarefas quânticas para serem executadas durante a reserva. Essas tarefas permanecem no QUEUED estado até o início de sua reserva.

nota

As reservas são AWS específico da conta e do dispositivo. Somente o AWS A conta que criou a reserva pode usar sua reservaARN.

nota

Não há visibilidade de fila para tarefas e trabalhos enviados com uma reserva ARN porque somente suas tarefas são executadas durante a reserva.

Você pode criar tarefas quânticas usando Python SDKs como Braket, Qiskit, PennyLane, ou diretamente com o boto3 (Trabalhando com o Boto3). Para usar reservas, você deve ter a versão v1.79.0 ou superior do Amazon Braket Python SDK. Você pode atualizar para o SDK Braket mais recente, Qiskit provedor e PennyLane plugin com o seguinte código.

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

Execute tarefas com o gerenciador de DirectReservation contexto

A forma recomendada de executar uma tarefa dentro da sua reserva agendada é usar o gerenciador de DirectReservation contexto. Ao especificar o dispositivo de destino e a reservaARN, o gerenciador de contexto garante que todas as tarefas criadas na instrução with Python sejam executadas com acesso exclusivo ao dispositivo.

Primeiro, defina um circuito quântico e o dispositivo. Em seguida, use o contexto de reserva e execute a tarefa.

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)

Você pode criar tarefas quânticas em uma reserva usando PennyLane e Qiskit plugins, desde que o DirectReservation contexto esteja ativo durante a criação de tarefas quânticas. Por exemplo, com o Qiskit-Braket provedor, você pode executar tarefas da seguinte forma.

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)

Da mesma forma, o código a seguir executa um circuito durante uma reserva usando o Braket-PennyLane plugin.

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()    

Configurando manualmente o contexto da reserva

Como alternativa, você pode definir manualmente o contexto da reserva com o código a seguir.

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

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

Isso é ideal para notebooks Jupyter, onde o contexto pode ser executado na primeira célula e todas as tarefas subsequentes serão executadas na reserva.

nota

A célula que contém a .start() chamada só deve ser executada uma vez.

Para voltar ao modo sob demanda: reinicie o notebook Jupyter ou ligue para o seguinte para alterar o contexto de volta para o modo sob demanda.

reservation.stop()  # unset reservation context 

nota

As reservas têm um horário de início e término programado (consulte Criar uma reserva). Os reservation.stop() métodos reservation.start() e não iniciam nem encerram uma reserva. Esses são métodos para modificar todas as tarefas quânticas subsequentes a serem executadas durante a reserva. Esses métodos não têm efeito no horário agendado da reserva.

Passe explicitamente a reserva ARN ao criar a tarefa

Outra forma de criar tarefas durante uma reserva é passar explicitamente a reserva ARN ao ligardevice.run().

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

Esse método associa diretamente a tarefa quântica à reservaARN, garantindo que ela seja executada durante o período reservado. Para essa opção, adicione a reserva ARN a cada tarefa que você planeja executar durante uma reserva. Além disso, verifique se as tarefas foram criadas no Qiskit ou PennyLane estão usando a reserva corretaARN. Devido a essas considerações adicionais, as duas formas anteriores são recomendadas.

Ao usar o boto3 diretamente, transmita a reserva ARN como uma associação ao criar uma tarefa.

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)