Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Ejecutar tu código local como un trabajo híbrido

Amazon Braket Hybrid Jobs proporciona una orquestación totalmente gestionada de algoritmos híbridos cuántico-clásicos, que combina los EC2 recursos informáticos de Amazon con el acceso a la unidad de procesamiento cuántico Braket () de Amazon Braket. QPU Las tareas cuánticas creadas en un trabajo híbrido tienen prioridad sobre las tareas cuánticas individuales para que sus algoritmos no se vean interrumpidos por las fluctuaciones de la cola de tareas cuánticas. Cada uno QPU mantiene una cola de trabajos híbridos independiente, lo que garantiza que solo se pueda ejecutar un trabajo híbrido en un momento dado.

Cree un trabajo híbrido a partir del código Python local

Puede ejecutar su código Python local como un Amazon Braket Hybrid Job. Para ello, anote el código con un @hybrid_job decorador, como se muestra en el siguiente ejemplo de código. Para entornos personalizados, puede optar por utilizar un contenedor personalizado de Amazon Elastic Container Registry (ECR).

Puede usar el @hybrid_job decorador para anotar una función. Braket transforma el código del decorador en un script de algoritmo de trabajo híbrido de Braket. A continuación, el trabajo híbrido invoca la función dentro del decorador en una instancia de AmazonEC2. Puede supervisar el progreso del trabajo con job.state() o con la consola Braket. El siguiente ejemplo de código muestra cómo ejecutar una secuencia de cinco estados en el 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}

El trabajo híbrido se crea invocando la función como lo haría con las funciones normales de Python. Sin embargo, la función decoradora devuelve el identificador de trabajo híbrido en lugar del resultado de la función. Para recuperar los resultados una vez que se haya completado, utilicejob.result().

job = run_hybrid_job(num_tasks=1)
result = job.result() 

El argumento device del @hybrid_job decorador especifica el dispositivo al que el trabajo híbrido tiene acceso prioritario; en este caso, el SV1 simulador. Para obtener QPU prioridad, debe asegurarse de que el dispositivo ARN utilizado en la función coincida con el especificado en el decorador. Para mayor comodidad, puede utilizar la función de ayuda get_job_device_arn() para capturar el dispositivo ARN declarado en. @hybrid_job

Hiperparámetros

La run_hybrid_job() función utiliza el argumento num_tasks para controlar el número de tareas cuánticas creadas. El trabajo híbrido lo captura automáticamente como un hiperparámetro.

Métricas y registro

Dentro de la run_hybrid_job() función, se registran las métricas de los algoritmos iterativos. log_metrics Las métricas se grafican automáticamente en la página de la consola de Braket, en la pestaña de tareas híbridas. Puede utilizar las métricas para realizar un seguimiento de los costes de las tareas cuánticas prácticamente en tiempo real durante la ejecución de un trabajo híbrido con el rastreador de costes de Braket. En el ejemplo anterior, se utiliza el nombre de métrica «probabilidad», que registra la primera probabilidad del tipo de resultado.

Recuperando los resultados

Una vez finalizado el trabajo híbrido, se utiliza job.result() para recuperar los resultados del trabajo híbrido. Braket captura automáticamente todos los objetos de la declaración de devolución. Tenga en cuenta que los objetos devueltos por la función deben ser una tupla y cada elemento debe ser serializable. Por ejemplo, el código siguiente muestra un ejemplo que funciona y otro que no funciona.

@hybrid_job(device=Devices.Amazon.SV1)
def passing():
    np_array = np.random.rand(5)
    return np_array  # serializable
    
@hybrid_job(device=Devices.Amazon.SV1)
def failing():
    return MyObject() # not serializable

Nombre del trabajo

De forma predeterminada, el nombre de este trabajo híbrido se deduce del nombre de la función. También puede especificar un nombre personalizado de hasta 50 caracteres. Por ejemplo, en el código siguiente, el nombre del trabajo es "my-job-name».

@hybrid_job(device=Devices.Amazon.SV1, job_name="my-job-name")
def function():
    pass

Modo local

Los trabajos locales se crean añadiendo el argumento local=True al decorador. Esto ejecuta el trabajo híbrido en un entorno contenerizado en su entorno informático local, como un portátil. Los trabajos locales no tienen prioridad en las colas para las tareas cuánticas. En casos avanzados, como los de varios nodos o localesMPI, es posible que los trabajos locales tengan acceso a las variables de entorno Braket requeridas. El siguiente código crea un trabajo híbrido local con el dispositivo como simuladorSV1.

@hybrid_job(device=Devices.Amazon.SV1, local=True)
def run_hybrid_job(num_tasks = 1):
    return ...

Se admiten todas las demás opciones de trabajos híbridos. Para ver una lista de opciones, consulte el módulo braket.jobs.quantum_job_creation.

Instalar paquetes y código fuente de Python adicionales

Puede personalizar su entorno de ejecución para usar sus paquetes de Python preferidos. Puedes usar un requirements.txt archivo, una lista de nombres de paquetes o traer tu propio container (BYOC). Para personalizar un entorno de ejecución mediante un requirements.txt archivo, consulte el siguiente ejemplo de código.

@hybrid_job(device=Devices.Amazon.SV1, dependencies="requirements.txt")
def run_hybrid_job(num_tasks = 1):
    return ...

Por ejemplo, el requirements.txt archivo puede incluir otros paquetes para instalar.

qiskit 
pennylane >= 0.31
mitiq == 0.29

Como alternativa, puede proporcionar los nombres de los paquetes como una lista de Python de la siguiente manera.

