As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Personalizar seu Hybrid Job O Amazon Braket fornece várias maneiras de personalizar a execução de seus trabalhos híbridos, permitindo que você adapte o ambiente às suas necessidades específicas. Esta seção explora as opções para personalizar trabalhos híbridos, desde a definição do ambiente de script de algoritmo até a criação de seu próprio contêiner. Você aprenderá a otimizar seu fluxo de trabalho usando hiperparâmetros, configurar instâncias de trabalho e aproveitar a compilação paramétrica para melhorar o desempenho. Essas técnicas de personalização ajudam você a maximizar o potencial de suas computações quânticas híbridas no Amazon Braket. **Topics** + [Defina o ambiente para seu script de algoritmo](braket-jobs-script-environment.md) + [Usando hiperparâmetros](braket-jobs-hyperparameters.md) + [Configure sua instância de trabalho híbrida](braket-jobs-configure-job-instance-for-script.md) + [Usar compilação paramétrica para acelerar trabalhos híbridos](braket-jobs-parametric-compilation.md) # Defina o ambiente para seu script de algoritmo O Amazon Braket oferece suporte a ambientes definidos por contêineres para seu script de algoritmo: + Um contêiner base (o padrão, se nenhum `image_uri` for especificado) + Um contêiner com CUDA-Q + Um contêiner com Tensorflow e PennyLane + Um contêiner com PyTorch PennyLane, e CUDA-Q A tabela a seguir fornece detalhes sobre os contêineres e as bibliotecas que eles incluem. **Contêineres Amazon Braket** | Tipo | Base | CUDA-Q | TensorFlow | PyTorch | | --- | --- | --- | --- | --- | | **URI da imagem** | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest amazon-braket-base-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest amazon-braket-cudaq-jobs | 292282985366.dkr. ecr.us-east-1.amazonaws.com /:latest amazon-braket-tensorflow-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest amazon-braket-pytorch-jobs | | **Bibliotecas herdadas** | | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/braket-jobs-script-environment.html) | | **Bibliotecas adicionais** | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/braket-jobs-script-environment.html) | Você pode visualizar e acessar as definições de contêiner de código aberto em [aws/ amazon-braket-containers](https://github.com/aws/amazon-braket-containers). Escolha o contêiner que corresponde ao seu caso de uso. Você pode usar qualquer uma das AWS regiões disponíveis no Braket (us-east-1, us-west-1, us-west-2, eu-north-1, eu-west-2), mas a região do contêiner deve corresponder à região do seu trabalho híbrido. Especifique a imagem do contêiner ao criar um trabalho híbrido adicionando um dos três argumentos a seguir à sua chamada `create(…​)` no script de trabalho híbrido. Você pode instalar dependências adicionais no contêiner escolhido em runtime (ao custo da inicialização ou do runtime) porque os contêineres do Amazon Braket têm conectividade com a internet. O exemplo a seguir refere-se à região us-west-2. + **Imagem base:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest” amazon-braket-base-jobs + **Imagem CUDA-Q:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest” amazon-braket-cudaq-jobs + **Imagem do Tensorflow:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest” amazon-braket-tensorflow-jobs + **PyTorch imagem:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest” amazon-braket-pytorch-jobs A `image-uris` pode ser recuperada usando a função `retrieve_image()` no SDK do Amazon Braket. O exemplo a seguir mostra como recuperá-los do Região da AWS us-west-2. ``` from braket.jobs.image_uris import retrieve_image, Framework image_uri_base = retrieve_image(Framework.BASE, "us-west-2") image_uri_cudaq = retrieve_image(Framework.CUDAQ, "us-west-2") image_uri_tf = retrieve_image(Framework.PL_TENSORFLOW, "us-west-2") image_uri_pytorch = retrieve_image(Framework.PL_PYTORCH, "us-west-2") ``` # Traga seu próprio contêiner (BYOC) O Amazon Braket Hybrid Jobs fornece três contêineres pré-criados para execução de código em ambientes diferentes. Se um desses contêineres oferecer suporte ao seu caso de uso, você só precisará fornecer seu script de algoritmo ao criar um trabalho híbrido. Pequenas dependências ausentes podem ser adicionadas a partir do seu script de algoritmo ou de um arquivo `requirements.txt` usando `pip`. Se nenhum desses contêineres oferecer suporte ao seu caso de uso, ou se você quiser expandi-los, o Braket Hybrid Jobs suporta a execução de trabalhos híbridos com sua própria imagem de Docker contêiner personalizada ou traga seu próprio contêiner (BYOC). Certifique-se que esse é o recurso certo para o seu caso de uso. **Topics** + [Quando trazer meu próprio contêiner é a decisão certa?](#bring-own-container-decision) + [Como trazer seu próprio contêiner](bring-own-container-recipe.md) + [Executando trabalhos híbridos do Braket em seu próprio contêiner](running-hybrid-jobs-in-own-container.md) ## Quando trazer meu próprio contêiner é a decisão certa? Trazer seu próprio contêiner (BYOC) para o Braket Hybrid Jobs oferece a flexibilidade de usar seu próprio software instalando-o em um ambiente empacotado. Dependendo de suas necessidades específicas, pode haver maneiras de obter a mesma flexibilidade sem precisar passar pelo ciclo completo de criação do BYOC Docker - upload do Amazon ECR - URI de imagem personalizada. **nota** O BYOC pode não ser a escolha certa se você quiser adicionar um pequeno número de pacotes Python adicionais (geralmente menos de 10) que estão disponíveis publicamente. Por exemplo, se você estiver usando PyPi. Nesse caso, você pode usar uma das imagens pré-criadas do Braket e, em seguida, incluir um arquivo `requirements.txt` no diretório de origem no envio do trabalho. O arquivo é lido automaticamente e o `pip` instalará os pacotes com as versões especificadas normalmente. Se você estiver instalando um grande número de pacotes, o runtime de seus trabalhos poderá ser substancialmente aumentado. Verifique a versão Python e, se aplicável, CUDA do contêiner pré-construído que você deseja usar para testar se seu software funcionará. O BYOC é necessário quando você deseja usar uma linguagem não Python (como C\$1\$1 ou Rust) para seu script de trabalho ou se quiser usar uma versão em Python não disponível nos contêineres pré-construídos do Braket. Essa também é uma boa escolha se: + Você está usando um software com uma chave de licença e precisa autenticar essa chave em um servidor de licenciamento para executar o software. Com o BYOC, você pode incorporar a chave de licença em sua imagem Docker e incluir um código para autenticá-la. + Você está usando um software que não está disponível ao público. Por exemplo, o software está hospedado em um repositório privado GitLab ou GitHub repositório que você precisa de uma chave SSH específica para acessar. + Você precisa instalar um grande pacote de software que não esteja empacotado nos contêineres fornecidos pelo Braket. O BYOC permitirá que você elimine longos tempos de inicialização de seus contêineres de trabalhos híbridos devido à instalação do software. O BYOC também permite que você disponibilize seu SDK ou algoritmo personalizado aos clientes criando um contêiner Docker com seu software e disponibilizando-o para seus usuários. Você pode fazer isso definindo as permissões apropriadas no Amazon ECR. **nota** Você deve estar em conformidade com todas as licenças de software aplicáveis. # Como trazer seu próprio contêiner Nesta seção, fornecemos um step-by-step guia do que você precisa fazer bring your own container (BYOC) para Braket Hybrid Jobs — os scripts, arquivos e etapas para combiná-los para começar a trabalhar com suas imagens personalizadasDocker. As receitas para dois casos comuns: 1. Instale software adicional em uma imagem Docker e use somente scripts de algoritmo Python em seus trabalhos. 1. Use scripts de algoritmo escritos em uma linguagem não Python com trabalhos híbridos ou uma arquitetura de CPU além de x86. Definir o *script de entrada do contêiner* é mais complexo para o caso 2. Quando o Braket executa seu Hybrid Job, ele inicia o número e o tipo solicitados de instâncias do Amazon EC2 e, em seguida, Docker executa a imagem especificada pela entrada do URI da imagem para a criação do trabalho nelas. Ao usar o recurso BYOC, você especifica um URI de imagem hospedado em um [repositório privado do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) ao qual você tem acesso de leitura. O Braket Hybrid Jobs usa essa imagem personalizada para executar o trabalho. Os componentes específicos necessários para criar uma imagem Docker que possa ser usada com trabalhos híbridos. Se você não estiver familiarizado com escrever e criar`Dockerfiles`, consulte a [documentação do Dockerfile](https://docs.docker.com/reference/dockerfile/) e a [documentação Amazon ECR CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html). **Topics** + [Uma imagem base para seu Dockerfile](#base-image-dockerfile) + [(Opcional) Um script de ponto de entrada de contêiner modificado](#modified-container-entry-point) + [Instale o software e o script de contêiner necessários com `Dockerfile`](#install-docketfile) ## Uma imagem base para seu Dockerfile [Se você estiver usando Python e quiser instalar software além do que é fornecido nos contêineres fornecidos pelo Braket, uma opção para uma imagem base é uma das imagens do contêiner do Braket, hospedada em nosso GitHub repositório e no Amazon ECR.](https://github.com/amazon-braket/amazon-braket-containers) Você precisará se [autenticar no Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry) para extrair a imagem e criar em cima dela. Por exemplo, a primeira linha do seu arquivo Docker BYOC pode ser: `FROM [IMAGE_URI_HERE]` Em seguida, preencha o restante do Dockerfile para instalar e configurar o software que você deseja adicionar ao contêiner. As imagens pré-criadas do Braket já conterão o script de ponto de entrada do contêiner apropriado, então você não precisa se preocupar em incluí-lo. Se você quiser usar uma linguagem não Python, como C\$1\$1, Rust ou Julia, ou se quiser criar uma imagem para uma arquitetura de CPU não x86, como ARM, talvez seja necessário criar com base em uma imagem pública básica. Você pode encontrar muitas dessas imagens na [Galeria Pública do Amazon Elastic Container Registry](https://gallery.ecr.aws/). Certifique-se de escolher uma que seja apropriada para a arquitetura da CPU e, se necessário, para a GPU que você deseja usar. ## (Opcional) Um script de ponto de entrada de contêiner modificado **nota** Se você só estiver adicionando mais software a uma imagem de Braket pré-criada, ignore esta seção. Para executar código não Python como parte de seu trabalho híbrido, modifique o script Python que define o ponto de entrada do contêiner. Por exemplo, o [script `braket_container.py` python no Amazon Braket Github](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py). Esse é o script que as imagens pré-construídas pelo Braket usam para iniciar seu script de algoritmo e definir as variáveis de ambiente apropriadas. O script de ponto de entrada do contêiner em si **deve** estar em Python, mas pode iniciar scripts que não sejam Python. No exemplo pré-construído, você pode ver que os scripts do algoritmo Python são lançados como um [subprocesso do Python](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L274) ou [como um processo totalmente novo.](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L257) Ao modificar essa lógica, você pode habilitar o script de ponto de entrada para iniciar scripts de algoritmo não Python. Por exemplo, você pode modificar a [função `thekick_off_customer_script()`](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L139) para iniciar processos Rust dependendo do final da extensão do arquivo. Você também pode escrever um `braket_container.py` completamente novo. Ele deve copiar dados de entrada, arquivos de origem e outros arquivos necessários do Amazon S3 para o contêiner e definir as variáveis de ambiente apropriadas. ## Instale o software e o script de contêiner necessários com `Dockerfile` **nota** Se você usar uma imagem Braket pré-criada como imagem Docker base, o script do contêiner já estará presente. Se você criou um script de contêiner modificado na etapa anterior, precisará copiá-lo para o contêiner **e** definir a variável de ambiente de `SAGEMAKER_PROGRAM` para `braket_container.py`, ou para o nome que você deu ao seu novo script de ponto de entrada do contêiner. Veja a seguir um exemplo de um `Dockerfile` que permite que você use Julia em instâncias de Jobs 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 ``` Este exemplo baixa e executa scripts fornecidos por AWS para garantir a conformidade com todas as licenças de código aberto relevantes. Por exemplo, atribuindo adequadamente qualquer código instalado governado por um MIT license. Se você precisar incluir código não público, por exemplo, código hospedado em um GitLab repositório GitHub ou privado, **não** incorpore chaves SSH na Docker imagem para acessá-la. Em vez disso, use o Docker Compose ao criar para permitir ao Docker o acesso ao SSH na máquina host em que ele foi criado. Para obter mais informações, consulte o guia [Como usar chaves SSH com segurança no Docker para acessar repositórios privados do Github](https://www.fastruby.io/blog/docker/docker-ssh-keys.html). **Criando e enviando sua imagem Docker** Com um repositório Amazon ECR devidamente definido`Dockerfile`, agora você está pronto para seguir as etapas para [criar um repositório privado do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html), caso ainda não exista um. Você também pode criar, marcar e carregar sua imagem de contêiner no repositório. Você está pronto para criar, marcar e enviar a imagem. Consulte a [documentação de compilação do Docker](https://docs.docker.com/reference/cli/docker/buildx/build/) para obter uma explicação completa das opções para o `docker build` e alguns exemplos. Para o arquivo de amostra definido acima, você pode executar: ``` 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 ``` **Atribuição de permissões apropriadas do Amazon ECR** As imagens do Braket Hybrid Jobs Docker devem ser hospedadas em repositórios privados do Amazon ECR. Por padrão, um repositório privado do Amazon ECR **não** fornece acesso de leitura ao Braket Hybrid Jobs IAM role ou a nenhum outro usuário que queira usar sua imagem, como um colaborador ou estudante. Você precisa [definir uma política de repositório](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) para conceder as permissões apropriadas. Em geral, dê permissão apenas aos usuários e perfis do IAM específicos aos quais você deseja acessar suas imagens, em vez de permitir que qualquer pessoa com a image URI as extraia. # Executando trabalhos híbridos do Braket em seu próprio contêiner Para criar um trabalho híbrido com seu próprio contêiner, chame `AwsQuantumJob.create()` com o argumento `image_uri` especificado. Você pode usar uma QPU, um simulador sob demanda ou executar seu código localmente no processador clássico disponível com o Braket Hybrid Jobs. Recomendamos testar seu código em um simulador como SV1 DM1, ou TN1 antes de executar em uma QPU real. Para executar seu código no processador clássico, especifique o `instanceType` e o `instanceCount` que você usa atualizando o `InstanceConfig`. Observe que, se você especificar um `instance_count` > 1, precisará garantir que seu código possa ser executado em vários hosts. O limite superior para o número de instâncias que você pode escolher é 5. Por exemplo: ``` 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** Use o ARN do dispositivo para rastrear o simulador que você usou como metadados do trabalho híbrido. Os valores aceitáveis devem seguir o formato `device = "local:/"`. Lembre-se que `` e `` deve consistir apenas em letras, números, `_`, `-`, e `.`. O tamanho máximo da string é 256 caracteres. Se você planeja usar o BYOC e não está usando o SDK do Braket para criar tarefas quânticas, deve passar o valor da variável ambiental `AMZN_BRAKET_JOB_TOKEN` para o parâmetro `jobToken` na solicitação `CreateQuantumTask`. Caso contrário, as tarefas quânticas não têm prioridade e são cobradas como tarefas quânticas autônomas regulares. # Usando hiperparâmetros Você pode definir os hiperparâmetros necessários ao seu algoritmo, como a taxa de aprendizado ou o tamanho da etapa, ao criar um trabalho híbrido. Os valores dos hiperparâmetros são normalmente usados para controlar vários aspectos do algoritmo e geralmente podem ser ajustados para otimizar o desempenho do algoritmo. Para usar hiperparâmetros em uma tarefa híbrida do Braket, você precisa especificar seus nomes e valores explicitamente como um dicionário. Especifique os valores dos hiperparâmetros a serem testados ao pesquisar o conjunto ideal de valores. A primeira etapa para usar hiperparâmetros é configurar e definir os hiperparâmetros como um dicionário, que pode ser visto no código a seguir. ``` from braket.devices import Devices device_arn = Devices.Amazon.SV1 hyperparameters = {"shots": 1_000} ``` Em seguida, passe os hiperparâmetros definidos no trecho de código fornecido acima para serem usados no algoritmo de sua escolha. Para executar o exemplo de código a seguir, crie um diretório chamado “src” no mesmo caminho do seu arquivo de hiperparâmetros. Dentro do diretório "src", adicione os arquivos 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), e [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 acessar seus hiperparâmetros de *dentro* do seu script de trabalho híbrido, consulte a função `load_jobs_hyperparams()` no arquivo [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 acessar seus hiperparâmetros *fora* do script de trabalho híbrido, execute o código a seguir. ``` 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 obter mais informações sobre como aprender a usar hiperparâmetros, consulte os tutoriais [QAOA com Amazon Braket Hybrid Jobs e Quantum PennyLane machine [learning nos](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) Amazon Braket Hybrid Jobs](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs/Using_PennyLane_with_Braket_Hybrid_Jobs.ipynb). # Configure sua instância de trabalho híbrida Dependendo do seu algoritmo, você pode ter requisitos diferentes. Por padrão, o Amazon Braket executa seu script de algoritmo em uma instância `ml.m5.large`. No entanto, você pode personalizar esse tipo de instância ao criar um trabalho híbrido usando o seguinte argumento de importação e configuração. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"), # Use NVIDIA T4 instance with 4 GPUs. ... ), ``` Se você estiver executando uma simulação incorporada e tiver especificado um dispositivo local na configuração do dispositivo, também poderá solicitar mais de uma instância no `InstanceConfig` especificando `instanceCount` e definindo que seja maior que um. O limite superior é 5. Por exemplo, você pode escolher 3 instâncias da seguinte maneira. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge", instanceCount=3), # Use 3 NVIDIA T4 instances ... ), ``` Ao usar várias instâncias, considere distribuir seu trabalho híbrido usando o recurso de data parallel. Consulte o exemplo de caderno a seguir para obter mais detalhes sobre como ver esse exemplo de [treinamento do Parallelize 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). As três tabelas a seguir listam os tipos e especificações de instância disponíveis para instâncias padrão, de alto desempenho e aceleradas por GPU. **nota** Para ver as cotas padrão de instância de computação clássica para trabalhos híbridos, consulte a página [Cotas do Amazon Braket](braket-quotas.md). | Instâncias padrão | vCPU | Memória (GiB) | | --- | --- | --- | | ml.m5.large (padrão) | 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 | | Instâncias de alta performance | vCPU | Memória (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 | | Inferência acelerada por GPU | GPUs | vCPU | Memória (GiB) | Memória 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 instância usa uma configuração padrão de armazenamento de dados (SSD) de 30 GB. Mas você pode ajustar o armazenamento da mesma forma que configura o `instanceType`. O exemplo a seguir mostra como aumentar o armazenamento total para 50 GB. ``` from braket.jobs.config import InstanceConfig job = AwsQuantumJob.create( ... instance_config=InstanceConfig( instanceType="ml.g4dn.xlarge", volumeSizeInGb=50, ), ... ), ``` ## Configure o bucket padrão em `AwsSession` A utilização de sua própria instância de `AwsSession` oferece maior flexibilidade, como a capacidade de especificar um local personalizado para seu bucket padrão do Amazon S3. Por padrão, uma `AwsSession` tem uma localização pré-configurada de bucket do Amazon S3 do `"amazon-braket-{id}-{region}"`. No entanto, você tem a opção de substituir a localização padrão do bucket do Amazon S3 ao criar uma `AwsSession`. Opcionalmente, os usuários podem passar um objeto `AwsSession` para o método `AwsQuantumJob.create()`, fornecendo o parâmetro `aws_session` conforme demonstrado no exemplo de código a seguir. ``` 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 ) ``` # Usar compilação paramétrica para acelerar trabalhos híbridos O Amazon Braket oferece suporte à compilação paramétrica em alguns. QPUs Isso permite que você reduza a sobrecarga associada à etapa de compilação computacionalmente cara compilando um circuito apenas uma vez e não para cada iteração em seu algoritmo híbrido. Isso pode melhorar drasticamente os runtimes de trabalhos híbridos, já que você evita a necessidade de recompilar seu circuito em cada etapa. Basta enviar circuitos parametrizados para um dos nossos serviços suportados QPUs como Braket Hybrid Job. Para trabalhos híbridos de longa duração, o Braket usa automaticamente os dados de calibração atualizados do fornecedor de hardware ao compilar seu circuito para garantir resultados da mais alta qualidade. Para criar um circuito paramétrico, primeiro você precisa fornecer parâmetros como entradas em seu script de algoritmo. Neste exemplo, usamos um pequeno circuito paramétrico e ignoramos qualquer processamento clássico entre cada iteração. Para workloads típicas, você enviaria vários circuitos em lote e executaria o processamento clássico, como atualizar os parâmetros em cada iteração. ``` 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.") ``` Você pode enviar o script do algoritmo para ser executado como um Hybrid Job com o script de trabalho a seguir. Ao executar o Hybrid Job em uma QPU compatível com compilação paramétrica, o circuito é compilado somente na primeira execução. Nas execuções seguintes, o circuito compilado é reutilizado, aumentando o desempenho do runtime do Hybrid Job sem nenhuma linha adicional de código. ``` from braket.aws import AwsQuantumJob job = AwsQuantumJob.create( device=device_arn, source_module="algorithm_script.py", ) ``` **nota** A compilação paramétrica é suportada em todos os formatos supercondutores baseados em portas, Rigetti Computing com exceção QPUs dos programas de nível de pulso.