Déploiement d'un modèle TensorFlow simple

Introduction

Ce projet est conçu pour vous guider tout au long du processus de création d'un modèle TensorFlow simple, de son exportation, puis de son déploiement à l'aide de Docker et de TensorFlow Serving. TensorFlow est un framework open-source d'apprentissage automatique, et TensorFlow Serving est un système de déploiement flexible et performant pour les modèles d'apprentissage automatique. Les conteneurs Docker facilitent le packaging et le déploiement cohérent de ces modèles. À la fin de ce projet, vous comprendrez comment configurer un modèle d'apprentissage automatique de base dans TensorFlow, l'exporter pour le déploiement, et le déployer à l'aide de TensorFlow Serving dans un conteneur Docker.

👀 Aperçu

## Envoyer une demande de prédiction au conteneur TensorFlow Serving
curl -X POST \
  http://localhost:9501/v1/models/half_plus_two:predict \
  -d '{"signature_name":"serving_default","instances":[[1.0], [2.0], [5.0]]}'

Sortie :

{
  "predictions": [[2.5], [3.0], [4.5]
  ]
}

🎯 Tâches

Dans ce projet, vous apprendrez :

• Comment installer les dépendances de TensorFlow et de TensorFlow Serving
• Comment créer un modèle TensorFlow simple pour des opérations arithmétiques de base
• Comment exporter le modèle dans un format adapté au déploiement avec TensorFlow Serving
• Comment déployer le modèle à l'aide de Docker et de TensorFlow Serving
• Comment envoyer des demandes de prédiction au modèle déployé et recevoir les prédictions

🏆 Réalisations

Après avoir terminé ce projet, vous serez en mesure de :

• Configurer un modèle d'apprentissage automatique de base dans TensorFlow
• Exporter un modèle TensorFlow pour le déploiement
• Déployer un modèle TensorFlow à l'aide de Docker et de TensorFlow Serving
• Envoyer des demandes de prédiction au modèle déployé et observer les résultats

Installer les dépendances

Avant de commencer, vous devez installer TensorFlow dans votre environnement. De plus, vous allez télécharger l'image TensorFlow Serving depuis Docker Hub pour préparer le déploiement de votre modèle dans un environnement conteneurisé. Exécutez les commandes suivantes dans votre terminal.

Installer TensorFlow :

## Install TensorFlow
pip install tensorflow==2.14.0
## Downgrade numpy to 1.26.4 to avoid compatibility issues with TensorFlow
pip install numpy==1.26.4

Télécharger l'image Docker de TensorFlow Serving :

## Pull TensorFlow Serving image from Docker Hub
docker pull tensorflow/serving

À cette étape, vous avez installé TensorFlow, une bibliothèque puissante pour le calcul numérique et l'apprentissage automatique, puis vous avez téléchargé l'image Docker de TensorFlow Serving.

TensorFlow Serving est spécialement conçu pour déployer des modèles d'apprentissage automatique dans des environnements de production. L'utilisation de Docker garantit que TensorFlow Serving s'exécute dans un environnement isolé avec toutes ses dépendances satisfaites, évitant ainsi les conflits avec d'autres logiciels sur votre machine.

Créer et exporter votre modèle

À cette étape, vous allez définir un modèle TensorFlow simple qui effectue une opération arithmétique de base : multiplier son entrée par 0,5 puis ajouter 2. Après avoir défini le modèle, vous l'exportere dans un format que TensorFlow Serving peut utiliser.

Créez et exportez le modèle dans ~/project/half_plus_two.py :

## Import TensorFlow
import tensorflow as tf

## Define a simple Sequential model
model = tf.keras.Sequential([
    tf.keras.layers.Dense(units=1, input_shape=[1], use_bias=True)
])

## Set the weights to achieve the "multiply by 0.5 and add 2" functionality
weights = [tf.constant([[0.5]]), tf.constant([2.0])]
model.set_weights(weights)

## Compile the model (required even if not training)
model.compile(optimizer='sgd', loss='mean_squared_error')

## Export the model to a SavedModel
export_path = './saved_model_half_plus_two/1'
tf.saved_model.save(model, export_path)

Cette étape consiste à définir un modèle TensorFlow qui effectue une opération simple sur son entrée : multiplier par 0,5 et ajouter 2. Le modèle est ensuite exporté dans un format adapté au déploiement.

