Partager via

Déployer un modèle de deep learning pour l’inférence avec GPU

S’APPLIQUE À :Kit de développement logiciel (SDK) Azure Machine Learning v1 pour Python

Important

Cet article fournit des informations sur l’utilisation du Kit de développement logiciel (SDK) Azure Machine Learning v1. Sdk v1 est déconseillé depuis le 31 mars 2025. La prise en charge prendra fin le 30 juin 2026. Vous pouvez installer et utiliser le Kit de développement logiciel (SDK) v1 jusqu’à cette date.

Nous vous recommandons de passer au SDK v2 avant le 30 juin 2026. Pour plus d’informations sur le SDK v2, consultez Qu’est-ce qu’Azure Machine Learning CLI et le SDK Python v2 ? et la référence du SDK v2.

Cet article explique comment utiliser Azure Machine Learning pour déployer un modèle compatible GPU en tant que service web. Les informations contenues dans cet article sont basées sur le déploiement d’un modèle sur Azure Kubernetes service (AKS). Le cluster AKS fournit une ressource GPU qui est utilisée par le modèle pour l’inférence.

L’inférence, ou notation de modèle, est la phase au cours de laquelle le modèle déployé est utilisé pour effectuer des prédictions. L’utilisation de GPU au lieu de CPU offre des avantages en termes de performances sur des calculs hautement parallélisables.

Remarque

Les points de terminaison Azure Machine Learning (v2) offrent une expérience de déploiement plus simple et améliorée. Les points de terminaison prennent en charge les scénarios d’inférence en temps réel et par lot. Les points de terminaison fournissent une interface unifiée pour appeler et gérer des déploiements de modèle pour différents types de calcul. Voir Que sont les points de terminaison Azure Machine Learning ?.

Important

Lorsque vous utilisez le Kit de développement logiciel (SDK) Azure Machine Learning v1, l’inférence GPU est prise en charge uniquement sur Azure Kubernetes Service. Lorsque vous utilisez le Kit de développement logiciel (SDK) Azure Machine Learning v2 ou CLI v2, vous pouvez utiliser un point de terminaison en ligne pour l’inférence GPU. Pour plus d’informations, consultez Déployer et scorer un modèle Machine Learning avec un point de terminaison en ligne.

Pour l'inférence à l’aide d’un pipeline d'apprentissage machine, les GPU sont uniquement pris en charge sur Azure Machine Learning Compute. Pour plus d’informations sur l’utilisation des pipelines ML, consultez Tutoriel : Créer un pipeline Azure Machine Learning pour la notation par lots.

Conseil

Bien que les extraits de code de cet article utilisent un modèle TensorFlow, vous pouvez appliquer les informations à n’importe quel framework Machine Learning qui prend en charge les GPU.

Remarque

Les informations contenues dans cet article s’appuient sur celles de l’article Comment déployer sur Azure Kubernetes Service. Alors que cet article couvre généralement le déploiement sur AKS, cet article couvre le déploiement spécifique au GPU.

Prérequis

Se connecter à un espace de travail

Pour vous connecter à un espace de travail existant, utilisez le code suivant :

Important

Cet extrait de code s’attend à ce que la configuration de l’espace de travail soit enregistrée dans le répertoire actif ou son parent. Pour plus d’informations sur la création d’un espace de travail, consultez Créer des ressources d’espace de travail. Pour plus d’informations sur l’enregistrement de la configuration dans un fichier, consultez Créer un fichier de configuration d’espace de travail.

from azureml.core import Workspace

# Connect to the workspace
ws = Workspace.from_config()

Créer un cluster Kubernetes avec des GPU

Azure Kubernetes Service fournit de nombreuses options de GPU. Vous pouvez utiliser celle de votre choix pour l’inférence de modèle. Pour obtenir la liste complète des fonctionnalités et des coûts, voir la liste des machines virtuelles série N.

Le code suivant montre comment associer un cluster AKS pour votre espace de travail :

from azureml.core.compute import ComputeTarget, AksCompute
from azureml.exceptions import ComputeTargetException

