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. # Personalización del trabajo híbrido Amazon Braket ofrece varias formas de personalizar la forma en que se ejecutan sus trabajos híbridos, lo que le permite adaptar el entorno a sus necesidades específicas. En esta sección se exploran las opciones para personalizar los trabajos híbridos, desde definir el entorno del script de algoritmo hasta utilizar su propio contenedor. Aprenderá a optimizar su flujo de trabajo utilizando hiperparámetros, configurar instancias de trabajo y utilizar la compilación paramétrica para mejorar el rendimiento. Estas técnicas de personalización le ayudan a maximizar el potencial de sus cómputos cuánticos híbridos en Amazon Braket. **Topics** + [Definición del entorno para el script de algoritmo](braket-jobs-script-environment.md) + [Uso de hiperparámetros](braket-jobs-hyperparameters.md) + [Configuración de su instancia de trabajo híbrido](braket-jobs-configure-job-instance-for-script.md) + [Uso de la compilación paramétrica para acelerar los trabajos híbridos](braket-jobs-parametric-compilation.md) # Definición del entorno para el script de algoritmo Amazon Braket admite entornos definidos por contenedores para el script de algoritmo: + Un contenedor base (el predeterminado, si no se especifica un `image_uri`) + Un contenedor con CUDA-Q + Un contenedor con Tensorflow y PennyLane + Un contenedor con PyTorch, y PennyLane CUDA-Q En la tabla siguiente, se proporcionan detalles sobre los contenedores y las bibliotecas que incluyen. **Contenedores de Amazon Braket** | Tipo | Base | CUDA-Q | TensorFlow | PyTorch | | --- | --- | --- | --- | --- | | **URI de imagen** | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest amazon-braket-base-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:último amazon-braket-cudaq-jobs | 292282985366.dkr. ecr.us-east-1.amazonaws.com /:último amazon-braket-tensorflow-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:último amazon-braket-pytorch-jobs | | **Bibliotecas heredadas** | | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/braket-jobs-script-environment.html) | | **Bibliotecas adicionales** | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/braket-jobs-script-environment.html) | [Puede ver y acceder a las definiciones de contenedores de código abierto en aws/. amazon-braket-containers](https://github.com/aws/amazon-braket-containers) Elija el contenedor que mejor se adapte a su caso de uso. Puedes usar cualquiera de las AWS regiones disponibles en Braket (us-east-1, us-west-1, us-west-2, eu-north-1, eu-west-2), pero la región contenedora debe coincidir con la región de tu trabajo híbrido. Especifique la imagen del contenedor al crear un trabajo híbrido añadiendo uno de los tres argumentos siguientes a su llamada a `create(…​)` en el script del trabajo híbrido. Puede instalar dependencias adicionales en el contenedor que elija en el tiempo de ejecución (al costo del inicio o el tiempo de ejecución), ya que los contenedores de Amazon Braket tienen conectividad a Internet. En el siguiente ejemplo es para la región us-west-2. + **Imagen** base: amazon-braket-base-jobs image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest» + **Imagen CUDA-Q:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest» amazon-braket-cudaq-jobs + **Imagen de Tensorflow:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest» amazon-braket-tensorflow-jobs + **PyTorch imagen**: image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest» amazon-braket-pytorch-jobs Los `image-uris` también se pueden recuperar usando la función `retrieve_image()` en el SDK de Amazon Braket. El siguiente ejemplo muestra cómo recuperarlos del us-west-2 Región de AWS. ``` 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") ``` # Utilice su propio contenedor (BYOC) Los trabajos híbridos de Amazon Braket proporcionan tres contenedores preconstruidos para ejecutar código en diferentes entornos. Si uno de estos contenedores es compatible con su caso de uso, solo tiene que proporcionar el script de algoritmo cuando cree un trabajo híbrido. Las pequeñas dependencias que falten se pueden añadir desde el script de algoritmo o desde un archivo `requirements.txt` utilizando `pip`. Si ninguno de estos contenedores se adapta a su caso de uso, o si desea ampliarlos, los trabajos híbridos de Braket admiten la ejecución de trabajos híbridos con su propia imagen de contenedor de Docker personalizada, o que utilice su propio contenedor (BYOC). Asegúrese de que sea la característica adecuada para su caso de uso. **Topics** + [¿Cuándo es conveniente utilizar su propio contenedor?](#bring-own-container-decision) + [Fórmula para utilizar su propio contenedor](bring-own-container-recipe.md) + [Ejecución de trabajos híbridos de Braket en su propio contenedor](running-hybrid-jobs-in-own-container.md) ## ¿Cuándo es conveniente utilizar su propio contenedor? Utilizar su propio contenedor (BYOC) en los trabajos híbridos de Braket le ofrece la flexibilidad de utilizar su propio software instalándolo en un entorno empaquetado. Dependiendo de sus necesidades específicas, puede haber formas de lograr la misma flexibilidad sin tener que pasar por todo el ciclo completo de construcción de BYOC Docker, carga en Amazon ECR y URI de imagen personalizada. **nota** BYOC puede no ser la opción adecuada si desea añadir un pequeño número de paquetes de Python adicionales (generalmente menos de 10) que están disponibles públicamente. Por ejemplo, si estás usando. PyPi En este caso, puede utilizar una de las imágenes de Braket preconstruidas y, a continuación, incluir un archivo `requirements.txt` en su directorio de origen al enviar el trabajo. El archivo se lee automáticamente y `pip` instalará los paquetes con las versiones especificadas de forma normal. Si va a instalar una gran cantidad de paquetes, es posible que el tiempo de ejecución de sus trabajos aumente considerablemente. Compruebe la versión de Python y, si corresponde, la de CUDA del contenedor preconstruido que desee utilizar para comprobar si el software funciona. BYOC es necesario cuando desea utilizar un lenguaje que no sea Python (como C\$1\$1 o Rust) para su script de trabajo, o si desea utilizar una versión de Python que no está disponible a través de los contenedores preconstruidos de Braket. También es una buena opción en los siguientes casos: + Está utilizando un software con una clave de licencia y necesita autenticar esa clave en un servidor de licencias para ejecutar el software. Con la opción de BYOC, puede incrustar la clave de licencia en su imagen de Docker e incluir un código para autenticarla. + Está utilizando un software que no es de acceso público. Por ejemplo, el software está alojado en un GitHub repositorio privado GitLab o al que se necesita una clave SSH específica para acceder. + Necesita instalar un gran conjunto de software que no está incluido en los contenedores proporcionados por Braket. BYOC le permitirá eliminar los largos tiempos de inicio de sus contenedores de trabajos híbridos debido a la instalación de software. BYOC también le permite poner su SDK o algoritmo personalizado a disposición de los clientes al crear un contenedor de Docker con su software y ponerlo a disposición de sus usuarios. Puede hacerlo configurando los permisos adecuados en Amazon ECR. **nota** Debe cumplir con todas las licencias de software aplicables. # Fórmula para utilizar su propio contenedor En esta sección, le ofrecemos una step-by-step guía sobre lo que necesita bring your own container (BYOC) para hacer Braket Hybrid Jobs: los scripts, los archivos y los pasos para combinarlos y ponerlos en marcha con sus imágenes personalizadasDocker. Las fórmulas para dos casos comunes: 1. Instale software adicional en una imagen de Docker y utilice únicamente scripts de algoritmo de Python en sus trabajos. 1. Utilice scripts de algoritmo escritos en un lenguaje que no sea Python con los trabajos híbridos o una arquitectura de CPU distinta de x86. Definir el *script de entrada de contenedor* es más complejo en el caso 2. Cuando Braket ejecuta su trabajo híbrido, inicia el número y tipo de instancias de Amazon EC2 solicitados y, a continuación, ejecuta la imagen de Docker especificada por la entrada de URI de imagen en la creación del trabajo. Al utilizar la característica BYOC, debe especificar un URI de imagen alojado en un [repositorio privado de Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) al que tenga acceso de lectura. Los trabajos híbridos de Braket utilizan esa imagen personalizada para ejecutar el trabajo. Los componentes específicos que necesita para crear una imagen de Docker que se pueda utilizar con trabajos híbridos. Si no está familiarizado con la escritura y la creación de `Dockerfiles`, consulte la [documentación de Dockerfile](https://docs.docker.com/reference/dockerfile/) y la [documentación de Amazon ECR CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html). **Topics** + [Una imagen base para su Dockerfile](#base-image-dockerfile) + [(Opcional) Un script de punto de entrada de contenedor modificado](#modified-container-entry-point) + [Instalación del software y el script de contenedor necesarios con `Dockerfile`](#install-docketfile) ## Una imagen base para su Dockerfile Si está utilizando Python y desea instalar software sobre lo que se proporciona en los contenedores proporcionados por Braket, una opción para una imagen base es una de las imágenes del contenedor de Braket, alojada en nuestro [GitHub repositorio](https://github.com/amazon-braket/amazon-braket-containers) y en Amazon ECR. Tendrá que [autenticarse en Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry) para extraer la imagen y construir sobre ella. Por ejemplo, la primera línea del archivo de Docker de BYOC podría ser: `FROM [IMAGE_URI_HERE]` A continuación, rellene el resto del Dockerfile para instalar y configurar el software que desea añadir al contenedor. Las imágenes de Braket preconstruidas ya contienen el script de punto de entrada de contenedor adecuado, por lo que no tiene que preocuparse por incluirlo. Si desea utilizar un lenguaje que no sea Python, como C\$1\$1, Rust o Julia, o si desea crear una imagen para una arquitectura de CPU que no sea x86, como ARM, es posible que tenga que crear una imagen pública básica. Puede encontrar muchas de estas imágenes en la [galería pública de Amazon Elastic Container Registry](https://gallery.ecr.aws/). Asegúrese de elegir una que sea adecuada para la arquitectura de la CPU y, si es necesario, para la GPU que desee utilizar. ## (Opcional) Un script de punto de entrada de contenedor modificado **nota** Si solo va a añadir software adicional a una imagen de Braket preconstruida, puede omitir esta sección. Para ejecutar código que no sea Python como parte de su trabajo híbrido, modifique el script de Python que define el punto de entrada del contenedor. Por ejemplo, el [script de Python `braket_container.py` en el GitHub de Amazon Braket](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py). Este es el script que utilizan las imágenes preconstruidas por Braket para ejecutar el script de algoritmo y establecer las variables de entorno adecuadas. El propio script del punto de entrada del contenedor **debe** estar en Python, pero puede lanzar scripts que no sean de Python. En el ejemplo preconstruido, puede ver que los scripts de algoritmos de Python se lanzan como un [subproceso de Python](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L274) o como un [proceso completamente nuevo](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L257). Al modificar esta lógica, puede habilitar el script de punto de entrada para lanzar scripts de algoritmos que no sean de Python. Por ejemplo, puede modificar la función [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) para lanzar procesos de Rust dependientes del final de la extensión del archivo. También puede elegir escribir un `braket_container.py` completamente nuevo. Debería copiar los datos de entrada, los archivos fuente y otros archivos necesarios de Amazon S3 en el contenedor y definir las variables de entorno adecuadas. ## Instalación del software y el script de contenedor necesarios con `Dockerfile` **nota** Si utiliza una imagen de Braket preconstruida como imagen base de Docker, el script de contenedor ya está presente. Si ha creado un script de contenedor modificado en el paso anterior, deberá copiarlo en el contenedor **y** definir la variable de entorno `SAGEMAKER_PROGRAM` como `braket_container.py`, o como haya llamado al script del nuevo punto de entrada del contenedor. El siguiente es un ejemplo de un `Dockerfile` que le permite usar Julia en instancias de trabajos aceleradas por 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 ``` En este ejemplo, se descargan y ejecutan los scripts proporcionados por AWS para garantizar el cumplimiento de todas las licencias de código abierto pertinentes. Por ejemplo, atribuyendo correctamente cualquier código instalado que se rija por una MIT license. Si necesitas incluir código no público, por ejemplo, código alojado en un repositorio privado GitHub o en un GitLab repositorio, **no** insertes claves SSH en la Docker imagen para acceder a él. En su lugar, utilice Docker Compose en la creación para permitir el acceso de Docker a SSH en la máquina host en la que está integrado. Para obtener más información, consulte la guía [Uso seguro de claves SSH en Docker para acceder a repositorios privados de GitHub](https://www.fastruby.io/blog/docker/docker-ssh-keys.html). **Cómo crear y subir su imagen de Docker** Una vez definido`Dockerfile` correctamente, ya puede seguir los pasos para [crear un repositorio privado de Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html), si aún no existe. También puede crear, etiquetar y cargar su imagen de contenedor en el repositorio. Ya puede crear, etiquetar y enviar la imagen. Consulte la [documentación de compilación de Docker](https://docs.docker.com/reference/cli/docker/buildx/build/) para obtener una explicación completa de las opciones para `docker build` y algunos ejemplos. Para el archivo de muestra definido anteriormente, puede ejecutar lo siguiente: ``` 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 ``` **Asignación de los permisos de Amazon ECR adecuados** Las imágenes de Braket Hybrid Jobs Docker deben estar alojadas en repositorios privados de Amazon ECR. De forma predeterminada, un repositorio privado de Amazon ECR **no** proporciona acceso de lectura al Braket Hybrid Jobs IAM role ni a ningún otro usuario que quiera usar su imagen, como un colaborador o un estudiante. Debe [establecer una política de repositorio](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) para conceder los permisos adecuados. En general, conceda permiso únicamente a los usuarios y roles de IAM específicos a los que quiera que accedan a sus imágenes, en lugar de permitir que cualquier persona con el image URI acceda. # Ejecución de trabajos híbridos de Braket en su propio contenedor Para crear un trabajo híbrido con su propio contenedor, llame a `AwsQuantumJob.create()` con el argumento de `image_uri` especificado. Puede utilizar una QPU, un simulador bajo demanda o ejecutar su código localmente en el procesador clásico disponible con los trabajos híbridos de Braket. Te recomendamos que pruebes tu código en un simulador o TN1 antes de ejecutarlo en una QPU real. SV1 DM1 Para ejecutar el código en el procesador clásico, especifique el `instanceType` y el `instanceCount` que utiliza actualizando la `InstanceConfig`. Tenga en cuenta que si especifica un `instance_count` > 1, debe asegurarse de que el código puede ejecutarse en varios hosts. El límite máximo de instancias que puede elegir es de 5. Por ejemplo: ``` 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** Utilice el ARN del dispositivo para realizar un seguimiento del simulador que utilizó como metadatos del trabajo híbrido. Los valores aceptables deben seguir el formato `device = "local:/"`. Recuerde que `` y `` debe constar únicamente de letras, números, `_`, `-` y `.` El tamaño de la cadena se limita a 256 caracteres. Si planea BYOC y no usa el SDK de Braket para crear tareas cuánticas, debe pasar el valor de la variable de entorno `AMZN_BRAKET_JOB_TOKEN` al parámetro `jobToken` en la solicitud `CreateQuantumTask`. De lo contrario, las tareas cuánticas no tienen prioridad y se consideran tareas cuánticas normales e independientes. # Uso de hiperparámetros Puede definir los hiperparámetros que necesita su algoritmo, como la tasa de aprendizaje o el tamaño del paso, al crear un trabajo híbrido. Los valores de los hiperparámetros se utilizan normalmente para controlar diversos aspectos del algoritmo y, a menudo, pueden ajustarse para optimizar el rendimiento del algoritmo. Para utilizar los hiperparámetros en un trabajo híbrido de Braket, es necesario especificar sus nombres y valores de forma explícita en un diccionario. Especifique los valores de los hiperparámetros que se van a probar al buscar el conjunto de valores óptimo. El primer paso para utilizar los hiperparámetros es configurar y definir los hiperparámetros como un diccionario, como se puede ver en el siguiente código. ``` from braket.devices import Devices device_arn = Devices.Amazon.SV1 hyperparameters = {"shots": 1_000} ``` A continuación, pase los hiperparámetros definidos en el fragmento de código indicado anteriormente para utilizarlos en el algoritmo que elija. Para ejecutar el siguiente ejemplo de código, cree un directorio denominado «src» en la misma ruta que el archivo de hiperparámetros. Dentro del directorio «src», añada los archivos de código 0[\$1Getting\$1started\$1papermill.ipynb](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/0_Getting_started_papermill.ipynb), [notebook\$1runner.py](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py) y [requirements.txt](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/requirements.txt). ``` 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) ``` Para acceder a sus hiperparámetros desde *dentro* de su script de trabajo híbrido, consulte la función `load_jobs_hyperparams()` en el archivo de python [notebook\$1runner.py](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py). Para acceder a los hiperparámetros desde *fuera* de su script de trabajo híbrido, ejecute el siguiente código. ``` 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) ``` Para obtener más información sobre cómo usar los hiperparámetros, consulte los tutoriales de [QAOA con Amazon Braket Hybrid Jobs PennyLane y Quantum Machine [Learning en Amazon Braket](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) 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). # Configuración de su instancia de trabajo híbrido Dependiendo de tu algoritmo, es posible que tengas diferente requisitos. De forma predeterminada, Amazon Braket ejecuta el script de algoritmo en una instancia de `ml.m5.large`. Sin embargo, puede personalizar este tipo de instancia al crear un trabajo híbrido mediante el siguiente argumento de importación y configuración. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"), # Use NVIDIA T4 instance with 4 GPUs. ... ), ``` Si está ejecutando una simulación integrada y ha especificado un dispositivo local en la configuración del dispositivo, también puede solicitar más de una instancia en la `InstanceConfig` especificando el `instanceCount` y configurándolo para que sea mayor que uno. El límite superior es 5. Por ejemplo, puede elegir 3 instancias de la siguiente manera. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge", instanceCount=3), # Use 3 NVIDIA T4 instances ... ), ``` Cuando utilice varias instancias, considere la posibilidad de distribuir su trabajo híbrido mediante la característica de paralelismo de datos. Consulte el siguiente cuaderno de ejemplo para obtener más información sobre cómo ver este ejemplo de [paralelizar el entrenamiento para QML](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb). Las tres tablas siguientes enumeran los tipos de instancias disponibles y las especificaciones para instancias estándar, de alto rendimiento y aceleradas por GPU. **nota** Para ver las cuotas de instancias de cómputo clásicas predeterminadas para trabajos híbridos, consulte la página [Cuotas de Amazon Braket](braket-quotas.md). | Instancia estándar | vCPU | Memoria (GiB) | | --- | --- | --- | | ml.m5.large (predeterminado) | 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 | | Instancias de alto rendimiento | vCPU | 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 | | Instancias aceleradas por GPU | GPUs | vCPU | Memoria (GiB) | Memoria de 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 | Cada instancia usa una configuración predeterminada de almacenamiento de datos (SSD) de 30 GB. Sin embargo, puede ajustar el almacenamiento de la misma manera que configure el `instanceType`. El siguiente ejemplo muestra cómo aumentar el almacenamiento total a 50 GB. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig( instanceType="ml.g4dn.xlarge", volumeSizeInGb=50, ), ... ), ``` ## Configuración de bucket predeterminado en `AwsSession` El uso de su propia instancia de `AwsSession` le proporciona una mayor flexibilidad, como la posibilidad de especificar una ubicación personalizada para su bucket de Amazon S3 predeterminado. De forma predeterminada, un `AwsSession` tiene una ubicación de bucket de Amazon S3 preconfigurada de `"amazon-braket-{id}-{region}"`. Sin embargo, tiene la opción de anular la ubicación de bucket de Amazon S3 predeterminada al crear un `AwsSession`. Los usuarios pueden pasar opcionalmente un objeto de `AwsSession` al método `AwsQuantumJob.create()` proporcionando el parámetro `aws_session` como se muestra en el siguiente ejemplo de código. ``` 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 ) ``` # Uso de la compilación paramétrica para acelerar los trabajos híbridos Amazon Braket admite la compilación paramétrica en algunos casos. QPUs Esto le permite reducir la sobrecarga asociada con el costoso paso de compilación computacional, ya que solo es necesario compilar un circuito una vez y no para cada iteración en su algoritmo híbrido. Esto puede mejorar considerablemente los tiempos de ejecución de los trabajos híbridos, ya que evita la necesidad de recompilar el circuito en cada paso. Simplemente envíe los circuitos parametrizados a uno de nuestros trabajos compatibles QPUs como Braket Hybrid. Para trabajos híbridos de larga duración, Braket utiliza automáticamente los datos de calibración actualizados del proveedor de hardware al compilar su circuito para garantizar resultados de la máxima calidad. Para crear un circuito paramétrico, primero debe proporcionar los parámetros como entradas en el script de algoritmo. En este ejemplo, utilizamos un circuito paramétrico pequeño e ignoramos cualquier procesamiento clásico entre cada iteración. Para las cargas de trabajo típicas, debe enviar muchos circuitos por lotes y realizar el procesamiento clásico, como la actualización de los parámetros en cada iteración. ``` 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.") ``` Puede enviar el script de algoritmo para que se ejecute como un trabajo híbrido con el siguiente script de trabajo. Al ejecutar el trabajo híbrido en una QPU que admite la compilación paramétrica, el circuito se compila solo en la primera ejecución. En las siguientes ejecuciones, el circuito compilado se reutiliza, lo que aumenta el rendimiento en el tiempo de ejecución del trabajo híbrido sin líneas de código adicionales. ``` from braket.aws import AwsQuantumJob job = AwsQuantumJob.create( device=device_arn, source_module="algorithm_script.py", ) ``` **nota** La compilación paramétrica es compatible con todos los sistemas superconductores basados en compuertas, Rigetti Computing con la excepción de los programas QPUs de nivel de pulso.