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

GÄLLER FÖR: Azure CLI ml-tillägget v2 (aktuellt)

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 Mašinsko učenje-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

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

# 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ö:

1. Logga in på Azure Mašinsko učenje Studio.
2. Välj din arbetsyta om det behövs.
3. Välj Miljöer i det vänstra navigeringsfältet.
4. Längst upp väljer du Anpassade miljöer.
5. Om du ser anpassade miljöer behövs inget mer.
6. 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ö startar du en terminal och konfigurerar CLI:

1. Öppna ett terminalfönster och logga in på Azure. Om du använder en Azure Mašinsko učenje 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.

2. Kontrollera att du har de senaste versionerna av CLI och ml tillägget:

   az upgrade
   

3. 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 <YOUR_SUBSCRIPTION_NAME_OR_ID> med antingen ditt prenumerationsnamn eller prenumerations-ID. Ta också bort hakparenteserna <>.

   az account set -s "<YOUR_SUBSCRIPTION_NAME_OR_ID>"
   

4. Ange standardarbetsytan. Om du använder en beräkningsinstans kan du behålla 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 Mašinsko učenje studio.)

   az configure --defaults group=$CI_RESOURCE_GROUP workspace=$CI_WORKSPACE
   

När du har konfigurerat CLI använder du följande steg för att skapa en container.

1. Kontrollera att du är i projektkatalogen.

   cd r-deploy-azureml
   

2. 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
   

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:

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 enskild slutpunkt kan innehålla flera distributioner. Med funktionerna för belastningsutjämning i Azure Mašinsko učenje hanterade slutpunkter 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

1. I projektkatalogen lägger du till filen endpoint.yml 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
   

2. 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
   

3. Låt terminalen vara öppen för att fortsätta använda den i nästa avsnitt.

Skapa distribution

1. 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
   

2. 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
   

Test

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

{
    "forecast_horizon" : [2]
}

{
    "forecast_horizon" : [2]
}

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 Mašinsko učenje finns i Översikt över R-funktioner i Azure Mašinsko učenje