Erstellen Sie Amazon SageMaker-Modellerstellungspipelines und stellen Sie R-Modelle mit RStudio auf Amazon SageMaker bereit

Im November 2021 in Zusammenarbeit mit RStudio PBCWir angekündigt die allgemeine Verfügbarkeit von RStudio auf Amazon SageMaker, die branchenweit erste vollständig verwaltete RStudio Workbench-IDE in der Cloud. Sie können jetzt Ihre aktuelle RStudio-Lizenz mitbringen, um Ihre selbstverwalteten RStudio-Umgebungen einfach zu migrieren Amazon Sage Maker in nur wenigen einfachen Schritten.

RStudio ist eine der beliebtesten IDEs unter R-Entwicklern für maschinelles Lernen (ML) und Data-Science-Projekte. RStudio bietet Open-Source-Tools für R und unternehmenstaugliche professionelle Software für Data-Science-Teams, um ihre Arbeit in der Organisation zu entwickeln und zu teilen. Wenn Sie RStudio auf SageMaker bringen, erhalten Sie nicht nur vollständig verwalteten Zugriff auf die AWS-Infrastruktur, sondern auch nativen Zugriff auf SageMaker.

In diesem Beitrag untersuchen wir, wie Sie SageMaker-Funktionen über RStudio auf SageMaker verwenden können, um eine SageMaker-Pipeline zu erstellen, die Ihre R-Modelle erstellt, verarbeitet, trainiert und registriert. Wir untersuchen auch die Verwendung von SageMaker für unsere Modellbereitstellung, alles unter Verwendung von R.

Lösungsüberblick

Das folgende Diagramm zeigt die in unserer Lösung verwendete Architektur. Der gesamte in diesem Beispiel verwendete Code befindet sich in der GitHub-Repository.

Voraussetzungen:

Um diesem Beitrag zu folgen, ist Zugriff auf RStudio auf SageMaker erforderlich. Wenn Sie neu bei der Verwendung von RStudio auf SageMaker sind, lesen Sie Erste Schritte mit RStudio auf Amazon SageMaker.

Wir müssen auch benutzerdefinierte Docker-Container erstellen. Wir gebrauchen AWS CodeBuild Um diese Container zu bauen, benötigen Sie also ein paar zusätzliche AWS Identity and Access Management and (IAM)-Berechtigungen, die Sie möglicherweise nicht standardmäßig haben. Bevor Sie fortfahren, stellen Sie sicher, dass die IAM-Rolle, die Sie verwenden, eine Vertrauensrichtlinie mit CodeBuild hat:

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

Die folgenden Berechtigungen sind auch in der IAM-Rolle erforderlich, um einen Build in CodeBuild auszuführen und das Image per Push dorthin zu übertragen Amazon Elastic Container-Registrierung (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"
                }
            }
        }
    ]
}

Erstellen Sie Baseline-R-Container

Um unsere R-Skripts für die Verarbeitung und das Training von SageMaker-Verarbeitungs- und Trainingsaufträgen zu verwenden, müssen wir unsere eigenen erstellen Docker-Container die die notwendige Laufzeit und Pakete enthält. Die Möglichkeit, einen eigenen Container zu verwenden, der Teil des SageMaker-Angebots ist, gibt Entwicklern und Datenwissenschaftlern eine große Flexibilität, die Tools und Frameworks ihrer Wahl praktisch ohne Einschränkungen zu verwenden.

Wir erstellen zwei R-fähige Docker-Container: einen für die Verarbeitung von Jobs und einen für das Training und die Bereitstellung unserer Modelle. Die Verarbeitung von Daten erfordert normalerweise andere Pakete und Bibliotheken als die Modellierung, daher ist es hier sinnvoll, die beiden Phasen zu trennen und unterschiedliche Container zu verwenden.

Weitere Einzelheiten zur Verwendung von Containern mit SageMaker finden Sie unter Docker-Container mit SageMaker verwenden.

Der für die Verarbeitung verwendete Behälter ist wie folgt definiert:

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

Für diesen Beitrag verwenden wir einen einfachen und relativ leichten Behälter. Abhängig von Ihren Anforderungen oder den Anforderungen Ihrer Organisation möchten Sie möglicherweise mehrere weitere R-Pakete vorinstallieren.

Der für Training und Bereitstellung verwendete Container ist wie folgt definiert:

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

Der RStudio-Kernel wird auf einem Docker-Container ausgeführt, sodass Sie die Container nicht mithilfe von Docker-Befehlen direkt in Ihrer Studio-Sitzung erstellen und bereitstellen können. Stattdessen können Sie die sehr nützliche Bibliothek verwenden sagemaker-studio-image-build, das im Wesentlichen die Aufgabe des Erstellens von Containern an CodeBuild auslagert.

