TFX | TensorFlow

Esta página se ha traducido con Cloud Translation API.

Desarrollando con Docker

Tirando de una imagen de desarrollo

Para un entorno de desarrollo donde puedas construir TensorFlow Serving, puedes probar:

docker pull tensorflow/serving:latest-devel

Para un entorno de desarrollo donde pueda crear TensorFlow Serving con soporte para GPU, use:

docker pull tensorflow/serving:latest-devel-gpu

Consulte el repositorio de tensorflow/serving de Docker Hub para conocer otras versiones de imágenes que puede extraer.

Ejemplo de desarrollo

Después de extraer una de las imágenes de desarrollo de Docker, puede ejecutarla mientras abre el puerto gRPC (8500):

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

Probar el entorno de desarrollo

Para probar un modelo, desde el interior del contenedor intente:

# 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

archivos Docker

Actualmente mantenemos los siguientes Dockerfiles:

Dockerfile , que es una máquina virtual mínima con TensorFlow Serving instalado.
Dockerfile.gpu , que es una máquina virtual mínima con TensorFlow Serving con soporte para GPU para usarse con nvidia-docker .
Dockerfile.devel , que es una máquina virtual mínima con todas las dependencias necesarias para crear TensorFlow Serving.
Dockerfile.devel-gpu , que es una máquina virtual mínima con todas las dependencias necesarias para crear TensorFlow Serving con soporte para GPU.

Construyendo un contenedor a partir de un Dockerfile

Si desea crear su propia imagen de Docker a partir de un Dockerfile, puede hacerlo ejecutando el comando 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 .

SUGERENCIA: Antes de intentar crear una imagen, verifique el repositorio de tensorflow/serving de Docker Hub para asegurarse de que no exista una imagen que satisfaga sus necesidades.

La compilación a partir de fuentes consume mucha RAM. Si la RAM es un problema en su sistema, puede limitar el uso de RAM especificando --local_ram_resources=2048 mientras invoca Bazel. Consulte los documentos de Bazel para obtener más información. Puedes usar este mismo mecanismo para modificar las optimizaciones con las que estás creando TensorFlow Serving. Por ejemplo:

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 .

Ejecutando un contenedor

Esto supone que ha creado el contenedor Dockerfile.devel .

Para ejecutar el contenedor abriendo el puerto gRPC (8500):

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

SUGERENCIA: Si está ejecutando una imagen de GPU, asegúrese de ejecutarla utilizando el tiempo de ejecución de NVIDIA --runtime=nvidia .

Desde aquí, puedes seguir las instrucciones para probar un entorno de desarrollo .

Construyendo un binario de servicio optimizado

Al ejecutar ModelServer de TensorFlow Serving, es posible que observe un mensaje de registro similar a este:

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

Esto indica que su binario ModelServer no está completamente optimizado para la CPU en la que se ejecuta. Dependiendo del modelo que esté sirviendo, es posible que no sean necesarias más optimizaciones. Sin embargo, construir un binario optimizado es sencillo.

Al crear una imagen de Docker a partir de los archivos Dockerfile.devel o Dockerfile.devel-gpu proporcionados, el binario de ModelServer se creará con la bandera -march=native . Esto hará que Bazel cree un binario de ModelServer con todas las optimizaciones de CPU que admite el host en el que está creando la imagen de Docker.

Para crear una imagen de publicación que esté completamente optimizada para su host, simplemente:

Clonar el proyecto de servicio TensorFlow

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

Construya una imagen con un ModelServer optimizado

Para CPU:

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

Para GPU: `

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

Cree una imagen de publicación con la imagen de desarrollo como base.
- Para CPU:
```
docker build -t $USER/tensorflow-serving \
  --build-arg TF_SERVING_BUILD_IMAGE=$USER/tensorflow-serving-devel \
  -f tensorflow_serving/tools/docker/Dockerfile .
```
  Su nueva imagen optimizada de Docker ahora es $USER/tensorflow-serving , que puede usar tal como lo haría con la imagen estándar tensorflow/serving:latest .
- Para 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 .
```
  Su nueva imagen optimizada de Docker ahora es $USER/tensorflow-serving-gpu , que puede usar tal como lo haría con la imagen estándar tensorflow/serving:latest-gpu .