Empaqueter et déployer des modèles en dehors d’Azure Machine Learning (préversion)

Article
12/08/2023

Vous pouvez déployer des modèles en dehors d’Azure Machine Learning pour le service en ligne en créant des packages de modèle (préversion). Azure Machine Learning vous permet de créer un package de modèle qui collecte toutes les dépendances requises pour déployer un modèle Machine Learning sur une plateforme de service. Vous pouvez déplacer un package de modèle entre des espaces de travail et même en dehors d’Azure Machine Learning. Pour en savoir plus sur les packages de modèles, consultez Packages de modèle pour le déploiement (préversion).

Important

Cette fonctionnalité est actuellement disponible en préversion publique. Cette préversion est fournie sans contrat de niveau de service et n’est pas recommandée pour les charges de travail de production. Certaines fonctionnalités peuvent être limitées ou non prises en charge.

Pour plus d’informations, consultez Conditions d’Utilisation Supplémentaires relatives aux Évaluations Microsoft Azure.

Dans cet article, vous allez découvrir comment empaqueter un modèle et le déployer sur Azure App Service.

Prérequis

Avant de suivre les étapes décrites dans cet article, vérifiez que vous disposez des composants requis suivants :

Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer. Essayez la version gratuite ou payante d’Azure Machine Learning.
Un espace de travail Azure Machine Learning. Si vous n’en avez pas, suivez les étapes décrites dans l’article Comment gérer des espaces de travail pour en créer un.

Remarque

Les espaces de travail avec liaison privée ne prennent pas en charge l’empaquetage des modèles à des fins de déploiement en dehors d’Azure Machine Learning.
Les contrôles d’accès en fonction du rôle Azure (Azure RBAC) sont utilisés pour accorder l’accès aux opérations dans Azure Machine Learning. Pour effectuer les étapes décrites dans cet article, votre compte d’utilisateur doit avoir le rôle Propriétaire ou Contributeur sur l’espace de travail Azure Machine Learning, ou un rôle personnalisé. Pour plus d’informations, consultez Gérer l’accès à un espace de travail Azure Machine Learning.

Préparer votre système

Suivez ces étapes pour préparer votre système.

L’exemple de cet article est basé sur des extraits de code contenus dans le référentiel azureml-examples. Pour exécuter les commandes localement sans avoir à copier/coller le fichier YAML et d’autres fichiers, clonez d’abord le référentiel, puis modifiez les répertoires dans le dossier :
- Azure CLI
- 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
```
Cet article utilise l’exemple dans le dossier endpoints/online/deploy-with-packages/mlflow-model.
Connectez-vous à l’espace de travail Azure Machine Learning dans lequel vous allez effectuer votre travail.
- Azure CLI
- Python
```
az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>
```
L’espace de travail est la ressource de niveau supérieur pour Azure Machine Learning. Il fournit un emplacement centralisé dans lequel exploiter tous les artefacts que vous créez lorsque vous utilisez Azure Machine Learning. Ici, vous vous connectez à l’espace de travail dans lequel vous effectuez des tâches de déploiement.

Important

Pour utiliser cette fonctionnalité en préversion, le package azure-ai-ml doit être mis à niveau vers une version minimale 1.12.0. Exécutez pip install azure-ai-ml==1.12.0 dans votre environnement conda pour vous assurer que le dernier Kit de développement logiciel (SDK) est installé.
1. Importez les bibliothèques nécessaires :
```
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
```
2. Si vous exécutez dans une instance de calcul Azure Machine Learning, créez une MLClient comme suit :
```
ml_client = MLClient.from_config(DefaultAzureCredential())
```
  Sinon, configurez les détails de l’espace de travail et obtenez un descripteur pour l’espace de travail :
```
subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
```
Les packages nécessitent l’inscription du modèle dans votre espace de travail ou dans un registre Azure Machine Learning. Dans ce cas, il existe une copie locale du modèle dans le référentiel. Nous devons donc uniquement publier le modèle dans le Registre dans l’espace de travail. Vous pouvez ignorer cette étape si le modèle que vous essayez de déployer est déjà inscrit.
- Azure CLI
- Python
```
MODEL_NAME='heart-classifier-mlflow'
MODEL_PATH='model'
az ml model create --name $MODEL_NAME --path $MODEL_PATH --type mlflow_model
```
```
model_name = "heart-classifier-mlflow"
model_path = "model"

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

Déployer un package de modèle sur Azure App Service

Dans cette section, vous empaquetez le modèle MLflow précédemment inscrit et le déployez sur Azure App Service.

