Delen via

Modellen implementeren voor scoren in batch-eindpunten

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

Met Batch-eindpunten kunt u modellen implementeren die deductie uitvoeren op grote hoeveelheden gegevens. Deze eindpunten vereenvoudigen het hosten van modellen voor batchgewijs scoren, zodat u zich kunt richten op machine learning in plaats van infrastructuur.

Batch-eindpunten gebruiken om modellen te implementeren wanneer:

  • U gebruikt dure modellen die langer duren om deductie uit te voeren.
  • U voert deductie uit over grote hoeveelheden gegevens die in meerdere bestanden zijn gedistribueerd.
  • U hebt geen lage latentie nodig.
  • U profiteert van parallelle uitvoering.

In dit artikel wordt beschreven hoe u een batch-eindpunt gebruikt om een machine learning-model te implementeren waarmee het klassieke MNIST-cijferherkenningsprobleem (Modified National Institute of Standards and Technology) wordt opgelost. Het geïmplementeerde model voert batchdeductie uit over grote hoeveelheden gegevens, zoals afbeeldingsbestanden. Het proces begint met het maken van een batchimplementatie van een model dat is gebouwd met Torch. Deze implementatie wordt de standaardinstelling in het eindpunt. Maak later een tweede implementatie van een model dat is gebouwd met TensorFlow (Keras), test de tweede implementatie en stel deze in als de standaardimplementatie van het eindpunt.

Vereisten

Voordat u de stappen in dit artikel uitvoert, moet u ervoor zorgen dat u aan de volgende vereisten voldoet:

  • Een Azure-abonnement. Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint. Probeer de gratis of betaalde versie van Azure Machine Learning.

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

  • Als u de volgende taken wilt uitvoeren, moet u ervoor zorgen dat u over deze machtigingen beschikt in de werkruimte:

    • Batch-eindpunten en -implementaties maken/beheren: gebruik de rol eigenaar, inzenderrol of een aangepaste rol die toestaat Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.

    • ARM-implementaties maken in de werkruimteresourcegroep: gebruik de rol eigenaar, inzender of een aangepaste rol die is toegestaan Microsoft.Resources/deployments/write in de resourcegroep waarin de werkruimte wordt geïmplementeerd.

  • U moet de volgende software installeren om te kunnen werken met Azure Machine Learning:

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

    De Azure CLI en de mlextensie voor Azure Machine Learning.

    az extension add -n ml

De opslagplaats met voorbeelden klonen

Het voorbeeld in dit artikel is gebaseerd op codevoorbeelden in de opslagplaats azureml-examples . Als u de opdrachten lokaal wilt uitvoeren zonder YAML en andere bestanden te hoeven kopiëren/plakken, kloont u eerst de opslagplaats en wijzigt u vervolgens mappen in de map:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli/endpoints/batch/deploy-models/mnist-classifier

Uw systeem voorbereiden

Verbinding maken met uw werkruimte

Maak eerst verbinding met de Azure Machine Learning-werkruimte waar u werkt.

Als u de standaardinstellingen voor de Azure CLI nog niet hebt ingesteld, slaat u de standaardinstellingen op. Voer deze code uit om te voorkomen dat u de waarden voor uw abonnement, werkruimte, resourcegroep en locatie meerdere keren invoert:

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Rekenproces maken

Batch-eindpunten worden uitgevoerd op rekenclusters en ondersteunen zowel Azure Machine Learning-rekenclusters (AmlCompute) als Kubernetes-clusters. Clusters zijn een gedeelde resource, dus één cluster kan een of meer batchimplementaties hosten (samen met andere workloads, indien gewenst).

Maak een rekenproces met de naam batch-cluster, zoals wordt weergegeven in de volgende code. Pas indien nodig aan en verwijs naar uw rekenproces met behulp van azureml:<your-compute-name>.

az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5

Notitie

Op dit moment worden er geen kosten in rekening gebracht voor de rekenkracht, omdat het cluster op 0 knooppunten blijft totdat een batch-eindpunt wordt aangeroepen en er een batch-scorejob wordt ingediend. Zie Kosten voor AmlCompute beheren en optimaliseren voor meer informatie over rekenkosten.

Een batch-eindpunt maken

