Executando vários programas - Amazon Braket
Sobre o conjunto de programas e os custosSobre o agrupamento e os custos de tarefas quânticasTratamento por lotes de tarefas quânticas e PennyLaneAgrupamento de tarefas e circuitos parametrizados

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Executando vários programas

O Amazon Braket oferece duas abordagens para executar vários programas quânticos de forma eficiente: conjuntos de programas e agrupamento de tarefas quânticas.

Os conjuntos de programas são a forma preferida de executar cargas de trabalho com vários programas. Eles permitem que você empacote vários programas em uma única tarefa quântica do Amazon Braket. Os conjuntos de programas oferecem melhorias de desempenho e economia de custos em comparação ao envio de programas individualmente, especialmente quando o número de execuções do programa se aproxima de 100.

Atualmente, IQM e Rigetti os dispositivos suportam conjuntos de programas. Antes de enviar o programa definido para QPUs, é recomendável testar primeiro no Amazon Braket Local Simulator. Para verificar se um dispositivo suporta conjuntos de programas, você pode visualizar as propriedades do dispositivo usando o Amazon Braket SDK ou visualizar a página do dispositivo no Amazon Braket Console.

O exemplo a seguir mostra como executar um conjunto de programas.

from math import pi
from braket.devices import LocalSimulator
from braket.program_sets import ProgramSet
from braket.circuits import Circuit

program_set = ProgramSet([
    Circuit().h(0).cnot(0,1),
    Circuit().rx(0, pi/4).ry(1, pi/8).cnot(1,0),
    Circuit().t(0).t(1).cz(0,1).s(0).cz(1,2).s(1).s(2),
])

device = LocalSimulator()
result = device.run(program_set, shots=300).result()
print(result[0][0].counts)  # The result of the first program in the program set

Para saber mais sobre as diferentes formas de construir um conjunto de programas (por exemplo, construir um conjunto de programas a partir de vários observáveis ou parâmetros com um único programa) e recuperar os resultados do conjunto de programas, consulte a seção de conjuntos de programas no Guia do desenvolvedor do Amazon Braket e a pasta de conjuntos de programas no repositório Github de exemplos do Braket.

O agrupamento quântico de tarefas está disponível em todos os dispositivos Amazon Braket. O agrupamento em lotes é especialmente útil para tarefas quânticas que você executa nos simuladores sob demanda (SV1, DM1 orTN1) porque eles podem processar várias tarefas quânticas em paralelo. O processamento em lotes permite que você inicie tarefas quânticas em paralelo. Por exemplo, se você deseja fazer um cálculo que exija 10 tarefas quânticas e os programas nessas tarefas quânticas são independentes uns dos outros, é recomendável usar o agrupamento de tarefas. Use o agrupamento quântico de tarefas ao executar cargas de trabalho com vários programas em um dispositivo que não suporta conjuntos de programas.

O exemplo a seguir mostra como executar um lote de tarefas quânticas.

from braket.circuits import Circuit
from braket.devices import LocalSimulator

bell = Circuit().h(0).cnot(0, 1)
circuits = [bell for _ in range(5)]

device = LocalSimulator()
batch = device.run_batch(circuits, shots=100)
print(batch.results()[0].measurement_counts)  # The result of the first quantum task in the batch

Para obter informações mais específicas sobre agrupamento em lotes, consulte os exemplos do Amazon GitHub Braket em.

Sobre o conjunto de programas e os custos

Os conjuntos de programas executam com eficiência vários programas quânticos, agrupando até 100 programas ou conjuntos de parâmetros em uma única tarefa quântica. Com os conjuntos de programas, você paga apenas uma taxa por tarefa mais as taxas por dose com base no total de fotos em todos os programas, reduzindo significativamente os custos em comparação com o envio de programas individualmente. Essa abordagem é particularmente benéfica para cargas de trabalho com muitos programas e com baixo número de disparos por programa. Atualmente, os conjuntos de programas são compatíveis com Rigetti dispositivos IQM e com o Amazon Braket Local Simulator.

