MLflow-modellen implementeren op online-eindpunten

Artikel
02/02/2024

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

In dit artikel leert u hoe u uw MLflow-model implementeert in een online-eindpunt voor realtime deductie. Wanneer u uw MLflow-model implementeert op een online-eindpunt, hoeft u geen scorescript of een omgeving op te geven. Deze functionaliteit wordt ook wel implementatie zonder code genoemd.

Voor implementatie zonder code, Azure Machine Learning:

Python-pakketten die in het conda.yaml bestand zijn opgegeven, worden dynamisch geïnstalleerd. Daarom worden afhankelijkheden geïnstalleerd tijdens de containerruntime.
Biedt een MLflow-basisinstallatiekopieën/gecureerde omgeving die de volgende items bevat:
- azureml-inference-server-http
- mlflow-skinny
- Een scorescript voor deductie.

Tip

Werkruimten zonder openbare netwerktoegang: Voordat u MLflow-modellen kunt implementeren naar online-eindpunten zonder uitgaande connectiviteit, moet u de modellen verpakken (preview).< Door modelverpakkingen te gebruiken, kunt u voorkomen dat er een internetverbinding nodig is, waarvoor azure Machine Learning anders de benodigde Python-pakketten voor de MLflow-modellen dynamisch moet installeren.

Over het voorbeeld

In het voorbeeld ziet u hoe u een MLflow-model kunt implementeren op een online-eindpunt om voorspellingen uit te voeren. In het voorbeeld wordt een MLflow-model gebruikt dat is gebaseerd op de gegevensset Diabetes. Deze gegevensset bevat 10 basislijnvariabelen: leeftijd, geslacht, lichaamsmassaindex, gemiddelde bloeddruk en zes bloedserummetingen verkregen van 442 diabetespatiënten. Het bevat ook de reactie van belang, een kwantitatieve meting van ziektevoortgang één jaar na de basislijn.

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

De informatie 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 de opslagplaats en wijzigt u vervolgens mappen cliin , als u de Azure CLI gebruikt. Als u de Azure Machine Learning SDK voor Python gebruikt, wijzigt u de mappen in sdk/python/endpoints/online/mlflow.

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

Volgen in Jupyter Notebook

U kunt de stappen voor het gebruik van de Azure Machine Learning Python SDK volgen door het MLflow-model implementeren te openen in het notebook voor online-eindpunten in de gekloonde opslagplaats.

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.
Op rollen gebaseerd toegangsbeheer van Azure (Azure RBAC) wordt gebruikt om toegang te verlenen tot bewerkingen in Azure Machine Learning. Als u de stappen in dit artikel wilt uitvoeren, moet aan uw gebruikersaccount de rol eigenaar of inzender voor de Azure Machine Learning-werkruimte zijn toegewezen, of een aangepaste rol die toestaat Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Zie Toegang tot een Azure Machine Learning-werkruimte beheren voor meer informatie over rollen.
U moet een MLflow-model hebben geregistreerd in uw werkruimte. In dit artikel wordt een model geregistreerd dat is getraind voor de gegevensset Diabetes in de werkruimte.
U moet ook het volgende doen:
- Installeer de Azure CLI en de ml extensie in de Azure CLI. Zie De CLI (v2) installeren en instellen voor meer informatie over het installeren van de CLI.
- Installeer de Azure Machine Learning SDK voor Python.
```
pip install azure-ai-ml azure-identity
```
- Installeer het MLflow SDK-pakket mlflow en de Azure Machine Learning-invoegtoepassing voor MLflow azureml-mlflow.
```
pip install mlflow azureml-mlflow
```
- Als u geen code uitvoert in de Azure Machine Learning-berekening, configureert u de MLflow-tracerings-URI of de register-URI van MLflow om te verwijzen naar de Azure Machine Learning-werkruimte waaraan u werkt. Zie MLflow configureren voor Azure Machine Learning voor meer informatie over het verbinden van MLflow met de werkruimte.
Er zijn geen aanvullende vereisten voor het werken in Azure Machine Learning-studio.

Verbinding maken met uw werkruimte

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

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

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 maakt u verbinding met de werkruimte waarin u implementatietaken uitvoert.

Importeer de vereiste bibliotheken:

from azure.ai.ml import MLClient, Input
from azure.ai.ml.entities import (
ManagedOnlineEndpoint,
ManagedOnlineDeployment,
Model,
Environment,
CodeConfiguration,
)
from azure.identity import DefaultAzureCredential
from azure.ai.ml.constants import AssetTypes

