Tworzenie pakietów modeli (wersja zapoznawcza)

Artykuł
09/02/2024

Pakiet modelu to funkcja w usłudze Azure Machine Learning, która umożliwia zbieranie wszystkich zależności wymaganych do wdrożenia modelu uczenia maszynowego na platformie obsługującej. Tworzenie pakietów przed wdrożeniem modeli zapewnia niezawodne i niezawodne wdrażanie oraz wydajniejszy przepływ pracy metodyki MLOps. Pakiety można przenosić między obszarami roboczymi, a nawet poza usługą Azure Machine Learning.

Ważne

Ta funkcja jest obecnie w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone.

Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Z tego artykułu dowiesz się, jak spakować model do wdrożenia.

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 Learning.
Obszar roboczy usługi Azure Machine Learning. Jeśli go nie masz, wykonaj kroki opisane w artykule How to manage workspaces (Jak zarządzać obszarami roboczymi), aby je utworzyć.
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, konto użytkownika musi mieć przypisaną rolę właściciela lub współautora dla obszaru roboczego usługi Azure Machine Learning lub rolę niestandardową. Aby uzyskać więcej informacji, zobacz Zarządzanie dostępem do obszaru roboczego usługi Azure Machine Learning.
Model do spakowania. W tym przykładzie użyto modelu MLflow zarejestrowanego w obszarze roboczym.

Uwaga

Tworzenie pakietów modeli nie jest obsługiwane w przypadku modeli w katalogu modeli usługi Azure AI, w tym dla dużych modeli językowych. Modele w katalogu modeli sztucznej inteligencji platformy Azure są zoptymalizowane pod kątem wnioskowania na docelowych wdrożeniach sztucznej inteligencji platformy Azure i nie są odpowiednie do tworzenia pakietów.

Informacje o tym przykładzie

W tym przykładzie dowiesz się, jak pakować modele w usłudze Azure Machine Learning.

Klonowanie repozytorium

Przykład w tym artykule jest oparty na przykładach kodu zawartych w repozytorium azureml-examples . Aby uruchomić polecenia lokalnie bez konieczności kopiowania/wklejania kodu YAML i innych plików, najpierw sklonuj repozytorium, a następnie zmień katalogi na folder:

Interfejs wiersza polecenia platformy Azure
Python

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

!git clone https://github.com/Azure/azureml-examples --depth 1
!cd azureml-examples/sdk/python

W tej sekcji użyto przykładu w folderze endpoints/online/deploy-packages/custom-model.

Nawiązywanie połączenia z obszarem roboczym

Połącz się z obszarem roboczym usługi Azure Machine Learning, w którym wykonasz swoją pracę.

Interfejs wiersza polecenia platformy Azure
Python

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łączysz się z obszarem roboczym, w którym wykonujesz zadania wdrażania.

Zaimportuj wymagane biblioteki:

from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
    AzureMLOnlineInferencingServer,
    ModelPackage,
    CodeConfiguration,
    BaseEnvironment,
    ModelConfiguration,
)
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Environment,
    Model,
)

Jeśli korzystasz z wystąpienia obliczeniowego w usłudze Azure Machine Learning, utwórz element MLClient w następujący sposób:

ml_client = MLClient.from_config(DefaultAzureCredential())

W przeciwnym razie skonfiguruj szczegóły obszaru roboczego i uzyskaj dojście do obszaru roboczego:

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

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

Tworzenie pakietu modelu

Możesz jawnie tworzyć pakiety modelu, aby umożliwić kontrolowanie sposobu wykonywania operacji pakowania. Użyj tego przepływu pracy, gdy:

Chcesz dostosować sposób tworzenia pakietu modelu.
Chcesz wdrożyć pakiet modelu poza usługą Azure Machine Learning.
Chcesz użyć pakietów modelu w przepływie pracy metodyki MLOps.

Pakiety modelu można tworzyć, określając następujące elementy:

Model do spakowania: każdy pakiet modelu może zawierać tylko jeden model. Usługa Azure Machine Learning nie obsługuje tworzenia pakietów wielu modeli w ramach tego samego pakietu modelu.
Środowisko podstawowe: środowiska są używane do wskazywania obrazu podstawowego i w pakietach języka Python zależności potrzebnego modelu. W przypadku modeli MLflow usługa Azure Machine Learning automatycznie generuje środowisko podstawowe. W przypadku modeli niestandardowych należy je określić.
Obsługa technologii: stos wnioskowania używany do uruchamiania modelu.

Rejestrowanie modelu

Pakiety modeli wymagają zarejestrowania modelu w obszarze roboczym lub w rejestrze usługi Azure Machine Learning. W tym przykładzie masz już lokalną kopię modelu w repozytorium, więc wystarczy opublikować model w rejestrze w obszarze roboczym. Tę sekcję można pominąć, jeśli model, który próbujesz wdrożyć, jest już zarejestrowany.