Para obter mais informações, consulte a seção Conjuntos de programas para ver as etapas detalhadas de implementação, as melhores práticas e exemplos de código.

Sobre o agrupamento e os custos de tarefas quânticas

Algumas ressalvas a serem lembradas em relação aos custos de agrupamento e cobrança de tarefas quânticas:

  • Por padrão, o agrupamento de tarefas quânticas tenta novamente o tempo limite ou falha nas tarefas quânticas 3 vezes.

  • Um lote de tarefas quânticas de longa execução, como 34 qubits paraSV1, pode gerar grandes custos. Certifique-se de verificar cuidadosamente os valores da run_batch atribuição antes de iniciar um lote de tarefas quânticas. Não recomendamos o uso TN1 comrun_batch.

  • TN1podem incorrer em custos por falhas nas tarefas da fase de ensaio (consulte a TN1 descrição para obter mais informações). Novas tentativas automáticas podem aumentar o custo e, portanto, recomendamos definir o número de 'max_retries' no lote como 0 durante o uso TN1 (consulte Quantum Task Batching, Linha 186).

Tratamento por lotes de tarefas quânticas e PennyLane

Aproveite o agrupamento em lotes ao usar PennyLane no Amazon Braket parallel = True configurando quando você instancia um dispositivo Amazon Braket, conforme mostrado no exemplo a seguir.

import pennylane as qml

# Define the number of wires (qubits) you want to use
wires = 2  # For example, using 2 qubits

# Define your S3 bucket 
my_bucket = "amazon-braket-s3-demo-bucket"
my_prefix = "pennylane-batch-output"
s3_folder = (my_bucket, my_prefix)

device = qml.device("braket.aws.qubit", 
                    device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1", 
                    wires=wires, 
                    s3_destination_folder=s3_folder, 
                    parallel=True)

Para obter mais informações sobre o agrupamento em lotes com PennyLane, consulte Otimização paralelizada de circuitos quânticos.

Agrupamento de tarefas e circuitos parametrizados

Ao enviar um lote de tarefas quânticas que contém circuitos parametrizados, você pode fornecer um inputs dicionário, que é usado para todas as tarefas quânticas do lote, ou um dicionário list de entrada. Nesse caso, o -ésimo dicionário é emparelhado com a i -ésima tarefa, conforme mostrado no exemplo a i seguir.

from braket.circuits import Circuit, FreeParameter, Observable
from braket.aws import AwsQuantumTaskBatch, AwsDevice

# Define your quantum device
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")

# Create the free parameters
alpha = FreeParameter('alpha')
beta = FreeParameter('beta')

# Create two circuits
circ_a = Circuit().rx(0, alpha).ry(1, alpha).cnot(0, 2).xx(0, 2, beta)
circ_a.variance(observable=Observable.Z(), target=0)

circ_b = Circuit().rx(0, alpha).rz(1, alpha).cnot(0, 2).zz(0, 2, beta)
circ_b.expectation(observable=Observable.Z(), target=2)

# Use the same inputs for both circuits in one batch
tasks = device.run_batch([circ_a, circ_b], inputs={'alpha': 0.1, 'beta': 0.2})

# Or provide each task its own set of inputs
inputs_list = [{'alpha': 0.3, 'beta': 0.1}, {'alpha': 0.1, 'beta': 0.4}]

tasks = device.run_batch([circ_a, circ_b], inputs=inputs_list)

Você também pode preparar uma lista de dicionários de entrada para um único circuito paramétrico e enviá-los como um lote de tarefas quânticas. Se houver N dicionários de entrada na lista, o lote contém N tarefas quânticas. A i -ésima tarefa quântica corresponde ao circuito executado com o i -ésimo dicionário de entrada. 

from braket.circuits import Circuit, FreeParameter

# Create a parametric circuit
circ = Circuit().rx(0, FreeParameter('alpha'))

# Provide a list of inputs to execute with the circuit
inputs_list = [{'alpha': 0.1}, {'alpha': 0.2}, {'alpha': 0.3}]

tasks = device.run_batch(circ, inputs=inputs_list, shots=100)