Configureer werkruimtegegevens en haal een ingang op voor de werkruimte:

subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

De vereiste bibliotheken importeren

import json
import mlflow
import requests
import pandas as pd
from mlflow.deployments import get_deploy_client
from mlflow.tracking import MlflowClient

De MLflow-client initialiseren
```
mlflow_client = MlflowClient()
```

De implementatieclient configureren

deployment_client = get_deploy_client(mlflow.get_tracking_uri())

Het model registreren

U kunt alleen geregistreerde modellen implementeren op online-eindpunten. In dit geval hebt u al een lokale kopie van het model in de opslagplaats, dus u hoeft 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='sklearn-diabetes'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "endpoints/online/ncd/sklearn-diabetes/model"

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"
model = ml_client.models.create_or_update(
        Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"file://{model_local_path}"
)
version = registered_model.version

Wat gebeurt er als uw model is geregistreerd in een uitvoering?

Als uw model is geregistreerd in een uitvoering, kunt u het rechtstreeks registreren.

Als u het model wilt registreren, moet u weten waar het is opgeslagen. Als u de functie van autolog MLflow gebruikt, is het pad naar het model afhankelijk van het modeltype en het framework. Controleer de taakuitvoer om de naam van de map van het model te identificeren. Deze map bevat een bestand met de naam MLModel.

Als u de log_model methode gebruikt om uw modellen handmatig te registreren, geeft u het pad naar het model als argument door aan de methode. Als u bijvoorbeeld het model aanmeldt met behulp van mlflow.sklearn.log_model(my_model, "classifier"), wordt het pad waar het model is opgeslagen, aangeroepen classifier.

Gebruik de Azure Machine Learning CLI v2 om een model te maken op basis van de uitvoer van een trainingstaak. In het volgende voorbeeld wordt een model met de naam $MODEL_NAME geregistreerd met behulp van de artefacten van een taak met id $RUN_ID. Het pad waar het model is opgeslagen, is $MODEL_PATH.

az ml model create --name $MODEL_NAME --path azureml://jobs/$RUN_ID/outputs/artifacts/$MODEL_PATH

Notitie

Het pad $MODEL_PATH is de locatie waar het model is opgeslagen in de uitvoering.

model_name = 'sklearn-diabetes'

ml_client.models.create_or_update(
    Model(
        path=f"azureml://jobs/{RUN_ID}/outputs/artifacts/{MODEL_PATH}"
        name=model_name,
        type=AssetTypes.MLFLOW_MODEL
    )
)

Notitie

Het pad MODEL_PATH is de locatie waar het model is opgeslagen in de uitvoering.

model_name = 'sklearn-diabetes'

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"runs://{RUN_ID}/{MODEL_PATH}"
)
version = registered_model.version

Notitie

Het pad MODEL_PATH is de locatie waar het model is opgeslagen in de uitvoering.

Een MLflow-model implementeren op een online-eindpunt

Configureer het eindpunt waar het model wordt geïmplementeerd. In het volgende voorbeeld wordt de naam en verificatiemodus van het eindpunt geconfigureerd:

Stel een eindpuntnaam in door de volgende opdracht uit te voeren (vervang door YOUR_ENDPOINT_NAME een unieke naam):

export ENDPOINT_NAME="<YOUR_ENDPOINT_NAME>"

Configureer het eindpunt:

create-endpoint.yaml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: my-endpoint
auth_mode: key

# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint = ManagedOnlineEndpoint(
    name=endpoint_name,
    description="An online endpoint to generate predictions for the diabetes dataset",
    auth_mode="key",
    tags={"foo": "bar"},
)

U kunt de eigenschappen van dit eindpunt configureren met behulp van een configuratiebestand. In dit geval configureert u de verificatiemodus van het eindpunt als 'sleutel'.


# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint_config = {
    "auth_mode": "key",
    "identity": {
        "type": "system_assigned"
    }
}

Schrijf deze configuratie naar een JSON bestand:

endpoint_config_path = "endpoint_config.json"
with open(endpoint_config_path, "w") as outfile:
    outfile.write(json.dumps(endpoint_config))

Maak het eindpunt:

az ml online-endpoint create --name $ENDPOINT_NAME -f endpoints/online/ncd/create-endpoint.yaml

ml_client.begin_create_or_update(endpoint)

endpoint = deployment_client.create_endpoint(
    name=endpoint_name,
    config={"endpoint-config-file": endpoint_config_path},
)

Configureer de implementatie. Een implementatie is een set resources die vereist is voor het hosten van het model dat de werkelijke deductie uitvoert.

