Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Esegui il codice locale come job 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 alla Amazon Braket Quantum Processing Unit (QPU). Le attività quantistiche create in un job ibrido hanno la priorità di accodamento 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, assicurando che possa essere eseguito un solo lavoro ibrido alla volta.

Crea un job ibrido a partire 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 di Amazon Elastic Container Registry (ECR).

È 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. Crea un lavoro ibrido 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}

Si crea il job ibrido invocando la funzione come si farebbe 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 job 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

Iperparametri

La run_hybrid_job() funzione utilizza l'argomento num_tasks per controllare il numero di attività quantistiche create. Il job ibrido lo acquisisce automaticamente come iperparametro. Utilizzo degli iperparametri

Metriche e registrazione

All'interno della run_hybrid_job() funzione, le metriche degli algoritmi iterativi vengono registrate con. log_metrics Le metriche vengono tracciate automaticamente nella pagina della console Braket nella scheda Hybrid Job. 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. Monitoraggio e risparmio dei costi L'esempio precedente utilizza il nome della metrica «probabilità» che registra la prima probabilità del tipo di risultato. Elenco dei tipi di risultati

Recupero dei risultati

Una volta completato il job ibrido, viene utilizzato job.result() per recuperare i risultati dei job ibridi. Tutti gli oggetti nella dichiarazione di ritorno 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 fallimentare.

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 job 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

Crea ed esegui il debug di un job ibrido in modalità localeI lavori locali 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 hanno una coda prioritaria per le attività quantistiche. Per casi avanzati, ad esempio multinodo o MPI, i job locali possono avere accesso alle variabili di ambiente Braket richieste. Il codice seguente crea un job 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 ibrido. Per un elenco di opzioni, consulta il modulo braket.jobs.quantum_job_creation.

Installa pacchetti Python aggiuntivi e codice sorgente

Puoi personalizzare il tuo ambiente di runtime per utilizzare i tuoi pacchetti Python preferiti. Puoi usare un requirements.txt file, un elenco di nomi di pacchetti o portare il tuo contenitore (BYOC). 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 job ibrido, puoi fornire un set di dati di formazione 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://<default_bucket_name>/jobs/<job_name>/<timestamp>/data/<channel_name> Se si specifica un percorso locale, il nome predefinito del canale è «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 degli URI S3 o dei percorsi 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")

Salvataggio dei risultati in 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 di Braket.

Salvare e riprendere dai checkpoint

Per i 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 di supporto. get_job_results_dir()

Di seguito è riportato un esempio di funzionamento minimo per il salvataggio e il caricamento dei 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 lavoro ibrido, save_job_checkpoint() viene richiamato con un dizionario contenente i dati che vogliamo salvare. Per impostazione predefinita, ogni valore deve essere serializzabile come testo. Per indicare 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 lavoro ibrido <jobname>.json in una sottocartella chiamata «checkpoints».

Per creare un nuovo job ibrido per continuare dal checkpoint, dobbiamo passare copy_checkpoints_from_job=job_arn dove si job_arn trova l'ARN del job ibrido del job precedente. Quindi utilizziamo il load_job_checkpoint(job_name) caricamento dal checkpoint.

Le migliori pratiche per i decoratori di lavori ibridi

Abbraccia l'asincronicità

I lavori ibridi creati con l'annotazione decorator sono asincroni: vengono eseguiti quando sono disponibili le risorse classiche e quantistiche. Puoi monitorare lo stato di avanzamento dell'algoritmo utilizzando o Amazon. Braket Management Console CloudWatch Quando invii l'algoritmo per l'esecuzione, Braket esegue l'algoritmo in un ambiente containerizzato scalabile e i risultati vengono recuperati quando l'algoritmo è completo.

Esegui algoritmi variazionali iterativi

Hybrid jobs offre gli strumenti per eseguire algoritmi iterativi quantistici classici. Per problemi puramente quantistici, utilizza attività quantistiche o una serie di attività quantistiche. Esecuzione di più programmi L'accesso prioritario a determinate QPU è particolarmente utile per gli algoritmi variazionali a lunga durata che richiedono più chiamate iterative alle QPU con elaborazione classica intermedia.

Effettua il debug utilizzando la modalità locale

Prima di eseguire un processo ibrido su una QPU, si consiglia di eseguire prima il simulatore SV1 per confermare che funzioni come previsto. Per i test su piccola scala, è possibile eseguirli in modalità locale per iterazioni e debug rapidi.

Migliora la riproducibilità con Bring your own container (BYOC)

Crea un esperimento riproducibile incapsulando il tuo software e le sue dipendenze in un ambiente containerizzato. Raggruppando tutto il codice, le dipendenze e le impostazioni in un contenitore, si evitano potenziali conflitti e problemi di controllo delle versioni.

Multi-instance simulatori distribuiti

Per eseguire un numero elevato di circuiti, è consigliabile utilizzare il supporto MPI integrato per eseguire simulatori locali su più istanze all'interno di un singolo job ibrido. Per ulteriori informazioni, consulta Simulatori integrati. Esegui PennyLane carichi di lavoro ibridi con simulatori integrati

Usa circuiti parametrici

I circuiti parametrici inviati da un job ibrido vengono compilati automaticamente su determinate QPU utilizzando la compilazione Utilizzo della compilazione parametrica per velocizzare i lavori ibridi parametrica per migliorare i tempi di esecuzione degli algoritmi.

Checkpoint periodicamente

Per i 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 Braket. GitHub