Comment déployer un modèle en Python à l'aide de TensorFlow Serving ?

Le déploiement de modèles d'apprentissage automatique est essentiel pour rendre les applications d'intelligence artificielle fonctionnelles, et pour servir efficacement les modèles dans les environnements de production, TensorFlow Serving fournit une solution fiable. Lorsqu'un modèle est formé et prêt à être déployé, il est essentiel de le servir efficacement pour traiter les demandes en temps réel. TensorFlow Serving est un outil puissant qui permet de déployer en douceur des modèles de machine learning dans des environnements de production.

Dans cet article, nous examinerons en profondeur les étapes impliquées dans le déploiement d'un modèle en Python à l'aide de TensorFlow Serving.

Qu'est-ce que le déploiement de modèles ?

Le déploiement de modèles implique la mise à disposition de modèles d'apprentissage automatique entraînés pour des prédictions en temps réel. Cela signifie déplacer le modèle d'un environnement de développement vers un système de production où il peut gérer efficacement les demandes entrantes. TensorFlow Serving est un système hautes performances spécialement conçu pour le déploiement de modèles d'apprentissage automatique.

Configurer le service TensorFlow

Tout d’abord, nous devons installer TensorFlow Serving sur notre système. Veuillez suivre les étapes ci-dessous pour configurer TensorFlow Serving -

Étape 1 : Installer TensorFlow Serving

Installez d’abord TensorFlow Serving à l’aide du gestionnaire de packages pip. Ouvrez l'invite de commande ou le terminal et entrez la commande suivante -

pip install tensorflow-serving-api

Étape 2 : Démarrez le serveur de service TensorFlow

Après l'installation, démarrez le serveur TensorFlow Serving en exécutant la commande suivante -

tensorflow_model_server --rest_api_port=8501 --model_name=my_model --model_base_path=/path/to/model/directory

Remplacez `/path/to/model/directory` par le chemin où le modèle entraîné est stocké.

Modèle prêt à déployer

Avant de déployer le modèle, il doit être enregistré dans un format que TensorFlow Serving peut comprendre. Suivez ces étapes pour préparer votre modèle pour le déploiement -

Enregistrer le modèle au format SavedModel

Dans un script Python, utilisez le code suivant pour enregistrer le modèle entraîné au format SavedModel -

import tensorflow as tf

# Assuming `model` is your trained TensorFlow model
tf.saved_model.save(model, '/path/to/model/directory')

Définir la signature du modèle

La signature du modèle fournit des informations sur les tenseurs d'entrée et de sortie du modèle. Utilisez la fonction `tf.saved_model.signature_def_utils.build_signature_def` pour définir la signature du modèle. Voici un exemple -

inputs = {'input': tf.saved_model.utils.build_tensor_info(model.input)}
outputs = {'output': tf.saved_model.utils.build_tensor_info(model.output)}

signature = tf.saved_model.signature_def_utils.build_signature_def(
   inputs=inputs,
   outputs=outputs,
   method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME
)

Enregistrer le modèle avec signature

Pour enregistrer le modèle avec la signature, utilisez le code suivant -

builder = tf.saved_model.builder.SavedModelBuilder('/path/to/model/directory')
builder.add_meta_graph_and_variables(
   sess=tf.keras.backend.get_session(),
   tags=[tf.saved_model.tag_constants.SERVING],
   signature_def_map={
      tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: signature
   }
)
builder.save

()

Utilisez TensorFlow Serving pour servir le modèle

Maintenant que notre modèle est prêt, il est temps de le servir à l'aide de TensorFlow Serving. Veuillez suivre les étapes ci-dessous -

Connectez-vous avec TensorFlow Serving

Dans le script Python, utilisez le protocole gRPC pour établir une connexion avec TensorFlow Serving. Voici un exemple -

from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc

channel = grpc.insecure_channel('localhost:8501')
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)

Créer une demande

Pour faire une prédiction, créez un message de requête protobuf et spécifiez le nom du modèle et le nom de la signature. Voici un exemple -

request = predict_pb2.PredictRequest()
request.model_spec.name = 'my_model'
request.model_spec.signature_name = tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
request.inputs['input'].CopyFrom(tf.contrib.util.make_tensor_proto(data, shape=data.shape))

