Een aangepaste container gebruiken om een model te implementeren op een online-eindpunt

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Meer informatie over het gebruik van een aangepaste container voor het implementeren van een model naar een online-eindpunt in Azure Machine Learning.

Aangepaste containerimplementaties kunnen andere webservers gebruiken dan de standaard Python Flask-server die wordt gebruikt door Azure Machine Learning. Gebruikers van deze implementaties kunnen nog steeds profiteren van de ingebouwde bewaking, schaalaanpassing, waarschuwingen en verificatie van Azure Machine Learning.

De volgende tabel bevat verschillende implementatievoorbeelden die gebruikmaken van aangepaste containers zoals TensorFlow Serving, TorchServe, Triton Inference Server, Plumber R package en Azure Machine Learning Inference Minimal image.

Opmerking	Script (CLI)	Beschrijving
minimaal/multimodel	deploy-custom-container-minimal-multimodel	Implementeer meerdere modellen in één implementatie door de minimale installatiekopie van Azure Machine Learning Uit te breiden.
minimaal/enkel model	deploy-custom-container-minimal-single-model	Implementeer één model door de minimale installatiekopie van Azure Machine Learning-deductie uit te breiden.
mlflow/multideployment-scikit	deploy-custom-container-mlflow-multideployment-scikit	Implementeer twee MLFlow-modellen met verschillende Python-vereisten voor twee afzonderlijke implementaties achter één eindpunt met behulp van de minimale installatiekopie van Azure Machine Learning.
r/multimodel-loodgieter	deploy-custom-container-r-multimodel-plumber	Drie regressiemodellen implementeren op één eindpunt met behulp van het Plumber R-pakket
tfserving/half-plus-two	deploy-custom-container-tfserving-half-plus-two	Implementeer een Half Plus Two-model met behulp van een aangepaste TensorFlow Serving-container met behulp van het standaardmodelregistratieproces.
tfserving/half-plus-two-integrated	deploy-custom-container-tfserving-half-plus-two-integrated	Implementeer een Half Plus Two-model met behulp van een aangepaste TensorFlow Serving-container met het model dat is geïntegreerd in de installatiekopieën.
torchserve/densenet	deploy-custom-container-torchserve-densenet	Implementeer één model met behulp van een aangepaste TorchServe-container.
triton/single-model	deploy-custom-container-triton-single-model	Een Triton-model implementeren met behulp van een aangepaste container

Dit artikel is gericht op het bedienen van een TensorFlow-model met TensorFlow (TF) Serving.

Waarschuwing

Microsoft kan mogelijk niet helpen bij het oplossen van problemen die worden veroorzaakt door een aangepaste installatiekopieën. Als u problemen ondervindt, wordt u mogelijk gevraagd om de standaardafbeelding te gebruiken of een van de afbeeldingen die Microsoft biedt om te zien of het probleem specifiek is voor uw afbeelding.

Vereisten

Voordat u de stappen in dit artikel volgt, moet u ervoor zorgen dat u over de volgende vereisten beschikt:

• Een Azure Machine Learning-werkruimte. Als u er nog geen hebt, gebruikt u de stappen in de quickstart: artikel Werkruimtebronnen maken om er een te maken.

• De Azure CLI en de ml extensie of de Azure Machine Learning Python SDK v2:

  • Zie De CLI (v2) installeren, instellen en gebruiken om de Azure CLI en extensie te installeren.

    Belangrijk

    In de CLI-voorbeelden in dit artikel wordt ervan uitgegaan dat u de Bash-shell (of compatibele) shell gebruikt. Bijvoorbeeld vanuit een Linux-systeem of Windows-subsysteem voor Linux.

  • Gebruik de volgende opdracht om de Python SDK v2 te installeren:

    pip install azure-ai-ml azure-identity
    

    Gebruik de volgende opdracht om een bestaande installatie van de SDK bij te werken naar de nieuwste versie:

    pip install --upgrade azure-ai-ml azure-identity
    

    Zie De Python SDK v2 voor Azure Machine Learning installeren voor meer informatie.

