Progresywne wdrażanie modeli MLflow w punktach końcowych online

Artykuł
10/19/2023

W tym artykule dowiesz się, jak stopniowo aktualizować i wdrażać modele MLflow w punktach końcowych online bez powodowania zakłóceń w działaniu usługi. W celu wprowadzenia nowej wersji usługi internetowej do środowiska produkcyjnego należy użyć wdrożenia niebieskiego zielonego, znanego również jako strategia bezpiecznego wdrażania. Ta strategia umożliwi wdrożenie nowej wersji usługi internetowej w małym podzestawie użytkowników lub żądań przed całkowitym wdrożeniem tej wersji.

Informacje o tym przykładzie

Punkty końcowe online mają koncepcję punktu końcowego i wdrożenia. Punkt końcowy reprezentuje interfejs API używany przez klientów do korzystania z modelu, a wdrożenie wskazuje konkretną implementację tego interfejsu API. To rozróżnienie umożliwia użytkownikom oddzielenie interfejsu API od implementacji i zmianę podstawowej implementacji bez wpływu na użytkownika. W tym przykładzie takie pojęcia będą używane do aktualizowania wdrożonego modelu w punktach końcowych bez wprowadzania zakłóceń w usłudze.

Model, który wdrożymy, jest oparty na zestawie danych choroby serca UCI. Baza danych zawiera 76 atrybutów, ale używamy podzestawu 14 z nich. Model próbuje przewidzieć obecność choroby serca u pacjenta. Jest to liczba całkowita z zakresu od 0 (brak obecności) do 1 (obecność). Został on wytrenowany przy użyciu XGBBoost klasyfikatora, a wszystkie wymagane przetwarzanie wstępne zostało spakowane jako potok, dzięki czemu ten model jest potokiem kompleksowego scikit-learn , który przechodzi od nieprzetworzonych danych do przewidywań.

Informacje przedstawione w tym artykule są oparte na przykładach kodu zawartych w repozytorium azureml-examples . Aby uruchomić polecenia lokalnie bez konieczności kopiowania/wklejania plików, sklonuj repozytorium, a następnie zmień katalogi na sdk/using-mlflow/deploy.

Postępuj zgodnie z instrukcjami w notesach Jupyter Notebook

Możesz wykonać czynności opisane w tym przykładzie w poniższych notesach. W sklonowanym repozytorium otwórz notes: mlflow_sdk_online_endpoints_progresive.ipynb.

Wymagania wstępne

Przed wykonaniem kroków opisanych w tym artykule upewnij się, że masz następujące wymagania wstępne:

