Creați conducte de creare de modele Amazon SageMaker și implementați modele R folosind RStudio pe Amazon SageMaker

În noiembrie 2021, în colaborare cu RStudio PBC, Ne- a anunțat disponibilitatea generală a RStudio pe Amazon SageMaker, primul IDE RStudio Workbench complet gestionat din industrie în cloud. Acum vă puteți aduce licența RStudio actuală pentru a migra cu ușurință mediile RStudio auto-gestionate către Amazon SageMaker în doar câțiva pași simpli.

RStudio este unul dintre cele mai populare IDE-uri printre dezvoltatorii R pentru proiecte de învățare automată (ML) și știința datelor. RStudio oferă instrumente open-source pentru R și software profesional pregătit pentru întreprindere pentru echipele de știință a datelor pentru a dezvolta și a-și împărtăși munca în organizație. Aducerea RStudio pe SageMaker nu numai că vă oferă acces la infrastructura AWS într-un mod complet gestionat, dar vă oferă și acces nativ la SageMaker.

În această postare, explorăm modul în care puteți utiliza funcțiile SageMaker prin RStudio pe SageMaker pentru a construi o conductă SageMaker care construiește, procesează, antrenează și înregistrează modelele dvs. R. De asemenea, explorăm utilizarea SageMaker pentru implementarea modelului nostru, toate folosind R.

Prezentare generală a soluțiilor

Următoarea diagramă arată arhitectura utilizată în soluția noastră. Tot codul folosit în acest exemplu poate fi găsit în GitHub depozit.

Cerințe preliminare

Pentru a urmări această postare, este necesar accesul la RStudio pe SageMaker. Dacă sunteți nou în utilizarea RStudio pe SageMaker, examinați Începeți cu RStudio pe Amazon SageMaker.

De asemenea, trebuie să construim containere Docker personalizate. Folosim AWS CodeBuild pentru a construi aceste containere, deci aveți nevoie de câteva în plus Gestionarea identității și accesului AWS (IAM) permisiuni pe care este posibil să nu le aveți în mod implicit. Înainte de a continua, asigurați-vă că rolul IAM pe care îl utilizați are o politică de încredere cu CodeBuild:

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

Următoarele permisiuni sunt, de asemenea, necesare în rolul IAM pentru a rula o versiune în CodeBuild și pentru a împinge imaginea Registrul Amazon de containere elastice (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"
                }
            }
        }
    ]
}

Creați containere de bază R

Pentru a folosi scripturile noastre R pentru procesarea și instruirea privind procesarea și instruirea SageMaker, trebuie să ne creăm propriile Docker containere care conțin timpul de rulare și pachetele necesare. Abilitatea de a folosi propriul container, care face parte din oferta SageMaker, oferă dezvoltatorilor și cercetătorilor de date o mare flexibilitate de a utiliza instrumentele și cadrele alese, practic fără limitări.

Creăm două containere Docker compatibile cu R: unul pentru procesarea joburilor și unul pentru instruirea și implementarea modelelor noastre. Procesarea datelor necesită, de obicei, pachete și biblioteci diferite decât modelarea, așa că are sens aici să se separe cele două etape și să folosești containere diferite.

Pentru mai multe detalii despre utilizarea containerelor cu SageMaker, consultați Utilizarea containerelor Docker cu SageMaker.

Containerul utilizat pentru prelucrare este definit după cum urmează:

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

Pentru această postare, folosim un container simplu și relativ ușor. În funcție de nevoile dvs. sau ale organizației dvs., este posibil să doriți să preinstalați mai multe pachete R.

Containerul utilizat pentru instruire și implementare este definit după cum urmează:

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

Nucleul RStudio rulează pe un container Docker, așa că nu veți putea construi și implementa containerele folosind comenzi Docker direct în sesiunea dvs. Studio. În schimb, puteți folosi biblioteca foarte utilă sagemaker-studio-imagine-build, care în esență externalizează sarcina de a construi containere către CodeBuild.

