Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Ejecución de varios programas
Amazon Braket ofrece dos enfoques para ejecutar varios programas cuánticos de manera eficiente: conjuntos de programas y procesamiento por lotes de tareas cuánticas.
Los **conjuntos de programas** son la forma preferida de ejecutar cargas de trabajo con varios programas. Permiten empaquetar varios programas en una sola tarea cuántica de Amazon Braket. Los conjuntos de programas ofrecen [mejoras en el rendimiento](https://aws.amazon.com/blogs/quantum-computing/amazon-braket-introduces-program-sets-enabling-customers-to-run-quantum-programs-up-to-24x-faster/) y un ahorro de costos en comparación con el envío de programas de forma individual, especialmente cuando el número de ejecuciones de programas se acerca a las 100.
Actualmente, los dispositivos IQM y Rigetti admiten conjuntos de programas. Antes de enviar los conjuntos de programas QPUs, se recomienda [probarlos primero en el simulador local de Amazon Braket](https://docs.aws.amazon.com/braket/latest/developerguide/braket-send-to-local-simulator.html). Para comprobar si un dispositivo admite conjuntos de programas, puede ver las [propiedades del dispositivo](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/braket_features/Getting_Devices_and_Checking_Device_Properties.ipynb) mediante el SDK de Amazon Braket o consultar la página del dispositivo en la [consola de Amazon Braket](https://console.aws.amazon.com/braket/).
El siguiente ejemplo muestra cómo ejecutar un 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 obtener más información sobre las diferentes formas de construir un conjunto de programas (por ejemplo, construir un conjunto de programas a partir de muchos observables o parámetros con un solo programa) y recuperar los resultados del conjunto de programas, consulte la sección de [conjuntos de programas](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set) de la *Guía para desarrolladores de Amazon Braket* y la [carpeta de conjuntos de programas](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/braket_features/program_sets) del repositorio de GitHub de ejemplos de Braket.
El **procesamiento por lotes de tareas cuánticas** está disponible en todos los dispositivos de Amazon Braket. El procesamiento por lotes es especialmente útil para las tareas cuánticas que se ejecutan en los simuladores bajo demanda (SV1, DM1 o TN1) porque pueden procesar varias tareas cuánticas en paralelo. El procesamiento por lotes le permite iniciar tareas cuánticas en paralelo. Por ejemplo, si desea realizar un cálculo que requiera 10 tareas cuánticas y los programas de esas tareas cuánticas son independientes entre sí, se recomienda utilizar el procesamiento por lotes de tareas. Utilice el procesamiento de tareas cuánticas por lotes cuando ejecute cargas de trabajo con varios programas en un dispositivo que no admita conjuntos de programas.
El siguiente ejemplo muestra cómo ejecutar un lote de tareas cuá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 obtener información más específica sobre el procesamiento por lotes, consulta los ejemplos de [Amazon Braket](https://github.com/amazon-braket/amazon-braket-examples) en. GitHub
**Topics**
+ [Acerca del conjunto de programas y los costos](#braket-program-sets-costs)
+ [Acerca del procesamiento por lotes de tareas cuánticas y los costos](#braket-batching-costs)
+ [Procesamiento por lotes de tareas cuánticas y PennyLane](#braket-batching-pennylane)
+ [Procesamiento por lotes de tareas y circuitos parametrizados](#braket-batching-parametrized-circuits)
## Acerca del conjunto de programas y los costos
Los conjuntos de programas ejecutan varios programas cuánticos de manera eficiente al empaquetar hasta 100 programas o conjuntos de parámetros en una sola tarea cuántica. Con los conjuntos de programas, solo paga una tarifa por tarea más las tarifas por shot en función del total de shots de todos los programas, lo que reduce considerablemente los costos en comparación con el envío de los programas de forma individual. Este enfoque resulta especialmente ventajoso para las cargas de trabajo con muchos programas y con un número reducido de shots por programa. Actualmente, los conjuntos de programas son compatibles con los dispositivos IQM y Rigetti y con el simulador local de Amazon Braket.
Para obtener más información, consulte la sección [Conjuntos de programas](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set) para ver los pasos de implementación detallados, las mejores prácticas y los ejemplos de código.
## Acerca del procesamiento por lotes de tareas cuánticas y los costos
Algunas advertencias a tener en cuenta con respecto a los costos de facturación y el procesamiento por lotes de tareas cuánticas:
+ De forma predeterminada, el procesamiento por lotes de tareas cuánticas se reintenta cada vez que se agota el tiempo de espera o las tareas cuánticas fallan 3 veces.
+ Un lote de tareas cuánticas de larga duración, como 34 qubits para SV1, puede generar grandes costos. Asegúrese de comprobar con cuidado los valores de las asignaciones de `run_batch` antes de iniciar un lote de tareas cuánticas. No recomendamos el uso de TN1 con `run_batch`.
+ TN1pueden incurrir en costes si no se realizan tareas de la fase de ensayo (consulte [la TN1 descripción](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html#braket-simulator-tn1) para obtener más información). Los reintentos automáticos pueden aumentar el costo, por lo que recomendamos establecer «max\_retries» en el procesamiento por lotes en 0 cuando se utilice TN1 (consulte [Procesamiento por lotes de tareas cuánticas, línea 186](https://github.com/aws/amazon-braket-sdk-python/blob/4c7c3b28e5a17b8f0cddf94377b7734fcbe2ebfc/src/braket/aws/aws_quantum_task_batch.py#L186)).
## Procesamiento por lotes de tareas cuánticas y PennyLane
Aprovecha el procesamiento por lotes cuando utilices PennyLane Amazon Braket `parallel = True` configurando cuándo instancias un dispositivo Amazon Braket, como se muestra en el siguiente ejemplo.
```
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 obtener más información sobre el procesamiento por lotes con PennyLane, consulte Optimización paralelizada de circuitos cuánticos.](https://github.com/aws/amazon-braket-examples/blob/main/examples/pennylane/1_Parallelized_optimization_of_quantum_circuits/1_Parallelized_optimization_of_quantum_circuits.ipynb)
## Procesamiento por lotes de tareas y circuitos parametrizados
Al enviar un lote de tareas cuánticas que contenga circuitos parametrizados, puede proporcionar un diccionario de `inputs`, que se utiliza para todas las tareas cuánticas del lote o una `list` de diccionarios de entrada, en cuyo caso el diccionario `i`-th se empareja con la tarea `i`-th, como se muestra en el siguiente ejemplo.
```
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)
```
También puede preparar una lista de diccionarios de entrada para un único circuito paramétrico y enviarlos como un lote de tareas cuánticas. Si hay N diccionarios de entrada en la lista, el lote contiene N tareas cuánticas. La tarea cuántica `i`-th corresponde al circuito ejecutado con el diccionario de entrada `i`-th.
```
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)
```