Zephyrnet logó

Hozzon létre Amazon SageMaker modellépítési folyamatokat, és telepítsen R modelleket az RStudio segítségével az Amazon SageMakeren

Találka:

2021 novemberében együttműködve RStudio PBC, Mi bejelentés - a RStudio az Amazon SageMakeren, az iparág első teljesen felügyelt RStudio Workbench IDE-je a felhőben. Mostantól elhozhatja jelenlegi RStudio licencét, hogy könnyen áttelepítse saját maga által kezelt RStudio környezeteit Amazon SageMaker néhány egyszerű lépésben.

Az RStudio az egyik legnépszerűbb IDE az R fejlesztők körében a gépi tanuláshoz (ML) és adattudományi projektekhez. Az RStudio nyílt forráskódú eszközöket biztosít az R-hez és a vállalati használatra kész professzionális szoftvereket az adattudományi csapatok számára, hogy fejlesszék és megosszák munkájukat a szervezetben. Az RStudio bevezetése a SageMakeren nem csak teljes körűen felügyelt módon hozzáférést biztosít az AWS infrastruktúrához, hanem natív hozzáférést is biztosít a SageMakerhez.

Ebben a bejegyzésben megvizsgáljuk, hogyan használhatja a SageMaker funkcióit a SageMaker RStudióján keresztül egy olyan SageMaker folyamat létrehozásához, amely megépíti, feldolgozza, betanítja és regisztrálja R-modelleit. Azt is megvizsgáljuk, hogy a SageMaker-t használjuk a modell bevezetéséhez, mindezt az R használatával.

Megoldás áttekintése

A következő diagram a megoldásunkban használt architektúrát mutatja be. A példában használt összes kód megtalálható a GitHub tárház.

Előfeltételek

A bejegyzés követéséhez hozzáférés szükséges a SageMaker RStudiójához. Ha még nem használja az RStudiót a SageMakeren, tekintse át Kezdje el az RStudio használatát az Amazon SageMakeren.

Egyedi Docker konténereket is kell építenünk. Használjuk AWS CodeBuild ezeknek a konténereknek a megépítéséhez szükség van néhány pluszra AWS Identity and Access Management (IAM) engedélyekkel, amelyekkel alapértelmezés szerint nem rendelkezik. Mielőtt folytatná, győződjön meg arról, hogy az Ön által használt IAM-szerepkör megbízhatósági szabályzattal rendelkezik a CodeBuild-ben:

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

A következő engedélyekre is szükség van az IAM-szerepkörben egy build CodeBuildben való futtatásához, és a kép leküldéséhez Amazon Elastic Container Registry (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"
                }
            }
        }
    ]
}

Hozzon létre alapvonali R-tárolókat

Ahhoz, hogy R-szkriptjeinket a SageMaker feldolgozási és betanítási feladatok feldolgozására és képzésére használhassuk, létre kell hoznunk saját Docker konténerek amely tartalmazza a szükséges futtatókörnyezetet és csomagokat. A SageMaker ajánlat részét képező saját konténer használatának lehetősége nagy rugalmasságot biztosít a fejlesztők és adatkutatók számára az általuk választott eszközök és keretrendszerek használatában, gyakorlatilag korlátozások nélkül.

Két R-kompatibilis Docker-tárolót hozunk létre: egyet a feladatok feldolgozására, egyet pedig modelljeink betanítására és telepítésére. Az adatok feldolgozásához általában más csomagokra és könyvtárakra van szükség, mint a modellezéshez, ezért itt érdemes elkülöníteni a két szakaszt és különböző tárolókat használni.

A konténerek SageMakerrel való használatáról további részletekért lásd: Docker konténerek használata a SageMakerrel.

A feldolgozáshoz használt tartály meghatározása a következő:

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

Ehhez a bejegyzéshez egy egyszerű és viszonylag könnyű edényt használunk. Az Ön vagy szervezete igényeitől függően érdemes több további R-csomagot előre telepíteni.

A képzéshez és telepítéshez használt konténer meghatározása a következő:

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

Az RStudio kernel Docker-tárolón fut, így nem fogja tudni felépíteni és telepíteni a tárolókat Docker-parancsokkal közvetlenül a Studio-munkamenetben. Ehelyett használhatja a nagyon hasznos könyvtárat sagemaker-studio-image-build, amely lényegében kiszervezi a konténerkészítés feladatát a CodeBuildnek.

