Looge Amazon SageMakeri mudelite ehitamise torujuhtmeid ja juurutage R-mudeleid, kasutades RStudiot Amazon SageMakeris

Novembris 2021 koostöös RStudio PBCOleme teatas - üldine kättesaadavus RStudio Amazon SageMakeris, valdkonna esimene täielikult hallatav RStudio Workbench IDE pilves. Nüüd saate oma praeguse RStudio litsentsi kaasa võtta, et oma isehallatavad RStudio keskkonnad hõlpsalt üle viia Amazon SageMaker vaid mõne lihtsa sammuga.

RStudio on R-i arendajate seas üks populaarsemaid IDE-sid masinõppe (ML) ja andmeteaduse projektide jaoks. RStudio pakub avatud lähtekoodiga tööriistu R-ile ja ettevõtte jaoks valmis professionaalset tarkvara andmeteaduse meeskondadele, et arendada ja jagada oma tööd organisatsioonis. RStudio lisamine SageMakerisse ei anna teile mitte ainult täielikult hallatud juurdepääsu AWS-i infrastruktuurile, vaid annab teile ka loomuliku juurdepääsu SageMakerile.

Selles postituses uurime, kuidas saate SageMakeri RStudio kaudu kasutada SageMakeri funktsioone, et luua SageMakeri torujuhe, mis loob, töötleb, treenib ja registreerib teie R-mudeleid. Samuti uurime oma mudeli juurutamiseks SageMakeri kasutamist, kasutades R.

Lahenduse ülevaade

Järgmine diagramm näitab meie lahenduses kasutatud arhitektuuri. Kogu selles näites kasutatud koodi leiate GitHubi hoidla.

Eeldused

Selle postituse jälgimiseks on vaja juurdepääsu RStudiole saidil SageMaker. Kui olete SageMakeris RStudio kasutamine uus, vaadake üle Alustage RStudioga Amazon SageMakeris.

Samuti peame ehitama kohandatud Dockeri konteinereid. Me kasutame AWS CodeBuild nende konteinerite ehitamiseks, nii et vajate mõnda lisa AWS-i identiteedi- ja juurdepääsuhaldus (IAM) õigused, mis teil vaikimisi ei pruugi olla. Enne jätkamist veenduge, et teie kasutataval IAM-rollil on CodeBuildi usalduspoliitika:

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

Järgmised õigused on vajalikud ka IAM-i rollis CodeBuildis järgu käitamiseks ja pildi edastamiseks Amazoni elastsete konteinerite register (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"
                }
            }
        }
    ]
}

Looge algtaseme R-konteinerid

R-skriptide kasutamiseks SageMakeri töötlemis- ja koolitustööde töötlemiseks ja koolitamiseks peame looma oma Dokkeri konteinerid mis sisaldab vajalikku käitusaega ja pakette. Võimalus kasutada oma konteinerit, mis on osa SageMakeri pakkumisest, annab arendajatele ja andmeteadlastele suure paindlikkuse oma valitud tööriistade ja raamistike kasutamiseks praktiliselt ilma piiranguteta.

Loome kaks R-toega Dockeri konteinerit: ühe tööde töötlemiseks ja teise meie mudelite koolitamiseks ja juurutamiseks. Andmete töötlemine nõuab tavaliselt erinevaid pakette ja teeke kui modelleerimine, seega on siinkohal mõistlik need kaks etappi eraldada ja kasutada erinevaid konteinereid.

Lisateavet konteinerite kasutamise kohta koos SageMakeriga leiate artiklist Dockeri konteinerite kasutamine koos SageMakeriga.

Töötlemiseks kasutatav konteiner on määratletud järgmiselt:

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

Selle postituse jaoks kasutame lihtsat ja suhteliselt kerget anumat. Sõltuvalt teie või teie organisatsiooni vajadustest võite soovida eelinstallida veel mitu R-paketti.

Väljaõppeks ja kasutuselevõtuks kasutatav konteiner on määratletud järgmiselt:

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 kernel töötab Dockeri konteineris, nii et te ei saa luua ega juurutada konteinereid Dockeri käskude abil otse oma Studio seansil. Selle asemel võite kasutada väga kasulikku raamatukogu sagemaker-studio-image-build, mis sisuliselt tellib konteinerite ehitamise ülesande CodeBuildile.

