Temos o prazer de anunciar dois novos recursos em Estúdio Amazon SageMaker que irá acelerar o desenvolvimento iterativo para profissionais de aprendizado de máquina (ML): Modo Local e suporte Docker. O desenvolvimento de modelos de ML geralmente envolve ciclos de iteração lentos, à medida que os desenvolvedores alternam entre codificação, treinamento e implantação. Cada etapa requer a espera pela inicialização dos recursos de computação remota, o que atrasa a validação das implementações e a obtenção de feedback sobre as alterações.

Com o Modo Local, os desenvolvedores agora podem treinar e testar modelos, depurar código e validar pipelines de ponta a ponta diretamente em sua instância de notebook SageMaker Studio, sem a necessidade de ativar recursos de computação remotos. Isso reduz o ciclo de iteração de minutos para segundos, aumentando a produtividade do desenvolvedor. O suporte Docker nos notebooks SageMaker Studio permite que os desenvolvedores criem contêineres Docker sem esforço e acessem contêineres pré-construídos, fornecendo um ambiente de desenvolvimento consistente para toda a equipe e evitando configuração demorada e gerenciamento de dependências.

O modo local e o suporte ao Docker oferecem um fluxo de trabalho simplificado para validar alterações de código e criar protótipos de modelos usando contêineres locais executados em um notebook SageMaker Studio

instância. Nesta postagem, orientamos você na configuração do modo local no SageMaker Studio, na execução de um exemplo de trabalho de treinamento e na implantação do modelo em um Amazon Sage Maker endpoint de um notebook SageMaker Studio.

Modo local do SageMaker Studio

O SageMaker Studio apresenta o modo local, permitindo que você execute treinamento, inferência, transformação em lote e trabalhos de processamento do SageMaker diretamente em instâncias de notebook JupyterLab, Code Editor ou SageMaker Studio Classic sem exigir recursos de computação remota. Os benefícios de usar o Modo Local incluem:

• Validação e teste instantâneos de fluxos de trabalho diretamente em ambientes de desenvolvimento integrados (IDEs)
• Iteração mais rápida por meio de execuções locais para trabalhos de menor escala para inspecionar resultados e identificar problemas antecipadamente
• Maior eficiência de desenvolvimento e depuração, eliminando a espera por trabalhos de treinamento remoto
• Feedback imediato sobre alterações de código antes de executar trabalhos completos na nuvem

A figura a seguir ilustra o fluxo de trabalho usando o Modo Local no SageMaker.

Para usar o modo local, defina instance_type='local' ao executar trabalhos do SageMaker Python SDK, como treinamento e inferência. Isso os executará nas instâncias usadas pelos IDEs do SageMaker Studio, em vez de provisionar recursos de nuvem.

Embora certos recursos, como treinamento distribuído, estejam disponíveis apenas na nuvem, o Modo Local elimina a necessidade de alternar contextos para iterações rápidas. Quando estiver pronto para aproveitar todo o poder e escala do SageMaker, você poderá executar seu fluxo de trabalho perfeitamente na nuvem.

Suporte Docker no SageMaker Studio

O SageMaker Studio agora também permite criar e executar contêineres Docker localmente em sua instância de notebook do SageMaker Studio. Este novo recurso permite construir e validar imagens Docker no SageMaker Studio antes de usá-las para treinamento e inferência do SageMaker.

O diagrama a seguir ilustra a arquitetura de orquestração Docker de alto nível no SageMaker Studio.

Com suporte Docker no SageMaker Studio, você pode:

• Crie contêineres Docker com modelos integrados e dependências diretamente no SageMaker Studio
• Elimine a necessidade de processos de construção externos do Docker para simplificar a criação de imagens
• Execute contêineres localmente para validar a funcionalidade antes de implantar modelos na produção
• Reutilize contêineres locais ao implantar no SageMaker para treinamento e hospedagem

Embora alguns recursos avançados do Docker, como redes personalizadas e de vários contêineres, não sejam suportados no momento desta redação, a funcionalidade principal de criação e execução está disponível para acelerar o desenvolvimento de contêineres para fluxos de trabalho de trazer seu próprio contêiner (BYOC).

Pré-requisitos

Para usar o Modo Local em aplicativos SageMaker Studio, você deve atender aos seguintes pré-requisitos:

