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à. # 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.