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.
torchserve/huggingface-textgen	deploy-custom-container-torchserve-huggingface-textgen	Implementeer Hugging Face-modellen naar een online-eindpunt en volg samen met het voorbeeld van Hugging Face Transformers TorchServe.
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 naar Azure Machine Learning-werkruimte

Verbinding maken naar 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 kunt zien in deze YAML-/Python-parameter:

Gereedheidsroute versus livenessroute

Een HTTP-server definieert paden voor zowel liveness als 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 machine learning-deductie kan een server 200 OK reageren op een liveness-aanvraag voordat een model wordt geladen. De server kan 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.

U ziet dat deze implementatie hetzelfde pad gebruikt voor zowel liveness als gereedheid, omdat TF-server alleen een livenessroute definieert.

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