sklearn-deployment.yaml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-deployment
endpoint_name: my-endpoint
model:
  name: mir-sample-sklearn-ncd-model
  version: 1
  path: sklearn-diabetes/model
  type: mlflow_model
instance_type: Standard_DS3_v2
instance_count: 1

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1
)

Als uw eindpunt geen uitgaande connectiviteit heeft, kunt u ook modelverpakkingen (preview) gebruiken door het argument with_package=Trueop te geven:

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1,
    with_package=True,
)

blue_deployment_name = "blue"

Als u de hardwarevereisten van uw implementatie wilt configureren, maakt u een JSON-bestand met de gewenste configuratie:

deploy_config = {
    "instance_type": "Standard_F4s_v2",
    "instance_count": 1,
}

Notitie

Zie het beheerde online implementatieschema (v2) voor meer informatie over de volledige specificatie van deze configuratie.

Schrijf de configuratie naar een bestand:

deployment_config_path = "deployment_config.json"
with open(deployment_config_path, "w") as outfile:
    outfile.write(json.dumps(deploy_config))

Notitie

Automatische generatie van de scoring_script en environment worden alleen ondersteund voor pyfunc modelsmaak. Zie MLflow-modelimplementaties aanpassen om een andere modelsmaak te gebruiken.

De implementatie maken:
```
az ml online-deployment create --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
Als uw eindpunt geen uitgaande connectiviteit heeft, gebruikt u modelverpakking (preview) door de vlag --with-packageop te geven:
```
az ml online-deployment create --with-package --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
```
ml_client.online_deployments.begin_create_or_update(blue_deployment)
```
```
blue_deployment = deployment_client.create_deployment(
    name=blue_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)    
```
1. Selecteer op de pagina Eindpunten maken op het tabblad Realtime-eindpunten.
2. Kies het MLflow-model dat u eerder hebt geregistreerd en selecteer vervolgens de knop Selecteren .
  
  Notitie
  
  De configuratiepagina bevat een opmerking om u te laten weten dat het scorescript en de omgeving automatisch worden gegenereerd voor het geselecteerde MLflow-model.
