MLflow-modellen implementeren in batchimplementaties

  • Artikel

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

In dit artikel leert u hoe u MLflow-modellen implementeert in Azure Machine Learning voor beide batchdeductie met behulp van batcheindpunten. Bij het implementeren van MLflow-modellen op batch-eindpunten, Azure Machine Learning:

  • Biedt een MLflow-basisinstallatiekopieën/gecureerde omgeving die de vereiste afhankelijkheden bevat voor het uitvoeren van een Azure Machine Learning Batch-taak.
  • Hiermee maakt u een batchtaakpijplijn met een scorescript dat kan worden gebruikt om gegevens te verwerken met behulp van parallelle uitvoering.

Notitie

Zie Overwegingen bij het implementeren van batchdeductie voor meer informatie over de ondersteunde invoerbestandstypen en details over hoe het MLflow-model werkt.

Over dit voorbeeld

In dit voorbeeld ziet u hoe u een MLflow-model kunt implementeren in een batch-eindpunt om batchvoorspellingen uit te voeren. In dit voorbeeld wordt een MLflow-model gebruikt op basis van de UCI Heart Disease Data Set. De database bevat 76 kenmerken, maar we gebruiken een subset van 14 kenmerken. Het model probeert de aanwezigheid van hart- en vaatziekten bij een patiënt te voorspellen. Het is een geheel getal van 0 (geen aanwezigheid) tot 1 (aanwezigheid).

Het model is getraind met behulp van een XGBBoost classificatie en alle vereiste voorverwerking is verpakt als een scikit-learn pijplijn, waardoor dit model een end-to-end-pijplijn is die van onbewerkte gegevens naar voorspellingen gaat.

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

De bestanden voor dit voorbeeld bevinden zich in:

cd endpoints/batch/deploy-models/heart-classifier-mlflow

Volgen in Jupyter Notebooks

U kunt dit voorbeeld volgen in de volgende notebooks. Open in de gekloonde opslagplaats het notebook: mlflow-for-batch-tabular.ipynb.

Vereisten

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

  • 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 Azure Machine Learning-werkruimten beheren om er een te maken.

  • Zorg ervoor dat u over de volgende machtigingen in de werkruimte beschikt:

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

    • ARM-implementaties maken in de resourcegroep van de werkruimte: gebruik een eigenaar, inzender of aangepaste rol die het mogelijk maakt 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:

    De Azure CLI en de mlextensie voor Azure Machine Learning.

    az extension add -n ml

    Notitie

    Implementaties van pijplijnonderdelen voor Batch-eindpunten zijn geïntroduceerd in versie 2.7 van de ml extensie voor Azure CLI. Gebruik az extension update --name ml deze om de laatste versie ervan op te halen.

Verbinding maken met uw werkruimte

De werkruimte is de resource op het hoogste niveau voor Azure Machine Learning en biedt een gecentraliseerde werkplek met alle artefacten die u maakt in Azure Machine Learning. In deze sectie maken we verbinding met de werkruimte waarin u implementatietaken uitvoert.

Geef de waarden voor uw abonnements-id, werkruimte, locatie en resourcegroep door in de volgende code:

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

Stappen

