Cree canalizaciones de creación de modelos de Amazon SageMaker e implemente modelos R con RStudio en Amazon SageMaker

En noviembre de 2021, en colaboración con RStudio PBC, Que anunció la disponibilidad general de RStudio en Amazon SageMaker, el primer IDE RStudio Workbench completamente administrado de la industria en la nube. Ahora puede traer su licencia RStudio actual para migrar fácilmente sus entornos RStudio autogestionados a Amazon SageMaker en tan solo unos sencillos pasos.

RStudio es uno de los IDE más populares entre los desarrolladores de R para proyectos de aprendizaje automático (ML) y ciencia de datos. RStudio proporciona herramientas de código abierto para R y software profesional listo para la empresa para que los equipos de ciencia de datos desarrollen y compartan su trabajo en la organización. Llevar RStudio a SageMaker no solo le brinda acceso a la infraestructura de AWS de forma totalmente administrada, sino que también le brinda acceso nativo a SageMaker.

En esta publicación, exploramos cómo puede usar las funciones de SageMaker a través de RStudio en SageMaker para crear una canalización de SageMaker que genere, procese, entrene y registre sus modelos R. También exploramos el uso de SageMaker para la implementación de nuestro modelo, todo con R.

Resumen de la solución

El siguiente diagrama muestra la arquitectura utilizada en nuestra solución. Todo el código utilizado en este ejemplo se puede encontrar en el Repositorio GitHub.

Requisitos previos

Para seguir esta publicación, se requiere acceso a RStudio en SageMaker. Si es nuevo en el uso de RStudio en SageMaker, revise Empiece a utilizar RStudio en Amazon SageMaker.

También necesitamos construir contenedores Docker personalizados. Usamos Construcción de código AWS para construir estos contenedores, por lo que necesita algunos extra Gestión de identidades y accesos de AWS (IAM) que es posible que no tenga de forma predeterminada. Antes de continuar, asegúrese de que el rol de IAM que está utilizando tenga una política de confianza con CodeBuild:

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

También se requieren los siguientes permisos en el rol de IAM para ejecutar una compilación en CodeBuild y enviar la imagen a Registro de contenedores elásticos de Amazon (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"
                }
            }
        }
    ]
}

Crear contenedores R de referencia

Para utilizar nuestros scripts R para el procesamiento y la capacitación en los trabajos de procesamiento y capacitación de SageMaker, debemos crear los nuestros propios. Contenedores Docker que contiene el tiempo de ejecución y los paquetes necesarios. La capacidad de usar su propio contenedor, que es parte de la oferta de SageMaker, brinda una gran flexibilidad a los desarrolladores y científicos de datos para usar las herramientas y los marcos de su elección, prácticamente sin limitaciones.

Creamos dos contenedores Docker habilitados para R: uno para procesar trabajos y otro para entrenar e implementar nuestros modelos. El procesamiento de datos generalmente requiere diferentes paquetes y bibliotecas que el modelado, por lo que aquí tiene sentido separar las dos etapas y usar diferentes contenedores.

Para obtener más detalles sobre el uso de contenedores con SageMaker, consulte Usar contenedores de Docker con SageMaker.

El contenedor utilizado para el procesamiento se define de la siguiente manera:

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 esta publicación, usamos un contenedor simple y relativamente liviano. Según sus necesidades o las de su organización, es posible que desee preinstalar varios paquetes R más.

El contenedor utilizado para el entrenamiento y la implementación se define de la siguiente manera:

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"]

El kernel de RStudio se ejecuta en un contenedor de Docker, por lo que no podrá compilar ni implementar los contenedores con los comandos de Docker directamente en su sesión de Studio. En su lugar, puede utilizar la biblioteca muy útil sagemaker-studio-imagen-construcción, que básicamente subcontrata la tarea de crear contenedores a CodeBuild.

Con los siguientes comandos, creamos dos registros de Amazon ECR: sagemaker-r-processing y sagemaker-r-train-n-deploy, y construimos los respectivos contenedores que usaremos más adelante:

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")

Crea la canalización

Ahora que los contenedores están construidos y listos, podemos crear la canalización de SageMaker que organiza el flujo de trabajo de creación de modelos. El código completo de esto está bajo el archivo pipeline.R en el repositorio. La forma más sencilla de crear una canalización de SageMaker es mediante el SDK de SageMaker, que es una biblioteca de Python a la que podemos acceder mediante la biblioteca reticular. Esto nos da acceso a todas las funcionalidades de SageMaker sin salir del entorno del lenguaje R.

El pipeline que construimos tiene los siguientes componentes:

• paso de preprocesamiento – Este es un trabajo de procesamiento de SageMaker (que utiliza el sagemaker-r-processing contenedor) responsable de preprocesar los datos y dividirlos en conjuntos de datos de prueba y entrenamiento.
• Paso de entrenamiento – Este es un trabajo de entrenamiento de SageMaker (que utiliza el sagemaker-r-train-n-deploy contenedor) responsable de entrenar el modelo. En este ejemplo, entrenamos un modelo lineal simple.
• Paso de evaluación – Este es un trabajo de procesamiento de SageMaker (que utiliza el sagemaker-r-processing contenedor) responsable de realizar la evaluación del modelo. Específicamente en este ejemplo, estamos interesados ​​en el RMSE (error cuadrático medio) en el conjunto de datos de prueba, que queremos usar en el siguiente paso y asociarlo con el modelo en sí.
• paso condicional – Este es un paso condicional, nativo de las canalizaciones de SageMaker, que nos permite bifurcar la lógica de la canalización en función de algún parámetro. En este caso, la canalización se bifurca según el valor de RMSE que se calculó en el paso anterior.
• Registrar modelo paso – Si el paso condicional anterior es True, y el rendimiento del modelo es aceptable, entonces el modelo se registra en el registro de modelos. Para obtener más información, consulte Registrar e implementar modelos con Model Registry.

