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á. # Criar um trabalho híbrido Esta seção mostra como criar um Hybrid Job usando um script do Python. Como alternativa, para criar um trabalho híbrido a partir do código Python local, como seu ambiente de desenvolvimento integrado (IDE) preferido ou um caderno do Braket, consulte [Execute seu código local como um trabalho híbrido](braket-hybrid-job-decorator.md). **Topics** + [Criar e executar](#braket-jobs-first-create) + [Monitorar resultados](#braket-jobs-first-monitor-results) + [Salve seus resultados](#braket-jobs-save-results) + [Usando pontos de verificação](#braket-jobs-checkpoints) + [Execute seu código local como um trabalho híbrido](braket-hybrid-job-decorator.md) + [Usando a API com trabalhos híbridos](braket-jobs-api.md) + [Crie e depure uma tarefa híbrida com o modo local](braket-jobs-local-mode.md) ## Criar e executar Depois de ter um perfil com permissões para executar um trabalho híbrido, você estará pronto para continuar. A peça-chave do seu primeiro trabalho híbrido do Braket é o *script do algoritmo*. Ele define o algoritmo que você deseja executar e contém a lógica clássica e as tarefas quânticas que fazem parte do seu algoritmo. Além do script do algoritmo, você pode fornecer outros arquivos de dependência. O script do algoritmo, junto com suas dependências, é chamado de *módulo de origem*. O *ponto de entrada* define o primeiro arquivo ou função a ser executado em seu módulo de origem quando o trabalho híbrido é iniciado. ![\[Diagrama mostrando o fluxo de trabalho de criar um trabalho quântico usando um console ou notebook, executando o script do algoritmo em um dispositivo quântico e analisando os resultados.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/braket-jobs-first-workflow.jpg) Primeiro, considere o seguinte exemplo básico de um script de algoritmo que cria cinco estados de sino e imprime os resultados de medição correspondentes. ``` 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!") ``` Salve esse arquivo com o nome *algorithm\$1script.py* em seu diretório de trabalho atual no notebook Braket ou no ambiente local. O arquivo algorithm\$1script.py tem `start_here()` como ponto de entrada planejado. Em seguida, crie um arquivo Python ou um caderno Python no mesmo diretório do arquivo algorithm\$1script.py. Esse script inicia o trabalho híbrido e processa qualquer processamento assíncrono, como imprimir o status ou os principais resultados nos quais estamos interessados. No mínimo, esse script precisa especificar seu script de trabalho híbrido e seu dispositivo principal. **nota** Para obter mais informações sobre como criar um caderno Braket ou fazer upload de um arquivo, como o arquivo *algorithm\$1script.py*, no mesmo diretório dos cadernos, consulte [Executar seu primeiro circuito usando o Amazon Braket Python SDK](braket-get-started-run-circuit.md). Para esse primeiro caso básico, você escolhe um simulador. Qualquer que seja o tipo de dispositivo quântico que você almeje, um simulador ou uma unidade de processamento quântico (QPU) real, o dispositivo especificado com `device` no script a seguir é usado para agendar a tarefa híbrida e está disponível para os scripts do algoritmo como a variável de ambiente `AMZN_BRAKET_DEVICE_ARN`. **nota** Você só pode usar dispositivos que estejam disponíveis no Região da AWS seu trabalho híbrido. O Amazon Braket SDK seleciona automaticamente a Região da AWS. Por exemplo, uma tarefa híbrida em us-east-1 pode usar dispositivos IonQ, SV1, DM1, e TN1, mas não Rigetti. Se você escolher um computador quântico em vez de um simulador, o Braket agenda seus trabalhos híbridos para executar todas as tarefas quânticas com acesso prioritário. ``` 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 ) ``` O parâmetro `wait_until_complete=True` define um modo detalhado para que seu trabalho imprima a saída do trabalho real enquanto ele está sendo executado. Você deverá ver uma saída semelhante ao exemplo a seguir. ``` 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** Você também pode usar seu módulo personalizado com o [AwsQuantumJobmétodo.create](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.aws.aws_quantum_job.html#braket.aws.aws_quantum_job.AwsQuantumJob.create) passando sua localização (o caminho para um diretório ou arquivo local ou um URI do S3 de um arquivo tar.gz). Para um exemplo prático, consulte o arquivo [Parallelize\$1training\$1for\$1QML.ipynb](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) na pasta hybrid jobs do [repositório de exemplos do Amazon Braket no Github](https://github.com/amazon-braket/amazon-braket-examples/tree/main). ## Monitorar resultados Como alternativa, você pode acessar a saída do log da Amazon CloudWatch. Para fazer isso, acesse a guia **Grupos de logs** no menu esquerdo da página de detalhes do trabalho, selecione o grupo de logs `aws/braket/jobs` e escolha o fluxo de logs que contém o nome do trabalho. No exemplo acima, ele é `braket-job-default-1631915042705/algo-1-1631915190`. ![\[CloudWatch grupo de registros mostrando uma lista de eventos de log com caminhos de arquivo e registros de data e hora para testes do SDK Python do Amazon Braket.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/braket-jobs-first-cw-log.png) Você também pode visualizar o status do trabalho híbrido no console selecionando a página **Trabalhos híbridos** e, em seguida, escolhendo **Configurações**. ![\[Detalhes do trabalho híbrido do Amazon Braket, incluindo resumo, horários dos eventos, código-fonte, configuração da instância e condições de parada.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/braket-jobs-first-console-status.png) Seu trabalho híbrido produz alguns artefatos no Amazon S3 enquanto é executado. O nome padrão do bucket do S3 é `amazon-braket--` e o conteúdo está no diretório `jobs//`. Você pode configurar os locais do S3 em que esses artefatos são armazenados especificando um `code_location` diferente quando a tarefa híbrida é criada com o SDK Braket Python. **nota** Esse bucket do S3 deve estar localizado da Região da AWS mesma forma que seu script de trabalho. O diretório `jobs//` contém uma subpasta com a saída do script do ponto de entrada em um arquivo `model.tar.gz`. Também há um diretório chamado `script` que contém os artefatos do script do algoritmo em um `source.tar.gz` arquivo. Os resultados de suas tarefas quânticas reais estão no diretório nomeado `jobs//tasks`. ## Salve seus resultados Você pode salvar os resultados gerados pelo script do algoritmo para que estejam disponíveis no objeto de trabalho híbrido no script de trabalho híbrido, bem como na pasta de saída no Amazon S3 (em um arquivo compactado em tar chamado model.tar.gz). A saída deve ser salva em um arquivo usando o formato JavaScript Object Notation (JSON). Se os dados não puderem ser prontamente serializados em texto, como no caso de uma matriz numérica, você poderá passar uma opção para serializar usando um formato de dados em conserva. Consulte o módulo [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) para obter mais detalhes. Para salvar os resultados das tarefas híbridas, adicione as seguintes linhas comentadas com \$1ADD ao arquivo 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!") ``` Em seguida, você pode exibir os resultados do trabalho a partir do seu script de trabalho anexando a linha ** `print(job.result())` ** comentada com \$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 ``` Neste exemplo, removemos `wait_until_complete=True` para suprimir a saída detalhada. Você pode adicioná-lo novamente para depuração. Quando você executa essa tarefa híbrida, ela gera o identificador e o `job-arn`, seguidos pelo estado da tarefa híbrida a cada 10 segundos até que a tarefa híbrida chegue a `COMPLETED`, após o qual mostra os resultados do circuito da campainha. Veja o exemplo a seguir. ``` 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}]} ``` ## Usando pontos de verificação Você pode salvar iterações intermediárias de seus trabalhos híbridos usando pontos de verificação. No exemplo de script de algoritmo da seção anterior, você adicionaria as seguintes linhas comentadas com \$1ADD para criar arquivos de ponto de verificação. ``` 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!") ``` Ao executar o trabalho híbrido, o arquivo *-checkpoint-1.json* é criado nos artefatos do trabalho híbrido, no diretório de checkpoints, com um caminho padrão `/opt/jobs/checkpoints`. O script de trabalho híbrido permanece inalterado, a menos que você queira alterar esse caminho padrão. Se você quiser carregar uma tarefa híbrida a partir de um ponto de verificação gerado por uma tarefa híbrida anterior, o script do algoritmo usa `from braket.jobs import load_job_checkpoint`. A lógica a ser carregada em seu script de algoritmo é a seguinte. ``` from braket.jobs import load_job_checkpoint checkpoint_1 = load_job_checkpoint( "previous_job_name", checkpoint_file_suffix="checkpoint-1", ) ``` Depois de carregar esse ponto de verificação, você pode continuar sua lógica com base no conteúdo carregado no `checkpoint-1`. **nota** O *checkpoint\$1file\$1suffix* deve corresponder ao sufixo especificado anteriormente ao criar o ponto de verificação. Seu script de orquestração precisa especificar o `job-arn` do trabalho híbrido anterior com a linha comentada com \$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 ) ``` # Execute seu código local como um trabalho híbrido O Amazon Braket Hybrid Jobs fornece uma orquestração totalmente gerenciada de algoritmos clássicos quânticos híbridos, combinando recursos computacionais do Amazon EC2 com o acesso à Amazon Braket Quantum Processing Unit (QPU). As tarefas quânticas criadas em um trabalho híbrido têm prioridade na fila em relação às tarefas quânticas individuais, para que seus algoritmos não sejam interrompidos por flutuações na fila de tarefas quânticas. Cada QPU mantém uma fila de trabalhos híbridos separada, garantindo que somente um trabalho híbrido possa ser executado a qualquer momento. **Topics** + [Crie um trabalho híbrido a partir do código Python local](#create-hybrid-job-from-local-python-code) + [Instale pacotes e código-fonte adicionais do Python](#install-python-packages-and-code) + [Salvar e carregar dados em uma instância de trabalho híbrida](#save-load-data-into-instance) + [Práticas recomendadas para decoradores de trabalhos híbridos](#best-practices) ## Crie um trabalho híbrido a partir do código Python local Você pode executar seu código Python local como um Amazon Braket Hybrid Job. Você pode fazer isso anotando seu código com um decorador `@hybrid_job`, como mostrado no exemplo de código a seguir. Para ambientes personalizados, você pode optar por [usar um contêiner personalizado](braket-jobs-byoc.md) do Amazon Elastic Container Registry (ECR). **nota** Somente o Python 3.12 é suportado por padrão. Você pode usar o decorador `@hybrid_job` para anotar uma função. O Braket transforma o código dentro do decorador em um [script de algoritmo](braket-jobs-first.md) de trabalho híbrido do Braket. O trabalho híbrido então invoca a função dentro do decorador em uma instância do Amazon EC2. É possível monitorar o progresso do trabalho com `job.state()` ou com o console Braket. O exemplo de código a seguir mostra como executar uma sequência de cinco estados no 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} ``` Você cria o trabalho híbrido invocando a função como faria com as funções normais do Python. No entanto, a função decoradora retorna o identificador de trabalho híbrido em vez do resultado da função. Para recuperar os resultados após a conclusão, use `job.result()`. ``` job = run_hybrid_job(num_tasks=1) result = job.result() ``` O argumento do dispositivo no `@hybrid_job` decorador especifica o dispositivo ao qual a tarefa híbrida tem acesso prioritário - nesse caso, o simulador SV1. Para obter prioridade de QPU, você deve garantir que o ARN do dispositivo usado na função corresponda ao especificado no decorador. Por conveniência, você pode usar a função auxiliar `get_job_device_arn()` para capturar o ARN do dispositivo declarado em `@hybrid_job`. **nota** Cada trabalho híbrido tem um tempo de inicialização de pelo menos um minuto, pois cria um ambiente em contêineres no Amazon EC2. Portanto, para workloads muito curtas, como um único circuito ou um lote de circuitos, pode ser suficiente usar tarefas quânticas. **Hiperparâmetros** A função `run_hybrid_job()` usa o argumento `num_tasks` para controlar o número de tarefas quânticas criadas. A tarefa híbrida captura isso automaticamente como um [hiperparâmetro](braket-jobs-hyperparameters.md). **nota** Os hiperparâmetros são exibidos no console do Braket como sequências de caracteres, limitadas a 2500 caracteres. **Métricas e log** Dentro da função `run_hybrid_job()`, métricas de algoritmos iterativos são registradas com `log_metrics`. As métricas são plotadas automaticamente na página do console do Braket, na guia de tarefas híbridas. Você pode usar métricas para rastrear os custos quânticos da tarefa quase em tempo real durante a execução do trabalho híbrido com o rastreador de custos [Braket](braket-pricing.md). O exemplo acima usa o nome da métrica “probabilidade” que registra a primeira probabilidade do [tipo de resultado](braket-result-types.md). **Recuperando resultados** Depois que a tarefa híbrida for concluída, você usará `job.result()` para recuperar os resultados da tarefa híbrida. Todos os objetos na declaração de retorno são automaticamente capturados pelo Braket. Observe que os objetos retornados pela função devem ser uma tupla com cada elemento sendo serializável. Por exemplo, o código a seguir mostra um exemplo de funcionamento e um de falha. ``` 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 do trabalho** Por padrão, o nome desse trabalho híbrido é inferido do nome da função. Você também pode especificar um nome personalizado com até 50 caracteres. Por exemplo, no código a seguir, o nome do trabalho é "my-job-name”. ``` @hybrid_job(device=Devices.Amazon.SV1, job_name="my-job-name") def function(): pass ``` **Modo local** Os [trabalhos locais](braket-jobs-local-mode.md) são criados adicionando o argumento `local=True` ao decorador. Isso executa a tarefa híbrida em um ambiente conteinerizado em seu ambiente de computação local, como seu laptop. Os trabalhos locais **não têm** fila prioritária para tarefas quânticas. Para casos avançados, como vários nós ou MPI, as tarefas locais podem ter acesso às variáveis de ambiente Braket necessárias. O código a seguir cria uma tarefa híbrida local com o dispositivo como SV1 simulador. ``` @hybrid_job(device=Devices.Amazon.SV1, local=True) def run_hybrid_job(num_tasks=1): return ... ``` Todas as outras opções de trabalhos híbrida são compatíveis. Para obter uma lista de opções, consulte o módulo [braket.jobs.quantum\$1job\$1creation](https://amazon-braket-sdk-python.readthedocs.io/en/stable/_apidoc/braket.jobs.quantum_job_creation.html). ## Instale pacotes e código-fonte adicionais do Python Você pode personalizar seu ambiente de runtime para usar seus pacotes Python preferidos. Você pode usar um arquivo `requirements.txt`, uma lista de nomes de pacotes ou [trazer seu próprio contêiner (BYOC)](braket-jobs-byoc.md). Por exemplo, o arquivo `requirements.txt` pode incluir outros pacotes para instalação. ``` qiskit pennylane >= 0.31 mitiq == 0.29 ``` Para personalizar um ambiente de runtime usando um arquivo `requirements.txt`, consulte o exemplo de código a seguir. ``` @hybrid_job(device=Devices.Amazon.SV1, dependencies="requirements.txt") def run_hybrid_job(num_tasks=1): return ... ``` Como alternativa, você pode fornecer os nomes dos pacotes como uma lista do Python da seguinte maneira. ``` @hybrid_job(device=Devices.Amazon.SV1, dependencies=["qiskit", "pennylane>=0.31", "mitiq==0.29"]) def run_hybrid_job(num_tasks=1): return ... ``` O código-fonte adicional pode ser especificado como uma lista de módulos ou como um único módulo, como no exemplo de código a seguir. ``` @hybrid_job(device=Devices.Amazon.SV1, include_modules=["my_module1", "my_module2"]) def run_hybrid_job(num_tasks=1): return ... ``` ## Salvar e carregar dados em uma instância de trabalho híbrida **Especificando dados de treinamento de entrada** Ao criar um trabalho híbrido, será possível fornecer uma entrada de conjuntos de dados de treinamento especificando um bucket do Amazon Simple Storage Service (Amazon S3). Você também pode especificar um caminho local e, em seguida, o Braket carrega automaticamente os dados para o Amazon S3 em `s3:///jobs///data/`. Se você especificar um caminho local, o nome do canal será padronizado como “entrada”. O código a seguir mostra um arquivo numpy do caminho `data/file.npy` local. ``` 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 ... ``` Para o S3, você deve usar a função auxiliar `get_input_data_dir()`. ``` 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") ``` Você pode especificar várias fontes de dados de entrada fornecendo um dicionário de valores de canais e caminhos S3 URIs ou locais. ``` 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 os dados de entrada são grandes (>1 GB), há um longo tempo de espera até que a tarefa seja criada. Isso se deve aos dados de entrada locais quando eles são carregados pela primeira vez em um bucket do S3 e, em seguida, o caminho do S3 é adicionado à solicitação de trabalho. Finalmente, a solicitação de trabalho é enviada ao serviço Braket. **Salvando resultados no S3** Para salvar resultados não incluídos na instrução de retorno da função decorada, você deve acrescentar o diretório correto a todas as operações de gravação de arquivos. O exemplo a seguir mostra como salvar uma matriz numérica e uma 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 ... ``` Todos os resultados são compactados em um arquivo chamado `model.tar.gz`. Você pode baixar os resultados com a função `job.result()` do Python ou navegando até a pasta de resultados na página de trabalhos híbridos no console de gerenciamento do Braket. **Salvando e retomando a partir dos pontos de verificação** Para trabalhos híbridos de longa duração, é recomendável salvar periodicamente o estado intermediário do algoritmo. Você pode usar a função auxiliar `save_job_checkpoint()` integrada ou salvar arquivos no caminho `AMZN_BRAKET_JOB_RESULTS_DIR`. O último está disponível com a função auxiliar `get_job_results_dir()`. Veja a seguir um exemplo prático mínimo para salvar e carregar pontos de verificação com um decorador de tarefas 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() ``` No primeiro trabalho híbrido, `save_job_checkpoint()` é chamado com um dicionário contendo os dados que queremos salvar. Por padrão, cada valor deve ser serializável como texto. Para verificar objetos Python mais complexos, como matrizes numpy, você pode definir `data_format = PersistedJobDataFormat.PICKLED_V4`. Esse código cria e sobrescreve um arquivo de ponto de verificação com nome padrão `.json` em seus artefatos de trabalho híbridos em uma subpasta chamada “pontos de verificação”. Para criar um novo trabalho híbrido para continuar a partir do posto de controle, precisamos informar `copy_checkpoints_from_job=job_arn` onde `job_arn` é o ARN do trabalho híbrido do trabalho anterior. Em seguida, usamos `load_job_checkpoint(job_name)` para carregar a partir do ponto de verificação. ## Práticas recomendadas para decoradores de trabalhos híbridos **Adote a assincronicidade** As tarefas híbridas criadas com a anotação do decorador são assíncronas — elas são executadas quando os recursos clássicos e quânticos estão disponíveis. Você monitora o progresso do algoritmo usando o Braket Management Console ou Amazon CloudWatch. Quando você envia seu algoritmo para execução, o Braket executa seu algoritmo em um ambiente escalável em contêineres e os resultados são recuperados quando o algoritmo é concluído. **Execute algoritmos variacionais iterativos** Os trabalhos híbridos oferecem as ferramentas para executar algoritmos clássicos quânticos iterativos. Para problemas puramente quânticos, use [tarefas quânticas](braket-submit-tasks.md) ou um [lote de tarefas quânticas](braket-batching-tasks.md). O acesso prioritário a determinados QPUs é mais benéfico para algoritmos variacionais de longa execução que exigem várias chamadas iterativas para o QPUs com processamento clássico intermediário. **Depurar usando o modo local** Antes de executar uma tarefa híbrida em uma QPU, é recomendável executá-la primeiro no simulador SV1 para confirmar se ela é executada conforme o esperado. Para testes de pequena escala, você pode executar com o modo local para iteração e depuração rápidas. **Melhore a reprodutibilidade com [Bring your own container (BYOC)](braket-jobs-byoc.md)** Crie um experimento reproduzível encapsulando seu software e suas dependências em um ambiente em contêineres. Ao empacotar todo o seu código, dependências e configurações em um contêiner, você evita possíveis conflitos e problemas de versão. **Simuladores distribuídos de várias instâncias** Para executar um grande número de circuitos, considere usar o suporte MPI integrado para executar simuladores locais em várias instâncias em uma única tarefa híbrida. Para obter mais informações, consulte [simuladores incorporados](pennylane-embedded-simulators.md). **Use circuitos paramétricos** Os circuitos paramétricos que você envia a partir de um trabalho híbrido são compilados automaticamente em determinados, QPUs usando a [compilação paramétrica](braket-jobs-parametric-compilation.md) para melhorar os tempos de execução de seus algoritmos. **Ponto de verificação periódico** Para trabalhos híbridos de longa duração, é recomendável salvar periodicamente o estado intermediário do algoritmo. **Para mais exemplos, casos de uso e melhores práticas, consulte exemplos do [Amazon Braket](https://github.com/amazon-braket/amazon-braket-examples). GitHub** # Usando a API com trabalhos híbridos Você pode acessar e interagir com o Amazon Braket Hybrid Jobs diretamente usando o API. No entanto, os padrões e os métodos de conveniência não estão disponíveis ao usar o API diretamente. **nota** É altamente recomendável que você interaja com o Amazon Braket Hybrid Jobs usando o [SDK Amazon Braket Python.](https://github.com/aws/amazon-braket-sdk-python) Ele oferece padrões e proteções convenientes que ajudam seus trabalhos híbridos a serem executados com êxito. Este tópico aborda os conceitos básicos do uso do API. Se você optar por usar a API, lembre-se de que essa abordagem pode ser mais complexa e estar preparada para várias iterações para que seu trabalho híbrido seja executado. Para usar a API, sua conta deve ter um papel na política gerenciada `AmazonBraketFullAccess`. **nota** Para obter mais informações sobre como obter uma função com a política gerenciada `AmazonBraketFullAccess`, consulte a página [Habilitar o Amazon Braket](braket-enable-overview.md). Além disso, você precisa de um **perfil de execução**. Esse perfil será passado para o serviço. Você pode criar o perfil usando o **console do Amazon Braket**. Use a guia **Perfis de execução** na página **Permissões e configurações** para criar um perfil padrão para trabalhos híbridos. O `CreateJob` API exige que você especifique todos os parâmetros necessários para a tarefa híbrida. Para usar o Python, compacte seus arquivos de script de algoritmo em um pacote tar, como um arquivo input.tar.gz, e execute o script a seguir. Atualize as partes do código entre colchetes angulares (`<>`) para corresponder às informações da sua conta e ao ponto de entrada que especificam o caminho, o arquivo e o método em que seu trabalho híbrido começa. ``` 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 }, ) ``` Depois de criar seu trabalho híbrido, você pode acessar os detalhes do trabalho híbrido por meio do `GetJob` API ou do console. Para obter os detalhes do trabalho híbrido da sessão do Python na qual você executou o código `createJob`, como no exemplo anterior, use o comando Python a seguir. ``` getJob = client.get_job(jobArn=job["jobArn"]) ``` Para cancelar um trabalho híbrido, chame o `CancelJob` API com o Amazon Resource Name do trabalho ('JobArn'). ``` cancelJob = client.cancel_job(jobArn=job["jobArn"]) ``` Você pode especificar pontos de verificação como parte do `createJob` API usando o `checkpointConfig` parâmetro. ``` checkpointConfig = { "localPath" : "/opt/omega/checkpoints", "s3Uri": f"s3://{bucket}/{s3_prefix}/checkpoints" }, ``` **nota** O localPath de `checkpointConfig` não pode começar com nenhum dos seguintes caminhos reservados: `/opt/ml`, `/opt/braket`, `/tmp`, ou `/usr/local/nvidia`. # Crie e depure uma tarefa híbrida com o modo local Quando você está criando um novo algoritmo híbrido, o modo local ajuda você a depurar e testar seu script de algoritmo. O modo local é um recurso que permite executar o código que você planeja usar no Amazon Braket Hybrid Jobs, mas sem precisar que o Braket gerencie a infraestrutura para executar o trabalho híbrido. Em vez disso, execute trabalhos híbridos localmente em sua instância do Amazon Braket Notebook ou em um cliente preferencial, como um laptop ou computador desktop. No modo local, você ainda pode enviar tarefas quânticas para dispositivos reais, mas não obtém os benefícios de desempenho ao executar em uma unidade de processamento quântico (QPU) real no modo local. Para usar o modo local, modifique `AwsQuantumJob` para `LocalQuantumJob` onde quer que ele ocorra dentro do seu programa. Por exemplo, para executar o exemplo de [Criar seu primeiro trabalho híbrido](braket-jobs-first.md), edite o script de trabalho híbrido no código da seguinte forma. ``` 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** O Docker, que já vem pré-instalado nos cadernos Amazon Braket, precisa ser instalado em seu ambiente local para usar esse recurso. As instruções para instalar o Docker podem ser encontradas na página [Obter Docker](https://docs.docker.com/get-started/get-docker/). Além disso, nem todos os parâmetros são compatíveis com o modo local.