Volg deze stappen om een MLflow-model te implementeren in een batch-eindpunt voor het uitvoeren van batchdeductie over nieuwe gegevens:

  1. Batch-eindpunt kan alleen geregistreerde modellen implementeren. In dit geval hebben we al een lokale kopie van het model in de opslagplaats, dus we hoeven het model alleen in het register in de werkruimte te publiceren. U kunt deze stap overslaan als het model dat u probeert te implementeren al is geregistreerd.

    MODEL_NAME='heart-classifier-mlflow'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "model"

  2. Voordat u verdergaat, moet u ervoor zorgen dat de batchimplementaties die we gaan maken, kunnen worden uitgevoerd op een bepaalde infrastructuur (compute). Batch-implementaties kunnen worden uitgevoerd op elke Azure Machine Learning-rekenkracht die al bestaat in de werkruimte. Dat betekent dat meerdere batchimplementaties dezelfde rekeninfrastructuur kunnen delen. In dit voorbeeld gaan we werken aan een Azure Machine Learning-rekencluster met de naam cpu-cluster. Laten we controleren of de berekening aanwezig is in de werkruimte of anders maakt.

    Maak als volgt een rekencluster:

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

  3. Nu is het tijd om het batch-eindpunt en de implementatie te maken. Laten we eerst beginnen met het eindpunt. Voor eindpunten is alleen een naam en een beschrijving vereist om te worden gemaakt. De naam van het eindpunt eindigt in de URI die is gekoppeld aan uw eindpunt. Daarom moeten namen van batcheindpunten uniek zijn binnen een Azure-regio. Er kan bijvoorbeeld slechts één batcheindpunt zijn met de naam mybatchendpoint in westus2.

    In dit geval plaatsen we de naam van het eindpunt in een variabele, zodat we er later eenvoudig naar kunnen verwijzen.

    ENDPOINT_NAME="heart-classifier"

  4. Maak het eindpunt:

    Als u een nieuw eindpunt wilt maken, maakt u een YAML configuratie zoals hieronder:

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: heart-classifier-batch
description: A heart condition classifier for batch inference
auth_mode: aad_token

    Maak vervolgens het eindpunt met de volgende opdracht:

    az ml batch-endpoint create -n $ENDPOINT_NAME -f endpoint.yml

  5. Nu gaan we de implementatie maken. Voor MLflow-modellen hoeft u geen omgeving of een scorescript aan te geven bij het maken van de implementaties terwijl deze voor u worden gemaakt. U kunt deze echter opgeven als u wilt aanpassen hoe de implementatie deductie uitvoert.

    Als u een nieuwe implementatie wilt maken onder het gemaakte eindpunt, maakt u een YAML configuratie zoals hieronder. U kunt het YAML-schema voor het volledige batcheindpunt controleren op extra eigenschappen.

    implementatie eenvoudig/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: heart-classifier-batch
name: classifier-xgboost-mlflow
description: A heart condition classifier based on XGBoost
type: model
model: azureml:heart-classifier-mlflow@latest
compute: azureml:batch-cluster
resources:
  instance_count: 2
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 2
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 300
  error_threshold: -1
  logging_level: info

    Maak vervolgens de implementatie met de volgende opdracht:

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

    Belangrijk

    Configureer timeout in uw implementatie op basis van hoe lang het duurt voordat uw model deductie uitvoert op één batch. Hoe groter de batchgrootte hoe langer deze waarde moet zijn. Remeber die mini_batch_size het aantal bestanden in een batch aangeeft, niet het aantal steekproeven. Wanneer u met tabelgegevens werkt, kan elk bestand meerdere rijen bevatten, waardoor de tijd die het duurt voordat het batcheindpunt elk bestand verwerkt, toeneemt. Gebruik hoge waarden voor deze gevallen om time-outfouten te voorkomen.

  6. 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. Deze implementatie heet de standaardimplementatie. Dit biedt u de mogelijkheid om de standaardimplementatie te wijzigen en daarom het model te wijzigen dat de implementatie bedient zonder het contract te wijzigen met de gebruiker die het eindpunt aanroept. Gebruik de volgende instructie om de standaardimplementatie bij te werken:

    DEPLOYMENT_NAME="classifier-xgboost-mlflow"
az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

  7. Op dit moment is ons batcheindpunt gereed om te worden gebruikt.

De implementatie testen