3. Selecteer Nieuw om te implementeren naar een nieuw eindpunt.
4. Geef een naam op voor het eindpunt en de implementatie of behoud de standaardnamen.
5. Selecteer Implementeren om het model naar het eindpunt te implementeren.
Wijs al het verkeer toe aan de implementatie. Tot nu toe heeft het eindpunt één implementatie, maar er wordt geen verkeer aan het eindpunt toegewezen.
Deze stap is niet vereist in de Azure CLI, omdat u de vlag hebt gebruikt tijdens het --all-traffic maken. Als u verkeer wilt wijzigen, kunt u de opdracht az ml online-endpoint update --trafficgebruiken. Zie Verkeer geleidelijk bijwerken voor meer informatie over het bijwerken van verkeer.
```
endpoint.traffic = {"blue": 100}
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Schrijf de configuratie naar een bestand:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```
Deze stap is niet vereist in de studio.
Werk de eindpuntconfiguratie bij:
Deze stap is niet vereist in de Azure CLI, omdat u de vlag hebt gebruikt tijdens het --all-traffic maken. Als u verkeer wilt wijzigen, kunt u de opdracht az ml online-endpoint update --trafficgebruiken. Zie Verkeer geleidelijk bijwerken voor meer informatie over het bijwerken van verkeer.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```
Deze stap is niet vereist in de studio.

Het eindpunt aanroepen

Zodra uw implementatie gereed is, kunt u deze gebruiken om een aanvraag te verwerken. Een manier om de implementatie te testen, is door gebruik te maken van de ingebouwde aanroepfunctie in de implementatieclient die u gebruikt. De volgende JSON is een voorbeeldaanvraag voor de implementatie.

sample-request-sklearn.json

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

Notitie

input_data wordt in dit voorbeeld gebruikt in plaats van inputs dat wordt gebruikt in MLflow-server. Dit komt doordat Azure Machine Learning een andere invoerindeling vereist om automatisch de swagger-contracten voor de eindpunten te kunnen genereren. Zie Verschillen tussen modellen die zijn geïmplementeerd in ingebouwde Azure Machine Learning- en MLflow-server voor meer informatie over verwachte invoerindelingen.

Dien als volgt een aanvraag in bij het eindpunt:

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json

ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    request_file="sample-request-sklearn.json",
)

# Read the sample request that's in the json file to construct a pandas data frame
with open("sample-request-sklearn.json", "r") as f:
    sample_request = json.loads(f.read())
    samples = pd.DataFrame(**sample_request["input_data"])

deployment_client.predict(endpoint=endpoint_name, df=samples)

Het antwoord is vergelijkbaar met de volgende tekst:

[ 
  11633.100167144921,
  8522.117402884991
]

Belangrijk

Testen via lokale eindpunten wordt momenteel niet ondersteund voor MLflow-implementatie zonder code.

MLflow-modelimplementaties aanpassen

U hoeft geen scorescript op te geven in de implementatiedefinitie van een MLflow-model naar een online-eindpunt. U kunt er echter voor kiezen om dit te doen en aan te passen hoe deductie wordt uitgevoerd.

Doorgaans wilt u de implementatie van uw MLflow-model aanpassen wanneer:

Het model heeft PyFunc er geen smaak op.
U moet de manier waarop het model wordt uitgevoerd aanpassen, bijvoorbeeld om een specifieke smaak te gebruiken om het model te laden met behulp van mlflow.<flavor>.load_model().
U moet pre-/postverwerking 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.

Belangrijk

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

Stappen

Een MLflow-model implementeren met een aangepast scorescript:

Identificeer de map waar uw MLflow-model zich bevindt.

a. Ga naar de Azure Machine Learning Studio.

b. Ga naar de sectie Modellen .

c. Selecteer het model dat u wilt implementeren en ga naar het tabblad Artefacten .

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

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

Tip

Het volgende scorescript wordt gegeven als voorbeeld van het uitvoeren van deductie met een MLflow-model. U kunt dit script aanpassen aan uw behoeften of de onderdelen ervan aanpassen aan uw scenario.

score.py

import logging
import os
import json
import mlflow
from io import StringIO
from mlflow.pyfunc.scoring_server import infer_and_parse_json_input, predictions_to_json


def init():
    global model
    global input_schema
    # "model" is the path of the mlflow artifacts when the model was registered. For automl
    # models, this is generally "mlflow-model".
    model_path = os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model")
    model = mlflow.pyfunc.load_model(model_path)
    input_schema = model.metadata.get_input_schema()


def run(raw_data):
    json_data = json.loads(raw_data)
    if "input_data" not in json_data.keys():
        raise Exception("Request must contain a top level key named 'input_data'")

    serving_input = json.dumps(json_data["input_data"])
    data = infer_and_parse_json_input(serving_input, input_schema)
    predictions = model.predict(data)

    result = StringIO()
    predictions_to_json(predictions, result)
    return result.getvalue()

Waarschuwing

MLflow 2.0-advies: Het opgegeven scorescript werkt met zowel MLflow 1.X als MLflow 2.X. Houd er echter rekening mee dat de verwachte invoer-/uitvoerindelingen voor deze versies kunnen variëren. Controleer de omgevingsdefinitie die wordt gebruikt om ervoor te zorgen dat u de verwachte MLflow-versie gebruikt. U ziet dat MLflow 2.0 alleen wordt ondersteund in Python 3.8+.

Maak een omgeving waarin het scorescript kan worden uitgevoerd. Omdat het model een MLflow-model is, worden de conda-vereisten ook opgegeven in het modelpakket. Zie de MLmodel-indeling voor meer informatie over de bestanden die zijn opgenomen in een MLflow-model. Vervolgens bouwt u de omgeving met behulp van de conda-afhankelijkheden van het bestand. U moet echter ook het pakket azureml-inference-server-httpopnemen, dat vereist is voor online-implementaties in Azure Machine Learning.

Het conda-definitiebestand is als volgt:

conda.yml
```
channels:
- conda-forge
dependencies:
- python=3.9
- pip
- pip:
  - mlflow
  - scikit-learn==1.2.2
  - cloudpickle==2.2.1
  - psutil==5.9.4
  - pandas==2.0.0
  - azureml-inference-server-http