Interfejs wiersza polecenia platformy Azure
Python

MODEL_NAME='sklearn-regression'
MODEL_PATH='model'
az ml model create --name $MODEL_NAME --path $MODEL_PATH --type custom_model

model_name = "sklearn-regression"
model_path = "model"

model = ml_client.models.create_or_update(Model(name=model_name, path=model_path))

Tworzenie środowiska podstawowego

Środowiska podstawowe służą do wskazywania obrazu podstawowego i zależności pakietu języka Python modelu. Nasz model wymaga użycia następujących pakietów wskazanych w pliku conda:

conda.yaml

name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.9
  - numpy=1.23.5
  - pip=23.0.1
  - scikit-learn=1.2.2
  - scipy=1.10.1
  - xgboost==1.3.3

Uwaga

Czym różni się środowisko podstawowe od środowiska używanego do wdrażania modelu w punktach końcowych online i wsadowych? Podczas wdrażania modeli w punktach końcowych środowisko musi zawierać zależności modelu i pakiety języka Python wymagane do działania zarządzanych punktów końcowych online. Spowoduje to ręczny proces wdrażania, w którym trzeba połączyć wymagania modelu z wymaganiami platformy obsługującej. Z drugiej strony użycie pakietów modelu eliminuje to tarcie, ponieważ wymagane pakiety dla serwera wnioskowania zostaną automatycznie wprowadzone do pakietu modelu w czasie pakowania.

Utwórz środowisko w następujący sposób:

Interfejs wiersza polecenia platformy Azure
Python

Utwórz definicję środowiska:

sklearn-regression-env.yml

$schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
name: sklearn-regression-env
image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04
conda_file: conda.yaml
description: An environment for models built with XGBoost and Scikit-learn.

Następnie utwórz środowisko:

az ml environment create -f environment/sklearn-regression-env.yml

base_environment = ml_client.environments.create_or_update(
    Environment(
        name=f"{model_name}-env",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04",
        conda_file="environment/conda.yml",
    )
)

Tworzenie specyfikacji pakietu

Pakiety modeli można tworzyć w usłudze Azure Machine Learning przy użyciu interfejsu wiersza polecenia platformy Azure lub zestawu AZURE Machine Learning SDK dla języka Python. Specyfikacja pakietu niestandardowego obsługuje następujące atrybuty:

Interfejs wiersza polecenia platformy Azure
Python

Atrybut	Type	Opis	Wymagania
`target_environment`	`str`	Nazwa pakietu do utworzenia. Wynikiem operacji pakietu jest środowisko w usłudze Azure Machine Learning.	Tak
`base_environment_source`	`object`	Obraz podstawowy do użycia w celu utworzenia pakietu, w którym określono zależności dla modelu.	Tak, chyba że model to MLflow.
`base_environment_source.type`	`str`	Typ obrazu podstawowego. Obsługiwane jest tylko użycie innego środowiska, ponieważ obraz podstawowy jest obsługiwany (`type: environment_asset`).
`base_environment_source.resource_id`	`str`	Identyfikator zasobu środowiska podstawowego do użycia. Użyj formatu `azureml:<name>:<version>` lub długiego identyfikatora zasobu.
`inferencing_server`	`object`	Serwer wnioskowania do użycia.	Tak
`inferencing_server.type`	`azureml_online` `custom`	Użyj `azureml_online` dla serwera wnioskowania usługi Azure Machine Learning lub `custom` niestandardowego serwera online, takiego jak tensorFlow obsługujący lub Torch Serve.	Tak
`inferencing_server.code_configuration`	`object`	Konfiguracja kodu z procedurą wnioskowania. Powinien zawierać co najmniej jeden plik języka Python z metodami `init` i `run`.	Tak, chyba że model to MLflow.
`model_configuration`	`object`	Konfiguracja modelu. Użyj tego atrybutu, aby kontrolować sposób tworzenia pakietu modelu w wynikowym obrazie.	Nie.
`model_configuration.mode`	`download` `copy`	Wskaż sposób umieszczenia modelu w pakiecie. Możliwe wartości to `download` (wartość domyślna) i `copy`. Użyj `download` polecenia , jeśli chcesz, aby model został pobrany z rejestru modeli w czasie wdrażania. Ta opcja umożliwia utworzenie mniejszych obrazów platformy Docker, ponieważ model nie jest na nim uwzględniony. Użyj `copy` polecenia , aby odłączyć obraz od usługi Azure Machine Learning. Model zostanie skopiowany wewnątrz obrazu platformy Docker w czasie pakietu. `copy` nie jest obsługiwany w obszarach roboczych z obsługą linków prywatnych.	Nie.

