¡Únase a la comunidad de SIG TFX-Addons y ayude a que TFX sea aún mejor!

Publicación de TensorFlow con Docker

Una de las formas más fáciles de comenzar a usar TensorFlow Serving es con Docker .

# Download the TensorFlow Serving Docker image and repo
docker pull tensorflow/serving
git clone https://github.com/tensorflow/serving # Location of demo models TESTDATA="$(pwd)/serving/tensorflow_serving/servables/tensorflow/testdata" # Start TensorFlow Serving container and open the REST API port docker run -t --rm -p 8501:8501 \ -v "$TESTDATA/saved_model_half_plus_two_cpu:/models/half_plus_two" \ -e MODEL_NAME=half_plus_two \ tensorflow/serving & # Query the model using the predict API curl -d '{"instances": [1.0, 2.0, 5.0]}' \ -X POST http://localhost:8501/v1/models/half_plus_two:predict
# Returns => { "predictions": [2.5, 3.0, 4.5] }

Para obtener puntos finales de servicio adicionales, consulte la API de REST de cliente .

Instalar Docker

Las instrucciones generales de instalación se encuentran en el sitio de Docker , pero ofrecemos algunos enlaces rápidos aquí:

Sirviendo con Docker

Tirando de una imagen de servicio

Una vez que haya instalado Docker, puede extraer la última imagen de la ventana acoplable de TensorFlow Serving ejecutando:

docker pull tensorflow/serving

Esto desplegará una imagen mínima de Docker con TensorFlow Serving instalado.

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

Ejecutando una imagen de publicación

Las imágenes de servicio (tanto CPU como GPU) tienen las siguientes propiedades:

  • Puerto 8500 expuesto para gRPC
  • Puerto 8501 expuesto para la API REST
  • Variable de entorno opcional MODEL_NAME (por defecto es model )
  • Variable de entorno opcional MODEL_BASE_PATH (por defecto es /models )

Cuando la imagen de servicio ejecuta ModelServer, lo ejecuta de la siguiente manera:

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=${MODEL_NAME} --model_base_path=${MODEL_BASE_PATH}/${MODEL_NAME}

Para servir con Docker, necesitará:

  • Un puerto abierto en su host para servir
  • Un modelo guardado para servir
  • Un nombre para su modelo al que se referirá su cliente

Lo que hará es ejecutar el contenedor Docker , publicar los puertos del contenedor en los puertos de su host y montar la ruta de su host al modelo guardado donde el contenedor espera modelos.

Veamos un ejemplo:

docker run -p 8501:8501 \
  --mount type=bind,source=/path/to/my_model/,target=/models/my_model \
  -e MODEL_NAME=my_model -t tensorflow/serving

En este caso, iniciamos un contenedor Docker, publicamos el puerto de la API REST 8501 en el puerto 8501 de nuestro host, y tomamos un modelo que llamamos my_model y lo my_model a la ruta base del modelo predeterminada ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Finalmente, completamos la variable de entorno MODEL_NAME con my_model , y dejamos MODEL_BASE_PATH a su valor predeterminado.

Esto se ejecutará en el contenedor:

tensorflow_model_server --port=8500 --rest_api_port=8501 \
  --model_name=my_model --model_base_path=/models/my_model

Si quisiéramos publicar el puerto gRPC, usaríamos -p 8500:8500 . Puede tener abiertos los puertos de API de REST y gRPC al mismo tiempo, o elegir abrir solo uno u otro.

Pasando argumentos adicionales

tensorflow_model_server admite muchos argumentos adicionales que podría pasar a los contenedores de la ventana acoplable de servicio. Por ejemplo, si quisiéramos pasar un archivo de configuración de modelo en lugar de especificar el nombre del modelo, podríamos hacer lo siguiente:

docker run -p 8500:8500 -p 8501:8501 \
  --mount type=bind,source=/path/to/my_model/,target=/models/my_model \
  --mount type=bind,source=/path/to/my/models.config,target=/models/models.config \
  -t tensorflow/serving --model_config_file=/models/models.config

Este enfoque funciona para cualquiera de los otros argumentos de la línea de comandos que admite tensorflow_model_server .

Creando su propia imagen de servicio

Si desea una imagen de publicación que tenga su modelo integrado en el contenedor, puede crear su propia imagen.

Primero ejecute una imagen de servicio como un demonio:

docker run -d --name serving_base tensorflow/serving

A continuación, copie su modelo guardado en la carpeta del modelo del contenedor:

docker cp models/<my model> serving_base:/models/<my model>

