Nasazení registrovaného modelu R do online koncového bodu (v reálném čase)

Článek
01/10/2024

PLATÍ PRO:Rozšíření Azure CLI ml v2 (aktuální)

V tomto článku se dozvíte, jak nasadit model R do spravovaného koncového bodu (webového rozhraní API), aby vaše aplikace dokázala ohodnotit nová data modelu téměř v reálném čase.

Požadavky

Pracovní prostor Učení Azure Machine.
Nainstalované rozšíření Azure CLI a ml Nebo ve svém pracovním prostoru použijte výpočetní instanci, která má předinstalované rozhraní příkazového řádku.
Alespoň jedno vlastní prostředí přidružené k vašemu pracovnímu prostoru. Pokud ho nemáte, vytvořte prostředí R nebo jiné vlastní prostředí.
Znalost balíčku R plumber
Model, který jste natrénovali a zabalili cratedo svého pracovního prostoru a zaregistrovali ho do svého pracovního prostoru

Vytvoření složky s touto strukturou

Vytvořte pro svůj projekt tuto strukturu složek:

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

Obsah každého z těchto souborů je zobrazený a vysvětlený v tomto článku.

Dockerfile

Toto je soubor, který definuje prostředí kontejneru. Tady také definujete instalaci všech dalších balíčků R.

Ukázkový soubor Dockerfile bude vypadat takto:

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

Upravte soubor tak, aby se přidaly balíčky, které potřebujete pro bodovací skript.

Instalatér. R

Důležité

Tato část ukazuje, jak strukturovat instalatéra. Skript jazyka R . Podrobné informace o plumber balíčku naleznete v plumber dokumentaci .

Instalatér souboru . R je skript R, ve kterém definujete funkci pro bodování. Tento skript také provádí úlohy, které jsou nezbytné k tomu, aby koncový bod fungoval. Tento skript:

Získá cestu, kde je model připojen z AZUREML_MODEL_DIR proměnné prostředí v kontejneru.
Načte objekt modelu vytvořený pomocí crate funkce z carrier balíčku, který byl uložen jako crate.bin při zabalení.
Unserializes objekt modelu
Definuje funkci bodování.

Tip

Ujistěte se, že cokoli, co bodovací funkce vytvoří, je možné převést zpět na JSON. Některé objekty jazyka R nejsou snadno převedeny.

# 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

Soubor start_plumber. R je skript R, který se spustí při spuštění kontejneru a volá instalatér. Skript jazyka R. Použijte následující skript tak, jak je.

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)

Sestavení kontejneru

Tento postup předpokládá, že máte přidružený azure Container Registry k vašemu pracovnímu prostoru, který se vytvoří při vytváření vašeho prvního vlastního prostředí. Pokud chcete zjistit, jestli máte vlastní prostředí:

Přihlaste se k studio Azure Machine Learning.
V případě potřeby vyberte svůj pracovní prostor.
V levém navigačním panelu vyberte Prostředí.
Nahoře vyberte Vlastní prostředí.
Pokud uvidíte vlastní prostředí, není potřeba nic dalšího.
Pokud nevidíte žádná vlastní prostředí, vytvořte prostředí R nebo jiné vlastní prostředí. (Toto prostředí nebudete používat pro nasazení, ale použijete registr kontejneru, který se pro vás také vytvoří.)

Jakmile ověříte, že máte aspoň jedno vlastní prostředí, pomocí následujícího postupu vytvořte kontejner.

Otevřete okno terminálu a přihlaste se k Azure. Pokud to provádíte z výpočetní instance Azure Machine Učení, použijte:
```
az login --identity
```
Pokud nejste ve výpočetní instanci, vymiďte --identity ji a postupujte podle pokynů a otevřete okno prohlížeče, které se má ověřit.
Ujistěte se, že máte nejnovější verze rozhraní příkazového řádku a ml rozšíření:
```
az upgrade
```
Pokud máte více předplatných Azure, nastavte aktivní předplatné na předplatné, které používáte pro svůj pracovní prostor. (Tento krok můžete přeskočit, pokud máte přístup jenom k jednomu předplatnému.) Nahraďte <SUBSCRIPTION-NAME> názvem předplatného. Odeberte také hranaté závorky <>.
```
az account set --subscription "<SUBSCRIPTION-NAME>"
```
Nastavte výchozí pracovní prostor. Pokud to provádíte z výpočetní instance, můžete použít následující příkaz, jak je tomu. Pokud jste na jiném počítači, nahraďte místo toho název skupiny prostředků a pracovního prostoru. (Tyto hodnoty najdete v studio Azure Machine Learning.)
```
az configure --defaults group=$CI_RESOURCE_GROUP workspace=$CI_WORKSPACE
```
Ujistěte se, že jste v adresáři projektu.
```
cd r-deploy-azureml
```
Pokud chcete vytvořit image v cloudu, spusťte v terminálu následující příkazy Bash. Nahraďte <IMAGE-NAME> názvem, který chcete obrázku dát.

