Een TensorFlow-model implementeren dat wordt bediend met TF Serving met behulp van een aangepaste container in een beheerd online eindpunt (preview)

Meer informatie over het implementeren van een aangepaste container als een beheerd online-eindpunt in Azure Machine Learning.

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

Belangrijk

Deze functie is momenteel beschikbaar als openbare preview-versie. Deze preview-versie wordt aangeboden zonder Service Level Agreement en wordt niet aanbevolen voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt. Zie Supplemental Terms of Use for Microsoft Azure Previews (Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews) voor meer informatie.

Waarschuwing

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

Vereisten

  • Installeer en configureer de Azure CLI en ML extensie. Zie De CLI (v2) installeren, instellen en gebruiken (preview)voor meer informatie.

  • U moet een Azure-resourcegroep hebben waarin u (of de service-principal die u gebruikt) toegang moet Contributor hebben. U hebt een dergelijke resourcegroep als u de extensie ML geconfigureerd volgens het bovenstaande artikel.

  • U moet een Azure Machine Learning hebben. U hebt een dergelijke werkruimte als u de extensie ML geconfigureerd volgens het bovenstaande artikel.

  • Als u de standaardinstellingen voor Azure CLI nog niet hebt ingesteld, moet u de standaardinstellingen opslaan. Voer het volgende uit om te voorkomen dat de waarden herhaaldelijk moeten worden door geven:

    az account set --subscription <subscription id>
    az configure --defaults workspace=<azureml workspace name> group=<resource group>
    
    
  • To deploy locally, you must have Docker engine running locally. This step is highly recommended. It will help you debug issues.

Download source code

To follow along with this tutorial, download the source code below.

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

Omgevingsvariabelen initialiseren

Omgevingsvariabelen definiëren:

BASE_PATH=endpoints/online/custom-container
AML_MODEL_NAME=tfserving-mounted
MODEL_NAME=half_plus_two
MODEL_BASE_PATH=/var/azureml-app/azureml-models/$AML_MODEL_NAME/1
ENDPOINT_NAME=tfserving-endpoint
DEPLOYMENT_NAME=tfserving

Een TensorFlow-model downloaden

Een model downloaden en uitsplitsen dat een invoer door twee deelt en 2 toevoegt 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-afbeelding lokaal uitvoeren om te testen of deze werkt

Gebruik docker om uw afbeelding lokaal uit te voeren voor 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 de liveness- en scoring-aanvragen naar de afbeelding kunt verzenden

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

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

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

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 afbeelding:

docker stop tfserving-test

Een YAML-bestand voor uw eindpunt maken

U kunt uw cloudimplementatie configureren met behulp van YAML. Bekijk het YAML-voorbeeld voor dit eindpunt:

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

deployments:
  - name: tfserving
    model:
      name: tfserving-mounted
      version: 1
      local_path: ./half_plus_two
    environment_variables:
      MODEL_BASE_PATH: /var/azureml-app/azureml-models/tfserving-mounted/1
      MODEL_NAME: half_plus_two
    environment:
      name: tfserving
      version: 1
      docker:
        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_F2s_v2
    scale_settings:
      scale_type: manual
      instance_count: 1
      min_instances: 1
      max_instances: 2

Er zijn enkele belangrijke concepten die u in deze YAML moet opvallen:

Gereedheidsroute versus livenessroute

Een HTTP-server kan eventueel paden definiëren voor zowel de liveheid als gereedheid. Een verbindingsroute wordt gebruikt om te controleren of de server wordt uitgevoerd. Er wordt een gereedheidsroute gebruikt om te controleren of de server klaar is om wat werk te doen. In machine learning kan een server 200 OK reageren op een aanvraag voor de uitvoering voordat een model wordt geladen. De server kan pas 200 OK reageren op een gereedheidsaanvraag nadat het model in het geheugen is geladen.

Bekijk de Kubernetes-documentatie voor meer informatie over de liveheid en gereedheidstests.

U ziet dat voor deze implementatie hetzelfde pad wordt gebruikt voor zowel de liveheid als de gereedheid, omdat TF Serving alleen een route voor de liveness definieert.

Het bevestigingsmodel zoeken

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

Als u bijvoorbeeld de volgende mapstructuur op uw lokale computer hebt:

azureml-examples
  cli
    endpoints
      online
        custom-container
          half_plus_two
          tfserving-endpoint.yml    

en tfserving-endpoint.yml bevat:

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

dan bevindt uw model zich op de volgende locatie in uw eindpunt:

var 
  azureml-app
    azureml-models
      tfserving-endpoint
        1
          half_plus_two

Het eindpunt maken

Nu u hebt begrepen hoe de YAML is samengesteld, maakt u uw eindpunt. Het uitvoeren van deze opdracht kan enkele minuten duren.

az ml endpoint create -f $BASE_PATH/$ENDPOINT_NAME.yml -n $ENDPOINT_NAME

Het eindpunt aanroepen

Zodra de implementatie is voltooid, kunt u een scoring-aanvraag indienen bij het geïmplementeerde eindpunt.

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

Eindpunt en model verwijderen

Nu u met uw eindpunt hebt gescoord, kunt u het verwijderen:

az ml endpoint delete -n $ENDPOINT_NAME -y
echo "deleting model..."
az ml model delete -n tfserving-mounted --version 1

Volgende stappen