Så här distribuerar du en registrerad R-modell till en onlineslutpunkt (realtid)

Artikel
01/10/2024

GÄLLER FÖR:Azure CLI ml extension v2 (aktuell)

I den här artikeln får du lära dig hur du distribuerar en R-modell till en hanterad slutpunkt (webb-API) så att ditt program kan poängsätta nya data mot modellen nästan i realtid.

Förutsättningar

En Azure Machine Learning-arbetsyta.
Azure CLI- och ml-tillägget har installerats. Eller använd en beräkningsinstans på din arbetsyta, som har CLI förinstallerat.
Minst en anpassad miljö som är associerad med din arbetsyta. Skapa en R-miljö eller någon annan anpassad miljö om du inte har någon.
En förståelse för R-paketet plumber
En modell som du har tränat och paketerat med crateoch registrerat i din arbetsyta

Skapa en mapp med den här strukturen

Skapa den här mappstrukturen för projektet:

📂 r-deploy-azureml
 ├─📂 docker-context
 │  ├─ Dockerfile
 │  └─ start_plumber.R
 ├─📂 src
 │  └─ plumber.R
 ├─ deployment.yml
 ├─ endpoint.yml

Innehållet i var och en av dessa filer visas och förklaras i den här artikeln.

Dockerfile

Det här är filen som definierar containermiljön. Du definierar även installationen av eventuella ytterligare R-paket här.

Ett Dockerfile-exempel ser ut så här:

# REQUIRED: Begin with the latest R container with plumber
FROM rstudio/plumber:latest

# REQUIRED: Install carrier package to be able to use the crated model (whether from a training job
# or uploaded)
RUN R -e "install.packages('carrier', dependencies = TRUE, repos = 'https://cloud.r-project.org/')"

# OPTIONAL: Install any additional R packages you may need for your model crate to run
RUN R -e "install.packages('<PACKAGE-NAME>', dependencies = TRUE, repos = 'https://cloud.r-project.org/')"
RUN R -e "install.packages('<PACKAGE-NAME>', dependencies = TRUE, repos = 'https://cloud.r-project.org/')"

# REQUIRED
ENTRYPOINT []

COPY ./start_plumber.R /tmp/start_plumber.R 

CMD ["Rscript", "/tmp/start_plumber.R"]

Ändra filen för att lägga till de paket som du behöver för ditt bedömningsskript.

Rörmokare. R

Viktigt!

Det här avsnittet visar hur du strukturerar rörmokaren . R-skript . Detaljerad information om paketet finns iplumber dokumentationen plumber .

Filen rörmokare. R är R-skriptet där du definierar funktionen för bedömning. Det här skriptet utför också uppgifter som krävs för att få slutpunkten att fungera. Skriptet kommer att:

Hämtar sökvägen där modellen monteras från AZUREML_MODEL_DIR miljövariabeln i containern.
Läser in ett modellobjekt som skapats med crate funktionen från carrier paketet, som sparades som crate.bin när det paketerades.
Avialiserar modellobjektet
Definierar bedömningsfunktionen

Dricks

Se till att det som din bedömningsfunktion producerar kan konverteras tillbaka till JSON. Vissa R-objekt konverteras inte enkelt.

# plumber.R
# This script will be deployed to a managed endpoint to do the model scoring

# REQUIRED
# When you deploy a model as an online endpoint, Azure Machine Learning mounts your model
# to your endpoint. Model mounting enables you to deploy new versions of the model without
# having to create a new Docker image.

model_dir <- Sys.getenv("AZUREML_MODEL_DIR")

# REQUIRED
# This reads the serialized model with its respecive predict/score method you 
# registered. The loaded load_model object is a raw binary object.
load_model <- readRDS(paste0(model_dir, "/models/crate.bin"))

# REQUIRED
# You have to unserialize the load_model object to make it its function
scoring_function <- unserialize(load_model)

# REQUIRED
# << Readiness route vs. liveness route >>
# An HTTP server defines paths for both liveness and readiness. A liveness route is used to
# check whether the server is running. A readiness route is used to check whether the 
# server's ready to do work. In machine learning inference, a server could respond 200 OK 
# to a liveness request before loading a model. The server could respond 200 OK to a
# readiness request only after the model has been loaded into memory.

#* Liveness check
#* @get /live
function() {
  "alive"
}

