Crie pipelines de criação de modelos do Amazon SageMaker e implante modelos R usando o RStudio no Amazon SageMaker

Em novembro de 2021, em colaboração com RS Estúdio PBC, nós anunciou a disponibilidade geral de RStudio no Amazon SageMaker, o primeiro RStudio Workbench IDE totalmente gerenciado do setor na nuvem. Agora você pode trazer sua licença atual do RStudio para migrar facilmente seus ambientes RStudio autogerenciados para Amazon Sage Maker em apenas alguns passos simples.

O RStudio é um dos IDEs mais populares entre os desenvolvedores de R para aprendizado de máquina (ML) e projetos de ciência de dados. O RStudio fornece ferramentas de código aberto para R e software profissional pronto para empresas para que as equipes de ciência de dados desenvolvam e compartilhem seu trabalho na organização. Trazer o RStudio para o SageMaker não apenas oferece acesso à infraestrutura da AWS de maneira totalmente gerenciada, mas também oferece acesso nativo ao SageMaker.

Neste post, exploramos como você pode usar os recursos do SageMaker por meio do RStudio no SageMaker para criar um pipeline do SageMaker que cria, processa, treina e registra seus modelos R. Também exploramos o uso do SageMaker para nossa implantação de modelo, todos usando R.

Visão geral da solução

O diagrama a seguir mostra a arquitetura usada em nossa solução. Todo o código usado neste exemplo pode ser encontrado no Repositório GitHub.

Pré-requisitos

Para acompanhar este post, é necessário acessar o RStudio no SageMaker. Se você é novo no uso do RStudio no SageMaker, revise Comece a usar o RStudio no Amazon SageMaker.

Também precisamos criar contêineres personalizados do Docker. Nós usamos AWS CodeBuild para construir esses contêineres, então você precisa de alguns Gerenciamento de acesso e identidade da AWS (IAM) que você pode não ter por padrão. Antes de continuar, certifique-se de que a função do IAM que você está usando tenha uma política de confiança com o CodeBuild:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "codebuild.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

