Servir un modelo de TensorFlow

Este instructivo le muestra cómo usar los componentes de publicación de TensorFlow para exportar un modelo de TensorFlow entrenado y usar el tensorflow_model_server estándar para entregarlo. Si ya está familiarizado con TensorFlow Servir, y quiere saber más acerca de cómo funcionan los componentes internos del servidor, consulte la TensorFlow Sirviendo tutorial avanzado .

Este tutorial utiliza un modelo de regresión Softmax simple que clasifica dígitos escritos a mano. Es muy similar a la introducida en el tutorial TensorFlow en la clasificación de imágenes usando el conjunto de datos moda MNIST .

El código de este tutorial consta de dos partes:

• Un archivo de Python, mnist_saved_model.py , que los trenes y las exportaciones del modelo.

• Binaria A ModelServer que puede ser instalado usando Apt, o compilado a partir de un archivo de C ++ ( main.cc ). Los TensorFlow Sirviendo descubre ModelServer nueva exportan modelos y dirige una GRPC servicio para servirlos.

Antes de comenzar, primero instalar estibador .

Entrene y exporte el modelo de TensorFlow

Para la fase de entrenamiento, el gráfico TensorFlow se puso en marcha en TensorFlow sesión sess , con el tensor de entrada (imagen) como x y tensor de salida (puntuación Softmax) como y .

Luego usamos de TensorFlow módulo SavedModelBuilder para exportar el modelo. SavedModelBuilder ahorra una "instantánea" del modelo de formación para el almacenamiento fiable de forma que se puede cargar más tarde para la inferencia.

Para más detalles sobre el formato SavedModel, consulte la documentación en SavedModel README.md .

De mnist_saved_model.py , el siguiente es un fragmento de código corto para ilustrar el proceso general de ahorro de un modelo en el disco.

export_path_base = sys.argv[-1]
export_path = os.path.join(
    tf.compat.as_bytes(export_path_base),
    tf.compat.as_bytes(str(FLAGS.model_version)))
print('Exporting trained model to', export_path)
builder = tf.saved_model.builder.SavedModelBuilder(export_path)
builder.add_meta_graph_and_variables(
    sess, [tf.compat.v1.saved_model.tag_constants.SERVING],
    signature_def_map={
        'predict_images':
            prediction_signature,
        tf.compat.v1.saved_model.signature_constants
            .DEFAULT_SERVING_SIGNATURE_DEF_KEY:
            classification_signature,
    },
    main_op=tf.compat.v1.tables_initializer(),
    strip_default_attrs=True)
builder.save()

SavedModelBuilder.__init__ toma el siguiente argumento:

• export_path es la ruta del directorio de exportación.

SavedModelBuilder creará el directorio si no existe. En el ejemplo, se concatena el argumento de línea de comandos y FLAGS.model_version para obtener el directorio de exportación. FLAGS.model_version especifica la versión del modelo. Debe especificar un valor entero mayor al exportar una versión más nueva del mismo modelo. Cada versión se exportará a un subdirectorio diferente en la ruta indicada.

Puede añadir el gráfico meta y variables para el constructor usando SavedModelBuilder.add_meta_graph_and_variables() con los siguientes argumentos:

• sess es la sesión TensorFlow que sostiene el modelo entrenado que está exportando.

• tags es el conjunto de etiquetas con la que desea guardar el gráfico meta. En este caso, ya que la intención de utilizar el gráfico de la porción, usamos la serve etiqueta partir de las constantes de etiqueta SavedModel predefinidos. Para más detalles, véase tag_constants.py y TensorFlow relacionada documentación de la API .

