Skapa Amazon SageMaker modellbyggande pipelines och distribuera R-modeller med RStudio på Amazon SageMaker

I november 2021, i samarbete med RStudio PBC, Vi meddelade den allmänna tillgängligheten till RStudio på Amazon SageMaker, branschens första fullt hanterade RStudio Workbench IDE i molnet. Du kan nu ta med din nuvarande RStudio-licens för att enkelt migrera dina självhanterade RStudio-miljöer till Amazon SageMaker med bara några enkla steg.

RStudio är en av de mest populära IDE:erna bland R-utvecklare för maskininlärning (ML) och datavetenskapsprojekt. RStudio tillhandahåller öppen källkodsverktyg för R och företagsklar professionell programvara för datavetenskapsteam att utveckla och dela sitt arbete i organisationen. Att ta med RStudio på SageMaker ger dig inte bara tillgång till AWS-infrastrukturen på ett helt hanterat sätt, utan det ger dig också inbyggd åtkomst till SageMaker.

I det här inlägget utforskar vi hur du kan använda SageMaker-funktioner via RStudio på SageMaker för att bygga en SageMaker-pipeline som bygger, bearbetar, tränar och registrerar dina R-modeller. Vi utforskar också att använda SageMaker för vår modellinstallation, allt med R.

Lösningsöversikt

Följande diagram visar arkitekturen som används i vår lösning. All kod som används i detta exempel kan hittas i GitHub repository.

Förutsättningar

För att följa detta inlägg krävs tillgång till RStudio på SageMaker. Om du är ny på att använda RStudio på SageMaker, granska Kom igång med RStudio på Amazon SageMaker.

Vi behöver också bygga anpassade Docker-containrar. Vi använder AWS CodeBuild för att bygga dessa containrar, så du behöver några extra AWS identitets- och åtkomsthantering (IAM) behörigheter som du kanske inte har som standard. Innan du fortsätter, se till att IAM-rollen som du använder har en förtroendepolicy med CodeBuild:

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

Följande behörigheter krävs också i IAM-rollen för att köra en build i CodeBuild och skicka bilden till Amazon Elastic Container Registry (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"
                }
            }
        }
    ]
}

Skapa baslinje R-behållare

För att använda våra R-skript för bearbetning och utbildning på SageMaker bearbetnings- och utbildningsjobb måste vi skapa våra egna Dockerbehållare som innehåller nödvändig körtid och paket. Möjligheten att använda din egen behållare, som är en del av SageMaker-erbjudandet, ger stor flexibilitet för utvecklare och datavetare att använda de verktyg och ramverk som de själva väljer, praktiskt taget utan begränsningar.

Vi skapar två R-aktiverade Docker-containrar: en för bearbetning av jobb och en för utbildning och driftsättning av våra modeller. Bearbetning av data kräver vanligtvis andra paket och bibliotek än modellering, så det är klokt här att separera de två stegen och använda olika behållare.

För mer information om hur du använder behållare med SageMaker, se Använda Docker -behållare med SageMaker.

Behållaren som används för bearbetning definieras enligt följande:

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

För det här inlägget använder vi en enkel och relativt lätt behållare. Beroende på dina eller din organisations behov kanske du vill förinstallera flera fler R-paket.

Behållaren som används för utbildning och driftsättning definieras enligt följande:

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

RStudio-kärnan körs på en Docker-behållare, så du kommer inte att kunna bygga och distribuera behållarna med Docker-kommandon direkt på din Studio-session. Istället kan du använda det mycket användbara biblioteket sagemaker-studio-image-build, som i huvudsak lägger ut uppgiften att bygga containrar till CodeBuild.

Med följande kommandon skapar vi två Amazon ECR-register: sagemaker-r-processing och sagemaker-r-train-n-deploy, och bygg respektive behållare som vi använder senare:

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

Skapa pipeline

Nu när containrarna är byggda och klara kan vi skapa SageMaker-pipeline som orkestrerar modellbyggandets arbetsflöde. Den fullständiga koden för detta finns under filen pipeline.R i förvaret. Det enklaste sättet att skapa en SageMaker-pipeline är att använda SageMaker SDK, som är ett Python-bibliotek som vi kan komma åt med hjälp av biblioteket nätformiga. Detta ger oss tillgång till alla funktioner i SageMaker utan att lämna R-språkmiljön.

Den pipeline vi bygger har följande komponenter:

• Förbehandlingssteg – Det här är ett SageMaker-bearbetningsjobb (som använder sagemaker-r-processing container) ansvarig för att förbearbeta data och dela upp data i tåg- och testdatauppsättningar.
• Träningssteg – Det här är ett SageMaker-utbildningsjobb (som använder sagemaker-r-train-n-deploy container) ansvarig för att träna modellen. I det här exemplet tränar vi en enkel linjär modell.
• Utvärderingssteg – Det här är ett SageMaker-bearbetningsjobb (som använder sagemaker-r-processing container) ansvarig för att utföra utvärdering av modellen. Specifikt i det här exemplet är vi intresserade av RMSE (root mean square error) på testdatauppsättningen, som vi vill använda i nästa steg såväl som för att associera med själva modellen.
• Villkorligt steg – Det här är ett villkorligt steg, inbyggt i SageMaker-pipelines, som tillåter oss att förgrena pipeline-logiken baserat på någon parameter. I det här fallet förgrenas pipelinen baserat på värdet på RMSE som beräknades i föregående steg.
• Registrera modellsteg – Om det föregående villkorade steget är True, och modellens prestanda är acceptabel, registreras modellen i modellregistret. För mer information, se Registrera och distribuera modeller med Model Registry.

