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á.
# Executar 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 workloads 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](https://aws.amazon.com/blogs/quantum-computing/amazon-braket-introduces-program-sets-enabling-customers-to-run-quantum-programs-up-to-24x-faster/) 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, os dispositivos IQM e Rigetti suportam conjuntos de programas. Antes de enviar o programa definido para QPUs, é recomendável [testar primeiro no Amazon Braket Local Simulator](https://docs.aws.amazon.com/braket/latest/developerguide/braket-send-to-local-simulator.html). Para verificar se um dispositivo suporta conjuntos de programas, você pode visualizar as [propriedades do dispositivo](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/braket_features/Getting_Devices_and_Checking_Device_Properties.ipynb) usando o Amazon Braket SDK ou visualizar a página do dispositivo no [Amazon Braket Console](https://console.aws.amazon.com/braket/).
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](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set) no *Guia do desenvolvedor do Amazon Braket* e a [pasta de conjuntos de programas](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/braket_features/program_sets) 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 ou TN1) 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 workloads 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](https://github.com/amazon-braket/amazon-braket-examples) em.
**Topics**
+ [Sobre o conjunto de programas e os custos](#braket-program-sets-costs)
+ [Sobre lotes e custos de tarefas quânticas](#braket-batching-costs)
+ [Tratamento por lotes de tarefas quânticas e PennyLane](#braket-batching-pennylane)
+ [Agrupamento de tarefas e circuitos parametrizados](#braket-batching-parametrized-circuits)
## 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 workloads com muitos programas e com baixo número de disparos por programa. Atualmente, os conjuntos de programas são suportados em dispositivos Rigetti e IQM, e no Amazon Braket Local Simulator.
Para obter mais informações, consulte a seção [Conjuntos de programas](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set) para ver as etapas detalhadas de implementação, as melhores práticas e exemplos de código.
## Sobre lotes e 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 atribuição `run_batch` antes de iniciar um lote de tarefas quânticas. Não recomendamos usar TN1 com `run_batch`.
+ TN1podem incorrer em custos por falhas nas tarefas da fase de ensaio (consulte [a TN1 descrição](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html#braket-simulator-tn1) 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 ao usar TN1 (consulte [Agrupamento de tarefas quânticas, Linha 186](https://github.com/aws/amazon-braket-sdk-python/blob/4c7c3b28e5a17b8f0cddf94377b7734fcbe2ebfc/src/braket/aws/aws_quantum_task_batch.py#L186)).
## 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](https://github.com/aws/amazon-braket-examples/blob/main/examples/pennylane/1_Parallelized_optimization_of_quantum_circuits/1_Parallelized_optimization_of_quantum_circuits.ipynb) 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 dicionário `inputs`, que é usado para todas as tarefas quânticas do lote, ou um dicionário `list` de entrada. Nesse caso, o `i`-ésimo dicionário é emparelhado com a `i`-ésima tarefa, conforme mostrado no exemplo a 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)
```