A következő parancsokkal két Amazon ECR nyilvántartást hozunk létre: sagemaker-r-processing és a sagemaker-r-train-n-deploy, és építsük meg a megfelelő konténereket, amelyeket később használunk:

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

Hozza létre a csővezetéket

Most, hogy a tárolók megépültek és készen állnak, létrehozhatjuk a SageMaker folyamatot, amely levezényli a modellépítési munkafolyamatot. Ennek teljes kódja a fájl alatt található pipeline.R az adattárban. A SageMaker-folyamat létrehozásának legegyszerűbb módja a SageMaker SDK használata, amely egy Python-könyvtár, amelyet a könyvtár használatával érhetünk el. hálószerű. Ezzel az R nyelvi környezet elhagyása nélkül hozzáférhetünk a SageMaker összes funkciójához.

Az általunk épített csővezeték a következő összetevőket tartalmazza:

  • Előfeldolgozási lépés – Ez egy SageMaker feldolgozási feladat (a sagemaker-r-processing konténer) felelős az adatok előfeldolgozásáért és az adatok vonat- és tesztadatkészletekre való felosztásáért.
  • Képzési lépés – Ez egy SageMaker képzési munka (a sagemaker-r-train-n-deploy konténer) felelős a modell betanításáért. Ebben a példában egy egyszerű lineáris modellt tanítunk.
  • Értékelési lépés – Ez egy SageMaker feldolgozási feladat (a sagemaker-r-processing konténer) felelős a modell értékeléséért. Ebben a példában konkrétan a tesztadatkészlet RMSE-je (root mean square error) érdekel bennünket, amelyet a következő lépésben szeretnénk használni, valamint magával a modellel társítani.
  • Feltételes lépés – Ez egy feltételes lépés, amely a SageMaker-folyamatokban natív, és lehetővé teszi, hogy a folyamat logikáját valamilyen paraméter alapján elágazzuk. Ebben az esetben a folyamat az előző lépésben kiszámított RMSE értéke alapján ágazik el.
  • Regisztrálja a modell lépését – Ha az előző feltételes lépés az True, és a modell teljesítménye elfogadható, akkor a modell regisztrálásra kerül a modellnyilvántartásban. További információkért lásd: Regisztráljon és telepítsen modelleket a Model Registry segítségével.

Először hívja meg az upsert függvényt a folyamat létrehozásához (vagy frissítéséhez), majd hívja meg a start függvényt a folyamat tényleges futtatásához:

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

Vizsgálja meg a folyamatot és a modell-nyilvántartást

Az egyik nagyszerű dolog az RStudio SageMakeren való használatában, hogy a SageMaker platformon a megfelelő eszközt használhatja a megfelelő munkához, és gyorsan válthat közöttük a tennivalók alapján.

Amint elindítjuk a csővezeték futást, áttérhetünk a Amazon SageMaker Studio, amely lehetővé teszi a csővezeték vizualizálását, valamint annak jelenlegi és korábbi futtatásának monitorozását.

Az imént létrehozott és futtatott folyamat részleteinek megtekintéséhez lépjen a Studio IDE felületére, és válassza a lehetőséget SageMaker források, választ Csővezetékek a legördülő menüben, és válassza ki a folyamatot (ebben az esetben AbalonePipelineUsingR).

Ez felfedi a folyamat részleteit, beleértve az összes jelenlegi és korábbi futtatást. Válassza ki a legfrissebbet a folyamat vizuális megjelenítéséhez, a következő képernyőkép szerint.

A folyamat DAG-ját a szolgáltatás automatikusan hozza létre a lépések közötti adatfüggőségek, valamint az egyéni hozzáadott függőségek alapján (ebben a példában nincs hozzáadva).

Ha a futtatás befejeződött, ha sikeres, az összes lépés zöldre vált.

Az egyes lépések bármelyikének kiválasztásakor megjelennek az adott lépés részletei, beleértve a bemeneteket, kimeneteket, naplókat és a kezdeti konfigurációs beállításokat. Ez lehetővé teszi, hogy lefúrja a folyamatot, és kivizsgálja a sikertelen lépéseket.