Järgmiste käskudega loome kaks Amazon ECR registrit: sagemaker-r-processing ja sagemaker-r-train-n-deployja ehitage vastavad konteinerid, mida me hiljem kasutame:

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

Loo torujuhe

Nüüd, kui konteinerid on ehitatud ja valmis, saame luua SageMakeri torujuhtme, mis juhib mudeli loomise töövoogu. Selle täielik kood on faili all pipeline.R hoidlas. Lihtsaim viis SageMakeri torujuhtme loomiseks on kasutada SageMaker SDK-d, mis on Pythoni teek, millele pääseme juurde teegi abil võrgutama. See annab meile juurdepääsu kõigile SageMakeri funktsioonidele ilma R-keelekeskkonnast lahkumata.

Meie ehitatud torujuhtmel on järgmised komponendid:

• Eeltöötluse etapp – See on SageMakeri töötlemistöö (kasutades sagemaker-r-processing konteiner), kes vastutab andmete eeltöötlemise ja andmete jagamise eest rongi- ja katseandmekogumiteks.
• Treeningu samm - See on SageMakeri koolitustöö (kasutades sagemaker-r-train-n-deploy konteiner), kes vastutab mudeli väljaõppe eest. Selles näites treenime lihtsat lineaarset mudelit.
• Hindamise etapp – See on SageMakeri töötlemistöö (kasutades sagemaker-r-processing konteiner), kes vastutab mudeli hindamise eest. Täpsemalt selles näites oleme huvitatud testandmestiku RMSE-st (root mean square error), mida soovime kasutada järgmises etapis ja seostada mudeli endaga.
• Tingimuslik samm – See on SageMakeri torujuhtmetele omane tingimuslik samm, mis võimaldab meil konveieri loogikat mõne parameetri alusel hargneda. Sel juhul hargneb torujuhe eelmises etapis arvutatud RMSE väärtuse alusel.
• Registreeri mudeli samm – Kui eelnev tingimuslik samm on True, ja mudeli jõudlus on vastuvõetav, registreeritakse mudel mudeliregistris. Lisateabe saamiseks vaadake Registreerige ja juurutage mudelid mudeliregistriga.

Konveieri loomiseks (või värskendamiseks) kutsuge esmalt üles funktsioon upsert ja seejärel käivitage funktsioon, et konveier käivitada:

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

Kontrollige torujuhtme ja mudeliregistrit

Üks suurepäraseid asju RStudio kasutamisel SageMakeris on see, et SageMakeri platvormil olles saate kasutada õige töö jaoks õiget tööriista ja vahetada nende vahel kiiresti vastavalt sellele, mida peate tegema.

Niipea kui alustame torujuhtme käitamist, saame lülituda sellele Amazon SageMaker Studio, mis võimaldab meil konveieri visualiseerida ning jälgida selle praegust ja eelnevat käitamist.

Äsja loodud ja käitatud konveieri üksikasjade vaatamiseks liikuge Studio IDE liidesesse ja valige SageMakeri ressursid, vali Torujuhtmed rippmenüüst ja valige torujuhe (antud juhul AbalonePipelineUsingR).

See näitab torujuhtme üksikasju, sealhulgas kõiki praeguseid ja eelnevaid käike. Valige uusim, et kuvada konveieri visuaalne esitus vastavalt järgmisele ekraanipildile.

Konveieri DAG-i loob teenus automaatselt nii etappidevaheliste andmete sõltuvuste kui ka kohandatud lisatud sõltuvuste põhjal (selles näites pole ühtegi lisatud).

Kui jooks on lõppenud, peaksite nägema, et kõik sammud muutuvad roheliseks.

Üksikute sammude valimisel kuvatakse konkreetse sammu üksikasjad, sealhulgas sisendid, väljundid, logid ja esialgsed konfiguratsioonisätted. See võimaldab teil torustikku põhjalikumalt uurida ja ebaõnnestunud toiminguid uurida.

