本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 运行多个程序
<a name="braket-batching-tasks"></a>

Amazon Braket 提供了两种高效运行多个量子程序的方法，即程序集和量子任务批处理。

**程序集**是使用多个程序运行工作负载的首选方式。它们可将多个程序打包成单个 Amazon Braket 量子任务。与单独提交程序相比，程序集可以[提高性能](https://aws.amazon.com/blogs/quantum-computing/amazon-braket-introduces-program-sets-enabling-customers-to-run-quantum-programs-up-to-24x-faster/)并节省成本，尤其是当程序执行数量接近 100 时。

目前，IQM 和 Rigetti 设备支持程序集。在向提交程序集之前 QPUs，建议先[在 Amazon Braket 本地模拟器上进行测试](https://docs.aws.amazon.com/braket/latest/developerguide/braket-send-to-local-simulator.html)。要检查设备是否支持程序集，您可以使用 Amazon Braket SDK [查看设备属性](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/braket_features/Getting_Devices_and_Checking_Device_Properties.ipynb)，或者在 [Amazon Braket](https://console.aws.amazon.com/braket/) 控制台中查看设备页面。

以下示例显示了如何运行程序集。

```
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
```

要详细了解构造程序集（例如，使用单个程序从多个可观察对象或参数构造程序集）和检索程序集结果的不同方法，请参阅《Amazon Braket 开发人员指南》**中的“[程序集](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set)”部分和 Braket 示例 Github 存储库中的[程序集文件夹](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/braket_features/program_sets)。

每台 Amazon Braket 设备都支持**量子任务批处理**。批处理对于在按需模拟器（SV1、DM1 或 TN1）上运行的量子任务特别有用，因为它们可以并行处理多个量子任务。批处理可并行启动量子任务。例如，如果您希望进行需要 10 项量子任务的计算，并且这些量子任务中的程序相互独立，则建议使用任务批处理。在不支持程序集的设备上运行包含多个程序的工作负载时，请使用量子任务批处理。

以下示例显示了如何运行量子任务。

```
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
```

有关批处理的更多具体信息，请参阅上的 [Amazon Braket 示例](https://github.com/amazon-braket/amazon-braket-examples)。 GitHub

**Topics**
+ [关于程序集和费用](#braket-program-sets-costs)
+ [关于量子任务批处理和成本](#braket-batching-costs)
+ [量子任务批处理和 PennyLane](#braket-batching-pennylane)
+ [任务批处理和参数化电路](#braket-batching-parametrized-circuits)

## 关于程序集和费用
<a name="braket-program-sets-costs"></a>

程序集通过将多达 100 个程序或参数集打包到单个量子任务中来高效运行多个量子程序。对于程序集，您只需支付每项任务的费用以及基于所有程序总拍摄次数的每次拍摄费用，这与单独提交程序相比，显著降低了成本。这种方法对于有许多程序且每个程序的拍摄次数较少的工作负载特别有用。目前，IQM 和 Rigetti 设备以及 Amazon Braket 本地模拟器都支持程序集。

有关更多信息，请参阅“[程序集](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set)”部分，了解详细的实现步骤、最佳实践和代码示例。

## 关于量子任务批处理和成本
<a name="braket-batching-costs"></a>

关于量子任务批处理和计费成本，请记住一些注意事项：
+ 默认情况下，量子任务批处理重试全部超时或量子任务失败 3 次。
+ 一批长时间运行的量子任务（例如：对于 SV1，为 34 个 qubits）可能会产生高昂的费用。在开始一批量子任务之前，请务必仔细检查 `run_batch` 分配值。我们不建议 TN1 搭配 `run_batch` 使用。
+  TN1可能因排练阶段的任务失败而产生费用（有关更多信息[，请参阅 TN1 说明](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html#braket-simulator-tn1)）。自动重试可能会增加成本，因此我们建议在使用 TN1 时将批处理时的“max\_retries”次数设置为 0（参见[量子任务批处理，第 186 行](https://github.com/aws/amazon-braket-sdk-python/blob/4c7c3b28e5a17b8f0cddf94377b7734fcbe2ebfc/src/braket/aws/aws_quantum_task_batch.py#L186)）。

## 量子任务批处理和 PennyLane
<a name="braket-batching-pennylane"></a>

在 Amazon Braket PennyLane 上使用时，通过`parallel = True`设置实例化 Amazon Braket 设备的时间，充分利用批处理功能，如以下示例所示。

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

有关批处理的更多信息 PennyLane，请参阅量子电路[的并行优化。](https://github.com/aws/amazon-braket-examples/blob/main/examples/pennylane/1_Parallelized_optimization_of_quantum_circuits/1_Parallelized_optimization_of_quantum_circuits.ipynb)

## 任务批处理和参数化电路
<a name="braket-batching-parametrized-circuits"></a>

在提交包含参数化电路的量子任务批处理时，您可以提供 `inputs` 字典（用于批次中的所有量子任务）或输入字典的 `list`，在第二种情况下，第 `i` 个字典与第 `i` 个任务配对，如以下示例所示。

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

您还可以为单个参数电路准备输入字典列表，然后将其作为量子任务批量提交。如果列表中有 N 个输入字典，则该批次包含 N 个量子任务。第 `i` 个量子任务对应于使用第 `i` 个输入字典执行的电路。

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