• Le modèle est défini à l'aide de l'API Keras de TensorFlow, qui est une API de haut niveau pour la construction et l'entraînement de modèles d'apprentissage profond. Le modèle se compose d'une seule couche dense, qui est une couche de réseau de neurones entièrement connectée.
• Les poids du modèle sont définis manuellement pour obtenir l'opération souhaitée (multiplier par 0,5 et ajouter 2).
• Même si ce modèle ne sera pas entraîné plus loin, il est compilé pour finaliser sa structure, ce qui est une étape obligatoire dans TensorFlow.
• Enfin, le modèle est enregistré au format TensorFlow SavedModel, qui est un répertoire contenant un fichier protobuf et un point de contrôle TensorFlow contenant les poids du modèle. Ce format est requis par TensorFlow Serving pour le déploiement du modèle.

Pour exporter le modèle, exécutez le script dans le terminal :

python half_plus_two.py

Le modèle est enregistré dans ~/project/saved_model_half_plus_two, et la structure du fichier est la suivante :

.
└── saved_model_half_plus_two
└── 1
├── assets
├── fingerprint.pb
├── saved_model.pb
└── variables
├── variables.data-00000-of-00001
└── variables.index

Déployer le modèle à l'aide de Docker et de TensorFlow Serving

Après avoir exporté le modèle, l'étape suivante consiste à le déployer à l'aide de TensorFlow Serving dans un conteneur Docker. Cela permet à votre modèle d'être accessible sur un réseau et de répondre aux demandes de prédiction.

Déployez le modèle avec Docker dans le terminal :

## Serve the model using TensorFlow Serving in a Docker container
docker run -t --rm -p 9500:8500 -p 9501:8501 \
  -v "/home/labex/project/saved_model_half_plus_two:/models/half_plus_two" \
  -e MODEL_NAME=half_plus_two \
  tensorflow/serving

À cette étape, le modèle exporté est déployé à l'aide de TensorFlow Serving dans un conteneur Docker. La commande docker run démarre une instance de TensorFlow Serving et rend le modèle disponible pour les demandes d'inférence.

• Les options -p mappent les ports du conteneur Docker sur votre machine hôte, vous permettant d'envoyer des demandes au serveur de modèles TensorFlow Serving depuis votre machine locale.
• L'option -v monte un volume de votre machine hôte dans le conteneur Docker, rendant le modèle exporté accessible à TensorFlow Serving.
• La variable d'environnement -e MODEL_NAME indique à TensorFlow Serving le nom du modèle à déployer.

Cette configuration encapsule l'environnement de déploiement du modèle, garantissant qu'il s'exécute de manière cohérente, quelle que soit l'endroit où il est déployé.

Envoyer une demande de prédiction à votre modèle

Enfin, vous allez tester le modèle déployé en envoyant une demande de prédiction. Cette demande demandera au modèle d'appliquer sa logique (multiplier par 0,5 et ajouter 2) à un ensemble de valeurs d'entrée.

Envoyez une demande de prédiction dans un autre nouveau terminal :

## Send a prediction request to the TensorFlow Serving container
curl -X POST \
  http://localhost:9501/v1/models/half_plus_two:predict \
  -d '{"signature_name":"serving_default","instances":[[1.0], [2.0], [5.0]]}'

Sortie :

{
  "predictions": [[2.5], [3.0], [4.5]
  ]
}

Cette étape finale consiste à tester le modèle déployé en envoyant une requête HTTP POST. Cette requête inclut une charge utile JSON avec les instances pour lesquelles des prédictions sont nécessaires.

• La commande curl est utilisée pour envoyer une requête POST au serveur TensorFlow Serving. L'URL spécifie le modèle et le point de terminaison de l'API de prédiction.
• L'option -d fournit les données pour la demande de prédiction au format JSON. La clé signature_name spécifie la signature de déploiement à utiliser, qui est un moyen d'indiquer à TensorFlow Serving quel graphe de calcul exécuter. La clé instances contient les données d'entrée pour la prédiction.

La réponse du serveur inclut les prédictions effectuées par le modèle sur les instances d'entrée fournies, démontrant que le modèle est déployé avec succès et répond aux demandes de prédiction.

Résumé

Dans ce projet, vous avez appris à créer un modèle TensorFlow simple, à l'exporter pour le déploiement et à le déployer à l'aide de TensorFlow Serving et de Docker. Vous avez commencé par installer les dépendances nécessaires, puis défini et exporté un modèle de base. Ensuite, vous avez déployé le modèle à l'aide de TensorFlow Serving dans un conteneur Docker et l'avez testé en envoyant une demande de prédiction. Ce flux de travail est une compétence fondamentale pour déployer des modèles d'apprentissage automatique de manière évolutive et reproductible.