TFX | TensorFlow

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

Développer avec Docker

Extraire 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 prise en charge GPU, utilisez :

docker pull tensorflow/serving:latest-devel-gpu

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

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

Fichiers Docker

Nous maintenons actuellement les fichiers Docker suivants :

Dockerfile , qui est une VM minimale sur laquelle TensorFlow Serving est installé.
Dockerfile.gpu , qui est une VM minimale avec TensorFlow Serving avec prise en charge GPU à utiliser avec nvidia-docker .
Dockerfile.devel , qui est une VM minimale avec toutes les dépendances nécessaires pour créer TensorFlow Serving.
Dockerfile.devel-gpu , qui est une VM minimale avec toutes les dépendances nécessaires pour créer TensorFlow Serving avec prise en charge 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 Docker build :

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 créer une image, vérifiez le référentiel tensorflow/serving Docker Hub pour vous assurer qu'une image répondant à vos besoins n'existe pas déjà.

Construire à partir de sources consomme beaucoup de RAM. Si la RAM pose un problème sur votre système, vous pouvez limiter l'utilisation de la RAM en spécifiant --local_ram_resources=2048 lors de l'appel de Bazel. Consultez la documentation Bazel pour plus d’informations. Vous pouvez utiliser ce même mécanisme pour modifier les optimisations avec lesquelles vous créez TensorFlow Serving. Par exemple:

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 créé le conteneur Dockerfile.devel .

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

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

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

À partir 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 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 proposez, d'autres optimisations peuvent ne pas être nécessaires. Cependant, créer un binaire optimisé est simple.

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

Pour créer une image de diffusion entièrement optimisée pour votre hôte, procédez simplement :

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 nouvelle image Docker optimisée est désormais $USER/tensorflow-serving , que vous pouvez utiliser comme vous le feriez pour l'image tensorflow/serving:latest standard.
- Pour les 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 désormais $USER/tensorflow-serving-gpu , que vous pouvez utiliser comme vous le feriez pour l'image tensorflow/serving:latest-gpu standard.