L'un des moyens les plus simples de commencer à utiliser TensorFlow Serving consiste à 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 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 Professionnel ou version ultérieure
- Docker Toolbox pour les versions beaucoup plus anciennes de macOS ou les versions de Windows antérieures à Windows 10 Pro
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 :
- Pilotes NVIDIA à jour pour votre système
-
nvidia-docker
: Vous pouvez suivre les instructions d'installation ici
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 .