Le déploiement d’un modèle en dehors d’Azure Machine Learning nécessite la création d’une spécification de package. Pour créer un package complètement déconnecté d’Azure Machine Learning, spécifiez le mode copy dans la configuration du modèle. Le mode copy indique au package de copier les artefacts à l’intérieur du package. Le code suivant montre comment spécifier le mode de copie pour la configuration du modèle :
- Azure CLI
- Python
Créez une spécification YAML de package :

package-external.yml
```
$schema: http://azureml/sdk-2-0/ModelVersionPackage.json
target_environment: heart-classifier-mlflow-pkg
inferencing_server: 
    type: azureml_online
model_configuration:
    mode: copy
```
```
pakage_config = ModelPackage(
    target_environment="heart-classifier-mlflow-pkg",
    inferencing_server=AzureMLOnlineInferencingServer(),
    model_configuration=ModelConfiguration(mode="copy"),
)
```
Conseil

Lorsque vous spécifiez la configuration du modèle à l’aide de copy pour la propriété mode, vous garantissez que tous les artefacts de modèle sont copiés à l’intérieur de l’image Docker générée au lieu de télécharger à partir du registre de modèles Azure Machine Learning, ce qui permet une portabilité réelle en dehors d’Azure Machine Learning. Pour obtenir une spécification complète sur toutes les options lors de la création de packages, consultez Créer une spécification de package.

Démarrez l’opération d’empaquetage.

Azure CLI
Python

az ml model package --name $MODEL_NAME --version $MODEL_VERSION --file package-external.yml

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

Le résultat de l’opération d’empaquetage est un environnement dans Azure Machine Learning. L’avantage d’avoir cet environnement est que chaque environnement a une image Docker correspondante que vous pouvez utiliser dans un déploiement externe. Les images sont hébergées dans Azure Container Registry. Les étapes suivantes montrent comment vous obtenez le nom de l’image générée :
1. Accédez à Azure Machine Learning Studio.
2. Sélectionnez la section Environnements.
3. Sélectionnez l'onglet Environnements personnalisés.
4. Recherchez l’environnement nommé heart-classifier-mlflow-package, qui est le nom du package que vous venez de créer.
5. Copiez la valeur qui se trouve dans le champ Registre de conteneurs Azure.
Déployez maintenant ce package dans un App Service.
1. Accédez au portail Azure et créez une ressource App Service.
2. Dans l’Assistant de création, sélectionnez l’abonnement et le groupe de ressources que vous utilisez.
3. Dans la section Détails de l’instance, donnez un nom à l’application.
4. Pour Publier, sélectionnez Conteneur Docker.
5. Pour Système d’exploitation, sélectionnez Linux.
6. Configurez le reste de la page en fonction des besoins, puis sélectionnez Suivant.
7. Accédez à l’onglet Docker.
8. Pour Options, sélectionnez Conteneur unique.
9. Pour Source d’image, sélectionnez Azure Container Registry.
10. Configurez les options de Registre de conteneurs Azure comme suit :
  1. Pour Registre, sélectionnez l’Azure Container Registry associé à l’espace de travail Azure Machine Learning.
  2. Pour Image, sélectionnez l’image que vous avez trouvée à l’étape 3(e) de ce didacticiel.
  3. Pour Balise, sélectionnez Le plus récent.
11. Configurez le reste de l’Assistant en fonction de vos besoins.
12. Cliquez sur Créer. Le modèle est maintenant déployé dans l’App Service que vous avez créé.
13. La façon dont vous appelez et obtenez des prédictions dépend du serveur d’inférence que vous avez utilisé. Dans cet exemple, vous avez utilisé le serveur d’inférence Azure Machine Learning, qui crée des prédictions sous l’itinéraire /score. Pour plus d’informations sur les formats et fonctionnalités d’entrée, consultez les détails du package azureml-inference-server-http.
14. Préparez la charge utile de la requête. Le format d’un modèle MLflow déployé avec le serveur d’inférence Azure Machine Learning est le suivant :
  
  sample-request.json
```
{
    "input_data": {
        "columns": [
            "age", "sex", "cp", "trestbps", "chol", "fbs", "restecg", "thalach", "exang", "oldpeak", "slope", "ca", "thal"
        ],
        "index": [1],
        "data": [
            [1, 1, 4, 145, 233, 1, 2, 150, 0, 2.3, 3, 0, 2]
        ]
    }
}
```
15. Testez le déploiement du modèle pour voir s’il fonctionne.
```
cat -A sample-request.json | curl http://heart-classifier-mlflow-pkg.azurewebsites.net/score \
    --request POST \
    --header 'Content-Type: application/json' \
    --data-binary @-
```

Étape suivante

Packages de modèles pour le déploiement (préversion)

Partager via