Subskrypcja platformy Azure. Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto. Wypróbuj bezpłatną lub płatną wersję usługi Azure Machine Edukacja.
Kontrola dostępu na podstawie ról platformy Azure (Azure RBAC): jest używana do udzielania dostępu do operacji w usłudze Azure Machine Learning. Aby wykonać kroki opisane w tym artykule, twoje konto użytkownika musi mieć przypisaną rolę właściciela lub współautora dla obszaru roboczego usługi Azure Machine Edukacja lub rolę niestandardową zezwalającą na korzystanie z usługi Microsoft.Machine Edukacja Services/workspaces/onlineEndpoints/*. Aby uzyskać więcej informacji, zobacz Zarządzanie dostępem do obszaru roboczego usługi Azure Machine Edukacja.

Ponadto należy wykonać następujące kroki:

Zainstaluj interfejs wiersza polecenia platformy Azure i rozszerzenie ml w interfejsie wiersza polecenia platformy Azure. Aby uzyskać więcej informacji, zobacz Instalowanie, konfigurowanie i używanie interfejsu wiersza polecenia (wersja 2).

Zainstaluj pakiet mlflow zestawu MLflow SDK i wtyczkę usługi Azure Machine Edukacja dla platformy MLflowazureml-mlflow.
```
pip install mlflow azureml-mlflow
```
Jeśli nie korzystasz z usługi Azure Machine Edukacja obliczeniowych, skonfiguruj identyfikator URI śledzenia MLflow lub identyfikator URI rejestru MLflow, aby wskazać obszar roboczy, nad którym pracujesz. Dowiedz się, jak skonfigurować platformę MLflow dla usługi Azure Machine Edukacja.

Nawiązywanie połączenia z obszarem roboczym

Najpierw nawiążmy połączenie z usługą Azure Machine Edukacja obszarem roboczym, w którym będziemy pracować.

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

Obszar roboczy jest zasobem najwyższego poziomu dla usługi Azure Machine Learning, który udostępnia scentralizowane miejsce do pracy z wszystkimi tworzonymi podczas korzystania usługi Azure Machine Learning artefaktami. W tej sekcji połączymy się z obszarem roboczym, w którym wykonasz zadania wdrażania.

Zaimportuj wymagane biblioteki:

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

Konfigurowanie szczegółów obszaru roboczego i uzyskiwanie dojścia do obszaru roboczego:

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

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

Importowanie wymaganych bibliotek

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

Skonfiguruj klienta MLflow i klienta wdrażania:

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

Rejestrowanie modelu w rejestrze

Upewnij się, że model jest zarejestrowany w rejestrze usługi Azure Machine Edukacja. Wdrażanie niezarejestrowanych modeli nie jest obsługiwane w usłudze Azure Machine Edukacja. Nowy model można zarejestrować przy użyciu zestawu 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

Tworzenie punktu końcowego online

Punkty końcowe online to punkty końcowe używane do wnioskowania online (w czasie rzeczywistym). Punkty końcowe online zawierają wdrożenia, które są gotowe do odbierania danych od klientów i mogą wysyłać odpowiedzi w czasie rzeczywistym.

Wykorzystamy tę funkcję, wdrażając wiele wersji tego samego modelu w ramach tego samego punktu końcowego. Jednak nowe wdrożenie otrzyma 0% ruchu podczas sugerowania. Po upewnieniu się, że nowy model działa prawidłowo, będziemy stopniowo przenosić ruch z jednego wdrożenia do drugiego.

Punkty końcowe wymagają nazwy, która musi być unikatowa w tym samym regionie. Upewnijmy się, że utworzymy taki, który nie istnieje:

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

Konfigurowanie punktu końcowego

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

Możemy skonfigurować właściwości tego punktu końcowego przy użyciu pliku konfiguracji. W poniższym przykładzie skonfigurujemy tryb uwierzytelniania punktu końcowego jako "klucz":

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

Zapiszmy tę konfigurację JSON w pliku:

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

Utwórz punkt końcowy:

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

Uzyskiwanie wpisu tajnego uwierzytelniania dla punktu końcowego.
```
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
```
Ta funkcja nie jest dostępna w zestawie MLflow SDK. Przejdź do usługi Azure Machine Edukacja Studio, przejdź do punktu końcowego i pobierz klucz tajny z tego miejsca.

Tworzenie niebieskiego wdrożenia

Do tej pory punkt końcowy jest pusty. Nie ma na nim wdrożeń. Utwórzmy pierwszy, wdrażając ten sam model, nad którymi wcześniej pracowaliśmy. Wywołamy to wdrożenie "domyślne", reprezentując nasze "niebieskie wdrożenie".

Konfigurowanie wdrożenia

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"

Skonfiguruj wymagania sprzętowe wdrożenia:

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

Jeśli punkt końcowy nie ma łączności wychodzącej, użyj pakietu modelu (wersja zapoznawcza), dołączając argument with_package=True:

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"

Aby skonfigurować wymagania sprzętowe wdrożenia, należy utworzyć plik JSON z odpowiednią konfiguracją:

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

Uwaga

Pełną specyfikację tej konfiguracji można znaleźć w artykule Zarządzany schemat wdrażania online (wersja 2).

Zapisz konfigurację w pliku:

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

Tworzenie wdrożenia

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

Jeśli punkt końcowy nie ma łączności wychodzącej, użyj pakietu modelu (wersja zapoznawcza), dołączając flagę --with-package:

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

Napiwek

Ustawiliśmy flagę --all-traffic w poleceniu create, które przypisze cały ruch do nowego wdrożenia.

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

Przypisywanie całego ruchu do wdrożenia

Do tej pory punkt końcowy ma jedno wdrożenie, ale żaden z jego ruchu nie jest przypisany do niego. Przypiszmy go.
Ten krok nie jest wymagany w interfejsie wiersza polecenia platformy Azure, ponieważ użyliśmy --all-traffic go podczas tworzenia.
```
endpoint.traffic = { blue_deployment_name: 100 }
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Zapisz konfigurację w pliku:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```
Zaktualizuj konfigurację punktu końcowego:
Ten krok nie jest wymagany w interfejsie wiersza polecenia platformy Azure, ponieważ użyliśmy --all-traffic go podczas tworzenia.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```

Tworzenie przykładowych danych wejściowych w celu przetestowania wdrożenia

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

Poniższe przykłady kodu 5 obserwacji z zestawu danych treningowych, usuwa kolumnę target (zgodnie z przewidywaniami modelu) i tworzy żądanie w pliku sample.json , który może być używany z wdrożeniem modelu.

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

Poniższe przykłady kodu 5 obserwacji z zestawu danych szkoleniowych usuwa kolumnę target (zgodnie z przewidywaniami modelu) i tworzy żądanie.

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

Testowanie wdrożenia

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
)

Tworzenie zielonego wdrożenia w punkcie końcowym

Wyobraźmy sobie, że istnieje nowa wersja modelu utworzona przez zespół deweloperów i jest gotowa do pracy w środowisku produkcyjnym. Możemy najpierw spróbować latać tym modelem, a gdy jesteśmy pewni siebie, możemy zaktualizować punkt końcowy w celu kierowania ruchu do niego.

Rejestrowanie nowej wersji modelu

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

Pobierzmy numer wersji nowego modelu:

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

Konfigurowanie nowego wdrożenia

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

Nazwimy wdrożenie w następujący sposób:

GREEN_DEPLOYMENT_NAME="xgboost-model-$VERSION"

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

Skonfiguruj wymagania sprzętowe wdrożenia:

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

Jeśli punkt końcowy nie ma łączności wychodzącej, użyj pakietu modelu (wersja zapoznawcza), dołączając argument 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}"

Aby skonfigurować wymagania sprzętowe wdrożenia, należy utworzyć plik JSON z odpowiednią konfiguracją:

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

Napiwek

Używamy tego samego potwierdzenia sprzętu wskazanego w pliku deployment-config-file. Nie ma jednak żadnych wymagań dotyczących tej samej konfiguracji. W zależności od wymagań można skonfigurować inny sprzęt dla różnych modeli.

Zapisz konfigurację w pliku:

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

Tworzenie nowego wdrożenia

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

Jeśli punkt końcowy nie ma łączności wychodzącej, użyj pakietu modelu (wersja zapoznawcza), dołączając flagę --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},
)

Testowanie wdrożenia bez zmieniania ruchu

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
)

Napiwek

Zwróć uwagę, że teraz wskazujemy nazwę wdrożenia, które chcemy wywołać.

Stopniowo aktualizuj ruch

Z nowym wdrożeniem mamy pewność, że możemy zaktualizować ruch, aby skierować go do nowego wdrożenia. Ruch jest konfigurowany na poziomie punktu końcowego:

Konfigurowanie ruchu:

Ten krok nie jest wymagany w interfejsie wiersza polecenia platformy Azure

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

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

Zapisz konfigurację w pliku:

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

Aktualizowanie punktu końcowego

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

Jeśli zdecydujesz się przełączyć cały ruch do nowego wdrożenia, zaktualizuj cały ruch:
Ten krok nie jest wymagany w interfejsie wiersza polecenia platformy Azure
```
endpoint.traffic = {blue_deployment_name: 0, green_deployment_name: 100}
```
```
traffic_config = {"traffic": {blue_deployment_name: 0, green_deployment_name: 100}}
```
Zapisz konfigurację w pliku:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```

Aktualizowanie punktu końcowego

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

Ponieważ stare wdrożenie nie odbiera żadnego ruchu, można go bezpiecznie usunąć:
```
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
)
```
Napiwek

Zwróć uwagę, że w tym momencie poprzednie "niebieskie wdrożenie" zostało usunięte, a nowe "zielone wdrożenie" zajęło miejsce "niebieskiego wdrożenia".

Czyszczenie zasobów

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

ml_client.online_endpoints.begin_delete(name=endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

Ważne

Zauważ, że usunięcie punktu końcowego powoduje również usunięcie wszystkich wdrożeń w nim.

Share via

Progresywne wdrażanie modeli MLflow w punktach końcowych online

Informacje o tym przykładzie

Postępuj zgodnie z instrukcjami w notesach Jupyter Notebook

Wymagania wstępne

Nawiązywanie połączenia z obszarem roboczym

Rejestrowanie modelu w rejestrze

Tworzenie punktu końcowego online

Tworzenie niebieskiego wdrożenia

Tworzenie zielonego wdrożenia w punkcie końcowym

Stopniowo aktualizuj ruch

Czyszczenie zasobów

Następne kroki

Dodatkowe zasoby