Finalmente, confirme el contenedor que está sirviendo su modelo cambiando MODEL_NAME para que coincida con el nombre de su modelo ` ':

docker commit --change "ENV MODEL_NAME <my model>" serving_base <my container>

Ahora puede dejar de serving_base

docker kill serving_base

Esto te dejará con una imagen de Docker llamada <my container> que puedes implementar y cargará tu modelo para servir al inicio.

Ejemplo de servicio

Repasemos un ejemplo completo donde cargamos un modelo guardado y lo llamamos usando la API REST. Primero, extraiga la imagen de servicio

docker pull tensorflow/serving

Esto extraerá la imagen de publicación de TensorFlow más reciente con ModelServer instalado.

A continuación, usaremos un modelo de juguete llamado Half Plus Two , que genera 0.5 * x + 2 para los valores de x que proporcionamos para la predicción.

Para obtener este modelo, primero clone el repositorio de publicación de TensorFlow.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

A continuación, ejecute el contenedor de publicación de TensorFlow apuntándolo a este modelo y abriendo el puerto de la API REST (8501):

docker run -p 8501:8501 \
  --mount type=bind,\
source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_cpu,\
target=/models/half_plus_two \
  -e MODEL_NAME=half_plus_two -t tensorflow/serving &

Esto ejecutará el contenedor de la ventana acoplable y lanzará TensorFlow Serving Model Server, vinculará el puerto de la API REST 8501 y mapeará nuestro modelo deseado desde nuestro host a donde se esperan modelos en el contenedor. También pasamos el nombre del modelo como una variable de entorno, que será importante cuando consultemos el modelo.

Para consultar el modelo utilizando la API de predicción, puede ejecutar

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Esto debería devolver un conjunto de valores:

{ "predictions": [2.5, 3.0, 4.5] }

Puede encontrar más información sobre el uso de la API RESTful aquí .

Sirviendo con Docker usando su GPU

Instalar nvidia-docker

Antes de servir con una GPU, además de instalar Docker , necesitará:

Ejecutando una imagen de servicio de GPU

Ejecutar una imagen de servicio de GPU es idéntico a ejecutar una imagen de CPU. Para obtener más detalles, consulte ejecutar una imagen de publicación .

Ejemplo de servicio de GPU

Repasemos un ejemplo completo en el que cargamos un modelo con operaciones vinculadas a la GPU y lo llamamos usando la API REST.

Primero instale nvidia-docker . A continuación, puede extraer la imagen de la ventana acoplable de GPU de servicio de TensorFlow más reciente ejecutando:

docker pull tensorflow/serving:latest-gpu

Esto desplegará una imagen mínima de Docker con ModelServer creado para ejecutarse en GPU instaladas.

A continuación, usaremos un modelo de juguete llamado Half Plus Two , que genera 0.5 * x + 2 para los valores de x que proporcionamos para la predicción. Este modelo tendrá operaciones vinculadas al dispositivo GPU y no se ejecutará en la CPU.

Para obtener este modelo, primero clone el repositorio de publicación de TensorFlow.

mkdir -p /tmp/tfserving
cd /tmp/tfserving
git clone https://github.com/tensorflow/serving

A continuación, ejecute el contenedor de publicación de TensorFlow apuntándolo a este modelo y abriendo el puerto de la API REST (8501):

docker run --runtime=nvidia -p 8501:8501 \
--mount type=bind,\
source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_gpu,\
target=/models/half_plus_two \
  -e MODEL_NAME=half_plus_two -t tensorflow/serving:latest-gpu &

Esto ejecutará el contenedor de la nvidia-docker tiempo de ejecución de nvidia-docker , lanzará el servidor de modelos de servicio de TensorFlow, vinculará el puerto de la API REST 8501 y mapeará nuestro modelo deseado desde nuestro host al lugar donde se esperan modelos en el contenedor. También pasamos el nombre del modelo como una variable de entorno, que será importante cuando consultemos el modelo.

SUGERENCIA: antes de consultar el modelo, asegúrese de esperar hasta que vea un mensaje como el siguiente, que indica que el servidor está listo para recibir solicitudes:

2018-07-27 00:07:20.773693: I tensorflow_serving/model_servers/main.cc:333]
Exporting HTTP/REST API at:localhost:8501 ...

Para consultar el modelo utilizando la API de predicción, puede ejecutar

curl -d '{"instances": [1.0, 2.0, 5.0]}' \
  -X POST http://localhost:8501/v1/models/half_plus_two:predict

Esto debería devolver un conjunto de valores:

{ "predictions": [2.5, 3.0, 4.5] }

SUGERENCIA: Intentar ejecutar el modelo de GPU en una máquina sin GPU o sin una compilación de GPU funcional de TensorFlow Model Server dará como resultado un error que se parece a lo siguiente:

Cannot assign a device for operation 'a': Operation was explicitly assigned to /device:GPU:0

Puede encontrar más información sobre el uso de la API RESTful aquí .

Desarrollando con Docker

Para obtener instrucciones sobre cómo compilar y desarrollar Tensorflow Serving, consulte la guía Desarrollar con Docker .