如何使用TensorFlow中的高级API:Estimator、Experiment和Dataset

近日,背景调查公司 Onfido 研究主管 Peter Roelants 在 Medium 上发表了一篇题为《Higher-Level APIs in TensorFlow》的文章,通过实例详细介绍了如何使用 TensorFlow 中的高级 API(Estimator、Experiment 和 Dataset)训练模型。值得一提的是 Experiment 和 Dataset 可以独立使用。这些高级 API 已被最新发布的 TensorFlow1.3 版收录。

TensorFlow 中有许多流行的库,如 Keras、TFLearn 和 Sonnet,它们可以让你轻松训练模型,而无需接触哪些低级别函数。目前,Keras API 正倾向于直接在 TensorFlow 中实现,TensorFlow 也在提供越来越多的高级构造,其中的一些已经被最新发布的 TensorFlow1.3 版收录。

在本文中,我们将通过一个例子来学习如何使用一些高级构造,其中包括 Estimator、Experiment 和 Dataset。阅读本文需要预先了解有关 TensorFlow 的基本知识。


Experiment、Estimator 和 DataSet 框架和它们的相互作用(以下将对这些组件进行说明)

在本文中,我们使用 MNIST 作为数据集。它是一个易于使用的数据集,可以通过 TensorFlow 访问。你可以在这个 gist 中找到完整的示例代码。使用这些框架的一个好处是我们不需要直接处理图形和会话。


Estimator

Estimator(评估器)类代表一个模型,以及这些模型被训练和评估的方式。我们可以这样构建一个评估器:

  1. return tf.estimator.Estimator(

  2.    model_fn=model_fn,  # First-class function

  3.    params=params,  # HParams

  4.    config=run_config  # RunConfig

  5. )

为了构建一个 Estimator,我们需要传递一个模型函数,一个参数集合以及一些配置。

  • 参数应该是模型超参数的集合,它可以是一个字典,但我们将在本示例中将其表示为 HParams 对象,用作 namedtuple。
  • 该配置指定如何运行训练和评估,以及如何存出结果。这些配置通过 RunConfig 对象表示,该对象传达 Estimator 需要了解的关于运行模型的环境的所有内容。
  • 模型函数是一个 Python 函数,它构建了给定输入的模型(见后文)。

模型函数

模型函数是一个 Python 函数,它作为第一级函数传递给 Estimator。稍后我们就会看到,TensorFlow 也会在其他地方使用第一级函数。模型表示为函数的好处在于模型可以通过实例化函数不断重新构建。该模型可以在训练过程中被不同的输入不断创建,例如:在训练期间运行验证测试。

模型函数将输入特征作为参数,相应标签作为张量。它还有一种模式来标记模型是否正在训练、评估或执行推理。模型函数的最后一个参数是超参数的集合,它们与传递给 Estimator 的内容相同。模型函数需要返回一个 EstimatorSpec 对象——它会定义完整的模型。

EstimatorSpec 接受预测,损失,训练和评估几种操作,因此它定义了用于训练,评估和推理的完整模型图。由于 EstimatorSpec 采用常规 TensorFlow Operations,因此我们可以使用像 TF-Slim 这样的框架来定义自己的模型。


Experiment

Experiment(实验)类是定义如何训练模型,并将其与 Estimator 进行集成的方式。我们可以这样创建一个实验类:

  1. experiment = tf.contrib.learn.Experiment(

  2.    estimator=estimator,  # Estimator

  3.    train_input_fn=train_input_fn,  # First-class function

  4.    eval_input_fn=eval_input_fn,  # First-class function

  5.    train_steps=params.train_steps,  # Minibatch steps

  6.    min_eval_frequency=params.min_eval_frequency,  # Eval frequency

  7.    train_monitors=[train_input_hook],  # Hooks for training

  8.    eval_hooks=[eval_input_hook],  # Hooks for evaluation

  9.    eval_steps=None  # Use evaluation feeder until its empty

  10. )

Experiment 作为输入:

  • 一个 Estimator(例如上面定义的那个)。
  • 训练和评估数据作为第一级函数。这里用到了和前述模型函数相同的概念,通过传递函数而非操作,如有需要,输入图可以被重建。我们会在后面继续讨论这个概念。
  • 训练和评估钩子(hooks)。这些钩子可以用于监视或保存特定内容,或在图形和会话中进行一些操作。例如,我们将通过操作来帮助初始化数据加载器。
  • 不同参数解释了训练时间和评估时间。

