Uw machine learning implementeren in Azure

Meer informatie over het implementeren van machine learning of deep learning-model als een webservice in de Azure-cloud.

Tip

Beheerde online eindpunten (preview) bieden een manier om uw getrainde model te implementeren zonder dat u de onderliggende infrastructuur moet maken en beheren. Zie Deploy and score a machine learning model with a managed online endpoint (preview) (Een model implementeren en scoren met een beheerd online-eindpunt (preview) voor meer informatie.

De werkstroom is vrijwel altijd hetzelfde, ongeacht waar u het model implementeert:

  1. Het model registreren
  2. Een invoerscript voorbereiden
  3. Een deferentieconfiguratie voorbereiden
  4. Het model lokaal implementeren om ervoor te zorgen dat alles werkt
  5. Een rekendoel kiezen
  6. Het model opnieuw implementeren in de cloud
  7. De resulterende webservice testen

Zie Manage, deploy, and monitor models withAzure Machine Learning (Modellen beheren, implementeren en bewaken met Azure Machine Learning) voor meer informatie over de concepten machine learning implementatiewerkstroom.

Vereisten

Verbinding maken met uw werkruimte

Wel doen

az login
az account set -s <my subscription>
az ml workspace list --resource-group=<my resource group>

om te zien tot welke werkruimten u toegang hebt.

Uw model registreren

Een typische situatie voor een geïmplementeerde machine learning-service is dat u de volgende onderdelen nodig hebt:

  • resources die het specifieke model vertegenwoordigen dat u wilt geïmplementeerd (bijvoorbeeld een pytorch-modelbestand)
  • code die u gaat uitvoeren in de th-service, die het model uitvoert op een bepaalde invoer

Met Azure Machine Learnings kunt u de implementatie scheiden in twee afzonderlijke onderdelen, zodat u dezelfde code kunt behouden, maar alleen het model kunt bijwerken. We definiëren het mechanisme waarmee u een model afzonderlijk van uw code uploadt als 'het model registreren'.

Wanneer u een model registreert, uploaden we het model naar de cloud (in het standaardopslagaccount van uw werkruimte) en vervolgens wordt het model aan dezelfde rekenkracht bevestigd als waar uw webservice wordt uitgevoerd.

In de volgende voorbeelden wordt gedemonstreerd hoe u een model registreert.

Belangrijk

Gebruik alleen modellen die u zelf maakt of van een vertrouwde bron verkrijgt. Behandel geserialiseerde modellen als code. Er zijn namelijk beveiligingslekken ontdekt in een aantal populaire indelingen. Het kan ook voorkomen dat modellen opzettelijk worden getraind met kwaadaardige bedoelingen om een vertekende of een onnauwkeurige uitvoer te genereren.

Een model registreren vanuit een lokaal bestand

!wget https://aka.ms/bidaf-9-model -o model.onnx
!az ml model register -n bidaf_onnx -p ./model.onnx

Stel -p in op het pad van een map of een bestand dat u wilt registreren.

Raadpleeg de referentiedocumentatie az ml model register voor meer informatie over.

Een model registreren vanuit een Azure ML-trainingsrun

az ml model register -n bidaf_onnx --asset-path outputs/model.onnx --experiment-name myexperiment --run-id myrunid --tag area=qna

Tip

Als er een foutbericht wordt weergegeven waarin staat dat de ml-extensie niet is geïnstalleerd, gebruikt u de volgende opdracht om deze te installeren:

az extension add -n azure-cli-ml

De --asset-path parameter verwijst naar de cloudlocatie van het model. In dit voorbeeld wordt het pad van één bestand gebruikt. Als u meerdere bestanden wilt opnemen in de modelregistratie, stelt u in op het pad van --asset-path een map die de bestanden bevat.

Raadpleeg de referentiedocumentatie az ml model register voor meer informatie over.

Een dummy-invoerscript definiëren

Het invoerscript ontvangt de gegevens die bij een geïmplementeerde webservice zijn ingediend en stuurt ze door naar het model. Vervolgens wordt het antwoord van het model naar de client terug gegeven. Het script is specifiek voor uw model. Het invoerscript moet de gegevens begrijpen die het model verwacht en retourneert.

De twee dingen die u moet doen in uw invoerscript zijn:

  1. Uw model laden (met behulp van een functie met de naam init() )
  2. Uw model uitvoeren op invoergegevens (met behulp van een functie met de naam run() )

Gebruik voor de eerste implementatie een dummyscript om de ontvangen gegevens weer te geven.

import json


def init():
    print("This is init")


def run(data):
    test = json.loads(data)
    print(f"received data {test}")
    return f"test is {test}"

Sla dit bestand op als echo_score.py in een map met de naam source_dir .

Als een gebruiker bijvoorbeeld uw model aanroept met:

curl -X POST -d '{"this":"is a test"}' -H "Content-Type: application/json" http://localhost:6789/score

De volgende waarde wordt geretourneerd:

"test is {'this': 'is a test'}"

Een deferentieconfiguratie definiëren

In een deferentieconfiguratie worden de Docker-container en -bestanden beschreven die moeten worden gebruikt bij het initialiseren van uw webservice. Alle bestanden in uw bronmap, inclusief subdirectory's, worden bij het implementeren van uw webservice ingepakt en geüpload naar de cloud.

De onderstaande deferentieconfiguratie geeft aan dat de machine learning-implementatie het bestand in de map gebruikt om binnenkomende aanvragen te verwerken en dat deze de Docker-installatiebestand gebruikt met de Python-pakketten die zijn opgegeven in de echo_score.py ./source_dir project_environment omgeving.

U kunt elke gecureerde Azure Machine Learning gebruiken als basis-Docker-afbeelding bij het maken van uw projectomgeving. We installeren de vereiste afhankelijkheden bovenaan en slaan de resulterende Docker-installatie afbeelding op in de opslagplaats die aan uw werkruimte is gekoppeld.

Een minimale deferentieconfiguratie kan worden geschreven als:

{
    "entryScript": "echo_score.py",
    "sourceDirectory": "./source_dir",
    "environment": {
        "docker": {
            "arguments": [],
            "baseDockerfile": null,
            "baseImage": "mcr.microsoft.com/azureml/base:intelmpi2018.3-ubuntu16.04",
            "enabled": false,
            "sharedVolumes": true,
            "shmSize": null
        },
        "environmentVariables": {
            "EXAMPLE_ENV_VAR": "EXAMPLE_VALUE"
        },
        "name": "my-deploy-env",
        "python": {
            "baseCondaEnvironment": null,
            "condaDependencies": {
                "channels": [],
                "dependencies": [
                    "python=3.6.2",
                    {
                        "pip": [
                            "azureml-defaults"
                        ]
                    }
                ],
                "name": "project_environment"
            },
            "condaDependenciesFile": null,
            "interpreterPath": "python",
            "userManagedDependencies": false
        },
        "version": "1"
    }
}

Sla dit bestand op met de naam dummyinferenceconfig.json .

Zie dit artikel voor een uitgebreidere bespreking van de deferentieconfiguraties.

Een implementatieconfiguratie definiëren

Een implementatieconfiguratie specificeert de hoeveelheid geheugen en kernen die moet worden reserveren voor uw webservice om te kunnen worden uitgevoerd, evenals configuratiegegevens van de onderliggende webservice. Met een implementatieconfiguratie kunt u bijvoorbeeld opgeven dat uw service 2 gigabyte aan geheugen, 2 CPU-kernen, 1 GPU-kern nodig heeft en dat u automatisch schalen wilt inschakelen.

De beschikbare opties voor een implementatieconfiguratie verschillen, afhankelijk van het rekendoel dat u kiest. In een lokale implementatie kunt u alleen opgeven op welke poort uw webservice wordt bediend.

De vermeldingen in de documenttoewijzing deploymentconfig.json voor de parameters voor LocalWebservice.deploy_configuration. In de volgende tabel wordt de toewijzing tussen de entiteiten in het JSON-document en de parameters beschreven voor de methode:

JSON-entiteit Methodeparameter Beschrijving
computeType NA Het rekendoel. Voor lokale doelen moet de waarde local zijn.
port port De lokale poort waarop het HTTP-eindpunt van de service beschikbaar wordt gemaakt.

De volgende JSON is een voorbeeld van een implementatieconfiguratie die gebruikt kan worden met de CLI:

{
    "computeType": "local",
    "port": 32267
}

Sla deze JSON op als een bestand met de naam deploymentconfig.json .

Zie deze naslaginformatie voor meer informatie.

Uw machine learning implementeren

U bent nu klaar om uw model te implementeren.

Vervang bidaf_onnx:1 door de naam van uw model en het versienummer.

!az ml model deploy -n myservice -m bidaf_onnx:1 --overwrite --ic dummyinferenceconfig.json --dc deploymentconfig.json
!az ml service get-logs -n myservice

Uw model aanroepen

Laten we controleren of uw echomodel is geïmplementeerd. U moet een eenvoudige aanvraag voor de liveheid kunnen doen, evenals een scoreaanvraag:

!curl -v http://localhost:32267
!curl -v -X POST -H "content-type:application/json" -d '{"query": "What color is the fox", "context": "The quick brown fox jumped over the lazy dog."}' http://localhost:32267/score

Een invoerscript definiëren

Het is nu tijd om uw model daadwerkelijk te laden. Wijzig eerst uw invoerscript:

import json
import numpy as np
import os
import onnxruntime
from nltk import word_tokenize
import nltk


def init():
    nltk.download("punkt")
    global sess
    sess = onnxruntime.InferenceSession(
        os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model.onnx")
    )


def run(request):
    print(request)
    text = json.loads(request)
    qw, qc = preprocess(text["query"])
    cw, cc = preprocess(text["context"])

    # Run inference
    test = sess.run(
        None,
        {"query_word": qw, "query_char": qc, "context_word": cw, "context_char": cc},
    )
    start = np.asscalar(test[0])
    end = np.asscalar(test[1])
    ans = [w for w in cw[start : end + 1].reshape(-1)]
    print(ans)
    return ans


def preprocess(word):
    tokens = word_tokenize(word)

    # split into lower-case word tokens, in numpy array with shape of (seq, 1)
    words = np.asarray([w.lower() for w in tokens]).reshape(-1, 1)

    # split words into chars, in numpy array with shape of (seq, 1, 1, 16)
    chars = [[c for c in t][:16] for t in tokens]
    chars = [cs + [""] * (16 - len(cs)) for cs in chars]
    chars = np.asarray(chars).reshape(-1, 1, 1, 16)
    return words, chars

Sla dit bestand op score.py als in source_dir .

Let op het gebruik van de AZUREML_MODEL_DIR omgevingsvariabele om uw geregistreerde model te vinden. Nu u een aantal PIP-pakketten hebt toegevoegd.

{
    "entryScript": "score.py",
    "sourceDirectory": "./source_dir",
    "environment": {
        "docker": {
            "arguments": [],
            "baseDockerfile": null,
            "baseImage": "mcr.microsoft.com/azureml/base:intelmpi2018.3-ubuntu16.04",
            "enabled": false,
            "sharedVolumes": true,
            "shmSize": null
        },
        "environmentVariables": {
            "EXAMPLE_ENV_VAR": "EXAMPLE_VALUE"
        },
        "name": "my-deploy-env",
        "python": {
            "baseCondaEnvironment": null,
            "condaDependencies": {
                "channels": [],
                "dependencies": [
                    "python=3.6.2",
                    {
                        "pip": [
                            "azureml-defaults",
                            "nltk",
                            "numpy",
                            "onnxruntime"
                        ]
                    }
                ],
                "name": "project_environment"
            },
            "condaDependenciesFile": null,
            "interpreterPath": "python",
            "userManagedDependencies": false
        },
        "version": "2"
    }
}

Sla dit bestand op als inferenceconfig.json

Deploy your service again: null

Vervang bidaf_onnx:1 door de naam van uw model en het versienummer.

!az ml model deploy -n myservice -m bidaf_onnx:1 --overwrite --ic inferenceconfig.json --dc deploymentconfig.json
!az ml service get-logs -n myservice

Zorg er vervolgens voor dat u een postaanvraag naar de service kunt verzenden:

!curl -v -X POST -H "content-type:application/json" -d '{"query": "What color is the fox", "context": "The quick brown fox jumped over the lazy dog."}' http://localhost:32267/score

Een rekendoel kiezen

Raadpleeg het onderstaande diagram bij het kiezen van een rekendoel.

Een rekendoel kiezen

Het rekendoel dat u gebruikt als host voor uw model, is van invloed op de kosten en beschikbaarheid van het geïmplementeerde eindpunt. Gebruik deze tabel om een geschikt rekendoel te kiezen.

Rekendoel Gebruikt voor GPU-ondersteuning FPGA-ondersteuning Beschrijving
Lokale web service Testen/fouten opsporen     Gebruiken voor testen en problemen oplossen. Hardwareversnelling is afhankelijk van het gebruik van bibliotheken in het lokale systeem.
Azure Kubernetes Service (AKS) Realtime deductie Ja (webservice-implementatie) Ja Gebruiken voor grootschalige productie-implementaties. Biedt een snelle reactietijd en automatische schaalaanpassing van de geïmplementeerde service. Automatische schaalaanpassing van clusters wordt niet ondersteund via de Azure Machine Learning SDK. Als u de knooppunten in het AKS-cluster wilt wijzigen, gebruikt u de gebruikersinterface voor uw AKS-cluster in de Azure-portal.

Ondersteund in de ontwerpfunctie.
Azure Container Instances Realtime deductie     Gebruiken voor lage CPU-werkbelastingen waarvoor minder dan 48 GB RAM-geheugen nodig is. U hoeft geen cluster te beheren.

Ondersteund in de ontwerpfunctie.
Azure Machine Learning-rekenclusters Batch deductie Ja (machine learning-pijplijn)   Batchscoreberekening uitvoeren op serverloze berekening. Ondersteunt VM's met normale en lage prioriteit. Er is geen ondersteuning voor realtime de deferentie.

Notitie

Hoewel rekendoelen zoals lokale en Azure Machine Learning-rekenclusters GPU ondersteunen voor training en experimenten, wordt het gebruik van GPU voor de deferentie bij de geïmplementeerd als een webservice alleen ondersteund in AKS.

Het gebruik van een GPU voor deductie bij scoreberekening met een machine learning-pijplijn wordt alleen ondersteund in Azure Machine Learning Compute.

Bij het kiezen van een cluster-SKU moet u eerst omhoog schalen en vervolgens uitbreiden. Begin met een machine met 150% van het RAM-geheugen dat voor uw model is vereist, profileer het resultaat en zoek een machine met de prestaties die u nodig hebt. Zodra u dat weet, verhoogt u het aantal machines dat u nodig hebt voor gelijktijdige deductie.

Notitie

  • Containerinstanties zijn alleen geschikt voor kleine modellen met een grootte van minder dan 1 GB.
  • Gebruik AKS clusters met één knooppunt voor het ontwikkelen en testen van grotere modellen.

Opnieuw implementeren in de cloud

Zodra u hebt bevestigd dat uw service lokaal werkt en een extern rekendoel hebt gekozen, bent u klaar om in de cloud te implementeren.

Wijzig de implementatieconfiguratie in overeenstemming met het rekendoel dat u hebt gekozen, in dit geval Azure Container Instances:

De beschikbare opties voor een implementatieconfiguratie verschillen afhankelijk van het rekendoel dat u kiest.

{
    "computeType": "aci",
    "containerResourceRequirements":
    {
        "cpu": 0.5,
        "memoryInGB": 1.0
    },
    "authEnabled": true,
    "sslEnabled": false,
    "appInsightsEnabled": false
}

Sla dit bestand op als re-deploymentconfig.json .

Zie deze naslaginformatie voor meer informatie.

Implementeer uw service opnieuw:

Vervang bidaf_onnx:1 door de naam van uw model en het versienummer.

!az ml model deploy -n myaciservice -m bidaf_onnx:1 --overwrite --ic inferenceconfig.json --dc re-deploymentconfig.json
!az ml service get-logs -n myaciservice

Uw externe webservice aanroepen

Wanneer u op afstand implementeert, hebt u mogelijk sleutelverificatie ingeschakeld. In het onderstaande voorbeeld ziet u hoe u uw servicesleutel op kunt halen met Python om een deferentieaanvraag te maken.

import requests
import json
from azureml.core import Webservice

service = Webservice(workspace=ws, name="myservice")
scoring_uri = service.scoring_uri

# If the service is authenticated, set the key or token
key, _ = service.get_keys()

# Set the appropriate headers
headers = {"Content-Type": "application/json"}
headers["Authorization"] = f"Bearer {key}"

# Make the request and display the response and logs
data = {
    "query": "What color is the fox",
    "context": "The quick brown fox jumped over the lazy dog.",
}
data = json.dumps(data)
resp = requests.post(scoring_uri, data=data, headers=headers)
print(resp.text)
print(service.get_logs())

Zie het artikel over clienttoepassingen om webservices te gebruiken voor meer voorbeeldclients in andere talen.

Servicetoestand begrijpen

Tijdens de modelimplementatie ziet u mogelijk de status van de service veranderen terwijl deze volledig wordt geïmplementeerd.

In de volgende tabel worden de verschillende service-staten beschreven:

Status van webservice Description Laatste status?
Overgang De service is bezig met de implementatie. No
Niet in orde De service is geïmplementeerd, maar is momenteel niet bereikbaar. No
Niet-bewerkbaar De service kan op dit moment niet worden geïmplementeerd vanwege een gebrek aan resources. No
Mislukt De service kan niet worden geïmplementeerd vanwege een fout of crash. Yes
In orde De service is in orde en het eindpunt is beschikbaar. Yes

Tip

Tijdens het implementeren worden Docker-afbeeldingen voor rekendoelen gebouwd en geladen vanuit Azure Container Registry (ACR). Standaard maakt Azure Machine Learning een ACR die gebruikmaakt van de basic-servicelaag. Het wijzigen van de ACR voor uw werkruimte in de Standard- of Premium-laag kan de tijd verminderen die nodig is om afbeeldingen te bouwen en te implementeren op uw rekendoelen. Zie servicelagen voor Azure Container Registry meer informatie.

Notitie

Als u een model implementeert naar Azure Kubernetes Service (AKS), raden we u aan om Azure Monitor voor dat cluster in te stellen. Dit helpt u inzicht te krijgen in de algehele clustertoestand en het resourcegebruik. Mogelijk vindt u de volgende resources ook nuttig:

Als u een model probeert te implementeren in een cluster dat niet in orde of overbelast is, zal dit naar verwachting problemen ervaren. Neem contact op met de ondersteuning van AKS als u hulp nodig hebt bij het oplossen van problemen met AKS-clusters.

Resources verwijderen

# Get the current model id
import os

stream = os.popen(
    'az ml model list --model-name=bidaf_onnx --latest --query "[0].id" -o tsv'
)
MODEL_ID = stream.read()[0:-1]
MODEL_ID
!az ml service delete -n myservice
!az ml service delete -n myaciservice
!az ml model delete --model-id=$MODEL_ID

Gebruik om een geïmplementeerde webservice te az ml service delete <name of webservice> verwijderen.

Als u een geregistreerd model uit uw werkruimte wilt verwijderen, gebruikt u az ml model delete <model id>

Lees meer over het verwijderen van een webservice en het verwijderen van een model.

Volgende stappen