O blog da AWS

Trazendo sua própria imagem de contêiner personalizada para notebooks do Amazon SageMaker Studio

Por Stefan Natu, Huong Nguyen e Jaipreet Singh

 

O Amazon SageMaker Studio é o primeiro ambiente de desenvolvimento (IDE) totalmente integrado para aprendizado de máquina (ML). O SageMaker Studio permite que cientistas de dados criem notebooks Studio para explorar dados, criar modelos, lançar trabalhos de treinamento do Amazon SageMaker e implantar endpoints hospedados. Os notebooks do Studio vêm com um conjunto de imagens de contêineres pré-criadas, que contêm o SDK do Amazon SageMaker Python e a versão mais recente do runtime ou kernel do IPython. Com esse novo recurso, você pode trazer suas próprias imagens personalizadas para os notebooks do Amazon SageMaker. Essas imagens estão disponíveis para todos os usuários autenticados no domínio. Neste post, compartilhamos como trazer uma imagem de contêiner personalizada para notebooks SageMaker Studio.

Desenvolvedores e cientistas de dados podem exigir imagens personalizadas para vários casos de uso diferentes:

  • Acesso a versões específicas ou mais recentes de frameworks de ML populares, como TensorFlow, MXNet, PyTorch ou outros.
  • Trazer códigos personalizados ou algoritmos desenvolvidos localmente para notebooks do Studio para iteração rápida e treinamento de modelos.
  • Acesso a data lakes ou dados em ambientes on-premises por meio de APIs, e os administradores precisam incluir os drivers correspondentes na imagem.
  • Acesso a um runtime de backend, também chamado de kernel, diferente do IPython, como R, Julia ou outros. Você também pode usar a abordagem descrita neste post para instalar um kernel personaliz­ado.

Em grandes empresas, os administradores da plataforma de ML geralmente precisam garantir que todos os pacotes e códigos de terceiros sejam pré-aprovados pelas equipes de segurança para uso e não baixados diretamente da Internet. Um fluxo de trabalho comum é que a equipe de plataforma de ML aprove um conjunto de pacotes e frameworks para uso, crie um contêiner personalizado usando esses pacotes, teste o contêiner quanto a vulnerabilidades e envie a imagem aprovada em um registro de contêiner privado, como o Amazon Elastic Container Registry (Amazon ECR). Agora, as equipes de plataforma de ML podem anexar diretamente imagens aprovadas ao domínio do Studio (consulte o diagrama de fluxo de trabalho a seguir). Você pode simplesmente selecionar a imagem personalizada aprovada de sua escolha no Studio. Em seguida, você pode trabalhar com a imagem personalizada no notebook do Studio. Com esta nova funcionalidade, um único domínio Studio pode conter até 30 imagens personalizadas, com a opção de adicionar uma nova versão ou excluir imagens conforme necessário.

 

 

Agora vamos examinar como você pode trazer uma imagem personalizada de contêiner para notebooks SageMaker Studio usando esse recurso. Embora demonstremos a abordagem padrão pela internet, incluímos detalhes sobre como você pode modificar isso para funcionar em uma Amazon Virtual Private Cloud (Amazon VPC) privada.

 

Pré-requisitos

Antes de começar, você precisa ter certeza de que atende aos seguintes pré-requisitos:

  • Tenha uma conta da AWS.
  • Certifique-se de que a role de execução usada para acessar o Amazon SageMaker tenha as seguintes permissões do AWS Identity and Access Management (IAM), que permitem que o SageMaker Studio crie um repositório no Amazon ECR com o prefixo smstudio, e conceda permissões para enviar e extrair imagens deste repositório. Para usar um repositório existente, substitua o Resource pelo ARN do repositório. Para criar a imagem de contêiner, você pode usar um cliente Docker local ou criar a imagem diretamente a partir do SageMaker Studio, o que demonstramos aqui. Para criar um repositório no Amazon ECR, o SageMaker Studio usa o AWS CodeBuild e você também precisa incluir as permissões do CodeBuild mostradas abaixo.
{

            "Effect": "Allow",

            "Action": [

                "ecr:CreateRepository",

                "ecr:BatchGetImage",

                "ecr:CompleteLayerUpload",

                "ecr:DescribeImages",

                "ecr:DescribeRepositories",

                "ecr:UploadLayerPart",

                "ecr:ListImages",

                "ecr:InitiateLayerUpload",

                "ecr:BatchCheckLayerAvailability",

                "ecr:GetDownloadUrlForLayer",

                "ecr:PutImage"

            ],

            "Resource": "arn:aws:ecr:*:*:repository/smstudio*"

        },

        {

            "Effect": "Allow",

            "Action": "ecr:GetAuthorizationToken",

            "Resource": "*"

           }