Een batch-eindpunt is een HTTPS-eindpunt dat clients aanroepen om een batchscore-taak te activeren. Een batchscoringtaak verwerkt meerdere invoerwaarden. Een batchimplementatie is een set rekenresources die als host fungeren voor het model waarmee batchgewijs scoren (of batchdeductie) wordt uitgevoerd. Eén batch-eindpunt kan meerdere batchimplementaties hebben. Zie Wat zijn batch-eindpunten? voor meer informatie over batcheindpunten.

Aanbeveling

Een van de batchimplementaties fungeert als de standaardimplementatie voor het eindpunt. Wanneer het eindpunt wordt aangeroepen, voert de standaardimplementatie batchgewijs scoren uit. Zie batcheindpunten en batchimplementaties voor meer informatie over batcheindpunten en implementaties.

  1. Geef het eindpunt een naam. De naam van het eindpunt moet uniek zijn binnen een Azure-regio omdat de naam is opgenomen in de URI van het eindpunt. Er kan bijvoorbeeld slechts één batcheindpunt zijn met de naam mybatchendpoint in westus2.

    Plaats de naam van het eindpunt in een variabele om er later eenvoudig naar te verwijzen.

    ENDPOINT_NAME="mnist-batch"

  2. Het batch-eindpunt configureren

    Het volgende YAML-bestand definieert een batch-eindpunt. Gebruik dit bestand met de CLI-opdracht voor het maken van batcheindpunten.

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: mnist-batch
description: A batch endpoint for scoring images from the MNIST dataset.
tags:
  type: deep-learning

    In de volgende tabel worden de belangrijkste eigenschappen van het eindpunt beschreven. Zie CLI (v2) YAML-schema voor het volledige YAML-schema voor batcheindpunten.

    Toets Beschrijving
    name De naam van het batch-eindpunt. Moet uniek zijn op het niveau van de Azure-regio.
    description De beschrijving van het batch-eindpunt. Deze eigenschap is optioneel.
    tags De tags die moeten worden opgenomen in het eindpunt. Deze eigenschap is optioneel.

  3. Maak het eindpunt:

    Voer deze code uit om een batch-eindpunt te maken.

    az ml batch-endpoint create --file endpoint.yml  --name $ENDPOINT_NAME

Een batchimplementatie maken

Een modelimplementatie is een set resources die vereist is voor het hosten van het model dat de werkelijke deductie uitvoert. Als u een batchmodelimplementatie wilt maken, hebt u het volgende nodig:

  • Een geregistreerd model in de werkruimte
  • De code voor het scoren van het model
  • Een omgeving waarop de afhankelijkheden van het model zijn geïnstalleerd
  • De vooraf gemaakte reken- en resource-instellingen

  1. Begin met het registreren van het model dat moet worden geïmplementeerd: een Torch-model voor het populaire probleem met cijferherkenning (MNIST). Batch-implementaties kunnen alleen modellen implementeren die zijn geregistreerd in de werkruimte. U kunt deze stap overslaan als het model dat u wilt implementeren al is geregistreerd.

    Aanbeveling

    Modellen zijn gekoppeld aan de implementatie in plaats van aan het eindpunt. Dit betekent dat één eindpunt verschillende modellen (of modelversies) onder hetzelfde eindpunt kan leveren zolang de verschillende modellen (of modelversies) in verschillende implementaties worden geïmplementeerd.

    MODEL_NAME='mnist-classifier-torch'
az ml model create --name $MODEL_NAME --type "custom_model" --path "deployment-torch/model"

  2. Nu is het tijd om een scorescript te maken. Batch-implementaties vereisen een scorescript dat aangeeft hoe een bepaald model moet worden uitgevoerd en hoe invoergegevens moeten worden verwerkt. Batch-eindpunten ondersteunen scripts die zijn gemaakt in Python. In dit geval implementeert u een model dat afbeeldingsbestanden leest die cijfers vertegenwoordigen en het bijbehorende cijfer uitvoert. Het scorescript is als volgt:

    Notitie

    Voor MLflow-modellen genereert Azure Machine Learning automatisch het scorescript, zodat u er geen hoeft op te geven. Als uw model een MLflow-model is, kunt u deze stap overslaan. Zie het artikel MLflow-modellen gebruiken in batchimplementaties voor meer informatie over hoe batch-eindpunten met MLflow-modellen werken.

    Waarschuwing

    Als u een AutoML-model (Automated Machine Learning) implementeert onder een batcheindpunt, moet u er rekening mee houden dat het scorescript dat AutoML alleen biedt voor online-eindpunten en niet is ontworpen voor batchuitvoering. Zie Scorescripts maken voor batchimplementaties voor informatie over het maken van een scorescript voor uw batchimplementatie.

    deployment-torch/code/batch_driver.py

    import os