一旦我们定义了 experiment,我们就可以通过 learn_runner.run 运行它来训练和评估模型:

  1. learn_runner.run(

  2.    experiment_fn=experiment_fn,  # First-class function

  3.    run_config=run_config,  # RunConfig

  4.    schedule="train_and_evaluate",  # What to run

  5.    hparams=params  # HParams

  6. )

与模型函数和数据函数一样,函数中的学习运算符将创建 experiment 作为参数。

Dataset

我们将使用 Dataset 类和相应的 Iterator 来表示我们的训练和评估数据,并创建在训练期间迭代数据的数据馈送器。在本示例中,我们将使用 TensorFlow 中可用的 MNIST 数据,并在其周围构建一个 Dataset 包装器。例如,我们把训练的输入数据表示为:

  1. # Define the training inputs

  2. def get_train_inputs(batch_size, mnist_data):

  3.    """Return the input function to get the training data.

  4.    Args:

  5.        batch_size (int): Batch size of training iterator that is returned

  6.                          by the input function.

  7.        mnist_data (Object): Object holding the loaded mnist data.

  8.    Returns:

  9.        (Input function, IteratorInitializerHook):

  10.            - Function that returns (features, labels) when called.

  11.            - Hook to initialise input iterator.

  12.    """

  13.    iterator_initializer_hook = IteratorInitializerHook()

  14.    def train_inputs():

  15.        """Returns training set as Operations.

  16.        Returns:

  17.            (features, labels) Operations that iterate over the dataset

  18.            on every evaluation

  19.        """

  20.        with tf.name_scope('Training_data'):

  21.            # Get Mnist data

  22.            images = mnist_data.train.images.reshape([-1, 28, 28, 1])

  23.            labels = mnist_data.train.labels

  24.            # Define placeholders

  25.            images_placeholder = tf.placeholder(

  26.                images.dtype, images.shape)

  27.            labels_placeholder = tf.placeholder(

  28.                labels.dtype, labels.shape)

  29.            # Build dataset iterator

  30.            dataset = tf.contrib.data.Dataset.from_tensor_slices(

  31.                (images_placeholder, labels_placeholder))

  32.            dataset = dataset.repeat(None)  # Infinite iterations

  33.            dataset = dataset.shuffle(buffer_size=10000)

  34.            dataset = dataset.batch(batch_size)

  35.            iterator = dataset.make_initializable_iterator()

  36.            next_example, next_label = iterator.get_next()

  37.            # Set runhook to initialize iterator

  38.            iterator_initializer_hook.iterator_initializer_func = \

  39.                lambda sess: sess.run(

  40.                    iterator.initializer,

  41.                    feed_dict={images_placeholder: images,

  42.                               labels_placeholder: labels})

  43.            # Return batched (features, labels)

  44.            return next_example, next_label

  45.    # Return function and hook

  46.    return train_inputs, iterator_initializer_hook

调用这个 get_train_inputs 会返回一个一级函数,它在 TensorFlow 图中创建数据加载操作,以及一个 Hook 初始化迭代器。

本示例中,我们使用的 MNIST 数据最初表示为 Numpy 数组。我们创建一个占位符张量来获取数据,再使用占位符来避免数据被复制。接下来,我们在 from_tensor_slices 的帮助下创建一个切片数据集。我们将确保该数据集运行无限长时间(experiment 可以考虑 epoch 的数量),让数据得到清晰,并分成所需的尺寸。

为了迭代数据,我们需要在数据集的基础上创建迭代器。因为我们正在使用占位符,所以我们需要在 NumPy 数据的相关会话中初始化占位符。我们可以通过创建一个可初始化的迭代器来实现。创建图形时,我们将创建一个自定义的 IteratorInitializerHook 对象来初始化迭代器:

  1. class IteratorInitializerHook(tf.train.SessionRunHook):

  2.    """Hook to initialise data iterator after Session is created."""

  3.    def __init__(self):

  4.        super(IteratorInitializerHook, self).__init__()

  5.        self.iterator_initializer_func = None

  6.    def after_create_session(self, session, coord):

  7.        """Initialise the iterator after the session has been created."""

  8.        self.iterator_initializer_func(session)

IteratorInitializerHook 继承自 SessionRunHook。一旦创建了相关会话,这个钩子就会调用 call after_create_session,并用正确的数据初始化占位符。这个钩子会通过 get_train_inputs 函数返回,并在创建时传递给 Experiment 对象。

train_inputs 函数返回的数据加载操作是 TensorFlow 操作,每次评估时都会返回一个新的批处理。

