Logo Zephyrnet

Crea pipeline di creazione di modelli Amazon SageMaker e distribuisci modelli R utilizzando RStudio su Amazon SageMaker

Data:

A novembre 2021, in collaborazione con RStudio PBC, noi ha annunciato la disponibilità generale di RStudio su Amazon SageMaker, il primo RStudio Workbench IDE completamente gestito nel cloud del settore. Ora puoi portare la tua attuale licenza RStudio per migrare facilmente i tuoi ambienti RStudio autogestiti Amazon Sage Maker in pochi semplici passaggi.

RStudio è uno degli IDE più popolari tra gli sviluppatori R per i progetti di apprendimento automatico (ML) e scienza dei dati. RStudio fornisce strumenti open source per R e software professionale pronto per l'impresa per consentire ai team di data science di sviluppare e condividere il proprio lavoro nell'organizzazione. Portare RStudio su SageMaker non solo ti dà accesso all'infrastruttura AWS in modo completamente gestito, ma ti dà anche accesso nativo a SageMaker.

In questo post, esploriamo come utilizzare le funzionalità di SageMaker tramite RStudio su SageMaker per creare una pipeline SageMaker che costruisce, elabora, addestra e registra i tuoi modelli R. Esploriamo anche l'utilizzo di SageMaker per la distribuzione del nostro modello, il tutto utilizzando R.

Panoramica della soluzione

Il diagramma seguente mostra l'architettura utilizzata nella nostra soluzione. Tutto il codice utilizzato in questo esempio può essere trovato in Repository GitHub.

Prerequisiti

Per seguire questo post, è richiesto l'accesso a RStudio su SageMaker. Se non conosci RStudio su SageMaker, rivedi Inizia con RStudio su Amazon SageMaker.

Abbiamo anche bisogno di creare container Docker personalizzati. Noi usiamo AWSCodeBuild per costruire questi contenitori, quindi hai bisogno di qualche extra Gestione dell'identità e dell'accesso di AWS (IAM) autorizzazioni che potresti non avere per impostazione predefinita. Prima di procedere, assicurati che il ruolo IAM che stai utilizzando disponga di una policy di attendibilità con CodeBuild:

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

Le autorizzazioni seguenti sono richieste anche nel ruolo IAM per eseguire una build in CodeBuild e inviare l'immagine a Registro dei contenitori Amazon Elastic (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 contenitori R di base

Per utilizzare i nostri script R per l'elaborazione e la formazione sui processi di elaborazione e formazione di SageMaker, dobbiamo crearne di nostri Contenitori Docker contenente il runtime e i pacchetti necessari. La possibilità di utilizzare il proprio container, che fa parte dell'offerta SageMaker, offre grande flessibilità a sviluppatori e data scientist per utilizzare gli strumenti e i framework di loro scelta, praticamente senza limitazioni.

Creiamo due contenitori Docker abilitati per R: uno per l'elaborazione dei lavori e uno per l'addestramento e la distribuzione dei nostri modelli. L'elaborazione dei dati in genere richiede pacchetti e librerie diversi rispetto alla modellazione, quindi ha senso separare le due fasi e utilizzare contenitori diversi.

Per maggiori dettagli sull'utilizzo dei contenitori con SageMaker, fare riferimento a Utilizzo dei contenitori Docker con SageMaker.

Il contenitore utilizzato per la lavorazione è così definito:

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

Per questo post, utilizziamo un contenitore semplice e relativamente leggero. A seconda delle tue esigenze o della tua organizzazione, potresti voler preinstallare molti altri pacchetti R.

Il contenitore utilizzato per la formazione e la distribuzione è definito come segue:

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

Il kernel RStudio viene eseguito su un contenitore Docker, quindi non sarai in grado di creare e distribuire i contenitori utilizzando i comandi Docker direttamente nella sessione di Studio. Invece, puoi usare l'utilissima libreria sagemaker-studio-costruzione di immagini, che essenzialmente affida a CodeBuild il compito di creare contenitori.