import pandas as pd
import torch
import torchvision
import glob
from os.path import basename
from mnist_classifier import MnistClassifier
from typing import List


def init():
    global model
    global device

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    # It is the path to the model folder
    model_path = os.environ["AZUREML_MODEL_DIR"]
    model_file = glob.glob(f"{model_path}/*/*.pt")[-1]

    model = MnistClassifier()
    model.load_state_dict(torch.load(model_file))
    model.eval()

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")


def run(mini_batch: List[str]) -> pd.DataFrame:
    print(f"Executing run method over batch of {len(mini_batch)} files.")

    results = []
    with torch.no_grad():
        for image_path in mini_batch:
            image_data = torchvision.io.read_image(image_path).float()
            batch_data = image_data.expand(1, -1, -1, -1)
            input = batch_data.to(device)

            # perform inference
            predict_logits = model(input)

            # Compute probabilities, classes and labels
            predictions = torch.nn.Softmax(dim=-1)(predict_logits)
            predicted_prob, predicted_class = torch.max(predictions, axis=-1)

            results.append(
                {
                    "file": basename(image_path),
                    "class": predicted_class.numpy()[0],
                    "probability": predicted_prob.numpy()[0],
                }
            )

    return pd.DataFrame(results)

  3. Maak een omgeving waarin uw batchimplementatie wordt uitgevoerd. De omgeving moet de pakketten azureml-core bevatten en azureml-dataset-runtime[fuse], die vereist zijn voor batch-eindpunten, plus eventuele afhankelijkheid die uw code nodig heeft om uit te voeren. In dit geval zijn de afhankelijkheden vastgelegd in een conda.yaml bestand:

    deployment-torch/environment/conda.yaml

    name: mnist-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip<22.0
  - pip:
    - torch==1.13.0
    - torchvision==0.14.0
    - pytorch-lightning
    - pandas
    - azureml-core
    - azureml-dataset-runtime[fuse]

    Belangrijk

    De pakketten azureml-core en azureml-dataset-runtime[fuse] zijn vereist voor batchimplementaties en moeten worden opgenomen in de omgevingsafhankelijkheden.

    Geef de omgeving als volgt op:

    De omgevingsdefinitie is opgenomen in de implementatiedefinitie zelf als een anonieme omgeving. U ziet in de volgende regels in de implementatie:

    environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml

  4. Ga naar het tabblad Omgevingen in het zijmenu.

  5. Selecteer Aangepaste omgevingen>maken.

    1. Voer in dit geval torch-batch-envde naam van de omgeving in.

    2. Selecteer voor Omgevingsbron selecteren de optie Bestaande Docker-installatiekopieën gebruiken met een optioneel Conda-bestand.

    3. Voer voor containerregisterinstallatiekopieënpad het volgende inmcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.

    4. Selecteer Volgende om naar de sectie Aanpassen te gaan.

    5. Kopieer de inhoud van de file deployment-torch/environment/conda.yaml vanuit de GitHub-opslagplaats naar de portal.

  6. Selecteer Volgende totdat u bij de controlepagina bent.

  7. Selecteer Maken en wacht totdat de omgeving gereed is.

    Waarschuwing

    Gecureerde omgevingen worden niet ondersteund in batchimplementaties. U moet uw eigen omgeving opgeven. U kunt altijd de basisafbeelding van een gecureerde omgeving gebruiken als uw omgeving om het proces te vereenvoudigen.

  8. Een implementatiedefinitie maken

    deployment-torch/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
name: mnist-torch-dpl
description: A deployment using Torch to solve the MNIST classification dataset.
endpoint_name: mnist-batch
type: model
model:
  name: mnist-classifier-torch
  path: model
code_configuration:
  code: code
  scoring_script: batch_driver.py
environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 30
  error_threshold: -1
  logging_level: info

    In de volgende tabel worden de belangrijkste eigenschappen van de batchimplementatie beschreven. Zie HET YAML-schema voor de volledige batchimplementatie van de BATCH-implementatie (v2) voor het YAML-schema voor de volledige batchimplementatie.

    Toets Beschrijving
    name De naam van de implementatie.
    endpoint_name De naam van het eindpunt voor het maken van de implementatie onder.
    model Het model dat moet worden gebruikt voor batchgewijs scoren. In het voorbeeld wordt een model inline gedefinieerd met behulp van path. Met deze definitie kunnen modelbestanden automatisch worden geüpload en geregistreerd met een automatisch gegenereerde naam en versie. Zie het modelschema voor meer opties. Als best practice voor productiescenario's moet u het model afzonderlijk maken en hiernaar verwijzen. Als u naar een bestaand model wilt verwijzen, gebruikt u de azureml:<model-name>:<model-version> syntaxis.
    code_configuration.code De lokale map die alle Python-broncode bevat om het model te scoren.
    code_configuration.scoring_script Het Python-bestand in de code_configuration.code map. Dit bestand moet een init() functie en een run() functie hebben. Gebruik de init() functie voor kostbare of algemene voorbereiding (bijvoorbeeld om het model in het geheugen te laden). init() wordt slechts één keer aan het begin van het proces aangeroepen. Gebruik run(mini_batch) dit om elke vermelding te scoren. De waarde mini_batch is een lijst met bestandspaden. De run() functie moet een Pandas DataFrame of een matrix retourneren. Elk geretourneerd element geeft een geslaagde uitvoering van het invoerelement in de mini_batch. Zie Inzicht in het scorescript voor meer informatie over het maken van een scorescript.
    environment De omgeving om het model te scoren. In het voorbeeld wordt een inline omgeving gedefinieerd met behulp van conda_file en image. De conda_file afhankelijkheden worden bovenop de image. De omgeving wordt automatisch geregistreerd met een automatisch gegenereerde naam en versie. Zie het omgevingsschema voor meer opties. Als best practice voor productiescenario's moet u de omgeving afzonderlijk maken en hiernaar verwijzen. Als u naar een bestaande omgeving wilt verwijzen, gebruikt u de azureml:<environment-name>:<environment-version> syntaxis.
    compute De berekening voor het uitvoeren van batchgewijs scoren. In het voorbeeld wordt de batch-cluster gemaakte aan het begin gebruikt en wordt ernaar verwezen met behulp van de azureml:<compute-name> syntaxis.
    resources.instance_count Het aantal exemplaren dat moet worden gebruikt voor elke batchscoretaak.
    settings.max_concurrency_per_instance Het maximum aantal parallelle scoring_script uitvoeringen per exemplaar.
    settings.mini_batch_size Het aantal bestanden dat in scoring_script één run() gesprek kan worden verwerkt.
    settings.output_action Hoe de uitvoer moet worden geordend in het uitvoerbestand. append_row hiermee worden alle run() geretourneerde uitvoerresultaten samengevoegd tot één bestand met de naam output_file_name. summary_only de uitvoerresultaten worden niet samengevoegd en worden alleen berekend error_threshold.
    settings.output_file_name De naam van het uitvoerbestand voor batchgewijs scoren voor append_rowoutput_action.
    settings.retry_settings.max_retries Het aantal mislukte pogingen voor een mislukte scoring_scriptrun()poging.
    settings.retry_settings.timeout De time-out in seconden voor een scoring_scriptrun() voor het scoren van een minibatch.
    settings.error_threshold Het aantal fouten bij het scoren van invoerbestanden die moeten worden genegeerd. Als het aantal fouten voor de volledige invoer hoger is dan deze waarde, wordt de batchscoretaak beëindigd. In het voorbeeld wordt -1gebruikgemaakt van , wat aangeeft dat een willekeurig aantal fouten is toegestaan zonder de batchscoretaak te beëindigen.
    settings.logging_level Uitgebreidheid van het logboek. Waarden in toenemende uitgebreidheid zijn: WAARSCHUWING, INFO en FOUTOPSPORING.
    settings.environment_variables Woordenlijst van naam-waardeparen van omgevingsvariabelen die moeten worden ingesteld voor elke batchscoretaak.

  9. Ga naar het tabblad Eindpunten in het zijmenu.

    1. Selecteer het tabblad Batch-eindpunten>maken.

    2. Geef het eindpunt een naam, in dit geval mnist-batch. U kunt de rest van de velden configureren of leeg laten.

    3. Selecteer Volgende om naar de sectie Model te gaan.

    4. Selecteer het model mnist-classifier-torch.

    5. Selecteer Volgende om naar de pagina Implementatie te gaan.

    6. Geef de implementatie een naam.

  10. Zorg ervoor dat de rij Toevoegen is geselecteerd voor de uitvoeractie.

    1. Controleer voor de naam van het uitvoerbestand of het uitvoerbestand voor batchgewijs scoren het bestand is dat u nodig hebt. Standaard is predictions.csv.

    2. Voor minibatchgrootte past u de grootte aan van de bestanden die in elke minibatch worden opgenomen. Deze grootte bepaalt de hoeveelheid gegevens die uw scorescript per batch ontvangt.

    3. Voor time-outs voor scoren (seconden) zorgt u ervoor dat u voldoende tijd geeft voor uw implementatie om een bepaalde batch bestanden te scoren. Als u het aantal bestanden verhoogt, moet u meestal ook de time-outwaarde verhogen. Duurdere modellen (zoals modellen op basis van deep learning) vereisen mogelijk hoge waarden in dit veld.

    4. Configureer voor maximale gelijktijdigheid per exemplaar het aantal uitvoerders dat u wilt hebben voor elk rekenproces dat u in de implementatie krijgt. Een hoger getal garandeert hier een hogere mate van parallellisatie, maar het verhoogt ook de geheugenbelasting op het rekenproces. Stem deze waarde helemaal af met minibatchgrootte.

    5. Als u klaar bent, selecteert u Volgende om naar de pagina Code + omgeving te gaan.

    6. Voor 'Selecteer een scorescript voor deductie', bladert u naar het scorescriptbestand deployment-torch/code/batch_driver.py.

    7. Selecteer in de sectie Omgeving selecteren de omgeving die u eerder hebt gemaakt in torch-batch-env.

    8. Selecteer Volgende om naar de pagina Compute te gaan.

    9. Selecteer het rekencluster dat u in een vorige stap hebt gemaakt.

      Waarschuwing

      Azure Kubernetes-clusters worden ondersteund in batchimplementaties, maar alleen wanneer ze worden gemaakt met behulp van de Azure Machine Learning CLI of Python SDK.

    10. Voer bijvoorbeeld het aantal rekeninstanties in dat u wilt gebruiken voor de implementatie. In dit geval gebruikt u 2.

    11. Selecteer Volgende.

  11. De implementatie maken:

    Voer de volgende code uit om een batch-implementatie te maken onder het batch-eindpunt en stel deze in als de standaardimplementatie.

    az ml batch-deployment create --file deployment-torch/deployment.yml --endpoint-name $ENDPOINT_NAME --set-default

    Aanbeveling

    Met --set-default de parameter wordt de zojuist gemaakte implementatie ingesteld als de standaardimplementatie van het eindpunt. Het is een handige manier om een nieuwe standaardimplementatie van het eindpunt te maken, met name voor het maken van de eerste implementatie. Als best practice voor productiescenario's wilt u mogelijk een nieuwe implementatie maken zonder deze als standaardinstelling in te stellen. Controleer of de implementatie werkt zoals verwacht en werk de standaardimplementatie later bij. Zie de sectie Een nieuw model implementeren voor meer informatie over het implementeren van dit proces.

  12. Controleer de details van het batch-eindpunt en de implementatie.

    Gebruik show dit om de details van het eindpunt en de implementatie te controleren. Voer de volgende code uit om een batchimplementatie te controleren:

    DEPLOYMENT_NAME="mnist-torch-dpl"