# Choose a name for your cluster
aks_name = "aks-gpu"

# Check to see if the cluster already exists
try:
    aks_target = ComputeTarget(workspace=ws, name=aks_name)
    print('Found existing compute target')
except ComputeTargetException:
    print('Creating a new compute target...')
    # Provision AKS cluster with GPU machine
    prov_config = AksCompute.provisioning_configuration(vm_size="Standard_NC6")

    # Create the cluster
    aks_target = ComputeTarget.create(
        workspace=ws, name=aks_name, provisioning_configuration=prov_config
    )

    aks_target.wait_for_completion(show_output=True)

Important

Azure vous facture tant que le cluster AKS existe. Veillez à supprimer votre cluster AKS lorsque vous n’en avec plus besoin.

Pour plus d’informations sur l’utilisation d’AKS avec Azure Machine Learning, consultez Comment déployer sur Azure Kubernetes Service.

Écrire le script d’entrée

Le script d'entrée reçoit les données soumises au service Web, les transmet au modèle et renvoie les résultats de notation. Le script suivant charge le modèle TensorFlow au démarrage, puis utilise le modèle pour noter les données.

Conseil

Le script d’entrée est spécifique de votre modèle. Par exemple, le script doit connaître le framework à utiliser avec votre modèle, les formats de données, etc.

import json
import numpy as np
import os
import tensorflow as tf

from azureml.core.model import Model


def init():
    global X, output, sess
    tf.reset_default_graph()
    model_root = os.getenv('AZUREML_MODEL_DIR')
    # the name of the folder in which to look for tensorflow model files
    tf_model_folder = 'model'
    saver = tf.train.import_meta_graph(
        os.path.join(model_root, tf_model_folder, 'mnist-tf.model.meta'))
    X = tf.get_default_graph().get_tensor_by_name("network/X:0")
    output = tf.get_default_graph().get_tensor_by_name("network/output/MatMul:0")

    sess = tf.Session()
    saver.restore(sess, os.path.join(model_root, tf_model_folder, 'mnist-tf.model'))


def run(raw_data):
    data = np.array(json.loads(raw_data)['data'])
    # make prediction
    out = output.eval(session=sess, feed_dict={X: data})
    y_hat = np.argmax(out, axis=1)
    return y_hat.tolist()

Ce fichier est nommé score.py. Pour plus d’informations sur les scripts d’entrée, consultez la page Comment et où déployer.

Définir l'environnement conda

Le fichier d’environnement conda spécifie les dépendances du service. Il inclut les dépendances requises aussi bien par le modèle que par le script d’entrée. Notez que vous devez indiquer azureml-defaults avec verion >= 1.0.45 comme dépendance pip, car il contient les fonctionnalités nécessaires pour héberger le modèle en tant que service web. Le code YAML suivant définit l’environnement pour un modèle TensorFlow. Il spécifie tensorflow-gpu, qui utilise le GPU utilisé dans ce déploiement :

name: project_environment
dependencies:
  # The Python interpreter version.
  # Currently Azure Machine Learning only supports 3.5.2 and later.
- python=3.7

- pip:
  # You must list azureml-defaults as a pip dependency
  - azureml-defaults>=1.0.45
  - numpy
  - tensorflow-gpu=1.12
channels:
- conda-forge

Pour cet exemple, le fichier est enregistré sous nom myenv.yml.

Définir la configuration du déploiement

Important

AKS n’autorise pas les pods à partager des GPU. Vous ne pouvez avoir que autant de réplicas d’un service web avec GPU qu’il existe des GPU dans le cluster.

La configuration du déploiement définit l’environnement Azure Kubernetes Service utilisé pour exécuter le service web :

from azureml.core.webservice import AksWebservice

gpu_aks_config = AksWebservice.deploy_configuration(autoscale_enabled=False,
                                                    num_replicas=3,
                                                    cpu_cores=2,
                                                    memory_gb=4)

Pour plus d’informations, consultez la documentation de référence pour AksService.deploy_configuration.

Définir la configuration de l’inférence

