Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

TensorFlow Servir avec Docker

L' un des moyens les plus faciles pour commencer à utiliser Serving tensorflow est avec 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 les noeuds finaux de service supplémentaires, consultez l' API REST client .

Installer Docker

Instructions générales d'installation sont sur le site Docker , mais nous donnons quelques liens ici:

Servir avec Docker

Tirer une image de service

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

docker pull tensorflow/serving

Cela entraînera une image Docker minimale avec TensorFlow Serving installé.

Voir le Hub Docker repo tensorflow / service pour les autres versions d'images que vous pouvez tirer.

Exécuter une image de diffusion

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

  • Port 8500 exposé pour gRPC
  • Port 8501 exposé pour l'API REST
  • Environnement variable facultative MODEL_NAME (par défaut model )
  • Variable d' environnement en option 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 des éléments suivants :

  • Un port ouvert sur votre hôte pour servir sur
  • Un modèle enregistré à servir
  • Un nom pour votre modèle auquel votre client se référera

Qu'est - ce que vous allez faire est exécuter le Docker conteneur, publier aux ports de votre hôte ports du conteneur, et monter le chemin de votre hôte au SavedModel 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 commencé un conteneur Docker, publié le port API REST 8501 au port de notre hôte 8501, et pris un modèle que nous avons appelé my_model et lié au chemin de base de modèle par défaut ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Enfin, nous avons rempli dans la variable d' environnement MODEL_NAME avec my_model , et à gauche 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 gRPC et REST API en même temps, ou choisir de n'ouvrir que l'un ou l'autre.

Passer des arguments supplémentaires

tensorflow_model_server soutient de nombreux arguments supplémentaires que vous pouvez passer aux conteneurs au service de docker. 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 l' un des autres arguments de ligne de commande qui tensorflow_model_server supports.

Créer votre propre image de service

Si vous souhaitez une image à diffuser qui intègre votre modèle dans le 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 modèle du conteneur :

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

Enfin, engager le conteneur qui est au service de votre modèle en changeant MODEL_NAME pour correspondre 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é <my container> que vous pouvez déployer et chargerez votre modèle pour servir au démarrage.

Exemple de service

Examinons un exemple complet où nous chargeons un SavedModel et l'appelons à l'aide de l'API REST. Commencez par extraire l'image de diffusion :

docker pull tensorflow/serving

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

Ensuite, nous allons utiliser 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, 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 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 TensorFlow Serving Model Server, liera le port REST API 8501 et mappera notre modèle souhaité de notre hôte à l'endroit où les modèles sont attendus dans le conteneur. Nous passons é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] }

Plus d' informations sur l' utilisation de l'API RESTful se trouve ici .

Servir avec Docker en utilisant votre GPU

Installer nvidia-docker

Avant de servir avec un GPU, en plus de l' installation Docker , vous aurez besoin:

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, voir courir une image au service .

Exemple de service GPU

Examinons 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.

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

docker pull tensorflow/serving:latest-gpu

Cela réduira une image Docker minimale avec ModelServer conçu pour s'exécuter sur les GPU installés.

Ensuite, nous allons utiliser 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, 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 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 TensorFlow Serving Model Server, liera le port REST API 8501 et mappera notre modèle souhaité de notre hôte à l'endroit où les modèles sont attendus dans le conteneur. Nous passons également le nom du modèle en tant que variable d'environnement, ce qui sera important lorsque nous interrogerons le modèle.

ASTUCE : avant d'interroger le modèle, assurez-vous d'attendre jusqu'à ce que vous voyiez un message comme le suivant, 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 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] }

ASTUCE : Essayer d'exécuter le modèle GPU sur une machine sans GPU ou sans une version GPU fonctionnelle 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

Plus d' informations sur l' utilisation de l'API RESTful se trouve ici .

Développer avec Docker

Pour obtenir des instructions sur la façon de construire et de développer tensorflow Serving, s'il vous plaît se référer à développement avec un guide Docker .