az ml batch-deployment show --name $DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME

  13. Selecteer het tabblad Batch-eindpunten .

    1. Selecteer het batch-eindpunt dat u wilt weergeven.

    2. Op de pagina Details van het eindpunt ziet u de details van het eindpunt, samen met alle implementaties die beschikbaar zijn in het eindpunt.

      Schermopname van de batch-eindpunten en implementatiegegevens controleren.

Batch-eindpunten uitvoeren en resultaten openen

Informatie over de gegevensstroom

Voordat u uw batch-eindpunt uitvoert, moet u begrijpen hoe gegevens door het systeem stromen:

Invoer: Gegevens die moeten worden verwerkt (score). Dit omvat:

  • Bestanden die zijn opgeslagen in Azure Storage (blobopslag, data lake)
  • Mappen met meerdere bestanden
  • Geregistreerde gegevenssets in Azure Machine Learning

Verwerking: Het geïmplementeerde model verwerkt de invoergegevens in batches (minibatches) en genereert voorspellingen.

Uitvoer: Resultaten van het model, opgeslagen als bestanden in Azure Storage. Standaard worden uitvoer opgeslagen in de standaard-blobopslag van de werkruimte, maar u kunt een andere locatie opgeven.

Een batch-eindpunt aanroepen

Als u een batcheindpunt aanroept, wordt een batchscoretaak geactiveerd. De taak name wordt geretourneerd in het aanroepende antwoord en houdt de voortgang van de batchgewijs score bij. Geef het pad naar invoergegevens op, zodat de eindpunten de gegevens kunnen vinden die moeten worden beoordeeld. In het volgende voorbeeld ziet u hoe u een nieuwe taak start op basis van een voorbeeldgegevens van de MNIST-gegevensset die is opgeslagen in een Azure Storage-account.

