Diffusion TensorFlow avec Docker

L'un des moyens les plus simples de commencer à utiliser TensorFlow Serving consiste à utiliser Docker .

# Download the TensorFlow Serving Docker image and repo
docker pull tensorflow/serving

git clone https://github.com/tensorflow/serving
# Location of demo models
TESTDATA="$(pwd)/serving/tensorflow_serving/servables/tensorflow/testdata"

# Start TensorFlow Serving container and open the REST API port
docker run -t --rm -p 8501:8501 \
    -v "$TESTDATA/saved_model_half_plus_two_cpu:/models/half_plus_two" \
    -e MODEL_NAME=half_plus_two \
    tensorflow/serving &

# Query the model using the predict API
curl -d '{"instances": [1.0, 2.0, 5.0]}' \
    -X POST http://localhost:8501/v1/models/half_plus_two:predict

# Returns => { "predictions": [2.5, 3.0, 4.5] }

Pour des points de terminaison de diffusion supplémentaires, consultez l' API REST client .

Installer Docker

Les instructions générales d'installation se trouvent sur le site Docker , mais nous donnons quelques liens rapides ici :

Servir avec Docker

Extraire une image de service

Une fois Docker installé, vous pouvez extraire la dernière image Docker TensorFlow Serving en exécutant :

docker pull tensorflow/serving

Cela affichera une image Docker minimale avec TensorFlow Serving installé.

Consultez le référentiel tensorflow/serving Docker Hub pour d'autres versions d'images que vous pouvez extraire.

Exécuter une image de diffusion

Les images diffusées (CPU et GPU) ont les propriétés suivantes :

  • Port 8500 exposé pour gRPC
  • Port 8501 exposé pour l'API REST
  • Variable d'environnement facultative MODEL_NAME (par défaut, model )
  • Variable d'environnement facultative MODEL_BASE_PATH (par défaut /models )

Lorsque l'image diffusée exécute ModelServer, elle l'exécute comme suit :

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=${MODEL_NAME} --model_base_path=${MODEL_BASE_PATH}/${MODEL_NAME}

Pour servir avec Docker, vous aurez besoin de :

  • Un port ouvert sur votre hôte pour servir
  • Un SavedModel à servir
  • Un nom pour votre modèle auquel votre client fera référence

Ce que vous allez faire est d'exécuter le conteneur Docker , de publier les ports du conteneur sur les ports de votre hôte et de monter le chemin de votre hôte vers le SavedModel là où le conteneur attend les modèles.

Regardons un exemple :

docker run -p 8501:8501 \
  --mount type=bind,source=/path/to/my_model/,target=/models/my_model \
  -e MODEL_NAME=my_model -t tensorflow/serving

Dans ce cas, nous avons démarré un conteneur Docker, publié le port 8501 de l'API REST sur le port 8501 de notre hôte, pris un modèle que nous avons nommé my_model et l'avons lié au chemin de base du modèle par défaut ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Enfin, nous avons rempli la variable d'environnement MODEL_NAME avec my_model et laissé MODEL_BASE_PATH à sa valeur par défaut.

Cela s'exécutera dans le conteneur :

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=my_model --model_base_path=/models/my_model

Si nous voulions publier le port gRPC, nous utiliserions -p 8500:8500 . Vous pouvez ouvrir les ports de l'API gRPC et REST en même temps, ou choisir de n'ouvrir que l'un ou l'autre.

Passer des arguments supplémentaires

tensorflow_model_server prend en charge de nombreux arguments supplémentaires que vous pouvez transmettre aux conteneurs Docker de diffusion. Par exemple, si nous voulions transmettre un fichier de configuration de modèle au lieu de spécifier le nom du modèle, nous pourrions procéder comme suit :

docker run -p 8500:8500 -p 8501:8501 \
  --mount type=bind,source=/path/to/my_model/,target=/models/my_model \
  --mount type=bind,source=/path/to/my/models.config,target=/models/models.config \
  -t tensorflow/serving --model_config_file=/models/models.config

Cette approche fonctionne pour tous les autres arguments de ligne de commande pris en charge par tensorflow_model_server .

Créer votre propre image de service

Si vous souhaitez une image de diffusion dans laquelle votre modèle est intégré au conteneur, vous pouvez créer votre propre image.

Exécutez d’abord une image diffusée en tant que démon :

docker run -d --name serving_base tensorflow/serving

Ensuite, copiez votre SavedModel dans le dossier modèle du conteneur :

docker cp models/<my model> serving_base:/models/<my model>

Enfin, validez le conteneur qui sert votre modèle en modifiant MODEL_NAME pour qu'il corresponde au nom de votre modèle ` ' :

docker commit --change "ENV MODEL_NAME <my model>" serving_base <my container>