• Para extrair imagens de Registro do Amazon Elastic Container (Amazon ECR), a conta que hospeda a imagem ECR deve fornecer permissão de acesso ao usuário Identidade e Acesso Gestão (IAM). A função do domínio também deve permitir acesso ao Amazon ECR.
• Para ativar os recursos do modo local e do Docker, você deve definir o EnableDockerAccess parâmetro como verdadeiro para o domínio DockerSettings usando o Interface de linha de comando da AWS (AWS CLI). Isso permite que os usuários no domínio usem os recursos do modo local e do Docker. Por padrão, o Modo Local e o Docker estão desabilitados no SageMaker Studio. Todos os aplicativos SageMaker Studio existentes precisarão ser reiniciados para que a atualização do serviço Docker entre em vigor. A seguir está um exemplo de comando da AWS CLI para atualizar um domínio do SageMaker Studio:

aws sagemaker --region <REGION> 
update-domain --domain-id <DOMAIN-ID> 
--domain-settings-for-update '{"DockerSettings": {"EnableDockerAccess": "ENABLED"}}'

• Você precisa atualizar a função IAM do SageMaker para poder enviar imagens do Docker para o Amazon ECR:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ecr:CompleteLayerUpload",
        "ecr:UploadLayerPart",
        "ecr:InitiateLayerUpload",
        "ecr:BatchCheckLayerAvailability",
        "ecr:PutImage"
      ],
      "Resource": "arn:aws:ecr:us-east-2:123456789012:repository/<repositoryname>"
    },
    {
      "Effect": "Allow",
      "Action": "ecr:GetAuthorizationToken",
      "Resource": "*"
    }
  ]
}

Execute arquivos Python em espaços do SageMaker Studio usando o modo local

SageMaker Studio JupyterLab e Code Editor (baseado em Code-OSS, Visual Studio Code – código aberto), estende o SageMaker Studio para que você possa escrever, testar, depurar e executar análises e código de ML usando o popular IDE leve. Para obter mais detalhes sobre como começar a usar os IDEs do SageMaker Studio, consulte Aumente a produtividade no Amazon SageMaker Studio: apresentando JupyterLab Spaces e ferramentas generativas de IA e Novo – Editor de código, baseado em Code-OSS VS Code Open Source agora disponível no Amazon SageMaker Studio. Conclua as seguintes etapas:

• Crie um novo terminal. 
• Instale o Docker CLI e o plugin Docker Compose seguindo as instruções a seguir GitHub repo. Se os comandos encadeados falharem, execute os comandos um de cada vez.

Você deve atualizar o SageMaker SDK para a versão mais recente.

• Execute pip install sagemaker -Uq no terminal.

Somente para o Editor de Código, você precisa definir o ambiente Python para ser executado no terminal atual.

• No Editor de Código, na guia Menu Arquivo¸ escolher Preferencias e Configurações.

• Pesquise e selecione Terminal: Executar no diretório do arquivo.

• No Code Editor ou JupyterLab, abra o scikit_learn_script_mode_local_training_and_serving pasta e execute o scikit_learn_script_mode_local_training_and_serving.py arquivo.

Você pode executar o script escolhendo Execute no Code Editor ou usando a CLI em um terminal JupyterLab. Você poderá ver como o modelo é treinado localmente. Em seguida, você implanta o modelo em um endpoint do SageMaker localmente e calcula a raiz do erro quadrático médio (RMSE).

Simule treinamento e inferência no SageMaker Studio Classic usando o modo local

Você também pode usar um notebook no SageMaker Studio Classic para executar um trabalho de treinamento em pequena escala CIFAR10 usando o modo local, implante o modelo localmente e execute inferência.

Configure seu caderno

Para configurar o notebook, execute as seguintes etapas:

• Abra o SageMaker Studio Classic e clone o seguinte GitHub repo.

• Abra o pytorch_local_mode_cifar10.ipynb notebook in blog/pytorch_cnn_cifar10.

• Escolha Imagem, escolha PyTorch 2.1.0 Python 3.10 CPU Optimized.

Confirme se seu notebook mostra a instância correta e a seleção de kernel.

• Abra um terminal escolhendo Terminal de Lançamento na imagem atual do SageMaker.

• Instale o Docker CLI e o plugin Docker Compose seguindo as instruções a seguir GitHub repo.

Como você está usando o Docker do SageMaker Studio Classic, remova sudo ao executar comandos porque o terminal já é executado como superusuário. Para o SageMaker Studio Classic, os comandos de instalação dependem do sistema operacional da imagem do aplicativo SageMaker Studio. Por exemplo, as imagens de estrutura baseadas em DLC são baseadas no Ubuntu, no qual as instruções a seguir funcionariam. No entanto, para uma imagem baseada em Debian como DataScience Images, você deve seguir as instruções a seguir GitHub repo. Se os comandos encadeados falharem, execute os comandos um de cada vez. Você deverá ver a versão do Docker exibida.