U kunt een batch-eindpunt uitvoeren en aanroepen met behulp van Azure CLI, Azure Machine Learning SDK of REST-eindpunten. Zie Taken en invoergegevens maken voor batcheindpunten voor meer informatie over deze opties.

Notitie

Hoe werkt parallelle uitvoering?

Batch-implementaties distribueren werk op bestandsniveau. Een map met 100 bestanden en minibatches van 10 bestanden genereert bijvoorbeeld 10 batches van elk 10 bestanden. Dit gebeurt ongeacht de bestandsgrootte. Als bestanden te groot zijn voor verwerking in minibatches, splitst u ze op in kleinere bestanden om parallelle uitvoering te vergroten of het aantal bestanden per minibatch te verminderen. Batch-implementaties maken momenteel geen rekening met scheeftrekken in de distributie van de bestandsgrootte.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Batch-eindpunten ondersteunen het lezen van bestanden of mappen die zich op verschillende locaties bevinden. Zie Toegang tot gegevens uit batch-eindpunttaken voor meer informatie over de ondersteunde typen en hoe u deze opgeeft.

Voortgang van batchtaakuitvoering bewaken

Batchverwerkingstaken nemen tijd in beslag om alle invoer te verwerken.

De volgende code controleert de taakstatus en voert een koppeling naar de Azure Machine Learning-studio uit voor meer informatie.

az ml job show -n $JOB_NAME --web

Resultaten van batchscore controleren

De taakuitvoer wordt opgeslagen in cloudopslag, ofwel in de standaard-blobopslag van de werkruimte of de opslag die u hebt opgegeven. Zie De uitvoerlocatie configureren voor meer informatie over het wijzigen van de standaardinstellingen. Met de volgende stappen kunt u de scoreresultaten weergeven in Azure Storage Explorer wanneer de taak is voltooid:

  1. Voer de volgende code uit om de batchscoretaak in Azure Machine Learning-studio te openen. De job studio-koppeling wordt ook opgenomen in het antwoord van invoke, als de waarde van interactionEndpoints.Studio.endpoint.

    az ml job show -n $JOB_NAME --web

  2. Selecteer de batchscoring stap in de grafiek van de taak.

  3. Selecteer het tabblad Uitvoer en logboeken en selecteer vervolgens Gegevensuitvoer weergeven.

  4. Selecteer in gegevensuitvoer het pictogram om Storage Explorer te openen.

    Schermopname van studio met de locatie van de uitvoer van gegevens.

    De scoreresultaten in Storage Explorer zijn vergelijkbaar met de volgende voorbeeldpagina:

    Schermopname van de score-uitvoer.

De uitvoerlocatie configureren

Batchscore resultaten worden standaard opgeslagen in de standaard blob-opslagplaats van de werkruimte in een map die is genoemd naar de taak (een door het systeem gegenereerde GUID). Configureer de uitvoerlocatie bij het aanroepen van het batch-eindpunt.