• U of de service-principal die u gebruikt, moet inzendertoegang hebben tot de Azure-resourcegroep die uw werkruimte bevat. U hebt een dergelijke resourcegroep als u uw werkruimte hebt geconfigureerd met behulp van het quickstart-artikel.

• Als u lokaal wilt implementeren, moet de Docker-engine lokaal worden uitgevoerd. Deze stap wordt ten zeerste aanbevolen. Dit helpt u bij het opsporen van problemen.

Broncode downloaden

Als u deze zelfstudie wilt volgen, kloont u de broncode van GitHub.

Azure-CLI

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Python SDK

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Zie ook het voorbeeldnotitieblok, maar houd er rekening mee dat 3. Test locally in de sectie in het notitieblok ervan wordt uitgegaan dat deze wordt uitgevoerd onder de azureml-examples/sdk map.

Omgevingsvariabelen initialiseren

Omgevingsvariabelen definiëren:

BASE_PATH=endpoints/online/custom-container/tfserving/half-plus-two
AML_MODEL_NAME=tfserving-mounted
MODEL_NAME=half_plus_two
MODEL_BASE_PATH=/var/azureml-app/azureml-models/$AML_MODEL_NAME/1

Een TensorFlow-model downloaden

Download en pak een model uit dat een invoer door twee deelt en voegt 2 toe aan het resultaat:

wget https://aka.ms/half_plus_two-model -O $BASE_PATH/half_plus_two.tar.gz
tar -xvf $BASE_PATH/half_plus_two.tar.gz -C $BASE_PATH

Een TF Serving-installatiekopieën lokaal uitvoeren om te testen of deze werkt

Gebruik docker om uw installatiekopieën lokaal uit te voeren om te testen:

docker run --rm -d -v $PWD/$BASE_PATH:$MODEL_BASE_PATH -p 8501:8501 \
 -e MODEL_BASE_PATH=$MODEL_BASE_PATH -e MODEL_NAME=$MODEL_NAME \
 --name="tfserving-test" docker.io/tensorflow/serving:latest
sleep 10

Controleer of u liveness- en scoreaanvragen naar de afbeelding kunt verzenden

Controleer eerst of de container actief is, wat betekent dat het proces in de container nog steeds wordt uitgevoerd. U krijgt een 200 (OK)-antwoord.

curl -v http://localhost:8501/v1/models/$MODEL_NAME

Controleer vervolgens of u voorspellingen kunt krijgen over niet-gelabelde gegevens:

curl --header "Content-Type: application/json" \
  --request POST \
  --data @$BASE_PATH/sample_request.json \
  http://localhost:8501/v1/models/$MODEL_NAME:predict

De afbeelding stoppen

Nu u lokaal hebt getest, stopt u de installatiekopieën:

docker stop tfserving-test

Uw online-eindpunt implementeren in Azure

Implementeer vervolgens uw online-eindpunt in Azure.

Azure-CLI

Een YAML-bestand maken voor uw eindpunt en implementatie

U kunt uw cloudimplementatie configureren met BEHULP van YAML. Bekijk de YAML-voorbeeld voor dit voorbeeld:

tfserving-endpoint.yml

$schema: https://azuremlsdk2.blob.core.windows.net/latest/managedOnlineEndpoint.schema.json
name: tfserving-endpoint
auth_mode: aml_token

tfserving-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: {{MODEL_VERSION}}
  path: ./half_plus_two
environment_variables:
  MODEL_BASE_PATH: /var/azureml-app/azureml-models/tfserving-mounted/{{MODEL_VERSION}}
  MODEL_NAME: half_plus_two