Anrop först upsert-funktionen för att skapa (eller uppdatera) pipelinen och anrop sedan startfunktionen för att faktiskt börja köra 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()

Inspektera pipeline- och modellregistret

En av de fantastiska sakerna med att använda RStudio på SageMaker är att genom att vara på SageMaker-plattformen kan du använda rätt verktyg för rätt jobb och snabbt växla mellan dem baserat på vad du behöver göra.

Så fort vi påbörjar pipelinekörningen kan vi byta till Amazon SageMaker Studio, vilket gör att vi kan visualisera pipelinen och övervaka nuvarande och tidigare körningar av den.

För att se detaljer om pipeline vi just skapade och körde, navigera till Studio IDE-gränssnittet, välj SageMaker-resurserväljer Rörledningar på rullgardinsmenyn och välj pipeline (i det här fallet, AbalonePipelineUsingR).

Detta avslöjar detaljer om pipelinen, inklusive alla nuvarande och tidigare körningar. Välj den senaste för att få upp en visuell representation av pipelinen, enligt följande skärmdump.

DAG för pipelinen skapas automatiskt av tjänsten baserat på databeroenden mellan stegen, såväl som baserat på anpassade tillagda beroenden (inte lagt till några i det här exemplet).

När körningen är klar, om den lyckades, bör du se att alla steg blir gröna.

Om du väljer något av de enskilda stegen visas detaljer om det specifika steget, inklusive ingångar, utgångar, loggar och initiala konfigurationsinställningar. Detta gör att du kan borra ner i pipelinen och undersöka eventuella misslyckade steg.

På samma sätt, när pipelinen har körts färdig, sparas en modell i modellregistret. För att komma åt det, i SageMaker-resurser välj Modellregister på rullgardinsmenyn och välj din modell. Detta avslöjar listan över registrerade modeller, som visas i följande skärmdump. Välj en för att öppna informationssidan för just den modellversionen.

När du har öppnat en version av modellen väljer du Uppdatera status och Godkänn att godkänna modellen.

Vid det här laget, baserat på ditt användningsfall, kan du ställa in detta godkännande för att utlösa ytterligare åtgärder, inklusive implementeringen av modellen enligt dina behov.

Serverlös distribution av modellen

När du har tränat och registrerat en modell på SageMaker är det enkelt att distribuera modellen på SageMaker.

Det finns flera alternativ för hur du kan distribuera en modell, till exempel batchinferens, realtidsslutpunkter eller asynkrona slutpunkter. Varje metod kommer med flera nödvändiga konfigurationer, inklusive att välja den instanstyp du vill ha samt skalningsmekanismen.

För det här exemplet använder vi den nyligen tillkännagivna funktionen i SageMaker, Serverlös slutledning (i förhandsgranskningsläge i skrivande stund), för att distribuera vår R-modell på en serverlös slutpunkt. För denna typ av slutpunkt definierar vi bara mängden RAM som vi vill ska allokeras till modellen för slutledning, såväl som det maximala antalet tillåtna samtidiga anrop av modellen. SageMaker tar hand om att vara värd för modellen och automatisk skalning efter behov. Du debiteras endast för det exakta antalet sekunder och data som används av modellen, utan kostnad för vilotid.

Du kan distribuera modellen till en serverlös slutpunkt med följande kod:

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

Om du ser felet ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" modellen du vill distribuera har inte godkänts. Följ stegen från föregående avsnitt för att godkänna din modell.

Anropa slutpunkten genom att skicka en begäran till HTTP-slutpunkten vi distribuerade, eller använd istället SageMaker SDK. I följande kod anropar vi slutpunkten på vissa testdata:

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)

Slutpunkten vi anropade var en serverlös slutpunkt, och som sådan debiteras vi för exakt varaktighet och data som används. Du kanske märker att första gången du anropar slutpunkten tar det ungefär en sekund att svara. Detta beror på kallstarttiden för den serverlösa slutpunkten. Om du gör en ny anrop strax efteråt, returnerar modellen förutsägelsen i realtid eftersom det redan är varmt.

När du är klar med att experimentera med slutpunkten kan du ta bort den med följande kommando:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Slutsats

I det här inlägget gick vi igenom processen att skapa en SageMaker-pipeline med hjälp av R i vår RStudio-miljö och visade hur man distribuerar vår R-modell på en serverlös slutpunkt på SageMaker med hjälp av SageMaker-modellregistret.

Med kombinationen av RStudio och SageMaker kan du nu skapa och orkestrera kompletta end-to-end ML-arbetsflöden på AWS med vårt föredragna språk, R.

För att dyka djupare in i den här lösningen uppmuntrar jag dig att granska källkoden för den här lösningen, såväl som andra exempel, på GitHub.

Om författaren

Georgios Schinas är en specialistlösningsarkitekt för AI/ML i EMEA-regionen. Han är baserad i London och arbetar nära kunder i Storbritannien och Irland. Georgios hjälper kunder att designa och distribuera maskininlärningsapplikationer i produktion på AWS med ett särskilt intresse för MLOps-praxis och gör det möjligt för kunder att utföra maskininlärning i stor skala. På fritiden tycker han om att resa, laga mat och umgås med vänner och familj.