L'un des moyens les plus simples de commencer à utiliser TensorFlow Serving est d'utiliser Docker .
# Download the TensorFlow Serving Docker image and repodocker pull tensorflow/serving
git clone https://github.com/tensorflow/serving
# Location of demo modelsTESTDATA="$(pwd)/serving/tensorflow_serving/servables/tensorflow/testdata"
# Start TensorFlow Serving container and open the REST API portdocker 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 APIcurl -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:
- Docker pour macOS
- Docker pour Windows pour Windows 10 Pro ou version ultérieure
- Docker Toolbox pour des versions beaucoup plus anciennes de macOS ou des versions de Windows antérieures à Windows 10 Pro
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éfautmodel
) - 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:
- Pilotes NVIDIA à jour pour votre système
-
nvidia-docker
: vous pouvez suivre les instructions d'installation ici
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 .