environment:
  #name: tfserving
  #version: 1
  image: docker.io/tensorflow/serving:latest
  inference_config:
    liveness_route:
      port: 8501
      path: /v1/models/half_plus_two
    readiness_route:
      port: 8501
      path: /v1/models/half_plus_two
    scoring_route:
      port: 8501
      path: /v1/models/half_plus_two:predict
instance_type: Standard_DS3_v2
instance_count: 1

Python SDK

Verbinding maken met Azure Machine Learning-werkruimte

Maak verbinding met uw Azure Machine Learning-werkruimte, configureer werkruimtegegevens en krijg als volgt een ingang voor de werkruimte:

1. Importeer de vereiste bibliotheken:

# import required libraries
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
   ManagedOnlineEndpoint,
   ManagedOnlineDeployment,
   Model,
   Environment,
   CodeConfiguration,
)
from azure.identity import DefaultAzureCredential

2. Configureer werkruimtegegevens en haal een ingang op voor de werkruimte:

# enter details of your Azure Machine Learning workspace
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AZUREML_WORKSPACE_NAME>"

# get a handle to the workspace
ml_client = MLClient(
   DefaultAzureCredential(), subscription_id, resource_group, workspace
)

Zie Machine Learning-modellen implementeren naar een beheerd online-eindpunt met behulp van Python SDK v2 voor meer informatie.

Online-eindpunt configureren

Tip

• name: De naam van het eindpunt. Deze moet uniek zijn in de Azure-regio. De naam van een eindpunt moet beginnen met een hoofdletter of kleine letter en mag alleen bestaan uit '-'s en alfanumerieke tekens. Zie eindpuntlimieten voor meer informatie over de naamgevingsregels.
• auth_mode : Gebruiken key voor verificatie op basis van sleutels. Gebruiken aml_token voor verificatie op basis van tokens op basis van Azure Machine Learning. A key verloopt niet, maar aml_token verloopt wel. Zie Verifiëren bij een online-eindpunt voor meer informatie over verificatie.

U kunt desgewenst een beschrijving, tags toevoegen aan uw eindpunt.

# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

online_endpoint_name = "endpoint-" + datetime.datetime.now().strftime("%m%d%H%M%f")

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is a sample online endpoint",
    auth_mode="key",
    tags={"foo": "bar"},
)

Online-implementatie configureren

Een implementatie is een set resources die vereist is voor het hosten van het model dat de werkelijke deductie uitvoert. Maak een implementatie voor ons eindpunt met behulp van de ManagedOnlineDeployment klasse.

Tip

• name - Naam van de implementatie.
• endpoint_name - Naam van het eindpunt waaronder de implementatie moet worden gemaakt.
• model - Het model dat moet worden gebruikt voor de implementatie. Deze waarde kan een verwijzing zijn naar een bestaand versiemodel > in de werkruimte of een inline modelspecificatie.
• environment - De omgeving die moet worden gebruikt voor de implementatie. Deze waarde kan een verwijzing zijn naar een bestaande > versieomgeving in de werkruimte of een inline-omgevingsspecificatie.
• code_configuration - de configuratie voor de broncode en het scorescript
  • path- Pad naar de broncodemap voor het scoren van het model
  • scoring_script - Relatief pad naar het scorebestand in de broncodemap
• instance_type - De VM-grootte die moet worden gebruikt voor de implementatie. Zie de SKU-lijst met eindpunten voor de lijst met ondersteunde grootten.
• instance_count - Het aantal exemplaren dat moet worden gebruikt voor de implementatie

# create a blue deployment
model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

env = Environment(
    image="docker.io/tensorflow/serving:latest",
    inference_config={
        "liveness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "readiness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "scoring_route": {"port": 8501, "path": "/v1/models/half_plus_two:predict"},
    },
)

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    environment_variables={
        "MODEL_BASE_PATH": "/var/azureml-app/azureml-models/tfserving-mounted/1",
        "MODEL_NAME": "half_plus_two",
    },
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Er zijn enkele belangrijke concepten die u moet noteren in deze YAML-/Python-parameter:

Basisinstallatiekopieën

De basisinstallatiekopieën worden opgegeven als een parameter in de omgeving en docker.io/tensorflow/serving:latest worden in dit voorbeeld gebruikt. Wanneer u de container inspecteert, kunt u zien dat deze server een ENTRYPOINT invoerpuntscript start, waarbij de omgevingsvariabelen, zoals MODEL_BASE_PATH en MODEL_NAME, worden gebruikt en poorten beschikbaar worden gemaakt zoals 8501. Deze details zijn allemaal specifieke informatie voor deze gekozen server. U kunt dit begrip van de server gebruiken om te bepalen hoe u de implementatie definieert. Als u bijvoorbeeld omgevingsvariabelen voor MODEL_BASE_PATH en MODEL_NAME in de implementatiedefinitie instelt, neemt de server (in dit geval TF Serving) de waarden om de server te initiëren. Als u de poort instelt voor de routes 8501 in de implementatiedefinitie, wordt de gebruikersaanvraag naar dergelijke routes correct doorgestuurd naar de TF-server.

Houd er rekening mee dat dit specifieke voorbeeld is gebaseerd op de TF Serving-case, maar u kunt alle containers gebruiken die op de hoogte blijven en reageren op aanvragen die beschikbaar zijn voor liveness, gereedheid en scoreroutes. U kunt naar andere voorbeelden verwijzen en zien hoe het dockerfile wordt gevormd (bijvoorbeeld met behulp CMD van in plaats van ENTRYPOINT) om de containers te maken.

Deductieconfiguratie

Deductieconfiguratie is een parameter in de omgeving en geeft de poort en het pad op voor drie typen van de route: liveness, gereedheid en scoreroute. Deductieconfiguratie is vereist als u uw eigen container wilt uitvoeren met een beheerd online-eindpunt.

Gereedheidsroute versus livenessroute

De API-server die u kiest, kan een manier bieden om de status van de server te controleren. Er zijn twee soorten route die u kunt opgeven: leven en gereedheid. Er wordt een livenessroute gebruikt om te controleren of de server wordt uitgevoerd. Er wordt een gereedheidsroute gebruikt om te controleren of de server gereed is voor werk. In de context van machine learning-deductie kan een server 200 OK reageren op een liveness-aanvraag voordat een model wordt geladen en kan de server 200 OK reageren op een gereedheidsaanvraag pas nadat het model in het geheugen is geladen.

Zie de Kubernetes-documentatie voor meer informatie over liveness- en gereedheidstests in het algemeen.

De liveness- en gereedheidsroutes worden bepaald door de API-server van uw keuze, zoals u zou hebben vastgesteld bij het lokaal testen van de container in een eerdere stap. Houd er rekening mee dat voor de voorbeeldimplementatie in dit artikel hetzelfde pad wordt gebruikt voor zowel liveness als gereedheid, omdat TF Serving alleen een livenessroute definieert. Raadpleeg andere voorbeelden voor verschillende patronen om de routes te definiëren.

Scoreroute

De API-server die u kiest, biedt een manier om de nettolading te ontvangen waaraan moet worden gewerkt. In de context van machine learning-deductie ontvangt een server de invoergegevens via een specifieke route. Identificeer deze route voor uw API-server tijdens het lokaal testen van de container in een eerdere stap en geef deze op wanneer u de implementatie definieert die moet worden gemaakt. Houd er rekening mee dat het maken van de implementatie ook de scoring_uri parameter van het eindpunt bijwerkt, waarmee u kunt verifiëren az ml online-endpoint show -n <name> --query scoring_uri.

Het gekoppelde model zoeken

Wanneer u een model implementeert als een online-eindpunt, koppelt Azure Machine Learning uw model aan uw eindpunt. Met model koppelen kunt u nieuwe versies van het model implementeren zonder dat u een nieuwe Docker-installatiekopieën hoeft te maken. Standaard bevindt een model dat is geregistreerd met de naam foo en versie 1 zich op het volgende pad in uw geïmplementeerde container: /var/azureml-app/azureml-models/foo/1