Vous pouvez maintenant arrêter serving_base

docker kill serving_base

Cela vous laissera avec une image Docker appelée <my container> que vous pourrez déployer et qui chargera votre modèle pour le servir au démarrage.

Exemple de service

Passons en revue un exemple complet dans lequel nous chargeons un SavedModel et l'appelons à l'aide de l'API REST. Tirez d’abord l’image de service :

docker pull tensorflow/serving

Cela extraira la dernière image TensorFlow Serving avec ModelServer installé.

Ensuite, nous utiliserons un modèle de jouet appelé Half Plus Two , qui génère 0.5 * x + 2 pour les valeurs de x que nous fournissons pour la prédiction.

Pour obtenir ce modèle, clonez d'abord le dépôt TensorFlow Serving.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

Ensuite, exécutez le conteneur TensorFlow Serving en le pointant vers ce modèle et en ouvrant le port de l'API REST (8501) :

docker run -p 8501:8501 \
  --mount type=bind,\
source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_cpu,\
target=/models/half_plus_two \
  -e MODEL_NAME=half_plus_two -t tensorflow/serving &

Cela exécutera le conteneur Docker et lancera le serveur TensorFlow Serving Model, liera le port 8501 de l'API REST et mappera notre modèle souhaité de notre hôte à l'endroit où les modèles sont attendus dans le conteneur. Nous transmettons également le nom du modèle comme variable d'environnement, ce qui sera important lorsque nous interrogerons le modèle.

Pour interroger le modèle à l'aide de l'API Predict, vous pouvez exécuter

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Cela devrait renvoyer un ensemble de valeurs :

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

Plus d'informations sur l'utilisation de l'API RESTful peuvent être trouvées ici .

Servir avec Docker à l'aide de votre GPU

Installer nvidia-docker

Avant de servir avec un GPU, en plus d' installer Docker , vous aurez besoin de :

Exécuter une image de diffusion GPU

L’exécution d’une image de diffusion GPU est identique à l’exécution d’une image CPU. Pour plus de détails, consultez exécuter une image de diffusion .

Exemple de service GPU

Passons en revue un exemple complet dans lequel nous chargeons un modèle avec des opérations liées au GPU et l'appelons à l'aide de l'API REST.

Installez d'abord nvidia-docker . Ensuite, vous pouvez extraire la dernière image Docker GPU TensorFlow Serving en exécutant :

docker pull tensorflow/serving:latest-gpu

Cela affichera une image Docker minimale avec ModelServer conçu pour fonctionner sur les GPU installés.

Ensuite, nous utiliserons un modèle de jouet appelé Half Plus Two , qui génère 0.5 * x + 2 pour les valeurs de x que nous fournissons pour la prédiction. Ce modèle aura des opérations liées au périphérique GPU et ne fonctionnera pas sur le CPU.

Pour obtenir ce modèle, clonez d'abord le dépôt TensorFlow Serving.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

Ensuite, exécutez le conteneur TensorFlow Serving en le pointant vers ce modèle et en ouvrant le port de l'API REST (8501) :

docker run --gpus all -p 8501:8501 \
--mount type=bind,\
source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_gpu,\
target=/models/half_plus_two \
  -e MODEL_NAME=half_plus_two -t tensorflow/serving:latest-gpu &

Cela exécutera le conteneur Docker, lancera le serveur TensorFlow Serving Model, liera le port 8501 de l'API REST et mappera notre modèle souhaité de notre hôte à l'endroit où les modèles sont attendus dans le conteneur. Nous transmettons également le nom du modèle comme variable d'environnement, ce qui sera important lorsque nous interrogerons le modèle.

CONSEIL : Avant d'interroger le modèle, assurez-vous d'attendre jusqu'à ce que vous voyiez un message comme celui-ci, indiquant que le serveur est prêt à recevoir des requêtes :

2018-07-27 00:07:20.773693: I tensorflow_serving/model_servers/main.cc:333]
Exporting HTTP/REST API at:localhost:8501 ...

Pour interroger le modèle à l'aide de l'API Predict, vous pouvez exécuter

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Cela devrait renvoyer un ensemble de valeurs :

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

CONSEIL : Si vous essayez d'exécuter le modèle GPU sur une machine sans GPU ou sans une version GPU fonctionnelle de TensorFlow Model Server, vous obtiendrez une erreur qui ressemble à :

Cannot assign a device for operation 'a': Operation was explicitly assigned to /device:GPU:0

Plus d'informations sur l'utilisation de l'API RESTful peuvent être trouvées ici .

Développer avec Docker

Pour obtenir des instructions sur la façon de créer et de développer Tensorflow Serving, veuillez vous référer au guide Développement avec Docker .