Hiermee output-path configureert u een map in een geregistreerde Azure Machine Learning-gegevensopslag. De syntaxis voor de --output-path map is hetzelfde als --input wanneer u een map opgeeft, dat wil azureml://datastores/<datastore-name>/paths/<path-on-datastore>/gezegd. Hiermee --set output_file_name=<your-file-name> configureert u een nieuwe naam voor het uitvoerbestand.

OUTPUT_FILE_NAME=predictions_`echo $RANDOM`.csv
OUTPUT_PATH="azureml://datastores/workspaceblobstore/paths/$ENDPOINT_NAME"

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --output-path $OUTPUT_PATH --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

Waarschuwing

U moet een unieke uitvoerlocatie gebruiken. Als het uitvoerbestand bestaat, mislukt de batchscoretaak.

Belangrijk

In tegenstelling tot invoer kunnen uitvoer alleen worden opgeslagen in Azure Machine Learning-gegevensarchieven die worden uitgevoerd op blobopslagaccounts.

Implementatieconfiguratie voor elke taak overschrijven

Wanneer u een batch-eindpunt aanroept, kunt u enkele instellingen overschrijven om het beste gebruik te maken van rekenresources en de prestaties te verbeteren. Deze functie is handig wanneer u verschillende instellingen voor verschillende taken nodig hebt zonder de implementatie permanent te wijzigen.

Welke instellingen kunnen worden overschreven?

U kunt de volgende instellingen per taak configureren:

Configuratie Wanneer te gebruiken Voorbeeldscenario
Aantal exemplaren Wanneer u verschillende gegevensvolumes hebt Gebruik meer exemplaren voor grotere gegevenssets (10 exemplaren voor 1 miljoen bestanden versus 2 exemplaren voor 100.000 bestanden).
Minibatchgrootte Wanneer u de doorvoer en het geheugengebruik wilt verdelen Gebruik kleinere batches (10-50 bestanden) voor grote afbeeldingen en grotere batches (100-500 bestanden) voor kleine tekstbestanden.
Maximum aantal nieuwe pogingen Wanneer de gegevenskwaliteit varieert Hogere pogingen (5-10) voor ruisgegevens; lagere pogingen (1-3) voor schone gegevens
Timeout Wanneer de verwerkingstijd verschilt per gegevenstype Langere time-out (300s) voor complexe modellen; kortere time-out (30s) voor eenvoudige modellen
Foutdrempel Wanneer u verschillende fouttolerantieniveaus nodig hebt Strikte drempelwaarde (-1) voor kritieke taken; lengtedrempel (10%) voor experimentele taken

Instellingen overschrijven

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --mini-batch-size 20 --instance-count 5 --query name -o tsv)

Implementaties toevoegen aan een eindpunt

Zodra u een batch-eindpunt met een implementatie hebt, kunt u uw model verder verfijnen en nieuwe implementaties toevoegen. Batch-eindpunten blijven de standaardimplementatie leveren terwijl u nieuwe modellen onder hetzelfde eindpunt ontwikkelt en implementeert. Implementaties hebben geen invloed op elkaar.

In dit voorbeeld voegt u een tweede implementatie toe die gebruikmaakt van een model dat is gebouwd met Keras en TensorFlow om hetzelfde MNIST-probleem op te lossen.

Een tweede implementatie toevoegen

  1. Maak een omgeving voor uw batchimplementatie. Neem eventuele afhankelijkheden op die door uw code moeten worden uitgevoerd. Voeg de bibliotheek azureml-coretoe, omdat deze vereist is voor batchimplementaties. De volgende omgevingsdefinitie bevat de vereiste bibliotheken voor het uitvoeren van een model met TensorFlow.

    De omgevingsdefinitie is opgenomen in de implementatiedefinitie zelf als een anonieme omgeving.

    environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml

  2. Kopieer de inhoud van de file deployment-keras/environment/conda.yaml vanuit de GitHub-opslagplaats naar de portal.

    1. Selecteer Volgende totdat u bij de pagina Controleren bent.

    2. Selecteer Maken en wacht totdat de omgeving gereed is voor gebruik.

    Het gebruikte Conda-bestand ziet er als volgt uit:

    deployment-keras/environment/conda.yaml

    name: tensorflow-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip
  - pip:
    - pandas
    - tensorflow
    - pillow
    - azureml-core
    - azureml-dataset-runtime[fuse]

  3. Maak een scorescript voor het model:

    deployment-keras/code/batch_driver.py

    import os