#* Readiness check
#* @get /ready
function() {
  "ready"
}

# << The scoring function >>
# This is the function that is deployed as a web API that will score the model
# Make sure that whatever you are producing as a score can be converted 
# to JSON to be sent back as the API response
# in the example here, forecast_horizon (the number of time units to forecast) is the input to scoring_function.  
# the output is a tibble
# we are converting some of the output types so they work in JSON


#* @param forecast_horizon 
#* @post /score
function(forecast_horizon) {
  scoring_function(as.numeric(forecast_horizon)) |> 
    tibble::as_tibble() |> 
    dplyr::transmute(period = as.character(yr_wk),
                     dist = as.character(logmove),
                     forecast = .mean) |> 
    jsonlite::toJSON()
}

start_plumber. R

Filen start_plumber. R är R-skriptet som körs när containern startar och anropar rörmokaren . R-skript . Använd följande skript som det är.

entry_script_path <- paste0(Sys.getenv('AML_APP_ROOT'),'/', Sys.getenv('AZUREML_ENTRY_SCRIPT'))

pr <- plumber::plumb(entry_script_path)

args <- list(host = '0.0.0.0', port = 8000); 

if (packageVersion('plumber') >= '1.0.0') {
  pr$setDocs(TRUE)
} else { 
  args$swagger <- TRUE 
} 

do.call(pr$run, args)

Byggcontainer

De här stegen förutsätter att du har ett Azure Container Registry associerat med din arbetsyta, som skapas när du skapar din första anpassade miljö. Så här ser du om du har en anpassad miljö:

Logga in på Azure Machine Learning-studio.
Välj din arbetsyta om det behövs.
Välj Miljöer i det vänstra navigeringsfältet.
Längst upp väljer du Anpassade miljöer.
Om du ser anpassade miljöer behövs inget mer.
Om du inte ser några anpassade miljöer skapar du en R-miljö eller någon annan anpassad miljö. (Du kommer inte att använda den här miljön för distribution, men du kommer att använda containerregistret som också skapas åt dig.)

När du har kontrollerat att du har minst en anpassad miljö använder du följande steg för att skapa en container.

Öppna ett terminalfönster och logga in på Azure. Om du gör detta från en Azure Machine Learning-beräkningsinstans använder du:
```
az login --identity
```
Om du inte använder beräkningsinstansen utelämnar --identity och följer du uppmaningen att öppna ett webbläsarfönster för att autentisera.
Kontrollera att du har de senaste versionerna av CLI och ml tillägget:
```
az upgrade
```
Om du har flera Azure-prenumerationer anger du den aktiva prenumerationen till den du använder för din arbetsyta. (Du kan hoppa över det här steget om du bara har åtkomst till en enda prenumeration.) Ersätt <SUBSCRIPTION-NAME> med ditt prenumerationsnamn. Ta också bort hakparenteserna <>.
```
az account set --subscription "<SUBSCRIPTION-NAME>"
```
Ange standardarbetsytan. Om du gör detta från en beräkningsinstans kan du använda följande kommando som det är. Om du är på någon annan dator ersätter du resursgruppen och arbetsytans namn i stället. (Du hittar dessa värden i Azure Machine Learning-studio.)
```
az configure --defaults group=$CI_RESOURCE_GROUP workspace=$CI_WORKSPACE
```
Kontrollera att du är i projektkatalogen.
```
cd r-deploy-azureml
```
Om du vill skapa avbildningen i molnet kör du följande bash-kommandon i terminalen. Ersätt <IMAGE-NAME> med det namn som du vill ge bilden.

Om din arbetsyta finns i ett virtuellt nätverk kan du läsa Aktivera Azure Container Registry (ACR) för ytterligare steg att lägga az acr build--image-build-compute till i kommandot på den sista raden i den här koden.
```
WORKSPACE=$(az config get --query "defaults[?name == 'workspace'].value" -o tsv)
ACR_NAME=$(az ml workspace show -n $WORKSPACE --query container_registry -o tsv | cut -d'/' -f9-)
IMAGE_TAG=${ACR_NAME}.azurecr.io/<IMAGE-NAME>

az acr build ./docker-context -t $IMAGE_TAG -r $ACR_NAME
```

Viktigt!

Det tar några minuter innan avbildningen skapas. Vänta tills byggprocessen är klar innan du fortsätter till nästa avsnitt. Stäng inte den här terminalen, du använder den bredvid för att skapa distributionen.

