Een geregistreerd R-model implementeren op een online (realtime) eindpunt

Artikel
01/10/2024

VAN TOEPASSING OP:Azure CLI ml-extensie v2 (huidige)

In dit artikel leert u hoe u een R-model implementeert in een beheerd eindpunt (Web-API), zodat uw toepassing in bijna realtime nieuwe gegevens kan scoren op basis van het model.

Vereisten

Een Azure Machine Learning-werkruimte.
Azure CLI en ml-extensie geïnstalleerd. Of gebruik een rekenproces in uw werkruimte, waarop de CLI vooraf is geïnstalleerd.
Ten minste één aangepaste omgeving die is gekoppeld aan uw werkruimte. Maak een R-omgeving of een andere aangepaste omgeving als u er nog geen hebt.
Een goed begrip van het R-pakket plumber
Een model waarmee u hebt getraind en verpakt crateen geregistreerd in uw werkruimte

Een map maken met deze structuur

Maak deze mapstructuur voor uw project:

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

De inhoud van elk van deze bestanden wordt weergegeven en uitgelegd in dit artikel.

Dockerfile

Dit is het bestand dat de containeromgeving definieert. U definieert hier ook de installatie van eventuele extra R-pakketten.

Een Dockerfile-voorbeeld ziet er als volgt uit:

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

Wijzig het bestand om de pakketten toe te voegen die u nodig hebt voor uw scorescript.

Loodgieter. R

Belangrijk

In deze sectie ziet u hoe u de loodgieter kunt structuren. R-script . Zie de documentatie voor gedetailleerde informatie over het plumber pakketplumber.

Het bestand loodgieter. R is het R-script waarin u de functie definieert voor scoren. Met dit script worden ook taken uitgevoerd die nodig zijn om uw eindpunt te laten werken. Met het script:

Hiermee haalt u het pad op waar het model is gekoppeld vanuit de AZUREML_MODEL_DIR omgevingsvariabele in de container.
Laadt een modelobject dat is gemaakt met de crate functie van het carrier pakket, dat is opgeslagen als crate.bin toen het werd verpakt.
Het modelobject wordt niet meer geserialiseerd
Definieert de scorefunctie

Tip

Zorg ervoor dat wat uw scorefunctie produceert, weer kan worden geconverteerd naar JSON. Sommige R-objecten kunnen niet eenvoudig worden geconverteerd.

# 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

Het bestand start_plumber. R is het R-script dat wordt uitgevoerd wanneer de container wordt gestart en die uw loodgieter aanroept. R-script . Gebruik het volgende script als zodanig.

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)

Container bouwen

Bij deze stappen wordt ervan uitgegaan dat er een Azure Container Registry is gekoppeld aan uw werkruimte, die wordt gemaakt wanneer u uw eerste aangepaste omgeving maakt. Als u wilt zien of u een aangepaste omgeving hebt:

Meld u aan bij Azure Machine Learning Studio.
Selecteer indien nodig uw werkruimte.
Selecteer omgevingen in het linkernavigatievenster.
Selecteer bovenaan aangepaste omgevingen.
Als u aangepaste omgevingen ziet, is er niets meer nodig.
Als u geen aangepaste omgevingen ziet, maakt u een R-omgeving of een andere aangepaste omgeving. (U gebruikt deze omgeving niet voor implementatie, maar u gebruikt het containerregister dat ook voor u is gemaakt.)

Nadat u hebt gecontroleerd of u ten minste één aangepaste omgeving hebt, gebruikt u de volgende stappen om een container te bouwen.

Open een terminalvenster en meld u aan bij Azure. Als u dit doet vanuit een Azure Machine Learning-rekenproces, gebruikt u:
```
az login --identity
```
Als u zich niet in het rekenproces bevindt, laat --identity u deze weg en volgt u de prompt om een browservenster te openen om te verifiëren.
Zorg ervoor dat u de meest recente versies van de CLI en de ml extensie hebt:
```
az upgrade
```
Als u meerdere Azure-abonnementen hebt, stelt u het actieve abonnement in op het abonnement dat u voor uw werkruimte gebruikt. (U kunt deze stap overslaan als u alleen toegang hebt tot één abonnement.) Vervang door <SUBSCRIPTION-NAME> de naam van uw abonnement. Verwijder ook de vierkante <>haken.
```
az account set --subscription "<SUBSCRIPTION-NAME>"
```
Stel de standaardwerkruimte in. Als u dit doet vanuit een rekenproces, kunt u de volgende opdracht gebruiken. Als u zich op een andere computer bevindt, vervangt u in plaats daarvan de naam van uw resourcegroep en werkruimte. (U vindt deze waarden in Azure Machine Learning-studio.)
```
az configure --defaults group=$CI_RESOURCE_GROUP workspace=$CI_WORKSPACE
```
Zorg ervoor dat u zich in de projectmap bevindt.
```
cd r-deploy-azureml
```
Als u de installatiekopieën in de cloud wilt bouwen, voert u de volgende bash-opdrachten uit in uw terminal. Vervang door <IMAGE-NAME> de naam die u de afbeelding wilt geven.