Samamoodi, kui konveier on töötamise lõpetanud, salvestatakse mudel mudeliregistrisse. Sellele juurdepääsu saamiseks avage SageMakeri ressursid paneel, valige Mudelite register rippmenüüst ja valige oma mudel. See näitab registreeritud mudelite loendit, nagu on näidatud järgmisel ekraanipildil. Valige üks, et avada selle konkreetse mudeliversiooni üksikasjade leht.

Pärast mudeli versiooni avamist valige oleku uuendus ja Heaks kiitma mudeli kinnitamiseks.

Praegu saate oma kasutusjuhtumi põhjal selle kinnituse seadistada, et käivitada edasised toimingud, sealhulgas mudeli juurutamine vastavalt teie vajadustele.

Mudeli serverivaba juurutamine

Kui olete mudeli SageMakeris välja õpetanud ja registreerinud, on mudeli SageMakeris juurutamine lihtne.

Mudeli juurutamiseks on mitu võimalust, näiteks partii järeldused, reaalajas lõpp-punktid või asünkroonsed lõpp-punktid. Igal meetodil on mitu nõutavat konfiguratsiooni, sealhulgas soovitud eksemplari tüübi ja skaleerimismehhanismi valimine.

Selle näite puhul kasutame hiljuti välja kuulutatud SageMakeri funktsiooni, Serverita järeldus (kirjutamise ajal eelvaaterežiimis), et juurutada meie R-mudel serverita lõpp-punktis. Seda tüüpi lõpp-punkti puhul määratleme ainult RAM-i hulga, mida tahame mudelile järelduste tegemiseks eraldada, ning mudeli lubatud samaaegsete kutsumiste maksimaalse arvu. SageMaker hoolitseb mudeli hostimise ja vajaduse korral automaatse skaleerimise eest. Teilt võetakse tasu ainult mudeli kasutatud täpse arvu sekundite ja andmete eest, ilma jõudeaja kuluta.

Saate mudeli juurutada serverita lõpp-punktis järgmise koodiga:

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

Kui näete viga ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" mudelit, mida soovite juurutada, pole heaks kiidetud. Mudeli kinnitamiseks järgige eelmises jaotises toodud juhiseid.

Kutsuge lõpp-punkt, saates päringu meie juurutatud HTTP-otspunktile, või kasutage selle asemel SageMakeri SDK-d. Järgmises koodis kutsume mõne testiandmete lõpp-punkti:

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)

Lõpp-punkt, mille me kutsusime, oli serverita lõpp-punkt ja sellisena võetakse meilt tasu täpse kestuse ja kasutatud andmete eest. Võite märgata, et lõpp-punkti esmakordsel käivitamisel kulub vastamiseks umbes sekund. Selle põhjuseks on serverita lõpp-punkti külmkäivitusaeg. Kui teete varsti pärast seda uuesti, tagastab mudel ennustuse reaalajas, kuna see on juba soe.

Kui olete lõpp-punktiga katsetamise lõpetanud, saate selle järgmise käsuga kustutada:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Järeldus

Selles postituses käisime läbi SageMakeri torujuhtme loomise protsessi, kasutades R-i meie RStudio keskkonnas, ja tutvustasime, kuidas juurutada meie R-mudelit SageMakeri serverita lõpp-punktis, kasutades SageMakeri mudeliregistrit.

RStudio ja SageMakeri kombinatsiooniga saate nüüd luua ja korraldada täielikke täielikke ML-i töövooge AWS-is, kasutades meie eelistatud keelt R.

Sellesse lahendusse sügavamale sukeldumiseks soovitan teil tutvuda selle lahenduse lähtekoodi ja muude näidetega. GitHub.

Teave Autor

Georgios Schinas on tehisintellekti/ML-i spetsialiseerunud lahenduste arhitekt EMEA piirkonnas. Ta asub Londonis ja teeb tihedat koostööd klientidega Ühendkuningriigis ja Iirimaal. Georgios aitab klientidel kavandada ja juurutada masinõpperakendusi tootmises AWS-is, tundes erilist huvi MLOps-i tavade vastu ja võimaldades klientidel teostada masinõpet ulatuslikult. Vabal ajal meeldib talle reisida, süüa teha ning sõprade ja perega aega veeta.