{

            "Effect": "Allow",

            "Action": [

                "codebuild:DeleteProject",

                "codebuild:CreateProject",

                "codebuild:BatchGetBuilds",

                "codebuild:StartBuild"

            ],

            "Resource": "arn:aws:codebuild:*:*:project/sagemaker-studio*"

}

{

            "Effect": "Allow",

            "Action": "iam:PassRole",

            "Resource": "arn:aws:iam::*:role/*",

            "Condition": {

                "StringLikeIfExists": {

                    "iam:PassedToService": "codebuild.amazonaws.com"

                }

            }

}
{
  "Version": "2012-10-17",

  "Statement": [

    {

      "Effect": "Allow",

      "Principal": {

        "Service": [

          "codebuild.amazonaws.com"

        ]

      },

      "Action": "sts:AssumeRole"

    }

  ]

}

Se você deseja usar sua VPC privada para trazer seu contêiner personalizado com segurança, você também precisa do seguinte:

Para configurar esses recursos, consulte Protegendo a conectividade do Amazon SageMaker Studio usando uma VPC privada e o repositório do GitHub associado.

 

Criando seu Dockerfile

Para demonstrar a necessidade comum dos cientistas de dados de experimentar frameworks mais recentes, usamos o seguinte Dockerfile, que usa a versão mais recente do TensorFlow 2.3 como a imagem base. Você pode substituir este Dockerfile por um Dockerfile de sua escolha. Atualmente, o SageMaker Studio oferece suporte a várias imagens básicas, como Ubuntu, Amazon Linux 2 e outras. O Dockerfile instala o runtime do IPython necessário para executar notebooks Jupyter e instala o Amazon SageMaker Python SDK e o boto3.

Além dos notebooks, cientistas de dados e engenheiros de ML muitas vezes iteram e experimentam seus laptops locais usando vários IDEs populares, como Visual Studio Code ou PyCharm. Você pode querer trazer esses scripts para a nuvem para treinamento escalável ou processamento de dados. Você pode incluir esses scripts como parte do contêiner do Docker para que eles fiquem visíveis no armazenamento local no SageMaker Studio. No Dockerfile a seguir, copiamos o script train.py , que é um script base para treinar um modelo simples de deep learning com o dataset MNIST. Você pode substituir este script por seus próprios scripts ou pacotes contendo seu código.

FROM tensorflow/tensorflow:2.3.0

RUN apt-get update

RUN apt-get install -y git

RUN pip install --upgrade pip

RUN pip install ipykernel && \

    python -m ipykernel install --sys-prefix && \

    pip install --quiet --no-cache-dir \

    'boto3>1.0<2.0' \

    'sagemaker>2.0<3.0'

       

COPY train.py /root/train.py #Replace with your own custom scripts or packages

O código abaixo é o script train.py:

import tensorflow as tf

import os

       

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()

x_train, x_test = x_train / 255.0, x_test / 255.0

       

model = tf.keras.models.Sequential([

  tf.keras.layers.Flatten(input_shape=(28, 28)),

  tf.keras.layers.Dense(128, activation='relu'),

  tf.keras.layers.Dropout(0.2),

  tf.keras.layers.Dense(10, activation='softmax')

])

model.compile(optimizer='adam',

              loss='sparse_categorical_crossentropy',

              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=1)

model.evaluate(x_test, y_test)

Em vez de um script personalizado, você também pode incluir outros arquivos, como arquivos Python que acessam segredos de cliente e variáveis de ambiente por meio do AWS Secrets Manager ou do AWS Systems Manager Parameter Store, arquivos de configuração para habilitar conexões com repositórios PyPI privados ou outras ferramentas de gerenciamento de pacotes. Embora você possa copiar o script usando a imagem personalizada, quaisquer comandos ENTRYPOINT ou CMD no Dockerfile não são executados.

 

Configurando sua pasta de instalação

