Maak Amazon SageMaker-pijplijnen voor het bouwen van modellen en implementeer R-modellen met RStudio op Amazon SageMaker

In november 2021, in samenwerking met RStudio PBC, wij aangekondigd de algemene beschikbaarheid van RStudio op Amazon SageMaker, de eerste volledig beheerde RStudio Workbench IDE in de cloud in de branche. U kunt nu uw huidige RStudio-licentie meenemen om uw zelfbeheerde RStudio-omgevingen eenvoudig te migreren naar Amazon Sage Maker in slechts een paar eenvoudige stappen.

RStudio is een van de meest populaire IDE's onder R-ontwikkelaars voor machine learning (ML) en data science-projecten. RStudio biedt open-source tools voor R en bedrijfsklare professionele software voor data science-teams om hun werk in de organisatie te ontwikkelen en te delen. Door RStudio op SageMaker te brengen, krijgt u niet alleen op een volledig beheerde manier toegang tot de AWS-infrastructuur, maar krijgt u ook native toegang tot SageMaker.

In dit bericht onderzoeken we hoe u SageMaker-functies via RStudio op SageMaker kunt gebruiken om een ​​SageMaker-pijplijn te bouwen die uw R-modellen bouwt, verwerkt, traint en registreert. We onderzoeken ook het gebruik van SageMaker voor onze modelimplementatie, allemaal met R.

Overzicht oplossingen

Het volgende diagram toont de architectuur die in onze oplossing wordt gebruikt. Alle code die in dit voorbeeld wordt gebruikt, is te vinden in de GitHub-repository.

Voorwaarden

Om dit bericht te volgen, is toegang tot RStudio op SageMaker vereist. Als je nieuw bent in het gebruik van RStudio op SageMaker, bekijk dan Ga aan de slag met RStudio op Amazon SageMaker.

We moeten ook aangepaste Docker-containers bouwen. We gebruiken AWS CodeBuild om deze containers te bouwen, dus je hebt er een paar extra nodig AWS Identiteits- en toegangsbeheer (IAM)-machtigingen die u mogelijk niet standaard hebt. Voordat u doorgaat, moet u ervoor zorgen dat de IAM-rol die u gebruikt een vertrouwensbeleid heeft met CodeBuild:

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

De volgende machtigingen zijn ook vereist in de IAM-rol om een ​​build in CodeBuild uit te voeren en de afbeelding te pushen naar: Amazon Elastic Container-register (Amazone 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"
                }
            }
        }
    ]
}

Basislijn R-containers maken

Om onze R-scripts te gebruiken voor het verwerken en trainen van SageMaker-verwerkings- en trainingstaken, moeten we onze eigen maken Dockercontainers met daarin de benodigde runtime en pakketten. De mogelijkheid om uw eigen container te gebruiken, die deel uitmaakt van het SageMaker-aanbod, biedt ontwikkelaars en datawetenschappers grote flexibiliteit om de tools en frameworks van hun keuze te gebruiken, vrijwel zonder beperkingen.

We maken twee R-enabled Docker-containers: één voor het verwerken van taken en één voor training en implementatie van onze modellen. Het verwerken van gegevens vereist doorgaans andere pakketten en bibliotheken dan modellering, dus het is hier logisch om de twee fasen te scheiden en verschillende containers te gebruiken.

Voor meer details over het gebruik van containers met SageMaker, zie: Docker-containers gebruiken met SageMaker.

De container die voor de verwerking wordt gebruikt, is als volgt gedefinieerd:

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

Voor dit bericht gebruiken we een eenvoudige en relatief lichtgewicht container. Afhankelijk van de behoeften van u of uw organisatie, wilt u misschien meerdere R-pakketten vooraf installeren.

De container die wordt gebruikt voor training en implementatie is als volgt gedefinieerd:

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

De RStudio-kernel draait op een Docker-container, dus u kunt de containers niet rechtstreeks in uw Studio-sessie bouwen en implementeren met Docker-opdrachten. In plaats daarvan kunt u de zeer nuttige bibliotheek gebruiken sagemaker-studio-image-build, die in wezen de taak van het bouwen van containers uitbesteedt aan CodeBuild.