• signature_def_map especifica el mapa de la clave proporcionada por el usuario para una firma a un tensorflow :: SignatureDef para agregar a la gráfica meta. La firma especifica qué tipo de modelo se está exportando y los tensores de entrada / salida a los que se debe unir cuando se ejecuta la inferencia.

  Los especiales de claves de firma serving_default especifica el valor predeterminado sirviendo firma. La clave de definición de firma de servicio predeterminada, junto con otras constantes relacionadas con las firmas, se definen como parte de las constantes de firma del modelo guardado. Para más detalles, véase signature_constants.py y TensorFlow relacionada documentación de la API .

  Además, para ayudar a construir la firma defs fácilmente, la API SavedModel proporciona utilidades de la firma def .. En concreto, en el original mnist_saved_model.py archivo, usamos signature_def_utils.build_signature_def() para construir predict_signature y classification_signature .

  Como un ejemplo de cómo predict_signature se define, el util toma los siguientes argumentos:

  • inputs={'images': tensor_info_x} especifica la información tensor de entrada.

  • outputs={'scores': tensor_info_y} especifica las puntuaciones tensor información.

  • method_name es el método utilizado para la inferencia. Para las solicitudes de predicción, se debe establecer en tensorflow/serving/predict . Para otros nombres de métodos, consulte signature_constants.py y TensorFlow relacionada documentación de la API .

Tenga en cuenta que tensor_info_x y tensor_info_y tienen la estructura de tensorflow::TensorInfo de búfer de protocolo define aquí . Para construir fácilmente tensor de informaciones, la API TensorFlow SavedModel también proporciona utils.py , la documentación de la API TensorFlow relacionada .

Además, tenga en cuenta que images y los scores son los nombres de alias tensor. Ellos pueden ser lo único que desea cuerdas, y se convertirán en los nombres lógicos de tensor de x e y que hace referencia a la unión al enviar solicitudes de predicción más tarde tensor.

Por ejemplo, si x se refiere al tensor con el nombre de 'long_tensor_name_foo' y y se refiere al tensor con el nombre de 'generated_tensor_name_bar', builder almacenará tensor de nombre lógico con el nombre real de asignación ( 'imágenes' -> 'long_tensor_name_foo') y (puntuaciones ' '->' barra_nombre_de_tensor_generada '). Esto permite que el usuario se refiera a estos tensores con sus nombres lógicos al ejecutar la inferencia.

¡Vamos a ejecutarlo!

Primero, si aún no lo ha hecho, clone este repositorio en su máquina local:

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

Borre el directorio de exportación si ya existe:

rm -rf /tmp/mnist

Ahora entrenemos el modelo:

tools/run_in_docker.sh python tensorflow_serving/example/mnist_saved_model.py \
  /tmp/mnist

Esto debería dar como resultado una salida que se parece a:

Training model...

...

Done training!
Exporting trained model to models/mnist
Done exporting!

Ahora echemos un vistazo al directorio de exportación.

$ ls /tmp/mnist
1

Como se mencionó anteriormente, se creará un subdirectorio para exportar cada versión del modelo. FLAGS.model_version tiene el valor predeterminado de 1, por lo tanto, el sub-directorio correspondiente 1 se crea.

$ ls /tmp/mnist/1
saved_model.pb variables

Cada subdirectorio de la versión contiene los siguientes archivos:

• saved_model.pb es la tensorflow serializado :: SavedModel. Incluye una o más definiciones de gráficos del modelo, así como metadatos del modelo, como firmas.

• variables son archivos que contienen las variables en serie de los gráficos.

¡Con eso, su modelo de TensorFlow se exporta y está listo para cargarse!

Cargar el modelo exportado con TensorFlow ModelServer estándar

Use una imagen de servicio de Docker para cargar fácilmente el modelo para el servicio:

docker run -p 8500:8500 \
--mount type=bind,source=/tmp/mnist,target=/models/mnist \
-e MODEL_NAME=mnist -t tensorflow/serving &

Prueba el servidor

Podemos usar el proporcionado mnist_client utilidad para probar el servidor. El cliente descarga los datos de prueba de MNIST, los envía como solicitudes al servidor y calcula la tasa de error de inferencia.

tools/run_in_docker.sh python tensorflow_serving/example/mnist_client.py \
  --num_tests=1000 --server=127.0.0.1:8500

Esto debería generar algo como

    ...
    Inference error rate: 11.13%

Esperamos una precisión de alrededor del 90% para el modelo Softmax entrenado y obtenemos una tasa de error de inferencia del 11% para las primeras 1000 imágenes de prueba. ¡Esto confirma que el servidor carga y ejecuta el modelo entrenado con éxito!