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

Publicación de TensorFlow con Docker

Una de las maneras más fáciles para empezar a usar TensorFlow porción es con estibador .

# 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 que sirven los puntos finales adicionales, consulte la API de cliente REST .

Instalar Docker

Instrucciones generales de instalación están en el sitio del estibador , pero nos dan algunos enlaces rápidos aquí:

Docker para macOS
Cargador de muelle para Windows para Windows 10 o posterior Pro
Acoplable caja de herramientas para las versiones más antiguas de MacOS, o versiones de Windows antes de Windows 10 Pro

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.

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

Ejecutando una imagen de publicación

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

Puerto 8500 expuesto para gRPC
Puerto 8501 expuesto para la API REST
Opcional variable de entorno MODEL_NAME (predeterminado en model )
Variable de entorno opcional MODEL_BASE_PATH (predeterminado en /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 en
Un modelo guardado para servir
Un nombre para su modelo al que se referirá su cliente

Lo que vamos a hacer es ejecutar el estibador contenedor, publicar puertos del contenedor a los puertos de su anfitrión, y montar el camino de su anfitrión para el SavedModel a que el recipiente 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, hemos empezado un recipiente estibador, publicado el puerto REST API 8501 al puerto de nuestro anfitrión 8501, y nos llevaron un modelo nombramos my_model y con destino a la ruta de la base modelo por defecto ( ${MODEL_BASE_PATH}/${MODEL_NAME} = /models/my_model ). Por último, hemos llenado en la variable de entorno MODEL_NAME con my_model , y dejamos MODEL_BASE_PATH a su valor por defecto.

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 compatible con muchos argumentos adicionales que se podía pasar a los recipientes que sirven ventana acoplable. 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 línea de comandos que tensorflow_model_server soportes.

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 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>

Por último, cometer el contenedor que está sirviendo su modelo cambiando MODEL_NAME para que coincida con el nombre de su modelo de ` ':

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

Ahora puede dejar de serving_base

docker kill serving_base

Esto le dejará una imagen llamada acoplable con <my container> que se puede desplegar y se carga el modelo para servir en el arranque.

Ejemplo de servicio

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

docker pull tensorflow/serving

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

A continuación, se utilizará un modelo de juguete llamado Half Plus Two , lo que genera 0.5 * x + 2 para los valores de x nos ofrecen 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 hasta 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] }

Más información sobre cómo utilizar la API REST se puede encontrar aquí .

Sirviendo con Docker usando su GPU

Instalar nvidia-docker

Antes de servir con una GPU, además de la instalación de estibador , se necesita:

Hasta a la fecha de los controladores de NVIDIA para su sistema
nvidia-docker : Usted puede seguir las instrucciones de instalación aquí

Ejecutando una imagen de servicio de GPU

Ejecutar una imagen de servicio de GPU es idéntico a ejecutar una imagen de CPU. Para más detalles, véase la ejecución de una imagen que sirve .

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, se utilizará un modelo de juguete llamado Half Plus Two , lo que genera 0.5 * x + 2 para los valores de x nos ofrecen 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 --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 de la ventana acoplable, 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.

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: Si intenta ejecutar el modelo de GPU en una máquina sin GPU o sin una compilación de GPU en funcionamiento de TensorFlow Model Server, se producirá un error que se parece a lo siguiente:

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

Más información sobre cómo utilizar la API REST se puede encontrar aquí .

Desarrollando con Docker

Para obtener instrucciones sobre cómo construir y desarrollar Tensorflow Servir, consulte Desarrollo con guía acoplable .