Pokud je váš pracovní prostor ve virtuální síti, přečtěte si téma Povolení služby Azure Container Registry (ACR) a další kroky pro přidání --image-build-compute do az acr build příkazu na posledním řádku tohoto kódu.
```
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
```

Důležité

Sestavení image bude trvat několik minut. Než budete pokračovat k další části, počkejte na dokončení procesu sestavení. Nezavírejte tento terminál, použijete ho vedle vytvoření nasazení.

Příkaz az acr automaticky nahraje vaši složku kontextu Dockeru , která obsahuje artefakty pro sestavení image , do cloudu, kde se image sestaví a hostuje ve službě Azure Container Registry.

Nasazení modelu

V této části článku definujete a vytvoříte koncový bod a nasazení pro nasazení modelu a image integrované v předchozích krocích do spravovaného online koncového bodu.

Koncový bod je koncový bod HTTPS, který klienti (například aplikace) můžou volat za účelem přijetí výstupu bodování vytrénovaného modelu. Poskytuje:

Ověřování pomocí ověřování založeného na klíči a tokenu
Ukončení protokolu SSL
Stabilní identifikátor URI bodování (endpoint-name.region.inference.ml.Azure.com)

Nasazení je sada prostředků vyžadovaných pro hostování modelu, který provádí skutečné bodování. Jedenkoncový bod může obsahovat vícenasazení. Funkce vyrovnávání zatížení spravovaných koncových bodů Azure Machine Učení umožňují poskytnout každému nasazení libovolné procento provozu. Přidělení provozu se dá použít k bezpečnému zavedení modrých nebo zelených nasazení vyvážením požadavků mezi různými instancemi.

Vytvoření spravovaného online koncového bodu

Do adresáře projektu přidejte soubor endpoint.yml s následujícím kódem. Nahraďte <ENDPOINT-NAME> názvem, který chcete dát spravovanému koncovému bodu.
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: <ENDPOINT-NAME>
auth_mode: aml_token
```
Pomocí stejného terminálu, ve kterém jste vytvořili image, vytvořte koncový bod spuštěním následujícího příkazu rozhraní příkazového řádku:
```
az ml online-endpoint create -f endpoint.yml
```
Nechte terminál otevřený a pokračujte v jeho používání v další části.

Vytvoření nasazení

Pokud chcete vytvořit nasazení, přidejte do souboru deployment.yml následující kód.

Nahraďte <ENDPOINT-NAME> názvem koncového bodu, který jste definovali v souboru endpoint.yml .
Nahraďte <DEPLOYMENT-NAME> názvem, který chcete nasazení udělit.
Nahraďte <MODEL-URI> identifikátorem URI registrovaného modelu ve formě azureml:modelname@latest
Nahraďte <IMAGE-TAG> hodnotou z:
```
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

Potom v terminálu spusťte následující příkaz rozhraní příkazového řádku a vytvořte nasazení (všimněte si, že nastavujete 100 % provozu na tento model):
```
az ml online-deployment create -f deployment.yml --all-traffic --skip-script-validation
```

Poznámka:

Nasazení služby může trvat několik minut. Než budete pokračovat k další části, počkejte na dokončení nasazení.

Test

Po úspěšném vytvoření nasazení můžete koncový bod otestovat pomocí studia nebo rozhraní příkazového řádku:

Studio
Azure CLI

Přejděte na studio Azure Machine Learning a vyberte z levé nabídky Koncové body. Pak vyberte r-endpoint-iris , který jste vytvořili dříve.

Do textového pole vstupních dat zadejte následující kód JSON, který bude uložený v reálném čase :

{
    "forecast_horizon" : [2]
}

Vyberte Test. Měl by se zobrazit následující výstup:

Vytvoření ukázkové žádosti

V nadřazené složce projektu vytvořte soubor s názvem sample_request.json a naplňte ho:

{
    "forecast_horizon" : [2]
}

Vyvolání koncového bodu

Vyvolání požadavku V tomto příkladu se používá název r-endpoint-forecast:

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

Vyčištění prostředků

Teď, když jste úspěšně získali skóre pomocí koncového bodu, můžete ho odstranit, abyste nemuseli účtovat průběžné náklady:

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

Další kroky

Další informace o používání jazyka R se službou Azure Machine Učení najdete v tématu Přehled možností jazyka R v Azure Machine Učení