Voor het testen van ons eindpunt gebruiken we een voorbeeld van niet-gelabelde gegevens die zich in deze opslagplaats bevinden en die kunnen worden gebruikt met het model. Batch-eindpunten kunnen alleen gegevens verwerken die zich in de cloud bevinden en die toegankelijk zijn vanuit de Azure Machine Learning-werkruimte. In dit voorbeeld gaan we het uploaden naar een Azure Machine Learning-gegevensarchief. We gaan met name een gegevensasset maken die kan worden gebruikt om het eindpunt aan te roepen voor scoren. U ziet echter dat batcheindpunten gegevens accepteren die op verschillende locaties kunnen worden geplaatst.

  1. Laten we eerst de gegevensasset maken. Deze gegevensasset bestaat uit een map met meerdere CSV-bestanden die we parallel willen verwerken met behulp van batch-eindpunten. U kunt deze stap overslaan, omdat uw gegevens al zijn geregistreerd als gegevensasset of u een ander invoertype wilt gebruiken.

    a. Een gegevensassetdefinitie maken in YAML:

    heart-dataset-unlabeled.yml

    $schema: https://azuremlschemas.azureedge.net/latest/data.schema.json
name: heart-dataset-unlabeled
description: An unlabeled dataset for heart classification.
type: uri_folder
path: data

    b. Maak de gegevensasset:

    az ml data create -f heart-dataset-unlabeled.yml

  2. Nu de gegevens zijn geüpload en klaar zijn om te worden gebruikt, gaan we het eindpunt aanroepen:

    JOB_NAME = $(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input azureml:heart-dataset-unlabeled@latest --query name -o tsv)

    Notitie

    Het hulpprogramma jq is mogelijk niet geïnstalleerd op elke installatie. In deze koppeling vindt u installatie-instructies.

    Tip

    U ziet dat de implementatienaam in de aanroepbewerking niet wordt aangegeven. Dat komt doordat het eindpunt de taak automatisch doorstuurt naar de standaardimplementatie. Omdat ons eindpunt slechts één implementatie heeft, is dat de standaardimplementatie. U kunt een specifieke implementatie instellen door het argument/de parameter deployment_nameaan te geven.

  3. Er wordt een batchtaak gestart zodra de opdracht wordt geretourneerd. U kunt de status van de taak controleren totdat deze is voltooid:

    az ml job show -n $JOB_NAME --web

De uitvoer analyseren

Uitvoervoorspellingen worden gegenereerd in het predictions.csv bestand zoals aangegeven in de implementatieconfiguratie. De taak genereert een benoemde uitvoer met de naam score waar dit bestand wordt geplaatst. Er wordt slechts één bestand per batchtaak gegenereerd.

Het bestand is als volgt gestructureerd:

  • Er is één rij per gegevenspunt dat naar het model is verzonden. Voor tabelgegevens betekent dit dat het bestand (predictions.csv) één rij bevat voor elke rij die aanwezig is in elk van de verwerkte bestanden. Voor andere gegevenstypen (bijvoorbeeld afbeeldingen, audio, tekst), is er één rij per verwerkt bestand.

  • De volgende kolommen bevinden zich in het bestand (in volgorde):

    • row (optioneel), de bijbehorende rijindex in het invoergegevensbestand. Dit geldt alleen als de invoergegevens tabellair zijn. Voorspellingen worden geretourneerd in dezelfde volgorde als in het invoerbestand, zodat u kunt vertrouwen op het rijnummer dat overeenkomt met de bijbehorende voorspelling.
    • prediction, de voorspelling die is gekoppeld aan de invoergegevens. Deze waarde wordt als resultaat gegeven door de functie van predict(). het model.
    • file_name, de bestandsnaam waaruit de gegevens zijn gelezen. Gebruik dit veld in tabelvorm om te weten welke voorspelling hoort bij welke invoergegevens.

U kunt de resultaten van de taak downloaden met behulp van de taaknaam:

Gebruik de volgende opdracht om de voorspellingen te downloaden:

az ml job download --name $JOB_NAME --output-name score --download-path ./