Primero llame a la función upsert para crear (o actualizar) la tubería y luego llame a la función de inicio para comenzar a ejecutar la tubería:

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()

Inspeccione la canalización y el registro del modelo

Una de las mejores cosas de usar RStudio en SageMaker es que al estar en la plataforma SageMaker, puede usar la herramienta correcta para el trabajo correcto y cambiar rápidamente entre ellas según lo que necesite hacer.

Tan pronto como comencemos la ejecución de la canalización, podemos cambiar a Estudio Amazon SageMaker, que nos permite visualizar la canalización y monitorear las ejecuciones actuales y anteriores de la misma.

Para ver detalles sobre la canalización que acabamos de crear y ejecutar, vaya a la interfaz del IDE de Studio, elija Recursos de SageMaker, escoger Pipelines en el menú desplegable y elija la canalización (en este caso, AbalonePipelineUsingR).

Esto revela detalles de la canalización, incluidas todas las ejecuciones actuales y anteriores. Elija el último para mostrar una representación visual de la canalización, según la siguiente captura de pantalla.

El servicio crea automáticamente el DAG de la canalización en función de las dependencias de datos entre los pasos, así como de las dependencias agregadas personalizadas (no agregadas en este ejemplo).

Cuando se completa la ejecución, si tiene éxito, debería ver que todos los pasos se vuelven verdes.

Al elegir cualquiera de los pasos individuales, se muestran detalles sobre el paso específico, incluidas las entradas, las salidas, los registros y los ajustes de configuración inicial. Esto le permite profundizar en la tubería e investigar cualquier paso fallido.

De manera similar, cuando la canalización ha terminado de ejecutarse, se guarda un modelo en el registro de modelos. Para acceder a él, en el Recursos de SageMaker panel, elija registro modelo en el desplegable y elige tu modelo. Esto revela la lista de modelos registrados, como se muestra en la siguiente captura de pantalla. Elija uno para abrir la página de detalles de esa versión de modelo en particular.

Después de abrir una versión del modelo, elija Actualizar el estado y Aprobar para aprobar el modelo.

En este punto, según su caso de uso, puede configurar esta aprobación para desencadenar acciones adicionales, incluida la implementación del modelo según sus necesidades.

Despliegue sin servidor del modelo

Una vez que haya entrenado y registrado un modelo en SageMaker, implementar el modelo en SageMaker es sencillo.

Hay varias opciones de cómo puede implementar un modelo, como inferencia por lotes, puntos finales en tiempo real o puntos finales asincrónicos. Cada método viene con varias configuraciones requeridas, incluida la elección del tipo de instancia que desea, así como el mecanismo de escalado.

Para este ejemplo, usamos la característica recientemente anunciada de SageMaker, Inferencia sin servidor (en modo de vista previa en el momento de escribir este artículo), para implementar nuestro modelo R en un punto final sin servidor. Para este tipo de punto final, solo definimos la cantidad de RAM que queremos que se asigne al modelo para la inferencia, así como la cantidad máxima de invocaciones simultáneas permitidas del modelo. SageMaker se encarga de alojar el modelo y escalar automáticamente según sea necesario. Solo se le cobra por la cantidad exacta de segundos y datos utilizados por el modelo, sin costo por tiempo de inactividad.

Puede implementar el modelo en un punto final sin servidor con el siguiente 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")

Si ves el error ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" el modelo que desea implementar no ha sido aprobado. Siga los pasos de la sección anterior para aprobar su modelo.

Invoque el punto final enviando una solicitud al punto final HTTP que implementamos o, en su lugar, utilice el SDK de SageMaker. En el siguiente código, invocamos el punto final en algunos datos de prueba:

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)

El punto final que invocamos era un punto final sin servidor y, como tal, se nos cobra por la duración exacta y los datos utilizados. Es posible que observe que la primera vez que invoca el punto final, tarda aproximadamente un segundo en responder. Esto se debe a la hora de inicio en frío del extremo sin servidor. Si realiza otra invocación poco después, el modelo devuelve la predicción en tiempo real porque ya está caliente.

Cuando termine de experimentar con el punto final, puede eliminarlo con el siguiente comando:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Conclusión

En esta publicación, analizamos el proceso de creación de una canalización de SageMaker con R en nuestro entorno de RStudio y mostramos cómo implementar nuestro modelo de R en un extremo sin servidor en SageMaker con el registro de modelos de SageMaker.

Con la combinación de RStudio y SageMaker, ahora puede crear y orquestar flujos de trabajo de ML completos e integrales en AWS utilizando nuestro idioma preferido, R.

Para profundizar en esta solución, lo animo a revisar el código fuente de esta solución, así como otros ejemplos, en GitHub.

Sobre la autora

Georgios Schinas es Arquitecto de Soluciones Especializado en IA/ML en la región EMEA. Tiene su sede en Londres y trabaja en estrecha colaboración con clientes en el Reino Unido e Irlanda. Georgios ayuda a los clientes a diseñar e implementar aplicaciones de aprendizaje automático en producción en AWS con un interés particular en las prácticas de MLOps y permite a los clientes realizar aprendizaje automático a escala. En su tiempo libre, le gusta viajar, cocinar y pasar tiempo con amigos y familiares.