Kommandot az acr laddar automatiskt upp docker-context-mappen – som innehåller artefakterna för att skapa avbildningen – till molnet där avbildningen skapas och finns i ett Azure Container Registry.

Distribuera en modell

I det här avsnittet i artikeln ska du definiera och skapa en slutpunkt och distribution för att distribuera modellen och avbildningen som skapades i föregående steg till en hanterad onlineslutpunkt.

En slutpunkt är en HTTPS-slutpunkt som klienter – till exempel ett program – kan anropa för att ta emot bedömningsutdata från en tränad modell. Den ger:

Autentisering med hjälp av "nyckel & token"-baserad autentisering
SSL-avslutning
En stabil bedömnings-URI (endpoint-name.region.inference.ml.Azure.com)

En distribution är en uppsättning resurser som krävs för att vara värd för den modell som utför den faktiska poängsättningen. En enskildslutpunkt kan innehålla fleradistributioner. Med funktionerna för belastningsutjämning i hanterade Slutpunkter i Azure Machine Learning kan du ge valfri procentandel trafik till varje distribution. Trafikallokering kan användas för säker distribution av blå/gröna distributioner genom att balansera begäranden mellan olika instanser.

Skapa hanterad onlineslutpunkt

Lägg till filen endpoint.yml i projektkatalogen med följande kod. Ersätt <ENDPOINT-NAME> med det namn som du vill ge den hanterade slutpunkten.
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: <ENDPOINT-NAME>
auth_mode: aml_token
```
Använd samma terminal där du skapade avbildningen och kör följande CLI-kommando för att skapa en slutpunkt:
```
az ml online-endpoint create -f endpoint.yml
```
Låt terminalen vara öppen för att fortsätta använda den i nästa avsnitt.

Skapa distribution

Om du vill skapa distributionen lägger du till följande kod i filen deployment.yml .

Ersätt <ENDPOINT-NAME> med det slutpunktsnamn som du definierade i filen endpoint.yml
Ersätt <DEPLOYMENT-NAME> med det namn som du vill ge distributionen
Ersätt <MODEL-URI> med den registrerade modellens URI i form av azureml:modelname@latest
Ersätt <IMAGE-TAG> med värdet från:
```
echo $IMAGE_TAG
```

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: <DEPLOYMENT-NAME>
endpoint_name: <ENDPOINT-NAME>
code_configuration:
  code: ./src
  scoring_script: plumber.R
model: <MODEL-URI>
environment:
  image: <IMAGE-TAG>
  inference_config:
    liveness_route:
      port: 8000
      path: /live
    readiness_route:
      port: 8000
      path: /ready
    scoring_route:
      port: 8000
      path: /score
instance_type: Standard_DS2_v2
instance_count: 1

Kör sedan följande CLI-kommando i terminalen för att skapa distributionen (observera att du anger 100 % av trafiken till den här modellen):
```
az ml online-deployment create -f deployment.yml --all-traffic --skip-script-validation
```

Kommentar

Det kan ta flera minuter innan tjänsten distribueras. Vänta tills distributionen är klar innan du fortsätter till nästa avsnitt.

Testa

När distributionen har skapats kan du testa slutpunkten med studio eller CLI:

Studio
Azure CLI

Gå till Azure Machine Learning-studio och välj slutpunkter på den vänstra menyn. Välj sedan r-endpoint-iris som du skapade tidigare.

Ange följande json i textrutan Indata för att vila slutpunkt i realtid:

{
    "forecast_horizon" : [2]
}

Välj Testa. Du bör se följande utdata:

Skapa en exempelbegäran

I den överordnade projektmappen skapar du en fil med namnet sample_request.json och fyller i den med:

{
    "forecast_horizon" : [2]
}

Anropa slutpunkten

Anropa begäran. I det här exemplet används namnet r-endpoint-forecast:

az ml online-endpoint invoke --name r-endpoint-forecast --request-file sample_request.json

Rensa resurser

Nu när du har gjort mål med slutpunkten kan du ta bort den så att du inte får löpande kostnader:

az ml online-endpoint delete --name r-endpoint-forecast

Nästa steg

Mer information om hur du använder R med Azure Machine Learning finns i Översikt över R-funktioner i Azure Machine Learning