Zodra het bestand is gedownload, kunt u het openen met uw favoriete hulpprogramma. In het volgende voorbeeld worden de voorspellingen geladen met behulp van Pandas dataframe.

import pandas as pd

score = pd.read_csv(
    "named-outputs/score/predictions.csv", names=["row", "prediction", "file"]
)

De uitvoer ziet er als volgt uit:

rij Voorspelling bestand
0 0 heart-unlabeled-0.csv
1 1 heart-unlabeled-0.csv
2 0 heart-unlabeled-0.csv
... ... ...
307 0 heart-unlabeled-3.csv

Tip

U ziet dat in dit voorbeeld de invoergegevens gegevens in tabelvorm waren en CSV dat er vier verschillende invoerbestanden (heart-unlabeled-0.csv, heart-unlabeled-1.csv, heart-unlabeled-2.csv en heart-unlabeled-3.csv) waren.

Overwegingen bij het implementeren naar batchdeductie

Azure Machine Learning biedt ondersteuning voor het implementeren van MLflow-modellen naar batch-eindpunten zonder een scorescript aan te geven. Dit is een handige manier om modellen te implementeren die verwerking van grote hoeveelheden gegevens in batchverwerking vereisen. Azure Machine Learning gebruikt informatie in de MLflow-modelspecificatie om het deductieproces in te delen.

Hoe werk wordt verdeeld over werkrollen

Batch-eindpunten distribueren werk op bestandsniveau voor gestructureerde en ongestructureerde gegevens. Als gevolg hiervan worden alleen URI-bestanden en URI-mappen ondersteund voor deze functie. Elke werkrol verwerkt batches Mini batch size bestanden tegelijk. Voor tabellaire gegevens houden batcheindpunten geen rekening met het aantal rijen in elk bestand bij het distribueren van het werk.

Waarschuwing

Geneste mapstructuren worden niet verkend tijdens deductie. Als u uw gegevens partitioneert met behulp van mappen, moet u de structuur vooraf platmaken.

Batch-implementaties roepen de predict functie van het MLflow-model eenmaal per bestand aan. Voor CSV-bestanden met meerdere rijen kan dit een geheugenbelasting in de onderliggende berekening opleggen en kan dit de tijd die het kost voor het model verhogen om één bestand te scoren (speciaal voor dure modellen zoals grote taalmodellen). Als u verschillende uitzonderingen met onvoldoende geheugen of time-outvermeldingen in logboeken tegenkomt, kunt u overwegen om de gegevens in kleinere bestanden met minder rijen te splitsen of batchverwerking op rijniveau in het model-/scorescript te implementeren.

Ondersteuning voor bestandstypen

De volgende gegevenstypen worden ondersteund voor batchdeductie bij het implementeren van MLflow-modellen zonder een omgeving en een scorescript. Als u een ander bestandstype wilt verwerken of deductie wilt uitvoeren op een andere manier die batcheindpunten standaard doen, kunt u de implementatie altijd maken met een scorescript, zoals wordt uitgelegd in MLflow-modellen gebruiken met een scorescript.

Bestandsextensie Type dat wordt geretourneerd als invoer van het model Handtekeningvereiste
.csv, , .parquet.pqt pd.DataFrame ColSpec. Als dit niet is opgegeven, wordt het typen van kolommen niet afgedwongen.
.png, , .jpg.jpeg, .tiff, , , .bmp.gif np.ndarray TensorSpec. De invoer wordt aangepast aan de vorm van tensors, indien beschikbaar. Als er geen handtekening beschikbaar is, worden de tensors van het type np.uint8 afgeleid. Lees overwegingen voor MLflow-modellen die afbeeldingen verwerken voor aanvullende richtlijnen.

Waarschuwing

Houd er rekening mee dat een niet-ondersteund bestand dat aanwezig kan zijn in de invoergegevens, ervoor zorgt dat de taak mislukt. U ziet een foutbericht als volgt: 'ERROR:azureml:Error processing input file: '/mnt/batch/tasks/.../a-given-file.avro'. Bestandstype 'avro' wordt niet ondersteund.'