@hybrid_job(device=Devices.Amazon.SV1, dependencies=["qiskit", "pennylane>=0.31", "mitiq==0.29"])
def run_hybrid_job(num_tasks = 1):
    return ...

El código fuente adicional se puede especificar como una lista de módulos o como un solo módulo, como en el siguiente ejemplo de código.

@hybrid_job(device=Devices.Amazon.SV1, include_modules=["my_module1", "my_module2"])
def run_hybrid_job(num_tasks = 1):
    return ...

Guarde y cargue datos en una instancia de trabajo híbrida

Especificar los datos de entrenamiento de entrada

Al crear un trabajo híbrido, puede proporcionar una entrada para los conjuntos de datos de entrenamiento especificando un bucket de Amazon Simple Storage Service (Amazon S3). También puede especificar una ruta local y, a continuación, Braket carga automáticamente los datos a Amazon S3 en. s3://<default_bucket_name>/jobs/<job_name>/<timestamp>/data/<channel_name> Si especificas una ruta local, el nombre del canal será «input» por defecto. El siguiente código muestra un archivo numérico de la ruta local. data/file.npy

@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 ...

Para S3, debe usar la función de get_input_data_dir() ayuda.

s3_path = "s3://amazon-braket-us-west-1-961591465522/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")

Puede especificar varias fuentes de datos de entrada proporcionando un diccionario de valores de canal y rutas S3 URIs o locales.

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")

Guardar los resultados en S3

Para guardar los resultados no incluidos en la declaración de devolución de la función decorada, debe añadir el directorio correcto a todas las operaciones de escritura de archivos. En el siguiente ejemplo, se muestra cómo guardar una matriz numérica y una figura de matplotlib.

@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 ...

Todos los resultados se comprimen en un archivo denominado. model.tar.gz Puede descargar los resultados con la función job.result() Python o navegando a la carpeta de resultados desde la página de trabajos híbridos de la consola de administración de Braket.

Guardar y reanudar desde los puntos de control

Para trabajos híbridos de larga duración, se recomienda guardar periódicamente el estado intermedio del algoritmo. Puede utilizar la función de save_job_checkpoint() ayuda integrada o guardar los archivos en la AMZN_BRAKET_JOB_RESULTS_DIR ruta. Esta última opción está disponible con la función auxiliar. get_job_results_dir()

El siguiente es un ejemplo práctico mínimo para guardar y cargar puntos de control con un decorador de trabajos híbrido:

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()

En el primer trabajo híbrido, save_job_checkpoint() se invoca con un diccionario que contiene los datos que queremos guardar. De forma predeterminada, todos los valores deben poder serializarse como texto. Para comprobar objetos de Python más complejos, como matrices numéricas, puede configurar. data_format = PersistedJobDataFormat.PICKLED_V4 Este código crea y sobrescribe un archivo de puntos de control con el nombre predeterminado <jobname>.json en tus artefactos de trabajo híbridos, en una subcarpeta llamada «puntos de control».

Para crear un nuevo trabajo híbrido para continuar desde el punto de control, debemos pasar por copy_checkpoints_from_job=job_arn dónde job_arn está el trabajo híbrido del trabajo ARN anterior. Luego solemos load_job_checkpoint(job_name) cargar desde el punto de control.

Mejores prácticas para decoradores de trabajos híbridos

Adopte la asincronicidad

Los trabajos híbridos creados con la anotación decorator son asíncronos: se ejecutan una vez que están disponibles los recursos clásicos y cuánticos. El progreso del algoritmo se monitorea mediante el Braket Management Console o Amazon CloudWatch. Cuando envías tu algoritmo para su ejecución, Braket lo ejecuta en un entorno contenerizado escalable y los resultados se recuperan cuando el algoritmo está completo.

Ejecuta algoritmos variacionales iterativos

Hybrid Jobs le proporciona las herramientas para ejecutar algoritmos iterativos clásicos cuánticos. Para problemas puramente cuánticos, utilice tareas cuánticas o un lote de tareas cuánticas. El acceso prioritario a ciertas QPUs es más beneficioso para los algoritmos variacionales de larga duración que requieren múltiples llamadas iterativas QPUs con el procesamiento clásico de por medio.

Depure utilizando el modo local

Antes de ejecutar un trabajo híbrido en unQPU, se recomienda ejecutarlo primero en el simulador SV1 para confirmar que se ejecuta según lo esperado. Para pruebas a pequeña escala, puede ejecutarlas en modo local para una iteración y depuración rápidas.

Mejore la reproducibilidad con Bring your own container () BYOC

Cree un experimento reproducible encapsulando su software y sus dependencias en un entorno contenerizado. Al empaquetar todo el código, las dependencias y la configuración en un contenedor, se evitan posibles conflictos y problemas de control de versiones.

Simuladores distribuidos de varias instancias

Para ejecutar una gran cantidad de circuitos, considere la posibilidad de utilizar el MPI soporte integrado para ejecutar simuladores locales en varias instancias dentro de un solo trabajo híbrido. Para obtener más información, consulte simuladores integrados.

Utilice circuitos paramétricos

Los circuitos paramétricos que envíe a partir de un trabajo híbrido se compilan automáticamente en algunos casos QPUs mediante la compilación paramétrica para mejorar los tiempos de ejecución de los algoritmos.

Compruebe periódicamente

Para trabajos híbridos de larga duración, se recomienda guardar periódicamente el estado intermedio del algoritmo.

Para ver más ejemplos, casos de uso y mejores prácticas, consulta los ejemplos de Amazon GitHub Braket.