La configuration de l'inférence pointe vers le script d’entrée et un objet d’environnement utilisant une image Docker avec prise en charge GPU. Notez que le fichier YAML utilisé pour la définition d’environnement doit répertorier azureml-defaults avec la version >= 1.0.45 comme dépendance pip, car il contient les fonctionnalités nécessaires pour héberger le modèle en tant que service web.

from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment, DEFAULT_GPU_IMAGE

myenv = Environment.from_conda_specification(name="myenv", file_path="myenv.yml")
myenv.docker.base_image = DEFAULT_GPU_IMAGE
inference_config = InferenceConfig(entry_script="score.py", environment=myenv)

Pour plus d’informations sur les environnements , consultez Créer et gérer des environnements pour la formation et le déploiement. Pour plus d’informations, consultez la documentation de référence pour InferenceConfig.

Déployer le modèle

Déployez le modèle sur votre cluster AKS et attendez qu’il crée votre service.

from azureml.core.model import Model

# Name of the web service that is deployed
aks_service_name = 'aks-dnn-mnist'
# Get the registerd model
model = Model(ws, "tf-dnn-mnist")
# Deploy the model
aks_service = Model.deploy(ws,
                           models=[model],
                           inference_config=inference_config,
                           deployment_config=gpu_aks_config,
                           deployment_target=aks_target,
                           name=aks_service_name)

aks_service.wait_for_deployment(show_output=True)
print(aks_service.state)

Pour plus d’informations, consultez la documentation de référence sur le modèle.

Envoyer un exemple de requête à votre service

Envoyez une requête test au modèle déployé. Lorsque vous envoyez une image jpeg au modèle, celui-ci note l’image. L’exemple de code suivant télécharge des données de test, puis sélectionne une image de test aléatoire à envoyer au service.

# Used to test your webservice
import os
import urllib
import gzip
import numpy as np
import struct
import requests

# load compressed MNIST gz files and return numpy arrays
def load_data(filename, label=False):
    with gzip.open(filename) as gz:
        struct.unpack('I', gz.read(4))
        n_items = struct.unpack('>I', gz.read(4))
        if not label:
            n_rows = struct.unpack('>I', gz.read(4))[0]
            n_cols = struct.unpack('>I', gz.read(4))[0]
            res = np.frombuffer(gz.read(n_items[0] * n_rows * n_cols), dtype=np.uint8)
            res = res.reshape(n_items[0], n_rows * n_cols)
        else:
            res = np.frombuffer(gz.read(n_items[0]), dtype=np.uint8)
            res = res.reshape(n_items[0], 1)
    return res

# one-hot encode a 1-D array
def one_hot_encode(array, num_of_classes):
    return np.eye(num_of_classes)[array.reshape(-1)]

# Download test data
os.makedirs('./data/mnist', exist_ok=True)
urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz', filename='./data/mnist/test-images.gz')
urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz', filename='./data/mnist/test-labels.gz')

# Load test data from model training
X_test = load_data('./data/mnist/test-images.gz', False) / 255.0
y_test = load_data('./data/mnist/test-labels.gz', True).reshape(-1)

# send a random row from the test set to score
random_index = np.random.randint(0, len(X_test)-1)
input_data = "{\"data\": [" + str(list(X_test[random_index])) + "]}"

api_key = aks_service.get_keys()[0]
headers = {'Content-Type': 'application/json',
           'Authorization': ('Bearer ' + api_key)}
resp = requests.post(aks_service.scoring_uri, input_data, headers=headers)

print("POST to url", aks_service.scoring_uri)
print("label:", y_test[random_index])
print("prediction:", resp.text)

Pour plus d’informations sur la création d’une application cliente, consultez Créer un client pour consommer un service web déployé.

Nettoyer les ressources

Si vous avez créé le cluster AKS spécifiquement pour cet exemple, supprimez vos ressources une fois que vous avez terminé.

Important

Azure vous facture en fonction de la durée de déploiement du cluster AKS. Veillez à le nettoyer une fois que vous l’avez terminé.

aks_service.delete()
aks_target.delete()

Étapes suivantes