运行代码

现在我们已经定义了所有的东西,我们可以用以下命令运行代码:

  1. python mnist_estimator.py --model_dir ./mnist_training --data_dir ./mnist_data

如果你不传递参数,它将使用文件顶部的默认标志来确定保存数据和模型的位置。训练将在终端输出全局步长、损失、精度等信息。除此之外,实验和估算器框架将记录 TensorBoard 可以显示的某些统计信息。如果我们运行:

  1. tensorboard --logdir='./mnist_training'

我们就可以看到所有训练统计数据,如训练损失、评估准确性、每步时间和模型图。


评估精度在 TensorBoard 中的可视化

在 TensorFlow 中,有关 Estimator、Experiment 和 Dataset 框架的示例很少,这也是本文存在的原因。希望这篇文章可以向大家介绍这些架构工作的原理,它们应该采用哪些抽象方法,以及如何使用它们。如果你对它们很感兴趣,以下是其他相关文档。

关于 Estimator、Experiment 和 Dataset 的注释

  • 论文《TensorFlow Estimators: Managing Simplicity vs. Flexibility in High-Level Machine Learning Frameworks》:https://terrytangyuan.github.io/data/papers/tf-estimators-kdd-paper.pdf
  • Using the Dataset API for TensorFlow Input Pipelines:https://www.tensorflow.org/versions/r1.3/programmers_guide/datasets
  • tf.estimator.Estimator:https://www.tensorflow.org/api_docs/python/tf/estimator/Estimator
  • tf.contrib.learn.RunConfig:https://www.tensorflow.org/api_docs/python/tf/contrib/learn/RunConfig
  • tf.estimator.DNNClassifier:https://www.tensorflow.org/api_docs/python/tf/estimator/DNNClassifier
  • tf.estimator.DNNRegressor:https://www.tensorflow.org/api_docs/python/tf/estimator/DNNRegressor
  • Creating Estimators in tf.estimator:https://www.tensorflow.org/extend/estimators
  • tf.contrib.learn.Head:https://www.tensorflow.org/api_docs/python/tf/contrib/learn/Head
  • 本文用到的 Slim 框架:https://github.com/tensorflow/models/tree/master/slim