• Deixe a janela do terminal aberta, volte para o notebook e comece a executá-lo célula por célula.

Certifique-se de executar a célula com pip install -U sagemaker então você está usando a versão mais recente do SageMaker Python SDK.

Treinamento local

Ao começar a executar o trabalho de treinamento local do SageMaker, você verá as seguintes linhas de registro:

INFO:sagemaker.local.image:'Docker Compose' found using Docker CLI.
INFO:sagemaker.local.local_session:Starting training job

Isso indica que o treinamento foi executado localmente usando Docker.

Seja paciente enquanto o pytorch-training:2.1-cpu-py310 A imagem do Docker é extraída. Devido ao seu grande tamanho (5.2 GB), pode demorar alguns minutos.

As imagens Docker serão armazenadas no volume raiz da instância do aplicativo SageMaker Studio, que não é acessível aos usuários finais. A única maneira de acessar e interagir com imagens Docker é por meio das operações expostas da API Docker.

Do ponto de vista da confidencialidade do usuário, a plataforma SageMaker Studio nunca acessa ou armazena imagens específicas do usuário.

Quando o treinamento for concluído, você poderá ver as seguintes linhas de registro de sucesso:

8zlz1zbfta-sagemaker-local exited with code 0
Aborting on container exit...
Container 8zlz1zbfta-sagemaker-local  Stopping
Container 8zlz1zbfta-sagemaker-local  Stopped
INFO:sagemaker.local.image:===== Job Complete =====

Inferência local

Conclua as seguintes etapas:

• Implante o endpoint SageMaker usando o modo local do SageMaker.

Seja paciente enquanto o pytorch-inference:2.1-cpu-py310 A imagem do Docker é extraída. Devido ao seu grande tamanho (4.32 GB), pode demorar alguns minutos.

• Invoque o endpoint SageMaker implantado localmente usando as imagens de teste.

Você poderá ver as classes previstas: sapo, navio, carro e avião:

Predicted:  frog ship  car plane

• Como o endpoint do SageMaker Local ainda está ativo, navegue de volta para a janela do terminal aberta e liste os contêineres em execução:

docker ps

Você poderá ver a corrida pytorch-inference:2.1-cpu-py310 contêiner que apoia o endpoint SageMaker.

• Para encerrar o endpoint local do SageMaker e parar o contêiner em execução, porque você só pode executar um endpoint local por vez, execute o código de limpeza.

• Para garantir que o contêiner do Docker esteja inativo, você pode navegar até a janela do terminal aberta, executar docker ps e certificar-se de que não há contêineres em execução.
• Se você vir um contêiner em execução, execute docker stop <CONTAINER_ID> para pará-lo.

Dicas para usar o modo local do SageMaker

Se você estiver usando o SageMaker pela primeira vez, consulte Treine modelos de aprendizado de máquina. Para saber mais sobre a implantação de modelos para inferência com o SageMaker, consulte Implantar modelos para inferência.

Tenha em mente as seguintes recomendações:

• Imprima arquivos e pastas de entrada e saída para entender o carregamento do conjunto de dados e do modelo
• Use 1–2 épocas e pequenos conjuntos de dados para testes rápidos
• Pré-instale dependências em um Dockerfile para otimizar a configuração do ambiente
• Isole o código de serialização em endpoints para depuração

Configurar a instalação do Docker como uma configuração de ciclo de vida

Você pode definir o processo de instalação do Docker como um script Lifecycle Configuration (LCC) para simplificar a configuração sempre que um novo espaço do SageMaker Studio é iniciado. LCCs são scripts que o SageMaker executa durante eventos como criação de espaço. Consulte o JupyterLabGenericName, Editor de códigoou SageMaker Estúdio Clássico Configuração LCC (usando docker instalar cli como referência) para saber mais.

Crie e teste imagens Docker personalizadas em espaços do SageMaker Studio

Nesta etapa, você instala o Docker dentro do espaço do aplicativo JupyterLab (ou Code Editor) e usa o Docker para construir, testar e publicar imagens personalizadas do Docker com espaços do SageMaker Studio. Os espaços são usados ​​para gerenciar as necessidades de armazenamento e recursos de alguns aplicativos do SageMaker Studio. Cada espaço tem um relacionamento 1:1 com uma instância de um aplicativo. Cada aplicativo compatível criado obtém seu próprio espaço. Para saber mais sobre os espaços SageMaker, consulte Aumente a produtividade no Amazon SageMaker Studio: apresentando JupyterLab Spaces e ferramentas generativas de IA. Certifique-se de provisionar um novo espaço com pelo menos 30 GB de armazenamento para permitir armazenamento suficiente para imagens e artefatos do Docker.