name: mlflow-env
```
Notitie

Het azureml-inference-server-http pakket is toegevoegd aan het oorspronkelijke conda-afhankelijkhedenbestand.

U gebruikt dit conda-afhankelijkhedenbestand om de omgeving te maken:
De omgeving wordt inline gemaakt in de implementatieconfiguratie.
```
environment = Environment(
    conda_file="sklearn-diabetes/environment/conda.yml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest",
)
```
Deze bewerking wordt niet ondersteund in MLflow SDK
1. Ga naar het tabblad Omgevingen in het zijmenu.
2. Selecteer het tabblad Aangepaste omgevingen>maken.
3. Voer in dit geval sklearn-mlflow-online-py37de naam van de omgeving in.
4. Kies voor Omgevingsbron selecteren de optie Bestaande Docker-installatiekopieën gebruiken met een optioneel Conda-bestand.
5. Voer voor containerregisterinstallatiekopieënpad het volgende inmcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04.
6. Selecteer Volgende om naar de sectie Aanpassen te gaan.
7. Kopieer de inhoud van het sklearn-diabetes/environment/conda.yml bestand en plak het in het tekstvak.
8. Selecteer Volgende om naar de pagina Tags te gaan en klik vervolgens nogmaals op Volgende .
9. Selecteer op de pagina Beoordelen de optie Maken. De omgeving is klaar voor gebruik.
De implementatie maken:
Maak een implementatieconfiguratiebestand deployment.yml:
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-diabetes-custom
endpoint_name: my-endpoint
model: azureml:sklearn-diabetes@latest
environment: 
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04
  conda_file: sklearn-diabetes/environment/conda.yml
code_configuration:
  code: sklearn-diabetes/src
  scoring_script: score.py
instance_type: Standard_F2s_v2
instance_count: 1
```
De implementatie maken:
```
az ml online-deployment create -f deployment.yml
```
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    environment=environment,
    code_configuration=CodeConfiguration(
        code="sklearn-diabetes/src",
        scoring_script="score.py"
    ),
    instance_type="Standard_F4s_v2",
    instance_count=1,
)
```
Deze bewerking wordt niet ondersteund in MLflow SDK
1. Selecteer +Maken op de pagina Eindpunten.
2. Selecteer het MLflow-model dat u eerder hebt geregistreerd.
3. Selecteer Meer opties in de wizard Voor het maken van eindpunten om geavanceerde opties te openen.
4. Geef een naam en verificatietype op voor het eindpunt en selecteer vervolgens Volgende om te zien dat het geselecteerde model wordt gebruikt voor uw implementatie.
5. Selecteer Volgendeom door te gaan naar de pagina _Implementatie.
6. Selecteer Volgende om naar de pagina Code en omgeving te gaan. Wanneer u een model selecteert dat is geregistreerd in MLflow-indeling, hoeft u geen scorescript of een omgeving op deze pagina op te geven. U wilt er echter een opgeven in deze sectie
7. Selecteer de schuifregelaar naast Omgeving aanpassen en scorescript.
8. Blader om het scorescript te selecteren dat u eerder hebt gemaakt.
9. Selecteer Aangepaste omgevingen voor het omgevingstype .
10. Selecteer de aangepaste omgeving die u eerder hebt gemaakt en selecteer Volgende.
11. Voltooi de wizard om het model naar het eindpunt te implementeren.
Zodra de implementatie is voltooid, kunt u aanvragen verwerken. Een manier om de implementatie te testen, is door een voorbeeldaanvraagbestand samen met de invoke methode te gebruiken.

sample-request-sklearn.json
```
{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}
```
Dien als volgt een aanvraag in bij het eindpunt:
```
az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json
```
```
ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    request_file="sample-request-sklearn.json",
)
```
Deze bewerking wordt niet ondersteund in MLflow SDK
1. Ga naar het tabblad Eindpunten en selecteer het nieuwe eindpunt dat is gemaakt.
2. Ga naar het tabblad Testen .
3. Plak de inhoud van het sample-request-sklearn.json bestand in het invoergegevensvak om het eindpuntvak te testen.
4. Selecteer Testen.
5. De voorspellingen worden weergegeven onder Testresultaten aan de rechterkant van het vak.
Het antwoord is vergelijkbaar met de volgende tekst:
```
{
  "predictions": [ 
    11633.100167144921,
    8522.117402884991
  ]
}
```
Waarschuwing

MLflow 2.0 advies: In MLflow 1.X ontbreekt de predictions sleutel.

Resources opschonen

Wanneer u klaar bent met het gebruik van het eindpunt, verwijdert u de bijbehorende resources:

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

ml_client.online_endpoints.begin_delete(endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

MLflow-modellen implementeren op online-eindpunten

Over het voorbeeld

Volgen in Jupyter Notebook

Vereisten

Verbinding maken met uw werkruimte

Het model registreren

Wat gebeurt er als uw model is geregistreerd in een uitvoering?

Een MLflow-model implementeren op een online-eindpunt

Het eindpunt aanroepen

MLflow-modelimplementaties aanpassen

Stappen

Resources opschonen

Gerelateerde inhoud

Aanvullende resources