Progressieve implementatie van MLflow-modellen voor online-eindpunten

Artikel
09/02/2024

In dit artikel leert u hoe u MLflow-modellen geleidelijk kunt bijwerken en implementeren in Online-eindpunten zonder dat dit serviceonderbreking veroorzaakt. U gebruikt blauwgroene implementatie, ook wel een veilige implementatiestrategie genoemd, om een nieuwe versie van een webservice in productie te introduceren. Met deze strategie kunt u uw nieuwe versie van de webservice implementeren voor een kleine subset van gebruikers of aanvragen voordat u deze volledig uitrolt.

Over dit voorbeeld

Online-eindpunten hebben het concept eindpunt en implementatie. Een eindpunt vertegenwoordigt de API die klanten gebruiken om het model te gebruiken, terwijl de implementatie de specifieke implementatie van die API aangeeft. Met dit onderscheid kunnen gebruikers de API loskoppelen van de implementatie en de onderliggende implementatie wijzigen zonder dat dit van invloed is op de consument. In dit voorbeeld worden dergelijke concepten gebruikt om het geïmplementeerde model in eindpunten bij te werken zonder serviceonderbreking te introduceren.

Het model dat we gaan implementeren, is gebaseerd op 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 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.

De informatie in dit artikel is gebaseerd op codevoorbeelden in de opslagplaats azureml-examples . Als u de opdrachten lokaal wilt uitvoeren zonder bestanden te hoeven kopiëren/plakken, kloont u de opslagplaats en wijzigt u de mappen sdk/using-mlflow/deployin .

Volgen in Jupyter Notebooks

U kunt dit voorbeeld volgen in de volgende notebooks. Open in de gekloonde opslagplaats het notebook: mlflow_sdk_online_endpoints_progresive.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.
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 zijn toegewezen voor de Azure Machine Learning-werkruimte, of aan een aangepaste rol die Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*toestaat. Zie Toegang tot een Azure Machine Learning-werkruimte beheren voor meer informatie.

Daarnaast moet u het volgende doen:

Installeer de Azure CLI en de ml-extensie in de Azure CLI. Zie De CLI (v2) installeren, instellen en gebruiken voor meer informatie.

Installeer het Mlflow SDK-pakket mlflow en de Azure Machine Learning-invoegtoepassing voor MLflow azureml-mlflow.
```
pip install mlflow azureml-mlflow
```
Als u niet in Azure Machine Learning Compute werkt, configureert u de MLflow-tracerings-URI of de register-URI van MLflow om te verwijzen naar de werkruimte waaraan u werkt. Meer informatie over het configureren van MLflow voor Azure Machine Learning.

Verbinding maken met uw werkruimte

Eerst gaan we verbinding maken met de Azure Machine Learning-werkruimte waaraan we gaan werken.

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 maken we 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
from azure.ai.ml.constants import AssetTypes
from azure.identity import DefaultAzureCredential

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

Configureer de MLflow-client en de implementatieclient:

mlflow_client = mlflow.MLflowClient()
deployment_client = get_deploy_client(mlflow.get_tracking_uri())

Het model registreren in het register

Zorg ervoor dat uw model is geregistreerd in het Azure Machine Learning-register. Implementatie van niet-geregistreerde modellen wordt niet ondersteund in Azure Machine Learning. U kunt een nieuw model registreren met behulp van de MLflow SDK:

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

model_name = 'heart-classifier'
model_local_path = "model"

model = ml_client.models.create_or_update(
     Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

model_name = 'heart-classifier'
model_local_path = "model"

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

Een online-eindpunt maken

Online-eindpunten zijn eindpunten die worden gebruikt voor onlinedeductie (realtime). Online-eindpunten bevatten implementaties die gereed zijn om gegevens van clients te ontvangen en die reacties in realtime kunnen terugsturen.

We gaan deze functionaliteit benutten door meerdere versies van hetzelfde model onder hetzelfde eindpunt te implementeren. De nieuwe implementatie ontvangt echter 0% van het verkeer bij het smeken. Zodra we zeker weten dat het nieuwe model correct werkt, gaan we het verkeer van de ene implementatie naar de andere geleidelijk verplaatsen.

Eindpunten vereisen een naam, die uniek moet zijn in dezelfde regio. Laten we ervoor zorgen dat u er een maakt die niet bestaat:

ENDPOINT_SUFIX=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w ${1:-5} | head -n 1)
ENDPOINT_NAME="heart-classifier-$ENDPOINT_SUFIX"

import random
import string

# Creating a unique endpoint name by including a random suffix
allowed_chars = string.ascii_lowercase + string.digits
endpoint_suffix = "".join(random.choice(allowed_chars) for x in range(5))
endpoint_name = "heart-classifier-" + endpoint_suffix

print(f"Endpoint name: {endpoint_name}")

import random
import string

# Creating a unique endpoint name by including a random suffix
allowed_chars = string.ascii_lowercase + string.digits
endpoint_suffix = "".join(random.choice(allowed_chars) for x in range(5))
endpoint_name = "heart-classifier-" + endpoint_suffix