Instale o Docker dentro de um espaço

Para instalar o Docker CLI e o plug-in Docker Compose dentro de um espaço JupyterLab, execute os comandos a seguir GitHub repo. Estúdio SageMaker suporta apenas Docker versão 20.10.X.

Construir imagens Docker

Para confirmar se o Docker está instalado e funcionando dentro do seu espaço JupyterLab, execute o seguinte código:

# to verify docker service
sagemaker-user@default:~$ docker version
Client: Docker Engine - Community
Version:           24.0.7
API version:       1.41 (downgraded from 1.43)
Go version:        go1.20.10
Git commit:        afdd53b
Built:             Thu Oct 26 09:07:41 2023
OS/Arch:           linux/amd64
Context:           default

Server:
Engine:
Version:          20.10.25
API version:      1.41 (minimum version 1.12)
Go version:       go1.20.10
Git commit:       5df983c
Built:            Fri Oct 13 22:46:59 2023
OS/Arch:          linux/amd64
Experimental:     false
containerd:
Version:          1.7.2
GitCommit:        0cae528dd6cb557f7201036e9f43420650207b58
runc:
Version:          1.1.7
GitCommit:        f19387a6bec4944c770f7668ab51c4348d9c2f38
docker-init:
Version:          0.19.0
GitCommit:        de40ad0

Para construir uma imagem Docker personalizada dentro de um espaço JupyterLab (ou Code Editor), conclua as seguintes etapas:

• Crie um Dockerfile vazio:

touch Dockerfile

• Edite o Dockerfile com os seguintes comandos, que criam uma imagem de servidor web de flask simples a partir da imagem base python:3.10.13-bullseye hospedada em Hub do Docker:

# Use the specified Python base image
FROM python:3.10.13-bullseye

# Create a code dir
RUN mkdir /code/

# Set the working directory in the container
WORKDIR /code

# Upgrade pip and install required packages
RUN python3 -m pip install --upgrade pip && 
python3 -m pip install flask

# Copy the app.py file to the container
COPY app.py /code/

# Set the command to run the app
ENTRYPOINT ["python", "app.py"]

O código a seguir mostra o conteúdo de um arquivo de aplicativo flask de exemplo app.py:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def hello():
return jsonify({"response": "Hello"})

if __name__ == '__main__':
app.run(host='0.0.0.0', port=6006)

Além disso, você pode atualizar os comandos de referência do Dockerfile para incluir pacotes e artefatos de sua escolha.

• Crie uma imagem Docker usando o Dockerfile de referência:

docker build --network sagemaker --tag myflaskapp:v1 --file ./Dockerfile .

Incluir --network sagemaker em seu comando docker build, caso contrário a compilação falhará. Os contêineres não podem ser executados na ponte padrão do Docker ou em redes Docker personalizadas. Os contêineres são executados na mesma rede que o contêiner do aplicativo SageMaker Studio. Os usuários só podem usar o sagemaker para o nome da rede.

• Quando sua construção estiver concluída, valide se a imagem existe. Marque novamente a compilação como uma imagem ECR e envie. Se você tiver problemas de permissão, execute o comando aws ecr get-login-password… e tente executar novamente o push/pull do Docker:

sagemaker-user@default:~$ docker image list
REPOSITORY      TAG       IMAGE ID       CREATED          SIZE
myflaskapp      v1        d623f1538f20   27 minutes ago   489MB

sagemaker-user@default:~$ docker tag myflaskapp:v1 123456789012.dkr.ecr.us-east-2.amazonaws.com/myflaskapp:v1

sagemaker-user@default:~$ docker image list
REPOSITORY                                                  TAG       IMAGE ID       CREATED          SIZE
123456789012.dkr.ecr.us-east-2.amazonaws.com/myflaskapp     latest    d623f1538f20   27 minutes ago   489MB
myflaskapp                                                  v1        d623f1538f20   27 minutes ago   489MB

sagemaker-user@default:~$ aws ecr get-login-password --region region | docker login --username AWS --password-stdin aws_account_id.dkr.ecr.region.amazonaws.com

sagemaker-user@default:~$ docker push 123456789012.dkr.ecr.us-east-2.amazonaws.com/myflaskapp:latest