Mit den folgenden Befehlen erstellen wir zwei Amazon ECR-Registries: sagemaker-r-processing und sagemaker-r-train-n-deploy, und bauen Sie die entsprechenden Container, die wir später verwenden:

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

Erstellen Sie die Pipeline

Nachdem die Container erstellt und bereit sind, können wir die SageMaker-Pipeline erstellen, die den Modellerstellungsworkflow orchestriert. Der vollständige Code davon befindet sich unter der Datei pipeline.R im Depot. Der einfachste Weg, eine SageMaker-Pipeline zu erstellen, ist die Verwendung des SageMaker SDK, einer Python-Bibliothek, auf die wir über die Bibliothek zugreifen können vernetzen. Dadurch erhalten wir Zugriff auf alle Funktionalitäten von SageMaker, ohne die R-Sprachumgebung zu verlassen.

Die von uns gebaute Pipeline hat folgende Komponenten:

• Vorverarbeitungsschritt – Dies ist ein SageMaker-Verarbeitungsjob (unter Verwendung der sagemaker-r-processing Container), der für die Vorverarbeitung der Daten und die Aufteilung der Daten in Zug- und Testdatensätze verantwortlich ist.
• Trainingsschritt – Dies ist ein SageMaker-Trainingsjob (unter Verwendung der sagemaker-r-train-n-deploy Container), der für das Training des Modells verantwortlich ist. In diesem Beispiel trainieren wir ein einfaches lineares Modell.
• Bewertungsschritt – Dies ist ein SageMaker-Verarbeitungsjob (unter Verwendung der sagemaker-r-processing Container), der für die Durchführung der Evaluierung des Modells verantwortlich ist. Speziell in diesem Beispiel interessieren wir uns für den RMSE (Root Mean Square Error) des Testdatensatzes, den wir im nächsten Schritt verwenden und dem Modell selbst zuordnen möchten.
• Bedingter Schritt – Dies ist ein bedingter Schritt, der in SageMaker-Pipelines nativ ist und es uns ermöglicht, die Pipeline-Logik basierend auf einigen Parametern zu verzweigen. In diesem Fall verzweigt sich die Pipeline basierend auf dem Wert von RMSE, der im vorherigen Schritt berechnet wurde.
• Modellschritt registrieren – Wenn der vorhergehende bedingte Schritt ist True, und die Leistung des Modells akzeptabel ist, wird das Modell in der Modellregistrierung registriert. Weitere Informationen finden Sie unter Registrieren und Bereitstellen von Modellen mit der Modellregistrierung.

Rufen Sie zuerst die Funktion upsert auf, um die Pipeline zu erstellen (oder zu aktualisieren), und rufen Sie dann die Funktion start auf, um die Ausführung der Pipeline tatsächlich zu starten:

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

Untersuchen Sie die Pipeline und die Modellregistrierung

Eines der großartigen Dinge bei der Verwendung von RStudio auf SageMaker ist, dass Sie auf der SageMaker-Plattform das richtige Tool für den richtigen Job verwenden und schnell zwischen ihnen wechseln können, je nachdem, was Sie tun müssen.

Sobald wir den Pipelinelauf starten, können wir zu wechseln Amazon SageMaker-Studio, was es uns ermöglicht, die Pipeline zu visualisieren und aktuelle und frühere Ausführungen davon zu überwachen.

Um Details über die gerade erstellte und ausgeführte Pipeline anzuzeigen, navigieren Sie zur Studio-IDE-Oberfläche, wählen Sie SageMaker-Ressourcen, wählen Pipelines im Dropdown-Menü und wählen Sie die Pipeline aus (in diesem Fall AbalonePipelineUsingR).

Dies zeigt Details der Pipeline, einschließlich aller aktuellen und vorherigen Läufe. Wählen Sie die neueste aus, um eine visuelle Darstellung der Pipeline anzuzeigen, wie im folgenden Screenshot gezeigt.

Der DAG der Pipeline wird automatisch vom Dienst erstellt, basierend auf den Datenabhängigkeiten zwischen den Schritten sowie basierend auf benutzerdefinierten hinzugefügten Abhängigkeiten (in diesem Beispiel wurden keine hinzugefügt).

Wenn der Lauf erfolgreich ist, sollten Sie sehen, dass alle Schritte grün werden.

Wenn Sie einen der einzelnen Schritte auswählen, werden Details zu dem jeweiligen Schritt angezeigt, einschließlich Eingaben, Ausgaben, Protokollen und anfänglichen Konfigurationseinstellungen. Auf diese Weise können Sie die Pipeline aufschlüsseln und alle fehlgeschlagenen Schritte untersuchen.