Cu următoarele comenzi, creăm două registre Amazon ECR: sagemaker-r-processing și sagemaker-r-train-n-deploy, și construim containerele respective pe care le folosim mai târziu:

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ți conducta

Acum că containerele sunt construite și gata, putem crea conducta SageMaker care orchestrează fluxul de lucru pentru construirea modelului. Codul complet al acestuia se află sub fișier pipeline.R în depozit. Cea mai ușoară modalitate de a crea o conductă SageMaker este utilizarea SDK-ului SageMaker, care este o bibliotecă Python pe care o putem accesa folosind biblioteca. reticulat. Acest lucru ne oferă acces la toate funcționalitățile SageMaker fără a părăsi mediul limbajului R.

Conducta pe care o construim are următoarele componente:

• Etapa de preprocesare – Aceasta este o sarcină de procesare SageMaker (folosind programul sagemaker-r-processing container) responsabil pentru preprocesarea datelor și împărțirea datelor în seturi de date de tren și de testare.
• Etapa de antrenament – Acesta este un job de formare SageMaker (folosind programul sagemaker-r-train-n-deploy container) responsabil de antrenamentul modelului. În acest exemplu, antrenăm un model liniar simplu.
• Etapa de evaluare – Aceasta este o sarcină de procesare SageMaker (folosind programul sagemaker-r-processing container) responsabil cu efectuarea evaluării modelului. Mai exact, în acest exemplu, suntem interesați de RMSE (root mean square error) de pe setul de date de testare, pe care dorim să îl folosim în pasul următor, precum și să îl asociem cu modelul în sine.
• Pas condiționat – Acesta este un pas condiționat, nativ pentru conductele SageMaker, care ne permite să ramificăm logica conductei pe baza unui parametru. În acest caz, conducta se ramifică pe baza valorii RMSE care este calculată în pasul anterior.
• Înregistrați pasul modelului – Dacă pasul condițional precedent este True, iar performanța modelului este acceptabilă, atunci modelul este înregistrat în registrul de modele. Pentru mai multe informații, consultați Înregistrați și implementați modele cu Model Registry.

Mai întâi apelați funcția upsert pentru a crea (sau actualiza) conducta și apoi apelați funcția de pornire pentru a începe efectiv rularea conductei:

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

Inspectați conducta și registrul de modele

Unul dintre lucrurile grozave despre utilizarea RStudio pe SageMaker este că, fiind pe platforma SageMaker, puteți folosi instrumentul potrivit pentru munca potrivită și puteți comuta rapid între ele în funcție de ceea ce trebuie să faceți.

De îndată ce începem rularea conductei, putem trece la Amazon SageMaker Studio, ceea ce ne permite să vizualizăm conducta și să monitorizăm rulajele curente și anterioare ale acesteia.

Pentru a vedea detalii despre conducta pe care tocmai l-am creat și rulat, navigați la interfața Studio IDE, alegeți Resurse SageMaker, alege Conducte din meniul derulant și alegeți conducta (în acest caz, AbalonePipelineUsingR).

Aceasta dezvăluie detalii ale conductei, inclusiv toate rulajele curente și anterioare. Alegeți cel mai recent pentru a afișa o reprezentare vizuală a conductei, conform următoarei capturi de ecran.

DAG-ul conductei este creat automat de serviciu pe baza dependențelor de date dintre pași, precum și pe baza dependențelor adăugate personalizate (nu a fost adăugată niciuna în acest exemplu).

Când rularea este finalizată, dacă are succes, ar trebui să vedeți toți pașii devin verzi.

Alegerea oricăruia dintre pașii individuali aduce detalii despre pasul specific, inclusiv intrările, ieșirile, jurnalele și setările de configurare inițială. Acest lucru vă permite să detaliați în conductă și să investigați orice pași eșuați.

