TFX | TensorFlow

Cette page a été traduite par l'API Cloud Translation.

Développer avec Docker

Tirer une image de développement

Pour un environnement de développement dans lequel vous pouvez créer TensorFlow Serving, vous pouvez essayer :

docker pull tensorflow/serving:latest-devel

Pour un environnement de développement dans lequel vous pouvez créer TensorFlow Serving avec la prise en charge du GPU, utilisez :

docker pull tensorflow/serving:latest-devel-gpu

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

Exemple de développement

Après avoir extrait l'une des images Docker de développement, vous pouvez l'exécuter tout en ouvrant le port gRPC (8500) :

docker run -it -p 8500:8500 --gpus all tensorflow/serving:latest-devel

Tester l'environnement de développement

Pour tester un modèle, depuis l'intérieur du conteneur, essayez :

# train the mnist model
python tensorflow_serving/example/mnist_saved_model.py /tmp/mnist_model
# serve the model
tensorflow_model_server --port=8500 --model_name=mnist --model_base_path=/tmp/mnist_model/ &
# test the client
python tensorflow_serving/example/mnist_client.py --num_tests=1000 --server=localhost:8500

Dockerfiles

Nous maintenons actuellement les fichiers Docker suivants :

Dockerfile , qui est une machine virtuelle minimale avec tensorflow Serving installé.
Dockerfile.gpu , qui est une machine virtuelle minimale avec tensorflow service avec le soutien du GPU à utiliser avec nvidia-docker .
Dockerfile.devel , qui est une machine virtuelle minimale avec toutes les dépendances nécessaires à la construction tensorflow service.
Dockerfile.devel-gpu , qui est une machine virtuelle minimale avec toutes les dépendances nécessaires à la construction tensorflow service avec le soutien du GPU.

Construire un conteneur à partir d'un Dockerfile

Si vous souhaitez créer votre propre image Docker à partir d'un fichier Docker, vous pouvez le faire en exécutant la commande de build Docker :

Dockerfile :

docker build --pull -t $USER/tensorflow-serving .

Dockerfile.gpu :

docker build --pull -t $USER/tensorflow-serving-gpu -f Dockerfile.gpu .

Dockerfile.devel :

docker build --pull -t $USER/tensorflow-serving-devel -f Dockerfile.devel .

Dockerfile.devel-gpu :

docker build --pull -t $USER/tensorflow-serving-devel-gpu -f Dockerfile.devel-gpu .

CONSEIL: Avant d' essayer de construire une image, vérifiez le Hub Docker repo tensorflow / servir une image qui répond à vos besoins n'existe pas déjà pour vous assurer.

Construire à partir de sources consomme beaucoup de RAM. Si la RAM est un problème sur votre système, vous pouvez limiter l' utilisation de la RAM en spécifiant --local_ram_resources=2048 en invoquant Bazel. Voir les docs Bazel pour plus d' informations. Vous pouvez utiliser ce même mécanisme pour ajuster les optimisations avec lesquelles vous créez TensorFlow Serving. Par example:

docker build --pull --build-arg TF_SERVING_BUILD_OPTIONS="--copt=-mavx \
  --cxxopt=-D_GLIBCXX_USE_CXX11_ABI=0 --local_ram_resources=2048" -t \
  $USER/tensorflow-serving-devel -f Dockerfile.devel .

Exécuter un conteneur

Cela suppose que vous avez construit le Dockerfile.devel conteneur.

Pour exécuter le conteneur en ouvrant le port gRPC (8500) :

docker run -it -p 8500:8500 $USER/tensorflow-serving-devel

CONSEIL: Si vous utilisez une image GPU, assurez - vous d'exécuter à l' aide du NVIDIA runtime --runtime=nvidia .

De là, vous pouvez suivre les instructions pour tester un environnement de développement .

Construire un binaire de service optimisé

Lors de l'exécution du serveur ModelServer de TensorFlow Serving, vous remarquerez peut-être un message de journal qui ressemble à ceci :

I external/org_tensorflow/tensorflow/core/platform/cpu_feature_guard.cc:141]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2 FMA

Cela indique que votre binaire ModelServer n'est pas entièrement optimisé pour le processeur sur lequel il s'exécute. Selon le modèle que vous diffusez, d'autres optimisations peuvent ne pas être nécessaires. Cependant, la construction d'un binaire optimisé est simple.

Lors de la construction d' une image Docker de la condition Dockerfile.devel ou Dockerfile.devel-gpu fichiers, le binaire ModelServer sera construit avec le drapeau -march=native . Cela amènera Bazel à créer un binaire ModelServer avec toutes les optimisations de processeur sur lesquelles l'hôte sur lequel vous construisez l'image Docker prend en charge.

Pour créer une image de diffusion entièrement optimisée pour votre hôte, il vous suffit de :

Cloner le projet TensorFlow Serving

git clone https://github.com/tensorflow/serving
cd serving

Construire une image avec un ModelServer optimisé

Pour le processeur :

docker build --pull -t $USER/tensorflow-serving-devel \
  -f tensorflow_serving/tools/docker/Dockerfile.devel .

Pour le GPU : `

docker build --pull -t $USER/tensorflow-serving-devel-gpu \
  -f tensorflow_serving/tools/docker/Dockerfile.devel-gpu .

Construire une image de diffusion avec l'image de développement comme base
- Pour le processeur :
```
docker build -t $USER/tensorflow-serving \
  --build-arg TF_SERVING_BUILD_IMAGE=$USER/tensorflow-serving-devel \
  -f tensorflow_serving/tools/docker/Dockerfile .
```
  Votre nouveau optimisé l' image Docker est maintenant $USER/tensorflow-serving , que vous pouvez utiliser comme vous le feriez la norme tensorflow/serving:latest image.
- Pour le GPU :
```
docker build -t $USER/tensorflow-serving-gpu \
  --build-arg TF_SERVING_BUILD_IMAGE=$USER/tensorflow-serving-devel-gpu \
  -f tensorflow_serving/tools/docker/Dockerfile.gpu .
```
  Votre nouvelle image Docker optimisée est maintenant $USER/tensorflow-serving-gpu , que vous pouvez utiliser comme vous le feriez la norme tensorflow/serving:latest-gpu image.