本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 執行多個程式
<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 Local Simulator 上進行測試](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 裝置都可以使用 **Quantum 任務批次**處理。批次處理對於您在隨需模擬器 ( DM1或 TN1) 上執行的量子任務特別有用SV1，因為它們可以平行處理多個量子任務。批次處理可讓您平行啟動量子任務。例如，如果您想要進行需要 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
```

如需批次處理的詳細資訊，請參閱 GitHub 上的 [Amazon Braket 範例](https://github.com/amazon-braket/amazon-braket-examples)。

**Topics**
+ [關於程式集和成本](#braket-program-sets-costs)
+ [關於量子任務批次處理和成本](#braket-batching-costs)
+ [Quantum 任務批次處理和 PennyLane](#braket-batching-pennylane)
+ [任務批次處理和參數化電路](#braket-batching-parametrized-circuits)

## 關於程式集和成本
<a name="braket-program-sets-costs"></a>

程式集透過將最多 100 個程式或參數集封裝到單一量子任務中，有效率地執行多個量子程式。使用程式集時，您只需要支付一次每個任務費用，加上根據所有程式的總拍攝次數，相較於個別提交程式，可大幅降低成本。這種方法特別適用於具有許多程式和每個程式拍攝次數較少的工作負載。IQM 和 Rigetti 裝置以及 Amazon Braket Local Simulator 目前支援程式集。

如需詳細資訊，請參閱[程式集](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set)一節，了解詳細的實作步驟、最佳實務和程式碼範例。

## 關於量子任務批次處理和成本
<a name="braket-batching-costs"></a>

有關量子任務批次處理和帳單成本的一些注意事項：
+ 根據預設，量子任務批次會重試所有逾時或失敗量子任務 3 次。
+ 一批長時間執行的量子任務，例如 qubits的 34SV1，可能會產生大量成本。開始一批量子任務之前，請務必仔細仔細檢查`run_batch`指派值。我們不建議使用 TN1搭配 `run_batch`。
+  TN1 可能產生失敗演練階段任務的成本 （如需詳細資訊[，請參閱 TN1 說明](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html#braket-simulator-tn1))。自動重試可以新增到成本中，因此我們建議在使用 時將批次處理的 'max\_retries' 數目設定為 0 TN1（請參閱 [Quantum 任務批次處理，第 186 行](https://github.com/aws/amazon-braket-sdk-python/blob/4c7c3b28e5a17b8f0cddf94377b7734fcbe2ebfc/src/braket/aws/aws_quantum_task_batch.py#L186))。

## Quantum 任務批次處理和 PennyLane
<a name="braket-batching-pennylane"></a>

當您在 Amazon Braket 上使用 PennyLane 時，請透過在執行個體化 Amazon Braket 裝置`parallel = True`時設定 來利用批次處理，如下列範例所示。

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