Twórz potoki budowania modeli Amazon SageMaker i wdrażaj modele R za pomocą RStudio na Amazon SageMaker

W listopadzie 2021 we współpracy z RStudio PBC, mamy ogłosił ogólna dostępność RStudio na Amazon SageMaker, pierwsze w branży w pełni zarządzane środowisko IDE RStudio Workbench w chmurze. Możesz teraz przenieść swoją aktualną licencję RStudio, aby łatwo migrować samodzielnie zarządzane środowiska RStudio do Amazon Sage Maker w zaledwie kilku prostych krokach.

RStudio jest jednym z najpopularniejszych środowisk IDE wśród programistów języka R dla projektów uczenia maszynowego (ML) i data science. RStudio zapewnia narzędzia typu open source dla profesjonalnego oprogramowania R i Enterprise dla zespołów zajmujących się analizą danych w celu opracowywania i udostępniania swojej pracy w organizacji. Wprowadzenie RStudio w SageMaker nie tylko zapewnia dostęp do infrastruktury AWS w sposób w pełni zarządzany, ale także zapewnia natywny dostęp do SageMaker.

W tym poście omówimy, w jaki sposób można wykorzystać funkcje SageMaker za pośrednictwem RStudio na SageMaker, aby zbudować potok SageMaker, który kompiluje, przetwarza, trenuje i rejestruje modele R. Badamy również użycie SageMaker do wdrażania naszych modeli, wszystkie przy użyciu języka R.

Omówienie rozwiązania

Poniższy diagram przedstawia architekturę zastosowaną w naszym rozwiązaniu. Cały kod użyty w tym przykładzie można znaleźć w Repozytorium GitHub.

Wymagania wstępne

Aby śledzić ten post, wymagany jest dostęp do RStudio na SageMaker. Jeśli dopiero zaczynasz korzystać z RStudio na SageMaker, przejrzyj Zacznij korzystać z RStudio w Amazon SageMaker.

Musimy również zbudować niestandardowe kontenery Dockera. Używamy Tworzenie kodu AWS aby zbudować te kontenery, więc potrzebujesz kilku dodatkowych AWS Zarządzanie tożsamością i dostępem (IAM), których domyślnie możesz nie mieć. Zanim przejdziesz dalej, upewnij się, że rola uprawnień, której używasz, ma zasady zaufania z CodeBuild:

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

Następujące uprawnienia są również wymagane w roli IAM, aby uruchomić kompilację w CodeBuild i wypchnąć obraz do Rejestr elastycznego pojemnika Amazon (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"
                }
            }
        }
    ]
}

Utwórz bazowe kontenery R

Aby używać naszych skryptów języka R do przetwarzania i szkolenia zadań przetwarzania i szkolenia w programie SageMaker, musimy utworzyć własne Docker containers zawierające niezbędne środowisko wykonawcze i pakiety. Możliwość korzystania z własnego kontenera, która jest częścią oferty SageMaker, zapewnia programistom i analitykom danych dużą elastyczność w korzystaniu z wybranych przez nich narzędzi i struktur, praktycznie bez żadnych ograniczeń.

Tworzymy dwa kontenery Docker z obsługą języka R: jeden do przetwarzania zadań, a drugi do szkolenia i wdrażania naszych modeli. Przetwarzanie danych zwykle wymaga innych pakietów i bibliotek niż modelowanie, dlatego sensowne jest tutaj oddzielenie dwóch etapów i użycie różnych kontenerów.

Aby uzyskać więcej informacji na temat korzystania z kontenerów w programie SageMaker, zobacz Używanie kontenerów Docker z SageMaker.

Pojemnik używany do przetwarzania definiuje się w następujący sposób:

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

W tym poście używamy prostego i stosunkowo lekkiego kontenera. W zależności od potrzeb Twojej lub Twojej organizacji możesz chcieć wstępnie zainstalować kilka dodatkowych pakietów R.

Kontener używany do szkolenia i wdrażania jest zdefiniowany w następujący sposób:

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

Jądro RStudio działa w kontenerze platformy Docker, więc nie będzie można kompilować i wdrażać kontenerów przy użyciu poleceń platformy Docker bezpośrednio w sesji Studio. Zamiast tego możesz skorzystać z bardzo przydatnej biblioteki sagemaker-studio-image-build, który zasadniczo zleca zadanie budowania kontenerów do CodeBuild.

