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

Servicio de TensorFlow con Docker

Una de las formas más sencillas de empezar a utilizar 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 puntos finales de servicio adicionales, consulte la API REST del cliente .

Instalar ventana acoplable

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

Ventana acoplable para MacOS
Docker para Windows para Windows 10 Pro o posterior
Docker Toolbox para versiones mucho más antiguas de macOS o versiones de Windows anteriores a Windows 10 Pro

Sirviendo con Docker

Extrayendo una imagen de publicación

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

docker pull tensorflow/serving

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

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

Ejecutar una imagen de publicación

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

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

Cuando la imagen publicada 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 su cliente se referirá

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 SavedModel donde el contenedor espera los 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 8501 de la API REST en el puerto 8501 de nuestro host, tomamos un modelo al que llamamos my_model y lo vinculamos 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 con 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 gRPC y REST API al mismo tiempo, o elegir abrir solo uno u otro.

Pasar argumentos adicionales

tensorflow_model_server admite muchos argumentos adicionales que puede pasar a los contenedores acoplables de servicio. Por ejemplo, si quisiéramos pasar un archivo de configuración del 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 comando que admite tensorflow_model_server .

Creando tu 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 publicación como demonio:

docker run -d --name serving_base tensorflow/serving

A continuación, copie su SavedModel a la carpeta del modelo del contenedor:

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

Finalmente, confirme el contenedor que sirve a 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 puedes dejar de serving_base

docker kill serving_base

Esto le dejará con una imagen de Docker llamada <my container> que puede implementar y cargará su modelo para servir al inicio.

ejemplo de servicio

Veamos un ejemplo completo en el que cargamos un SavedModel y lo llamamos usando la API REST. Primero extraiga la imagen de publicación:

docker pull tensorflow/serving

Esto extraerá la última imagen de TensorFlow Serving 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 TensorFlow Serving.

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

A continuación, ejecute el contenedor TensorFlow Serving apuntándolo a este modelo y abriendo el puerto 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 acoplable e iniciará el servidor de modelos de servicio TensorFlow, vinculará el puerto 8501 de la API REST y asignará nuestro modelo deseado desde nuestro host al lugar donde se esperan los modelos en el contenedor. También pasamos el nombre del modelo como variable de entorno, lo cual 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 tu GPU

Instalar nvidia-docker

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

Controladores NVIDIA actualizados para su sistema
nvidia-docker : Puedes seguir las instrucciones de instalación aquí.

Ejecutar una imagen de servicio de GPU

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

Ejemplo de servicio de GPU

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

Primero instale nvidia-docker . A continuación, puede obtener la última imagen de la ventana acoplable GPU de TensorFlow Serving 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 TensorFlow Serving.

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

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

docker run --gpus all -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 acoplable, iniciará el servidor de modelos de servicio TensorFlow, vinculará el puerto 8501 de la API REST y asignará nuestro modelo deseado desde nuestro host al lugar donde se esperan los modelos en el contenedor. También pasamos el nombre del modelo como variable de entorno, lo cual será importante cuando consultemos el modelo.

SUGERENCIA: Antes de consultar el modelo, asegúrese de esperar hasta ver 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 generará un error similar al 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 crear y desarrollar Tensorflow Serving, consulte la guía Desarrollo con Docker .