Als uw werkruimte zich in een virtueel netwerk bevindt, raadpleegt u Azure Container Registry (ACR) inschakelen voor aanvullende stappen om toe te voegen --image-build-compute aan de az acr build opdracht in de laatste regel van deze code.
```
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
```

Belangrijk

Het duurt enkele minuten voordat de installatiekopie is gemaakt. Wacht totdat het buildproces is voltooid voordat u verdergaat met de volgende sectie. Sluit deze terminal niet, u gebruikt deze naast het maken van de implementatie.

Met az acr de opdracht wordt uw docker-contextmap , die de artefacten bevat om de installatiekopie te bouwen, automatisch geüpload naar de cloud waarin de installatiekopie wordt gebouwd en gehost in een Azure Container Registry.

Model implementeren

In deze sectie van het artikel definieert en maakt u een eindpunt en implementatie om het model en de installatiekopie te implementeren die in de vorige stappen zijn gebouwd naar een beheerd online-eindpunt.

Een eindpunt is een HTTPS-eindpunt dat clients, zoals een toepassing, kunnen aanroepen om de score-uitvoer van een getraind model te ontvangen. Het biedt:

Verificatie met op sleutel en token gebaseerde verificatie
SSL-beëindiging
Een stabiele score-URI (endpoint-name.region.inference.ml.Azure.com)

Een implementatie is een set resources die vereist is voor het hosten van het model dat de werkelijke score uitvoert. Eén eindpunt kan meerdereimplementaties bevatten. Met de taakverdelingsmogelijkheden van door Azure Machine Learning beheerde eindpunten kunt u elk percentage verkeer aan elke implementatie geven. Verkeerstoewijzing kan worden gebruikt om veilige blauw/groene implementaties uit te voeren door aanvragen tussen verschillende exemplaren te verdelen.

Beheerd online-eindpunt maken

Voeg in de projectmap het bestand endpoint.yml toe met de volgende code. Vervang door <ENDPOINT-NAME> de naam die u uw beheerde eindpunt wilt geven.
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: <ENDPOINT-NAME>
auth_mode: aml_token
```
Voer met behulp van dezelfde terminal waar u de installatiekopie hebt gemaakt de volgende CLI-opdracht uit om een eindpunt te maken:
```
az ml online-endpoint create -f endpoint.yml
```
Laat de terminal geopend om door te gaan met het gebruik ervan in de volgende sectie.

Implementatie maken

Als u uw implementatie wilt maken, voegt u de volgende code toe aan het bestand deployment.yml .

Vervang door <ENDPOINT-NAME> de eindpuntnaam die u hebt gedefinieerd in het bestand endpoint.yml
Vervang <DEPLOYMENT-NAME> door de naam die u de implementatie wilt geven
Vervangen door <MODEL-URI> de URI van het geregistreerde model in de vorm van azureml:modelname@latest
Vervang <IMAGE-TAG> door de waarde van:
```
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

Voer vervolgens in de terminal de volgende CLI-opdracht uit om de implementatie te maken (u ziet dat u 100% van het verkeer naar dit model instelt):
```
az ml online-deployment create -f deployment.yml --all-traffic --skip-script-validation
```

Notitie

Het kan enkele minuten duren voordat de service is geïmplementeerd. Wacht totdat de implementatie is voltooid voordat u verdergaat met de volgende sectie.

Testen

Zodra uw implementatie is gemaakt, kunt u het eindpunt testen met behulp van Studio of de CLI:

Studio
Azure-CLI

Navigeer naar de Azure Machine Learning-studio en selecteer in het menu Eindpunten aan de linkerkant. Selecteer vervolgens de r-endpoint-iris die u eerder hebt gemaakt.

Voer de volgende json in het tekstvak Invoergegevens in om het realtime-eindpunt in te schakelen:

{
    "forecast_horizon" : [2]
}

Selecteer Testen. U moet de volgende uitvoer zien:

Een voorbeeldaanvraag maken

Maak in de bovenliggende map van het project een bestand met de naam sample_request.json en vul het in met:

{
    "forecast_horizon" : [2]
}

Het eindpunt aanroepen

Roep de aanvraag aan. In dit voorbeeld wordt de naam r-endpoint-forecast gebruikt:

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

Resources opschonen

Nu u met succes hebt gescoord met uw eindpunt, kunt u het verwijderen zodat er geen doorlopende kosten in rekening worden gebracht:

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

Volgende stappen

Zie Overzicht van R-mogelijkheden in Azure Machine Learning voor meer informatie over het gebruik van R met Azure Machine Learning

Share via