RSVP pour votre événement TensorFlow Everywhere local dès aujourd'hui!
Cette page a été traduite par l'API Cloud Translation.
Switch to English

TensorFlow Serving avec Docker

L'un des moyens les plus simples de commencer à utiliser TensorFlow Serving est d'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 du 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 diffusion

Une fois que Docker est installé, vous pouvez extraire la dernière image docker du serveur TensorFlow en exécutant:

docker pull tensorflow/serving

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

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

Exécuter une image de diffusion

Les images de diffusion (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 de diffusion 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 modèle enregistré à servir
  • Un nom pour votre modèle auquel votre client se référera

Ce que vous ferez 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 des 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 et pris un modèle que nous avons nommé my_model et l' my_model 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 fonctionnera 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 simultanément les ports gRPC et REST API 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 service. 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 tensorflow_model_server charge par tensorflow_model_server .

Créer votre propre image de service

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

Exécutez d'abord une image de diffusion en tant que démon:

docker run -d --name serving_base tensorflow/serving

Ensuite, copiez votre SavedModel dans le dossier du 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 de serving_base

docker kill serving_base

Cela vous laissera avec une image Docker appelée <my container> que vous pouvez déployer et 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 diffusion:

docker pull tensorflow/serving

Cela extraira la dernière image de serveur TensorFlow 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 nous fournissons pour la prédiction.

Pour obtenir ce modèle, commencez par cloner le référentiel 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 de modèles de service TensorFlow, liera le port de l'API REST 8501 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 en tant que variable d'environnement, ce qui sera important lorsque nous interrogerons le modèle.

Pour interroger le modèle à l'aide de l'API de prédiction, 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] }

Vous trouverez plus d'informations sur l'utilisation de l'API RESTful ici .

Servir avec Docker en utilisant votre GPU

Installez nvidia-docker

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

Exécution d'une image de diffusion GPU

L'exécution d'une image de service GPU est identique à l'exécution d'une image CPU. Pour plus d'informations, consultez la section Exécution d'une image de diffusion .

Exemple de service GPU

Passons en revue un exemple complet où 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 du docker du GPU TensorFlow Serving en exécutant:

docker pull tensorflow/serving:latest-gpu

Cela affichera une image Docker minimale avec ModelServer conçu pour s'exécuter 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 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 processeur.

Pour obtenir ce modèle, commencez par cloner le référentiel 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 --runtime=nvidia -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 avec le runtime nvidia-docker , lancera le serveur de modèles de service TensorFlow, liera le port de l'API REST 8501 et mappera notre modèle souhaité de notre hôte à l'emplacement prévu pour les modèles dans le conteneur. Nous transmettons également le nom du modèle en tant que variable d'environnement, ce qui sera important lorsque nous interrogerons le modèle.

CONSEIL: Avant d'interroger le modèle, assurez-vous d'attendre de voir un message comme celui-ci, indiquant que le serveur est prêt à recevoir des demandes:

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: Tenter d'exécuter le modèle GPU sur une machine sans GPU ou sans build GPU fonctionnel de TensorFlow Model Server entraînera une erreur qui ressemble à:

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

Vous trouverez plus d'informations sur l'utilisation de l'API RESTful ici .

Développer avec Docker

Pour obtenir des instructions sur la création et le développement de Tensorflow Serving, veuillez consulter le guide Developing with Docker .