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à.
# Esegui le tue attività quantistiche con Amazon Braket
Braket fornisce un accesso sicuro e su richiesta a diversi tipi di computer quantistici. Hai accesso ai computer quantistici basati su gate daAQT,, e IonQIQM, nonché a un simulatore Rigetti hamiltoniano analogico di. QuEra Inoltre, non hai alcun impegno anticipato e non devi procurarti l'accesso tramite singoli provider.
+ La [console Amazon Braket](https://console.aws.amazon.com/braket/home) fornisce informazioni e stato del dispositivo per aiutarti a creare, gestire e monitorare le tue risorse e le tue attività quantistiche.
+ Invia ed esegui attività quantistiche tramite l'SDK [Amazon Braket Python](https://github.com/aws/amazon-braket-sdk-python) e tramite la console. L'SDK è accessibile tramite notebook Braket preconfigurati. Amazon
+ L'[API Amazon Braket](https://docs.aws.amazon.com/braket/latest/APIReference/Welcome.html) è accessibile tramite l'SDK e i notebook Amazon Braket Python. Puoi effettuare chiamate direttamente a API se stai creando applicazioni che funzionano con l'informatica quantistica a livello di programmazione.
[Gli esempi presenti in questa sezione dimostrano come è possibile lavorare con Amazon Braket API direttamente utilizzando l'SDK Amazon Braket Python insieme all'SDK Python per Braket (AWS Boto3).](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/braket.html)
**Ulteriori informazioni su Amazon Braket Python SDK**
Per lavorare con Amazon Braket Python SDK, installa prima l'SDK AWS Python per Braket (Boto3) in modo da poter comunicare con. AWS API Puoi pensare all'SDK Amazon Braket Python come a una comoda soluzione per Boto3 per i clienti quantistici.
+ Boto3 contiene interfacce a cui devi attingere. AWS API (Nota che Boto3 è un grande SDK Python che parla con. AWS API La maggior parte Servizi AWS supporta un'interfaccia Boto3.)
+ L'SDK Amazon Braket Python contiene moduli software per circuiti, porte, dispositivi, tipi di risultati e altre parti di un'attività quantistica. Ogni volta che crei un programma, importi i moduli necessari per quell'attività quantistica.
+ L'SDK Amazon Braket Python è accessibile tramite notebook, che sono precaricati con tutti i moduli e le dipendenze necessari per eseguire attività quantistiche.
+ Puoi importare moduli dall'SDK Amazon Braket Python in qualsiasi script Python se non desideri lavorare con i notebook.
Dopo aver [installato Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html), una panoramica dei passaggi per la creazione di un'attività quantistica tramite Braket Amazon Python SDK è simile alla seguente:
1. (Facoltativamente) Apri il tuo notebook.
1. Importa i moduli SDK necessari per i tuoi circuiti.
1. Specificate una QPU o un simulatore.
1. Crea un'istanza del circuito.
1. Avvia il circuito.
1. Raccogli i risultati.
Gli esempi in questa sezione mostrano i dettagli di ogni passaggio.
Per altri esempi, consulta il repository [Amazon Braket Examples](https://github.com/aws/amazon-braket-examples) su. GitHub
**Topics**
+ [Invio di attività quantistiche a QPUs](braket-submit-tasks.md)
+ [Esecuzione di più programmi](braket-batching-tasks.md)
+ [Quando verrà eseguito il mio task quantistico?](braket-task-when.md)
+ [Lavorare con le prenotazioni](braket-reservations.md)
+ [Tecniche di mitigazione degli errori](braket-error-mitigation.md)
# Invio di attività quantistiche a QPUs
Amazon Braket fornisce l'accesso a diversi dispositivi in grado di eseguire attività quantistiche. Puoi inviare attività quantistiche singolarmente oppure puoi impostare il raggruppamento di attività [quantistiche](https://docs.aws.amazon.com/braket/latest/developerguide/braket-batching-tasks.html).
**Unità di elaborazione quantistica () QPUs**
Puoi inviare attività quantistiche a QPUs in qualsiasi momento, ma l'attività viene eseguita entro determinate finestre di disponibilità visualizzate nella pagina **Dispositivi** della console Amazon Braket. Puoi recuperare i risultati dell'attività quantistica con il quantum task ID, introdotto nella sezione successiva.
+ ** AQT IBEX-Q1 ** : `arn:aws:braket:eu-north-1::device/qpu/aqt/Ibex-Q1`
+ ** IonQ Forte-1 ** : `arn:aws:braket:us-east-1::device/qpu/ionq/Forte-1`
+ ** IonQ Forte-Enterprise-1 ** : `arn:aws:braket:us-east-1::device/qpu/ionq/Forte-Enterprise-1`
+ ** IQM Garnet ** : `arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet`
+ ** IQM Emerald ** : `arn:aws:braket:eu-north-1::device/qpu/iqm/Emerald`
+ ** QuEra Aquila ** : `arn:aws:braket:us-east-1::device/qpu/quera/Aquila`
+ ** Rigetti Ankaa-3 ** : `arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3`
**Nota**
È possibile annullare le attività quantistiche nei simulatori `CREATED` state for QPUs e on-demand. È possibile annullare le attività quantistiche `QUEUED` nello stato nel miglior modo possibile per i simulatori su richiesta e. QPUs Tieni presente che è improbabile che le attività `QUEUED` quantistiche QPU vengano annullate correttamente durante le finestre di disponibilità della QPU.
**Topics**
+ [AQT](#braket-qpu-partner-aqt)
+ [IonQ](#braket-qpu-partner-ionq)
+ [IQM](#braket-qpu-partner-iqm)
+ [Rigetti](#braket-qpu-partner-rigetti)
+ [QuEra](#braket-qpu-partner-quera)
+ [Esempio: invio di un'attività quantistica a una QPU](braket-submit-to-qpu.md)
+ [Ispezione dei circuiti compilati](braket-compiled-circuits-inspecting.md)
## AQT
AQTIBEX-Q1 QPU si basa su un cristallo di 40 ioni Ca\$1 in una trappola a radiofrequenza macroscopica situata in una camera ad altissimo vuoto. Il dispositivo funziona a temperatura ambiente e si inserisce in due rack compatibili con data center da 19 pollici.
Le porte ad alta fedeltà sono rese possibili dalle basse velocità di riscaldamento della trappola e dall'uso di una transizione ottica diretta per la rotazione dei qubit. La transizione qubit è guidata da un laser a larghezza di linea stretta con una stabilità di frequenza relativa molto elevata. I qubit sono inoltre caratterizzati da un'efficiente preparazione e lettura dello stato tramite scaffalature ottiche. All-to-allla connettività è ottenuta mediante l'interazione di Coulomb a lungo raggio nel cristallo ionico. L'indirizzamento e la lettura a ioni singoli si ottengono mediante l'uso di un obiettivo ad alta apertura numerica.
Il AQT dispositivo supporta le seguenti porte quantistiche.
```
'ccnot', 'cnot', 'cphaseshift', 'cphaseshift00', 'cphaseshift01', 'cphaseshift10', 'cswap', 'swap', 'iswap', 'pswap', 'ecr', 'cy', 'cz', 'xy', 'xx', 'yy', 'zz', 'h', 'i', 'phaseshift', 'rx', 'ry', 'rz', 's', 'si', 't', 'ti', 'v', 'vi', 'x', 'y', 'z', 'prx'
```
Con la compilazione letterale, il AQT dispositivo supporta le seguenti porte native.
```
'prx', 'xx', 'rz'
```
**Nota**
Di seguito vengono descritte le porte equivalenti tra porte AQT native e Amazon Braket:
Il gate AQT Mølmer-Sørensen (MS o RXX) corrisponde al gate di Braket `'xx'`
La porta AQT R corrisponde alla porta di `'prx'` Braket
Il nome del `'rz'` cancello è lo stesso
## IonQ
IonQoffre porte QPUs basate sulla tecnologia delle trappole ioniche. IonQ's QPUs gli ioni intrappolati sono costruiti su una catena di ioni 171Yb\$1 intrappolati che sono confinati spazialmente mediante una trappola per elettrodi superficiali microfabbricata all'interno di una camera a vuoto.
IonQi dispositivi supportano le seguenti porte quantistiche.
```
'x', 'y', 'z', 'rx', 'ry', 'rz', 'h', 'cnot', 's', 'si', 't', 'ti', 'v', 'vi', 'xx', 'yy', 'zz', 'swap'
```
Con la compilazione letterale, IonQ QPUs supportano le seguenti porte native.
```
'gpi', 'gpi2', 'ms'
```
Se si specificano solo parametri a due fasi quando si utilizza la porta MS nativa, viene eseguita una porta MS completamente interconnessa. Un gate MS completamente aggrovigliato esegue sempre una rotazione π /2. Per specificare un angolo diverso e far funzionare una porta MS parzialmente aggrovigliata, si specifica l'angolo desiderato aggiungendo un terzo parametro. [Per ulteriori informazioni, vedete il modulo braket.circuits.gate.](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.circuits.gate.html)
Queste porte native possono essere utilizzate solo con la compilazione letterale. [Per ulteriori informazioni sulla compilazione letterale, consulta Verbatim Compilation.](https://docs.aws.amazon.com/braket/latest/developerguide/braket-constructing-circuit.html#verbatim-compilation)
## IQM
IQMi processori quantistici sono dispositivi universali modello gate basati su qubit transmonici superconduttori. È un dispositivo da 20 qubit, IQM Garnet mentre è un dispositivo da 54 qubit. IQM Emerald Entrambi questi dispositivi utilizzano una topologia a reticolo quadrato, nota anche come topologia a reticolo cristallino.
I IQM dispositivi supportano le seguenti porte quantistiche.
```
"ccnot", "cnot", "cphaseshift", "cphaseshift00", "cphaseshift01", "cphaseshift10", "cswap", "swap", "iswap", "pswap", "ecr", "cy", "cz", "xy", "xx", "yy", "zz", "h", "i", "phaseshift", "rx", "ry", "rz", "s", "si", "t", "ti", "v", "vi", "x", "y", "z"
```
Con la compilazione letterale, IQM i dispositivi supportano le seguenti porte native.
```
'cz', 'prx'
```
## Rigetti
Rigettii processori quantistici sono macchine universali modello gate basate su superconduttori completamente sintonizzabili. qubits
+ Il Ankaa-3 sistema è un dispositivo da 84 qubit che utilizza una tecnologia multi-chip scalabile.
Il Rigetti dispositivo supporta le seguenti porte quantistiche.
```
'cz', 'xy', 'ccnot', 'cnot', 'cphaseshift', 'cphaseshift00', 'cphaseshift01', 'cphaseshift10', 'cswap', 'h', 'i', 'iswap', 'phaseshift', 'pswap', 'rx', 'ry', 'rz', 's', 'si', 'swap', 't', 'ti', 'x', 'y', 'z'
```
Con la compilazione letterale, Ankaa-3 supporta le seguenti porte native.
```
'rx', 'rz', 'iswap'
```
Rigettii processori quantistici superconduttori possono far funzionare la porta 'rx' solo con gli angoli di ±π o ±π.
Il controllo a livello di impulsi è disponibile sui dispositivi Rigetti, che supportano una serie di frame predefiniti dei seguenti tipi per il sistema. Ankaa-3
```
`flux_tx`, `charge_tx`, `readout_rx`, `readout_tx`
```
Il Ankaa-3 dispositivo ha un limite massimo di 20.000 porte per circuito. I circuiti che superano questo limite vengono rifiutati con un errore di convalida. Si tratta di un limite fisso che non può essere aumentato. Il numero di porte si riferisce al circuito compilato, che può differire dal numero di porte del circuito non compilato originale. Per stimare il numero di porte compilate prima dell'invio alla QPU, è possibile utilizzare la compilazione letterale localmente o trasporre il circuito nel set di porte nativo (,,). `rx` `rz` `iswap`
## QuEra
QuEraoffre dispositivi basati su atomi neutri in grado di eseguire attività quantistiche di simulazione hamiltoniana analogica (AHS). Questi dispositivi speciali riproducono fedelmente la dinamica quantistica dipendente dal tempo di centinaia di qubit che interagiscono simultaneamente.
È possibile programmare questi dispositivi secondo il paradigma della simulazione hamiltoniana analogica prescrivendo il layout del registro dei qubit e la dipendenza temporale e spaziale dei campi di manipolazione. Amazon Braket fornisce utilità per creare tali programmi tramite il modulo AHS dell'SDK python,. `braket.ahs`
[Per ulteriori informazioni, consulta i [taccuini di esempio di Analog Hamiltonian Simulation](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation) o la pagina Invia un programma analogico utilizzando Aquila. QuEra](braket-quera-submitting-analog-program-aquila.md)
# Esempio: invio di un'attività quantistica a una QPU
Amazon Braket ti consente di eseguire un circuito quantistico su un dispositivo QPU. L'esempio seguente mostra come inviare un'attività quantistica ai nostri dispositivi. Rigetti IonQ
**Scegli il Rigetti Ankaa-3 dispositivo, quindi guarda il grafico di connettività associato**
```
# import the QPU module
from braket.aws import AwsDevice
# choose the Rigetti device
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
# take a look at the device connectivity graph
device.properties.dict()['paradigm']['connectivity']
```
```
{'fullyConnected': False,
'connectivityGraph': {'0': ['1', '7'],
'1': ['0', '2', '8'],
'2': ['1', '3', '9'],
'3': ['2', '4', '10'],
'4': ['3', '5', '11'],
'5': ['4', '6', '12'],
'6': ['5', '13'],
'7': ['0', '8', '14'],
'8': ['1', '7', '9', '15'],
'9': ['2', '8', '10', '16'],
'10': ['3', '9', '11', '17'],
'11': ['4', '10', '12', '18'],
'12': ['5', '11', '13', '19'],
'13': ['6', '12', '20'],
'14': ['7', '15', '21'],
'15': ['8', '14', '22'],
'16': ['9', '17', '23'],
'17': ['10', '16', '18', '24'],
'18': ['11', '17', '19', '25'],
'19': ['12', '18', '20', '26'],
'20': ['13', '19', '27'],
'21': ['14', '22', '28'],
'22': ['15', '21', '23', '29'],
'23': ['16', '22', '24', '30'],
'24': ['17', '23', '25', '31'],
'25': ['18', '24', '26', '32'],
'26': ['19', '25', '33'],
'27': ['20', '34'],
'28': ['21', '29', '35'],
'29': ['22', '28', '30', '36'],
'30': ['23', '29', '31', '37'],
'31': ['24', '30', '32', '38'],
'32': ['25', '31', '33', '39'],
'33': ['26', '32', '34', '40'],
'34': ['27', '33', '41'],
'35': ['28', '36', '42'],
'36': ['29', '35', '37', '43'],
'37': ['30', '36', '38', '44'],
'38': ['31', '37', '39', '45'],
'39': ['32', '38', '40', '46'],
'40': ['33', '39', '41', '47'],
'41': ['34', '40', '48'],
'42': ['35', '43', '49'],
'43': ['36', '42', '44', '50'],
'44': ['37', '43', '45', '51'],
'45': ['38', '44', '46', '52'],
'46': ['39', '45', '47', '53'],
'47': ['40', '46', '48', '54'],
'48': ['41', '47', '55'],
'49': ['42', '56'],
'50': ['43', '51', '57'],
'51': ['44', '50', '52', '58'],
'52': ['45', '51', '53', '59'],
'53': ['46', '52', '54'],
'54': ['47', '53', '55', '61'],
'55': ['48', '54', '62'],
'56': ['49', '57', '63'],
'57': ['50', '56', '58', '64'],
'58': ['51', '57', '59', '65'],
'59': ['52', '58', '60', '66'],
'60': ['59'],
'61': ['54', '62', '68'],
'62': ['55', '61', '69'],
'63': ['56', '64', '70'],
'64': ['57', '63', '65', '71'],
'65': ['58', '64', '66', '72'],
'66': ['59', '65', '67'],
'67': ['66', '68'],
'68': ['61', '67', '69', '75'],
'69': ['62', '68', '76'],
'70': ['63', '71', '77'],
'71': ['64', '70', '72', '78'],
'72': ['65', '71', '73', '79'],
'73': ['72', '80'],
'75': ['68', '76', '82'],
'76': ['69', '75', '83'],
'77': ['70', '78'],
'78': ['71', '77', '79'],
'79': ['72', '78', '80'],
'80': ['73', '79', '81'],
'81': ['80', '82'],
'82': ['75', '81', '83'],
'83': ['76', '82']}}
```
Il dizionario precedente `connectivityGraph` elenca i qubit adiacenti per ogni qubit del dispositivo. Rigetti
**Scegli il dispositivo IonQ Forte-Enterprise-1**
Per il IonQ Forte-Enterprise-1 dispositivo, `connectivityGraph` è vuoto, come illustrato nell'esempio seguente, perché il dispositivo offre *all-to-all*connettività. Pertanto, non `connectivityGraph` è necessario un dettaglio.
```
# or choose the IonQ Forte-Enterprise-1 device
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Forte-Enterprise-1")
# take a look at the device connectivity graph
device.properties.dict()['paradigm']['connectivity']
```
```
{'fullyConnected': True, 'connectivityGraph': {...}}
```
Come illustrato nell'esempio seguente, hai la possibilità di modificare shots (default=1000), `poll_timeout_seconds` (default = 432000 = 5 giorni), `poll_interval_seconds` (default = 1) e la posizione del bucket S3 (`s3_location`) in cui verranno archiviati i risultati se scegli di specificare una posizione diversa dal bucket predefinito.
```
my_task = device.run(circ, s3_location = 'amazon-braket-my-folder', shots=100, poll_timeout_seconds = 100, poll_interval_seconds = 10)
```
RigettiI dispositivi IonQ e compilano automaticamente il circuito fornito nei rispettivi set di porte nativi e mappano qubit gli indici astratti su quelli fisici qubits sulla rispettiva QPU.
**Nota**
I dispositivi QPU hanno una capacità limitata. Quando viene raggiunta la capacità, è possibile aspettarsi tempi di attesa più lunghi.
Amazon Braket può eseguire attività quantistiche QPU entro determinate finestre di disponibilità, ma puoi comunque inviare attività quantistiche in qualsiasi momento (24 ore su 24, 7 giorni su 7) perché tutti i dati e i metadati corrispondenti vengono archiviati in modo affidabile nel bucket S3 appropriato. Come illustrato nella sezione successiva, puoi ripristinare il tuo task quantistico utilizzando e il tuo ID di attività quantistica univoco. `AwsQuantumTask`
# Ispezione dei circuiti compilati
Quando un circuito quantistico deve essere eseguito su un dispositivo hardware, come un'unità di elaborazione quantistica (QPU), il circuito deve prima essere compilato in un formato accettabile che il dispositivo possa comprendere ed elaborare. Ad esempio, trasponendo il circuito quantistico di alto livello fino alle porte native specifiche supportate dall'hardware QPU di destinazione. L'ispezione dell'effettivo output compilato del circuito quantistico può essere estremamente utile per scopi di debug e ottimizzazione. Queste conoscenze possono aiutare a identificare potenziali problemi, strozzature o opportunità per migliorare le prestazioni e l'efficienza dell'applicazione quantistica. È possibile visualizzare e analizzare l'output compilato dei circuiti quantistici sia per i dispositivi di elaborazione quantistica che per i dispositivi di elaborazione IQM quantistica Rigetti utilizzando il codice fornito di seguito.
```
task = AwsQuantumTask(arn=task_id, aws_session=session)
# After the task has finished running
task_result = task.result()
compiled_circuit = task_result.get_compiled_circuit()
```
**Nota**
Attualmente, la visualizzazione dell'uscita del circuito compilato per IonQ i dispositivi non è supportata.
# 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\$1retry» 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)
```
# Quando verrà eseguito il mio task quantistico?
Quando invii un circuito, Amazon Braket lo invia al dispositivo specificato. Le attività quantistiche della Quantum Processing Unit (QPU) e del simulatore su richiesta vengono messe in coda ed elaborate nell'ordine in cui vengono ricevute. Il tempo necessario per elaborare un'attività quantistica dopo l'invio varia a seconda del numero e della complessità delle attività inviate da altri clienti Amazon Braket e della disponibilità della QPU selezionata.
**Topics**
+ [Disponibilità, finestre e stato della QPU](#braket-qpu-availability)
+ [Visibilità della coda](#braket-queue-visibility)
+ [Configurare le notifiche via e-mail o SMS](status-change-notifications-in-email-or-sms.md)
## Disponibilità, finestre e stato della QPU
La disponibilità delle QPU varia da dispositivo a dispositivo.
Nella pagina **Dispositivi** della console Amazon Braket, puoi visualizzare le finestre di disponibilità attuali e future e lo stato del dispositivo. Inoltre, ogni pagina del dispositivo mostra le profondità di coda individuali per attività quantistiche e lavori ibridi.
Un dispositivo è considerato *offline* se non è disponibile per i clienti, indipendentemente dalla finestra di disponibilità. Ad esempio, potrebbe essere offline a causa di manutenzione programmata, aggiornamenti o problemi operativi.
## Visibilità della coda
Prima di inviare un'attività quantistica o un lavoro ibrido, puoi visualizzare quante attività quantistiche o ibride hai davanti a te controllando la profondità della coda del dispositivo.
**Profondità della coda**
Queue depthsi riferisce al numero di attività quantistiche e lavori ibridi in coda per un particolare dispositivo. Le attività quantistiche di un dispositivo e il conteggio delle code di lavoro ibride sono accessibili tramite l'opzione o. Braket Software Development Kit (SDK) Amazon Braket Management Console
1. La *profondità della coda delle attività* si riferisce al numero totale di attività quantistiche attualmente in attesa di essere eseguite con priorità normale.
1. La *profondità della coda delle attività prioritarie* si riferisce al numero totale di attività quantistiche inviate in attesa di essere eseguite. Amazon Braket Hybrid Jobs Queste attività vengono eseguite prima delle attività autonome.
1. La *profondità della coda dei lavori ibridi* si riferisce al numero totale di lavori ibridi attualmente in coda su un dispositivo. Quantum tasksinviati come parte di un lavoro ibrido hanno la priorità e sono aggregati in. Priority Task Queue
I clienti che desiderano visualizzare la profondità della coda tramite il Braket SDK possono modificare il seguente frammento di codice per ottenere la posizione in coda della loro attività quantistica o del loro lavoro ibrido:
```
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Forte-Enterprise-1")
# returns the number of quantum tasks queued on the device
print(device.queue_depth().quantum_tasks)
{: '0', : '0'}
# returns the number of hybrid jobs queued on the device
print(device.queue_depth().jobs)
'3'
```
L'invio di un'attività quantistica o di un lavoro ibrido a una QPU può comportare lo stato del carico di lavoro. `QUEUED` Amazon Braket offre ai clienti visibilità sulle attività quantistiche e sulla posizione ibrida nella coda dei lavori.
**Posizione in coda**
Queue positionsi riferisce alla posizione corrente dell'attività quantistica o del lavoro ibrido all'interno della rispettiva coda del dispositivo. Può essere ottenuto per attività quantistiche o lavori ibridi tramite o. Braket Software Development Kit (SDK) Amazon Braket Management Console
I clienti che desiderano visualizzare la posizione della coda tramite il Braket SDK possono modificare il seguente frammento di codice per ottenere la posizione in coda del loro task quantistico o del loro lavoro ibrido:
```
# choose the device to run your circuit
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")
#execute the circuit
task = device.run(bell, s3_folder, shots=100)
# retrieve the queue position information
print(task.queue_position().queue_position)
# Returns the number of Quantum Tasks queued ahead of you
'2'
from braket.aws import AwsQuantumJob
job = AwsQuantumJob.create(
"arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet",
source_module="algorithm_script.py",
entry_point="algorithm_script:start_here",
wait_until_complete=False
)
# retrieve the queue position information
print(job.queue_position().queue_position)
'3' # returns the number of hybrid jobs queued ahead of you
```
# Configurare le notifiche via e-mail o SMS
Amazon Braket invia eventi ad Amazon EventBridge quando la disponibilità di una QPU cambia o quando cambia lo stato dell'attività quantistica. Segui questi passaggi per ricevere notifiche di modifica dello stato del dispositivo e delle attività quantistiche tramite e-mail o messaggio SMS:
1. Crea un argomento Amazon SNS e un abbonamento a e-mail o SMS. La disponibilità di e-mail o SMS dipende dalla tua regione. Per ulteriori informazioni, consulta [Guida introduttiva ad Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-getting-started.html) e [invio di messaggi SMS](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html).
1. Crea una regola EventBridge che attivi le notifiche sul tuo argomento SNS. Per ulteriori informazioni, consulta [Monitoring Amazon Braket with Amazon](braket-monitor-eventbridge.md). EventBridge
## (Facoltativo) Configura le notifiche SNS
Puoi configurare le notifiche tramite Amazon Simple Notification Service (SNS) in modo da ricevere un avviso quando l'attività quantistica di Amazon Braket è completata. Le notifiche attive sono utili se prevedi un lungo tempo di attesa, ad esempio quando invii un'attività quantistica di grandi dimensioni o quando invii un'attività quantistica al di fuori della finestra di disponibilità di un dispositivo. Se non volete attendere il completamento dell'operazione quantistica, potete impostare una notifica SNS.
Un notebook Amazon Braket ti guida attraverso i passaggi di configurazione. Per ulteriori informazioni, consulta [gli esempi di Amazon Braket su GitHub](https://github.com/aws/amazon-braket-examples) e, in particolare, [il notebook di esempio per l'impostazione delle notifiche](https://github.com/aws/amazon-braket-examples/tree/main/examples/braket_features).
# Lavorare con le prenotazioni
Le prenotazioni ti danno accesso esclusivo al dispositivo quantistico di tua scelta. Puoi programmare una prenotazione quando preferisci, in modo da sapere esattamente quando inizia e termina l'esecuzione del carico di lavoro. Le prenotazioni sono disponibili con incrementi di 1 ora per tutti i dispositivi Braket e possono essere annullate fino a 48 ore di anticipo, senza costi aggiuntivi. Ti consigliamo di mettere in coda le attività quantistiche e i lavori ibridi per una prenotazione imminente in anticipo, utilizzando l'ARN di Braket Direct Reservation o di inviare carichi di lavoro durante la prenotazione.
Il costo dell'accesso dedicato ai dispositivi si basa sulla durata della prenotazione, indipendentemente dal numero di attività quantistiche e lavori ibridi eseguiti sull'unità di elaborazione quantistica (QPU). Un elenco aggiornato dei computer quantistici disponibili per le prenotazioni è disponibile sulla nostra [pagina dei prezzi](https://aws.amazon.com/braket/pricing/) o tramite la console di gestione [Amazon Braket](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/devices).
**Nota**
In una prenotazione non ci sono limiti per i [gateshot](braket-terms.md#gateshot-limit-term). Inoltre, per IonQ i dispositivi, il numero minimo di colpi per le attività di [mitigazione degli errori](https://docs.aws.amazon.com/braket/latest/developerguide/braket-error-mitigation.html) è ridotto a 500 (rispetto ai 2500 per le attività on-demand).
**Quando utilizzare una prenotazione**
L'utilizzo dell'accesso alle prenotazioni offre la comodità e la prevedibilità di sapere esattamente quando il carico di lavoro quantistico inizia e termina l'esecuzione. Rispetto all'invio di attività e lavori ibridi su richiesta, non è necessario attendere in coda per le attività di altri clienti. Poiché hai accesso esclusivo al dispositivo durante la prenotazione, solo i tuoi carichi di lavoro verranno eseguiti sul dispositivo per l'intera prenotazione.
Ti consigliamo di utilizzare l'accesso su richiesta per la fase di progettazione e prototipazione della ricerca, per consentire un'iterazione rapida ed economica degli algoritmi. Quando siete pronti a produrre i risultati finali dell'esperimento, prendete in considerazione la possibilità di prenotare un dispositivo in base alle vostre esigenze per assicurarvi di rispettare le scadenze del progetto o della pubblicazione. Ti consigliamo inoltre di utilizzare le prenotazioni quando desideri eseguire le attività in orari specifici, ad esempio quando esegui una demo dal vivo o un workshop su un computer quantistico.
**Topics**
+ [Come creare una prenotazione](braket-create-a-reservation.md)
+ [Esecuzione di attività quantistiche durante una prenotazione](braket-run-quantum-task-with-reservation.md)
+ [Esecuzione di lavori ibridi durante una prenotazione](braket-run-hybrid-jobs-with-reservation.md)
+ [Cosa succede alla fine della prenotazione](braket-end-of-reservation.md)
+ [Annulla o riprogramma una prenotazione esistente](braket-cancel-reservation.md)
# Come creare una prenotazione
Per creare una prenotazione, contatta il team di Braket seguendo questi passaggi:
1. Apri la console Amazon Braket.
1. Scegli **Braket Direct** nel riquadro a sinistra, quindi nella sezione **Prenotazioni**, scegli **Prenota** dispositivo.
1. Seleziona il **dispositivo** che desideri prenotare.
1. Fornisci le tue informazioni di contatto tra cui **nome** ed **e-mail**. Assicurati di fornire un indirizzo email valido che controlli regolarmente.
1. Nella sezione **Comunicaci il tuo carico di lavoro**, fornisci tutti i dettagli sul carico di lavoro da eseguire utilizzando la tua prenotazione. Ad esempio, la durata della prenotazione desiderata, i vincoli pertinenti o la pianificazione desiderata.
Dopo aver inviato il modulo, riceverai un'e-mail dal team di Braket con i passaggi successivi. Una volta confermata la prenotazione, riceverai l'ARN della prenotazione tramite e-mail. È necessario utilizzare l'ARN di prenotazione per creare attività di prenotazione. Le attività create senza l'ARN di prenotazione verranno inviate alla normale coda su richiesta e NON verranno eseguite durante la prenotazione.
**Nota**
La prenotazione è confermata solo dopo aver ricevuto l'ARN di prenotazione.
Le prenotazioni sono disponibili con incrementi minimi di 1 ora e alcuni dispositivi potrebbero avere ulteriori vincoli di durata della prenotazione (inclusa la durata minima e massima della prenotazione). Il team di Braket condivide tutte le informazioni pertinenti con te prima di confermare la prenotazione.
Il team di Braket ti contatterà tramite e-mail per organizzare una sessione di 30 minuti con un esperto di Braket.
# Esecuzione di attività quantistiche durante una prenotazione
Dopo aver ottenuto un ARN di prenotazione valido da [Crea una prenotazione](https://docs.aws.amazon.com/braket/latest/developerguide/braket-reservations.html#braket-create-a-reservation), puoi creare attività quantistiche da eseguire durante la prenotazione. Le attività quantistiche e i lavori ibridi inviati con un ARN di prenotazione non verranno visualizzati nella coda dei dispositivi. Le attività inviate prima dell'orario di inizio della prenotazione rimarranno nello `QUEUED` stato fino all'inizio della prenotazione.
**Nota**
Le prenotazioni sono AWS specifiche per account e dispositivo. Solo l' AWS account che ha creato la prenotazione può utilizzare l'ARN della prenotazione.
Durante una prenotazione, è possibile creare sia attività di prenotazione che attività regolari. Per verificare che un'attività quantistica Braket creata sia associata a una prenotazione, controlla il campo «ARN di prenotazione» nella pagina dell'attività quantistica nella console Braket o interroga lo stesso campo nei metadati dell'attività utilizzando l'SDK. Il resto di questa pagina descrive come specificare quali attività sono associate alla prenotazione.
[È possibile creare attività quantistiche utilizzando Python SDKs ad esempio [Braket](https://docs.aws.amazon.com/braket/latest/developerguide/braket-references.html),, [https://github.com/NVIDIA/cuda-quantum](https://github.com/NVIDIA/cuda-quantum), o direttamente con boto3 (Lavorare con Boto3).](https://docs.aws.amazon.com/braket/latest/developerguide/braket-using-boto3.html) [Per utilizzare le prenotazioni, devi disporre della versione [v1.79.0](https://github.com/amazon-braket/amazon-braket-sdk-python/releases/tag/v1.79.0) o successiva di Amazon Braket. Python SDK](https://github.com/amazon-braket/amazon-braket-sdk-python) Puoi eseguire l'aggiornamento all'SDK, al Qiskit provider e PennyLane al plug-in Braket più recenti con il codice seguente.
```
pip install --upgrade amazon-braket-sdk amazon-braket-pennylane-plugin qiskit-braket-provider
```
**Esegui attività con il gestore di contesto `DirectReservation`**
Il modo consigliato per eseguire un'attività all'interno della prenotazione pianificata consiste nell'utilizzare il gestore di `DirectReservation` contesto. Specificando il dispositivo di destinazione e l'ARN di prenotazione, il gestore di contesto assicura che tutte le attività create all'interno dell'istruzione `with` Python vengano eseguite con accesso esclusivo al dispositivo.
Innanzitutto, definisci un circuito quantistico e il dispositivo. Quindi utilizza il contesto di prenotazione ed esegui l'attività. **Assicurati che l'intero carico di lavoro venga eseguito all'interno del `with` blocco; tutto ciò che non rientra nell'ambito del `with` blocco non verrà associato alla tua prenotazione\$1**
```
from braket.aws import AwsDevice, DirectReservation
from braket.circuits import Circuit
from braket.devices import Devices
bell = Circuit().h(0).cnot(0, 1)
device = AwsDevice(Devices.IonQ.ForteEnterprise1)
# run the circuit in a reservation
with DirectReservation(device, reservation_arn=""):
task = device.run(bell, shots=100)
```
È possibile creare attività quantistiche in una prenotazione utilizzandoCUDA-Q, e i Qiskit pluginPennyLane, purché il `DirectReservation` contesto sia attivo durante la creazione di attività quantistiche. Ad esempio, con il Qiskit-Braket provider, è possibile eseguire le attività come segue.
```
from braket.devices import Devices
from braket.aws import DirectReservation
from qiskit import QuantumCircuit
from qiskit_braket_provider import BraketProvider
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qpu = BraketProvider().get_backend("Forte Enterprise 1")
# run the circuit in a reservation
with DirectReservation(Devices.IonQ.ForteEnterprise1, reservation_arn=""):
qpu_task = qpu.run(qc, shots=10)
```
Analogamente, il codice seguente esegue un circuito durante una prenotazione utilizzando il Braket-PennyLane plugin.
```
from braket.devices import Devices
from braket.aws import DirectReservation
import pennylane as qml
dev = qml.device("braket.aws.qubit", device_arn=Devices.IonQ.ForteEnterprise1.value, wires=2, shots=10)
@qml.qnode(dev)
def bell_state():
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
return qml.probs(wires=[0, 1])
# run the circuit in a reservation
with DirectReservation(Devices.IonQ.ForteEnterprise1, reservation_arn=""):
probs = bell_state()
```
**Impostazione manuale del contesto di prenotazione**
In alternativa, puoi impostare manualmente il contesto di prenotazione con il seguente codice.
```
# set reservation context
reservation_context = DirectReservation(device, reservation_arn="").start()
# run circuit during reservation
task = device.run(bell, shots=100)
```
Questo è ideale per i notebook Jupyter in cui il contesto può essere eseguito nella prima cella e tutte le attività successive verranno eseguite nella prenotazione.
**Nota**
*La cella contenente la `.start()` chiamata deve essere eseguita solo una volta.*
Per tornare alla modalità su richiesta: riavvia il notebook Jupyter o chiama quanto segue per riportare il contesto alla modalità su richiesta.
```
reservation_context.stop() # unset reservation context
```
**Nota**
[Le prenotazioni hanno un orario di inizio e di fine predeterminati (vedi Creare una prenotazione).](https://docs.aws.amazon.com/braket/latest/developerguide/braket-reservations.html#braket-create-a-reservation) I `reservation_context.stop()` metodi `reservation_context.start()` and **non iniziano o terminano una prenotazione**. Invece, mentre il contesto è attivo, tutte le attività quantistiche create verranno associate alla prenotazione e verranno eseguite solo durante la prenotazione pianificata. Il contesto della prenotazione non ha alcun effetto sull'orario di prenotazione pianificato.
**Passa esplicitamente l'ARN di prenotazione durante la creazione dell'attività**
Un altro modo per creare attività durante una prenotazione consiste nel trasmettere esplicitamente l'ARN della prenotazione durante la chiamata. `device.run()`
```
task = device.run(bell, shots=100, reservation_arn="")
```
Questo metodo associa direttamente l'attività quantistica all'ARN di prenotazione, assicurando che venga eseguita durante il periodo riservato. Per questa opzione, aggiungi l'ARN di prenotazione a ogni attività che intendi eseguire durante una prenotazione. Tuttavia, tieni presente che quando utilizzi librerie di terze parti come Qiskit orPennyLane, può essere difficile garantire che le attività inviate utilizzino l'ARN di prenotazione corretto. Per questo motivo, si consiglia di utilizzare il gestore di DirectReservation contesto.
Quando usi direttamente boto3, passa l'ARN di prenotazione come associazione durante la creazione di un'attività.
```
import boto3
braket_client = boto3.client("braket")
kwargs["associations"] = [
{
"arn": "",
"type": "RESERVATION_TIME_WINDOW_ARN",
}
]
response = braket_client.create_quantum_task(**kwargs)
```
# Esecuzione di lavori ibridi durante una prenotazione
Una volta che hai una funzione Python da eseguire come lavoro ibrido, puoi eseguire il lavoro ibrido in una prenotazione passando l'argomento della `reservation_arn` parola chiave. Tutte le attività all'interno del lavoro ibrido utilizzano l'ARN di prenotazione. È importante sottolineare che il job ibrido attiva *l'elaborazione classica `reservation_arn` solo dopo l'inizio della prenotazione*.
**Nota**
Un processo ibrido in esecuzione durante una prenotazione *esegue correttamente solo* attività quantistiche sul dispositivo riservato. Il tentativo di utilizzare un dispositivo Braket on-demand diverso genererà un errore. Se devi eseguire attività sia su un simulatore su richiesta che sul dispositivo riservato all'interno dello stesso lavoro ibrido, utilizza invece. `DirectReservation`
Il codice seguente mostra come eseguire un processo ibrido durante una prenotazione.
```
from braket.aws import AwsDevice
from braket.devices import Devices
from braket.jobs import get_job_device_arn, hybrid_job
@hybrid_job(device=Devices.IonQ.ForteEnterprise1, reservation_arn="")
def example_hybrid_job():
# declare AwsDevice within the hybrid job
device = AwsDevice(get_job_device_arn())
bell = Circuit().h(0).cnot(0, 1)
task = device.run(bell, shots=10)
```
Per i lavori ibridi che utilizzano uno script Python (vedi la sezione sulla [creazione del primo lavoro](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs-first.html) ibrido nella guida per gli sviluppatori), puoi eseguirli all'interno della prenotazione passando l'argomento della `reservation_arn` parola chiave durante la creazione del lavoro.
```
from braket.aws import AwsQuantumJob
from braket.devices import Devices
job = AwsQuantumJob.create(
Devices.IonQ.ForteEnterprise1,
source_module="algorithm_script.py",
entry_point="algorithm_script:start_here",
reservation_arn=""
)
```
# Cosa succede alla fine della prenotazione
Al termine della prenotazione, non avrai più un accesso dedicato al dispositivo. Tutti i carichi di lavoro rimanenti in coda con questa prenotazione vengono automaticamente annullati.
**Nota**
Qualsiasi lavoro che era in corso al termine della `RUNNING` prenotazione viene annullato. Ti consigliamo di utilizzare i [checkpoint per salvare e riavviare i](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs-checkpoints.html) lavori a tuo piacimento.
Una prenotazione in corso, ad esempio dopo l'inizio della prenotazione e prima della fine della prenotazione, non può essere estesa perché ogni prenotazione rappresenta l'accesso indipendente a un dispositivo dedicato. Ad esempio, due back-to-back prenotazioni sono considerate separate e tutte le attività in sospeso dalla prima prenotazione vengono automaticamente annullate. Non riprendono nella seconda prenotazione.
**Nota**
Le prenotazioni rappresentano l'accesso al dispositivo dedicato al tuo AWS account. Anche se il dispositivo rimane inattivo, nessun altro cliente può utilizzarlo. Pertanto, ti verrà addebitato il costo per la durata del tempo prenotato, indipendentemente dal tempo utilizzato.
# Annulla o riprogramma una prenotazione esistente
Puoi cancellare la tua prenotazione non meno di 48 ore prima dell'orario di inizio previsto per la prenotazione. Per annullare, rispondi all'e-mail di conferma della prenotazione che hai ricevuto con la richiesta di cancellazione.
Per riprogrammare, devi cancellare la prenotazione esistente e quindi crearne una nuova.
# Tecniche di mitigazione degli errori
La mitigazione quantistica degli errori è un insieme di tecniche volte a ridurre gli effetti degli errori nei computer quantistici.
I dispositivi quantistici sono soggetti a rumori ambientali che riducono la qualità dei calcoli eseguiti. Sebbene il calcolo quantistico tollerante ai guasti prometta una soluzione a questo problema, gli attuali dispositivi quantistici sono limitati dal numero di qubit e dai tassi di errore relativamente elevati. Per ovviare a questo problema nel breve termine, i ricercatori stanno studiando metodi per migliorare l'accuratezza dei rumorosi calcoli quantistici. Questo approccio, noto come *mitigazione degli errori quantistici*, prevede l'utilizzo di varie tecniche per estrarre il segnale migliore da dati di misurazione rumorosi.
**Topics**
+ [Tecniche di mitigazione degli errori sui dispositivi IonQ](error-mitigation-ionq.md)
# Tecniche di mitigazione degli errori sui dispositivi IonQ
La mitigazione degli errori implica l'esecuzione di più circuiti fisici e la combinazione delle relative misurazioni per ottenere un risultato migliore.
**Nota**
[Per tutti i IonQ dispositivi: quando si utilizza un modello on demand, è previsto un limite di 1 milione di [gateshot](braket-terms.md#gateshot-limit-term) e un minimo di 2500 scatti per le attività di mitigazione degli errori.](https://docs.aws.amazon.com/braket/latest/developerguide/braket-error-mitigation.html) Per una prenotazione diretta, non è previsto un limite di gateshot e un minimo di 500 shot per le attività di mitigazione degli errori.
## Debiasing
IonQ*i dispositivi dispongono di un metodo di mitigazione degli errori chiamato debiasing.*
Debiasing mappa un circuito in più varianti che agiscono su diverse permutazioni di qubit o con diverse decomposizioni dei gate. Ciò riduce l'effetto di errori sistematici come le sovratratazioni delle porte o un singolo qubit difettoso, utilizzando diverse implementazioni di un circuito che altrimenti potrebbero alterare i risultati di misurazione. Ciò comporta costi aggiuntivi per la calibrazione di più qubit e gate.
Per ulteriori informazioni sul debiasing, vedere [Miglioramento](https://arxiv.org/abs/2301.07233) delle prestazioni dei computer quantistici attraverso la simmetrizzazione.
**Nota**
L'uso del debiasing richiede un minimo di 2500 scatti.
È possibile eseguire un'operazione quantistica con debiasing su un IonQ dispositivo utilizzando il codice seguente:
```
from braket.aws import AwsDevice
from braket.circuits import Circuit
from braket.error_mitigation import Debias
# choose an IonQ device
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Forte-Enterprise-1")
circuit = Circuit().h(0).cnot(0, 1)
task = device.run(circuit, shots=2500, device_parameters={"errorMitigation": Debias()})
result = task.result()
print(result.measurement_counts)
>>> {"00": 1245, "01": 5, "10": 10 "11": 1240} # result from debiasing
```
Una volta completata l'operazione quantistica, è possibile visualizzare le probabilità di misurazione e tutti i tipi di risultato dell'operazione quantistica. Le probabilità di misurazione e i conteggi di tutte le varianti vengono aggregati in un'unica distribuzione. Tutti i tipi di risultato specificati nel circuito, ad esempio i valori di aspettativa, vengono calcolati utilizzando i conteggi delle misurazioni aggregate.
## Filtro di nitidezza
*È inoltre possibile accedere alle probabilità di misurazione calcolate con una diversa strategia di post-elaborazione chiamata nitidezza.* La nitidezza confronta i risultati di ciascuna variante ed elimina le immagini incoerenti, favorendo il risultato di misurazione più probabile tra le varianti. Per ulteriori informazioni, vedete [Migliorare](https://arxiv.org/abs/2301.07233) le prestazioni dei computer quantistici attraverso la simmetrizzazione.
È importante sottolineare che la nitidezza presuppone che la forma della distribuzione di output sia scarsa, con pochi stati ad alta probabilità e molti stati a probabilità zero. Se questa ipotesi non è valida, può distorcere la distribuzione delle probabilità.
Puoi accedere alle probabilità da una distribuzione più nitida nel `additional_metadata` campo dell'SDK Braket `GateModelTaskResult` Python. Nota che la nitidezza non restituisce i conteggi delle misurazioni, ma restituisce invece una distribuzione di probabilità rinormalizzata. Il seguente frammento di codice mostra come accedere alla distribuzione dopo la nitidezza.
```
print(result.additional_metadata.ionqMetadata.sharpenedProbabilities)
>>> {"00": 0.51, "11": 0.549} # sharpened probabilities
```