完整示例

  1. """Script to illustrate usage of tf.estimator.Estimator in TF v1.3"""

  2. import tensorflow as tf

  3. from tensorflow.examples.tutorials.mnist import input_data as mnist_data

  4. from tensorflow.contrib import slim

  5. from tensorflow.contrib.learn import ModeKeys

  6. from tensorflow.contrib.learn import learn_runner

  7. # Show debugging output

  8. tf.logging.set_verbosity(tf.logging.DEBUG)

  9. # Set default flags for the output directories

  10. FLAGS = tf.app.flags.FLAGS

  11. tf.app.flags.DEFINE_string(

  12.    flag_name='model_dir', default_value='./mnist_training',

  13.    docstring='Output directory for model and training stats.')

  14. tf.app.flags.DEFINE_string(

  15.    flag_name='data_dir', default_value='./mnist_data',

  16.    docstring='Directory to download the data to.')

  17. # Define and run experiment ###############################

  18. def run_experiment(argv=None):

  19.    """Run the training experiment."""

  20.    # Define model parameters

  21.    params = tf.contrib.training.HParams(

  22.        learning_rate=0.002,

  23.        n_classes=10,

  24.        train_steps=5000,

  25.        min_eval_frequency=100

  26.    )

  27.    # Set the run_config and the directory to save the model and stats

  28.    run_config = tf.contrib.learn.RunConfig()

  29.    run_config = run_config.replace(model_dir=FLAGS.model_dir)

  30.    learn_runner.run(

  31.        experiment_fn=experiment_fn,  # First-class function

  32.        run_config=run_config,  # RunConfig

  33.        schedule="train_and_evaluate",  # What to run

  34.        hparams=params  # HParams

  35.    )

  36. def experiment_fn(run_config, params):

  37.    """Create an experiment to train and evaluate the model.

  38.    Args:

  39.        run_config (RunConfig): Configuration for Estimator run.

  40.        params (HParam): Hyperparameters

  41.    Returns:

  42.        (Experiment) Experiment for training the mnist model.

  43.    """

  44.    # You can change a subset of the run_config properties as

  45.    run_config = run_config.replace(

  46.        save_checkpoints_steps=params.min_eval_frequency)

  47.    # Define the mnist classifier

  48.    estimator = get_estimator(run_config, params)

  49.    # Setup data loaders

  50.    mnist = mnist_data.read_data_sets(FLAGS.data_dir, one_hot=False)

  51.    train_input_fn, train_input_hook = get_train_inputs(

  52.        batch_size=128, mnist_data=mnist)

  53.    eval_input_fn, eval_input_hook = get_test_inputs(

  54.        batch_size=128, mnist_data=mnist)

  55.    # Define the experiment

  56.    experiment = tf.contrib.learn.Experiment(

  57.        estimator=estimator,  # Estimator

  58.        train_input_fn=train_input_fn,  # First-class function

  59.        eval_input_fn=eval_input_fn,  # First-class function

  60.        train_steps=params.train_steps,  # Minibatch steps

  61.        min_eval_frequency=params.min_eval_frequency,  # Eval frequency

  62.        train_monitors=[train_input_hook],  # Hooks for training

  63.        eval_hooks=[eval_input_hook],  # Hooks for evaluation

  64.        eval_steps=None  # Use evaluation feeder until its empty

  65.    )

  66.    return experiment

  67. # Define model ############################################

  68. def get_estimator(run_config, params):

  69.    """Return the model as a Tensorflow Estimator object.

  70.    Args:

  71.         run_config (RunConfig): Configuration for Estimator run.

  72.         params (HParams): hyperparameters.

  73.    """

  74.    return tf.estimator.Estimator(

  75.        model_fn=model_fn,  # First-class function

  76.        params=params,  # HParams

  77.        config=run_config  # RunConfig

  78.    )

  79. def model_fn(features, labels, mode, params):

  80.    """Model function used in the estimator.

  81.    Args:

  82.        features (Tensor): Input features to the model.

  83.        labels (Tensor): Labels tensor for training and evaluation.

  84.        mode (ModeKeys): Specifies if training, evaluation or prediction.

  85.        params (HParams): hyperparameters.

  86.    Returns:

  87.        (EstimatorSpec): Model to be run by Estimator.

  88.    """

  89.    is_training = mode == ModeKeys.TRAIN

  90.    # Define model's architecture

  91.    logits = architecture(features, is_training=is_training)

  92.    predictions = tf.argmax(logits, axis=-1)

  93.    # Loss, training and eval operations are not needed during inference.

  94.    loss = None

  95.    train_op = None

  96.    eval_metric_ops = {}

  97.    if mode != ModeKeys.INFER:

  98.        loss = tf.losses.sparse_softmax_cross_entropy(

  99.            labels=tf.cast(labels, tf.int32),

  100.            logits=logits)

  101.        train_op = get_train_op_fn(loss, params)

  102.        eval_metric_ops = get_eval_metric_ops(labels, predictions)

  103.    return tf.estimator.EstimatorSpec(

  104.        mode=mode,

  105.        predictions=predictions,

  106.        loss=loss,

  107.        train_op=train_op,

  108.        eval_metric_ops=eval_metric_ops

  109.    )

  110. def get_train_op_fn(loss, params):

  111.    """Get the training Op.

  112.    Args:

  113.         loss (Tensor): Scalar Tensor that represents the loss function.

  114.         params (HParams): Hyperparameters (needs to have `learning_rate`)

  115.    Returns:

  116.        Training Op

  117.    """

  118.    return tf.contrib.layers.optimize_loss(

  119.        loss=loss,

  120.        global_step=tf.contrib.framework.get_global_step(),

  121.        optimizer=tf.train.AdamOptimizer,

  122.        learning_rate=params.learning_rate

  123.    )

  124. def get_eval_metric_ops(labels, predictions):

  125.    """Return a dict of the evaluation Ops.

  126.    Args:

  127.        labels (Tensor): Labels tensor for training and evaluation.

  128.        predictions (Tensor): Predictions Tensor.

  129.    Returns:

  130.        Dict of metric results keyed by name.

  131.    """

  132.    return {

  133.        'Accuracy': tf.metrics.accuracy(

  134.            labels=labels,

  135.            predictions=predictions,

  136.            name='accuracy')

  137.    }

  138. def architecture(inputs, is_training, scope='MnistConvNet'):

  139.    """Return the output operation following the network architecture.

  140.    Args:

  141.        inputs (Tensor): Input Tensor

  142.        is_training (bool): True iff in training mode

  143.        scope (str): Name of the scope of the architecture

  144.    Returns:

  145.         Logits output Op for the network.

  146.    """

  147.    with tf.variable_scope(scope):

  148.        with slim.arg_scope(

  149.                [slim.conv2d, slim.fully_connected],

  150.                weights_initializer=tf.contrib.layers.xavier_initializer()):

  151.            net = slim.conv2d(inputs, 20, [5, 5], padding='VALID',

  152.                              scope='conv1')

  153.            net = slim.max_pool2d(net, 2, stride=2, scope='pool2')

  154.            net = slim.conv2d(net, 40, [5, 5], padding='VALID',

  155.                              scope='conv3')

  156.            net = slim.max_pool2d(net, 2, stride=2, scope='pool4')

  157.            net = tf.reshape(net, [-1, 4 * 4 * 40])

  158.            net = slim.fully_connected(net, 256, scope='fn5')

  159.            net = slim.dropout(net, is_training=is_training,

  160.                               scope='dropout5')

  161.            net = slim.fully_connected(net, 256, scope='fn6')

  162.            net = slim.dropout(net, is_training=is_training,

  163.                               scope='dropout6')

  164.            net = slim.fully_connected(net, 10, scope='output',

  165.                                       activation_fn=None)

  166.        return net

  167. # Define data loaders #####################################

  168. class IteratorInitializerHook(tf.train.SessionRunHook):

  169.    """Hook to initialise data iterator after Session is created."""

  170.    def __init__(self):

  171.        super(IteratorInitializerHook, self).__init__()

  172.        self.iterator_initializer_func = None

  173.    def after_create_session(self, session, coord):

  174.        """Initialise the iterator after the session has been created."""

  175.        self.iterator_initializer_func(session)

  176. # Define the training inputs

  177. def get_train_inputs(batch_size, mnist_data):

  178.    """Return the input function to get the training data.

  179.    Args:

  180.        batch_size (int): Batch size of training iterator that is returned

  181.                          by the input function.

  182.        mnist_data (Object): Object holding the loaded mnist data.

  183.    Returns:

  184.        (Input function, IteratorInitializerHook):

  185.            - Function that returns (features, labels) when called.

  186.            - Hook to initialise input iterator.

  187.    """

  188.    iterator_initializer_hook = IteratorInitializerHook()

  189.    def train_inputs():

  190.        """Returns training set as Operations.

  191.        Returns:

  192.            (features, labels) Operations that iterate over the dataset

  193.            on every evaluation

  194.        """

  195.        with tf.name_scope('Training_data'):

  196.            # Get Mnist data

  197.            images = mnist_data.train.images.reshape([-1, 28, 28, 1])

  198.            labels = mnist_data.train.labels

  199.            # Define placeholders

  200.            images_placeholder = tf.placeholder(

  201.                images.dtype, images.shape)

  202.            labels_placeholder = tf.placeholder(

  203.                labels.dtype, labels.shape)

  204.            # Build dataset iterator

  205.            dataset = tf.contrib.data.Dataset.from_tensor_slices(

  206.                (images_placeholder, labels_placeholder))

  207.            dataset = dataset.repeat(None)  # Infinite iterations

  208.            dataset = dataset.shuffle(buffer_size=10000)

  209.            dataset = dataset.batch(batch_size)

  210.            iterator = dataset.make_initializable_iterator()

  211.            next_example, next_label = iterator.get_next()

  212.            # Set runhook to initialize iterator

  213.            iterator_initializer_hook.iterator_initializer_func = \

  214.                lambda sess: sess.run(

  215.                    iterator.initializer,

  216.                    feed_dict={images_placeholder: images,

  217.                               labels_placeholder: labels})

  218.            # Return batched (features, labels)

  219.            return next_example, next_label

  220.    # Return function and hook

  221.    return train_inputs, iterator_initializer_hook

  222. def get_test_inputs(batch_size, mnist_data):

  223.    """Return the input function to get the test data.

  224.    Args:

  225.        batch_size (int): Batch size of training iterator that is returned

  226.                          by the input function.

  227.        mnist_data (Object): Object holding the loaded mnist data.

  228.    Returns:

  229.        (Input function, IteratorInitializerHook):

  230.            - Function that returns (features, labels) when called.

  231.            - Hook to initialise input iterator.

  232.    """

  233.    iterator_initializer_hook = IteratorInitializerHook()

  234.    def test_inputs():

  235.        """Returns training set as Operations.

  236.        Returns:

  237.            (features, labels) Operations that iterate over the dataset

  238.            on every evaluation

  239.        """

  240.        with tf.name_scope('Test_data'):

  241.            # Get Mnist data

  242.            images = mnist_data.test.images.reshape([-1, 28, 28, 1])

  243.            labels = mnist_data.test.labels

  244.            # Define placeholders

  245.            images_placeholder = tf.placeholder(

  246.                images.dtype, images.shape)

  247.            labels_placeholder = tf.placeholder(

  248.                labels.dtype, labels.shape)

  249.            # Build dataset iterator

  250.            dataset = tf.contrib.data.Dataset.from_tensor_slices(

  251.                (images_placeholder, labels_placeholder))

  252.            dataset = dataset.batch(batch_size)

  253.            iterator = dataset.make_initializable_iterator()

  254.            next_example, next_label = iterator.get_next()

  255.            # Set runhook to initialize iterator

  256.            iterator_initializer_hook.iterator_initializer_func = \

  257.                lambda sess: sess.run(

  258.                    iterator.initializer,

  259.                    feed_dict={images_placeholder: images,

  260.                               labels_placeholder: labels})

  261.            return next_example, next_label

  262.    # Return function and hook

  263.    return test_inputs, iterator_initializer_hook

  264. # Run script ##############################################

  265. if __name__ == "__main__":

  266.    tf.app.run(

  267.        main=run_experiment

  268.    )