Za pomocą następujących poleceń tworzymy dwa rejestry Amazon ECR: sagemaker-r-processing i sagemaker-r-train-n-deployi zbuduj odpowiednie kontenery, których użyjemy później:

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

Utwórz potok

Teraz, gdy kontenery są już skompilowane i gotowe, możemy utworzyć potok SageMaker, który organizuje przepływ pracy budowania modelu. Pełny kod tego znajduje się w pliku pipeline.R w repozytorium. Najłatwiejszym sposobem utworzenia potoku SageMaker jest użycie pakietu SageMaker SDK, który jest biblioteką Pythona, do której możemy uzyskać dostęp za pomocą biblioteki siatkowaty. Daje nam to dostęp do wszystkich funkcji SageMaker bez opuszczania środowiska języka R.

Budowany przez nas potok składa się z następujących elementów:

• Etap wstępnego przetwarzania – To jest zadanie przetwarzania SageMaker (z wykorzystaniem sagemaker-r-processing kontener) odpowiedzialny za wstępne przetwarzanie danych i podział danych na zestawy danych pociągowych i testowych.
• Etap szkolenia – To jest praca szkoleniowa SageMaker (z wykorzystaniem sagemaker-r-train-n-deploy kontener) odpowiedzialny za trenowanie modelu. W tym przykładzie trenujemy prosty model liniowy.
• Etap oceny – To jest zadanie przetwarzania SageMaker (z wykorzystaniem sagemaker-r-processing kontener) odpowiedzialny za wykonanie oceny modelu. W szczególności w tym przykładzie interesuje nas RMSE (błąd średniokwadratowy) w testowym zestawie danych, którego chcemy użyć w następnym kroku, a także powiązać z samym modelem.
• Krok warunkowy – Jest to krok warunkowy, natywny dla potoków SageMaker, który pozwala nam rozgałęziać logikę potoku w oparciu o jakiś parametr. W takim przypadku rurociąg rozgałęzia się na podstawie wartości RMSE, która została obliczona w poprzednim kroku.
• Zarejestruj krok modelu – Jeżeli poprzedni krok warunkowy to True, a wydajność modelu jest akceptowalna, model jest rejestrowany w rejestrze modeli. Aby uzyskać więcej informacji, zobacz Rejestruj i wdrażaj modele za pomocą Rejestru modeli.

Najpierw wywołaj funkcję upsert, aby utworzyć (lub zaktualizować) potok, a następnie wywołaj funkcję start, aby faktycznie uruchomić potok:

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

Sprawdź rejestr potoku i modelu

Jedną z największych zalet korzystania z RStudio na platformie SageMaker jest to, że będąc na platformie SageMaker, możesz używać odpowiedniego narzędzia do właściwej pracy i szybko przełączać się między nimi w zależności od tego, co musisz zrobić.

Jak tylko zaczniemy bieg potoku, możemy przełączyć się na Studio Amazon SageMaker, co pozwala nam zwizualizować rurociąg oraz monitorować jego bieżące i poprzednie przebiegi.

Aby wyświetlić szczegółowe informacje o potoku, który właśnie utworzyliśmy i uruchomiliśmy, przejdź do interfejsu Studio IDE, wybierz Zasoby SageMakerwybierz Rurociągi z rozwijanego menu i wybierz potok (w tym przypadku AbalonePipelineUsingR).

Ujawnia to szczegóły potoku, w tym wszystkie bieżące i poprzednie uruchomienia. Wybierz najnowszy, aby wyświetlić wizualną reprezentację potoku, jak na poniższym zrzucie ekranu.

DAG potoku jest tworzony automatycznie przez usługę na podstawie zależności danych między krokami, a także na podstawie niestandardowych dodanych zależności (nie dodano żadnych w tym przykładzie).

Po zakończeniu biegu, jeśli się powiedzie, wszystkie kroki powinny zmienić kolor na zielony.

Wybranie dowolnego z poszczególnych kroków powoduje wyświetlenie szczegółowych informacji o konkretnym kroku, w tym danych wejściowych, wyjściowych, dziennikach i początkowych ustawieniach konfiguracji. Pozwala to na drążenie w potoku i zbadanie wszelkich nieudanych kroków.