As seguintes permissões também são necessárias na função do IAM para executar uma compilação no CodeBuild e enviar a imagem para Registro do Amazon Elastic Container (Amazon ECR):

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "codebuild:DeleteProject",
                "codebuild:CreateProject",
                "codebuild:BatchGetBuilds",
                "codebuild:StartBuild"
            ],
            "Resource": "arn:aws:codebuild:*:*:project/sagemaker-studio*"
        },
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogStream",
            "Resource": "arn:aws:logs:*:*:log-group:/aws/codebuild/sagemaker-studio*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:GetLogEvents",
                "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:*:*:log-group:/aws/codebuild/sagemaker-studio*:log-stream:*"
        },
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ecr:CreateRepository",
                "ecr:BatchGetImage",
                "ecr:CompleteLayerUpload",
                "ecr:DescribeImages",
                "ecr:DescribeRepositories",
                "ecr:UploadLayerPart",
                "ecr:ListImages",
                "ecr:InitiateLayerUpload", 
                "ecr:BatchCheckLayerAvailability",
                "ecr:PutImage"
            ],
            "Resource": "arn:aws:ecr:*:*:repository/sagemaker-studio*"
        },
        {
            "Sid": "ReadAccessToPrebuiltAwsImages",
            "Effect": "Allow",
            "Action": [
                "ecr:BatchGetImage",
                "ecr:GetDownloadUrlForLayer"
            ],
            "Resource": [
                "arn:aws:ecr:*:763104351884:repository/*",
                "arn:aws:ecr:*:217643126080:repository/*",
                "arn:aws:ecr:*:727897471807:repository/*",
                "arn:aws:ecr:*:626614931356:repository/*",
                "arn:aws:ecr:*:683313688378:repository/*",
                "arn:aws:ecr:*:520713654638:repository/*",
                "arn:aws:ecr:*:462105765813:repository/*"
            ]
        },
        {
            "Sid": "EcrAuthorizationTokenRetrieval",
            "Effect": "Allow",
            "Action": [
                "ecr:GetAuthorizationToken"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
              "s3:GetObject",
              "s3:DeleteObject",
              "s3:PutObject"
              ],
            "Resource": "arn:aws:s3:::sagemaker-*/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:CreateBucket"
            ],
            "Resource": "arn:aws:s3:::sagemaker*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "iam:GetRole",
                "iam:ListRoles"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::*:role/*",
            "Condition": {
                "StringLikeIfExists": {
                    "iam:PassedToService": "codebuild.amazonaws.com"
                }
            }
        }
    ]
}

Criar contêineres R de linha de base

Para usar nossos scripts R para processamento e treinamento em trabalhos de processamento e treinamento do SageMaker, precisamos criar nossos próprios Recipientes Docker contendo o tempo de execução e os pacotes necessários. A capacidade de usar seu próprio contêiner, que faz parte da oferta do SageMaker, oferece grande flexibilidade aos desenvolvedores e cientistas de dados para usar as ferramentas e estruturas de sua escolha, praticamente sem limitações.

Criamos dois contêineres Docker habilitados para R: um para processar trabalhos e outro para treinamento e implantação de nossos modelos. O processamento de dados normalmente requer pacotes e bibliotecas diferentes da modelagem, portanto, aqui faz sentido separar os dois estágios e usar contêineres diferentes.

Para obter mais detalhes sobre o uso de contêineres com o SageMaker, consulte Usando contêineres Docker com SageMaker.

O contêiner usado para processamento é definido da seguinte forma:

FROM public.ecr.aws/docker/library/r-base:4.1.2

# Install tidyverse
RUN apt update && apt-get install -y --no-install-recommends 
    r-cran-tidyverse
    
RUN R -e "install.packages(c('rjson'))"

ENTRYPOINT ["Rscript"]

Para este post, usamos um container simples e relativamente leve. Dependendo das suas necessidades ou das necessidades da sua organização, talvez você queira pré-instalar vários outros pacotes R.

O contêiner usado para treinamento e implantação é definido da seguinte forma:

FROM public.ecr.aws/docker/library/r-base:4.1.2

RUN apt-get -y update && apt-get install -y --no-install-recommends 
    wget 
    apt-transport-https 
    ca-certificates 
    libcurl4-openssl-dev 
    libsodium-dev
    
RUN apt-get update && apt-get install -y python3-dev python3-pip 
RUN pip3 install boto3
RUN R -e "install.packages(c('readr','plumber', 'reticulate'),dependencies=TRUE, repos='http://cran.rstudio.com/')"

ENV PATH="/opt/ml/code:${PATH}"

WORKDIR /opt/ml/code

COPY ./docker/run.sh /opt/ml/code/run.sh
COPY ./docker/entrypoint.R /opt/ml/entrypoint.R

RUN /bin/bash -c 'chmod +x /opt/ml/code/run.sh'

ENTRYPOINT ["/bin/bash", "run.sh"]

O kernel do RStudio é executado em um contêiner do Docker, portanto, você não poderá criar e implantar os contêineres usando comandos do Docker diretamente em sua sessão do Studio. Em vez disso, você pode usar a biblioteca muito útil sagemaker-studio-image-build, que essencialmente terceiriza a tarefa de construir contêineres para o CodeBuild.

Com os comandos a seguir, criamos dois registros do Amazon ECR: sagemaker-r-processing e sagemaker-r-train-n-deploy, e construa os respectivos contêineres que usaremos posteriormente:

if (!py_module_available("sagemaker-studio-image-build")){py_install("sagemaker-studio-image-build", pip=TRUE)}
system("cd pipeline-example ; sm-docker build . —file ./docker/Dockerfile-train-n-deploy —repository sagemaker-r-train-and-deploy:1.0")
system("cd pipeline-example ; sm-docker build . —file ./docker/Dockerfile-processing —repository sagemaker-r-processing:1.0")

Criar o pipeline

Agora que os contêineres estão criados e prontos, podemos criar o pipeline do SageMaker que orquestra o fluxo de trabalho de construção do modelo. O código completo disso está no arquivo pipeline.R no repositório. A maneira mais fácil de criar um pipeline do SageMaker é usando o SageMaker SDK, que é uma biblioteca Python que podemos acessar usando a biblioteca reticulado. Isso nos dá acesso a todas as funcionalidades do SageMaker sem sair do ambiente da linguagem R.

O pipeline que construímos tem os seguintes componentes:

• Etapa de pré-processamento – Este é um trabalho de processamento do SageMaker (utilizando o sagemaker-r-processing container) responsável por pré-processar os dados e dividir os dados em conjuntos de dados de treinamento e teste.
• Etapa de treinamento – Este é um trabalho de treinamento do SageMaker (utilizando o sagemaker-r-train-n-deploy container) responsável pelo treinamento do modelo. Neste exemplo, treinamos um modelo linear simples.
• Etapa de avaliação – Este é um trabalho de processamento do SageMaker (utilizando o sagemaker-r-processing container) responsável por realizar a avaliação do modelo. Especificamente neste exemplo, estamos interessados ​​no RMSE (root mean square error) no conjunto de dados de teste, que queremos usar na próxima etapa, bem como associar ao próprio modelo.
• Etapa condicional – Esta é uma etapa condicional, nativa dos pipelines do SageMaker, que nos permite ramificar a lógica do pipeline com base em algum parâmetro. Nesse caso, o pipeline se ramifica com base no valor de RMSE calculado na etapa anterior.
• Etapa do modelo de registro – Se a etapa condicional anterior for True, e o desempenho do modelo for aceitável, o modelo será registrado no registro de modelos. Para obter mais informações, consulte Registrar e implantar modelos com o registro de modelos.

Primeiro, chame a função upsert para criar (ou atualizar) o pipeline e, em seguida, chame a função start para realmente começar a executar o pipeline:

source("pipeline-example/pipeline.R")
my_pipeline <- get_pipeline(input_data_uri=s3_raw_data)

upserted <- my_pipeline$upsert(role_arn=role_arn)
started <- my_pipeline$start()

Inspecione o pipeline e o registro do modelo

Uma das grandes vantagens de usar o RStudio no SageMaker é que, por estar na plataforma SageMaker, você pode usar a ferramenta certa para o trabalho certo e alternar rapidamente entre elas com base no que precisa fazer.

Assim que iniciarmos a execução do pipeline, podemos mudar para Estúdio Amazon SageMaker, que nos permite visualizar o pipeline e monitorar execuções atuais e anteriores dele.

Para visualizar detalhes sobre o pipeline que acabamos de criar e executar, navegue até a interface do Studio IDE, escolha Recursos do SageMaker, escolha Dutos no menu suspenso e escolha o pipeline (neste caso, AbalonePipelineUsingR).

Isso revela detalhes do pipeline, incluindo todas as execuções atuais e anteriores. Escolha o mais recente para exibir uma representação visual do pipeline, conforme a captura de tela a seguir.

O DAG do pipeline é criado automaticamente pelo serviço com base nas dependências de dados entre as etapas, bem como com base nas dependências adicionadas personalizadas (não adicionadas neste exemplo).

Quando a execução estiver concluída, se for bem-sucedida, você verá todas as etapas ficarem verdes.

A escolha de qualquer uma das etapas individuais traz detalhes sobre a etapa específica, incluindo entradas, saídas, logs e definições de configuração inicial. Isso permite que você faça uma busca detalhada no pipeline e investigue todas as etapas com falha.

Da mesma forma, quando a execução do pipeline termina, um modelo é salvo no registro do modelo. Para acessá-lo, no Recursos do SageMaker painel, escolha Registro do modelo no menu suspenso e escolha seu modelo. Isso revela a lista de modelos registrados, conforme mostrado na captura de tela a seguir. Escolha um para abrir a página de detalhes dessa versão de modelo específica.

Depois de abrir uma versão do modelo, escolha Atualização de status e Aprovar para aprovar o modelo.

Neste ponto, com base no seu caso de uso, você pode configurar essa aprovação para acionar outras ações, incluindo a implantação do modelo conforme suas necessidades.

Implantação sem servidor do modelo

Depois de treinar e registrar um modelo no SageMaker, a implantação do modelo no SageMaker é simples.

Existem várias opções de como você pode implantar um modelo, como inferência em lote, endpoints em tempo real ou endpoints assíncronos. Cada método vem com várias configurações necessárias, incluindo a escolha do tipo de instância desejado, bem como o mecanismo de dimensionamento.

Para este exemplo, usamos o recurso recentemente anunciado do SageMaker, Inferência sem servidor (no modo de visualização no momento da escrita), para implantar nosso modelo R em um endpoint sem servidor. Para esse tipo de endpoint, definimos apenas a quantidade de RAM que queremos que seja alocada ao modelo para inferência, bem como o número máximo de invocações simultâneas permitidas do modelo. O SageMaker cuida da hospedagem do modelo e do dimensionamento automático conforme necessário. Você é cobrado apenas pelo número exato de segundos e dados usados ​​pelo modelo, sem custo por tempo ocioso.

Você pode implantar o modelo em um endpoint sem servidor com o seguinte código:

model_package_arn <- 'ENTER_MODEL_PACKAGE_ARN_HERE'
model <- sagemaker$ModelPackage(
                        role=role_arn, 
                        model_package_arn=model_package_arn, 
                        sagemaker_session=session)
serverless_config <- sagemaker$serverless$ServerlessInferenceConfig(
                        memory_size_in_mb=1024L, 
                        max_concurrency=5L)
model$deploy(serverless_inference_config=serverless_config, 
             endpoint_name="serverless-r-abalone-endpoint")

Se você ver o erro ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" o modelo que você deseja implantar não foi aprovado. Siga as etapas da seção anterior para aprovar seu modelo.

Invoque o endpoint enviando uma solicitação para o endpoint HTTP que implantamos ou, em vez disso, use o SDK do SageMaker. No código a seguir, invocamos o endpoint em alguns dados de teste:

library(jsonlite)
x = list(features=format_csv(abalone_t[1:3,1:11]))
x = toJSON(x)

# test the endpoint
predictor <- sagemaker$predictor$Predictor(endpoint_name="serverless-r-abalone-endpoint", sagemaker_session=session)
predictor$predict(x)

O endpoint que invocamos era um endpoint sem servidor e, como tal, somos cobrados pela duração exata e pelos dados usados. Você pode notar que a primeira vez que invocar o endpoint leva cerca de um segundo para responder. Isso ocorre devido ao horário de inicialização a frio do endpoint sem servidor. Se você fizer outra invocação logo em seguida, o modelo retornará a previsão em tempo real porque já está quente.

Ao terminar de experimentar o endpoint, você pode excluí-lo com o seguinte comando:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Conclusão

Neste post, percorremos o processo de criação de um pipeline SageMaker usando R em nosso ambiente RStudio e mostramos como implantar nosso modelo R em um endpoint sem servidor no SageMaker usando o registro de modelo SageMaker.

Com a combinação de RStudio e SageMaker, agora você pode criar e orquestrar fluxos de trabalho de ML completos de ponta a ponta na AWS usando nossa linguagem preferida, R.

Para se aprofundar nesta solução, recomendo que você revise o código-fonte desta solução, bem como outros exemplos, em GitHub.

Sobre o autor

Georgios Schinas é um Arquiteto de Soluções Especialista para AI/ML na região EMEA. Ele está baseado em Londres e trabalha em estreita colaboração com clientes no Reino Unido e na Irlanda. A Georgios ajuda os clientes a projetar e implantar aplicativos de machine learning em produção na AWS com um interesse particular em práticas de MLOps e permitindo que os clientes realizem machine learning em escala. Em seu tempo livre, ele gosta de viajar, cozinhar e passar o tempo com amigos e familiares.