Met de volgende opdrachten maken we twee Amazon ECR-registers: sagemaker-r-processing en sagemaker-r-train-n-deploy, en bouw de respectievelijke containers die we later gebruiken:

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

Maak de pijplijn

Nu de containers zijn gebouwd en klaar zijn, kunnen we de SageMaker-pijplijn maken die de werkstroom voor het bouwen van modellen orkestreert. De volledige code hiervan staat onder het bestand pipeline.R in de bewaarplaats. De eenvoudigste manier om een ​​SageMaker-pijplijn te maken, is door de SageMaker SDK te gebruiken, een Python-bibliotheek waartoe we toegang hebben via de bibliotheek reticulair. Dit geeft ons toegang tot alle functionaliteiten van SageMaker zonder de R-taalomgeving te verlaten.

De pijplijn die we bouwen heeft de volgende componenten:

• Voorbewerkingsstap: – Dit is een SageMaker-verwerkingstaak (gebruikmakend van de sagemaker-r-processing container) verantwoordelijk voor het voorbewerken van de data en het opsplitsen van de data in trein- en testdatasets.
• Trainingsstap – Dit is een SageMaker-trainingsbaan (gebruikmakend van de sagemaker-r-train-n-deploy container) verantwoordelijk voor het trainen van het model. In dit voorbeeld trainen we een eenvoudig lineair model.
• Evaluatiestap – Dit is een SageMaker-verwerkingstaak (gebruikmakend van de sagemaker-r-processing container) die verantwoordelijk is voor het uitvoeren van de evaluatie van het model. Specifiek in dit voorbeeld zijn we geïnteresseerd in de RMSE (root mean square error) op de testdataset, die we in de volgende stap willen gebruiken en ook willen associëren met het model zelf.
• Voorwaardelijke stap – Dit is een voorwaardelijke stap, eigen aan SageMaker-pijplijnen, waarmee we de pijplijnlogica kunnen vertakken op basis van een parameter. In dit geval vertakt de pijplijn zich op basis van de waarde van RMSE die in de vorige stap is berekend.
• Model stap registreren – Als de voorgaande voorwaardelijke stap is True, en de prestatie van het model acceptabel is, wordt het model geregistreerd in het modelregister. Voor meer informatie, zie: Modellen registreren en implementeren met modelregister.

Roep eerst de upsert-functie aan om de pijplijn te maken (of bij te werken) en roep vervolgens de startfunctie aan om de pijplijn daadwerkelijk uit te voeren:

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

Inspecteer de pijplijn en het modelregister

Een van de geweldige dingen van het gebruik van RStudio op SageMaker is dat u, door op het SageMaker-platform te zijn, de juiste tool voor de juiste taak kunt gebruiken en er snel tussen kunt schakelen op basis van wat u moet doen.

Zodra we de pijplijnrun starten, kunnen we overschakelen naar: Amazon SageMaker Studio, waarmee we de pijplijn kunnen visualiseren en de huidige en eerdere uitvoeringen ervan kunnen volgen.

Om details te bekijken over de pijplijn die we zojuist hebben gemaakt en uitgevoerd, navigeert u naar de Studio IDE-interface, kiest u SageMaker-bronnen, kiezen Pijpleidingen in het vervolgkeuzemenu en kies de pijplijn (in dit geval AbalonePipelineUsingR).

Dit onthult details van de pijplijn, inclusief alle huidige en eerdere runs. Kies de nieuwste om een ​​visuele weergave van de pijplijn weer te geven, zoals in de volgende schermafbeelding.

De DAG van de pijplijn wordt automatisch gemaakt door de service op basis van de gegevensafhankelijkheden tussen stappen, evenals op basis van aangepaste toegevoegde afhankelijkheden (niet toegevoegd in dit voorbeeld).

Als de run is voltooid, moet u zien dat alle stappen groen worden.

Als u een van de afzonderlijke stappen kiest, worden details over de specifieke stap weergegeven, inclusief invoer, uitvoer, logboeken en initiële configuratie-instellingen. Hierdoor kunt u inzoomen op de pijplijn en eventuele mislukte stappen onderzoeken.

