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à. # Lavorare con Amazon Braket Hybrid Jobs Amazon Braket Hybrid Jobs ti offre un modo per eseguire algoritmi ibridi quantistici classici che richiedono sia AWS risorse classiche che unità di elaborazione quantistica (). QPUs *Hybrid Jobs è progettato per attivare le risorse classiche richieste, eseguire l'algoritmo e rilasciare le istanze dopo il completamento, in modo da pagare solo per ciò che usi.* Hybrid Jobs è ideale per algoritmi iterativi di lunga durata che prevedono l'uso sia di risorse di calcolo classiche che di risorse di calcolo quantistico. Con Hybrid Jobs, dopo aver inviato l'algoritmo per l'esecuzione, Braket lo eseguirà in un ambiente scalabile e containerizzato. Una volta completato l'algoritmo, puoi recuperare i risultati. Inoltre, le attività quantistiche create da un lavoro ibrido traggono vantaggio dall'accodamento con priorità più elevata verso il dispositivo QPU di destinazione. Questa prioritizzazione garantisce che i calcoli quantistici vengano elaborati ed eseguiti prima delle altre attività in attesa in coda. Ciò è particolarmente vantaggioso per gli algoritmi ibridi iterativi, in cui i risultati di un'attività quantistica dipendono dai risultati di attività quantistiche precedenti. [https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_quantum_algorithms/VQE_Chemistry/VQE_chemistry_braket.ipynb](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_quantum_algorithms/VQE_Chemistry/VQE_chemistry_braket.ipynb) È inoltre possibile monitorare l'avanzamento dell'algoritmo quasi in tempo reale, in modo da tenere traccia dei costi, del budget o di metriche personalizzate come la perdita di allenamento o i valori di aspettativa. Puoi accedere ai lavori ibridi in Braket utilizzando: + L'[SDK Amazon Braket Python](https://github.com/aws/amazon-braket-sdk-python). + La [console Amazon Braket.](https://console.aws.amazon.com/braket/home) + Amazon BraketAPI. **Topics** + [Quando usare Amazon Braket Hybrid Jobs](#braket-jobs-use) + [Esecuzione di un processo ibrido con Amazon Braket Hybrid Jobs](#braket-jobs-works) + [Concetti chiave per Hybrid Jobs](braket-jobs-concepts.md) + [Prerequisiti](braket-jobs-prerequisites.md) + [Crea un Job ibrido](braket-jobs-first.md) + [Annullare un Job ibrido](braket-jobs-cancel.md) + [Personalizzazione del tuo Hybrid Job](braket-jobs-customize.md) + [Utilizzo PennyLane con Amazon Braket](hybrid.md) + [Utilizzo di CUDA-Q con Amazon Braket](braket-using-cuda-q.md) ## Quando usare Amazon Braket Hybrid Jobs Amazon Braket Hybrid Jobs ti consente di eseguire algoritmi ibridi quantistici classici, come Variational Quantum Eigensolver (VQE) e Quantum Approximate Optimization Algorithm (QAOA), che combinano risorse di calcolo classiche con dispositivi di calcolo quantistico per ottimizzare le prestazioni dei sistemi quantistici odierni. Amazon Braket Hybrid Jobs offre tre vantaggi principali: 1. **Prestazioni**: Amazon Braket Hybrid Jobs offre prestazioni migliori rispetto all'esecuzione di algoritmi ibridi dal tuo ambiente. Mentre il processo è in esecuzione, ha accesso prioritario alla QPU di destinazione selezionata. Le attività del tuo job vengono eseguite prima delle altre attività in coda sul dispositivo. Ciò si traduce in tempi di esecuzione più brevi e prevedibili per gli algoritmi ibridi. Amazon Braket Hybrid Jobs supporta anche la compilazione parametrica. Puoi inviare un circuito utilizzando parametri liberi e Braket lo compila una sola volta, senza la necessità di ricompilarlo per i successivi aggiornamenti dei parametri sullo stesso circuito, con tempi di esecuzione ancora più rapidi. 1. **Convenienza**: Amazon Braket Hybrid Jobs semplifica la configurazione e la gestione dell'ambiente di calcolo e ne semplifica l'esecuzione durante l'esecuzione dell'algoritmo ibrido. Devi solo fornire lo script dell'algoritmo e selezionare un dispositivo quantistico (un'unità di elaborazione quantistica o un simulatore) su cui eseguire. Amazon Braket attende che il dispositivo di destinazione diventi disponibile, attiva le risorse classiche, esegue il carico di lavoro in ambienti container predefiniti, restituisce i risultati ad Amazon Simple Storage Service (Amazon S3) e rilascia le risorse di elaborazione. 1. **Metriche**: Amazon Braket Hybrid Jobs on-the-fly fornisce approfondimenti sugli algoritmi in esecuzione e fornisce metriche degli algoritmi personalizzabili quasi in tempo reale ad Amazon e alla console Amazon Braket in modo da poter monitorare CloudWatch l'avanzamento dei tuoi algoritmi. ## Esecuzione di un processo ibrido con Amazon Braket Hybrid Jobs Per eseguire un processo ibrido con Amazon Braket Hybrid Jobs, devi prima definire il tuo algoritmo. Puoi definirlo scrivendo lo *script dell'algoritmo* e, facoltativamente, altri file di dipendenza utilizzando Amazon [Braket Python](https://github.com/aws/amazon-braket-sdk-python) SDK o. [PennyLane](https://pennylane.ai) Se desideri utilizzare altre librerie (open source o proprietarie), puoi definire un'immagine del contenitore personalizzata utilizzando Docker, che include queste librerie. Per ulteriori informazioni, consulta [Bring your own container (BYOC](braket-jobs-byoc.md)). In entrambi i casi, successivamente crei un lavoro ibrido utilizzando Amazon BraketAPI, dove fornisci lo script o il contenitore dell'algoritmo, seleziona il dispositivo quantistico di destinazione che il lavoro ibrido deve utilizzare e quindi scegli tra una serie di impostazioni opzionali. I valori predefiniti forniti per queste impostazioni opzionali funzionano per la maggior parte dei casi d'uso. Affinché il dispositivo di destinazione esegua il tuo Hybrid Job, puoi scegliere tra una QPU, un simulatore on-demand (comeSV1, DM1 oTN1) o la classica istanza di job ibrida stessa. Con un simulatore o una QPU on-demand, il tuo contenitore di job ibrido effettua chiamate API verso un dispositivo remoto. Con i simulatori incorporati, il simulatore è incorporato nello stesso contenitore dello script dell'algoritmo. I [simulatori di fulmini](https://github.com/PennyLaneAI/pennylane-lightning) di PennyLane sono integrati nel contenitore di job ibrido predefinito e preconfigurato che puoi utilizzare. Se esegui il codice utilizzando un PennyLane simulatore incorporato o un simulatore personalizzato, puoi specificare un tipo di istanza e quante istanze desideri utilizzare. Consulta la [pagina dei prezzi di Amazon Braket](https://aws.amazon.com/braket/pricing/) per i costi associati a ciascuna scelta. ![\[Diagramma di flusso che mostra le interazioni degli utenti con componenti, API, Jobs Instance e simulatori di Amazon Braket per attività ibride, QPU, on-demand e integrate. I risultati vengono archiviati nel bucket Amazon Simple Storage Service e analizzati utilizzando Amazon CloudWatch sulla console Amazon Braket.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-hybrid-job-run.png) Se il dispositivo di destinazione è un simulatore on-demand o integrato, Amazon Braket inizia subito a eseguire il processo ibrido. Avvia l'istanza del processo ibrido (puoi personalizzare il tipo di istanza nella API chiamata), esegue l'algoritmo, scrive i risultati su Amazon S3 e rilascia le tue risorse. Questa versione di risorse garantisce che paghi solo per ciò che usi. Il numero totale di lavori ibridi simultanei per unità di elaborazione quantistica (QPU) è limitato. Oggi, su una QPU può essere eseguito solo un processo ibrido alla volta. Le code vengono utilizzate per controllare il numero di processi ibridi che possono essere eseguiti in modo da non superare il limite consentito. Se il dispositivo di destinazione è una QPU, il processo ibrido entra prima nella *coda dei lavori* della QPU selezionata. Amazon Braket attiva l'istanza di lavoro ibrida necessaria ed esegue il processo ibrido sul dispositivo. Per tutta la durata dell'algoritmo, il processo ibrido ha accesso prioritario, il che significa che le attività quantistiche del lavoro ibrido vengono eseguite prima delle altre attività quantistiche di Braket in coda sul dispositivo, a condizione che le attività quantistiche del lavoro vengano inviate alla QPU una volta ogni pochi minuti. Una volta completato il lavoro ibrido, vengono rilasciate risorse, il che significa che paghi solo per ciò che utilizzi. **Nota** I dispositivi sono regionali e il processo ibrido viene eseguito sullo Regione AWS stesso dispositivo principale. Sia nello scenario target del simulatore che in quello della QPU, hai la possibilità di definire metriche personalizzate dell'algoritmo, come l'energia della tua Hamiltoniana, come parte dell'algoritmo. Queste metriche vengono segnalate automaticamente ad Amazon CloudWatch e da lì vengono visualizzate quasi in tempo reale nella console Amazon Braket. **Nota** Se desideri utilizzare un'istanza basata su GPU, assicurati di utilizzare uno dei simulatori basati su GPU disponibili con i simulatori integrati su Braket (ad esempio,). `lightning.gpu` Se scegli uno dei simulatori integrati basati su CPU (ad esempio, o`braket:default-simulator`)`lightning.qubit`, la GPU non verrà utilizzata e potresti incorrere in costi inutili. # Concetti chiave per Hybrid Jobs Questa sezione spiega i concetti chiave della `AwsQuantumJob.create` funzione fornita da Amazon Braket Python SDK e la mappatura alla struttura del file contenitore. Oltre al file o ai file che compongono lo script completo dell'algoritmo, il lavoro ibrido può avere input e output aggiuntivi. All'avvio del processo ibrido, Amazon Braket copia gli input forniti come parte della creazione del lavoro ibrido nel contenitore che esegue lo script dell'algoritmo. Al termine del processo ibrido, tutti gli output definiti durante l'algoritmo vengono copiati nella posizione Amazon S3 specificata. **Nota** Le *metriche dell'algoritmo* vengono riportate in tempo reale e non seguono questa procedura di output. Amazon Braket fornisce anche diverse variabili di ambiente e funzioni di supporto per semplificare le interazioni con gli input e gli output dei container. *Per ulteriori informazioni, consulta il [pacchetto braket.jobs nell'SDK](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.jobs.html) Amazon Braket.* **Topics** + [Input](#braket-jobs-inputs) + [Output](#braket-jobs-outputs) + [Variabili di ambiente](#braket-jobs-environmental-variables) + [Funzioni di supporto](#braket-jobs-helper-functions) ## Input **Dati di** input: i dati di input possono essere forniti all'algoritmo ibrido specificando il file di dati di input, che è impostato come dizionario, con l'`input_data`argomento. L'utente definisce l'`input_data`argomento all'interno della `AwsQuantumJob.create` funzione nell'SDK. Questo copia i dati di input nel file system del contenitore nella posizione indicata dalla variabile `"AMZN_BRAKET_INPUT_DIR"` di ambiente. Per un paio di esempi di come i dati di input vengono utilizzati in un algoritmo ibrido, consulta [QAOA con Amazon Braket Hybrid Jobs PennyLane [e Quantum machine learning nei notebook Amazon Braket Hybrid Jobs Jobs Jupyter](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/1_Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs/Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs.ipynb)](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs/Using_PennyLane_with_Braket_Hybrid_Jobs.ipynb). **Nota** Quando i dati di input sono di grandi dimensioni (> 1 GB), ci sarà un lungo tempo di attesa prima che il lavoro ibrido venga inviato. Ciò è dovuto al fatto che i dati di input locali verranno prima caricati su un bucket S3, quindi il percorso S3 verrà aggiunto alla richiesta di lavoro ibrida e, infine, la richiesta di lavoro ibrida verrà inviata al servizio Braket. **Iperparametri**: se si passa`hyperparameters`, sono disponibili nella variabile di ambiente. `"AMZN_BRAKET_HP_FILE"` **Nota** [Per ulteriori informazioni su come creare iperparametri e dati di input e quindi passare queste informazioni allo script di lavoro ibrido, consulta la sezione [Use hyperparameters](braket-jobs-hyperparameters.md) e questa pagina github.](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/1_Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs/qcbm/qcbm.py) **Punti di controllo**: per specificare `job-arn` il checkpoint di cui desideri utilizzare in un nuovo lavoro ibrido, usa il comando. `copy_checkpoints_from_job` Questo comando copia i dati del checkpoint nel nuovo processo ibrido, rendendoli disponibili nel percorso indicato dalla variabile di ambiente `AMZN_BRAKET_CHECKPOINT_DIR` durante l'esecuzione del lavoro. `checkpoint_configs3Uri` L'impostazione predefinita è `None` che i dati del checkpoint di un altro lavoro ibrido non verranno utilizzati nel nuovo lavoro ibrido. ## Output **Attività quantistiche: i risultati delle attività** quantistiche vengono archiviati nella posizione S3. `s3://amazon-braket--/jobs//tasks` **Risultati del lavoro**: tutto ciò che lo script dell'algoritmo salva nella directory fornita dalla variabile di ambiente `"AMZN_BRAKET_JOB_RESULTS_DIR"` viene copiato nella posizione S3 specificata in. `output_data_config` Se il valore non è specificato, il valore predefinito è. `s3://amazon-braket--/jobs///data` Forniamo la funzione di supporto SDK **`save_job_result`**, che puoi utilizzare per archiviare comodamente i risultati sotto forma di dizionario quando richiami dallo script dell'algoritmo. **Punti di controllo**: se desideri utilizzare i checkpoint, puoi salvarli nella directory fornita dalla variabile di ambiente. `"AMZN_BRAKET_CHECKPOINT_DIR"` Puoi invece utilizzare anche la funzione di supporto SDK. `save_job_checkpoint` **Metriche dell'algoritmo**: puoi definire le metriche dell'algoritmo come parte dello script dell'algoritmo che vengono emesse su Amazon CloudWatch e visualizzate in tempo reale nella console Amazon Braket mentre il processo ibrido è in esecuzione. Per un esempio di come utilizzare le metriche degli algoritmi, consulta Use [Amazon Braket Hybrid Jobs per eseguire un algoritmo QAOA](braket-jobs-run-qaoa-algorithm.md). Per ulteriori informazioni sul salvataggio dei risultati dei lavori, consulta [Salvare i risultati nella documentazione di Hybrid](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs-first.html#braket-jobs-save-results) Jobs. ## Variabili di ambiente Amazon Braket fornisce diverse variabili di ambiente per semplificare le interazioni con gli input e gli output dei container. Il codice seguente elenca le variabili ambientali utilizzate da Braket. + `AMZN_BRAKET_INPUT_DIR`— La directory dei dati di input. opt/braket/input/data + `AMZN_BRAKET_JOB_RESULTS_DIR`— La directory di output opt/braket/model in cui scrivere i risultati del lavoro. + `AMZN_BRAKET_JOB_NAME`— Il nome del lavoro. + `AMZN_BRAKET_CHECKPOINT_DIR`— L'elenco dei checkpoint. + `AMZN_BRAKET_HP_FILE`— Il file contenente gli iperparametri. + `AMZN_BRAKET_DEVICE_ARN`— L'ARN (AWS Resource Name) del dispositivo. + `AMZN_BRAKET_OUT_S3_BUCKET`— Il bucket Amazon S3 di output, come specificato nella `CreateJob` richiesta. `OutputDataConfig` + `AMZN_BRAKET_SCRIPT_ENTRY_POINT`— Il punto di ingresso specificato nella `CreateJob` richiesta. `ScriptModeConfig` + `AMZN_BRAKET_SCRIPT_COMPRESSION_TYPE`— Il tipo di compressione specificato nella `CreateJob` richiesta`ScriptModeConfig`. + `AMZN_BRAKET_SCRIPT_S3_URI`— La posizione Amazon S3 dello script dell'utente come specificato nella `CreateJob` richiesta. `ScriptModeConfig` + `AMZN_BRAKET_TASK_RESULTS_S3_URI`— La posizione Amazon S3 in cui l'SDK archivia i risultati quantistici delle attività per impostazione predefinita per il lavoro. + `AMZN_BRAKET_JOB_RESULTS_S3_PATH`— La sede Amazon S3 in cui verranno archiviati i risultati del lavoro, come specificato nella `CreateJob` richiesta. `OutputDataConfig` + `AMZN_BRAKET_JOB_TOKEN`— La stringa che deve essere passata al `CreateQuantumTask` `jobToken` parametro per le attività quantistiche create nel job container. ## Funzioni di supporto Amazon Braket offre diverse funzioni di supporto per semplificare le interazioni con gli input e gli output dei container. Queste funzioni di supporto verrebbero richiamate dall'interno dello script dell'algoritmo utilizzato per eseguire Hybrid Job. L'esempio seguente mostra come utilizzarle. ``` from braket.jobs import get_checkpoint_dir, get_hyperparameters, get_input_data_dir, get_job_device_arn, get_job_name, get_results_dir, save_job_result, save_job_checkpoint, load_job_checkpoint get_checkpoint_dir() # Get the checkpoint directory get_hyperparameters() # Get the hyperparameters as strings get_input_data_dir() # Get the input data directory get_job_device_arn() # Get the device specified by the hybrid job get_job_name() # Get the name of the hybrid job. get_results_dir() # Get the path to a results directory save_job_result(result_data='data') # Save hybrid job results save_job_checkpoint(checkpoint_data={'key': 'value'}) # Save a checkpoint load_job_checkpoint() # Load a previously saved checkpoint ``` # Prerequisiti Prima di eseguire il primo lavoro ibrido, è necessario assicurarsi di disporre delle autorizzazioni sufficienti per procedere con questa attività. Per stabilire di disporre delle autorizzazioni corrette, seleziona **Autorizzazioni** dal menu sul lato sinistro della Braket Console. La pagina **Gestione delle autorizzazioni per Amazon** Braket ti aiuta a verificare se uno dei tuoi ruoli esistenti dispone di autorizzazioni sufficienti per eseguire il tuo lavoro ibrido o ti guida attraverso la creazione di un ruolo predefinito che può essere utilizzato per eseguire il tuo lavoro ibrido se non disponi già di tale ruolo. ![\[Pagina delle autorizzazioni e delle impostazioni per il servizio Amazon Braket che mostra un ruolo collegato al servizio e l'opzione per verificare i ruoli esistenti per il ruolo di esecuzione di Hybrid Jobs.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-jobs-first-permissions.png) **Per verificare di disporre di ruoli con autorizzazioni sufficienti per eseguire un lavoro ibrido, seleziona il pulsante Verifica il ruolo esistente.** Se lo fai, ricevi un messaggio che indica che i ruoli sono stati trovati. Per visualizzare i nomi dei ruoli e il relativo ruolo ARNs, seleziona il pulsante **Mostra ruoli**. ![\[Schermata delle autorizzazioni e delle impostazioni di Amazon Braket che mostra un ruolo collegato al servizio trovato e i ruoli esistenti con autorizzazioni sufficienti per eseguire lavori ibridi.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-yes.png) Se non disponi di un ruolo con autorizzazioni sufficienti per eseguire un lavoro ibrido, ricevi un messaggio che indica che tale ruolo non è stato trovato. Seleziona il pulsante **Crea ruolo predefinito** per ottenere un ruolo con autorizzazioni sufficienti. ![\[Pagina delle autorizzazioni e delle impostazioni di Amazon Braket che mostra il ruolo collegato al servizio trovato e nessun ruolo di esecuzione di lavori ibridi trovato.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-no.png) Se il ruolo è stato creato correttamente, riceverai un messaggio di conferma. ![\[Pagina delle autorizzazioni e delle impostazioni di Amazon Braket che mostra un ruolo collegato al servizio trovato e un ruolo di esecuzione di lavori ibridi creato correttamente.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-created.png) Se non disponi delle autorizzazioni necessarie per effettuare questa richiesta, ti verrà negato l'accesso. In questo caso, contatta l' AWS amministratore interno. ![\[AccessDenied messaggio di errore che indica che l'utente non è autorizzato a eseguire iam: ListAttachedRolePolicies on e AmazonBraketJobsExecutionRole con un rifiuto esplicito.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-jobs-first-permissions-access-denied.png) # Crea un Job ibrido Questa sezione mostra come creare un Hybrid Job usando uno script Python. In alternativa, per creare un lavoro ibrido da codice Python locale, come il tuo ambiente di sviluppo integrato (IDE) preferito o un notebook Braket, vedi. [Esegui il codice locale come lavoro ibrido](braket-hybrid-job-decorator.md) **Topics** + [Crea ed esegui](#braket-jobs-first-create) + [Monitora i tuoi risultati](#braket-jobs-first-monitor-results) + [Salva i risultati](#braket-jobs-save-results) + [Utilizzo dei checkpoint](#braket-jobs-checkpoints) + [Esegui il codice locale come lavoro ibrido](braket-hybrid-job-decorator.md) + [Utilizzo dell'API con Hybrid Jobs](braket-jobs-api.md) + [Crea ed esegui il debug di un processo ibrido con modalità locale](braket-jobs-local-mode.md) ## Crea ed esegui Una volta ottenuto un ruolo con le autorizzazioni per eseguire un lavoro ibrido, sei pronto per procedere. L'elemento chiave del tuo primo lavoro ibrido con Braket è lo script dell'*algoritmo*. Definisce l'algoritmo da eseguire e contiene le classiche attività logiche e quantistiche che fanno parte dell'algoritmo. Oltre allo script dell'algoritmo, puoi fornire altri file di dipendenza. Lo script dell'algoritmo, insieme alle sue dipendenze, viene chiamato modulo *sorgente*. Il *punto di ingresso* definisce il primo file o funzione da eseguire nel modulo di origine all'avvio del processo ibrido. ![\[Diagramma che mostra il flusso di lavoro relativo alla creazione di un lavoro quantistico utilizzando una console o un notebook, all'esecuzione dello script dell'algoritmo su un dispositivo quantistico e all'analisi dei risultati.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-jobs-first-workflow.jpg) Innanzitutto, consideriamo il seguente esempio di base di uno script di algoritmo che crea cinque stati a campana e stampa i risultati di misurazione corrispondenti. ``` import os from braket.aws import AwsDevice from braket.circuits import Circuit def start_here(): print("Test job started!") # Use the device declared in the job script device = AwsDevice(os.environ["AMZN_BRAKET_DEVICE_ARN"]) bell = Circuit().h(0).cnot(0, 1) for count in range(5): task = device.run(bell, shots=100) print(task.result().measurement_counts) print("Test job completed!") ``` Salvate questo file con il nome *algorithm\$1script.py* nella directory di lavoro corrente sul notebook Braket o nell'ambiente locale. Il file algorithm\$1script.py ha `start_here()` come punto di ingresso pianificato. Quindi, crea un file Python o un taccuino Python nella stessa directory del file algorithm\$1script.py. Questo script avvia il processo ibrido e gestisce qualsiasi elaborazione asincrona, come la stampa dello stato o dei risultati chiave che ci interessano. Come minimo, questo script deve specificare lo script di lavoro ibrido e il dispositivo principale. **Nota** Per ulteriori informazioni su come creare un notebook Braket o caricare un file, ad esempio il file *algorithm\$1script.py*, nella stessa directory dei notebook, consulta [Esegui il tuo primo circuito usando l'SDK Amazon Braket Python](braket-get-started-run-circuit.md) Per questo primo caso di base, scegli come target un simulatore. Indipendentemente dal tipo di dispositivo quantistico scelto come target, un simulatore o un'unità di elaborazione quantistica (QPU) effettiva, il dispositivo specificato `device` nello script seguente viene utilizzato per pianificare il processo ibrido ed è disponibile per gli script dell'algoritmo come variabile di ambiente. `AMZN_BRAKET_DEVICE_ARN` **Nota** È possibile utilizzare solo i dispositivi disponibili nel processo ibrido. Regione AWS L'SDK Amazon Braket seleziona automaticamente questa opzione. Regione AWS Ad esempio, un lavoro ibrido in us-east-1 può IonQ utilizzareSV1,, TN1 e dispositiviDM1, ma non dispositivi. Rigetti Se scegli un computer quantistico anziché un simulatore, Braket pianifica i tuoi lavori ibridi per eseguire tutte le loro attività quantistiche con accesso prioritario. ``` from braket.aws import AwsQuantumJob from braket.devices import Devices job = AwsQuantumJob.create( Devices.Amazon.SV1, source_module="algorithm_script.py", entry_point="algorithm_script:start_here", wait_until_complete=True ) ``` Il parametro `wait_until_complete=True` imposta una modalità dettagliata in modo che il lavoro stampi l'output del lavoro effettivo mentre è in esecuzione. Dovreste vedere un output simile a quello dell'esempio seguente. ``` Initializing Braket Job: arn:aws:braket:us-west-2:111122223333:job/braket-job-default-123456789012 Job queue position: 1 Job queue position: 1 Job queue position: 1 .............. . . . Beginning Setup Checking for Additional Requirements Additional Requirements Check Finished Running Code As Process Test job started! Counter({'00': 58, '11': 42}) Counter({'00': 55, '11': 45}) Counter({'11': 51, '00': 49}) Counter({'00': 56, '11': 44}) Counter({'11': 56, '00': 44}) Test job completed! Code Run Finished 2025-09-24 23:13:40,962 sagemaker-training-toolkit INFO Reporting training SUCCESS ``` **Nota** Puoi anche usare il tuo modulo personalizzato con il metodo [AwsQuantumJob.create](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.aws.aws_quantum_job.html#braket.aws.aws_quantum_job.AwsQuantumJob.create) passandone la posizione (il percorso di una directory o di un file locale o un URI S3 di un file tar.gz). [Per un esempio funzionante, consulta il file [Parallelize\$1training\$1for\$1qml.ipynb nella cartella hybrid jobs nel repository Amazon Braket examples Github.](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb)](https://github.com/amazon-braket/amazon-braket-examples/tree/main) ## Monitora i tuoi risultati In alternativa, puoi accedere all'output del registro da Amazon CloudWatch. Per fare ciò, vai alla scheda **Gruppi di log** nel menu a sinistra della pagina di dettaglio del lavoro, seleziona il gruppo di log`aws/braket/jobs`, quindi scegli il flusso di log che contiene il nome del lavoro. Nell'esempio precedente è `braket-job-default-1631915042705/algo-1-1631915190`. ![\[CloudWatch gruppo di log che mostra l'elenco degli eventi di log con percorsi di file e timestamp per i test Python di Amazon Braket SDK.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-jobs-first-cw-log.png) **Puoi anche visualizzare lo stato del lavoro ibrido nella console selezionando la pagina **Hybrid Jobs** e quindi scegliendo Impostazioni.** ![\[Dettagli del processo ibrido di Amazon Braket con riepilogo, orari degli eventi, codice sorgente e configurazione dell'istanza e condizioni di arresto.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-jobs-first-console-status.png) Il tuo lavoro ibrido produce alcuni artefatti in Amazon S3 mentre è in esecuzione. Il nome predefinito del bucket S3 è `amazon-braket--` e il contenuto si trova nella directory. `jobs//` Puoi configurare le posizioni S3 in cui vengono archiviati questi artefatti specificandone una diversa `code_location` quando il lavoro ibrido viene creato con Braket Python SDK. **Nota** Questo bucket S3 deve trovarsi nella stessa posizione del job script. Regione AWS La `jobs//` directory contiene una sottocartella con l'output dello script del punto di ingresso in un file. `model.tar.gz` Esiste anche una directory denominata `script` che contiene gli elementi dello script dell'algoritmo in un file. `source.tar.gz` I risultati delle vostre attività quantistiche effettive si trovano nella directory denominata. `jobs//tasks` ## Salva i risultati È possibile salvare i risultati generati dallo script dell'algoritmo in modo che siano disponibili dall'oggetto di lavoro ibrido nello script del processo ibrido e dalla cartella di output in Amazon S3 (in un file tar-zip denominato model.tar.gz). L'output deve essere salvato in un file utilizzando un formato JavaScript Object Notation (JSON). Se i dati non possono essere serializzati prontamente in testo, come nel caso di un array numpy, puoi passare un'opzione per serializzare utilizzando un formato di dati selezionato. Vedi il modulo [braket.jobs.data\$1persistence](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.jobs.data_persistence.html#braket.jobs.data_persistence.save_job_result) per maggiori dettagli. Per salvare i risultati dei lavori ibridi, aggiungi le seguenti righe commentate con \$1ADD al file algorithm\$1script.py. ``` import os from braket.aws import AwsDevice from braket.circuits import Circuit from braket.jobs import save_job_result # ADD def start_here(): print("Test job started!") device = AwsDevice(os.environ['AMZN_BRAKET_DEVICE_ARN']) results = [] # ADD bell = Circuit().h(0).cnot(0, 1) for count in range(5): task = device.run(bell, shots=100) print(task.result().measurement_counts) results.append(task.result().measurement_counts) # ADD save_job_result({"measurement_counts": results}) # ADD print("Test job completed!") ``` È quindi possibile visualizzare i risultati del lavoro dal proprio script di lavoro aggiungendo la riga **`print(job.result())`**commentata con \$1ADD. ``` import time from braket.aws import AwsQuantumJob job = AwsQuantumJob.create( source_module="algorithm_script.py", entry_point="algorithm_script:start_here", device="arn:aws:braket:::device/quantum-simulator/amazon/sv1", ) print(job.arn) while job.state() not in AwsQuantumJob.TERMINAL_STATES: print(job.state()) time.sleep(10) print(job.state()) print(job.result()) # ADD ``` In questo esempio, abbiamo rimosso `wait_until_complete=True` per sopprimere l'output verboso. Puoi aggiungerlo nuovamente per il debug. Quando si esegue questo processo ibrido, vengono emessi l'identificatore e il`job-arn`, seguiti dallo stato del lavoro ibrido ogni 10 secondi fino all'arrivo del lavoro ibrido`COMPLETED`, dopodiché vengono visualizzati i risultati del circuito a campana. Guarda l'esempio seguente. ``` arn:aws:braket:us-west-2:111122223333:job/braket-job-default-123456789012 INITIALIZED RUNNING RUNNING RUNNING RUNNING RUNNING RUNNING RUNNING RUNNING RUNNING RUNNING ... RUNNING RUNNING COMPLETED {'measurement_counts': [{'11': 53, '00': 47},..., {'00': 51, '11': 49}]} ``` ## Utilizzo dei checkpoint Puoi salvare iterazioni intermedie dei tuoi lavori ibridi utilizzando i checkpoint. Nell'esempio di script di algoritmo della sezione precedente, dovresti aggiungere le seguenti righe commentate con \$1ADD per creare file di checkpoint. ``` from braket.aws import AwsDevice from braket.circuits import Circuit from braket.jobs import save_job_checkpoint # ADD import os def start_here(): print("Test job starts!") device = AwsDevice(os.environ["AMZN_BRAKET_DEVICE_ARN"]) # ADD the following code job_name = os.environ["AMZN_BRAKET_JOB_NAME"] save_job_checkpoint(checkpoint_data={"data": f"data for checkpoint from {job_name}"}, checkpoint_file_suffix="checkpoint-1") # End of ADD bell = Circuit().h(0).cnot(0, 1) for count in range(5): task = device.run(bell, shots=100) print(task.result().measurement_counts) print("Test hybrid job completed!") ``` Quando si esegue il job ibrido, viene creato il file *-checkpoint-1.json* negli artefatti del job ibrido nella directory checkpoints con un percorso predefinito. `/opt/jobs/checkpoints` Lo script di lavoro ibrido rimane invariato a meno che non si desideri modificare questo percorso predefinito. Se si desidera caricare un lavoro ibrido da un checkpoint generato da un precedente lavoro ibrido, lo script dell'algoritmo utilizza. `from braket.jobs import load_job_checkpoint` La logica da caricare nello script dell'algoritmo è la seguente. ``` from braket.jobs import load_job_checkpoint checkpoint_1 = load_job_checkpoint( "previous_job_name", checkpoint_file_suffix="checkpoint-1", ) ``` Dopo aver caricato questo checkpoint, puoi continuare la logica in base al contenuto caricato su. `checkpoint-1` **Nota** Il *checkpoint\$1file\$1suffix deve corrispondere al suffisso precedentemente* specificato durante la creazione del checkpoint. Lo script di orchestrazione deve specificare il precedente lavoro ibrido con la riga commentata con `job-arn` \$1ADD. ``` from braket.aws import AwsQuantumJob job = AwsQuantumJob.create( source_module="source_dir", entry_point="source_dir.algorithm_script:start_here", device="arn:aws:braket:::device/quantum-simulator/amazon/sv1", copy_checkpoints_from_job="", #ADD ) ``` # Esegui il codice locale come lavoro ibrido Amazon Braket Hybrid Jobs fornisce un'orchestrazione completamente gestita di algoritmi ibridi quantistici classici, combinando le risorse di calcolo di Amazon EC2 con l'accesso ad Amazon Braket Quantum Processing Unit (QPU). Le attività quantistiche create in un processo ibrido hanno la priorità di essere messe in coda rispetto alle singole attività quantistiche, in modo che gli algoritmi non vengano interrotti dalle fluttuazioni nella coda delle attività quantistiche. Ogni QPU mantiene una coda di lavori ibridi separata, garantendo che sia possibile eseguire solo un processo ibrido alla volta. **Topics** + [Crea un lavoro ibrido dal codice Python locale](#create-hybrid-job-from-local-python-code) + [Installa pacchetti Python e codice sorgente aggiuntivi](#install-python-packages-and-code) + [Salva e carica i dati in un'istanza di lavoro ibrida](#save-load-data-into-instance) + [Le migliori pratiche per arredatori di lavori ibridi](#best-practices) ## Crea un lavoro ibrido dal codice Python locale Puoi eseguire il codice Python locale come Amazon Braket Hybrid Job. Puoi farlo annotando il codice con un `@hybrid_job` decoratore, come mostrato nel seguente esempio di codice. Per gli ambienti personalizzati, puoi scegliere di [utilizzare un contenitore personalizzato](braket-jobs-byoc.md) da Amazon Elastic Container Registry (ECR). **Nota** Per impostazione predefinita, è supportato solo Python 3.12. È possibile utilizzare il `@hybrid_job` decoratore per annotare una funzione. [Braket trasforma il codice all'interno del decoratore in uno script di algoritmo di lavoro ibrido Braket.](braket-jobs-first.md) Il job ibrido richiama quindi la funzione all'interno del decoratore su un'istanza Amazon EC2. Puoi monitorare l'avanzamento del lavoro con `job.state()` o con la console Braket. Il seguente esempio di codice mostra come eseguire una sequenza di cinque stati su. State Vector Simulator (SV1) device ``` from braket.aws import AwsDevice from braket.circuits import Circuit, FreeParameter, Observable from braket.devices import Devices from braket.jobs.hybrid_job import hybrid_job from braket.jobs.metrics import log_metric device_arn = Devices.Amazon.SV1 @hybrid_job(device=device_arn) # Choose priority device def run_hybrid_job(num_tasks=1): device = AwsDevice(device_arn) # Declare AwsDevice within the hybrid job # Create a parametric circuit circ = Circuit() circ.rx(0, FreeParameter("theta")) circ.cnot(0, 1) circ.expectation(observable=Observable.X(), target=0) theta = 0.0 # Initial parameter for i in range(num_tasks): task = device.run(circ, shots=100, inputs={"theta": theta}) # Input parameters exp_val = task.result().values[0] theta += exp_val # Modify the parameter (possibly gradient descent) log_metric(metric_name="exp_val", value=exp_val, iteration_number=i) return {"final_theta": theta, "final_exp_val": exp_val} ``` Crei il lavoro ibrido invocando la funzione come faresti con le normali funzioni di Python. Tuttavia, la funzione decorator restituisce l'handle del lavoro ibrido anziché il risultato della funzione. Per recuperare i risultati dopo il completamento, usa. `job.result()` ``` job = run_hybrid_job(num_tasks=1) result = job.result() ``` L'argomento device nel `@hybrid_job` decoratore specifica il dispositivo a cui il lavoro ibrido ha accesso prioritario, in questo caso, il simulatore. SV1 Per ottenere la priorità QPU, è necessario assicurarsi che l'ARN del dispositivo utilizzato all'interno della funzione corrisponda a quello specificato nel decoratore. Per comodità, è possibile utilizzare la funzione helper per `get_job_device_arn()` acquisire l'ARN del dispositivo dichiarato in. `@hybrid_job` **Nota** Ogni processo ibrido ha un tempo di avvio di almeno un minuto poiché crea un ambiente containerizzato su Amazon EC2. Quindi, per carichi di lavoro molto brevi, come un singolo circuito o un batch di circuiti, può essere sufficiente utilizzare attività quantistiche. **Iperparametri** La `run_hybrid_job()` funzione utilizza l'argomento `num_tasks` per controllare il numero di attività quantistiche create. [Il processo ibrido lo acquisisce automaticamente come iperparametro.](braket-jobs-hyperparameters.md) **Nota** Gli iperparametri vengono visualizzati nella console Braket come stringhe, limitate a 2500 caratteri. **Metriche e registrazione** All'interno della `run_hybrid_job()` funzione, vengono registrate le metriche degli algoritmi iterativi con. `log_metrics` Le metriche vengono tracciate automaticamente nella pagina della console Braket nella scheda del lavoro ibrido. [Puoi utilizzare le metriche per tracciare i costi quantistici delle attività in tempo quasi reale durante l'esecuzione del lavoro ibrido con il tracker dei costi di Braket.](braket-pricing.md) [L'esempio precedente utilizza il nome della metrica «probabilità» che registra la prima probabilità del tipo di risultato.](braket-result-types.md) **Recupero dei risultati** Una volta completato il lavoro ibrido, si utilizza `job.result()` per recuperare i risultati dei lavori ibridi. Tutti gli oggetti nell'istruzione return vengono acquisiti automaticamente da Braket. Nota che gli oggetti restituiti dalla funzione devono essere una tupla con ogni elemento serializzabile. Ad esempio, il codice seguente mostra un esempio funzionante e uno non riuscito. ``` import numpy as np # Working example @hybrid_job(device=Devices.Amazon.SV1) def passing(): np_array = np.random.rand(5) return np_array # Serializable # # Failing example # @hybrid_job(device=Devices.Amazon.SV1) # def failing(): # return MyObject() # Not serializable ``` **Nome del lavoro** Per impostazione predefinita, il nome di questo lavoro ibrido viene dedotto dal nome della funzione. È inoltre possibile specificare un nome personalizzato lungo fino a 50 caratteri. Ad esempio, nel codice seguente il nome del lavoro è "my-job-name». ``` @hybrid_job(device=Devices.Amazon.SV1, job_name="my-job-name") def function(): pass ``` **modalità locale** I [lavori locali](braket-jobs-local-mode.md) vengono creati aggiungendo l'argomento `local=True` al decoratore. Questo esegue il lavoro ibrido in un ambiente containerizzato sull'ambiente di elaborazione locale, ad esempio il laptop. I lavori locali **non** prevedono la priorità delle code per le attività quantistiche. Per casi avanzati come multi-nodo o MPI, i job locali possono avere accesso alle variabili di ambiente Braket richieste. Il codice seguente crea un processo ibrido locale con il dispositivo come simulatore. SV1 ``` @hybrid_job(device=Devices.Amazon.SV1, local=True) def run_hybrid_job(num_tasks=1): return ... ``` Sono supportate tutte le altre opzioni di lavoro ibride. Per un elenco di opzioni, consultate il modulo [braket.jobs.quantum\$1job\$1creation](https://amazon-braket-sdk-python.readthedocs.io/en/stable/_apidoc/braket.jobs.quantum_job_creation.html). ## Installa pacchetti Python e codice sorgente aggiuntivi Puoi personalizzare il tuo ambiente di runtime per usare i tuoi pacchetti Python preferiti. È possibile utilizzare un `requirements.txt` file, un elenco di nomi di pacchetti o [portare il proprio contenitore (BYOC)](braket-jobs-byoc.md). Ad esempio, il `requirements.txt` file può includere altri pacchetti da installare. ``` qiskit pennylane >= 0.31 mitiq == 0.29 ``` Per personalizzare un ambiente di runtime utilizzando un `requirements.txt` file, fate riferimento al seguente esempio di codice. ``` @hybrid_job(device=Devices.Amazon.SV1, dependencies="requirements.txt") def run_hybrid_job(num_tasks=1): return ... ``` In alternativa, puoi fornire i nomi dei pacchetti come elenco Python come segue. ``` @hybrid_job(device=Devices.Amazon.SV1, dependencies=["qiskit", "pennylane>=0.31", "mitiq==0.29"]) def run_hybrid_job(num_tasks=1): return ... ``` Il codice sorgente aggiuntivo può essere specificato come elenco di moduli o come singolo modulo come nel seguente esempio di codice. ``` @hybrid_job(device=Devices.Amazon.SV1, include_modules=["my_module1", "my_module2"]) def run_hybrid_job(num_tasks=1): return ... ``` ## Salva e carica i dati in un'istanza di lavoro ibrida **Specificazione dei dati di addestramento in ingresso** Quando crei un lavoro ibrido, puoi fornire un set di dati di addestramento di input specificando un bucket Amazon Simple Storage Service (Amazon S3). Puoi anche specificare un percorso locale, quindi Braket carica automaticamente i dati su Amazon S3 all'indirizzo. `s3:///jobs///data/` Se specifichi un percorso locale, il nome del canale è predefinito su «input». Il codice seguente mostra un file numpy dal percorso locale. `data/file.npy` ``` import numpy as np @hybrid_job(device=Devices.Amazon.SV1, input_data="data/file.npy") def run_hybrid_job(num_tasks=1): data = np.load("data/file.npy") return ... ``` Per S3, è necessario utilizzare la funzione di `get_input_data_dir()` supporto. ``` import numpy as np from braket.jobs import get_input_data_dir s3_path = "s3://amazon-braket-us-east-1-123456789012/job-data/file.npy" @hybrid_job(device=None, input_data=s3_path) def job_s3_input(): np.load(get_input_data_dir() + "/file.npy") @hybrid_job(device=None, input_data={"channel": s3_path}) def job_s3_input_channel(): np.load(get_input_data_dir("channel") + "/file.npy") ``` È possibile specificare più fonti di dati di input fornendo un dizionario dei valori dei canali e dei percorsi URIs S3 o locali. ``` import numpy as np from braket.jobs import get_input_data_dir input_data = { "input": "data/file.npy", "input_2": "s3://amzn-s3-demo-bucket/data.json" } @hybrid_job(device=None, input_data=input_data) def multiple_input_job(): np.load(get_input_data_dir("input") + "/file.npy") np.load(get_input_data_dir("input_2") + "/data.json") ``` **Nota** Quando i dati di input sono di grandi dimensioni (>1 GB), c'è un lungo tempo di attesa prima che il lavoro venga creato. Ciò è dovuto ai dati di input locali che vengono caricati per la prima volta in un bucket S3, quindi il percorso S3 viene aggiunto alla richiesta di lavoro. Infine, la richiesta di lavoro viene inviata al servizio Braket. **Salvataggio dei risultati su S3** Per salvare i risultati non inclusi nell'istruzione return della funzione decorata, è necessario aggiungere la directory corretta a tutte le operazioni di scrittura dei file. L'esempio seguente mostra il salvataggio di un array numpy e di una figura matplotlib. ``` import matplotlib.pyplot as plt import numpy as np @hybrid_job(device=Devices.Amazon.SV1) def run_hybrid_job(num_tasks=1): result = np.random.rand(5) # Save a numpy array np.save("result.npy", result) # Save a matplotlib figure plt.plot(result) plt.savefig("fig.png") return ... ``` Tutti i risultati vengono compressi in un file denominato. `model.tar.gz` Puoi scaricare i risultati con la funzione `job.result()` Python o accedendo alla cartella dei risultati dalla pagina del lavoro ibrido nella console di gestione Braket. **Salvataggio e ripresa dai checkpoint** Per lavori ibridi di lunga durata, si consiglia di salvare periodicamente lo stato intermedio dell'algoritmo. È possibile utilizzare la funzione di `save_job_checkpoint()` supporto integrata o salvare i file nel percorso. `AMZN_BRAKET_JOB_RESULTS_DIR` Quest'ultima è disponibile con la funzione helper. `get_job_results_dir()` Quello che segue è un esempio di funzionamento minimo per salvare e caricare i checkpoint con un Job Decorator ibrido: ``` from braket.jobs import save_job_checkpoint, load_job_checkpoint, hybrid_job @hybrid_job(device=None, wait_until_complete=True) def function(): save_job_checkpoint({"a": 1}) job = function() job_name = job.name job_arn = job.arn @hybrid_job(device=None, wait_until_complete=True, copy_checkpoints_from_job=job_arn) def continued_function(): load_job_checkpoint(job_name) continued_job = continued_function() ``` Nel primo job ibrido, `save_job_checkpoint()` viene chiamato con un dizionario contenente i dati che vogliamo salvare. Per impostazione predefinita, ogni valore deve essere serializzabile come testo. Per controllare oggetti Python più complessi, come gli array numpy, puoi impostare. `data_format = PersistedJobDataFormat.PICKLED_V4` Questo codice crea e sovrascrive un file di checkpoint con nome predefinito negli artefatti del job ibrido `.json` in una sottocartella chiamata «checkpoints». Per creare un nuovo lavoro ibrido che prosegua dal checkpoint, dobbiamo indicare `copy_checkpoints_from_job=job_arn` `job_arn` dov'è l'ARN del lavoro ibrido del lavoro precedente. Quindi eseguiamo `load_job_checkpoint(job_name)` il caricamento dal checkpoint. ## Le migliori pratiche per arredatori di lavori ibridi **Abbraccia l'asincronicità** I lavori ibridi creati con l'annotazione decorator sono asincroni: vengono eseguiti non appena le risorse classiche e quantistiche sono disponibili. Monitora l'avanzamento dell'algoritmo utilizzando Braket Management Console o Amazon CloudWatch. Quando invii l'algoritmo per l'esecuzione, Braket lo esegue in un ambiente containerizzato scalabile e i risultati vengono recuperati quando l'algoritmo è completo. **Esegui algoritmi variazionali iterativi** Hybrid jobs ti offre gli strumenti per eseguire algoritmi iterativi quantistici classici. [Per problemi puramente quantistici, utilizzate attività quantistiche o una serie di [attività quantistiche](braket-submit-tasks.md).](braket-batching-tasks.md) L'accesso prioritario a determinati QPUs è particolarmente vantaggioso per gli algoritmi variazionali di lunga durata che richiedono più chiamate iterative a o con l'elaborazione classica intermedia. QPUs **Esegui il debug utilizzando la modalità locale** Prima di eseguire un job ibrido su una QPU, si consiglia di eseguirlo prima sul simulatore SV1 per confermare che funzioni come previsto. Per i test su piccola scala, puoi eseguirli in modalità locale per iterazioni e debug rapidi. **[Migliora la riproducibilità con Bring your own container (BYOC)](braket-jobs-byoc.md)** Crea un esperimento riproducibile incapsulando il tuo software e le sue dipendenze in un ambiente containerizzato. Comprimendo tutto il codice, le dipendenze e le impostazioni in un contenitore, si evitano potenziali conflitti e problemi di versione. **Simulatori distribuiti a più istanze** Per eseguire un gran numero di circuiti, prendi in considerazione l'utilizzo del supporto MPI integrato per eseguire simulatori locali su più istanze all'interno di un singolo processo ibrido. [Per ulteriori informazioni, consulta Simulatori incorporati.](pennylane-embedded-simulators.md) **Usa circuiti parametrici** I circuiti parametrici inviati da un processo ibrido vengono compilati automaticamente su determinati circuiti QPUs utilizzando la [compilazione parametrica](braket-jobs-parametric-compilation.md) per migliorare i tempi di esecuzione degli algoritmi. **Checkpoint periodicamente** Per lavori ibridi di lunga durata, si consiglia di salvare periodicamente lo stato intermedio dell'algoritmo. **Per ulteriori esempi, casi d'uso e best practice, consulta gli esempi di [Amazon GitHub Braket](https://github.com/amazon-braket/amazon-braket-examples).** # Utilizzo dell'API con Hybrid Jobs Puoi accedere e interagire con Amazon Braket Hybrid Jobs direttamente utilizzando. API Tuttavia, le impostazioni predefinite e i metodi pratici non sono disponibili quando si utilizza direttamente. API **Nota** Ti consigliamo vivamente di interagire con Amazon Braket Hybrid Jobs utilizzando l'SDK Amazon [Braket Python](https://github.com/aws/amazon-braket-sdk-python). Offre impostazioni predefinite e protezioni convenienti che aiutano i processi ibridi a funzionare correttamente. In questo argomento vengono illustrate le nozioni di base sull'utilizzo di. API Se scegli di utilizzare l'API, tieni presente che questo approccio può essere più complesso e prepararti a diverse iterazioni per far funzionare il tuo lavoro ibrido. Per utilizzare l'API, il tuo account deve avere un ruolo nella politica `AmazonBraketFullAccess` gestita. **Nota** Per ulteriori informazioni su come ottenere un ruolo con la policy `AmazonBraketFullAccess` gestita, consulta la pagina [Abilita Amazon Braket](braket-enable-overview.md). Inoltre, è necessario un **ruolo di esecuzione**. Questo ruolo verrà passato al servizio. Puoi creare il ruolo utilizzando la console **Amazon Braket.** Utilizza la scheda **Ruoli di esecuzione** nella pagina **Autorizzazioni e impostazioni** per creare un ruolo predefinito per i lavori ibridi. È `CreateJob` API necessario specificare tutti i parametri richiesti per il lavoro ibrido. Per usare Python, comprimi i file di script dell'algoritmo in un pacchetto tar, ad esempio un file input.tar.gz, ed esegui lo script seguente. Aggiorna le parti del codice tra parentesi angolate (`<>`) in modo che corrispondano alle informazioni dell'account e al punto di ingresso che specificano il percorso, il file e il metodo con cui inizia il processo ibrido. ``` from braket.aws import AwsDevice, AwsSession import boto3 from datetime import datetime s3_client = boto3.client("s3") client = boto3.client("braket") project_name = "job-test" job_name = project_name + "-" + datetime.strftime(datetime.now(), "%Y%m%d%H%M%S") bucket = "amazon-braket-" s3_prefix = job_name job_script = "input.tar.gz" job_object = f"{s3_prefix}/script/{job_script}" s3_client.upload_file(job_script, bucket, job_object) input_data = "inputdata.csv" input_object = f"{s3_prefix}/input/{input_data}" s3_client.upload_file(input_data, bucket, input_object) job = client.create_job( jobName=job_name, roleArn="arn:aws:iam:::role/service-role/AmazonBraketJobsExecutionRole", # https://docs.aws.amazon.com/braket/latest/developerguide/braket-manage-access.html#about-amazonbraketjobsexecution algorithmSpecification={ "scriptModeConfig": { "entryPoint": ":", "containerImage": {"uri": "292282985366.dkr.ecr.us-west-1.amazonaws.com/amazon-braket-base-jobs:1.0-cpu-py37-ubuntu18.04"}, # Change to the specific region you are using "s3Uri": f"s3://{bucket}/{job_object}", "compressionType": "GZIP" } }, inputDataConfig=[ { "channelName": "hellothere", "compressionType": "NONE", "dataSource": { "s3DataSource": { "s3Uri": f"s3://{bucket}/{s3_prefix}/input", "s3DataType": "S3_PREFIX" } } } ], outputDataConfig={ "s3Path": f"s3://{bucket}/{s3_prefix}/output" }, instanceConfig={ "instanceType": "ml.m5.large", "instanceCount": 1, "volumeSizeInGb": 1 }, checkpointConfig={ "s3Uri": f"s3://{bucket}/{s3_prefix}/checkpoints", "localPath": "/opt/omega/checkpoints" }, deviceConfig={ "priorityAccess": { "devices": [ "arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3" ] } }, hyperParameters={ "hyperparameter key you wish to pass": "", }, stoppingCondition={ "maxRuntimeInSeconds": 1200, "maximumTaskLimit": 10 }, ) ``` Dopo aver creato il lavoro ibrido, puoi accedere ai dettagli del lavoro ibrido tramite `GetJob` API o la console. Per ottenere i dettagli del lavoro ibrido dalla sessione Python in cui hai eseguito il `createJob` codice come nell'esempio precedente, usa il seguente comando Python. ``` getJob = client.get_job(jobArn=job["jobArn"]) ``` Per annullare un lavoro ibrido, chiamate the `CancelJob` API with the Amazon Resource Name of the job ()'JobArn'. ``` cancelJob = client.cancel_job(jobArn=job["jobArn"]) ``` È possibile specificare i checkpoint come parte dell'`createJob`APIutilizzo del `checkpointConfig` parametro. ``` checkpointConfig = { "localPath" : "/opt/omega/checkpoints", "s3Uri": f"s3://{bucket}/{s3_prefix}/checkpoints" }, ``` **Nota** Il LocalPath di `checkpointConfig` non può iniziare con nessuno dei seguenti percorsi riservati:`/opt/ml`,, `/opt/braket``/tmp`, o. `/usr/local/nvidia` # Crea ed esegui il debug di un processo ibrido con modalità locale Quando si crea un nuovo algoritmo ibrido, la modalità locale consente di eseguire il debug e il test dello script dell'algoritmo. La modalità locale è una funzionalità che ti consente di eseguire il codice che intendi utilizzare in Amazon Braket Hybrid Jobs, ma senza bisogno di Braket per gestire l'infrastruttura per l'esecuzione del lavoro ibrido. Esegui invece lavori ibridi localmente sulla tua istanza Amazon Braket Notebook o su un client preferito, come un laptop o un computer desktop. In modalità locale, puoi comunque inviare attività quantistiche a dispositivi reali, ma non ottieni vantaggi in termini di prestazioni quando esegui su un'unità di elaborazione quantistica (QPU) effettiva in modalità locale. Per utilizzare la modalità locale, modificatela `AwsQuantumJob` `LocalQuantumJob` ovunque si verifichi all'interno del programma. Ad esempio, per eseguire l'esempio di [Create your first hybrid job](braket-jobs-first.md), modificate lo script del job ibrido nel codice come segue. ``` from braket.jobs.local import LocalQuantumJob job = LocalQuantumJob.create( device="arn:aws:braket:::device/quantum-simulator/amazon/sv1", source_module="algorithm_script.py", entry_point="algorithm_script:start_here", ) ``` **Nota** Docker, che è già preinstallato nei notebook Amazon Braket, deve essere installato nel tuo ambiente locale per utilizzare questa funzionalità. [Le istruzioni per l'installazione di Docker sono disponibili nella pagina Get Docker.](https://docs.docker.com/get-started/get-docker/) Inoltre, non tutti i parametri sono supportati in modalità locale. # Annullare un Job ibrido Potrebbe essere necessario annullare un processo ibrido in uno stato non terminale. Questa operazione può essere eseguita nella console o con il codice. Per annullare il lavoro ibrido nella console, seleziona il lavoro ibrido da annullare dalla pagina **Lavori ibridi**, quindi seleziona **Annulla lavoro ibrido** dal menu a discesa **Azioni**. ![\[Tabella dei lavori ibridi di Amazon Braket con 4 lavori che ne mostrano il nome, lo stato, le informazioni sul dispositivo e gli orari. Il menu a discesa Azioni contiene opzioni per visualizzare nuovi lavori ibridi, annullare o gestire i tag.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-hybrid-cancel-job.png) **Per confermare l'annullamento, inserisci *cancel* nel campo di immissione quando richiesto, quindi seleziona OK.** ![\[Finestra di dialogo per annullare un lavoro specifico con avvisi sulla procedura di annullamento e un campo di immissione di testo per confermare inserendo «annulla».\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/braket-hybrid-cancel-job-confirm.png) Per annullare il lavoro ibrido utilizzando il codice dell'SDK Braket Python, usa per identificare `job_arn` il lavoro ibrido e quindi chiama `cancel` il comando su di esso come mostrato nel codice seguente. ``` job = AwsQuantumJob(arn=job_arn) job.cancel() ``` Il `cancel` comando termina immediatamente il classico contenitore di lavoro ibrido e fa del suo meglio per annullare tutte le attività quantistiche correlate che sono ancora in uno stato non terminale. # Personalizzazione del tuo Hybrid Job Amazon Braket offre diversi modi per personalizzare il modo in cui vengono eseguiti i processi ibridi, consentendoti di adattare l'ambiente alle tue esigenze specifiche. Questa sezione esplora le opzioni per personalizzare i lavori ibridi, dalla definizione dell'ambiente di script dell'algoritmo alla creazione di un contenitore personalizzato. Imparerai come ottimizzare il flusso di lavoro utilizzando gli iperparametri, configurare le istanze di lavoro e sfruttare la compilazione parametrica per migliorare le prestazioni. Queste tecniche di personalizzazione ti aiutano a massimizzare il potenziale dei tuoi calcoli quantistici ibridi su Amazon Braket. **Topics** + [Definisci l'ambiente per lo script del tuo algoritmo](braket-jobs-script-environment.md) + [Utilizzo degli iperparametri](braket-jobs-hyperparameters.md) + [Configura la tua istanza di lavoro ibrida](braket-jobs-configure-job-instance-for-script.md) + [Utilizzo della compilazione parametrica per velocizzare i lavori ibridi](braket-jobs-parametric-compilation.md) # Definisci l'ambiente per lo script del tuo algoritmo Amazon Braket supporta ambienti definiti da contenitori per lo script dell'algoritmo: + Un contenitore di base (predefinito, se non `image_uri` è specificato) + Un contenitore con CUDA-Q + Un contenitore con Tensorflow e PennyLane + Un contenitore con PyTorch, PennyLane e CUDA-Q La tabella seguente fornisce dettagli sui contenitori e sulle librerie che includono. **Contenitori Amazon Braket** | Tipo | Base | CUDA-Q | TensorFlow | PyTorch | | --- | --- | --- | --- | --- | | **URI dell'immagine** | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:più recente amazon-braket-base-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:più recente amazon-braket-cudaq-jobs | 292282985366.dkr. ecr.us-east-1.amazonaws.com /:più recente amazon-braket-tensorflow-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:più recente amazon-braket-pytorch-jobs | | **Librerie ereditate** | | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/braket-jobs-script-environment.html) | | **Librerie aggiuntive** | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/braket-jobs-script-environment.html) | [Puoi visualizzare e accedere alle definizioni dei contenitori open source su aws/. amazon-braket-containers](https://github.com/aws/amazon-braket-containers) Scegli il contenitore più adatto al tuo caso d'uso. Puoi utilizzare una qualsiasi delle AWS regioni disponibili in Braket (us-east-1, us-west-1, us-west-2, eu-north-1, eu-west-2), ma la regione del contenitore deve corrispondere alla regione per il tuo lavoro ibrido. Specificate l'immagine del contenitore quando create un lavoro ibrido aggiungendo uno dei seguenti tre argomenti alla chiamata nello script del lavoro ibrido. `create(…​)` Puoi installare dipendenze aggiuntive nel contenitore che scegli in fase di esecuzione (al costo dell'avvio o del runtime) perché i contenitori Amazon Braket dispongono di connettività Internet. L'esempio seguente si riferisce alla regione us-west-2. + **Immagine di base:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest» amazon-braket-base-jobs + **Immagine CUDA-Q:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest» amazon-braket-cudaq-jobs + **Immagine Tensorflow:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest» amazon-braket-tensorflow-jobs + **PyTorch immagine**: image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest» amazon-braket-pytorch-jobs Possono `image-uris` anche essere recuperati utilizzando la funzione in Braket SDK. `retrieve_image()` Amazon L'esempio seguente mostra come recuperarli da Regione AWS us-west-2. ``` from braket.jobs.image_uris import retrieve_image, Framework image_uri_base = retrieve_image(Framework.BASE, "us-west-2") image_uri_cudaq = retrieve_image(Framework.CUDAQ, "us-west-2") image_uri_tf = retrieve_image(Framework.PL_TENSORFLOW, "us-west-2") image_uri_pytorch = retrieve_image(Framework.PL_PYTORCH, "us-west-2") ``` # Importare un container personalizzato (Bring Your Own Container, BYOC) Amazon Braket Hybrid Jobs offre tre contenitori predefiniti per l'esecuzione di codice in ambienti diversi. Se uno di questi contenitori supporta il tuo caso d'uso, devi fornire lo script dell'algoritmo solo quando crei un lavoro ibrido. Le dipendenze minori mancanti possono essere aggiunte dallo script dell'algoritmo o da un `requirements.txt` file utilizzando`pip`. Se nessuno di questi contenitori supporta il tuo caso d'uso o se desideri ampliarli, Braket Hybrid Jobs supporta l'esecuzione di lavori ibridi con la tua immagine del Docker contenitore personalizzata o Bring your own container (BYOC). Assicurati che sia la funzionalità giusta per il tuo caso d'uso. **Topics** + [Quando portare il mio container è la decisione giusta?](#bring-own-container-decision) + [Ricetta per portare il proprio contenitore](bring-own-container-recipe.md) + [Esecuzione dei job ibridi di Braket nel tuo contenitore](running-hybrid-jobs-in-own-container.md) ## Quando portare il mio container è la decisione giusta? Bringing your own container (BYOC) a Braket Hybrid Jobs offre la flessibilità di utilizzare il proprio software installandolo in un ambiente impacchettato. A seconda delle esigenze specifiche, potrebbero esserci modi per ottenere la stessa flessibilità senza dover passare attraverso la BYOC Docker build completa - caricamento Amazon ECR - ciclo URI dell'immagine personalizzata. **Nota** BYOC potrebbe non essere la scelta giusta se si desidera aggiungere un numero limitato di pacchetti Python aggiuntivi (generalmente meno di 10) disponibili pubblicamente. Ad esempio, se stai usando. PyPi In questo caso, puoi utilizzare una delle immagini Braket predefinite e quindi includere un `requirements.txt` file nella directory dei sorgenti al momento dell'invio del lavoro. Il file viene letto automaticamente e `pip` installerà i pacchetti con le versioni specificate come di consueto. Se state installando un gran numero di pacchetti, la durata dei vostri job potrebbe aumentare notevolmente. Controlla la versione Python e, se applicabile, CUDA del contenitore precostruito che desideri utilizzare per verificare se il tuo software funzionerà. Il BYOC è necessario quando si desidera utilizzare un linguaggio non Python (come C\$1\$1 o Rust) per lo script di lavoro o se si desidera utilizzare una versione Python non disponibile tramite i contenitori predefiniti di Braket. È anche una buona scelta se: + Stai utilizzando un software con una chiave di licenza e devi autenticarla su un server di licenza per eseguire il software. Con BYOC, puoi incorporare la chiave di licenza nell'Dockerimmagine e includere il codice per autenticarla. + Stai utilizzando un software che non è disponibile pubblicamente. Ad esempio, il software è ospitato su un archivio privato GitLab o su un GitHub repository a cui è necessaria una particolare chiave SSH per accedere. + È necessario installare un'ampia suite di software che non sia inclusa nei contenitori forniti da Braket. Il BYOC ti consentirà di eliminare i lunghi tempi di avvio per i contenitori di lavori ibridi dovuti all'installazione del software. BYOC consente inoltre di mettere a disposizione dei clienti il proprio SDK o algoritmo personalizzato creando un Docker contenitore con il software e rendendolo disponibile agli utenti. Puoi farlo impostando le autorizzazioni appropriate in Amazon ECR. **Nota** È necessario rispettare tutte le licenze software applicabili. # Ricetta per portare il proprio contenitore In questa sezione, forniamo una step-by-step guida su ciò che ti serve bring your own container (BYOC) per Braket Hybrid Jobs: gli script, i file e i passaggi per combinarli per iniziare a utilizzare le tue immagini personalizzateDocker. Le ricette per due casi comuni: 1. Installa software aggiuntivo in un'Dockerimmagine e usa solo script di algoritmi Python nei tuoi lavori. 1. Usa script di algoritmi scritti in un linguaggio non Python con Hybrid Jobs o un'architettura CPU diversa da x86. La definizione dello *script di immissione del contenitore* è più complessa nel caso 2. Quando Braket esegue il tuo Hybrid Job, avvia il numero e il tipo richiesti di istanze Amazon EC2, quindi esegue Docker l'immagine specificata dall'input URI dell'immagine per la creazione di job su di esse. Quando utilizzi la funzionalità BYOC, specifichi un URI di immagine ospitato in un [repository Amazon ECR privato](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) a cui hai accesso in lettura. Braket Hybrid Jobs utilizza quell'immagine personalizzata per eseguire il lavoro. I componenti specifici necessari per creare un'Dockerimmagine che può essere utilizzata con Hybrid Jobs. [Se non hai familiarità con la scrittura e la creazione`Dockerfiles`, fai riferimento alla documentazione e alla [documentazione di Dockerfile](https://docs.docker.com/reference/dockerfile/). Amazon ECR CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html) **Topics** + [Un'immagine di base per il tuo Dockerfile](#base-image-dockerfile) + [(Facoltativo) Uno script modificato per il punto di ingresso del contenitore](#modified-container-entry-point) + [Installa il software e lo script del contenitore necessari con `Dockerfile`](#install-docketfile) ## Un'immagine di base per il tuo Dockerfile Se utilizzi Python e desideri installare software in aggiunta a quanto fornito nei contenitori forniti da Braket, un'opzione per un'immagine di base è una delle immagini del contenitore Braket, ospitate nel nostro [GitHub repository](https://github.com/amazon-braket/amazon-braket-containers) e su Amazon ECR. Dovrai [autenticarti su Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry) per estrarre l'immagine e crearla su di essa. Ad esempio, la prima riga del tuo file BYOC potrebbe essereDocker: `FROM [IMAGE_URI_HERE]` Quindi, compila il resto Dockerfile per installare e configurare il software che desideri aggiungere al contenitore. Le immagini Braket predefinite conterranno già lo script del punto di ingresso del contenitore appropriato, quindi non devi preoccuparti di includerlo. Se vuoi usare un linguaggio non Python, come C\$1\$1, Rust o Julia, o se vuoi creare un'immagine per un'architettura CPU non x86, come ARM, potresti dover creare su un'immagine pubblica barebone. Puoi trovare molte di queste immagini nella [galleria pubblica di Amazon Elastic Container Registry](https://gallery.ecr.aws/). Assicurati di sceglierne una adatta all'architettura della CPU e, se necessario, alla GPU che desideri utilizzare. ## (Facoltativo) Uno script modificato per il punto di ingresso del contenitore **Nota** Se stai solo aggiungendo software aggiuntivo a un'immagine Braket predefinita, puoi saltare questa sezione. Per eseguire codice non Python come parte del tuo lavoro ibrido, modifica lo script Python che definisce il punto di ingresso del contenitore. Ad esempio, lo [script `braket_container.py` python su Amazon Braket](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py) Github. Questo è lo script che le immagini precreate da Braket utilizzano per avviare lo script dell'algoritmo e impostare le variabili di ambiente appropriate. Lo script del punto di ingresso del contenitore stesso **deve** essere in Python, ma può avviare script non Python. [Nell'esempio predefinito, puoi vedere che gli script degli algoritmi Python vengono avviati come sottoprocesso [Python](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L274) o come processo completamente nuovo.](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L257) Modificando questa logica, è possibile abilitare lo script del punto di ingresso per avviare script di algoritmi non Python. Ad esempio, è possibile modificare la [https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L139](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L139)funzione per avviare i processi Rust in base alla fine dell'estensione del file. Puoi anche scegliere di scriverne uno completamente nuovo`braket_container.py`. Dovrebbe copiare i dati di input, gli archivi di origine e altri file necessari da Amazon S3 nel contenitore e definire le variabili di ambiente appropriate. ## Installa il software e lo script del contenitore necessari con `Dockerfile` **Nota** Se utilizzi un'immagine Braket predefinita come immagine di Docker base, lo script del contenitore è già presente. Se hai creato uno script contenitore modificato nel passaggio precedente, dovrai copiarlo nel contenitore **e** definire la variabile di ambiente o il nome che hai dato `SAGEMAKER_PROGRAM` al `braket_container.py` nuovo script del punto di ingresso del contenitore. Di seguito è riportato un esempio `Dockerfile` che consente di utilizzare Julia su istanze Jobs accelerate da GPU: ``` FROM nvidia/cuda:12.2.0-devel-ubuntu22.04 ARG DEBIAN_FRONTEND=noninteractive ARG JULIA_RELEASE=1.8 ARG JULIA_VERSION=1.8.3 ARG PYTHON=python3.11 ARG PYTHON_PIP=python3-pip ARG PIP=pip ARG JULIA_URL = https://julialang-s3.julialang.org/bin/linux/x64/${JULIA_RELEASE}/ ARG TAR_NAME = julia-${JULIA_VERSION}-linux-x86_64.tar.gz ARG PYTHON_PKGS = # list your Python packages and versions here RUN curl -s -L ${JULIA_URL}/${TAR_NAME} | tar -C /usr/local -x -z --strip-components=1 -f - RUN apt-get update \ && apt-get install -y --no-install-recommends \ build-essential \ tzdata \ openssh-client \ openssh-server \ ca-certificates \ curl \ git \ libtemplate-perl \ libssl1.1 \ openssl \ unzip \ wget \ zlib1g-dev \ ${PYTHON_PIP} \ ${PYTHON}-dev \ RUN ${PIP} install --no-cache --upgrade ${PYTHON_PKGS} RUN ${PIP} install --no-cache --upgrade sagemaker-training==4.1.3 # Add EFA and SMDDP to LD library path ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH" ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH # Julia specific installation instructions COPY Project.toml /usr/local/share/julia/environments/v${JULIA_RELEASE}/ RUN JULIA_DEPOT_PATH=/usr/local/share/julia \ julia -e 'using Pkg; Pkg.instantiate(); Pkg.API.precompile()' # generate the device runtime library for all known and supported devices RUN JULIA_DEPOT_PATH=/usr/local/share/julia \ julia -e 'using CUDA; CUDA.precompile_runtime()' # Open source compliance scripts RUN HOME_DIR=/root \ && curl -o ${HOME_DIR}/oss_compliance.zip https://aws-dlinfra-utilities.s3.amazonaws.com/oss_compliance.zip \ && unzip ${HOME_DIR}/oss_compliance.zip -d ${HOME_DIR}/ \ && cp ${HOME_DIR}/oss_compliance/test/testOSSCompliance /usr/local/bin/testOSSCompliance \ && chmod +x /usr/local/bin/testOSSCompliance \ && chmod +x ${HOME_DIR}/oss_compliance/generate_oss_compliance.sh \ && ${HOME_DIR}/oss_compliance/generate_oss_compliance.sh ${HOME_DIR} ${PYTHON} \ && rm -rf ${HOME_DIR}/oss_compliance* # Copying the container entry point script COPY braket_container.py /opt/ml/code/braket_container.py ENV SAGEMAKER_PROGRAM braket_container.py ``` Questo esempio scarica ed esegue gli script forniti da per garantire la conformità con tutte le licenze AWS Open-Source pertinenti. Ad esempio, attribuendo correttamente qualsiasi codice installato governato da un. MIT license Se devi includere codice non pubblico, ad esempio codice ospitato in un GitLab archivio GitHub o in un archivio privato, **non** incorporare le chiavi SSH nell'immagine per accedervi. Docker Utilizza invece Docker Compose when you build per consentire l'accesso Docker a SSH sulla macchina host su cui è costruito. Per maggiori informazioni, consulta la guida [Uso sicuro delle chiavi SSH in Docker per accedere ai repository privati](https://www.fastruby.io/blog/docker/docker-ssh-keys.html) di Github. **DockerCreazione e caricamento della tua immagine** Una volta definito correttamente`Dockerfile`, sei pronto a seguire i passaggi per [creare un repository Amazon ECR privato](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html), se non ne esiste già uno. Puoi anche creare, etichettare e caricare l'immagine del contenitore nel repository. Sei pronto per creare, etichettare e inserire l'immagine. Consulta la [documentazione della build di Docker](https://docs.docker.com/reference/cli/docker/buildx/build/) per una spiegazione completa delle opzioni `docker build` e alcuni esempi. Per il file di esempio sopra definito, puoi eseguire: ``` aws ecr get-login-password --region ${your_region} | docker login --username AWS --password-stdin ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com docker build -t braket-julia . docker tag braket-julia:latest ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com/braket-julia:latest docker push ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com/braket-julia:latest ``` **Assegnazione delle autorizzazioni Amazon ECR appropriate** Braket Hybrid Jobs Dockerle immagini devono essere ospitate in repository privati di Amazon ECR. Per impostazione predefinita, un repository Amazon ECR privato **non** fornisce l'accesso in lettura a Braket Hybrid Jobs IAM role o ad altri utenti che desiderano utilizzare la tua immagine, ad esempio un collaboratore o uno studente. È necessario [impostare una politica di repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) per concedere le autorizzazioni appropriate. In generale, concedi l'autorizzazione solo agli utenti e ai IAM ruoli specifici a cui desideri accedere alle tue immagini, anziché consentire a chiunque li possieda di image URI recuperarle. # Esecuzione dei job ibridi di Braket nel tuo contenitore Per creare un lavoro ibrido con il tuo contenitore, chiama `AwsQuantumJob.create()` con l'argomento `image_uri` specificato. È possibile utilizzare una QPU, un simulatore on-demand o eseguire il codice localmente sul processore classico disponibile con Braket Hybrid Jobs. Ti consigliamo di testare il codice su un simulatore come SV1 DM1, o TN1 prima di eseguirlo su una vera QPU. Per eseguire il codice sul processore classico, specifica `instanceType` and the `instanceCount` che usi aggiornando il. `InstanceConfig` Tieni presente che se specifichi un valore `instance_count` > 1, devi assicurarti che il codice possa essere eseguito su più host. Il limite massimo per il numero di istanze che puoi scegliere è 5. Esempio: ``` job = AwsQuantumJob.create( source_module="source_dir", entry_point="source_dir.algorithm_script:start_here", image_uri="111122223333.dkr.ecr.us-west-2.amazonaws.com/my-byoc-container:latest", instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge", instanceCount=3), device="local:braket/braket.local.qubit", # ...) ``` **Nota** Usa l'ARN del dispositivo per tracciare il simulatore che hai usato come metadati di lavoro ibridi. I valori accettabili devono seguire il formato. `device = "local:/"` Ricordatelo `` e `` deve essere composto solo da lettere, numeri`_`,`-`, e`.`. La stringa è limitata a 256 caratteri. Se intendi utilizzare BYOC e non utilizzi l'SDK Braket per creare attività quantistiche, dovresti passare il valore della variabile ambientale `AMZN_BRAKET_JOB_TOKEN` al parametro nella richiesta. `jobToken` `CreateQuantumTask` In caso contrario, le attività quantistiche non hanno la priorità e vengono fatturate come normali attività quantistiche autonome. # Utilizzo degli iperparametri È possibile definire gli iperparametri necessari all'algoritmo, come il tasso di apprendimento o la dimensione del passo, quando si crea un lavoro ibrido. I valori degli iperparametri vengono in genere utilizzati per controllare vari aspetti dell'algoritmo e spesso possono essere regolati per ottimizzare le prestazioni dell'algoritmo. Per utilizzare gli iperparametri in un processo ibrido Braket, è necessario specificarne i nomi e i valori in modo esplicito come dizionario. Specificate i valori degli iperparametri da testare durante la ricerca del set di valori ottimale. Il primo passaggio per utilizzare gli iperparametri consiste nell'impostare e definire gli iperparametri come dizionario, come illustrato nel codice seguente. ``` from braket.devices import Devices device_arn = Devices.Amazon.SV1 hyperparameters = {"shots": 1_000} ``` Quindi passate gli iperparametri definiti nel frammento di codice sopra riportato da utilizzare nell'algoritmo di vostra scelta. Per eseguire il seguente esempio di codice, create una directory denominata «src» nello stesso percorso del file di iperparametri. [https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py) ``` import time from braket.aws import AwsQuantumJob job = AwsQuantumJob.create( device=device_arn, source_module="src", entry_point="src.notebook_runner:run_notebook", input_data="src/0_Getting_started_papermill.ipynb", hyperparameters=hyperparameters, job_name=f"papermill-job-demo-{int(time.time())}", ) # Print job to record the ARN print(job) ``` *[Per accedere ai tuoi iperparametri dall'interno dello script di lavoro ibrido, consulta la funzione nel file notebook\$1runner.py python. `load_jobs_hyperparams()`](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py)* Per accedere ai tuoi iperparametri *al di fuori* dello script di lavoro ibrido, esegui il codice seguente. ``` from braket.aws import AwsQuantumJob # Get the job using the ARN job_arn = "arn:aws:braket:us-east-1:111122223333:job/5eabb790-d3ff-47cc-98ed-b4025e9e296f" # Replace with your job ARN job = AwsQuantumJob(arn=job_arn) # Access the hyperparameters job_metadata = job.metadata() hyperparameters = job_metadata.get("hyperParameters", {}) print(hyperparameters) ``` Per ulteriori informazioni su come imparare a usare gli iperparametri, consulta i tutorial [QAOA con Amazon Braket Hybrid Jobs PennyLane e [Quantum machine learning nei](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/1_Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs/Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs.ipynb) tutorial Amazon Braket Hybrid Jobs](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs/Using_PennyLane_with_Braket_Hybrid_Jobs.ipynb). # Configura la tua istanza di lavoro ibrida A seconda dell'algoritmo, potresti avere requisiti diversi. Per impostazione predefinita, Amazon Braket esegue lo script dell'algoritmo su un'`ml.m5.large`istanza. Tuttavia, puoi personalizzare questo tipo di istanza quando crei un lavoro ibrido utilizzando il seguente argomento di importazione e configurazione. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"), # Use NVIDIA T4 instance with 4 GPUs. ... ), ``` Se state eseguendo una simulazione incorporata e avete specificato un dispositivo locale nella configurazione del dispositivo, potete inoltre richiedere più di un'istanza `InstanceConfig` specificando `instanceCount` e impostando che sia maggiore di una. Il limite massimo è 5. Ad esempio, puoi scegliere 3 istanze come segue. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge", instanceCount=3), # Use 3 NVIDIA T4 instances ... ), ``` Quando utilizzi più istanze, valuta la possibilità di distribuire il job ibrido utilizzando la funzionalità data parallel. Consulta il seguente taccuino di esempio per maggiori dettagli su come vedere questo esempio di formazione su [Parallelize](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) per QML. Le tre tabelle seguenti elencano i tipi di istanze e le specifiche disponibili per le istanze standard, ad alte prestazioni e con accelerazione GPU. **Nota** Per visualizzare le quote predefinite delle istanze di calcolo classiche per Hybrid Jobs, consulta la pagina [Amazon Braket](braket-quotas.md) Quotas. | Istanza | VPCU | Memoria (GiB) | | --- | --- | --- | | ml.m5.large (impostazione predefinita) | 4 | 16 | | ml.m5.xlarge | 4 | 16 | | ml.m5.2xlarge | 8 | 32 | | ml.m5.4xlarge | 16 | 64 | | ml.m5.12xlarge | 48 | 192 | | ml.m5.24xlarge | 96 | 384 | | Istanze ad alte prestazioni | VPCU | Memoria (GiB) | | --- | --- | --- | | ml.c5.xlarge | 4 | 8 | | ml.c5.2xlarge | 8 | 16 | | ml.c5.4xlarge | 16 | 32 | | ml.c5.9xlarge | 36 | 72 | | ml.c5.18xlarge | 72 | 144 | | ml.c5n.xlarge | 4 | 10,5 | | ml.c5n.2xlarge | 8 | 21 | | ml.c5n.4xlarge | 16 | 32 | | ml.c5n.9xlarge | 36 | 72 | | ml.c5n.18xlarge | 72 | 192 | | Istanze con accelerazione GPU | GPUs | VPCU | Memoria (GiB) | Memoria GPU (GiB) | | --- | --- | --- | --- | --- | | ml.p4d.24xlarge | 8 | 96 | 1152 | 320 | | ml.g4dn.xlarge | 1 | 4 | 16 | 16 | | ml.g4dn.2xlarge | 1 | 8 | 32 | 16 | | ml.g4dn.4xlarge | 1 | 16 | 64 | 16 | | ml.g4dn.8xlarge | 1 | 32 | 128 | 16 | | ml.g4dn.12xlarge | 4 | 48 | 192 | 64 | | ml.g4dn.16xlarge | 1 | 64 | 256 | 16 | Ogni istanza utilizza una configurazione predefinita di archiviazione dati (SSD) di 30 GB. È tuttavia possibile regolare lo spazio di archiviazione nello stesso modo in cui si configura il`instanceType`. L'esempio seguente mostra come aumentare lo spazio di archiviazione totale a 50 GB. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig( instanceType="ml.g4dn.xlarge", volumeSizeInGb=50, ), ... ), ``` ## Configura il bucket predefinito in `AwsSession` L'utilizzo della tua `AwsSession` istanza ti offre una maggiore flessibilità, come la possibilità di specificare una posizione personalizzata per il tuo bucket Amazon S3 predefinito. Per impostazione predefinita, an `AwsSession` ha una posizione del bucket Amazon S3 preconfigurata di. `"amazon-braket-{id}-{region}"` Tuttavia, hai la possibilità di sovrascrivere la posizione predefinita del bucket Amazon S3 durante la creazione di un. `AwsSession` Gli utenti possono facoltativamente passare un `AwsSession` oggetto al `AwsQuantumJob.create()` metodo, fornendo il `aws_session` parametro come illustrato nel seguente esempio di codice. ``` aws_session = AwsSession(default_bucket="amazon-braket-s3-demo-bucket") # Then you can use that AwsSession when creating a hybrid job job = AwsQuantumJob.create( ... aws_session=aws_session ) ``` # Utilizzo della compilazione parametrica per velocizzare i lavori ibridi Amazon Braket supporta la compilazione parametrica su alcuni. QPUs Ciò consente di ridurre il sovraccarico associato alla fase di compilazione, dal punto di vista computazionalmente costoso, compilando un circuito una sola volta e non per ogni iterazione del tuo algoritmo ibrido. Ciò può migliorare notevolmente i tempi di esecuzione per Hybrid Jobs, poiché si evita la necessità di ricompilare il circuito in ogni fase. Basta inviare circuiti parametrizzati a uno dei nostri Braket Hybrid QPUs Job supportati. Per lavori ibridi di lunga durata, Braket utilizza automaticamente i dati di calibrazione aggiornati del fornitore di hardware durante la compilazione del circuito per garantire risultati della massima qualità. Per creare un circuito parametrico, devi prima fornire i parametri come input nello script dell'algoritmo. In questo esempio, utilizziamo un piccolo circuito parametrico e ignoriamo qualsiasi elaborazione classica tra ogni iterazione. Per i carichi di lavoro tipici, è necessario inviare molti circuiti in batch ed eseguire l'elaborazione classica, ad esempio l'aggiornamento dei parametri in ogni iterazione. ``` import os from braket.aws import AwsDevice from braket.circuits import Circuit, FreeParameter def start_here(): print("Test job started.") # Use the device declared in the job script device = AwsDevice(os.environ["AMZN_BRAKET_DEVICE_ARN"]) circuit = Circuit().rx(0, FreeParameter("theta")) parameter_list = [0.1, 0.2, 0.3] for parameter in parameter_list: result = device.run(circuit, shots=1000, inputs={"theta": parameter}) print("Test job completed.") ``` È possibile inviare lo script dell'algoritmo per l'esecuzione come Hybrid Job con il seguente script di processo. Quando si esegue Hybrid Job su una QPU che supporta la compilazione parametrica, il circuito viene compilato solo alla prima esecuzione. Nelle esecuzioni successive, il circuito compilato viene riutilizzato, aumentando le prestazioni di runtime di Hybrid Job senza righe di codice aggiuntive. ``` from braket.aws import AwsQuantumJob job = AwsQuantumJob.create( device=device_arn, source_module="algorithm_script.py", ) ``` **Nota** La compilazione parametrica è supportata su tutti i moduli superconduttori basati su gate, ad eccezione dei programmi a livello di QPUs Rigetti Computing impulsi. # Utilizzo PennyLane con Amazon Braket Gli algoritmi ibridi sono algoritmi che contengono istruzioni sia classiche che quantistiche. Le istruzioni classiche vengono eseguite su hardware classico (un'istanza EC2 o un laptop) e le istruzioni quantistiche vengono eseguite su un simulatore o su un computer quantistico. Ti consigliamo di eseguire algoritmi ibridi utilizzando la funzionalità Hybrid Jobs. Per ulteriori informazioni, consulta [Quando usare Amazon Braket](braket-jobs.md#braket-jobs-use) Jobs. Amazon Braket ti consente di configurare ed eseguire algoritmi quantistici ibridi con l'assistenza del ** PennyLane plug-in Amazon Braket o con l'SDK Amazon Braket Python** e repository di notebook di **esempio**. I notebook di esempio Amazon Braket, basati sull'SDK, consentono di configurare ed eseguire determinati algoritmi ibridi senza il plug-in. PennyLane Tuttavia, lo consigliamo PennyLane perché offre un'esperienza più ricca. **Informazioni sugli algoritmi quantistici ibridi** Gli algoritmi quantistici ibridi sono importanti per il settore odierno perché i dispositivi informatici quantistici contemporanei generalmente producono rumore e quindi errori. Ogni porta quantistica aggiunta a un calcolo aumenta la possibilità di aggiungere rumore; pertanto, gli algoritmi di lunga durata possono essere sopraffatti dal rumore, con conseguenti errori di calcolo. Algoritmi quantistici puri come quelli di Shor [(esempio Quantum Phase Estimation) o Grover [(](https://github.com/aws/amazon-braket-examples/tree/main/examples/advanced_circuits_algorithms/Grover)esempio Grover)](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/advanced_circuits_algorithms/Quantum_Phase_Estimation) richiedono migliaia o milioni di operazioni. *Per questo motivo, possono essere poco pratici per i dispositivi quantistici esistenti, che vengono generalmente definiti dispositivi quantistici rumorosi su scala intermedia (NISQ).* Negli algoritmi quantistici ibridi, le unità di elaborazione quantistica (QPUs) funzionano come coprocessori per la versione classica, in particolare per velocizzare determinati calcoli in un algoritmo classico. CPUs Le esecuzioni dei circuiti diventano molto più brevi, alla portata delle funzionalità dei dispositivi odierni. **Topics** + [Amazon Braket con PennyLane](#pennylane-option) + [Algoritmi ibridi nei notebook di esempio Amazon Braket](#braket-hybrid-workflow) + [Algoritmi ibridi con simulatori integrati PennyLane](#hybrid-alorithms-pennylane) + [Aggiungi il gradiente con i simulatori Amazon PennyLane Braket](#adjoint-gradient-pennylane) + [PennyLane Utilizzo di Hybrid Jobs ed esecuzione di un algoritmo QAOA](braket-jobs-run-qaoa-algorithm.md) + [Esegui carichi di lavoro ibridi con simulatori integrati PennyLane](pennylane-embedded-simulators.md) ## Amazon Braket con PennyLane Amazon Braket fornisce supporto per [PennyLane](https://pennylane.ai)un framework software open source basato sul concetto di programmazione *quantistica* differenziabile. Puoi usare questo framework per addestrare i circuiti quantistici nello stesso modo in cui addestreresti una rete neurale per trovare soluzioni a problemi computazionali di chimica quantistica, apprendimento automatico quantistico e ottimizzazione. La PennyLane libreria fornisce interfacce a strumenti di apprendimento automatico familiari, tra cui PyTorch e, per rendere l'addestramento dei circuiti quantistici TensorFlow rapido e intuitivo. + **La PennyLane libreria** -— PennyLane è preinstallata nei notebook Braket. Amazon Per accedere ai dispositivi Amazon Braket da PennyLane, apri un notebook e importa la libreria con il PennyLane seguente comando. ``` import pennylane as qml ``` I taccuini tutorial ti aiutano a iniziare rapidamente. In alternativa, puoi utilizzarlo PennyLane su Amazon Braket da un IDE a tua scelta. + **Il PennyLane plug-in Amazon Braket**: per utilizzare il tuo IDE, puoi installare il plug-in Amazon Braket PennyLane manualmente. Il plug-in si connette PennyLane all'[SDK Amazon Braket Python](https://github.com/aws/amazon-braket-sdk-python), in modo da poter eseguire circuiti sui dispositivi Braket. PennyLane Amazon Per installare il PennyLane plugin, usa il seguente comando. ``` pip install amazon-braket-pennylane-plugin ``` L'esempio seguente mostra come configurare l'accesso ai dispositivi Amazon Braket in: PennyLane ``` # to use SV1 import pennylane as qml sv1 = qml.device("braket.aws.qubit", device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1", wires=2) # to run a circuit: @qml.qnode(sv1) def circuit(x): qml.RZ(x, wires=0) qml.CNOT(wires=[0,1]) qml.RY(x, wires=1) return qml.expval(qml.PauliZ(1)) result = circuit(0.543) #To use the local sim: local = qml.device("braket.local.qubit", wires=2) ``` Per esempi di tutorial e ulteriori informazioni a riguardo PennyLane, consulta l'archivio degli [esempi di Amazon Braket](https://github.com/aws/amazon-braket-examples/tree/main/examples/pennylane). Il PennyLane plug-in Amazon Braket ti consente di passare da Amazon Braket QPU a dispositivi di simulazione integrati PennyLane con una sola riga di codice. Offre due dispositivi quantistici Amazon Braket con cui lavorare: PennyLane + `braket.aws.qubit`per funzionare con i dispositivi quantistici del servizio Amazon Braket, inclusi i simulatori QPUs + `braket.local.qubit`per funzionare con il simulatore locale di Amazon Braket SDK Il PennyLane plugin Amazon Braket è open source. Puoi installarlo dal [ GitHub repository dei PennyLane plugin](https://github.com/aws/amazon-braket-pennylane-plugin-python). Per ulteriori informazioni in merito PennyLane, consulta la documentazione sul [PennyLane sito Web](https://pennylane.ai). ## Algoritmi ibridi nei notebook di esempio Amazon Braket Amazon Braket fornisce una serie di notebook di esempio che non si basano sul PennyLane plug-in per l'esecuzione di algoritmi ibridi. Puoi iniziare con uno qualsiasi di questi [notebook di esempio ibridi Amazon Braket](https://github.com/aws/amazon-braket-examples/tree/main/examples/hybrid_quantum_algorithms) che illustrano *metodi variazionali, come Quantum Approximate Optimization Algorithm (QAOA) o Variational* Quantum Eigensolver (VQE). [I notebook di esempio Amazon Braket si basano sull'SDK Amazon Braket Python.](https://github.com/aws/amazon-braket-sdk-python) L'SDK fornisce un framework per interagire con i dispositivi hardware di calcolo quantistico tramite Braket. Amazon È una libreria open source progettata per assistervi nella parte quantistica del vostro flusso di lavoro ibrido. Puoi esplorare ulteriormente Amazon Braket con i nostri taccuini di [esempio](https://github.com/aws/amazon-braket-examples). ## Algoritmi ibridi con simulatori integrati PennyLane Amazon Braket Hybrid Jobs ora include simulatori integrati ad alte prestazioni basati su CPU e GPU di. [PennyLane](https://github.com/PennyLaneAI/pennylane-lightning) [Questa famiglia di simulatori integrati può essere incorporata direttamente nel tuo contenitore di lavori ibridi e include il veloce simulatore state-vector, il `lightning.qubit``lightning.gpu` simulatore accelerato utilizzando la libreria cuQuantum di NVIDIA e altri.](https://developer.nvidia.com/cuquantum-sdk) [Questi simulatori integrati sono ideali per algoritmi variazionali come l'apprendimento automatico quantistico, che possono trarre vantaggio da metodi avanzati come il metodo di differenziazione adjoint.](https://docs.pennylane.ai/en/stable/introduction/interfaces.html#simulation-based-differentiation) È possibile eseguire questi simulatori incorporati su una o più istanze di CPU o GPU. Con Hybrid Jobs, ora puoi eseguire il codice dell'algoritmo variazionale utilizzando una combinazione di un coprocessore classico e una QPU, un simulatore on-demand Amazon Braket comeSV1, o utilizzando direttamente il simulatore incorporato di. PennyLane Il simulatore incorporato è già disponibile con il contenitore Hybrid Jobs, devi decorare la tua funzione Python principale con `@hybrid_job` il decoratore. Per utilizzare il PennyLane `lightning.gpu` simulatore, è inoltre necessario specificare un'istanza GPU `InstanceConfig` come mostrato nel seguente frammento di codice: ``` import pennylane as qml from braket.jobs import hybrid_job from braket.jobs.config import InstanceConfig @hybrid_job(device="local:pennylane/lightning.gpu", instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge")) def function(wires): dev = qml.device("lightning.gpu", wires=wires) ... ``` Fate riferimento al [notebook di esempio](https://github.com/aws/amazon-braket-examples/blob/main/examples/hybrid_jobs/4_Embedded_simulators_in_Braket_Hybrid_Jobs/Embedded_simulators_in_Braket_Hybrid_Jobs.ipynb) per iniziare a utilizzare un simulatore PennyLane incorporato con Hybrid Jobs. ## Aggiungi il gradiente con i simulatori Amazon PennyLane Braket Con il PennyLane plug-in per Amazon Braket, puoi calcolare i gradienti utilizzando il metodo di differenziazione adjoint quando esegui sul simulatore vettoriale statale locale o. SV1 **Nota:** **per utilizzare il metodo di differenziazione aggiuntiva, devi specificare nel tuo, e non. `diff_method='device'` `qnode`** `diff_method='adjoint'` Guarda l'esempio seguente. ``` device_arn = "arn:aws:braket:::device/quantum-simulator/amazon/sv1" dev = qml.device("braket.aws.qubit", wires=wires, shots=0, device_arn=device_arn) @qml.qnode(dev, diff_method="device") def cost_function(params): circuit(params) return qml.expval(cost_h) gradient = qml.grad(circuit) initial_gradient = gradient(params0) ``` **Nota** Attualmente, PennyLane calcolerà gli indici di raggruppamento per gli hamiltoniani di QAOA e li utilizzerà per dividere l'hamiltoniano in più valori di aspettativa. Se desideri utilizzare la funzionalità di differenziazione aggiuntiva SV1 di QAOA da cui esegui QAOA, dovrai ricostruire il costo hamiltoniano rimuovendo gli indici di raggruppamentoPennyLane, in questo modo: `cost_h, mixer_h = qml.qaoa.max_clique(g, constrained=False) cost_h = qml.Hamiltonian(cost_h.coeffs, cost_h.ops)` # PennyLane Utilizzo di Hybrid Jobs ed esecuzione di un algoritmo QAOA In questa sezione, userai ciò che hai imparato per scrivere un vero programma ibrido utilizzando PennyLane la compilazione parametrica. Lo script dell'algoritmo viene utilizzato per risolvere un problema relativo al Quantum Approximate Optimization Algorithm (QAOA). Il programma crea una funzione di costo corrispondente a un classico problema di ottimizzazione Max Cut, specifica un circuito quantistico parametrizzato e utilizza un metodo di discesa del gradiente per ottimizzare i parametri in modo da ridurre al minimo la funzione di costo. In questo esempio, generiamo il grafico del problema nello script dell'algoritmo per semplicità, ma per i casi d'uso più tipici la migliore pratica consiste nel fornire le specifiche del problema attraverso un canale dedicato nella configurazione dei dati di input. L'`parametrize_differentiable`impostazione predefinita del flag consente di `True` ottenere automaticamente i vantaggi di prestazioni di runtime migliorate grazie alla compilazione parametrica su Support. QPUs ``` import os import json import time from braket.jobs import save_job_result from braket.jobs.metrics import log_metric import networkx as nx import pennylane as qml from pennylane import numpy as np from matplotlib import pyplot as plt def init_pl_device(device_arn, num_nodes, shots, max_parallel): return qml.device( "braket.aws.qubit", device_arn=device_arn, wires=num_nodes, shots=shots, # Set s3_destination_folder=None to output task results to a default folder s3_destination_folder=None, parallel=True, max_parallel=max_parallel, parametrize_differentiable=True, # This flag is True by default. ) def start_here(): input_dir = os.environ["AMZN_BRAKET_INPUT_DIR"] output_dir = os.environ["AMZN_BRAKET_JOB_RESULTS_DIR"] job_name = os.environ["AMZN_BRAKET_JOB_NAME"] checkpoint_dir = os.environ["AMZN_BRAKET_CHECKPOINT_DIR"] hp_file = os.environ["AMZN_BRAKET_HP_FILE"] device_arn = os.environ["AMZN_BRAKET_DEVICE_ARN"] # Read the hyperparameters with open(hp_file, "r") as f: hyperparams = json.load(f) p = int(hyperparams["p"]) seed = int(hyperparams["seed"]) max_parallel = int(hyperparams["max_parallel"]) num_iterations = int(hyperparams["num_iterations"]) stepsize = float(hyperparams["stepsize"]) shots = int(hyperparams["shots"]) # Generate random graph num_nodes = 6 num_edges = 8 graph_seed = 1967 g = nx.gnm_random_graph(num_nodes, num_edges, seed=graph_seed) # Output figure to file positions = nx.spring_layout(g, seed=seed) nx.draw(g, with_labels=True, pos=positions, node_size=600) plt.savefig(f"{output_dir}/graph.png") # Set up the QAOA problem cost_h, mixer_h = qml.qaoa.maxcut(g) def qaoa_layer(gamma, alpha): qml.qaoa.cost_layer(gamma, cost_h) qml.qaoa.mixer_layer(alpha, mixer_h) def circuit(params, **kwargs): for i in range(num_nodes): qml.Hadamard(wires=i) qml.layer(qaoa_layer, p, params[0], params[1]) dev = init_pl_device(device_arn, num_nodes, shots, max_parallel) np.random.seed(seed) cost_function = qml.ExpvalCost(circuit, cost_h, dev, optimize=True) params = 0.01 * np.random.uniform(size=[2, p]) optimizer = qml.GradientDescentOptimizer(stepsize=stepsize) print("Optimization start") for iteration in range(num_iterations): t0 = time.time() # Evaluates the cost, then does a gradient step to new params params, cost_before = optimizer.step_and_cost(cost_function, params) # Convert cost_before to a float so it's easier to handle cost_before = float(cost_before) t1 = time.time() if iteration == 0: print("Initial cost:", cost_before) else: print(f"Cost at step {iteration}:", cost_before) # Log the current loss as a metric log_metric( metric_name="Cost", value=cost_before, iteration_number=iteration, ) print(f"Completed iteration {iteration + 1}") print(f"Time to complete iteration: {t1 - t0} seconds") final_cost = float(cost_function(params)) log_metric( metric_name="Cost", value=final_cost, iteration_number=num_iterations, ) # We're done with the hybrid job, so save the result. # This will be returned in job.result() save_job_result({"params": params.numpy().tolist(), "cost": final_cost}) ``` **Nota** La compilazione parametrica è supportata su tutti i formati superconduttori basati su gate QPUs , ad eccezione dei programmi a livello di impulsi. Rigetti Computing # Esegui carichi di lavoro ibridi con simulatori integrati PennyLane Vediamo come utilizzare i simulatori integrati di Amazon Braket Hybrid Jobs per eseguire carichi di lavoro ibridi. PennyLane [Il simulatore integrato basato su GPU di Pennylane utilizza la libreria Nvidia CuQuantum per accelerare `lightning.gpu` le simulazioni di circuiti.](https://developer.nvidia.com/cuquantum-sdk) [Il simulatore GPU integrato è preconfigurato in tutti i contenitori di lavoro Braket che gli utenti possono utilizzare immediatamente.](https://github.com/amazon-braket/amazon-braket-containers) In questa pagina, ti mostriamo come utilizzarlo per velocizzare i carichi `lightning.gpu` di lavoro ibridi. ## Utilizzo `lightning.gpu` per carichi di lavoro QAOA [Considerate gli esempi di Quantum Approximate Optimization Algorithm (QAOA) tratti da questo taccuino.](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs) Per selezionare un simulatore incorporato, si specifica che l'`device`argomento sia una stringa del formato:. `"local:/"` Ad esempio, imposteresti `"local:pennylane/lightning.gpu"` per`lightning.gpu`. La stringa del dispositivo fornita a Hybrid Job all'avvio viene passata al lavoro come variabile di ambiente`"AMZN_BRAKET_DEVICE_ARN"`. ``` device_string = os.environ["AMZN_BRAKET_DEVICE_ARN"] prefix, device_name = device_string.split("/") device = qml.device(simulator_name, wires=n_wires) ``` In questa pagina, confronta i due simulatori vettoriali di PennyLane stato incorporati `lightning.qubit` (basati su CPU) e `lightning.gpu` (basati su GPU). Fornisci ai simulatori scomposizioni di gate personalizzate per calcolare vari gradienti. Ora sei pronto per preparare lo script ibrido di avvio del lavoro. Esegui l'algoritmo QAOA utilizzando due tipi di istanza: e. `ml.m5.2xlarge` `ml.g4dn.xlarge` Il tipo di `ml.m5.2xlarge` istanza è paragonabile a un laptop standard per sviluppatori. `ml.g4dn.xlarge`Si tratta di un'istanza di elaborazione accelerata con una singola GPU NVIDIA T4 con 16 GB di memoria. Per eseguire la GPU, dobbiamo prima specificare un'immagine compatibile e l'istanza corretta (che per impostazione predefinita è un'istanza). `ml.m5.2xlarge` ``` from braket.aws import AwsSession from braket.jobs.image_uris import Framework, retrieve_image image_uri = retrieve_image(Framework.PL_PYTORCH, AwsSession().region) instance_config = InstanceConfig(instanceType="ml.g4dn.xlarge") ``` Dobbiamo quindi inserirli nell'hybrid job decorator, insieme ai parametri del dispositivo aggiornati sia nel sistema che negli argomenti del lavoro ibrido. ``` @hybrid_job( device="local:pennylane/lightning.gpu", input_data=input_file_path, image_uri=image_uri, instance_config=instance_config) def run_qaoa_hybrid_job_gpu(p=1, steps=10): params = np.random.rand(2, p) braket_task_tracker = Tracker() graph = nx.read_adjlist(input_file_path, nodetype=int) wires = list(graph.nodes) cost_h, _mixer_h = qaoa.maxcut(graph) device_string = os.environ["AMZN_BRAKET_DEVICE_ARN"] prefix, device_name = device_string.split("/") dev= qml.device(simulator_name, wires=len(wires)) ... ``` **Nota** Se si specifica l'`instance_config`as utilizzando un'istanza basata su GPU, ma si sceglie come simulatore basato su CPU incorporato (`lightning.qubit`), la GPU non verrà utilizzata. `device` Assicurati di utilizzare il simulatore integrato basato su GPU se desideri utilizzare come target la GPU\$1 Il tempo medio di iterazione per l'`m5.2xlarge`istanza è di circa 73 secondi, mentre per l'`ml.g4dn.xlarge`istanza è di circa 0,6 secondi. Per questo flusso di lavoro da 21 qubit, l'istanza GPU ci offre una velocità di 100 volte superiore. Se guardi la [pagina dei prezzi](https://aws.amazon.com/braket/pricing/) di Amazon Braket Hybrid Jobs, puoi vedere che il costo al minuto per un'`m5.2xlarge`istanza è di 0,00768 USD, mentre per l'`ml.g4dn.xlarge`istanza è di 0,01227 USD. In questo caso è più veloce ed economico eseguire l'istanza GPU. ## Apprendimento automatico quantistico e parallelismo dei dati Se il tuo tipo di carico di lavoro è l'apprendimento automatico quantistico (QML) che si addestra su set di dati, puoi accelerare ulteriormente il carico di lavoro utilizzando il parallelismo dei dati. In QML, il modello contiene uno o più circuiti quantistici. Il modello può contenere o meno anche reti neurali classiche. Quando si addestra il modello con il set di dati, i parametri del modello vengono aggiornati per ridurre al minimo la funzione di perdita. Di solito viene definita una funzione di perdita per un singolo punto dati e la perdita totale per la perdita media sull'intero set di dati. In QML, le perdite vengono generalmente calcolate in serie prima di calcolare la media della perdita totale per i calcoli a gradiente. Questa procedura richiede molto tempo, soprattutto quando ci sono centinaia di punti dati. Poiché la perdita da un punto dati non dipende da altri punti dati, le perdite possono essere valutate in parallelo\$1 Le perdite e i gradienti associati a diversi punti dati possono essere valutati contemporaneamente. Questo è noto come parallelismo dei dati. Con SageMaker la libreria parallela di dati distribuiti, Amazon Braket Hybrid Jobs semplifica l'utilizzo del parallelismo dei dati per accelerare la formazione. Considera il seguente carico di lavoro QML per il parallelismo dei dati, che utilizza il [set di dati Sonar del noto repository](https://archive.ics.uci.edu/dataset/151/connectionist+bench+sonar+mines+vs+rocks) UCI come esempio di classificazione binaria. Il set di dati Sonar ha 208 punti dati ciascuno con 60 caratteristiche raccolte dai segnali sonar che rimbalzano sui materiali. Ogni punto dati è etichettato come «M» per le miniere o «R» per le rocce. Il nostro modello QML è costituito da un livello di input, un circuito quantistico come livello nascosto e un livello di output. I livelli di input e output sono reti neurali classiche implementate in. PyTorch Il circuito quantistico è integrato con le reti PyTorch neurali utilizzando il modulo qml.qnn. PennyLane Consulta i nostri taccuini di [esempio](https://github.com/aws/amazon-braket-examples) per maggiori dettagli sul carico di lavoro. Come nell'esempio QAOA riportato sopra, puoi sfruttare la potenza della GPU utilizzando simulatori integrati basati su GPU come quelli per migliorare le prestazioni rispetto ai simulatori integrati basati su CPU. PennyLane `lightning.gpu` Per creare un lavoro ibrido, puoi chiamare `AwsQuantumJob.create` e specificare lo script dell'algoritmo, il dispositivo e altre configurazioni tramite gli argomenti delle parole chiave. ``` instance_config = InstanceConfig(instanceType='ml.g4dn.xlarge') hyperparameters={"nwires": "10", "ndata": "32", ... } job = AwsQuantumJob.create( device="local:pennylane/lightning.gpu", source_module="qml_source", entry_point="qml_source.train_single", hyperparameters=hyperparameters, instance_config=instance_config, ... ) ``` Per utilizzare il parallelismo dei dati, è necessario modificare alcune righe di codice nello script dell'algoritmo per la libreria SageMaker distribuita per parallelizzare correttamente l'addestramento. Innanzitutto, importate il `smdistributed` pacchetto che svolge la maggior parte del lavoro necessario per distribuire i carichi di lavoro su più e più istanze. GPUs Questo pacchetto è preconfigurato nel Braket e nei contenitori. PyTorch TensorFlow Il `dist` modulo indica al nostro script di algoritmo qual è il numero totale di elementi GPUs per il training (`world_size`) `rank` e la fine `local_rank` di un core della GPU. `rank`è l'indice assoluto di una GPU in tutte le istanze, mentre `local_rank` è l'indice di una GPU all'interno di un'istanza. Ad esempio, se ci sono quattro istanze ciascuna di cui otto GPUs allocate per l'addestramento, i `rank` valori vanno da 0 a 31 e quelli da 0 a 7`local_rank`. ``` import smdistributed.dataparallel.torch.distributed as dist dp_info = { "world_size": dist.get_world_size(), "rank": dist.get_rank(), "local_rank": dist.get_local_rank(), } batch_size //= dp_info["world_size"] // 8 batch_size = max(batch_size, 1) ``` Successivamente, si definisce un `DistributedSampler` in base a `world_size` `rank` e quindi lo si passa nel caricatore di dati. Questo campionatore evita di GPUs accedere alla stessa porzione di un set di dati. ``` train_sampler = torch.utils.data.distributed.DistributedSampler( train_dataset, num_replicas=dp_info["world_size"], rank=dp_info["rank"] ) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=batch_size, shuffle=False, num_workers=0, pin_memory=True, sampler=train_sampler, ) ``` Successivamente, si utilizza la `DistributedDataParallel` classe per abilitare il parallelismo dei dati. ``` from smdistributed.dataparallel.torch.parallel.distributed import DistributedDataParallel as DDP model = DressedQNN(qc_dev).to(device) model = DDP(model) torch.cuda.set_device(dp_info["local_rank"]) model.cuda(dp_info["local_rank"]) ``` Quanto sopra sono le modifiche necessarie per utilizzare il parallelismo dei dati. In QML, spesso si desidera salvare i risultati e stampare i progressi della formazione. Se ogni GPU esegue il comando di salvataggio e stampa, il registro verrà invaso dalle informazioni ripetute e i risultati si sovrascriveranno a vicenda. Per evitare ciò, è possibile salvare e stampare solo dalla GPU con 0. `rank` ``` if dp_info["rank"]==0: print('elapsed time: ', elapsed) torch.save(model.state_dict(), f"{output_dir}/test_local.pt") save_job_result({"last loss": loss_before}) ``` Amazon Braket Hybrid Jobs supporta i tipi di `ml.g4dn.12xlarge` istanza per la libreria parallela di SageMaker dati distribuiti. Puoi configurare il tipo di istanza tramite l'`InstanceConfig`argomento in Hybrid Jobs. Affinché la libreria parallela di dati SageMaker distribuiti sappia che il parallelismo dei dati è abilitato, devi aggiungere due iperparametri aggiuntivi, `"sagemaker_distributed_dataparallel_enabled"` impostandoli `"true"` e `"sagemaker_instance_type"` impostandoli sul tipo di istanza che stai utilizzando. Questi due iperparametri vengono utilizzati per pacchetto. `smdistributed` Lo script dell'algoritmo non deve utilizzarli in modo esplicito. In Amazon Braket SDK, fornisce un comodo argomento per le parole chiave. `distribution` Per quanto `distribution="data_parallel"` riguarda la creazione di posti di lavoro ibridi, l'SDK Amazon Braket inserisce automaticamente i due iperparametri per te. Se utilizzi l'API Amazon Braket, devi includere questi due iperparametri. Con il parallelismo di istanze e dati configurato, ora puoi inviare il tuo lavoro ibrido. Ce ne sono 4 GPUs in un'`ml.g4dn.12xlarge`istanza. Quando si imposta`instanceCount=1`, il carico di lavoro viene distribuito tra gli 8 membri GPUs dell'istanza. Se ne imposti `instanceCount` più di uno, il carico di lavoro viene distribuito tra quelli GPUs disponibili in tutte le istanze. Quando si utilizzano più istanze, ogni istanza comporta un addebito in base al tempo di utilizzo. Ad esempio, quando utilizzi quattro istanze, il tempo fatturabile è quattro volte il tempo di esecuzione per istanza perché ci sono quattro istanze che eseguono i tuoi carichi di lavoro contemporaneamente. ``` instance_config = InstanceConfig(instanceType='ml.g4dn.12xlarge', instanceCount=1, ) hyperparameters={"nwires": "10", "ndata": "32", ..., } job = AwsQuantumJob.create( device="local:pennylane/lightning.gpu", source_module="qml_source", entry_point="qml_source.train_dp", hyperparameters=hyperparameters, instance_config=instance_config, distribution="data_parallel", ... ) ``` **Nota** Nella creazione di posti di lavoro ibridi di cui sopra, `train_dp.py` si tratta dello script algoritmico modificato per l'utilizzo del parallelismo dei dati. Tieni presente che il parallelismo dei dati funziona correttamente solo quando modifichi lo script dell'algoritmo in base alla sezione precedente. Se l'opzione di parallelismo dei dati è abilitata senza uno script di algoritmo modificato correttamente, il processo ibrido può generare errori o ogni GPU può elaborare ripetutamente la stessa porzione di dati, il che è inefficiente. Se usato correttamente, l'utilizzo di più istanze può portare a una riduzione di ordini di grandezza in termini di tempi e costi. Vedi il [taccuino di esempio per maggiori dettagli](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb). # Utilizzo di CUDA-Q con Amazon Braket NVIDIA's CUDA-Qè una libreria software progettata per la programmazione di algoritmi quantistici ibridi che combinano CPUs unità di elaborazione quantistiche e quantistiche (). GPUs QPUs Fornisce un modello di programmazione unificato, che consente agli sviluppatori di esprimere istruzioni classiche e quantistiche all'interno di un unico programma, semplificando i flussi di lavoro. CUDA-Qaccelera la simulazione e il runtime quantistici dei programmi grazie ai simulatori di CPU e GPU integrati. CUDA-Qè disponibile con le istanze native per notebook Braket (NBIs) e Amazon Braket Hybrid Jobs. **Topics** + [CUDA-Q in NBIs](#braket-cuda-q-nbis) + [CUDA-Q nei lavori ibridi](#braket-cuda-q-hybrid-jobs) ## CUDA-Q in NBIs CUDA-Qè installato per impostazione predefinita nell'ambiente Braket NBI. È possibile aprire un notebook di CUDA-Q esempio accedendo alla pagina di avvio di Jupyter e selezionando il riquadro and Braket. CUDA-Q Questo apre il taccuino `0_Getting_started_with_CUDA-Q.ipynb` di esempio nella finestra principale. Per altri CUDA-Q esempi, consultate il pannello a sinistra nella `nvidia_cuda_q/` directory. Puoi anche verificare la versione CUDA-Q o qualsiasi altro pacchetto di terze parti installato nel tuo NBI. Ad esempio, è possibile eseguire il comando seguente in una cella di codice di un notebook per verificare le versioni dei CUDA-Q pacchetti Qiskit e Braket installate nell'ambiente. PennyLane ``` %pip freeze | grep -i -e cudaq -e qiskit -e pennylane -e braket ``` ## CUDA-Q nei lavori ibridi L'utilizzo CUDA-Q su [Amazon Braket Hybrid Jobs](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html) offre un ambiente di elaborazione flessibile e on-demand. Le istanze computazionali vengono eseguite solo per la durata del carico di lavoro, assicurandoti di pagare solo per ciò che usi. Amazon Braket Hybrid Jobs offre anche un'esperienza scalabile. Gli utenti possono iniziare con istanze più piccole per la prototipazione e il test, quindi passare a istanze più grandi in grado di gestire carichi di lavoro maggiori per esperimenti completi. Il supporto di Amazon Braket Hybrid Jobs GPUs è essenziale per massimizzare CUDA-Q il potenziale di Amazon Braket. GPUs velocizza notevolmente le simulazioni di programmi quantistici rispetto ai simulatori basati su CPU, specialmente quando si lavora con circuiti ad alto numero di qubit. La parallelizzazione diventa semplice quando viene utilizzata su Amazon CUDA-Q Braket Hybrid Jobs. Hybrid Jobs semplifica la distribuzione del campionamento dei circuiti e delle valutazioni osservabili su più nodi computazionali. Questa perfetta parallelizzazione dei carichi di lavoro consente agli utenti di concentrarsi maggiormente sullo sviluppo dei propri CUDA-Q carichi di lavoro piuttosto che sulla creazione di infrastrutture per esperimenti su larga scala. Per iniziare, consulta l'[esempio CUDA-Q iniziale](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/0_Getting_started_with_CUDA-Q.ipynb) su Amazon Braket examples Github per utilizzare CUDA-Q un contenitore di lavori ibrido fornito da Braket. Il seguente frammento di codice è un `hello-world` esempio di esecuzione di un CUDA-Q programma con Amazon Braket Hybrid Jobs. ``` image_uri = retrieve_image(Framework.CUDAQ, AwsSession().region) @hybrid_job(device='local:nvidia/qpp-cpu', image_uri=image_uri) def hello_quantum(): import cudaq # define the backend device=get_job_device_arn() cudaq.set_target(device.split('/')[-1]) # define the Bell circuit kernel = cudaq.make_kernel() qubits = kernel.qalloc(2) kernel.h(qubits[0]) kernel.cx(qubits[0], qubits[1]) # sample the Bell circuit result = cudaq.sample(kernel, shots_count=1000) measurement_probabilities = dict(result.items()) return measurement_probabilities ``` L'esempio precedente simula un circuito Bell su un simulatore di CPU. Questo esempio viene eseguito localmente sul laptop o sul notebook Braket Jupyter. A causa dell'`local=True`impostazione, quando si esegue questo script, nell'ambiente locale verrà avviato un contenitore per eseguire il CUDA-Q programma per il test e il debug. Dopo aver terminato il test, puoi rimuovere il `local=True` flag ed eseguire il job su. AWS Per ulteriori informazioni, consulta [Lavorare con Amazon Braket Hybrid](braket-jobs.md) Jobs. Se i tuoi carichi di lavoro hanno un numero elevato di qubit, un gran numero di circuiti o un gran numero di iterazioni, puoi utilizzare risorse di elaborazione della CPU più potenti specificando l'impostazione. `instance_config` Il seguente frammento di codice mostra come configurare l'impostazione nel decoratore. `instance_config` `hybrid_job` Per ulteriori informazioni sui tipi di istanze supportati, consulta [Configurare l'istanza di job ibrida](braket-jobs-configure-job-instance-for-script.md). Per un elenco dei tipi di istanze, consulta Tipi di [istanze Amazon EC2](https://aws.amazon.com/ec2/instance-types/). ``` @hybrid_job( device="local:nvidia/qpp-cpu", image_uri=image_uri, instance_config=InstanceConfig(instanceType="ml.c5.2xlarge"), ) def my_job_script(): ... ``` Per carichi di lavoro più impegnativi, puoi eseguire i carichi di lavoro su un CUDA-Q simulatore GPU. Per abilitare un simulatore GPU, usa il nome del backend. `nvidia` Il `nvidia` backend funziona come un simulatore di GPU. CUDA-Q Quindi, seleziona un tipo di istanza Amazon EC2 che supporti una NVIDIA GPU. Il seguente frammento di codice mostra il decoratore configurato dalla GPU. `hybrid_job` ``` @hybrid_job( device="local:nvidia/nvidia", image_uri=image_uri, instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"), ) def my_job_script(): ... ``` Amazon Braket Hybrid Jobs e supporta simulazioni GPU NBIs parallele con. CUDA-Q Puoi parallelizzare la valutazione di più osservabili o più circuiti per aumentare le prestazioni del tuo carico di lavoro. Per parallelizzare più osservabili, apporta le seguenti modifiche allo script dell'algoritmo. Imposta l'`mgpu`opzione del backend. `nvidia` Ciò è necessario per parallelizzare gli osservabili. La parallelizzazione utilizza MPI per la comunicazione tra di loro GPUs, quindi MPI deve essere inizializzato prima dell'esecuzione e finalizzato dopo. Quindi, specifica la modalità di esecuzione impostando. `execution=cudaq.parallel.mpi` Il seguente frammento di codice mostra queste modifiche. ``` cudaq.set_target("nvidia", option="mqpu") cudaq.mpi.initialize() result = cudaq.observe( kernel, hamiltonian, shots_count=n_shots, execution=cudaq.parallel.mpi ) cudaq.mpi.finalize() ``` Nel `hybrid_job` decoratore, specifica un tipo di istanza che ne ospita più di uno, GPUs come mostrato nel seguente frammento di codice. ``` @hybrid_job( device="local:nvidia/nvidia-mqpu", instance_config=InstanceConfig(instanceType="ml.g4dn.12xlarge", instanceCount=1), image_uri=image_uri, ) def parallel_observables_gpu_job(sagemaker_mpi_enabled=True): ... ``` Il [notebook di simulazioni parallele](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/5_Multiple_GPU_simulations.ipynb) negli esempi di Amazon Braket Github end-to-end fornisce esempi che dimostrano come eseguire simulazioni di programmi quantistici su backend di GPU ed eseguire simulazioni parallele di osservabili e batch di circuiti. ### Esecuzione dei carichi di lavoro su computer quantistici Dopo aver completato i test con il simulatore, puoi passare all'esecuzione di esperimenti su. QPUs Basta passare il target a una QPU Amazon Braket, ad esempio IQMIonQ, o dispositivi. Rigetti Il seguente frammento di codice illustra come impostare la destinazione sul dispositivo. IQM Garnet Per un elenco di quelli disponibili QPUs, consulta la [console Amazon Braket.](https://console.aws.amazon.com/braket/home) ``` device_arn = "arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet" cudaq.set_target("braket", machine=device_arn) ``` Per ulteriori informazioni su Hybrid Jobs, consulta [Working with Amazon Braket Hybrid Jobs](braket-jobs.md) nella guida per sviluppatori. Per ulteriori informazioni su CUDA-Q, consulta la [documentazione su NVIDIA CUDA-Q](https://nvidia.github.io/cuda-quantum/latest/index.html).