Você precisa criar uma pasta em sua máquina local e adicionar os seguintes arquivos nessa pasta:

  • O Dockerfile que você criou na etapa anterior
  • Um arquivo chamado app-image-config-input.json com o seguinte conteúdo:
"AppImageConfigName": "custom-tf2",

    "KernelGatewayImageConfig": {

        "KernelSpecs": [

            {

                "Name": "python3",

                "DisplayName": "Python 3"

            }

        ],

        "FileSystemConfig": {

            "MountPath": "/root/data",

            "DefaultUid": 0,

            "DefaultGid": 0

        }

    }

}

Definimos o kernel de backend para este Dockerfile como um kernel IPython e fornecemos um caminho de montagem ao Amazon Elastic File System (Amazon EFS). O Amazon SageMaker reconhece kernels conforme definido pelo Jupyter. Por exemplo, para um kernel R, defina Name no código anterior como ir. Você precisa garantir que o Uid, o Gid e o nome do kernel correspondam às especificações do kernelspecs e às informações do usuário na imagem do Docker. Para extrair esses valores, consulte este documento.

  • Crie um arquivo chamado default-user-settings.json com o seguinte conteúdo. Se você estiver adicionando várias imagens personalizadas, basta adicionar à lista de CustomImages.
{

  "DefaultUserSettings": {

    "KernelGatewayAppSettings": {

      "CustomImages": [

          {

                   "ImageName": "tf2kernel",

                   "AppImageConfigName": "custom-tf2"

                }

            ]

        }

    }

}

 

Criando e anexando a imagem ao seu domínio Studio

Se você tiver um domínio existente, basta atualizar o domínio com a nova imagem. Nesta seção, demonstramos como os usuários existentes do Studio podem anexar imagens. Para obter instruções sobre como integrar um novo usuário, consulte Inicializando o Amazon SageMaker Studio usando o IAM.

Primeiro, usamos a CLI do SageMaker Studio Docker Build para criar e enviar o Dockerfile para o Amazon ECR. Observe que você pode usar outros métodos para enviar contêineres para o ECR, como seu cliente de Docker local e a AWS CLI.

  1. Faça login no Studio usando seu perfil de usuário.
  2. Carregue seu Dockerfile e qualquer outro código ou dependências que você deseja copiar em seu contêiner para o seu domínio Studio.
  3. Navegue até a pasta que contém o Dockerfile.
  4. Em uma janela de terminal ou em um notebook execute:
!pip install sagemaker-studio-image-build

5. Exporte uma variável chamada IMAGE_NAME e defina-a para o valor especificado em default-user-settings.json

sm-docker build . --repository smstudio-custom:IMAGE_NAME

6. Se você deseja usar um repositório diferente, substitua smstudio-custom no código anterior pelo nome do repositório.

O SageMaker Studio cria a imagem do Docker para você e envia a imagem para o Amazon ECR em um repositório chamado smstudio-custom com tags de nome apropriado. Para personalizar isso ainda mais, como por exemplo fornecendo um caminho detalhado a arquivos ou outras opções, consulte Usando a CLI do Amazon SageMaker Studio Image Build para criar imagens de contêiner a partir de seus notebooks Studio. Para que o comando pip acima funcione em um ambiente VPC privado, você precisa de uma rota para a Internet ou acesso a esse pacote em seu repositório privado.

7. Na pasta de instalação anterior, crie um novo arquivo chamado create-and-update-image.sh:

ACCOUNT_ID=AWS ACCT ID #Substitua com o ID de sua conta AWS

REGION=us-east-2 #Substitua com sua região

DOMAINID=d-####### #Substitua com o nome do domínio do seu SageMaker Studio

IMAGE_NAME=tf2kernel #Substitua com o nome da sua imagem




# Usando com o SageMaker Studio

## Crie a imagem do SageMaker com a imagem no ECR (modifique o nome da imagem como requerido)

ROLE_ARN='The Execution Role ARN for the execution role you want to use'




aws --region ${REGION} sagemaker create-image \

    --image-name ${IMAGE_NAME} \

    --role-arn ${ROLE_ARN}




aws --region ${REGION} sagemaker create-image-version \

    --image-name ${IMAGE_NAME} \

    --base-image "${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}"

   

## Crie o AppImageConfig para esta imagem (modifique o AppImageConfigName e KernelSpecs no app-image-config-input.json conforme necessário)