Hasonlóképpen, amikor a folyamat befejeződött, a modell elmentődik a modellnyilvántartásba. A hozzáféréshez a SageMaker források panelen válassza a lehetőséget Modell nyilvántartás a legördülő menüben, és válassza ki a modellt. Ez felfedi a regisztrált modellek listáját, ahogy az a következő képernyőképen látható. Válasszon egyet az adott modellváltozat részletes oldalának megnyitásához.

Miután megnyitotta a modell verzióját, válassza a lehetőséget Frissítés állapota és a jóváhagy hogy hagyja jóvá a modellt.

Ezen a ponton, a használati esettől függően, beállíthatja ezt a jóváhagyást, hogy további műveleteket indítson el, beleértve a modell igényeinek megfelelő telepítését.

A modell szerver nélküli telepítése

Miután betanította és regisztrálta a modellt a SageMakeren, a modell telepítése a SageMakeren egyszerű.

Számos lehetőség áll rendelkezésre egy modell üzembe helyezésére, például kötegelt következtetésre, valós idejű végpontokra vagy aszinkron végpontokra. Mindegyik módszerhez több szükséges konfiguráció tartozik, beleértve a kívánt példánytípus kiválasztását, valamint a méretezési mechanizmust.

Ebben a példában a SageMaker nemrég bejelentett funkcióját használjuk, Szerver nélküli következtetés (az írás idején előnézeti módban), hogy R-modellünket kiszolgáló nélküli végponton telepítsük. Az ilyen típusú végpontok esetében csak azt a RAM mennyiségét határozzuk meg, amelyet a modellhez le kívánunk foglalni következtetés céljából, valamint a modell megengedett egyidejű meghívásának maximális számát. A SageMaker gondoskodik a modell tárolásáról és szükség szerint az automatikus méretezésről. Csak a modell által felhasznált másodpercek és adatok pontos számát kell fizetnie, az üresjárati időért nincs költség.

A modellt a következő kóddal telepítheti egy kiszolgáló nélküli végpontra:

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

Ha látja a hibát ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" a telepíteni kívánt modellt nem hagyták jóvá. Kövesse az előző szakasz lépéseit a modell jóváhagyásához.

Hívja meg a végpontot úgy, hogy kérést küld az általunk telepített HTTP-végpontnak, vagy használja a SageMaker SDK-t. A következő kódban meghívjuk a végpontot néhány tesztadaton:

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)

Az általunk meghívott végpont egy kiszolgáló nélküli végpont volt, ezért a pontos időtartamért és a felhasznált adatokért kell fizetniünk. Észreveheti, hogy a végpont első meghívásakor körülbelül egy másodpercig tart a válasz. Ennek oka a kiszolgáló nélküli végpont hidegindítási ideje. Ha nem sokkal ezután újabb hívást hajt végre, a modell valós időben adja vissza az előrejelzést, mert már meleg.

Ha befejezte a kísérletezést a végponttal, törölheti azt a következő paranccsal:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

Következtetés

Ebben a bejegyzésben végigjártuk a SageMaker folyamat létrehozásának folyamatát R használatával az RStudio környezetünkben, és bemutattuk, hogyan telepíthetjük R modellünket a SageMaker szerver nélküli végpontjára a SageMaker modellnyilvántartás segítségével.

Az RStudio és a SageMaker kombinációjával immár teljes, végpontok közötti ML munkafolyamatokat hozhat létre és hangszerelhet az AWS-en a választott nyelvünk, az R használatával.

Ahhoz, hogy mélyebben elmerülhessen ebben a megoldásban, javasoljuk, hogy tekintse át ennek a megoldásnak a forráskódját, valamint más példákat a webhelyen. GitHub.


A szerzőről

Georgios Schinas az EMEA régióban az AI/ML speciális megoldások építésze. Székhelye Londonban van, és szorosan együttműködik az Egyesült Királyságban és Írországban élő ügyfelekkel. A Georgios segít az ügyfeleknek a gépi tanulási alkalmazások tervezésében és üzembe helyezésében az AWS-en, különös tekintettel az MLOps-gyakorlatokra, és lehetővé teszi az ügyfelek számára a gépi tanulás nagyarányú végrehajtását. Szabadidejében szívesen utazik, főz, és a barátaival és családjával tölti az idejét.

spot_img

Legújabb intelligencia

spot_img