În mod similar, când conducta a terminat de rulat, un model este salvat în registrul modelului. Pentru a-l accesa, în Resurse SageMaker panoul, alegeți Registrul modelului din meniul derulant și alegeți modelul dvs. Aceasta dezvăluie lista de modele înregistrate, așa cum se arată în următoarea captură de ecran. Alegeți unul pentru a deschide pagina de detalii pentru respectiva versiune de model.

După ce deschideți o versiune a modelului, alegeți Starea de actualizare și Aproba pentru a aproba modelul.

În acest moment, pe baza cazului dvs. de utilizare, puteți configura această aprobare pentru a declanșa acțiuni suplimentare, inclusiv implementarea modelului în funcție de nevoile dvs.

Implementarea modelului fără server

După ce ați antrenat și înregistrat un model pe SageMaker, implementarea modelului pe SageMaker este simplă.

Există mai multe opțiuni cu privire la modul în care puteți implementa un model, cum ar fi inferența în lot, punctele finale în timp real sau punctele finale asincrone. Fiecare metodă vine cu mai multe configurații necesare, inclusiv alegerea tipului de instanță dorit, precum și mecanismul de scalare.

Pentru acest exemplu, folosim caracteristica recent anunțată a SageMaker, Inferență fără server (în modul de previzualizare la momentul scrierii), pentru a implementa modelul nostru R pe un punct final fără server. Pentru acest tip de punct final, definim doar cantitatea de RAM pe care dorim să fie alocată modelului pentru inferență, precum și numărul maxim de invocări concurente permise ale modelului. SageMaker se ocupă de găzduirea modelului și de scalarea automată după cum este necesar. Sunteți taxat doar pentru numărul exact de secunde și pentru datele utilizate de model, fără costuri pentru timpul inactiv.

Puteți implementa modelul într-un punct final fără server cu următorul cod:

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

Dacă vezi eroarea ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" modelul pe care doriți să îl implementați nu a fost aprobat. Urmați pașii din secțiunea anterioară pentru a vă aproba modelul.

Invocați punctul final trimițând o solicitare către punctul final HTTP pe care l-am implementat sau utilizați în schimb SDK-ul SageMaker. În următorul cod, invocăm punctul final pe unele date de testare:

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)

Punctul final pe care l-am invocat a fost un punct final fără server și, ca atare, suntem taxați pentru durata exactă și datele utilizate. Este posibil să observați că prima dată când invocați punctul final durează aproximativ o secundă pentru a răspunde. Acest lucru se datorează timpului de pornire la rece a punctului final fără server. Dacă faceți o altă invocare la scurt timp după aceea, modelul returnează predicția în timp real pentru că este deja cald.

Când terminați de experimentat cu punctul final, îl puteți șterge cu următoarea comandă:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Concluzie

În această postare, am parcurs procesul de creare a unei conducte SageMaker folosind R în mediul nostru RStudio și am prezentat cum să implementăm modelul nostru R pe un punct final fără server pe SageMaker folosind registrul modelului SageMaker.

Cu combinația dintre RStudio și SageMaker, puteți acum să creați și să orchestrați fluxuri de lucru complete ML end-to-end pe AWS folosind limba noastră preferată, R.

Pentru a aprofunda această soluție, vă încurajez să revizuiți codul sursă al acestei soluții, precum și alte exemple, pe GitHub.

Despre autor

Georgios Schinas este arhitect specializat în soluții pentru AI/ML în regiunea EMEA. Are sediul la Londra și lucrează îndeaproape cu clienții din Marea Britanie și Irlanda. Georgios îi ajută pe clienți să proiecteze și să implementeze aplicații de învățare automată în producție pe AWS, cu un interes deosebit pentru practicile MLOps și le permite clienților să efectueze învățarea automată la scară. În timpul liber, îi place să călătorească, să gătească și să petreacă timpul cu prietenii și familia.