Как импортировать сохраненный поезд модели Tensorflow с использованием tf.estimator и предсказать входные данные

Я сохранил модель, используя tf.estimator.method export_savedmodel следующим образом:

export_dir="exportModel/"

feature_spec = tf.feature_column.make_parse_example_spec(feature_columns)

input_receiver_fn = tf.estimator.export.build_parsing_serving_input_receiver_fn(feature_spec)

classifier.export_savedmodel(export_dir, input_receiver_fn, as_text=False, checkpoint_path="Model/model.ckpt-400") 

Как импортировать эту сохраненную модель и использовать ее для прогнозов?

Ответ 1

Я попытался найти хороший базовый пример, но, похоже, документация и образцы немного разбросаны по этой теме. Поэтому давайте начнем с базового примера: tf.estimator quickstart.

Этот конкретный пример фактически не экспортирует модель, поэтому пусть это делает (не нужно для использования 1):

def serving_input_receiver_fn():
  """Build the serving inputs."""
  # The outer dimension (None) allows us to batch up inputs for
  # efficiency. However, it also means that if we want a prediction
  # for a single instance, we'll need to wrap it in an outer list.
  inputs = {"x": tf.placeholder(shape=[None, 4], dtype=tf.float32)}
  return tf.estimator.export.ServingInputReceiver(inputs, inputs)

export_dir = classifier.export_savedmodel(
    export_dir_base="/path/to/model",
    serving_input_receiver_fn=serving_input_receiver_fn)

Огромная звездочка на этом коде. В TensorFlow 1.3 появляется ошибка, которая не позволяет вам выполнять вышеуказанный экспорт на "консервированной" оценке (например, DNNClassifier). Обходной путь см. В разделе "Приложение: Временное решение".

Ниже приведен код export_dir (возвращаемое значение на этапе экспорта), чтобы подчеркнуть, что он не "/путь/в/модель", а скорее является подкаталогом этого каталога, имя которого это отметка времени.

Использовать случай 1: выполнить прогноз в том же процессе, что и обучение

Это научный опыт, основанный на использовании sci-kit, и уже показан образцом. Для полноты вы просто вызываете predict на обученной модели:

classifier.train(input_fn=train_input_fn, steps=2000)
# [...snip...]
predictions = list(classifier.predict(input_fn=predict_input_fn))
predicted_classes = [p["classes"] for p in predictions]

Использовать пример 2. Загрузите SavedModel в Python/Java/С++ и выполните прогнозы

Клиент Python

Возможно, проще всего использовать, если вы хотите сделать прогноз в Python, SavedModelPredictor. В программе Python, которая будет использовать SavedModel, нам нужен код следующим образом:

from tensorflow.contrib import predictor

predict_fn = predictor.from_saved_model(export_dir)
predictions = predict_fn(
    {"x": [[6.4, 3.2, 4.5, 1.5],
           [5.8, 3.1, 5.0, 1.7]]})
print(predictions['scores'])

Клиент Java

package dummy;

import java.nio.FloatBuffer;
import java.util.Arrays;
import java.util.List;

import org.tensorflow.SavedModelBundle;
import org.tensorflow.Session;
import org.tensorflow.Tensor;

public class Client {

  public static void main(String[] args) {
    Session session = SavedModelBundle.load(args[0], "serve").session();

    Tensor x =
        Tensor.create(
            new long[] {2, 4},
            FloatBuffer.wrap(
                new float[] {
                  6.4f, 3.2f, 4.5f, 1.5f,
                  5.8f, 3.1f, 5.0f, 1.7f
                }));

    // Doesn't look like Java has a good way to convert the
    // input/output name ("x", "scores") to their underlying tensor,
    // so we hard code them ("Placeholder:0", ...).
    // You can inspect them on the command-line with saved_model_cli:
    //
    // $ saved_model_cli show --dir $EXPORT_DIR --tag_set serve --signature_def serving_default
    final String xName = "Placeholder:0";
    final String scoresName = "dnn/head/predictions/probabilities:0";

    List<Tensor> outputs = session.runner()
        .feed(xName, x)
        .fetch(scoresName)
        .run();

    // Outer dimension is batch size; inner dimension is number of classes
    float[][] scores = new float[2][3];
    outputs.get(0).copyTo(scores);
    System.out.println(Arrays.deepToString(scores));
  }
}