推理训练模式

在训练模型后,我们可以运行 estimateator.predict 来预测给定图像的类别。可使用以下代码示例。 

  1. """Script to illustrate inference of a trained tf.estimator.Estimator.

  2. NOTE: This is dependent on mnist_estimator.py which defines the model.

  3. mnist_estimator.py can be found at:

  4. https://gist.github.com/peterroelants/9956ec93a07ca4e9ba5bc415b014bcca

  5. """

  6. import numpy as np

  7. import skimage.io

  8. import tensorflow as tf

  9. from mnist_estimator import get_estimator

  10. # Set default flags for the output directories

  11. FLAGS = tf.app.flags.FLAGS

  12. tf.app.flags.DEFINE_string(

  13.    flag_name='saved_model_dir', default_value='./mnist_training',

  14.    docstring='Output directory for model and training stats.')

  15. # MNIST sample images

  16. IMAGE_URLS = [

  17.    'https://i.imgur.com/SdYYBDt.png',  # 0

  18.    'https://i.imgur.com/Wy7mad6.png',  # 1

  19.    'https://i.imgur.com/nhBZndj.png',  # 2

  20.    'https://i.imgur.com/V6XeoWZ.png',  # 3

  21.    'https://i.imgur.com/EdxBM1B.png',  # 4

  22.    'https://i.imgur.com/zWSDIuV.png',  # 5

  23.    'https://i.imgur.com/Y28rZho.png',  # 6

  24.    'https://i.imgur.com/6qsCz2W.png',  # 7

  25.    'https://i.imgur.com/BVorzCP.png',  # 8

  26.    'https://i.imgur.com/vt5Edjb.png',  # 9

  27. ]

  28. def infer(argv=None):

  29.    """Run the inference and print the results to stdout."""

  30.    params = tf.contrib.training.HParams()  # Empty hyperparameters

  31.    # Set the run_config where to load the model from

  32.    run_config = tf.contrib.learn.RunConfig()

  33.    run_config = run_config.replace(model_dir=FLAGS.saved_model_dir)

  34.    # Initialize the estimator and run the prediction

  35.    estimator = get_estimator(run_config, params)

  36.    result = estimator.predict(input_fn=test_inputs)

  37.    for r in result:

  38.        print(r)

  39. def test_inputs():

  40.    """Returns training set as Operations.

  41.    Returns:

  42.        (features, ) Operations that iterate over the test set.

  43.    """

  44.    with tf.name_scope('Test_data'):

  45.        images = tf.constant(load_images(), dtype=np.float32)

  46.        dataset = tf.contrib.data.Dataset.from_tensor_slices((images,))

  47.        # Return as iteration in batches of 1

  48.        return dataset.batch(1).make_one_shot_iterator().get_next()

  49. def load_images():

  50.    """Load MNIST sample images from the web and return them in an array.

  51.    Returns:

  52.        Numpy array of size (10, 28, 28, 1) with MNIST sample images.

  53.    """

  54.    images = np.zeros((10, 28, 28, 1))

  55.    for idx, url in enumerate(IMAGE_URLS):

  56.        images[idx, :, :, 0] = skimage.io.imread(url)

  57.    return images

  58. # Run script ##############################################

  59. if __name__ == "__main__":

  60.    tf.app.run(main=infer)

入门TensorFlow工程GitHubAPI数据集
2
返回顶部