print(f"Endpoint name: {endpoint_name}")

Het eindpunt configureren

endpoint.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: heart-classifier-edp
auth_mode: key

endpoint = ManagedOnlineEndpoint(
    name=endpoint_name,
    description="An endpoint to serve predictions of the UCI heart disease problem",
    auth_mode="key",
)

We kunnen de eigenschappen van dit eindpunt configureren met behulp van een configuratiebestand. In het volgende voorbeeld configureren we de verificatiemodus van het eindpunt als sleutel:

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

Laten we deze configuratie naar een JSON bestand schrijven:

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 -n $ENDPOINT_NAME -f endpoint.yml

ml_client.online_endpoints.begin_create_or_update(endpoint).result()

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

Het verificatiegeheim voor het eindpunt ophalen.
```
ENDPOINT_SECRET_KEY=$(az ml online-endpoint get-credentials -n $ENDPOINT_NAME | jq -r ".accessToken")
```
```
endpoint_secret_key = ml_client.online_endpoints.list_keys(
    name=endpoint_name
).access_token
```
Deze functionaliteit is niet beschikbaar in de MLflow SDK. Ga naar Azure Machine Learning-studio, navigeer naar het eindpunt en haal daar de geheime sleutel op.

Een blauwe implementatie maken

Tot nu toe is het eindpunt leeg. Er zijn geen implementaties op. We gaan de eerste maken door hetzelfde model te implementeren waarop we eerder hebben gewerkt. We noemen deze implementatie 'standaard', die onze 'blauwe implementatie' vertegenwoordigt.

De implementatie configureren

blue-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: default
endpoint_name: heart-classifier-edp
model: azureml:heart-classifier@latest
instance_type: Standard_DS2_v2
instance_count: 1

blue_deployment_name = "default"

Configureer de hardwarevereisten van uw implementatie:

blue_deployment = ManagedOnlineDeployment(
    name=blue_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Als uw eindpunt geen uitgaande connectiviteit heeft, gebruikt u modelverpakking (preview) door het argument with_package=Trueop te geven:

blue_deployment = ManagedOnlineDeployment(
    name=blue_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
    with_package=True,
)

blue_deployment_name = "default"

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

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

Notitie

De volledige specificatie van deze configuratie vindt u in het beheerde online implementatieschema (v2).

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))

De implementatie maken

az ml online-deployment create --endpoint-name $ENDPOINT_NAME -f blue-deployment.yml --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 --endpoint-name $ENDPOINT_NAME -f blue-deployment.yml --all-traffic

Tip

We stellen de vlag --all-traffic in de opdracht maken in, waarmee al het verkeer wordt toegewezen aan de nieuwe implementatie.

ml_client.online_deployments.begin_create_or_update(blue_deployment).result()

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},
)

Al het verkeer toewijzen aan de implementatie

