En novembre 2021, en collaboration avec PBC de RStudio, Nous annoncé la disponibilité générale de RStudio sur Amazon SageMaker, le premier IDE RStudio Workbench entièrement géré dans le cloud. Vous pouvez désormais apporter votre licence RStudio actuelle pour migrer facilement vos environnements RStudio autogérés vers Amazon Sage Maker en quelques étapes simples.

RStudio est l'un des IDE les plus populaires parmi les développeurs R pour les projets d'apprentissage automatique (ML) et de science des données. RStudio fournit des outils open source pour R et des logiciels professionnels prêts pour l'entreprise permettant aux équipes de science des données de développer et de partager leur travail au sein de l'organisation. L'intégration de RStudio sur SageMaker vous donne non seulement accès à l'infrastructure AWS de manière entièrement gérée, mais vous donne également un accès natif à SageMaker.

Dans cet article, nous explorons comment vous pouvez utiliser les fonctionnalités de SageMaker via RStudio sur SageMaker pour créer un pipeline SageMaker qui construit, traite, forme et enregistre vos modèles R. Nous explorons également l'utilisation de SageMaker pour le déploiement de notre modèle, le tout à l'aide de R.

Vue d'ensemble de la solution

Le schéma suivant montre l'architecture utilisée dans notre solution. Tout le code utilisé dans cet exemple se trouve dans le GitHub référentiel.

Pré-requis

Pour suivre cet article, l'accès à RStudio sur SageMaker est requis. Si vous débutez dans l'utilisation de RStudio sur SageMaker, passez en revue Premiers pas avec RStudio sur Amazon SageMaker.

Nous devons également créer des conteneurs Docker personnalisés. Nous utilisons Création de code AWS pour construire ces conteneurs, vous avez donc besoin de quelques Gestion des identités et des accès AWS (IAM) autorisations que vous n'avez peut-être pas par défaut. Avant de continuer, assurez-vous que le rôle IAM que vous utilisez dispose d'une stratégie d'approbation avec CodeBuild :

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

Les autorisations suivantes sont également requises dans le rôle IAM pour exécuter une génération dans CodeBuild et envoyer l'image vers Registre des conteneurs élastiques 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"
                }
            }
        }
    ]
}

Créer des conteneurs R de base

Pour utiliser nos scripts R pour le traitement et la formation sur les tâches de traitement et de formation SageMaker, nous devons créer nos propres Conteneurs Docker contenant le runtime et les packages nécessaires. La possibilité d'utiliser votre propre conteneur, qui fait partie de l'offre SageMaker, offre une grande flexibilité aux développeurs et aux scientifiques des données pour utiliser les outils et les cadres de leur choix, sans pratiquement aucune limitation.

Nous créons deux conteneurs Docker compatibles R : un pour le traitement des tâches et un pour la formation et le déploiement de nos modèles. Le traitement des données nécessite généralement des packages et des bibliothèques différents de ceux de la modélisation, il est donc logique ici de séparer les deux étapes et d'utiliser des conteneurs différents.

Pour plus de détails sur l'utilisation des conteneurs avec SageMaker, reportez-vous à Utiliser des conteneurs Docker avec SageMaker.

Le conteneur utilisé pour le traitement est défini comme suit :

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

Pour ce poste, nous utilisons un contenant simple et relativement léger. En fonction de vos besoins ou de ceux de votre organisation, vous souhaiterez peut-être préinstaller plusieurs packages R supplémentaires.

Le conteneur utilisé pour la formation et le déploiement est défini comme suit :

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

Le noyau RStudio s'exécute sur un conteneur Docker, vous ne pourrez donc pas créer et déployer les conteneurs à l'aide des commandes Docker directement sur votre session Studio. Au lieu de cela, vous pouvez utiliser la bibliothèque très utile sagemaker-studio-image-build, qui sous-traite essentiellement la tâche de création de conteneurs à CodeBuild.