Handtekening afdwingen voor MLflow-modellen

De gegevenstypen van invoer worden afgedwongen door batchimplementatietaken terwijl de gegevens worden gelezen met behulp van de beschikbare handtekening van het MLflow-model. Dit betekent dat uw gegevensinvoer moet voldoen aan de typen die zijn aangegeven in de modelhandtekening. Als de gegevens niet kunnen worden geparseerd zoals verwacht, mislukt de taak met een foutbericht dat lijkt op de volgende: 'ERROR:azureml:Error processing input file: '/mnt/batch/tasks/.../a-given-file.csv'. Uitzondering: ongeldige letterlijke waarde voor int() met grondtal 10: 'waarde'.

Tip

Handtekeningen in MLflow-modellen zijn optioneel, maar ze worden sterk aangemoedigd omdat ze een handige manier bieden om problemen met gegevenscompatibiliteit vroeg te detecteren. Voor meer informatie over het vastleggen van modellen met handtekeningen leest u Logboekregistratiemodellen met een aangepaste handtekening, omgeving of voorbeelden.

U kunt de modelhandtekening van uw model inspecteren door het MLmodel bestand te openen dat is gekoppeld aan uw MLflow-model. Zie Handtekeningen in MLflow voor meer informatie over hoe handtekeningen werken in MLflow.

Smaakondersteuning

Batch-implementaties ondersteunen alleen het implementeren van MLflow-modellen met een pyfunc smaak. Als u een andere smaak wilt implementeren, raadpleegt u MLflow-modellen gebruiken met een scorescript.

Implementaties van MLflow-modellen aanpassen met een scorescript

MLflow-modellen kunnen worden geïmplementeerd op batch-eindpunten zonder een scorescript in de implementatiedefinitie aan te geven. U kunt er echter voor kiezen om dit bestand aan te geven (meestal het batchstuurprogramma genoemd) om aan te passen hoe deductie wordt uitgevoerd.

Doorgaans selecteert u deze werkstroom wanneer:

  • U moet een bestandstype verwerken dat niet wordt ondersteund door MLflow-implementaties in batchimplementaties.
  • U moet de manier waarop het model wordt uitgevoerd aanpassen, bijvoorbeeld een specifieke smaak gebruiken om het mee mlflow.<flavor>.load()te laden.
  • U moet de verwerking vooraf/pos uitvoeren in uw scoreroutine wanneer dit niet wordt gedaan door het model zelf.
  • De uitvoer van het model kan niet mooi worden weergegeven in tabelgegevens. Het is bijvoorbeeld een tensor die een afbeelding vertegenwoordigt.
  • U kunt elk bestand niet tegelijk verwerken vanwege geheugenbeperkingen en moet het in segmenten lezen.

Belangrijk

Als u ervoor kiest om een scorescript voor een implementatie van een MLflow-model aan te geven, moet u ook de omgeving opgeven waarin de implementatie wordt uitgevoerd.

Stappen

Gebruik de volgende stappen om een MLflow-model te implementeren met een aangepast scorescript.

  1. Identificeer de map waarin uw MLflow-model is geplaatst.

    a. Ga naar de Azure Machine Learning-portal.

    b. Ga naar de sectie Modellen.

    c. Selecteer het model dat u wilt implementeren en klik op het tabblad Artefacten.

    d. Noteer de map die wordt weergegeven. Deze map is aangegeven toen het model werd geregistreerd.

    Schermopname van de map waarin de modelartefacten zijn geplaatst.

  2. Maak een scorescript. U ziet hoe de mapnaam model die u eerder hebt geïdentificeerd, is opgenomen in de init() functie.

    deployment-custom/code/batch_driver.py

    # Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license.

import os
import glob
import mlflow
import pandas as pd
import logging