Клиент С++

Скорее всего, вы захотите использовать tensorflow::LoadSavedModel с Session.

#include <unordered_set>
#include <utility>
#include <vector>

#include "tensorflow/cc/saved_model/loader.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/public/session.h"

namespace tf = tensorflow;

int main(int argc, char** argv) {
  const string export_dir = argv[1];

  tf::SavedModelBundle bundle;
  tf::Status load_status = tf::LoadSavedModel(
      tf::SessionOptions(), tf::RunOptions(), export_dir, {"serve"}, &bundle);
  if (!load_status.ok()) {
    std::cout << "Error loading model: " << load_status << std::endl;
    return -1;
  }

  // We should get the signature out of MetaGraphDef, but that a bit
  // involved. We'll take a shortcut like we did in the Java example.
  const string x_name = "Placeholder:0";
  const string scores_name = "dnn/head/predictions/probabilities:0";

  auto x = tf::Tensor(tf::DT_FLOAT, tf::TensorShape({2, 4}));
  auto matrix = x.matrix<float>();
  matrix(0, 0) = 6.4;
  matrix(0, 1) = 3.2;
  matrix(0, 2) = 4.5;
  matrix(0, 3) = 1.5;
  matrix(0, 1) = 5.8;
  matrix(0, 2) = 3.1;
  matrix(0, 3) = 5.0;
  matrix(0, 4) = 1.7;

  std::vector<std::pair<string, tf::Tensor>> inputs = {{x_name, x}};
  std::vector<tf::Tensor> outputs;

  tf::Status run_status =
      bundle.session->Run(inputs, {scores_name}, {}, &outputs);
  if (!run_status.ok()) {
    cout << "Error running session: " << run_status << std::endl;
    return -1;
  }

  for (const auto& tensor : outputs) {
    std::cout << tensor.matrix<float>() << std::endl;
  }
}

Пример использования 3: Подача модели с использованием службы TensorFlow

Экспортирование моделей способом, подходящим для обслуживания Модель классификации, требует, чтобы вход был tf.Example. Здесь мы можем экспортировать модель для обслуживания TensorFlow:

def serving_input_receiver_fn():
  """Build the serving inputs."""
  # The outer dimension (None) allows us to batch up inputs for
  # efficiency. However, it also means that if we want a prediction
  # for a single instance, we'll need to wrap it in an outer list.
  example_bytestring = tf.placeholder(
      shape=[None],
      dtype=tf.string,
  )
  features = tf.parse_example(
      example_bytestring,
      tf.feature_column.make_parse_example_spec(feature_columns)
  )
  return tf.estimator.export.ServingInputReceiver(
      features, {'examples': example_bytestring})

export_dir = classifier.export_savedmodel(
    export_dir_base="/path/to/model",
    serving_input_receiver_fn=serving_input_receiver_fn)

Ссылаться на документацию TensorFlow Servers на дополнительную информацию о том, как настроить службу TensorFlow, я предоставил здесь только код клиента:

  # Omitting a bunch of connection/initialization code...
  # But at some point we end up with a stub whose lifecycle
  # is generally longer than that of a single request.
  stub = create_stub(...)

  # The actual values for prediction. We have two examples in this
  # case, each consisting of a single, multi-dimensional feature `x`.
  # This data here is the equivalent of the map passed to the 
  # `predict_fn` in use case #2.
  examples = [
    tf.train.Example(
      features=tf.train.Features(
        feature={"x": tf.train.Feature(
          float_list=tf.train.FloatList(value=[6.4, 3.2, 4.5, 1.5]))})),
    tf.train.Example(
      features=tf.train.Features(
        feature={"x": tf.train.Feature(
          float_list=tf.train.FloatList(value=[5.8, 3.1, 5.0, 1.7]))})),
  ]

  # Build the RPC request.
  predict_request = predict_pb2.PredictRequest()
  predict_request.model_spec.name = "default"
  predict_request.inputs["examples"].CopyFrom(
      tensor_util.make_tensor_proto(examples, tf.float32))

  # Perform the actual prediction.
  stub.Predict(request, PREDICT_DEADLINE_SECS)

