O blog da AWS

Trazendo seu próprio ambiente R para o Amazon SageMaker Studio

Por Nick Minaie e Sam Liu

 

O Amazon SageMaker Studio é o primeiro ambiente de desenvolvimento (IDE) totalmente integrado para aprendizado de máquina (ML). Com um único clique, cientistas de dados e desenvolvedores podem criar rapidamente notebooks do SageMaker Studio para explorar conjuntos de dados e criar modelos. Em 27 de outubro de 2020, a Amazon lançou um recurso de imagens personalizadas que permite que você inicie notebooks do SageMaker Studio com suas próprias imagens.

Os notebooks do SageMaker Studio, fornecem um conjunto de imagens integradas para estruturas populares de ciência de dados e estruturas de ML e opções de computação para executar notebooks. As imagens incorporadas do SageMaker contêm o SDK Python do Amazon SageMaker e a versão mais recente do processo de runtime de back-end, também chamado de kernel. Com o recurso de imagens personalizadas, você pode registrar imagens e kernels criados personalizados e disponibilizá-los para todos os usuários que compartilham um domínio do SageMaker Studio. Você pode começar clonando e estendendo um dos exemplos de arquivos Docker fornecidos pelo SageMaker ou criar suas próprias imagens do zero.

Este post se concentra em adicionar uma imagem R personalizada ao SageMaker Studio para que você possa criar e treinar seus modelos R com o SageMaker. Depois de anexar a imagem R personalizada, você pode selecionar a imagem no Studio e usar R para acessar os SDKs usando o pacote de reticulate no RStudio . Para obter mais informações sobre R no SageMaker, consulte Codificação com R em instâncias de notebook do Amazon SageMaker e Guia do usuário de R para o Amazon SageMaker.

Você pode criar imagens e versões de imagem e anexar versões de imagem ao seu domínio usando o Painel de Controle do SageMaker Studio, o AWS SDK para Python (Boto3) e a Interface da Linha de Comando da  AWS (AWS CLI) — para obter mais informações sobre comandos da CLI, consulte a Referência de comandos da CLI da AWS. Esta publicação explica os métodos da interface de usuário (UI) do console da AWS CLI e do SageMaker para anexar e desanexar imagens a um domínio do SageMaker Studio.

 

Pré-requisitos

Antes de começar, você precisa atender aos seguintes pré-requisitos:

Criando seu Dockerfile

Antes de anexar sua imagem ao Studio, você precisa criar uma imagem do Docker usando um Dockerfile. Você pode criar um Dockerfile personalizado usando imagens base ou outros repositórios de imagens do Docker, como o repositório Jupyter Docker-stacks, e usar ou revisar aqueles que se adequam à sua necessidade específica.

O SageMaker mantém um repositório de amostras de imagens Docker que você pode usar para casos de uso comuns (incluindo R, Julia, Scala e TensorFlow). Este repositório contém exemplos de imagens do Docker que são imagens personalizadas válidas para os aplicativos Jupyter Kernel Gateway no SageMaker Studio. Essas imagens personalizadas permitem que você traga seus próprios pacotes, arquivos e kernels para uso no SageMaker Studio.

Para obter mais informações sobre as especificações que se aplicam à imagem de contêiner representada por uma versão de imagem do SageMaker, consulte Especificações personalizadas da imagem do SageMaker.

Para este post, usamos o R Dockerfile. Este Dockerfile leva a imagem base do Python 3.6 e instala os pré-requisitos da biblioteca do sistema R, conda via Miniconda, e pacotes R e Python, que são utilizáveis via reticulate. Você pode criar um arquivo chamado Dockerfile usando o seguinte script e copiá-lo para sua pasta de instalação. Você pode personalizar este Dockerfile para seu caso de uso específico e instalar pacotes adicionais.

 

# This project is licensed under the terms of the Modified BSD License 
# (also known as New or Revised or 3-Clause BSD), as follows:

#    Copyright (c) 2001-2015, IPython Development Team
#    Copyright (c) 2015-, Jupyter Development Team

# All rights reserved.

FROM python:3.6

ARG NB_USER="sagemaker-user"
ARG NB_UID="1000"
ARG NB_GID="100"

# Setup the "sagemaker-user" user with root privileges.
RUN \
    apt-get update && \
    apt-get install -y sudo && \
    useradd -m -s /bin/bash -N -u $NB_UID $NB_USER && \
    chmod g+w /etc/passwd && \
    echo "${NB_USER}    ALL=(ALL)    NOPASSWD:    ALL" >> /etc/sudoers && \
    # Prevent apt-get cache from being persisted to this layer.
    rm -rf /var/lib/apt/lists/*

USER $NB_UID

# Make the default shell bash (vs "sh") for a better Jupyter terminal UX
ENV SHELL=/bin/bash \
    NB_USER=$NB_USER \
    NB_UID=$NB_UID \
    NB_GID=$NB_GID \
    HOME=/home/$NB_USER \
    MINICONDA_VERSION=4.6.14 \
    CONDA_VERSION=4.6.14 \
    MINICONDA_MD5=718259965f234088d785cad1fbd7de03 \
    CONDA_DIR=/opt/conda \
    PATH=$CONDA_DIR/bin:${PATH}

# Heavily inspired from https://github.com/jupyter/docker-stacks/blob/master/r-notebook/Dockerfile

USER root

# R system library pre-requisites
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    fonts-dejavu \
    unixodbc \
    unixodbc-dev \
    r-cran-rodbc \
    gfortran \
    gcc && \
    rm -rf /var/lib/apt/lists/* && \
    mkdir -p $CONDA_DIR && \
    chown -R $NB_USER:$NB_GID $CONDA_DIR && \
    # Fix for devtools https://github.com/conda-forge/r-devtools-feedstock/issues/4
    ln -s /bin/tar /bin/gtar

USER $NB_UID

ENV PATH=$CONDA_DIR/bin:${PATH}

# Install conda via Miniconda
RUN cd /tmp && \
    curl --silent --show-error --output miniconda-installer.sh https://repo.anaconda.com/miniconda/Miniconda3-${MINICONDA_VERSION}-Linux-x86_64.sh && \
    echo "${MINICONDA_MD5} *miniconda-installer.sh" | md5sum -c - && \
    /bin/bash miniconda-installer.sh -f -b -p $CONDA_DIR && \
    rm miniconda-installer.sh && \
    conda config --system --prepend channels conda-forge && \
    conda config --system --set auto_update_conda false && \
    conda config --system --set show_channel_urls true && \
    conda install --quiet --yes conda="${CONDA_VERSION%.*}.*" && \
    conda update --all --quiet --yes && \
    conda clean --all -f -y && \
    rm -rf /home/$NB_USER/.cache/yarn


# R packages and Python packages that are usable via "reticulate".
RUN conda install --quiet --yes \
    'r-base=4.0.0' \
    'r-caret=6.*' \
    'r-crayon=1.3*' \
    'r-devtools=2.3*' \
    'r-forecast=8.12*' \
    'r-hexbin=1.28*' \
    'r-htmltools=0.4*' \
    'r-htmlwidgets=1.5*' \
    'r-irkernel=1.1*' \
    'r-rmarkdown=2.2*' \
    'r-rodbc=1.3*' \
    'r-rsqlite=2.2*' \
    'r-shiny=1.4*' \
    'r-tidyverse=1.3*' \
    'unixodbc=2.3.*' \
    'r-tidymodels=0.1*' \
    'r-reticulate=1.*' \
    && \
    pip install --quiet --no-cache-dir \
    'boto3>1.0<2.0' \
    'sagemaker>2.0<3.0' && \
    conda clean --all -f -y

WORKDIR $HOME
USER $NB_UID
 
       
Configurando sua pasta de instalação
 
       
Você precisa criar uma pasta em sua máquina local e adicionar os seguintes arquivos nessa pasta:
 
       
.
 
       
├── Dockerfile

├── app-image-config-input.json

├── create-and-attach-image.sh

├── create-domain-input.json

└── default-user-settings.json
 
       
Nos scripts a seguir, os nomes de recursos da Amazon (ARNs) devem ter um formato semelhante a:
 
       
arn:partition:service:region:account-id:resource-id

arn:partition:service:region:account-id:resource-type/resource-id

arn:partition:service:region:account-id:resource-type:resource-id
 
       
 
 
       
     
        
  1. Dockerfile é o Dockerfile que você criou na etapa anterior.
    2.  
        
  2. Crie um arquivo chamado app-image-config-input.json com o seguinte conteúdo:
    3.  
       
 
       
{

    "AppImageConfigName": "custom-r-image-config",

    "KernelGatewayImageConfig": {

        "KernelSpecs": [

            {

                "Name": "ir",

                "DisplayName": "R (Custom R Image)"

            }

        ],

        "FileSystemConfig": {

            "MountPath": "/home/sagemaker-user",

            "DefaultUid": 1000,

            "DefaultGid": 100

        }

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

  "DefaultUserSettings": {

    "KernelGatewayAppSettings": {

      "CustomImages": [

          {

                   "ImageName": "custom-r",

                   "AppImageConfigName": "custom-r-image-config"

                }

            ]

        }

    }

}
 
       
 
 
       
4. Crie um último arquivo na pasta de instalação chamado create-and-attach-image.sh usando o seguinte script bash. O script executa o seguinte em ordem:
 
       
a. Cria um repositório chamado smstudio-custom no Amazon ECR e faz logon nesse repositório
 
       
b. Constrói uma imagem usando o Dockerfile e anexa uma tag à imagem r
 
       
c. Envia a imagem para o Amazon ECR
 
       
d. Cria uma imagem para o SageMaker Studio e anexa a imagem do Amazon ECR a essa imagem
 
       
e. Cria um AppImageConfigfor usando app-image-config-input.json
 
       
 
 
       
# Replace with your AWS account ID and your Region, e.g. us-east-1, us-west-2
ACCOUNT_ID = <AWS ACCOUNT ID>
REGION = <STUDIO DOMAIN REGION>

# create a repository in ECR, and then login to ECR repository
aws --region ${REGION} ecr create-repository --repository-name smstudio-custom
aws ecr --region ${REGION} get-login-password | docker login --username AWS \
    --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom

# Build the docker image and push to Amazon ECR (modify image tags and name as required)
$(aws ecr get-login --region ${REGION} --no-include-email)
docker build . -t smstudio-r -t ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:r
docker push ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:r

# Using with SageMaker Studio
## Create SageMaker Image with the image in ECR (modify image name as required)
ROLE_ARN = "<YOUR EXECUTION ROLE ARN>"

aws sagemaker create-image \
    --region ${REGION} \
    --image-name custom-r \
    --role-arn ${ROLE_ARN}

aws sagemaker create-image-version \
    --region ${REGION} \
    --image-name custom-r \
    --base-image ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:r

## Create AppImageConfig for this image (modify AppImageConfigName and 
## KernelSpecs in app-image-config-input.json as needed)
## note that 'file://' is required in the file path
aws sagemaker create-app-image-config \
    --region ${REGION} \
    --cli-input-json file://app-image-config-input.json
 
       
 
       
 
 
       
Atualizando um domínio existente do SageMaker Studio com uma imagem personalizada
 
       
Se você já tiver um domínio do Studio, não precisará criar um novo domínio e pode atualizar facilmente seu domínio existente anexando a imagem personalizada. Você pode fazer isso usando a AWS CLI para Amazon SageMaker ou o painel de controle do SageMaker Studio (que discutimos nas seções a seguir). Antes de ir para as próximas etapas, verifique se seu domínio está no status Pronto e obtenha o ID de domínio do Studio no próprio Painel de Controle do Studio. O ID do domínio deve estar no formato d-xxxxxxxx .
 
       
 
 
       
 
       
 
 
       
Uso da AWS CLI para SageMaker
 
       
No terminal, navegue até a pasta de instalação e execute os seguintes comandos. Isso faz do bash script executável:
 
       
chmod +x create-and-attach-image.sh
 
       
Em seguida, execute o seguinte comando no terminal:
 
       
./create-and-attach-image.sh
 
       
Depois de executar com sucesso o script bash, você precisa atualizar seu domínio existente executando o seguinte comando no terminal. Certifique-se de fornecer seu ID de domínio e Região.
 
       
aws sagemaker update-domain —domain-id <DOMAIN_ID>\

aws sagemaker update-domain --domain-id <DOMAIN_ID> \

    --region <REGION_ID> \

    --cli-input-json file://default-user-settings.json
 
       
Depois de executar este comando, seu status de domínio é exibido como Atualizando por alguns segundos e, em seguida, mostra como Pronto novamente. Agora você pode abrir o Studio.
 
       
Quando estiver no ambiente do Studio, você pode usar o Launcher para iniciar uma nova atividade e deve ver a imagem custom-r (latest) listada no menu suspenso em Selecionar uma imagem do SageMaker para iniciar sua atividade.
 
       
Usando o console do SageMaker
 
       
Como alternativa, você pode atualizar seu domínio anexando a imagem através do console do SageMaker. A imagem que você criou está listada na página Imagens no console.
 
       
 
 
       
 
       
 
 
       
     
        
  1. Para anexar essa imagem ao seu domínio, no Painel de Controle do SageMaker Studio, em Imagens personalizadas anexadas ao domínio, escolha Anexar imagem.
    2.  
        
  2. Em Origem da imagem, escolha Imagem existente.
    3.  
        
  3. Escolha uma imagem existente na lista.
    4.  
        
  4. Escolha uma versão da imagem na lista.
    5.  
        
  5. Escolha Próximo.
    6.  
        
  6. Escolha a função do IAM. Para obter mais informações, consulte Criar uma imagem personalizada do SageMaker (Console).
    7.  
        
  7. Escolha Próximo.
    8.  
        
  8. Em Configuração do Studio, insira ou altere as seguintes configurações. Para obter informações sobre como obter as informações do kernel da imagem, consulte DEVELOPMENT no repositório do GitHub SageMaker Studio Custom Image Samples.
    9.  
       
 
       
a. Para o caminho de montagem do EFS, insira o caminho dentro da imagem para montar o diretório inicial do Amazon Elastic File System (Amazon EFS) do usuário.
 
       
b. Para o nome do Kernel, insira o nome de um kernel existente na imagem.
 
       
c. (Opcional) Para o nome de exibição do Kernel, insira o nome de exibição do kernel.
 
       
d. Escolha Adicionar kernel.
 
       
e. (Opcional) Para etiquetas de configuração, escolha Adicionar nova etiqueta e adicione uma etiqueta de configuração.
 
       
Para obter mais informações, consulte as seções Descoberta de Kernel e Dados do usuário das especificações de imagens personalizadas do SageMaker.
 
       
9. Escolha Submeter.
 
       
10. Aguarde até que a versão da imagem seja anexada ao domínio.
 
       
Ao anexar, o status do seu domínio é mostrado como Atualizando. Quando anexada, a versão é exibida na lista Imagens personalizadas e destacada brevemente, e o status do seu domínio é exibido como Pronto.
 
       
 
 
       
 
       
 
 
       
O SageMaker armazena automaticamente versões de suas imagens. Você pode selecionar uma imagem pré-anexada e escolher Desanexar para desanexar a imagem e todas as 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.
 
       
 
 
       
Usando uma imagem personalizada para criar notebooks
 
       
Quando terminar de atualizar seu domínio do Studio com a imagem personalizada, você pode usar essa imagem para criar novos notebooks. Para fazer isso, escolha sua imagem personalizada na lista de imagens do Launcher. Neste exemplo, usamos custom-r . Isso mostra a lista de kernels que você pode usar para criar notebooks. Crie um novo notebook com o kernel R.
 
       
 
 
       
 
       
 
 
       
Se esta for a primeira vez que você está usando este kernel para criar um notebook, pode demorar cerca de um minuto para iniciar o kernel, e a mensagem de Kernel starting aparecer no canto inferior esquerdo do seu Studio. Você pode escrever scripts R enquanto o kernel está começando, mas só pode executar seu script depois que seu kernel estiver pronto. O notebook é criado com uma instância default ml.t3.medium anexada a ele. Você pode ver o kernel R (Custom R Image) e o tipo de instância no canto superior direito do notebook . Você pode alterar instâncias de ML rapidamente no SageMaker Studio. Você também pode dimensionar corretamente suas instâncias para diferentes cargas de trabalho. Para obter mais informações, consulte Dimensionando corretamente recursos e evitando custos desnecessários no Amazon SageMaker.
 
       
Para testar o kernel, insira o seguinte script R de exemplo na primeira célula e execute o script. Esse script testa vários aspectos, incluindo a importação de bibliotecas, a criação de uma sessão do SageMaker, a obtenção da função do IAM e a importação de dados de repositórios públicos.
 
       
O conjunto de dados abalone neste post é de Dua, D. e Graff, C. (2019). Repositório UCI Machine Learning [http://archive.ics.uci.edu/ml]. Irvine, CA: Universidade da Califórnia, Escola de Informação e Ciência da Computação (http://archive.ics.uci.edu/ml/datasets/Abalone).
 
       
 
       
# Simple script to test R Kernel in SageMaker Studio

# Import reticulate, readr and sagemaker libraries
library(reticulate)
library(readr)
sagemaker <- import('sagemaker')

# Create a sagemaker session
session <- sagemaker$Session()

# Get execution role
role_arn <- sagemaker$get_execution_role()

# Read a csv file from UCI public repository
# Dua, D. and Graff, C. (2019). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml].\ 
# Irvine, CA: University of California, School of Information and Computer Science
data_file <- 'http://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data'

# Copy data to a dataframe, rename columns, and show dataframe head
abalone <- read_csv(file = data_file, col_names = FALSE, col_types = cols())
names(abalone) <- c('sex', 'length', 'diameter', 'height', 'whole_weight', 'shucked_weight', 'viscera_weight', 'shell_weight', 'rings')
head(abalone)
 
       


 
       
Se a imagem estiver configurada corretamente e o kernel estiver em execução, a saída deverá ser parecida com a seguinte captura de tela.
 
       
 
 
       
 
       
 
 
       
Listando, desanexando e excluindo imagens personalizadas
 
       
Se você quiser ver a lista de imagens personalizadas anexadas ao seu Studio, você pode usar a AWS CLI ou acessar o console do SageMaker para exibir a imagem anexada no Painel de controle do Studio.
 
       
Uso da AWS CLI para SageMaker
 
       
Para visualizar sua lista de imagens personalizadas por meio da AWS CLI, insira o seguinte comando no terminal (forneça a região na qual você criou seu domínio):
 
       
 
        
 
         
aws sagemaker list-images --region <region-id> 
 
        
 
       
 
       
A resposta inclui os detalhes das imagens personalizadas anexadas:
 
       
{

    "Images": [

        {

            "CreationTime": "xxxxxxxxxxxx",

            "ImageArn": "arn:aws:sagemaker:us-east-2:XXXXXXX:image/custom-r",

            "ImageName": "custom-r",

            "ImageStatus": "CREATED",

            "LastModifiedTime": "xxxxxxxxxxxxxx"

        },

        ....

    ]

}
 
       
Se você quiser desanexar ou excluir uma imagem anexada, você pode fazê-lo no Painel de Controle do SageMaker Studio (consulte Desanexar uma imagem personalizada do SageMaker). Como alternativa, use o nome da imagem personalizada do arquivo default-user-settings.json e execute novamente o comando a seguir para atualizar o domínio, desanexando assim a imagem:
 
       
aws sagemaker update-domain --domain-id <YOUR DOMAIN ID> \

    --cli-input-json file://default-user-settings.json
 
       
Em seguida, exclua a configuração da imagem da aplicação:
 
       
aws sagemaker delete-app-image-config \

    --app-image-config-name custom-r-image-config
 
       
Exclua a imagem do SageMaker, que também exclui todas as versões de imagem. As imagens de contêiner no Amazon ECR representadas pelas versões da imagem, não são excluídas.
 
       
aws sagemaker delete-image \

    --region <region-id> \

    --image-name custom-r
 
       
Depois de excluir a imagem, ela não será listada em imagens personalizadas no SageMaker Studio. Para obter mais informações, consulte Limpar recursos.
 
       
Usando o console do SageMaker
 
       
Você também pode desanexar (e excluir) imagens do seu domínio por meio da interface do usuário do Painel de Controle do Studio. Para fazer isso, em Imagens personalizadas anexadas ao domínio, selecione a imagem e escolha Desanexar. Você tem a opção de excluir também todas as versões da imagem do seu domínio. Isso desconecta a imagem do domínio.
 
       
 
 
       
 
       
 
 
       
Obtenção de logs no Amazon CloudWatch
 
       
Você também pode ter acesso aos logs do SageMaker Studio no Amazon CloudWatch, que você pode usar para solucionar problemas de seu ambiente. 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 Grupos de log, insira o namespace para ver os logs associados ao servidor Jupyter e ao gateway do kernel.
 
       
Para obter mais informações, consulte Registrar eventos do Amazon SageMaker com o Amazon CloudWatch.
 
       
 
 
       
Conclusão
 
       
Este post descreveu o processo de anexar uma imagem personalizada do Docker ao seu domínio do Studio para estender as imagens incorporadas do Studio. Discutimos como você pode atualizar um domínio existente com uma imagem personalizada usando a AWS CLI para SageMaker ou o console do SageMaker. Também explicamos como você pode usar a imagem personalizada para criar notebooks com kernels personalizados.
 
       
Para obter mais informações, consulte os seguintes recursos:
 
        
       
 
 
       
Este artigo foi traduzido do Blog da AWS em Inglês.
 
       
 
 
       
 
       
Sobre os autores
 
       
Nick Minaie é um arquiteto de soluções especializado em inteligência artificial e aprendizado de máquina (AI/ML), tem ajudando os clientes em sua jornada de soluções de aprendizado de máquina de forma bem arquitetada e em escala. Em seu tempo livre, Nick gosta de tempo em família, pintura abstrata e explorar a natureza.
 
       
 
 
       
 
 
       
 
 
       
Sam Liu é gerente de produto da Amazon Web Services (AWS). Seu foco atual é a infraestrutura e ferramentas de aprendizado de máquina e inteligência artificial. Além disso, ele tem 10 anos de experiência na construção de aplicativos de aprendizado de máquina em vários setores. Em seu tempo livre, ele gosta de fazer vídeos curtos para educação técnica ou proteção animal.
 
       
 
 
       
 
 
       
 
 
       
Revisor
 
       
Andreza Cruz é um arquiteta de soluções na Amazon Web Services (AWS). Trabalha com foco em desenvolvimento ajudando os clientes em sua jornada na nuvem, e tem se especializado em inteligência artificial e aprendizado de máquina (AI/ML).