aws --region ${REGION} sagemaker create-app-image-config --cli-input-json file://app-image-config-input.json




## Atualize o domínio, provendo a imagem e AppImageConfig

aws --region ${REGION} sagemaker update-domain --domain-id ${DOMAINID} --cli-input-json file://default-user-settings.json

Consulte a AWS CLI para ler mais sobre os argumentos que você pode passar à API create-image. Para verificar o status, navegue até o console do Amazon SageMaker e escolha o Amazon SageMaker Studio no painel de navegação.

 

Anexar imagens usando a console do Studio

Você também pode executar a etapa final de anexar a imagem ao domínio Studio por meio da console AWS. Nesse caso, a console gerenciará a criação da versão da imagem e da imagem e atualizará o domínio com a imagem anexada.

  1. Na console do Amazon SageMaker, escolha Amazon SageMaker Studio.

Na página SageMaker Studio Control Panel, você pode ver que o domínio Studio foi provisionado, juntamente com todos os perfis de usuário que você criou.

2. Escolha Attach image.

 

 

3. Selecione se deseja anexar uma imagem nova ou pré-existente.

a. Se você selecionar Existing image, escolha uma imagem no armazenamento de imagens do Amazon SageMaker.

b. Se você selecionar New image, forneça o caminho do registry do Amazon ECR para sua imagem Docker. O caminho precisa estar na mesma região que o domínio do Studio. O repositório ECR também precisa estar na mesma conta que o domínio do Studio ou as permissões entre contas para o Studio precisam estar habilitadas.

4. Escolha Next.

 

 

5. Em Image name, insira um nome.

6. Em Image display name, insira um nome descritivo.

7. Em Description, insira uma definição de rótulo.

8. Para a role do IAM, escolha a role do IAM exigida pelo Amazon SageMaker para anexar imagens do Amazon ECR às imagens do Amazon SageMaker em seu nome.

9. Além disso, você pode colocar tags na sua imagem.

10. Escolha Next.

 

 

11. Em Kernel name, insira Python 3.

12. Escolha Submit.

 

 

A caixa de seleção verde indica que a imagem foi anexada com sucesso ao domínio.

 

 

O armazenamento de imagens do Amazon SageMaker versiona automaticamente suas imagens. Você pode selecionar uma imagem pré-anexada e escolher Desanexar para desanexar a imagem e todas suas versões ou escolher Anexar imagem para anexar uma nova versão. Não há limite para o número de versões por imagem ou a capacidade de desanexar imagens.

 

Experiência do usuário com uma imagem personalizada

Vamos agora analisar a experiência do usuário para um cientista de dados no Studio.

  1. Faça login no Studio usando seu perfil de usuário.
  2. Para iniciar uma nova atividade, escolha Launcher.
  3. Em Select a SageMaker image to launch your activity, escolha tf2kernel.

 

 

4. Escolha o ícone Notebook para abrir um novo notebook com o kernel personalizado.

O kernel do notebook leva alguns minutos para inicializar e tudo está pronto você usar!

 

Testando seu contêiner personalizado no notebook

Quando o kernel estiver instalado e em execução, você pode executar o código no notebook. Primeiro, vamos testar se a versão correta do TensorFlow especificada no Dockerfile está disponível para uso. Na captura de tela a seguir, podemos ver que o notebook está usando o tf2kernel que acabamos de lançar.

 

 

Os notebooks do Amazon SageMaker também exibem o uso local da CPU e da memória.

Em seguida, vamos experimentar o script de treinamento personalizado diretamente no notebook. Copie o script de treinamento para uma célula de notebook e execute-o. O script baixa o dataset mnist com o utilitário tf.keras.datasets, divide os dados em datasets de treinamento e teste, define um algoritmo personalizado de rede neural profunda, treina o algoritmo com os dados de treinamento e testa o algoritmo com o dataset de teste.

 

 

Para experimentar com o framework do TensorFlow 2.3, talvez você queira testar APIs recém-lançadas, como os utilitários de pré-processamento no Keras. Na captura de tela a seguir, importamos a biblioteca keras.layers.experimental lançada no TensorFlow 2.3, que contém APIs mais recentes para pré-processamento de dados. Carregamos uma dessas APIs e executamos novamente o script no notebook.

 

 

