Execute seu código local como um trabalho SageMaker de treinamento - Amazon SageMaker
Configure o ambiente

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

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 (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 recurso 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 SageMaker pelo uso de pools quentes gerenciados. Para ter mais informações, consulte Usando cache persistente.

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.

Tópicos

Configure o ambiente

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

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 no Amazon SageMaker Developer Guide.

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

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

    4. Selecione Open Studio Classic.

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

    6. Selecione Criar caderno na área de trabalho principal.

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

      Para ver uma lista das imagens disponíveis, consulte Imagens compatíveis do Docker.

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

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

    Para executar seu código ML local, primeiro crie um arquivo de dependências para instruir SageMaker 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.

    2. Renomeie untitled.txt para requirements.txt.

    3. Adicione todas as dependências necessárias para o código junto com a SageMaker biblioteca a. 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

    4. 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_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 Use a barra de ferramentas do notebook SageMaker Studio Classic no Amazon SageMaker Developer Guide.

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 SageMaker console em https://console.aws.amazon.com/sagemaker/.

    2. No painel de navegação esquerdo, escolha Caderno para expandir as opções.

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

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

    5. 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 .:+=@ _%- (hífen).

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

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

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

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

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

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

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

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

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

    2. No servidor Jupyter, selecione Novo no menu superior direito.

    3. Na seta para baixo, selecione conda_custom_python310. 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.

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

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

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

    3. Escolha Selecionar.

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

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

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

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

    8. 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_start.ipynb para exemplos de código adicionais.

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 SageMaker domínio seguindo as instruções na seção AWS CLI Pré-requisitos de Configurar pré-requisitos da Amazon. SageMaker

    • Crie uma função do IAM seguindo a seção Criar função de execução de SageMakerFunções.

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

      2. Escolha New Project (Novo projeto).

      3. Escolha Conda na seta para baixo em Novo ambiente usando.

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

        Novo ambiente do Python selecionado como Conda, com a versão do Python selecionada na versão 3.10.

    • Se você tiver o Anaconda instalado, você pode configurar um ambiente virtual usando conda, da seguinte forma:

      • Abra uma interface de terminal de mensagens 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

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

  4. 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 dentro de um notebook Jupyter. PyCharm A Professional Edition oferece suporte nativo ao Jupyter. Para obter mais orientações, consulte o suporte do notebook Jupyter na documentação PyCharm.