Con i seguenti comandi, creiamo due registri Amazon ECR: sagemaker-r-processing ed sagemaker-r-train-n-deploye costruisci i rispettivi contenitori che useremo in seguito:

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 la pipeline

Ora che i container sono costruiti e pronti, possiamo creare la pipeline SageMaker che orchestra il flusso di lavoro di costruzione del modello. Il codice completo di questo è sotto il file pipeline.R nel deposito. Il modo più semplice per creare una pipeline SageMaker è utilizzare SageMaker SDK, che è una libreria Python a cui possiamo accedere utilizzando la libreria reticolare. Questo ci dà accesso a tutte le funzionalità di SageMaker senza uscire dall'ambiente del linguaggio R.

La pipeline che costruiamo ha i seguenti componenti:

  • Fase di preelaborazione – Questo è un lavoro di elaborazione SageMaker (che utilizza il file sagemaker-r-processing container) responsabile della preelaborazione dei dati e della suddivisione dei dati in set di dati di training e test.
  • Fase di formazione – Questo è un lavoro di formazione SageMaker (che utilizza il file sagemaker-r-train-n-deploy container) responsabile della formazione del modello. In questo esempio, formiamo un semplice modello lineare.
  • Fase di valutazione – Questo è un lavoro di elaborazione SageMaker (che utilizza il file sagemaker-r-processing container) responsabile della valutazione del modello. In particolare, in questo esempio, siamo interessati all'RMSE (root mean square error) sul set di dati di test, che vogliamo utilizzare nel passaggio successivo e associare al modello stesso.
  • Passaggio condizionale – Questo è un passaggio condizionale, nativo delle pipeline SageMaker, che ci consente di diramare la logica della pipeline in base ad alcuni parametri. In questo caso, il gasdotto si dirama in base al valore di RMSE calcolato nel passaggio precedente.
  • Registra il passaggio del modello – Se lo è il passaggio condizionale precedente Truee le prestazioni del modello sono accettabili, il modello viene registrato nel registro dei modelli. Per ulteriori informazioni, fare riferimento a Registra e distribuisci modelli con Model Registry.

Chiama prima la funzione upsert per creare (o aggiornare) la pipeline, quindi chiama la funzione di avvio per avviare effettivamente l'esecuzione della 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()

Ispezionare la pipeline e il registro del modello

Una delle grandi cose dell'utilizzo di RStudio su SageMaker è che essendo sulla piattaforma SageMaker, puoi utilizzare lo strumento giusto per il lavoro giusto e passare rapidamente da uno all'altro in base a ciò che devi fare.

Non appena iniziamo il percorso dell'oleodotto, possiamo passare a Amazon Sage Maker Studio, che ci consente di visualizzare la pipeline e di monitorarne le esecuzioni attuali e precedenti.

Per visualizzare i dettagli sulla pipeline che abbiamo appena creato ed eseguito, vai all'interfaccia IDE di Studio, scegli Risorse di SageMakerscegli Condotte nel menu a tendina e scegli la pipeline (in questo caso, AbalonePipelineUsingR).

Questo rivela i dettagli della pipeline, comprese tutte le esecuzioni attuali e precedenti. Scegli l'ultimo per visualizzare una rappresentazione visiva della pipeline, come da screenshot seguente.

Il DAG della pipeline viene creato automaticamente dal servizio in base alle dipendenze dei dati tra i passaggi, nonché in base alle dipendenze aggiunte personalizzate (non aggiunte in questo esempio).

Al termine dell'esecuzione, in caso di esito positivo, dovresti vedere tutti i passaggi diventare verdi.

Scegliendo uno dei singoli passaggi vengono visualizzati i dettagli del passaggio specifico, inclusi input, output, registri e impostazioni di configurazione iniziale. Ciò ti consente di approfondire la pipeline e indagare su eventuali passaggi non riusciti.