Remplacez `data` par les données d'entrée que vous souhaitez prédire.

Envoyez une demande et obtenez une réponse

Envoyez la requête à TensorFlow Serving et récupérez la réponse. Voici un exemple -

response = stub.Predict(request, timeout_seconds)
output = tf.contrib.util.make_ndarray(response.outputs['output'])

Le paramètre

`timeout_seconds` spécifie le temps maximum d'attente d'une réponse.

Tester le modèle déployé

Pour garantir que le modèle déployé fonctionne correctement, il doit être testé avec des exemples d'entrées. Voici comment tester un modèle déployé -

Préparer des exemples de données

Créez un ensemble d’exemples de données d’entrée qui correspondent au format d’entrée attendu du modèle.

Envoyer une demande à un modèle déployé

Créez et envoyez des requêtes aux modèles déployés.

request = predict_pb2.PredictRequest()
request.model_spec.name = 'my_model'
request.model_spec.signature_name = tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
request.inputs['input'].CopyFrom(tf.contrib.util.make_tensor_proto(data, shape=data.shape))

Évaluer le résultat

Comparez le résultat reçu du modèle déployé avec le résultat attendu. Cette étape garantit que le modèle fait des prédictions précises.

Mise à l'échelle et surveillance des déploiements

À mesure que la demande prévue augmente, il est essentiel d'adapter votre déploiement pour gérer de grands volumes de demandes entrantes. De plus, la surveillance des déploiements permet de suivre les performances et l’état des modèles déployés. Envisagez de mettre en œuvre les stratégies de mise à l'échelle et de surveillance suivantes : 

Zoom

• Utilisez plusieurs instances de TensorFlow Serving pour l'équilibrage de charge.

• Containerisez à l'aide de plateformes comme Docker et Kubernetes.

Surveillance

• Collectez des métriques telles que la latence des requêtes, le taux d'erreur et le débit.

• Définissez des alertes et des notifications pour les événements critiques.

Exemple

L'exemple de programme ci-dessous montre comment déployer un modèle à l'aide du service TensorFlow -

import tensorflow as tf
from tensorflow import keras

# Load the trained model
model = keras.models.load_model("/path/to/your/trained/model")

# Convert the model to the TensorFlow SavedModel format
export_path = "/path/to/exported/model"
tf.saved_model.save(model, export_path)

# Start the TensorFlow Serving server
import os
os.system("tensorflow_model_server --port=8501 --model_name=your_model --model_base_path={}".format(export_path))

Dans l'exemple ci-dessus, vous devez remplacer "/path/to/your/trained/model" par le chemin réel vers le modèle entraîné. Le modèle sera chargé à l'aide de la fonction load_model() de Keras.

Ensuite, le modèle sera converti au format TensorFlow SavedModel et enregistré dans le chemin d'exportation spécifié.

Utilisez ensuite la fonction os.system() pour démarrer le serveur TensorFlow Serving, qui exécute la commande tensorflow_model_server. Cette commande spécifie le port du serveur, le nom du modèle (votre_modèle) et le chemin de base où se trouve le modèle exporté.

Veuillez vous assurer que TensorFlow Serving est installé et remplacez le chemin du fichier par la valeur appropriée pour votre système.

Sortie souhaitée

Une fois le serveur démarré avec succès, il sera prêt à fournir des services de prédiction. Vous pouvez utiliser d'autres programmes ou API pour envoyer des requêtes de prédiction au serveur, et le serveur répondra avec une sortie de prédiction basée sur le modèle chargé.

Conclusion

En résumé, il est important de déployer des modèles d'apprentissage automatique dans des environnements de production pour tirer parti de leurs capacités prédictives. Dans cet article, nous explorons le processus de déploiement de modèles en Python à l'aide de TensorFlow Serving. Nous avons discuté de l'installation de TensorFlow Serving, de la préparation du déploiement du modèle, de la diffusion du modèle et du test de ses performances. Avec les étapes suivantes, nous pouvons déployer avec succès le modèle TensorFlow et effectuer des prédictions précises en temps réel.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!