TFX | TensorFlow

Se usó la API de Cloud Translation para traducir esta página.

Desarrollando con Docker

Extraer una imagen de desarrollo

Para un entorno de desarrollo en el que pueda compilar TensorFlow Serving, puede probar:

docker pull tensorflow/serving:latest-devel

Para un entorno de desarrollo en el que pueda compilar TensorFlow Serving con compatibilidad con GPU, use:

docker pull tensorflow/serving:latest-devel-gpu

Ver la ventana acoplable Hub tensorflow / repo servir para otras versiones de las imágenes se puede tirar.

Ejemplo de desarrollo

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

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

Probando 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

Dockerfiles

Actualmente mantenemos los siguientes archivos Docker:

Dockerfile , que es una máquina virtual con un mínimo TensorFlow Sirviendo instalado.
Dockerfile.gpu , que es un VM mínimo con TensorFlow Sirviendo con apoyo GPU para ser utilizado con nvidia-docker .
Dockerfile.devel , que es una máquina virtual mínimo con todas las dependencias necesarias para construir TensorFlow Servir.
Dockerfile.devel-gpu , que es una máquina virtual mínimo con todas las dependencias necesarias para construir TensorFlow Sirviendo con el apoyo de la 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 de compilación de 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 .

CONSEJO: Antes de intentar construir una imagen, compruebe el estibador Hub tensorflow / repo servir para asegurarse de que una imagen que se adapte a sus necesidades aún no existe.

La construcció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 se invoca Basel. Ver los documentos Bazel para más información. Puede utilizar este mismo mecanismo para modificar las optimizaciones con las que está 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 usted ha construido la Dockerfile.devel contenedor.

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

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

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

A partir de aquí, puede seguir las instrucciones para la prueba de un entorno de desarrollo .

Construyendo un binario de servicio optimizado

Al ejecutar ModelServer de TensorFlow Serving, es posible que observe un mensaje de registro que se ve así:

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 está ejecutando. Dependiendo del modelo que esté sirviendo, es posible que no sean necesarias más optimizaciones. Sin embargo, construir un binario optimizado es sencillo.

Cuando se construye una imagen de la ventana acoplable proporcionado Dockerfile.devel o Dockerfile.devel-gpu archivos, el binario ModelServer se construirá con la bandera -march=native . Esto hará que Bazel compile un binario ModelServer con todas las optimizaciones de CPU en las que el host en el que está construyendo la imagen de Docker admite.

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

Clonar el proyecto de publicación de TensorFlow

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

Cree 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 del estibador optimizado es ahora $USER/tensorflow-serving , que se puede utilizar del mismo modo que el estándar tensorflow/serving:latest imagen.
- 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 del estibador optimizado es ahora $USER/tensorflow-serving-gpu , que se puede utilizar si fuera el estándar tal como tensorflow/serving:latest-gpu imagen.