¡El Día de la Comunidad de ML es el 9 de noviembre! Únase a nosotros para recibir actualizaciones de TensorFlow, JAX, y más Más información

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

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

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 VM mínima con TensorFlow Serving instalado.

  • Dockerfile.gpu , que es una VM mínima con TensorFlow Serving con soporte de GPU para usarse con nvidia-docker .

  • Dockerfile.devel , que es una VM mínima con todas las dependencias necesarias para compilar TensorFlow Serving.

  • Dockerfile.devel-gpu , que es una VM mínima con todas las dependencias necesarias para compilar TensorFlow Serving con compatibilidad con 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 .

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

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 invoca a Bazel. Consulte los documentos de Bazel para obtener 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 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 con el tiempo de ejecución de NVIDIA --runtime=nvidia .

Desde aquí, puede 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 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.

Al Dockerfile.devel una imagen de Docker a partir de los Dockerfile.devel o Dockerfile.devel-gpu , el binario ModelServer se compilará con la marca -march=native . Esto hará que Bazel cree 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:

  1. Clonar el proyecto de publicación de TensorFlow

    git clone https://github.com/tensorflow/serving
    cd serving
    
  2. 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 .
      
  3. 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 el tensorflow/serving:latest 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 optimizada de Docker ahora es $USER/tensorflow-serving-gpu , que puede usar tal como lo haría con la imagen estándar de tensorflow/serving:latest-gpu .