O Amazon SageMaker também atualiza dinamicamente o uso da CPU e da memória conforme o código é executado. Ao trazer seu contêiner personalizado e scripts de treinamento, esse recurso permite que você experimente scripts e algoritmos de treinamento personalizados diretamente no notebook do Amazon SageMaker. Quando estiver satisfeito com a experimentação no notebook do Studio, você pode iniciar um trabalho de treinamento.

E quanto aos arquivos Python ou arquivos personalizados que você incluiu com o Dockerfile usando o comando COPY? O SageMaker Studio monta o sistema de arquivos no Amazon EFS no caminho fornecido no app-image-config-input.json, que definimos como root/data. Para evitar que o Studio sobrescreva qualquer arquivo personalizados que você deseja incluir, o comando COPY carrega o arquivo train.py no caminho /root. Para acessar esse arquivo, abra um terminal ou notebook e execute o código:

! cat /root/train.py

Você deve ver uma saída como mostrado na captura de tela abaixo.

 

 

O arquivo train.py está no local especificado.

 

Logging de métricas no CloudWatch

O SageMaker Studio também publica métricas do kernel no Amazon CloudWatch, que você pode usar para troubleshooting. As métricas são capturadas sob o namespace /aws/sagemaker/studio.

Para acessar os logs, no console do CloudWatch, escolha CloudWatch Logs. Na página Log groups, insira o namespace para ver os logs associados ao servidor Jupyter e ao gateway do kernel.

 

 

Desanexando uma imagem ou versão

Você pode desanexar uma imagem ou uma versão de imagem do domínio do Studio se ela não for mais suportada.

Para desanexar uma imagem e todas as versões, selecione a imagem na tabela Custom images attached to domain e escolha Detach.

 

 

Você tem a opção de excluir também a imagem e todas as versões, o que não afeta a imagem no Amazon ECR.

 

 

Para desanexar uma versão de imagem, escolha a imagem. Na página Image details, selecione a versão da imagem (ou múltiplas versões) da tabela Image versions attached to domain e escolha Detach. Você vê um aviso e opções semelhantes como no fluxo anterior.

 

Conclusão

O SageMaker Studio permite colaborar, experimentar, treinar e implantar modelos de ML de forma simplificada. Para isso, os cientistas de dados geralmente exigem acesso aos mais recentes frameworks de ML, scripts personalizados, pacotes de repositórios de código públicos e privados e ferramentas de gerenciamento de pacotes. Agora você pode criar imagens personalizadas contendo todo o código relevante e iniciá-las usando notebooks do Studio. Essas imagens estarão disponíveis para todos os usuários no domínio Studio. Você também pode usar esse recurso para experimentar outras linguagens populares e runtimes além do Python, como R, Julia e Scala. Arquivos de exemplo estão disponíveis no repositório do GitHub. Para obter mais informações sobre esse recurso, consulte Traga sua própria imagem ao SageMaker.

 

Este artigo foi traduzido do Blog da AWS em Inglês.

 

Sobre os Autores

Stefan Natu é um Sr. Especialista em aprendizado de máquina na AWS. Ele está focado em ajudar os clientes de serviços financeiros a criar soluções completas de aprendizado de máquina na AWS. Em seu tempo livre, ele gosta de ler blogs de aprendizado de máquina, tocar guitarra e explorar a cena gastronômica na cidade de Nova York.

 

 

 

Jaipreet Singh é engenheiro sênior de software na equipe do Amazon SageMaker Studio. Ele trabalha no Amazon SageMaker desde sua criação em 2017 e contribuiu para vários projetos de código aberto do Projeto Jupyter. Em seu tempo livre, ele gosta de caminhadas e esqui no noroeste do Pacífico.

 

 

 

 

Huong Nguyen é um Ir. Gerente de produto da AWS. Ela está liderando a experiência do usuário para o SageMaker Studio. Ela tem 13 anos de experiência na criação de produtos obcecados pelo cliente e orientados por dados para espaços empresariais e de consumo. Em seu tempo livre, ela gosta de ler, estar na natureza e passar tempo com sua família.

 

 

 

Revisor

Marcelo Cunha é um arquiteto de soluções da AWS especialista em AI/ML. Em sua função, ele ajuda os clientes a criar soluções de ML para resolver os seus desafios de negócio utilizando a plataforma AWS. De uma família de médicos e profissionais da saúde, ele também tem interesse em aplicações de ML nesse setor.