Als u bijvoorbeeld een mapstructuur hebt van /azureml-examples/cli/endpoints/online/custom-container op uw lokale computer, waarbij het model de naam half_plus_two heeft:

Azure-CLI

En tfserving-deployment.yml bevat:

model:
    name: tfserving-mounted
    version: 1
    path: ./half_plus_two

Python SDK

En Model klasse bevat:

model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

Vervolgens bevindt uw model zich onder /var/azureml-app/azureml-models/tfserving-deployment/1 in uw implementatie:

U kunt desgewenst uw model_mount_path. Hiermee kunt u het pad wijzigen waar het model is gekoppeld.

Belangrijk

Het model_mount_path moet een geldig absoluut pad in Linux zijn (het besturingssysteem van de containerinstallatiekopieën).

Azure-CLI

U kunt bijvoorbeeld de parameter in uw tfserving-deployment.yml hebbenmodel_mount_path:

name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: 1
  path: ./half_plus_two
model_mount_path: /var/tfserving-model-mount
.....

Python SDK

U kunt bijvoorbeeld een parameter in uw ManagedOnlineDeployment klasse hebbenmodel_mount_path:

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    model_mount_path="/var/tfserving-model-mount",
    ...
)

Vervolgens bevindt uw model zich in /var/tfserving-model-mount/tfserving-deployment/1 in uw implementatie. Houd er rekening mee dat het niet meer onder azureml-app/azureml-models valt, maar onder het koppelpad dat u hebt opgegeven:

Uw eindpunt en implementatie maken

Azure-CLI

Nu u begrijpt hoe de YAML is samengesteld, maakt u uw eindpunt.

az ml online-endpoint create --name tfserving-endpoint -f endpoints/online/custom-container/tfserving-endpoint.yml

Het maken van een implementatie kan enkele minuten duren.

az ml online-deployment create --name tfserving-deployment -f endpoints/online/custom-container/tfserving-deployment.yml --all-traffic

Python SDK

Maak met behulp van het MLClient eerder gemaakte eindpunt in de werkruimte. Met deze opdracht wordt het maken van het eindpunt gestart en wordt een bevestigingsantwoord geretourneerd terwijl het maken van het eindpunt wordt voortgezet.

ml_client.begin_create_or_update(endpoint)

Maak de implementatie door het volgende uit te voeren:

ml_client.begin_create_or_update(blue_deployment)

Het eindpunt aanroepen

Zodra de implementatie is voltooid, controleert u of u een scoreaanvraag kunt indienen bij het geïmplementeerde eindpunt.

Azure-CLI

RESPONSE=$(az ml online-endpoint invoke -n $ENDPOINT_NAME --request-file $BASE_PATH/sample_request.json)

Python SDK

Met behulp van de MLClient eerder gemaakte greep krijgt u een ingang naar het eindpunt. Het eindpunt kan worden aangeroepen met behulp van de invoke opdracht met de volgende parameters:

• endpoint_name - Naam van het eindpunt
• request_file - Bestand met aanvraaggegevens
• deployment_name - Naam van de specifieke implementatie die moet worden getest in een eindpunt

Een voorbeeldaanvraag verzenden met behulp van een JSON-bestand. De voorbeeld-JSON bevindt zich in de voorbeeldopslagplaats.

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name="blue",
    request_file="sample-request.json",
)

Het eindpunt verwijderen

Nu u uw eindpunt hebt beoordeeld, kunt u het volgende verwijderen:

Azure-CLI

az ml online-endpoint delete --name tfserving-endpoint

Python SDK

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Gerelateerde inhoud

• Veilige implementatie voor online-eindpunten
• Problemen met de implementatie van online eindpunten oplossen
• Torch serveer voorbeeld