Avec les commandes suivantes, nous créons deux registres Amazon ECR : sagemaker-r-processing et sagemaker-r-train-n-deploy, et construisez les conteneurs respectifs que nous utiliserons plus tard :

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

Créer le pipeline

Maintenant que les conteneurs sont construits et prêts, nous pouvons créer le pipeline SageMaker qui orchestre le workflow de création de modèles. Le code complet de ceci est sous le fichier pipeline.R dans le référentiel. Le moyen le plus simple de créer un pipeline SageMaker consiste à utiliser le SDK SageMaker, qui est une bibliothèque Python à laquelle nous pouvons accéder à l'aide de la bibliothèque réticulé. Cela nous donne accès à toutes les fonctionnalités de SageMaker sans quitter l'environnement du langage R.

Le pipeline que nous construisons comprend les composants suivants :

• Étape de prétraitement – Il s'agit d'une tâche de traitement SageMaker (utilisant sagemaker-r-processing conteneur) responsable du prétraitement des données et de la division des données en ensembles de données d'apprentissage et de test.
• Étape d'entraînement – Il s'agit d'un travail de formation SageMaker (utilisant le sagemaker-r-train-n-deploy conteneur) responsable de la formation du modèle. Dans cet exemple, nous formons un modèle linéaire simple.
• Étape d'évaluation – Il s'agit d'une tâche de traitement SageMaker (utilisant sagemaker-r-processing container) chargé d'effectuer l'évaluation du modèle. Plus précisément dans cet exemple, nous nous intéressons au RMSE (erreur quadratique moyenne) sur l'ensemble de données de test, que nous voulons utiliser à l'étape suivante et associer au modèle lui-même.
• Étape conditionnelle – Il s'agit d'une étape conditionnelle, native des pipelines SageMaker, qui nous permet de brancher la logique du pipeline en fonction de certains paramètres. Dans ce cas, le pipeline se ramifie en fonction de la valeur de RMSE calculée à l'étape précédente.
• Enregistrer l'étape du modèle – Si l'étape conditionnelle précédente est True, et que les performances du modèle sont acceptables, le modèle est enregistré dans le registre des modèles. Pour plus d'informations, reportez-vous à Enregistrer et déployer des modèles avec Model Registry.

Appelez d'abord la fonction upsert pour créer (ou mettre à jour) le pipeline, puis appelez la fonction start pour démarrer réellement l'exécution du 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()

Inspecter le pipeline et le registre des modèles

L'un des avantages de l'utilisation de RStudio sur SageMaker est qu'en étant sur la plate-forme SageMaker, vous pouvez utiliser le bon outil pour le bon travail et basculer rapidement entre eux en fonction de ce que vous devez faire.

Dès que nous commençons l'exécution du pipeline, nous pouvons passer à Amazon SageMakerStudio, ce qui nous permet de visualiser le pipeline et de surveiller les exécutions actuelles et précédentes de celui-ci.

Pour afficher les détails du pipeline que nous venons de créer et d'exécuter, accédez à l'interface de l'IDE Studio, choisissez Ressources SageMaker, choisissez Pipelines dans le menu déroulant, et choisissez le pipeline (dans ce cas, AbalonePipelineUsingR).

Cela révèle les détails du pipeline, y compris toutes les exécutions actuelles et précédentes. Choisissez le dernier pour afficher une représentation visuelle du pipeline, comme indiqué dans la capture d'écran suivante.

Le DAG du pipeline est créé automatiquement par le service en fonction des dépendances de données entre les étapes, ainsi qu'en fonction des dépendances ajoutées personnalisées (aucune ajoutée dans cet exemple).

Lorsque l'exécution est terminée, en cas de succès, vous devriez voir toutes les étapes devenir vertes.

Le choix de l'une des étapes individuelles affiche des détails sur l'étape spécifique, y compris les entrées, les sorties, les journaux et les paramètres de configuration initiaux. Cela vous permet d'explorer le pipeline et d'examiner les étapes ayant échoué.

