Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esecuzione di più programmi
Amazon Braket offre due approcci per eseguire più programmi quantistici in modo efficiente: set di programmi e batch di attività quantistiche.
I **set di programmi** sono il modo preferito per eseguire carichi di lavoro con più programmi. Consentono di raggruppare più programmi in un'unica attività quantistica di Amazon Braket. I set di programmi offrono [miglioramenti delle prestazioni](https://aws.amazon.com/blogs/quantum-computing/amazon-braket-introduces-program-sets-enabling-customers-to-run-quantum-programs-up-to-24x-faster/) e risparmi sui costi rispetto all'invio di programmi singolarmente, soprattutto quando il numero di esecuzioni di programmi si avvicina a 100.
Attualmente, Rigetti tutti IQM i dispositivi supportano i set di programmi. Prima di inviare i set di programmi a QPUs, si consiglia di eseguire prima [il test su Amazon Braket Local](https://docs.aws.amazon.com/braket/latest/developerguide/braket-send-to-local-simulator.html) Simulator. [Per verificare se un dispositivo supporta i set di programmi, puoi visualizzare le [proprietà del dispositivo](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/braket_features/Getting_Devices_and_Checking_Device_Properties.ipynb) utilizzando Amazon Braket SDK o visualizzare la pagina del dispositivo nella console Amazon Braket.](https://console.aws.amazon.com/braket/)
L'esempio seguente mostra come eseguire un set di programmi.
```
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
```
Per saperne di più sui diversi modi di costruire un set di programmi (ad esempio, costruire un set di programmi da più osservabili o parametri con un singolo programma) e recuperare i risultati dei set di programmi, consulta la sezione [Program sets](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set) nella Amazon Braket *Developer Guide e la cartella program sets nel repository Braket* [examples Github](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/braket_features/program_sets).
Il **quantum task batching** è disponibile su tutti i dispositivi Amazon Braket. Il batching è particolarmente utile per le attività quantistiche eseguite sui simulatori on-demand (SV1, DM1 orTN1) perché possono elaborare più attività quantistiche in parallelo. Il batching consente di avviare attività quantistiche in parallelo. Ad esempio, se si desidera eseguire un calcolo che richiede 10 attività quantistiche e i programmi in tali attività quantistiche sono indipendenti l'uno dall'altro, si consiglia di utilizzare il task batching. Utilizzate il quantum task batching quando eseguite carichi di lavoro con più programmi su un dispositivo che non supporta set di programmi.
L'esempio seguente mostra come eseguire un batch di attività quantistiche.
```
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
```
Per informazioni più specifiche sul batching, consulta gli esempi di [Amazon Braket](https://github.com/amazon-braket/amazon-braket-examples) su. GitHub
**Topics**
+ [Informazioni sul set e sui costi del programma](#braket-program-sets-costs)
+ [Informazioni sul raggruppamento quantistico delle attività e sui costi](#braket-batching-costs)
+ [Quantum task batching e PennyLane](#braket-batching-pennylane)
+ [Task batching e circuiti parametrizzati](#braket-batching-parametrized-circuits)
## Informazioni sul set e sui costi del programma
I set di programmi eseguono in modo efficiente più programmi quantistici raggruppando fino a 100 programmi o set di parametri in un'unica attività quantistica. Con i set di programmi, paghi solo una tariffa per attività più le tariffe per ripresa basate sul totale delle riprese di tutti i programmi, riducendo significativamente i costi rispetto all'invio dei programmi singolarmente. Questo approccio è particolarmente utile per carichi di lavoro con molti programmi e con un numero ridotto di riprese per programma. I set di programmi sono attualmente supportati su Rigetti dispositivi IQM e, oltre che su Amazon Braket Local Simulator.
Per ulteriori informazioni, consulta la sezione [Set di programmi](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#braket-program-set) per passaggi di implementazione dettagliati, best practice ed esempi di codice.
## Informazioni sul raggruppamento quantistico delle attività e sui costi
Alcune avvertenze da tenere a mente per quanto riguarda il raggruppamento quantistico delle attività e i costi di fatturazione:
+ Per impostazione predefinita, il quantum task batching riprova ogni volta o fallisce le attività quantistiche 3 volte.
+ Un batch di attività quantistiche di lunga durata, ad esempio 34 qubits forSV1, può comportare costi elevati. Assicuratevi di ricontrollare attentamente i valori di `run_batch` assegnazione prima di iniziare una serie di attività quantistiche. Si sconsiglia l'utilizzo conTN1. `run_batch`
+ TN1può comportare costi in caso di mancata riuscita delle attività della fase di prova (per ulteriori informazioni, consulta [la TN1 descrizione](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html#braket-simulator-tn1)). [I nuovi tentativi automatici possono aumentare il costo, quindi consigliamo di impostare il numero di «max\_retry» per il batch su 0 quando si utilizza TN1 (vedere Quantum Task Batching, riga 186).](https://github.com/aws/amazon-braket-sdk-python/blob/4c7c3b28e5a17b8f0cddf94377b7734fcbe2ebfc/src/braket/aws/aws_quantum_task_batch.py#L186)
## Quantum task batching e PennyLane
Sfrutta i vantaggi del batch quando utilizzi PennyLane Amazon Braket `parallel = True` impostando quando crei un'istanza di un dispositivo Amazon Braket, come illustrato nell'esempio seguente.
```
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)
```
[Per ulteriori informazioni sul batching with, consulta Ottimizzazione parallelizzata dei circuiti PennyLane quantistici.](https://github.com/aws/amazon-braket-examples/blob/main/examples/pennylane/1_Parallelized_optimization_of_quantum_circuits/1_Parallelized_optimization_of_quantum_circuits.ipynb)
## Task batching e circuiti parametrizzati
Quando si invia un batch di attività quantistiche che contiene circuiti parametrizzati, è possibile fornire un `inputs` dizionario, che viene utilizzato per tutte le attività quantistiche `list` del batch, o un dizionario di input, nel qual caso il dizionario `i` -th viene abbinato `i` al task -th, come mostrato nell'esempio seguente.
```
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)
```
È inoltre possibile preparare un elenco di dizionari di input per un singolo circuito parametrico e inviarli come batch di operazioni quantistiche. Se nell'elenco sono presenti N dizionari di input, il batch contiene N task quantistici. Il task quantistico `i` -th corrisponde al circuito eseguito con il dizionario di input -th. `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)
```