Обратите внимание, что ключ examples, на который ссылается в predict_request.inputs, должен соответствовать ключу, используемому в serving_input_receiver_fn во время экспорта (см. конструктор в ServingInputReceiver в этом коде).

Приложение: Работа с экспортом из Canned Models в TF 1.3

В TensorFlow 1.3 появляется ошибка, в которой консервированные модели не корректно экспортируются для использования в случае 2 (проблема не существует для "пользовательских" оценок). Вот обходной путь, который обертывает DNNClassifier, чтобы заставить все работать, в частности, для примера Iris:

# Build 3 layer DNN with 10, 20, 10 units respectively.
class Wrapper(tf.estimator.Estimator):
  def __init__(self, **kwargs):
    dnn = tf.estimator.DNNClassifier(**kwargs)

    def model_fn(mode, features, labels):
      spec = dnn._call_model_fn(features, labels, mode)
      export_outputs = None
      if spec.export_outputs:
        export_outputs = {
           "serving_default": tf.estimator.export.PredictOutput(
                  {"scores": spec.export_outputs["serving_default"].scores,
                   "classes": spec.export_outputs["serving_default"].classes})}

      # Replace the 3rd argument (export_outputs)
      copy = list(spec)
      copy[4] = export_outputs
      return tf.estimator.EstimatorSpec(mode, *copy)

    super(Wrapper, self).__init__(model_fn, kwargs["model_dir"], dnn.config)

classifier = Wrapper(feature_columns=feature_columns,
                     hidden_units=[10, 20, 10],
                     n_classes=3,
                     model_dir="/tmp/iris_model")

Ответ 2

Я не думаю, что есть ошибка с консервированными оценщиками (точнее, если она была когда-либо одна, она была исправлена). Я смог успешно экспортировать модель консервированной оценки с помощью Python и импортировать ее в Java.

Вот мой код для экспорта модели:

a = tf.feature_column.numeric_column("a");
b = tf.feature_column.numeric_column("b");
feature_columns = [a, b];

model = tf.estimator.DNNClassifier(feature_columns=feature_columns ...);

# To export
feature_spec = tf.feature_column.make_parse_example_spec(feature_columns);
export_input_fn = tf.estimator.export.build_parsing_serving_input_receiver_fn(feature_spec);
servable_model_path = model.export_savedmodel(servable_model_dir, export_input_fn, as_text=True);

Чтобы импортировать модель в Java, я использовал код клиента Java, предоставленный rhaertel80 выше, и он работает. Надеюсь, что это также ответит на вопрос Бена Фаулера выше.

Ответ 3

Похоже, что команда TensorFlow не согласна с тем, что в версии 1.3 имеется ошибка, использующая консервированные оценки для экспорта модели в случае использования # 2. Я отправил здесь отчет об ошибке: https://github.com/tensorflow/tensorflow/issues/13477

Ответ, полученный мной от TensorFlow, заключается в том, что входной сигнал должен быть только одним строковым тензором. Похоже, что может быть способ объединить несколько функций в один строковый тензор с использованием сериализованных TF.examples, но я не нашел четкого метода для этого. Если у кого есть код, показывающий, как это сделать, я был бы признателен.

Ответ 4

Вам нужно экспортировать сохраненную модель с помощью tf.contrib.export_savedmodel, и вам необходимо определить входную функцию приемника для ввода ввода. Позже вы можете загрузить сохраненную модель (обычно saved.model.pb) с диска и выполнить ее.

TensorFlow: как прогнозировать с помощью SavedModel?