De même, lorsque le pipeline a fini de s'exécuter, un modèle est enregistré dans le registre des modèles. Pour y accéder, dans le Ressources SageMaker volet, choisissez Registre des modèles dans le menu déroulant et choisissez votre modèle. Cela révèle la liste des modèles enregistrés, comme indiqué dans la capture d'écran suivante. Choisissez-en un pour ouvrir la page de détails de cette version de modèle particulière.

Après avoir ouvert une version du modèle, choisissez Mise à jour Statut et Approuver pour approuver le modèle.

À ce stade, en fonction de votre cas d'utilisation, vous pouvez configurer cette approbation pour déclencher d'autres actions, y compris le déploiement du modèle selon vos besoins.

Déploiement sans serveur du modèle

Une fois que vous avez formé et enregistré un modèle sur SageMaker, le déploiement du modèle sur SageMaker est simple.

Il existe plusieurs options pour déployer un modèle, telles que l'inférence par lots, les points de terminaison en temps réel ou les points de terminaison asynchrones. Chaque méthode est livrée avec plusieurs configurations requises, notamment le choix du type d'instance souhaité ainsi que le mécanisme de mise à l'échelle.

Pour cet exemple, nous utilisons la fonctionnalité récemment annoncée de SageMaker, Inférence sans serveur (en mode aperçu au moment de la rédaction), pour déployer notre modèle R sur un point de terminaison sans serveur. Pour ce type de point de terminaison, nous définissons uniquement la quantité de RAM que nous voulons allouer au modèle pour l'inférence, ainsi que le nombre maximal d'invocations simultanées autorisées du modèle. SageMaker s'occupe de l'hébergement du modèle et de la mise à l'échelle automatique selon les besoins. Vous n'êtes facturé que pour le nombre exact de secondes et de données utilisées par le modèle, sans frais pour le temps d'inactivité.

Vous pouvez déployer le modèle sur un point de terminaison sans serveur avec le code suivant :

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 vous voyez l'erreur ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" le modèle que vous souhaitez déployer n'a pas été approuvé. Suivez les étapes de la section précédente pour approuver votre modèle.

Appelez le point de terminaison en envoyant une demande au point de terminaison HTTP que nous avons déployé ou utilisez plutôt le SDK SageMaker. Dans le code suivant, nous invoquons le point de terminaison sur certaines données de test :

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)

Le point de terminaison que nous avons invoqué était un point de terminaison sans serveur, et en tant que tel, nous sommes facturés pour la durée exacte et les données utilisées. Vous remarquerez peut-être que la première fois que vous appelez le point de terminaison, il faut environ une seconde pour répondre. Cela est dû à l'heure de démarrage à froid du point de terminaison sans serveur. Si vous effectuez une autre invocation peu de temps après, le modèle renvoie la prédiction en temps réel car il fait déjà chaud.

Lorsque vous avez fini de tester le point de terminaison, vous pouvez le supprimer à l'aide de la commande suivante :

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Conclusion

Dans cet article, nous avons parcouru le processus de création d'un pipeline SageMaker à l'aide de R dans notre environnement RStudio et expliqué comment déployer notre modèle R sur un point de terminaison sans serveur sur SageMaker à l'aide du registre de modèles SageMaker.

Grâce à la combinaison de RStudio et SageMaker, vous pouvez désormais créer et orchestrer des workflows ML complets de bout en bout sur AWS à l'aide de notre langage préféré, R.

Pour approfondir cette solution, je vous encourage à consulter le code source de cette solution, ainsi que d'autres exemples, sur GitHub.

À propos de l’auteur

Georgios Schinas est un architecte de solutions spécialisé pour l'IA/ML dans la région EMEA. Il est basé à Londres et travaille en étroite collaboration avec des clients au Royaume-Uni et en Irlande. Georgios aide les clients à concevoir et à déployer des applications d'apprentissage automatique en production sur AWS avec un intérêt particulier pour les pratiques MLOps et permettant aux clients d'effectuer l'apprentissage automatique à grande échelle. Dans ses temps libres, il aime voyager, cuisiner et passer du temps avec ses amis et sa famille.