Lag Amazon SageMaker-modellbyggingspipelines og distribuer R-modeller ved hjelp av RStudio på Amazon SageMaker

I november 2021, i samarbeid med RStudio PBC, vi annonsert den generelle tilgjengeligheten av RStudio på Amazon SageMaker, bransjens første fullt administrerte RStudio Workbench IDE i skyen. Du kan nå ta med din nåværende RStudio-lisens for enkelt å migrere dine selvadministrerte RStudio-miljøer til Amazon SageMaker i noen få enkle trinn.

RStudio er en av de mest populære IDE-ene blant R-utviklere for maskinlæring (ML) og datavitenskapsprosjekter. RStudio tilbyr åpen kildekode-verktøy for R og bedriftsklar profesjonell programvare for datavitenskapsteam for å utvikle og dele arbeidet sitt i organisasjonen. Å bringe RStudio på SageMaker gir deg ikke bare tilgang til AWS-infrastrukturen på en fullstendig administrert måte, men det gir deg også innfødt tilgang til SageMaker.

I dette innlegget utforsker vi hvordan du kan bruke SageMaker-funksjoner via RStudio på SageMaker for å bygge en SageMaker-pipeline som bygger, behandler, trener og registrerer R-modellene dine. Vi utforsker også bruken av SageMaker for vår modelldistribusjon, alt ved hjelp av R.

Løsningsoversikt

Følgende diagram viser arkitekturen som brukes i løsningen vår. All kode som brukes i dette eksemplet kan finnes i GitHub repository.

Forutsetninger

For å følge dette innlegget kreves tilgang til RStudio på SageMaker. Hvis du er ny til å bruke RStudio på SageMaker, se gjennom Kom i gang med RStudio på Amazon SageMaker.

Vi må også bygge tilpassede Docker-containere. Vi bruker AWS CodeBuild å bygge disse containerne, så du trenger noen ekstra AWS identitets- og tilgangsadministrasjon (IAM) tillatelser som du kanskje ikke har som standard. Før du fortsetter, sørg for at IAM-rollen du bruker har en tillitspolicy med CodeBuild:

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

Følgende tillatelser kreves også i IAM-rollen for å kjøre en build i CodeBuild og skyve bildet til 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"
                }
            }
        }
    ]
}

Lag baseline R-beholdere

For å bruke R-skriptene våre for prosessering og opplæring på SageMaker prosesserings- og opplæringsjobber, må vi lage våre egne Dockerbeholdere som inneholder nødvendig kjøretid og pakker. Muligheten til å bruke din egen container, som er en del av SageMaker-tilbudet, gir stor fleksibilitet til utviklere og dataforskere til å bruke verktøyene og rammeverkene de selv velger, praktisk talt uten begrensninger.

Vi lager to R-aktiverte Docker-beholdere: én for behandlingsjobber og én for opplæring og distribusjon av modellene våre. Behandling av data krever vanligvis andre pakker og biblioteker enn modellering, så det er fornuftig her å skille de to stadiene og bruke forskjellige beholdere.

For mer informasjon om bruk av beholdere med SageMaker, se Bruke Docker-containere med SageMaker.

Beholderen som brukes til behandling er definert som følger:

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

Til dette innlegget bruker vi en enkel og relativt lett beholder. Avhengig av dine eller organisasjonens behov, kan det være lurt å forhåndsinstallere flere R-pakker.

Beholderen som brukes til opplæring og distribusjon er definert som følger:

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-kjernen kjører på en Docker-beholder, så du vil ikke kunne bygge og distribuere beholderne ved å bruke Docker-kommandoer direkte på Studio-økten din. I stedet kan du bruke det svært nyttige biblioteket sagemaker-studio-image-build, som i hovedsak outsourcer oppgaven med å bygge containere til CodeBuild.

Med følgende kommandoer oppretter vi to Amazon ECR-registre: sagemaker-r-processing og sagemaker-r-train-n-deploy, og bygg de respektive beholderne som vi bruker senere:

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

Lag rørledningen

Nå som containerne er bygget og klare, kan vi lage SageMaker-rørledningen som orkestrerer arbeidsflyten for modellbygging. Den fullstendige koden for dette er under filen pipeline.R i depotet. Den enkleste måten å lage en SageMaker-pipeline på er å bruke SageMaker SDK, som er et Python-bibliotek som vi kan få tilgang til ved hjelp av biblioteket retikulere. Dette gir oss tilgang til alle funksjonene til SageMaker uten å forlate R-språkmiljøet.

Rørledningen vi bygger har følgende komponenter:

• Forbehandlingstrinn – Dette er en SageMaker-behandlingsjobb (som bruker sagemaker-r-processing container) ansvarlig for å forhåndsbehandle dataene og dele opp dataene i tog- og testdatasett.
• Treningstrinn – Dette er en SageMaker-treningsjobb (som bruker sagemaker-r-train-n-deploy container) ansvarlig for opplæring av modellen. I dette eksemplet trener vi en enkel lineær modell.
• Evalueringstrinn – Dette er en SageMaker-behandlingsjobb (som bruker sagemaker-r-processing container) ansvarlig for å utføre evaluering av modellen. Spesielt i dette eksemplet er vi interessert i RMSE (root mean square error) på testdatasettet, som vi ønsker å bruke i neste trinn, samt å assosiere med selve modellen.
• Betinget trinn – Dette er et betinget trinn, hjemmehørende i SageMaker-rørledninger, som lar oss forgrene rørledningslogikken basert på en eller annen parameter. I dette tilfellet forgrener rørledningen seg basert på verdien av RMSE som ble beregnet i forrige trinn.
• Registrer modelltrinn – Hvis det foregående betingede trinnet er True, og ytelsen til modellen er akseptabel, blir modellen registrert i modellregisteret. For mer informasjon, se Registrer og distribuer modeller med modellregister.