Atrybut	Type	Opis	Wymagania
`target_environment`	`str`	Nazwa pakietu do utworzenia. Wynikiem operacji pakietu jest środowisko w usłudze Azure Machine Learning.	Tak
`base_environment_source`	`BaseEnvironment`	Obraz podstawowy do użycia w celu utworzenia pakietu, w którym określono zależności dla modelu.	Tak, chyba że typ modelu to MLflow.
`base_environment_source.type`	`BaseEnvironmentType`	Typ obrazu podstawowego. Obsługiwane jest tylko użycie innego środowiska (`EnvironmentAsset`) jako obrazu podstawowego.
`base_environment_source.resource_id`	`str`	Identyfikator zasobu środowiska podstawowego do użycia. Użyj formatu `azureml:<name>:<version>` lub identyfikatora zasobu w długim formacie.
`inferencing_server`	`AzureMLOnlineInferencingServer` `CustomOnlineInferenceServer`	Serwer wnioskowania do użycia. Użyj `AzureMLOnlineInferencingServer` polecenia do serwera wnioskowania usługi Azure Machine Learning lub `CustomOnlineInferenceServer` niestandardowego serwera online, takiego jak obsługa TensorFlow, Torch Serve itp. Jeśli ustawiono wartość i `AzureMLInferencingServer` typ modelu nie jest mlflow, należy określić sekcję konfiguracji kodu zawierającą co najmniej jeden plik języka Python z metodami `init` i `run`. Jeśli ustawiono `CustomOnlineInferenceServer`wartość , należy określić sekcję konfiguracji serwera online.	Tak
`model_configuration`	`ModelConfiguration`	Konfiguracja modelu. Użyj tego atrybutu, aby kontrolować sposób tworzenia pakietu modelu w wynikowym obrazie.	Nie.
`model_configuration.mode`	`ModelInputMode`	Określ sposób umieszczania modelu w pakiecie. Możliwe wartości to `ModelInputMode.DOWNLOAD` (wartość domyślna) i `ModelInputMode.COPY`. Użyj `ModelInputMode.DOWNLOAD` polecenia , jeśli chcesz, aby model został pobrany z rejestru modeli w czasie wdrażania. Ta opcja umożliwia utworzenie mniejszych obrazów platformy Docker, ponieważ model nie jest na nim uwzględniony. Użyj `ModelInputMode.COPY` polecenia , aby odłączyć obraz od usługi Azure Machine Learning. Model zostanie skopiowany wewnątrz obrazu platformy Docker w czasie pakietu. `ModelInputMode.COPY` nie jest obsługiwany w obszarach roboczych z obsługą linków prywatnych.	Nie.

Utwórz specyfikację pakietu w następujący sposób:

Interfejs wiersza polecenia platformy Azure
Python

package-moe.yml

$schema: http://azureml/sdk-2-0/ModelVersionPackage.json
base_environment_source:
    type: environment_asset
    resource_id: azureml:sklearn-regression-env:1
target_environment: sklearn-regression-online-pkg
inferencing_server: 
    type: azureml_online
    code_configuration:
      code: src
      scoring_script: score.py

Aby utworzyć pakiet modelu, utwórz specyfikację pakietu w następujący sposób:

pakage_config = ModelPackage(
    target_environment="sklearn-regression-online-pkg",
    base_environment_source=BaseEnvironment(
        type="asset",
        resource_id=f"azureml:{base_environment.name}:{base_environment.version}",
    ),
    inferencing_server=AzureMLOnlineInferencingServer(
        code_configuration=CodeConfiguration(code="src", scoring_script="score.py")
    ),
)

Uruchom operację pakietu modelu:

Interfejs wiersza polecenia platformy Azure
Python

az ml model package -n $MODEL_NAME -v $MODEL_VERSION --file package-moe.yml

model_package = ml_client.models.package(model_name, model.version, pakage_config)

Wynikiem operacji pakietu jest środowisko.

Tworzenie pakietu modelu, który ma zależności w prywatnych kanałach informacyjnych języka Python

Pakiety modeli mogą rozpoznawać zależności języka Python, które są dostępne w prywatnych źródłach danych. Aby użyć tej funkcji, musisz utworzyć połączenie z obszaru roboczego do kanału informacyjnego i określić konfigurację tokenu pat. Poniższy kod języka Python pokazuje, jak skonfigurować obszar roboczy, w którym jest uruchamiana operacja pakietu.

from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import PatTokenConfiguration

# fetching secrets from env var to secure access, these secrets can be set outside or source code
git_pat = os.environ["GIT_PAT"]

credentials = PatTokenConfiguration(pat=git_pat)

ws_connection = WorkspaceConnection(
    name="<workspace_connection_name>",
    target="<git_url>",
    type="git",
    credentials=credentials,
)

ml_client.connections.create_or_update(ws_connection)