import numpy as np
import pandas as pd
import tensorflow as tf
from typing import List
from os.path import basename
from PIL import Image
from tensorflow.keras.models import load_model


def init():
    global model

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model")

    # load the model
    model = load_model(model_path)


def run(mini_batch: List[str]) -> pd.DataFrame:
    print(f"Executing run method over batch of {len(mini_batch)} files.")

    results = []
    for image_path in mini_batch:
        data = Image.open(image_path)
        data = np.array(data)
        data_batch = tf.expand_dims(data, axis=0)

        # perform inference
        pred = model.predict(data_batch)

        # Compute probabilities, classes and labels
        pred_prob = tf.math.reduce_max(tf.math.softmax(pred, axis=-1)).numpy()
        pred_class = tf.math.argmax(pred, axis=-1).numpy()

        results.append(
            {
                "file": basename(image_path),
                "class": pred_class[0],
                "probability": pred_prob,
            }
        )

    return pd.DataFrame(results)

  4. Een implementatiedefinitie maken

    deployment-keras/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
name: mnist-keras-dpl
description: A deployment using Keras with TensorFlow to solve the MNIST classification dataset.
endpoint_name: mnist-batch
type: model
model: 
  name: mnist-classifier-keras
  path: model
code_configuration:
  code: code
  scoring_script: batch_driver.py
environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv

  5. Selecteer Volgende om door te gaan naar de pagina Code + omgeving.

    1. Als u een scorescript wilt selecteren voor deductie, bladert u naar het scorescriptbestand deployment-keras/code/batch_driver.py.

    2. Selecteer bij Omgeving selecteren de omgeving die u in een vorige stap hebt gemaakt.

    3. Selecteer Volgende.

    4. Selecteer op de pagina Compute het rekencluster dat u in een vorige stap hebt gemaakt.

    5. Voer bijvoorbeeld het aantal rekeninstanties in dat u wilt gebruiken voor de implementatie. In dit geval gebruikt u 2.

    6. Selecteer Volgende.

  6. De implementatie maken:

    Voer de volgende code uit om een batch-implementatie te maken onder het batch-eindpunt en deze in te stellen als de standaardimplementatie.

    az ml batch-deployment create --file deployment-keras/deployment.yml --endpoint-name $ENDPOINT_NAME

    Aanbeveling

    De --set-default parameter ontbreekt in dit geval. Als best practice voor productiescenario's maakt u een nieuwe implementatie zonder deze als standaardinstelling in te stellen. Controleer deze en werk de standaardimplementatie later bij.

Een niet-standaard batchimplementatie testen

Als u de nieuwe niet-standaardimplementatie wilt testen, moet u de naam weten van de implementatie die u wilt uitvoeren.

DEPLOYMENT_NAME="mnist-keras-dpl"
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --deployment-name $DEPLOYMENT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Kennisgeving --deployment-name wordt gebruikt om de implementatie op te geven die moet worden uitgevoerd. Met deze parameter kunt u een niet-standaardimplementatie uitvoeren invoke zonder de standaardimplementatie van het batch-eindpunt bij te werken.

De standaardbatchimplementatie bijwerken

Hoewel u een specifieke implementatie binnen een eindpunt kunt aanroepen, wilt u meestal het eindpunt zelf aanroepen en het eindpunt laten bepalen welke implementatie moet worden gebruikt, de standaardimplementatie. U kunt de standaardimplementatie wijzigen (en dus het model dat de implementatie bedient) wijzigen zonder uw contract te wijzigen met de gebruiker die het eindpunt aanroept. Gebruik de volgende code om de standaardimplementatie bij te werken:

az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

Het batch-eindpunt en de implementatie verwijderen

Als u de oude batchimplementatie niet nodig hebt, verwijdert u deze door de volgende code uit te voeren. De --yes vlag bevestigt de verwijdering.

az ml batch-deployment delete --name mnist-torch-dpl --endpoint-name $ENDPOINT_NAME --yes

Voer de volgende code uit om het batch-eindpunt en de onderliggende implementaties te verwijderen. Batchscoretaken worden niet verwijderd.

az ml batch-endpoint delete --name $ENDPOINT_NAME --yes

Gerelateerde inhoud