Progressiv distribution av MLflow-modeller till onlineslutpunkter

2024-11-23

I den här artikeln får du lära dig hur du progressivt kan uppdatera och distribuera MLflow-modeller till onlineslutpunkter utan att orsaka avbrott i tjänsten. Du använder blågrön distribution, även kallad säker distributionsstrategi, för att introducera en ny version av en webbtjänst i produktion. Med den här strategin kan du distribuera din nya version av webbtjänsten till en liten delmängd av användare eller begäranden innan du distribuerar den helt.

Om det här exemplet

Onlineslutpunkter har begreppet Slutpunkt och distribution. En slutpunkt representerar det API som kunder använder för att använda modellen, medan distributionen anger den specifika implementeringen av api:et. Den här skillnaden gör det möjligt för användare att frikoppla API:et från implementeringen och ändra den underliggande implementeringen utan att påverka konsumenten. Det här exemplet använder sådana begrepp för att uppdatera den distribuerade modellen i slutpunkter utan att införa tjänststörningar.

Den modell som vi ska distribuera baseras på datauppsättningen för UCI-hjärtsjukdomar. Databasen innehåller 76 attribut, men vi använder en delmängd av 14 av dem. Modellen försöker förutsäga förekomsten av hjärtsjukdomar hos en patient. Det är heltalsvärde från 0 (ingen närvaro) till 1 (närvaro). Den har tränats med en XGBBoost klassificerare och all nödvändig förbearbetning har paketerats som en scikit-learn pipeline, vilket gör den här modellen till en pipeline från slutpunkt till slutpunkt som går från rådata till förutsägelser.

Informationen i den här artikeln baseras på kodexempel som finns i lagringsplatsen azureml-examples . Om du vill köra kommandona lokalt utan att behöva kopiera/klistra in filer klonar du lagringsplatsen och ändrar sedan katalogerna till sdk/using-mlflow/deploy.

Följ med i Jupyter Notebooks

Du kan följa det här exemplet i följande notebook-filer. Öppna notebook-filen på den klonade lagringsplatsen: mlflow_sdk_online_endpoints_progresive.ipynb.

Prerequisites

Innan du följer stegen i den här artikeln kontrollerar du att du har följande förutsättningar:

En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Machine Learning.
Rollbaserade åtkomstkontroller i Azure (Azure RBAC) används för att bevilja åtkomst till åtgärder i Azure Machine Learning. Om du vill utföra stegen i den här artikeln måste ditt användarkonto tilldelas rollen ägare eller deltagare för Azure Machine Learning-arbetsytan, eller en anpassad roll som tillåter Microsoft.MachineLearningServices/arbetsytor/onlineEndpoints/*. Mer information finns i Hantera åtkomst till en Azure Machine Learning-arbetsyta.

Dessutom måste du:

Installera Azure CLI och ml-tillägget till Azure CLI. Mer information finns i Installera, konfigurera och använda CLI (v2).

Installera Mlflow SDK-paketet mlflow och Azure Machine Learning-plugin-programmet för MLflow azureml-mlflow.
```
pip install mlflow azureml-mlflow
```
Om du inte kör i Azure Machine Learning-beräkning konfigurerar du URI:n för MLflow-spårning eller MLflows register-URI så att den pekar på den arbetsyta som du arbetar med. Lär dig hur du konfigurerar MLflow för Azure Machine Learning.

Anslut till din arbetsyta

Först ska vi ansluta till Azure Machine Learning-arbetsytan där vi ska arbeta med.

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

Arbetsytan är resursen på den översta nivån i Azure Machine Learning, och är en central plats där du kan arbeta med alla artefakter du skapar när du använder Azure Machine Learning. I det här avsnittet ansluter vi till arbetsytan där du ska utföra distributionsuppgifter.

Importera de bibliotek som krävs:

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

Konfigurera information om arbetsytan och få ett handtag till arbetsytan:

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

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

Importera nödvändiga bibliotek

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

Konfigurera MLflow-klienten och distributionsklienten:

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

Registrera modellen i registret

Kontrollera att din modell är registrerad i Azure Machine Learning-registret. Distribution av oregistrerade modeller stöds inte i Azure Machine Learning. Du kan registrera en ny modell med hjälp av 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

Skapa en onlineslutpunkt

Onlineslutpunkter är slutpunkter som används för onlineinferenser (realtid). Onlineslutpunkter innehåller distributioner som är redo att ta emot data från klienter och kan skicka svar i realtid.

Vi kommer att utnyttja den här funktionen genom att distribuera flera versioner av samma modell under samma slutpunkt. Den nya distributionen tar dock emot 0 % av trafiken vid tiggeriet. När vi är säkra på att den nya modellen fungerar korrekt kommer vi att gradvis flytta trafik från en distribution till en annan.

Slutpunkter kräver ett namn som måste vara unikt i samma region. Nu ska vi se till att skapa en som inte finns:

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

Konfigurera slutpunkten

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

Vi kan konfigurera egenskaperna för den här slutpunkten med hjälp av en konfigurationsfil. Vi konfigurerar autentiseringsläget för slutpunkten som "nyckel" i följande exempel:

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

Nu ska vi skriva den här konfigurationen till en JSON fil:

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

Skapa slutpunkten:

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

Hämta autentiseringshemligheten för slutpunkten.
```
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
```
Den här funktionen är inte tillgänglig i MLflow SDK. Gå till Azure Machine Learning-studio, navigera till slutpunkten och hämta den hemliga nyckeln därifrån.

Skapa en blå distribution

Än så länge är slutpunkten tom. Det finns inga distributioner på den. Nu ska vi skapa den första genom att distribuera samma modell som vi arbetade med tidigare. Vi kallar den här distributionen "standard", som representerar vår "blå distribution".

Konfigurera distributionen

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"

Konfigurera maskinvarukraven för distributionen:

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

blue_deployment_name = "default"

För att konfigurera maskinvarukraven för distributionen måste du skapa en JSON-fil med önskad konfiguration:

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

Note

Den fullständiga specifikationen för den här konfigurationen finns i Hanterat onlinedistributionsschema (v2).

Skriv konfigurationen till en fil:

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

Skapa distributionen

az ml online-deployment create --endpoint-name $ENDPOINT_NAME -f blue-deployment.yml --all-traffic

Om slutpunkten inte har utgående anslutning använder du modellpaketering (förhandsversion) genom att inkludera flaggan --with-package:

az ml online-deployment create --with-package --endpoint-name $ENDPOINT_NAME -f blue-deployment.yml --all-traffic

Tip

Vi anger flaggan --all-traffic i kommandot create, som tilldelar all trafik till den nya distributionen.

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

Tilldela all trafik till distributionen

Än så länge har slutpunkten en distribution, men ingen av dess trafik har tilldelats den. Vi tilldelar den.
Det här steget krävs inte i Azure CLI eftersom vi använde --all-traffic när vi skapade.
```
endpoint.traffic = { blue_deployment_name: 100 }
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Skriv konfigurationen till en fil:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```
Uppdatera slutpunktskonfigurationen:
Det här steget krävs inte i Azure CLI eftersom vi använde --all-traffic när vi skapade.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```

Skapa ett exempel på indata för att testa distributionen

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" ]
        ]
    }
}

Följande kodexempel 5 observationer från träningsdatauppsättningen target tar bort kolumnen (som modellen förutsäger den) och skapar en begäran i filen sample.json som kan användas med modelldistributionen.

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

Följande kodexempel 5 observationer från träningsdatauppsättningen target , tar bort kolumnen (som modellen förutsäger den) och skapar en begäran.

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

Testa distributionen

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
)

Skapa en grön distribution under slutpunkten

Anta att det finns en ny version av modellen som skapats av utvecklingsteamet och att den är redo att vara i produktion. Vi kan först försöka flyga den här modellen och när vi är säkra kan vi uppdatera slutpunkten för att dirigera trafiken till den.

Registrera en ny modellversion

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

Nu ska vi hämta versionsnumret för den nya modellen:

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

Konfigurera en ny distribution

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

Vi namnger distributionen på följande sätt:

GREEN_DEPLOYMENT_NAME="xgboost-model-$VERSION"

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

Konfigurera maskinvarukraven för distributionen:

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

Om slutpunkten inte har utgående anslutning använder du modellpaketering (förhandsversion) genom att inkludera argumentet with_package=True:

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}"

För att konfigurera maskinvarukraven för distributionen måste du skapa en JSON-fil med önskad konfiguration:

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

Tip

Vi använder samma maskinvarubekräftelse som anges i deployment-config-file. Det finns dock inga krav på att ha samma konfiguration. Du kan konfigurera olika maskinvara för olika modeller beroende på kraven.

Skriv konfigurationen till en fil:

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

Skapa den nya distributionen

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

Om slutpunkten inte har utgående anslutning använder du modellpaketering (förhandsversion) genom att inkludera flaggan --with-package:

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

Testa distributionen utan att ändra trafik

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

Observera hur vi nu anger namnet på den distribution som vi vill anropa.

Uppdatera trafiken progressivt

Som vi är säkra på med den nya distributionen kan vi uppdatera trafiken för att dirigera en del av den till den nya distributionen. Trafiken konfigureras på slutpunktsnivå:

Konfigurera trafiken:

Det här steget krävs inte i Azure CLI

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

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

Skriv konfigurationen till en fil:

traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))

Uppdatera slutpunkten

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

Om du bestämmer dig för att växla hela trafiken till den nya distributionen uppdaterar du all trafik:

Det här steget krävs inte i Azure CLI

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

traffic_config = {"traffic": {blue_deployment_name: 0, green_deployment_name: 100}}

Skriv konfigurationen till en fil:

traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))

Uppdatera slutpunkten

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

Eftersom den gamla distributionen inte tar emot någon trafik kan du ta bort den på ett säkert sätt:
```
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

Observera att den tidigare "blå distributionen" nu har tagits bort och att den nya "gröna distributionen" har ersatts av den "blå distributionen".

Rensa resurser

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

ml_client.online_endpoints.begin_delete(name=endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

Important

Observera att borttagning av en slutpunkt även tar bort alla distributioner under den.

Nästa steg

Feedback

Var den här sidan till hjälp?

Dela via

Progressiv distribution av MLflow-modeller till onlineslutpunkter

Om det här exemplet

Följ med i Jupyter Notebooks

Prerequisites

Anslut till din arbetsyta

Registrera modellen i registret

Skapa en onlineslutpunkt

Skapa en blå distribution

Skapa en grön distribution under slutpunkten

Uppdatera trafiken progressivt

Rensa resurser

Nästa steg

Feedback

Ytterligare resurser