Auf ähnliche Weise wird ein Modell in der Modellregistrierung gespeichert, wenn die Ausführung der Pipeline beendet ist. Um darauf zuzugreifen, in der SageMaker-Ressourcen Fenster, wählen Sie Modellregistrierung Klicken Sie auf das Dropdown-Menü und wählen Sie Ihr Modell aus. Dadurch wird die Liste der registrierten Modelle angezeigt, wie im folgenden Screenshot gezeigt. Wählen Sie eine aus, um die Detailseite für diese bestimmte Modellversion zu öffnen.

Nachdem Sie eine Version des Modells geöffnet haben, wählen Sie aus Status aktualisieren und genehmigen das Modell genehmigen.

An diesem Punkt können Sie basierend auf Ihrem Anwendungsfall diese Genehmigung einrichten, um weitere Aktionen auszulösen, einschließlich der Bereitstellung des Modells gemäß Ihren Anforderungen.

Serverlose Bereitstellung des Modells

Nachdem Sie ein Modell auf SageMaker trainiert und registriert haben, ist die Bereitstellung des Modells auf SageMaker unkompliziert.

Es gibt mehrere Möglichkeiten, wie Sie ein Modell bereitstellen können, z. B. Batchrückschluss, Echtzeit-Endpunkte oder asynchrone Endpunkte. Jede Methode umfasst mehrere erforderliche Konfigurationen, einschließlich der Auswahl des gewünschten Instance-Typs sowie des Skalierungsmechanismus.

Für dieses Beispiel verwenden wir die kürzlich angekündigte Funktion von SageMaker, Serverlose Inferenz (zum Zeitpunkt des Schreibens im Vorschaumodus), um unser R-Modell auf einem serverlosen Endpunkt bereitzustellen. Für diese Art von Endpunkt definieren wir nur die RAM-Menge, die dem Modell für die Inferenz zugewiesen werden soll, sowie die maximale Anzahl gleichzeitig zulässiger Aufrufe des Modells. SageMaker kümmert sich um das Hosten des Modells und die automatische Skalierung nach Bedarf. Ihnen werden nur die genauen Sekunden und Daten berechnet, die vom Modell verwendet werden, ohne Kosten für Leerlaufzeiten.

Sie können das Modell mit dem folgenden Code auf einem serverlosen Endpunkt bereitstellen:

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

Wenn Sie den Fehler sehen ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" Das Modell, das Sie bereitstellen möchten, wurde nicht genehmigt. Befolgen Sie die Schritte aus dem vorherigen Abschnitt, um Ihr Modell zu genehmigen.

Rufen Sie den Endpunkt auf, indem Sie eine Anfrage an den von uns bereitgestellten HTTP-Endpunkt senden, oder verwenden Sie stattdessen das SageMaker SDK. Im folgenden Code rufen wir den Endpunkt für einige Testdaten auf:

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)

Der von uns aufgerufene Endpunkt war ein serverloser Endpunkt, und als solcher werden uns die genaue Dauer und die verwendeten Daten in Rechnung gestellt. Möglicherweise stellen Sie fest, dass es beim ersten Aufruf des Endpunkts etwa eine Sekunde dauert, bis er antwortet. Dies liegt an der Kaltstartzeit des serverlosen Endpunkts. Wenn Sie kurz darauf einen weiteren Aufruf vornehmen, gibt das Modell die Vorhersage in Echtzeit zurück, da es bereits warm ist.

Wenn Sie mit dem Experimentieren mit dem Endpunkt fertig sind, können Sie ihn mit dem folgenden Befehl löschen:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Zusammenfassung

In diesem Beitrag haben wir den Prozess zum Erstellen einer SageMaker-Pipeline mit R in unserer RStudio-Umgebung durchlaufen und gezeigt, wie unser R-Modell mithilfe der SageMaker-Modellregistrierung auf einem serverlosen Endpunkt in SageMaker bereitgestellt wird.

Mit der Kombination aus RStudio und SageMaker können Sie jetzt vollständige End-to-End-ML-Workflows auf AWS erstellen und orchestrieren, indem Sie unsere bevorzugte Sprache R verwenden.

Um tiefer in diese Lösung einzutauchen, empfehle ich Ihnen, sich den Quellcode dieser Lösung sowie andere Beispiele anzusehen GitHub.

Über den Autor

Georgios Schinas ist ein Specialist Solutions Architect für AI/ML in der EMEA-Region. Er hat seinen Sitz in London und arbeitet eng mit Kunden in Großbritannien und Irland zusammen. Georgios unterstützt Kunden bei der Entwicklung und Bereitstellung von Anwendungen für maschinelles Lernen in der Produktion auf AWS mit besonderem Interesse an MLOps-Praktiken und ermöglicht Kunden, maschinelles Lernen in großem Maßstab durchzuführen. In seiner Freizeit reist er gerne, kocht und verbringt Zeit mit Freunden und Familie.