Po utworzeniu połączenia skompiluj pakiet modelu zgodnie z opisem w sekcji Tworzenie pakietu modelu. W poniższym przykładzie podstawowe środowisko pakietu używa prywatnego źródła danych dla zależności barjęzyka Python, jak określono w następującym pliku conda:

conda.yml

name: foo
channels:
  - defaults
dependencies:
  - python
  - pip
  - pip:
    - --extra-index-url <python_feed_url>
    - bar

Jeśli używasz modelu MLflow, zależności modelu są wskazywane wewnątrz samego modelu, dlatego środowisko podstawowe nie jest potrzebne. Zamiast tego określ zależności kanału prywatnego podczas rejestrowania modelu, zgodnie z opisem w artykule Modele rejestrowania przy użyciu niestandardowego podpisu, środowiska lub przykładów.

Tworzenie pakietu modelu hostowanego w rejestrze

Pakiety modelu zapewniają wygodny sposób zbierania zależności przed wdrożeniem. Jednak gdy modele są hostowane w rejestrach, obiekt docelowy wdrożenia jest zwykle innym obszarem roboczym. Podczas tworzenia pakietów w tej konfiguracji użyj target_environment właściwości , aby określić pełną lokalizację, w której ma zostać utworzony pakiet modelu, a nie tylko jego nazwa.

Poniższy kod tworzy pakiet t5-base modelu z rejestru:

Połącz się z rejestrem, w którym znajduje się model, i obszarem roboczym, w którym ma zostać utworzony pakiet modelu:

Interfejs wiersza polecenia platformy Azure
Python

az login

registry_client = MLClient(
    credential=DefaultAzureCredential(),
    subscription_id=ml_client.subscription_id,
    resource_group_name=ml_client.resource_group_name,
    workspace_reference=ml_client.workspace_name,
    registry_name=registry_name,
)

Uzyskaj odwołanie do modelu, który chcesz spakować. W tym przypadku pakujemy model t5-base z azureml rejestru.

Interfejs wiersza polecenia platformy Azure
Python

MODEL_NAME="t5-base"
MODEL_VERSION=$(az ml model show --name $MODEL_NAME --label latest --registry-name azureml | jq .version -r)

model_name = "t5-base"
model = registry_client.models.get(name=model_name, label="latest")

Konfigurowanie specyfikacji pakietu. Ponieważ model, który chcemy spakować, to MLflow, podstawowy skrypt środowiska i oceniania jest opcjonalny.

Interfejs wiersza polecenia platformy Azure
Python

package.yml

$schema: http://azureml/sdk-2-0/ModelVersionPackage.json
target_environment: pkg-t5-base-online
inferencing_server: 
    type: azureml_online

import time

model_package_name = f"pkg-{model.name}-{model.version}"
model_package_version = str(int(time.time()))

package_config = ModelPackage(
    target_environment=model_package_name,
    target_environment_version=model_package_version,
    inferencing_server=AzureMLOnlineInferencingServer(),
)

Uruchom operację, aby utworzyć pakiet modelu:

Interfejs wiersza polecenia platformy Azure
Python

az ml model package --name $MODEL_NAME \
                    --version $MODEL_VERSION \
                    --registry-name azureml \
                    --file package.yml

model_package = registry_client.models.package(
    model.name, model.version, package_config
)

Pakiet jest teraz tworzony w docelowym obszarze roboczym i jest gotowy do wdrożenia.

Modele pakietów do wdrożenia poza usługą Azure Machine Learning

W razie potrzeby pakiety modeli można wdrażać poza usługą Azure Machine Learning. Aby zagwarantować przenośność, musisz upewnić się, że konfiguracja modelu w pakiecie ma ustawiony copy tryb tak, aby sam model został skopiowany wewnątrz wygenerowanego obrazu platformy Docker zamiast odwoływać się do rejestru modeli w usłudze Azure Machine Learning.

Poniższy kod przedstawia sposób konfigurowania copy w pakiecie modelu:

Interfejs wiersza polecenia platformy Azure
Python

package-external.yml

$schema: http://azureml/sdk-2-0/ModelVersionPackage.json
base_environment_source:
    type: environment_asset
    resource_id: azureml:sklearn-regression-env:1
target_environment: sklearn-regression-docker-pkg
inferencing_server: 
    type: azureml_online
    code_configuration:
      code: src
      scoring_script: score.py
model_configuration:
  mode: copy

pakage_config = ModelPackage(
    target_environment="sklearn-regression-online-pkg",
    base_environment_source=BaseEnvironment(
        type="asset",
        resource_id=f"azureml:{base_environment.name}:{base_environment.version}",
    ),
    inferencing_server=AzureMLOnlineInferencingServer(
        code_configuration=CodeConfiguration(code="src", scoring_script="score.py")
    ),
    model_configuration=ModelConfiguration(mode="copy"),
)

Udostępnij za pośrednictwem