def init():
    global model
    global model_input_types
    global model_output_names

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    # It is the path to the model folder
    # Please provide your model's folder name if there's one
    model_path = glob.glob(os.environ["AZUREML_MODEL_DIR"] + "/*/")[0]

    # Load the model, it's input types and output names
    model = mlflow.pyfunc.load(model_path)
    if model.metadata and model.metadata.signature:
        if model.metadata.signature.inputs:
            model_input_types = dict(
                zip(
                    model.metadata.signature.inputs.input_names(),
                    model.metadata.signature.inputs.pandas_types(),
                )
            )
        if model.metadata.signature.outputs:
            if model.metadata.signature.outputs.has_input_names():
                model_output_names = model.metadata.signature.outputs.input_names()
            elif len(model.metadata.signature.outputs.input_names()) == 1:
                model_output_names = ["prediction"]
    else:
        logging.warning(
            "Model doesn't contain a signature. Input data types won't be enforced."
        )


def run(mini_batch):
    print(f"run method start: {__file__}, run({len(mini_batch)} files)")

    data = pd.concat(
        map(
            lambda fp: pd.read_csv(fp).assign(filename=os.path.basename(fp)), mini_batch
        )
    )

    if model_input_types:
        data = data.astype(model_input_types)

    # Predict over the input data, minus the column filename which is not part of the model.
    pred = model.predict(data.drop("filename", axis=1))

    if pred is not pd.DataFrame:
        if not model_output_names:
            model_output_names = ["pred_col" + str(i) for i in range(pred.shape[1])]
        pred = pd.DataFrame(pred, columns=model_output_names)

    return pd.concat([data, pred], axis=1)

  3. We gaan een omgeving maken waarin het scorescript kan worden uitgevoerd. Omdat ons model MLflow is, worden de conda-vereisten ook opgegeven in het modelpakket (zie de MLmodel-indeling voor meer informatie over MLflow-modellen en de bestanden die erin zijn opgenomen). Vervolgens gaan we de omgeving bouwen met behulp van de conda-afhankelijkheden van het bestand. We moeten echter ook het pakket azureml-core opnemen dat vereist is voor Batch-implementaties.

    Tip

    Als uw model al is geregistreerd in het modelregister, kunt u het conda.yml bestand dat is gekoppeld aan uw model downloaden/kopiëren door naar Azure Machine Learning-studio> Modellen > uw model selecteren in de lijst > Artefacten. Open de hoofdmap in de navigatie en selecteer het conda.yml vermelde bestand. Klik op Downloaden of de inhoud ervan kopiëren.

    Belangrijk

    In dit voorbeeld wordt een Conda-omgeving gebruikt die is opgegeven bij /heart-classifier-mlflow/environment/conda.yaml. Dit bestand is gemaakt door het oorspronkelijke MLflow conda-afhankelijkhedenbestand te combineren en het pakket azureml-coretoe te voegen. U kunt het conda.yml bestand niet rechtstreeks vanuit het model gebruiken.

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

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

  4. De implementatie configureren:

    Als u een nieuwe implementatie wilt maken onder het gemaakte eindpunt, maakt u een YAML configuratie zoals hieronder. U kunt het YAML-schema voor het volledige batcheindpunt controleren op extra eigenschappen.

    implementatie-aangepast/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: heart-classifier-batch
name: classifier-xgboost-custom
description: A heart condition classifier based on XGBoost
type: model
model: azureml:heart-classifier-mlflow@latest
environment:
  name: batch-mlflow-xgboost
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
code_configuration:
  code: code
  scoring_script: batch_driver.py
compute: azureml:batch-cluster
resources:
  instance_count: 2
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 2
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 300
  error_threshold: -1
  logging_level: info

  5. We gaan nu de implementatie maken:

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

  6. Op dit moment is ons batcheindpunt gereed om te worden gebruikt.

Resources opschonen

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

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

Volgende stappen