Allo stesso modo, al termine dell'esecuzione della pipeline, un modello viene salvato nel registro modelli. Per accedervi, nel Risorse di SageMaker riquadro, scegli Registro dei modelli nel menu a tendina e scegli il tuo modello. Questo rivela l'elenco dei modelli registrati, come mostrato nella schermata seguente. Scegline uno per aprire la pagina dei dettagli per quella particolare versione del modello.

Dopo aver aperto una versione del modello, scegli Aggiornamento di stato ed approvare per approvare il modello.

A questo punto, in base al tuo caso d'uso, puoi impostare questa approvazione per attivare ulteriori azioni, inclusa la distribuzione del modello secondo le tue esigenze.

Distribuzione serverless del modello

Dopo aver addestrato e registrato un modello su SageMaker, la distribuzione del modello su SageMaker è semplice.

Esistono diverse opzioni su come distribuire un modello, ad esempio inferenza batch, endpoint in tempo reale o endpoint asincroni. Ogni metodo viene fornito con diverse configurazioni richieste, inclusa la scelta del tipo di istanza desiderato e il meccanismo di ridimensionamento.

Per questo esempio, utilizziamo la funzionalità recentemente annunciata di SageMaker, Inferenza senza server (in modalità di anteprima al momento della scrittura), per distribuire il nostro modello R su un endpoint serverless. Per questo tipo di endpoint, definiamo solo la quantità di RAM che vogliamo allocare al modello per l'inferenza, nonché il numero massimo di chiamate simultanee consentite del modello. SageMaker si occupa dell'hosting del modello e del ridimensionamento automatico secondo necessità. Ti vengono addebitati solo il numero esatto di secondi e dati utilizzati dal modello, senza alcun costo per il tempo di inattività.

È possibile distribuire il modello su un endpoint serverless con il codice seguente:

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

Se vedi l'errore ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" il modello che desideri distribuire non è stato approvato. Segui i passaggi della sezione precedente per approvare il tuo modello.

Richiama l'endpoint inviando una richiesta all'endpoint HTTP che abbiamo distribuito o utilizza invece SageMaker SDK. Nel codice seguente, invochiamo l'endpoint su alcuni dati di test:

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'endpoint che abbiamo invocato era un endpoint serverless e, in quanto tale, ci viene addebitata la durata esatta e i dati utilizzati. Potresti notare che la prima volta che invochi l'endpoint ci vuole circa un secondo per rispondere. Ciò è dovuto al tempo di avvio a freddo dell'endpoint serverless. Se fai un'altra chiamata subito dopo, il modello restituisce la previsione in tempo reale perché è già caldo.

Al termine della sperimentazione con l'endpoint, è possibile eliminarlo con il comando seguente:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Conclusione

In questo post, abbiamo illustrato il processo di creazione di una pipeline SageMaker utilizzando R nel nostro ambiente RStudio e mostrato come distribuire il nostro modello R su un endpoint serverless su SageMaker utilizzando il registro del modello SageMaker.

Con la combinazione di RStudio e SageMaker, ora puoi creare e orchestrare flussi di lavoro ML end-to-end completi su AWS utilizzando il nostro linguaggio preferito, R.

Per approfondire questa soluzione, ti incoraggio a rivedere il codice sorgente di questa soluzione, così come altri esempi, su GitHub.


L'autore

Giorgio Schina è uno Specialist Solutions Architect per AI/ML nella regione EMEA. Ha sede a Londra e lavora a stretto contatto con clienti nel Regno Unito e in Irlanda. Georgios aiuta i clienti a progettare e distribuire applicazioni di machine learning in produzione su AWS con un particolare interesse per le pratiche MLOps e consentendo ai clienti di eseguire machine learning su larga scala. Nel tempo libero ama viaggiare, cucinare e passare il tempo con gli amici e la famiglia.

spot_img

L'ultima intelligenza

spot_img