Tot nu toe heeft het eindpunt één implementatie, maar er wordt geen verkeer aan het eindpunt toegewezen. Laten we het toewijzen.
Deze stap is niet vereist in de Azure CLI omdat we de stap tijdens het --all-traffic maken hebben gebruikt.
```
endpoint.traffic = { blue_deployment_name: 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))
```
Werk de eindpuntconfiguratie bij:
Deze stap is niet vereist in de Azure CLI omdat we de stap tijdens het --all-traffic maken hebben gebruikt.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```

Een voorbeeldinvoer maken om de implementatie te testen

sample.yml

{
    "input_data": {
        "columns": [
            "age",
            "sex",
            "cp",
            "trestbps",
            "chol",
            "fbs",
            "restecg",
            "thalach",
            "exang",
            "oldpeak",
            "slope",
            "ca",
            "thal"
        ],
        "data": [
            [ 48, 0, 3, 130, 275, 0, 0, 139, 0, 0.2, 1, 0, "normal" ]
        ]
    }
}

Met de volgende codevoorbeelden 5 waarnemingen uit de trainingsgegevensset verwijdert u de target kolom (zoals het model dit voorspelt) en wordt er een aanvraag gemaakt in het bestand sample.json dat kan worden gebruikt met de modelimplementatie.

samples = (
    pd.read_csv("data/heart.csv")
    .sample(n=5)
    .drop(columns=["target"])
    .reset_index(drop=True)
)

with open("sample.json", "w") as f:
    f.write(
        json.dumps(
            {"input_data": json.loads(samples.to_json(orient="split", index=False))}
        )
    )

De volgende codevoorbeelden 5 waarnemingen uit de trainingsgegevensset, verwijdert de target kolom (zoals het model dit voorspelt) en maakt een aanvraag.

samples = (
    pd.read_csv("data/heart.csv")
    .sample(n=5)
    .drop(columns=["target"])
    .reset_index(drop=True)
)

De implementatie testen

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file sample.json

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

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

Een groene implementatie maken onder het eindpunt

Stel dat er een nieuwe versie van het model is gemaakt door het ontwikkelteam en klaar is om in productie te zijn. We kunnen eerst proberen om dit model te vliegen en zodra we vertrouwen, kunnen we het eindpunt bijwerken om het verkeer naar het model te routeren.

Een nieuwe modelversie registreren

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

Laten we het versienummer van het nieuwe model ophalen:

VERSION=$(az ml model show -n heart-classifier --label latest | jq -r ".version")

model_name = 'heart-classifier'
model_local_path = "model"

model = ml_client.models.create_or_update(
     Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)
version = model.version

model_name = 'heart-classifier'
model_local_path = "model"

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

Een nieuwe implementatie configureren

green-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: xgboost-model
endpoint_name: heart-classifier-edp
model: azureml:heart-classifier@latest
instance_type: Standard_DS2_v2
instance_count: 1

We noemen de implementatie als volgt:

GREEN_DEPLOYMENT_NAME="xgboost-model-$VERSION"

green_deployment_name = f"xgboost-model-{version}"

Configureer de hardwarevereisten van uw implementatie:

green_deployment = ManagedOnlineDeployment(
    name=green_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Als uw eindpunt geen uitgaande connectiviteit heeft, gebruikt u modelverpakking (preview) door het argument with_package=Trueop te geven:

green_deployment = ManagedOnlineDeployment(
    name=green_deployment_name,
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_DS2_v2",
    instance_count=1,
    with_package=True,
)

green_deployment_name = f"xgboost-model-{version}"

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

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

Tip

We gebruiken dezelfde hardwarebevestiging die wordt aangegeven in de deployment-config-file. Er zijn echter geen vereisten om dezelfde configuratie te hebben. U kunt verschillende hardware voor verschillende modellen configureren, afhankelijk van de vereisten.

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))

De nieuwe implementatie maken

az ml online-deployment create -n $GREEN_DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME -f green-deployment.yml

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 -n $GREEN_DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME -f green-deployment.yml

ml_client.online_deployments.begin_create_or_update(green_deployment).result()

new_deployment = deployment_client.create_deployment(
    name=green_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)

De implementatie testen zonder verkeer te wijzigen

az ml online-endpoint invoke --name $ENDPOINT_NAME --deployment-name $GREEN_DEPLOYMENT_NAME --request-file sample.json

ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=green_deployment_name
    request_file="sample.json",
)

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

Tip

U ziet nu hoe we de naam aangeven van de implementatie die we willen aanroepen.

Het verkeer geleidelijk bijwerken

Een implementatie die we vertrouwen hebben, kunnen we het verkeer bijwerken om een deel ervan naar de nieuwe implementatie te leiden. Verkeer is geconfigureerd op eindpuntniveau:

Configureer het verkeer:

Deze stap is niet vereist in de Azure CLI

endpoint.traffic = {blue_deployment_name: 90, green_deployment_name: 10}

traffic_config = {"traffic": {blue_deployment_name: 90, green_deployment_name: 10}}

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))

Het eindpunt bijwerken

az ml online-endpoint update --name $ENDPOINT_NAME --traffic "default=90 $GREEN_DEPLOYMENT_NAME=10"

ml_client.begin_create_or_update(endpoint).result()

deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)

Als u besluit het hele verkeer over te schakelen naar de nieuwe implementatie, werkt u al het verkeer bij:

Deze stap is niet vereist in de Azure CLI

endpoint.traffic = {blue_deployment_name: 0, green_deployment_name: 100}

traffic_config = {"traffic": {blue_deployment_name: 0, green_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))

Het eindpunt bijwerken

az ml online-endpoint update --name $ENDPOINT_NAME --traffic "default=0 $GREEN_DEPLOYMENT_NAME=100"

ml_client.begin_create_or_update(endpoint).result()

deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)

Omdat de oude implementatie geen verkeer ontvangt, kunt u deze veilig verwijderen:
```
az ml online-deployment delete --endpoint-name $ENDPOINT_NAME --name default
```
```
ml_client.online_deployments.begin_delete(
    name=blue_deployment_name, 
    endpoint_name=endpoint_name
)
```
```
deployment_client.delete_deployment(
    blue_deployment_name, 
    endpoint=endpoint_name
)
```
Tip

U ziet dat op dit moment de voormalige 'blauwe implementatie' is verwijderd en dat de nieuwe 'groene implementatie' de plaats van de 'blauwe implementatie' heeft genomen.

Resources opschonen

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

ml_client.online_endpoints.begin_delete(name=endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

Belangrijk

Als u een eindpunt verwijdert, worden ook alle implementaties eronder verwijderd.

Delen via

Progressieve implementatie van MLflow-modellen voor online-eindpunten

Over dit voorbeeld

Volgen in Jupyter Notebooks

Vereisten

Verbinding maken met uw werkruimte

Het model registreren in het register

Een online-eindpunt maken

Een blauwe implementatie maken

Een groene implementatie maken onder het eindpunt

Het verkeer geleidelijk bijwerken

Resources opschonen

Volgende stappen

Feedback

Aanvullende resources