Podobnie po zakończeniu działania potoku model jest zapisywany w rejestrze modeli. Aby uzyskać do niego dostęp, w Zasoby SageMaker okienko, wybierz Rejestr modeli z listy rozwijanej i wybierz swój model. To pokazuje listę zarejestrowanych modeli, jak pokazano na poniższym zrzucie ekranu. Wybierz jedną, aby otworzyć stronę szczegółów dla tej konkretnej wersji modelu.

Po otwarciu wersji modelu wybierz Status i Zatwierdzać aby zatwierdzić model.

W tym momencie, w oparciu o Twój przypadek użycia, możesz skonfigurować to zatwierdzenie, aby wyzwolić dalsze działania, w tym wdrożenie modelu zgodnie z Twoimi potrzebami.

Bezserwerowe wdrożenie modelu

Po przeszkoleniu i zarejestrowaniu modelu w SageMaker wdrożenie modelu w SageMaker jest proste.

Istnieje kilka opcji wdrażania modelu, takich jak wnioskowanie wsadowe, punkty końcowe w czasie rzeczywistym lub asynchroniczne punkty końcowe. Każda metoda ma kilka wymaganych konfiguracji, w tym wybór żądanego typu instancji oraz mechanizm skalowania.

W tym przykładzie używamy niedawno ogłoszonej funkcji SageMaker, Wnioskowanie bezserwerowe (w trybie podglądu w momencie pisania), aby wdrożyć nasz model R na bezserwerowym punkcie końcowym. Dla tego typu punktu końcowego definiujemy tylko ilość pamięci RAM, którą chcemy przydzielić modelowi w celu wnioskowania, a także maksymalną liczbę dozwolonych równoczesnych wywołań modelu. SageMaker dba o hostowanie modelu i automatyczne skalowanie w razie potrzeby. Płacisz tylko za dokładną liczbę sekund i dane używane przez model, bez żadnych kosztów za czas bezczynności.

Model można wdrożyć w bezserwerowym punkcie końcowym za pomocą następującego kodu:

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

Jeśli widzisz błąd ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" model, który chcesz wdrożyć, nie został zatwierdzony. Wykonaj kroki z poprzedniej sekcji, aby zatwierdzić swój model.

Wywołaj punkt końcowy, wysyłając żądanie do wdrożonego przez nas punktu końcowego HTTP, lub zamiast tego użyj pakietu SageMaker SDK. W poniższym kodzie wywołujemy punkt końcowy na niektórych danych testowych:

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)

Wywołany przez nas punkt końcowy był bezserwerowym punktem końcowym i dlatego naliczamy opłatę za dokładny czas trwania i użyte dane. Możesz zauważyć, że przy pierwszym wywołaniu punktu końcowego odpowiedź zajmuje około sekundy. Wynika to z zimnego czasu uruchomienia bezserwerowego punktu końcowego. Jeśli wkrótce potem wykonasz kolejne wywołanie, model zwróci prognozę w czasie rzeczywistym, ponieważ jest już ciepła.

Po zakończeniu eksperymentowania z punktem końcowym możesz go usunąć za pomocą następującego polecenia:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Wnioski

W tym poście omówiliśmy proces tworzenia potoku SageMaker przy użyciu języka R w naszym środowisku RStudio i pokazaliśmy, jak wdrożyć nasz model R na bezserwerowym punkcie końcowym w SageMaker przy użyciu rejestru modeli SageMaker.

Dzięki połączeniu RStudio i SageMaker możesz teraz tworzyć i organizować kompletne, kompleksowe przepływy pracy ML w AWS przy użyciu preferowanego przez nas języka R.

Aby zagłębić się w to rozwiązanie, zachęcam do zapoznania się z kodem źródłowym tego rozwiązania, a także innymi przykładami, na GitHub.

O autorze

Georgios Schinas jest Specjalistą Architektem Rozwiązań dla AI/ML w regionie EMEA. Mieszka w Londynie i ściśle współpracuje z klientami w Wielkiej Brytanii i Irlandii. Georgios pomaga klientom projektować i wdrażać aplikacje do uczenia maszynowego w środowisku produkcyjnym na AWS, ze szczególnym zainteresowaniem praktykami MLOps i umożliwianiem klientom wykonywania uczenia maszynowego na dużą skalę. W wolnym czasie lubi podróżować, gotować i spędzać czas z przyjaciółmi i rodziną.