Evenzo, wanneer de pijplijn is voltooid, wordt een model opgeslagen in het modelregister. Om toegang te krijgen, in de SageMaker-bronnen kies het venster Modelregister op de vervolgkeuzelijst en kies uw model. Dit onthult de lijst met geregistreerde modellen, zoals weergegeven in de volgende schermafbeelding. Kies er een om de detailpagina voor die specifieke modelversie te openen.

Nadat u een versie van het model hebt geopend, kiest u Updaten Status en Goedkeuren om het model goed te keuren.

Op dit punt kunt u, op basis van uw gebruiksscenario, deze goedkeuring instellen om verdere acties te starten, waaronder de implementatie van het model volgens uw behoeften.

Serverloze implementatie van het model

Nadat u een model op SageMaker hebt getraind en geregistreerd, is het eenvoudig om het model op SageMaker te implementeren.

Er zijn verschillende opties voor het implementeren van een model, zoals batch-inferentie, realtime eindpunten of asynchrone eindpunten. Elke methode wordt geleverd met verschillende vereiste configuraties, waaronder het kiezen van het gewenste exemplaartype en het schaalmechanisme.

Voor dit voorbeeld gebruiken we de recent aangekondigde functie van SageMaker, Serverloze inferentie (in preview-modus vanaf het moment van schrijven), om ons R-model te implementeren op een serverloos eindpunt. Voor dit type eindpunt definiëren we alleen de hoeveelheid RAM die we aan het model willen toewijzen voor inferentie, evenals het maximale aantal toegestane gelijktijdige aanroepen van het model. SageMaker zorgt voor het hosten van het model en voor automatisch schalen als dat nodig is. Er worden alleen kosten in rekening gebracht voor het exacte aantal seconden en gegevens dat door het model wordt gebruikt, zonder kosten voor inactieve tijd.

U kunt het model implementeren op een serverloos eindpunt met de volgende code:

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

Als je de fout ziet ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" het model dat u wilt implementeren, is niet goedgekeurd. Volg de stappen uit de vorige sectie om uw model goed te keuren.

Roep het eindpunt op door een aanvraag te verzenden naar het HTTP-eindpunt dat we hebben geïmplementeerd, of gebruik in plaats daarvan de SageMaker SDK. In de volgende code roepen we het eindpunt aan op sommige testgegevens:

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)

Het eindpunt dat we aanriepen was een serverloos eindpunt en als zodanig worden de exacte duur en gebruikte gegevens in rekening gebracht. U merkt misschien dat de eerste keer dat u het eindpunt aanroept, het ongeveer een seconde duurt om te reageren. Dit komt door de koude starttijd van het serverloze eindpunt. Als u kort daarna nog een aanroep doet, retourneert het model de voorspelling in realtime omdat het al warm is.

Wanneer u klaar bent met experimenteren met het eindpunt, kunt u het verwijderen met de volgende opdracht:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Conclusie

In dit bericht hebben we het proces van het maken van een SageMaker-pijplijn met R in onze RStudio-omgeving doorlopen en laten zien hoe we ons R-model kunnen implementeren op een serverloos eindpunt op SageMaker met behulp van het SageMaker-modelregister.

Met de combinatie van RStudio en SageMaker kunt u nu complete end-to-end ML-workflows op AWS creëren en orkestreren met behulp van onze voorkeurstaal, R.

Om dieper in deze oplossing te duiken, raad ik u aan om de broncode van deze oplossing, evenals andere voorbeelden, te bekijken op GitHub.

Over de auteur

Georgios Schinas is Specialist Solutions Architect voor AI/ML in de EMEA-regio. Hij is gevestigd in Londen en werkt nauw samen met klanten in het VK en Ierland. Georgios helpt klanten bij het ontwerpen en implementeren van machine learning-applicaties in productie op AWS met een bijzondere interesse in MLOps-praktijken en om klanten in staat te stellen machine learning op grote schaal uit te voeren. In zijn vrije tijd houdt hij van reizen, koken en tijd doorbrengen met vrienden en familie.