Testar imagens do Docker

Ter o Docker instalado dentro de um espaço JupyterLab (ou Code Editor) SageMaker Studio permite testar imagens Docker pré-construídas ou personalizadas como contêineres (ou aplicativos em contêineres). Nesta seção, usamos o comando docker run para provisionar contêineres Docker dentro de um espaço do SageMaker Studio para testar cargas de trabalho em contêineres, como serviços da web REST e scripts Python. Conclua as seguintes etapas:

sagemaker-user@default:~$ docker image list
REPOSITORY                                                  TAG       IMAGE ID       CREATED       SIZE

• Se a imagem de teste não existir, execute docker pull para extrair a imagem para sua máquina local:

sagemaker-user@default:~$ docker pull 123456789012.dkr.ecr.us-east-2.amazonaws.com/myflaskapp:v1

• Se você encontrar problemas de autenticação, execute os seguintes comandos:

aws ecr get-login-password --region region | docker login --username AWS --password-stdin aws_account_id.dkr.ecr.region.amazonaws.com

• Crie um contêiner para testar sua carga de trabalho:

docker run --network sagemaker 123456789012.dkr.ecr.us-east-2.amazonaws.com/myflaskapp:v1

Isso gera uma nova instância de contêiner e executa o aplicativo definido usando o ENTRYPOINT do Docker:

sagemaker-user@default:~$ docker run --network sagemaker 905418447590.dkr.ecr.us-east-2.amazonaws.com/myflaskapp:v1
* Serving Flask app 'app'
* Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:6006
* Running on http://169.255.255.2:6006

• Para testar se o seu endpoint da web está ativo, navegue até o URL https://<sagemaker-space-id>.studio.us-east-2.sagemaker.aws/jupyterlab/default/proxy/6006/.

Você deverá ver uma resposta JSON semelhante à captura de tela a seguir.

limpar

Para evitar cobranças desnecessárias, exclua os recursos que você criou ao executar os exemplos desta postagem:

1. Em seu domínio SageMaker Studio, escolha Estúdio Clássico no painel de navegação e escolha Dê um basta.
2. Em seu domínio SageMaker Studio, escolha JupyterLabGenericName or Editor de código no painel de navegação, escolha seu aplicativo e escolha Dê um basta.

Conclusão

O modo local do SageMaker Studio e o suporte ao Docker capacitam os desenvolvedores a criar, testar e iterar em implementações de ML com mais rapidez, sem sair do espaço de trabalho. Ao fornecer acesso instantâneo a ambientes e resultados de teste, esses recursos otimizam os fluxos de trabalho e melhoram a produtividade. Experimente o modelo local do SageMaker Studio e o suporte ao Docker usando nosso recurso de integração rápida, que permite criar um novo domínio para usuários únicos em poucos minutos. Compartilhe seus pensamentos na seção de comentários!

Sobre os autores

Shweta Singh é gerente de produto sênior na equipe da plataforma Amazon SageMaker Machine Learning (ML) na AWS, liderando o SageMaker Python SDK. Ela trabalhou em diversas funções de produtos na Amazon por mais de 5 anos. Ela possui bacharelado em Engenharia da Computação e mestrado em Engenharia Financeira, ambos pela Universidade de Nova York.

Eitan Sela é arquiteto de soluções especialista em IA generativa e aprendizado de máquina na AWS. Ele trabalha com clientes da AWS para fornecer orientação e assistência técnica, ajudando-os a criar e operar soluções de IA generativa e aprendizado de máquina na AWS. Em seu tempo livre, Eitan gosta de correr e ler os artigos mais recentes sobre aprendizado de máquina.

Pranav Murthy é arquiteto de soluções especialista em IA/ML na AWS. Ele se concentra em ajudar os clientes a criar, treinar, implantar e migrar cargas de trabalho de aprendizado de máquina (ML) para o SageMaker. Anteriormente, ele trabalhou na indústria de semicondutores desenvolvendo grandes modelos de visão computacional (CV) e processamento de linguagem natural (PNL) para melhorar processos de semicondutores usando técnicas de ML de última geração. Nas horas vagas, gosta de jogar xadrez e viajar. Você pode encontrar Pranav em LinkedIn.

Mufaddal Rohawala é engenheiro de software na AWS. Ele trabalha na biblioteca SageMaker Python SDK para Amazon SageMaker. Nas horas vagas gosta de viajar, atividades ao ar livre e é fã de futebol.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/accelerate-ml-workflows-with-amazon-sagemaker-studio-local-mode-and-docker-support/