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

# Execute seu código local como um trabalho SageMaker de treinamento
<a name="train-remote-decorator"></a>

Você pode executar seu código Python de aprendizado de máquina (ML) local como um grande trabalho de treinamento de nó único da SageMaker Amazon ou como vários trabalhos paralelos. Você pode fazer isso anotando o código com um decorador @remote, conforme mostrado no exemplo de código a seguir. O [treinamento distribuído](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-training.html) (em várias instâncias) não é compatível com funções remotas.

```
@remote(**settings)
def divide(x, y):
    return x / y
```

O SDK do SageMaker Python traduzirá automaticamente seu ambiente de espaço de trabalho existente e qualquer código de processamento de dados e conjuntos de dados associados em um trabalho de SageMaker treinamento executado na plataforma de treinamento. SageMaker Você também pode ativar um atributo de cache persistente, que reduzirá ainda mais a latência de início do trabalho ao armazenar em cache pacotes de dependências baixados anteriormente. Essa redução na latência do trabalho é maior do que a redução na latência causada apenas pelo uso de pools quentes gerenciados por SageMaker IA. Para obter mais informações, consulte [Usando cache persistente](train-warm-pools.md#train-warm-pools-persistent-cache).

**nota**  
Os trabalhos de treinamento distribuídos não são compatíveis com as funções remotas.

As seções a seguir mostram como anotar o código de ML local com um decorador @remote e adaptar sua experiência para seu caso de uso. Isso inclui a personalização do ambiente e a integração com SageMaker os Experimentos.

**Topics**
+ [Configurar o ambiente](#train-remote-decorator-env)
+ [Invocar uma função remota](train-remote-decorator-invocation.md)
+ [Arquivo de configuração](train-remote-decorator-config.md)
+ [Personalize o ambiente de execução](train-remote-decorator-customize.md)
+ [Compatibilidade de imagens de contêiner](train-remote-decorator-container.md)
+ [Registrando parâmetros e métricas com Amazon SageMaker Experiments](train-remote-decorator-experiments.md)
+ [Como usar o código modular com o decorador @remote](train-remote-decorator-modular.md)
+ [Repositório privado para dependências de runtime](train-remote-decorator-private.md)
+ [Cadernos de exemplo](train-remote-decorator-examples.md)

## Configurar o ambiente
<a name="train-remote-decorator-env"></a>

Escolha uma das três opções a seguir para configurar o ambiente.

### Execute seu código no Amazon SageMaker Studio Classic
<a name="train-remote-decorator-env-studio"></a>

Você pode anotar e executar seu código de ML local a partir do SageMaker Studio Classic criando um SageMaker Notebook e anexando qualquer imagem disponível na imagem do SageMaker Studio Classic. As instruções a seguir ajudam você a criar um SageMaker Notebook, instalar o SDK do SageMaker Python e anotar seu código com o decorador.

1. Crie um SageMaker Notebook e anexe uma imagem no SageMaker Studio Classic da seguinte forma:

   1. Siga as instruções em [Inicie o Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html) no *Amazon SageMaker AI Developer Guide*.

   1. Selecione **Studio** no painel de navegação à esquerda. Essa ação abre uma nova janela.

   1. Na caixa de diálogo **Comece a usar**, selecione um perfil do usuário na seta para baixo. Essa ação abre uma nova janela.

   1. Escolha **Abrir Studio Classic**.

   1. Selecione **Abrir inicializador** na área de trabalho principal. Essa ação abre uma nova página.

   1. Selecione **Criar caderno** na área de trabalho principal.

   1. Selecione **Base Python 3.0** na seta para baixo ao lado de **Imagem** na caixa de diálogo **Alterar ambiente**. 

      O decorador @remote detecta automaticamente a imagem anexada ao notebook SageMaker Studio Classic e a usa para executar o trabalho de SageMaker treinamento. Se o `image_uri` for especificado como um argumento no decorador ou no arquivo de configuração, o valor especificado em `image_uri` será usado em vez da imagem detectada.

      Para obter mais informações sobre como criar um notebook no SageMaker Studio Classic, consulte a seção **Criar um caderno a partir do menu Arquivo** em [Criar ou abrir um caderno Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-create-open.html#notebooks-create-file-menu).

      Para ver uma lista das imagens disponíveis, consulte [Imagens do Docker compatíveis](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-container.html).

1. Instale o SageMaker SDK do Python.

   Para anotar seu código com a função @remote dentro de um notebook SageMaker Studio Classic, você deve ter o SDK do SageMaker Python instalado. Instale o SDK do SageMaker Python, conforme mostrado no exemplo de código a seguir.

   ```
   !pip install sagemaker
   ```

1. Use o decorador @remote para executar funções em um trabalho de SageMaker treinamento.

   Para executar seu código de ML local, primeiro crie um arquivo de dependências para instruir a SageMaker IA sobre onde localizar seu código local. Para fazer isso, siga estas etapas:

   1. Na área de trabalho principal do SageMaker Studio Classic Launcher, em **Utilitários e arquivos**, escolha Arquivo de **texto**. Isso abre uma nova guia com um arquivo de texto chamado `untitled.txt.` 

      Para obter mais informações sobre a interface de usuário (UI) do SageMaker Studio Classic, consulte [Visão geral da interface do usuário do Amazon SageMaker Studio Classic](https://docs.aws.amazon.com//sagemaker/latest/dg/studio-ui.html).

   1. Renomeie `untitled.txt ` para `requirements.txt`.

   1. Adicione todas as dependências necessárias para o código junto com a biblioteca de SageMaker IA em. `requirements.txt` 

      Um exemplo de código mínimo `requirements.txt` para a função `divide` do exemplo é fornecido na seção a seguir.

      ```
      sagemaker
      ```

   1. Execute o código com o decorador remoto aprovando o arquivo de dependências, da seguinte forma:

      ```
      from sagemaker.remote_function import remote
      
      @remote(instance_type="ml.m5.xlarge", dependencies='./requirements.txt')
      def divide(x, y):
          return x / y
      
      divide(2, 3.0)
      ```

      Para ver exemplos de código adicionais, consulte o caderno de amostra [quick\$1start.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb).

      **Se você já está executando um notebook SageMaker Studio Classic e instala o SDK do Python conforme as instruções em 2. Instale o SDK do SageMaker Python**, você deve reiniciar seu kernel. Para obter mais informações, consulte [Usar a barra de ferramentas do notebook SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-menu.html) no *Amazon SageMaker AI Developer Guide*.

### Execute seu código em um SageMaker notebook da Amazon
<a name="train-remote-decorator-env-notebook"></a>

Você pode anotar seu código de ML local a partir de uma instância do SageMaker notebook. As instruções a seguir mostram como criar uma instância de notebook com um kernel personalizado, instalar o SDK do SageMaker Python e anotar seu código com o decorador.

1. Criar uma instância de caderno com um kernel `conda` personalizado.

   Você pode anotar seu código de ML local com um decorador @remote para usar dentro de um SageMaker trabalho de treinamento. Primeiro, você deve criar e personalizar uma instância do SageMaker notebook para usar um kernel com Python versão 3.7 ou superior, até 3.10.x. Para fazer isso, siga estas etapas:

   1. Abra o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

   1. No painel de navegação à esquerda, escolha **Caderno** para expandir as opções.

   1. Escolha **Instância de cadernos** entre as opções expandidas.

   1. Escolha o botão **Criar instância de cadernos**. Essa ação abre uma nova página.

   1. Em **Nome de instância de cadernos**, insira um nome com no máximo 63 caracteres e sem espaços. Caracteres válidos: **A-Z**, **a-z**, **0-9**, e **.****:****\$1****=****@**** \$1****%****-** (hífen).

   1. Na caixa de diálogo **Configurações da instância de cadernos**, expanda a seta para a direita ao lado de **Configuração adicional**.

   1. Em **Configuração do ciclo de vida - opcional**, expanda a seta para baixo e selecione **Criar uma nova configuração do ciclo de vida**. Isso abre uma nova caixa de diálogo.

   1. Em **Nome**, digite um nome para o ajuste de configuração.

   1. Na caixa de diálogo **Scripts**, na guia **Iniciar caderno**, substitua o conteúdo já existente da caixa de texto pelo script a seguir.

      ```
      #!/bin/bash
      
      set -e
      
      sudo -u ec2-user -i <<'EOF'
      unset SUDO_UID
      WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda/
      source "$WORKING_DIR/miniconda/bin/activate"
      for env in $WORKING_DIR/miniconda/envs/*; do
          BASENAME=$(basename "$env")
          source activate "$BASENAME"
          python -m ipykernel install --user --name "$BASENAME" --display-name "Custom ($BASENAME)"
      done
      EOF
      
      echo "Restarting the Jupyter server.."
      # restart command is dependent on current running Amazon Linux and JupyterLab
      CURR_VERSION_AL=$(cat /etc/system-release)
      CURR_VERSION_JS=$(jupyter --version)
      
      if [[ $CURR_VERSION_JS == *$"jupyter_core     : 4.9.1"* ]] && [[ $CURR_VERSION_AL == *$" release 2018"* ]]; then
       sudo initctl restart jupyter-server --no-wait
      else
       sudo systemctl --no-block restart jupyter-server.service
      fi
      ```

   1. Na caixa de diálogo **Scripts**, na guia **Iniciar caderno**, substitua o conteúdo já existente da caixa de texto pelo script a seguir.

      ```
      #!/bin/bash
      
      set -e
      
      sudo -u ec2-user -i <<'EOF'
      unset SUDO_UID
      # Install a separate conda installation via Miniconda
      WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
      mkdir -p "$WORKING_DIR"
      wget https://repo.anaconda.com/miniconda/Miniconda3-4.6.14-Linux-x86_64.sh -O "$WORKING_DIR/miniconda.sh"
      bash "$WORKING_DIR/miniconda.sh" -b -u -p "$WORKING_DIR/miniconda" 
      rm -rf "$WORKING_DIR/miniconda.sh"
      # Create a custom conda environment
      source "$WORKING_DIR/miniconda/bin/activate"
      KERNEL_NAME="custom_python310"
      PYTHON="3.10"
      conda create --yes --name "$KERNEL_NAME" python="$PYTHON" pip
      conda activate "$KERNEL_NAME"
      pip install --quiet ipykernel
      # Customize these lines as necessary to install the required packages
      EOF
      ```

   1. Escolha o botão **Criar configuração** na parte inferior direita da janela.

   1. Escolha o botão **Criar instância de caderno** na parte inferior direita da janela.

   1. Aguarde até que o **status** da instância do notebook mude de **Pendente** para **InService**.

1. Crie um caderno Jupyter na instância de cadernos.

   As instruções a seguir mostram como criar um notebook Jupyter usando o Python 3.10 na sua instância recém-criada. SageMaker 

   1. Depois que o **Status** da instância do notebook da etapa anterior for **InService**, faça o seguinte: 

      1. Selecione **Abrir o Jupyter** em **Ações** na linha que contém o **nome** de instância de caderno recém-criada. Isso abre um novo servidor Jupyter.

   1. No servidor Jupyter, selecione **Novo** no menu superior direito. 

   1. Na seta para baixo, selecione **conda\$1custom\$1python310**. Isso cria um novo caderno Jupyter que usa um kernel Python 3.10. Esse novo caderno Jupyter agora pode ser usado de forma semelhante a um caderno Jupyter local. 

1. Instale o SageMaker SDK do Python.

   Depois que seu ambiente virtual estiver em execução, instale o SDK do SageMaker Python usando o exemplo de código a seguir.

   ```
   !pip install sagemaker
   ```

1. Use um decorador @remote para executar funções em um trabalho de SageMaker treinamento.

   Quando você anota seu código de ML local com um decorador @remote dentro do SageMaker notebook, o SageMaker treinamento interpreta automaticamente a função do seu código e a executa como um SageMaker trabalho de treinamento. Para configurar o caderno, faça o seguinte:

   1. Selecione o nome do kernel no menu do notebook na instância do SageMaker notebook que você criou na etapa 1, **Criar uma instância do SageMaker Notebook com um kernel personalizado**.

      Para obter mais informações, consulte [Alterar uma imagem ou um kernel](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-run-and-manage-change-image.html). 

   1. Na seta para baixo, escolha um kernel `conda` personalizado que usa uma versão do Python 3.7 ou superior. 

      Por exemplo, ao selecionar `conda_custom_python310`, escolhe-se o kernel para Python 3.10.

   1. Escolha **Selecionar**.

   1. Aguarde até que o status do kernel apareça como inativo, o que indica que o kernel foi iniciado.

   1. Na página inicial do Jupyter Server, selecione **Novo** no menu superior direito.

   1. Ao lado da seta para baixo, selecione **Arquivo de texto**. Isso cria um novo arquivo de texto chamado `untitled.txt.`

   1. Renomeie `untitled.txt` como `requirements.txt` e adicione todas as dependências necessárias para o código junto com o `sagemaker`.

   1. Execute o código com o decorador remoto aprovando o arquivo de dependências conforme mostrado abaixo.

      ```
      from sagemaker.remote_function import remote
      
      @remote(instance_type="ml.m5.xlarge", dependencies='./requirements.txt')
      def divide(x, y):
          return x / y
      
      divide(2, 3.0)
      ```

      Consulte o caderno de exemplo [quick\$1start.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb) para exemplos de código adicionais.

### Execute o código de dentro do IDE local
<a name="train-remote-decorator-env-ide"></a>

Você pode anotar o código de ML local com um decorador @remote dentro do IDE local de sua preferência. As etapas a seguir mostram os pré-requisitos necessários, como instalar o SDK Python e como anotar seu código com o decorador @remote.

1. Instale os pré-requisitos configurando o AWS Command Line Interface (AWS CLI) e criando uma função, da seguinte forma:
   + Integre-se a um domínio de SageMaker IA seguindo as instruções na seção **AWS CLI Pré-requisitos de Configurar os pré-requisitos** [do Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html#gs-cli-prereq) AI. SageMaker 
   + Crie uma função do IAM seguindo a seção **Criar função de execução** do [SageMaker AI Roles](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html).

1. Crie um ambiente virtual usando PyCharm ou `conda` usando Python versão 3.7 ou superior, até 3.10.x.
   + Configure um ambiente virtual usando PyCharm o seguinte:

     1. Selecione **Arquivo** no menu principal.

     1. Escolha **Novo projeto**.

     1. Escolha **Conda** na seta para baixo em **Novo ambiente usando**.

     1. No campo da **versão do Python**, use a seta para baixo para selecionar uma versão do Python que seja 3.7 ou superior. Você pode ir até 3.10.x na lista.  
![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/training-pycharm-ide.png)
   + Se você tiver o Anaconda instalado, você pode configurar um ambiente virtual usando `conda`, da seguinte forma:
     + Abra uma interface de terminal de prompt do Anaconda.
     + Crie e ative um novo ambiente `conda` usando uma versão Python 3.7 ou superior, até 3.10x. O exemplo de código a seguir mostra como criar um ambiente `conda` usando o Python versão 3.10.

       ```
       conda create -n sagemaker_jobs_quick_start python=3.10 pip
       conda activate sagemaker_jobs_quick_start
       ```

1. Instale o SageMaker SDK do Python.

   Para empacotar o código do seu IDE preferido, você deve ter um ambiente virtual configurado usando Python 3.7 ou superior, até 3,10x. Você também precisa de uma imagem de contêiner compatível. Instale o SDK do SageMaker Python usando o exemplo de código a seguir.

   ```
   pip install sagemaker
   ```

1. Encapsule o código dentro do decorador @remote. O SDK do SageMaker Python interpretará automaticamente a função do seu código e a executará como um SageMaker trabalho de treinamento. Os exemplos de código a seguir mostram como importar as bibliotecas necessárias, configurar uma SageMaker sessão e anotar uma função com o decorador @remote.

   Você pode executar o código fornecendo diretamente as dependências necessárias ou usando dependências do ambiente `conda` ativo.
   + Para fornecer as dependências diretamente, faça o seguinte:
     + Crie um arquivo `requirements.txt` no diretório de trabalho em que o código reside.
     + Adicione todas as dependências necessárias para o código junto com a SageMaker biblioteca. A seção a seguir fornece um exemplo mínimo de código para o `requirements.txt`, para a função `divide` do exemplo.

       ```
       sagemaker
       ```
     + Execute o código com o decorador @remote aprovando o arquivo de dependências. No exemplo de código a seguir, `The IAM role name` substitua por um ARN de função AWS Identity and Access Management (IAM) que você gostaria de usar SageMaker para executar seu trabalho.

       ```
       import boto3
       import sagemaker
       from sagemaker.remote_function import remote
       
       sm_session = sagemaker.Session(boto_session=boto3.session.Session(region_name="us-west-2"))
       settings = dict(
           sagemaker_session=sm_session,
           role=<The IAM role name>,
           instance_type="ml.m5.xlarge",
           dependencies='./requirements.txt'
       )
       
       @remote(**settings)
       def divide(x, y):
           return x / y
       
       
       if __name__ == "__main__":
           print(divide(2, 3.0))
       ```
   + Para usar dependências do ambiente `conda` ativo, use o valor `auto_capture` do parâmetro `dependencies`, conforme mostrado a seguir.

     ```
     import boto3
     import sagemaker
     from sagemaker.remote_function import remote
     
     sm_session = sagemaker.Session(boto_session=boto3.session.Session(region_name="us-west-2"))
     settings = dict(
         sagemaker_session=sm_session,
         role=<The IAM role name>,
         instance_type="ml.m5.xlarge",
         dependencies="auto_capture"
     )
     
     @remote(**settings)
     def divide(x, y):
         return x / y
     
     
     if __name__ == "__main__":
         print(divide(2, 3.0))
     ```
**nota**  
Você também pode implementar o código anterior em um notebook Jupyter. PyCharm A Professional Edition oferece suporte nativo ao Jupyter. Para obter mais orientações, consulte o [suporte do notebook Jupyter](https://www.jetbrains.com/help/pycharm/ipython-notebook-support.html) na documentação PyCharm.