Kall først upsert-funksjonen for å opprette (eller oppdatere) rørledningen, og ring deretter startfunksjonen for å faktisk begynne å kjøre rørledningen:

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

Inspiser rørledningen og modellregisteret

En av de flotte tingene med å bruke RStudio på SageMaker er at ved å være på SageMaker-plattformen kan du bruke det riktige verktøyet til den rette jobben og raskt bytte mellom dem basert på hva du trenger å gjøre.

Så snart vi starter rørledningen kan vi bytte til Amazon SageMaker Studio, som lar oss visualisere rørledningen og overvåke nåværende og tidligere kjøringer av den.

For å se detaljer om rørledningen vi nettopp opprettet og kjørte, naviger til Studio IDE-grensesnittet, velg SageMaker-ressurser, velg Rørledninger på rullegardinmenyen, og velg rørledningen (i dette tilfellet, AbalonePipelineUsingR).

Dette avslører detaljer om rørledningen, inkludert alle nåværende og tidligere kjøringer. Velg den nyeste for å få opp en visuell representasjon av rørledningen, i henhold til følgende skjermbilde.

DAG-en til rørledningen opprettes automatisk av tjenesten basert på dataavhengighetene mellom trinnene, så vel som basert på egendefinerte avhengigheter (ikke lagt til noen i dette eksemplet).

Når kjøringen er fullført, hvis vellykket, bør du se at alle trinnene blir grønne.

Hvis du velger et av de individuelle trinnene, får du opp detaljer om det spesifikke trinnet, inkludert innganger, utganger, logger og innledende konfigurasjonsinnstillinger. Dette lar deg bore ned i rørledningen og undersøke eventuelle mislykkede trinn.

På samme måte, når rørledningen har kjørt ferdig, lagres en modell i modellregisteret. For å få tilgang til den, i SageMaker-ressurser ruten, velg Modellregister på rullegardinmenyen og velg din modell. Dette avslører listen over registrerte modeller, som vist i følgende skjermbilde. Velg en for å åpne detaljsiden for den aktuelle modellversjonen.

Når du har åpnet en versjon av modellen, velger du Oppdatere status og Godkjenne for å godkjenne modellen.

På dette tidspunktet, basert på din brukssituasjon, kan du sette opp denne godkjenningen for å utløse ytterligere handlinger, inkludert distribusjon av modellen i henhold til dine behov.

Serverløs distribusjon av modellen

Etter at du har trent og registrert en modell på SageMaker, er det enkelt å distribuere modellen på SageMaker.

Det er flere alternativer for hvordan du kan distribuere en modell, for eksempel batch-inferens, sanntidsendepunkter eller asynkrone endepunkter. Hver metode kommer med flere nødvendige konfigurasjoner, inkludert valg av forekomsttype du ønsker, samt skaleringsmekanisme.

For dette eksemplet bruker vi den nylig annonserte funksjonen til SageMaker, Serverløs slutning (i forhåndsvisningsmodus i skrivende stund), for å distribuere R-modellen vår på et serverløst endepunkt. For denne typen endepunkter definerer vi bare mengden RAM som vi ønsker skal allokeres til modellen for slutning, samt maksimalt antall tillatte samtidige påkallinger av modellen. SageMaker tar seg av å være vert for modellen og automatisk skalering etter behov. Du belastes kun for det nøyaktige antallet sekunder og data som brukes av modellen, uten kostnad for inaktiv tid.

Du kan distribuere modellen til et serverløst endepunkt med følgende kode:

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

Hvis du ser feilen ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" modellen du vil distribuere, er ikke godkjent. Følg trinnene fra forrige seksjon for å godkjenne modellen din.

Påkall endepunktet ved å sende en forespørsel til HTTP-endepunktet vi distribuerte, eller bruk i stedet SageMaker SDK. I følgende kode påkaller vi endepunktet på noen 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)

Endepunktet vi påkalte var et serverløst endepunkt, og som sådan belastes vi for nøyaktig varighet og data som brukes. Du vil kanskje legge merke til at første gang du påkaller endepunktet, tar det omtrent et sekund å svare. Dette skyldes kaldstarttiden til det serverløse endepunktet. Hvis du gjør en ny påkalling kort tid etter, returnerer modellen prediksjonen i sanntid fordi den allerede er varm.

Når du er ferdig med å eksperimentere med endepunktet, kan du slette det med følgende kommando:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

konklusjonen

I dette innlegget gikk vi gjennom prosessen med å lage en SageMaker-pipeline ved hjelp av R i vårt RStudio-miljø og viste frem hvordan du distribuerer R-modellen vår på et serverløst endepunkt på SageMaker ved å bruke SageMaker-modellregisteret.

Med kombinasjonen av RStudio og SageMaker kan du nå opprette og orkestrere komplette ende-til-ende ML-arbeidsflyter på AWS ved å bruke vårt foretrukne språk, R.

For å dykke dypere inn i denne løsningen, oppfordrer jeg deg til å gå gjennom kildekoden til denne løsningen, samt andre eksempler, på GitHub.

om forfatteren

Georgios Schinas er en spesialistløsningsarkitekt for AI/ML i EMEA-regionen. Han er basert i London og jobber tett med kunder i Storbritannia og Irland. Georgios hjelper kunder med å designe og distribuere maskinlæringsapplikasjoner i produksjon på AWS med en spesiell interesse for MLOps-praksis og gjør det mulig for kunder å utføre maskinlæring i stor skala. På fritiden liker han å reise, lage mat og tilbringe tid med venner og familie.