超智能体
首发于超智能体
TensorFlow高层API:Custom Estimator建立CNN+RNN

TensorFlow高层API:Custom Estimator建立CNN+RNN

实践

YJango:免费上机:TensorFlow 通用框架 Estimatorzhuanlan.zhihu.com图标

目录

前言

机器学习

  • 两大模块:数据、模型
  • 三个阶段:训练、评估、预测

优势

实现

  • 数据集:TFRecord+Dataset
  • 定义input_fn
  • 定义model_fn
    • 正向传播
      • CNN:二维卷积层
      • RNN:循环层(双向循环层)
      • CNN+RNN:一维卷积层+循环层
    • 预测分支
    • 训练分支
    • 评估分支
  • 创建estimator
  • 训练
  • 评估
  • 预测
  • 可视化

前言

该文是YJango:TensorFlow中层API Datasets+TFRecord的数据导入的后续。

知道了如何用中层API:Dataset来导入数据后,下面介绍如何接着用高层API:Estimator来用下面四个网络结构来完成mnist手写数字识别。

  • 卷积神经网络
  • 循环神经网络
  • 双向循环神经网络
  • 卷积+循环网络

机器学习

人们常说深度学习是黑箱,我们同样也希望使用深度学习可以像使用黑箱工具那样简单。可事实却并非如此。以监督学习为例:

我们的最终目标是:希望获得一个可以输入问题就能获得答案的算法。

可为了获得该算法,要先搜集数据,然后将数据处理成适应计算机或模型的形式。根据目的分成训练集、验证集、测试集。经过反复的选择、训练、调参、评估后确定最终投入应用的模型。

上述流程可分为训练评估预测三个阶段。不同阶段:

  • 使用的模型数据处理记录操作是相同的。
  • 使用的数据集模型操作不同。

一、训练:

  • 模型操作:正向传播+反向传播。遍历整个训练集若干次,用于更新模型权重。
  • 数据集:训练集。

二、评估:

  • 模型操作:正向传播。遍历每个数据集一次,算出评估指标来衡量模型表现。
  • 数据集:会使用多个数据集进行评估,但意义不同。
    • 训练集:评估模型能力是否足够,判断是否欠拟合。
    • 验证集:其本质也属于训练集的一部分。评估模型的普遍性,和训练集的评估结果一起来判断是否过拟合。因为会根据验证集的结果来调整模型超参数 (hyper-parameters),所以模型间接的“见过”验证集的数据。
    • 测试集:模型从未见过的数据,用于评估模型的最终表现,决定是否选择新模型。

注:训练集和验证集都无法作为最终表现的考核标准。评估模型的最终表现一定要用模型从未见过的数据。就如同考核高考解题能力的方法是考核我们从没做过的题目一样,因为我们可以记住做过题目的答案。

三、预测:

  • 模型操作:正向传播。用训练好的模型算出所有预测值即可。
  • 数据集:只有输入的实际应用数据。

优势

一、为什么用Estimator API?

正如先前所说机器学习可分为训练、评估、预测三个阶段,每个阶段又都会用到相同的模型和数据处理方法。

而Tensorflow的高层API:Estimator正是对共用部分使用通用方法,而在不同的阶段实现具体的控制。

共用部分:

  • model_fn:构建模型
  • input_fn:导入数据 + 数据集的处理(结合中层API:Dataset)
  • 其他:帮助控制sessions、graphs、loops、logging

三个阶段:通过调用对应的train(), evaluate(), predict()方法来执行不同的阶段。

优势

  • 学习流程:Estimator 封装了对机器学习不同阶段的控制,用户无需不断的为新机器学习任务重复编写训练、评估、预测的代码。可以专注于对网络结构的控制。
  • 网络结构:Estimator 的网络结构是在 model_fn 中独立定义的,用户创建的任何网络结构都可以在 Estimator 的控制下进行机器学习。这可以允许用户很方便的使用别人定义好的 model_fn。
  • 数据导入:Estimator 的数据导入也是由 input_fn 独立定义的。例如,用户可以非常方便的只通过改变 input_fn 的定义,来使用相同的网络结构学习不同的数据。

实现

一、数据集

这里直接使用上篇文章中所描述的方法(没看过的先看上一篇),将MNIST数据集先写成tfrecord文件,再用dataset API导入,进行batch,shuffle,padding等操作。需要文件:tfrecorder.py

1. 制作TFrecord文件

# 所需库包
import pandas as pd
import numpy as np
import tensorflow as tf
# 需要从我给的github上获得tfrecorder
from tfrecorder import TFrecorder
from matplotlib import pyplot as plt
import matplotlib.image as mpimg
%pylab inline

# mnist数据
mnist = tf.contrib.learn.datasets.load_dataset("mnist")

# 指定如何写成tfrecord文件的信息
# 每一个row是一个feature
df = pd.DataFrame({'name':['image','label'],
                  'type':['float32','int64'],
                  'shape':[(784,),()],
                  'isbyte':[False,False],
                  "length_type":['fixed','fixed'],
                  "default":[np.NaN,np.NaN]})
# 实例化该类
tfr = TFrecorder()

# 写训练集和测试集的位置
mkdir mnist_tfrecord mnist_tfrecord/train mnist_tfrecord/test

使用tfr.feature_writer方法创建样本写入字典,一个样本一个样本的写入TFRecord file中。

由于使用tfrecord时往往是拥有大量数据的情况,需要一点点写入。

1.1. 训练集

# 用该方法写训练集的tfrecord文件
dataset = mnist.train
path = 'mnist_tfrecord/train/train'
# 每个tfrecord文件写多少个样本
num_examples_per_file = 1000
# 当前写的样本数
num_so_far = 0
# 要写入的文件
writer = tf.python_io.TFRecordWriter('%s%s_%s.tfrecord' %(path, num_so_far, num_examples_per_file))
# 写多个样本
for i in np.arange(dataset.num_examples):
    # 要写到tfrecord文件中的字典
    features = {}
    # 写一个样本的图片信息存到字典features中
    tfr.feature_writer(df.iloc[0], dataset.images[i], features)
    # 写一个样本的标签信息存到字典features中
    tfr.feature_writer(df.iloc[1], dataset.labels[i], features)
    
    tf_features = tf.train.Features(feature= features)
    tf_example = tf.train.Example(features = tf_features)
    tf_serialized = tf_example.SerializeToString()
    writer.write(tf_serialized)
    # 每写了num_examples_per_file个样本就令生成一个tfrecord文件
    if i%num_examples_per_file ==0 and i!=0:
        writer.close()
        num_so_far = i
        writer = tf.python_io.TFRecordWriter('%s%s_%s.tfrecord' %(path, num_so_far, i+num_examples_per_file))
        print('saved %s%s_%s.tfrecord' %(path, num_so_far, i+num_examples_per_file))
writer.close()
# 把指定如何写成tfrecord文件的信息保存起来
data_info_path = 'mnist_tfrecord/data_info.csv'
df.to_csv(data_info_path,index=False)

1.2. 测试集

# 用该方法写测试集的tfrecord文件
dataset = mnist.test
path = 'mnist_tfrecord/test/test'
# 每个tfrecord文件写多少个样本
num_examples_per_file = 1000
# 当前写的样本数
num_so_far = 0
# 要写入的文件
writer = tf.python_io.TFRecordWriter('%s%s_%s.tfrecord' %(path, num_so_far, num_examples_per_file))
# 写多个样本
for i in np.arange(dataset.num_examples):
    # 要写到tfrecord文件中的字典
    features = {}
    # 写一个样本的图片信息存到字典features中
    tfr.feature_writer(df.iloc[0], dataset.images[i], features)
    # 写一个样本的标签信息存到字典features中
    tfr.feature_writer(df.iloc[1], dataset.labels[i], features)
    
    tf_features = tf.train.Features(feature= features)
    tf_example = tf.train.Example(features = tf_features)
    tf_serialized = tf_example.SerializeToString()
    writer.write(tf_serialized)
    # 每写了num_examples_per_file个样本就令生成一个tfrecord文件
    if i%num_examples_per_file ==0 and i!=0:
        writer.close()
        num_so_far = i
        writer = tf.python_io.TFRecordWriter('%s%s_%s.tfrecord' %(path, num_so_far, i+num_examples_per_file))
        print('saved %s%s_%s.tfrecord' %(path, num_so_far, i+num_examples_per_file))
writer.close()
# 把指定如何写成tfrecord文件的信息保存起来
data_info_path = 'mnist_tfrecord/data_info.csv'
df.to_csv(data_info_path,index=False)

二、生成input_fn

送入到Estimator中的input_fn需要是一个函数,而不是具体的数据。

所以这里用input_fn_maker来控制如何生成不同的input_fn函数。

tfr = TFrecorder()
def input_fn_maker(path, data_info_path, shuffle=False, batch_size = 1, epoch = 1, padding = None):
    def input_fn():
        # tfr.get_filenames会返回包含path下的所有tfrecord文件的list
        # shuffle会让这些文件的顺序打乱
        filenames = tfr.get_filenames(path=path, shuffle=shuffle)
        dataset=tfr.get_dataset(paths=filenames, data_info=data_info_path, shuffle = shuffle, 
                            batch_size = batch_size, epoch = epoch, padding =padding)
        iterator = dataset.make_one_shot_iterator()
        return iterator.get_next()
    return input_fn
padding_info = ({'image':[784,],'label':[]})
# 生成3个input_fn
test_input_fn = input_fn_maker('mnist_tfrecord/test/',  'mnist_tfrecord/data_info.csv',
                               padding = padding_info)
train_input_fn = input_fn_maker('mnist_tfrecord/train/',  'mnist_tfrecord/data_info.csv', shuffle=True, batch_size = 512,
                               padding = padding_info)
# 用来评估训练集用,不想要shuffle
train_eval_fn = input_fn_maker('mnist_tfrecord/train/',  'mnist_tfrecord/data_info.csv', batch_size = 512,
                               padding = padding_info)
# input_fn在执行时会返回一个字典,里面的key对应着不同的feature(包括label在内)

完整代码可以在MNIST TFrecord.ipynb找到。


三、model_fn

模型函数必须要有features, mode两个参数,可自己选择加入labels(YJango习惯把label也放进features中)。最后要返回特定的tf.estimator.EstimatorSpec()。

模型有三个阶段都共用的正向传播部分,和由mode值来控制返回不同tf.estimator.EstimatorSpec的三个分支。

def model_fn(features, mode):
    # reshape 784维的图片到28x28的平面表达,1为channel数
    features['image'] = tf.reshape(features['image'],[-1,28,28,1])

1. 正向传播

这里使用tf.layers来搭建模型,

要点:

  • 记住tensor在每层前后的shape
  • 记住shape上每个dimension上的意义
  • 给每一层都赋予name,用于debug和方便后续操作。

注:虽然我循序罗列了不同结构,但请一次只拿一个使用

注:关于下面网络的搭建,不明白的细节可以问我。

1.1. 二维卷积层

定义LeNet模型。

# shape: [None,28,28,1]
    conv1 = tf.layers.conv2d(
        inputs=features['image'],
        filters=32,
        kernel_size=[5, 5],
        padding="same",
        activation=tf.nn.relu,
        name = 'conv1')
    # shape: [None,28,28,32]
    pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2, name= 'pool1')
    # shape: [None,14,14,32]
    conv2 = tf.layers.conv2d(
        inputs=pool1,
        filters=64,
        kernel_size=[5, 5],
        padding="same",
        activation=tf.nn.relu,
        name = 'conv2')
    # shape: [None,14,14,64]
    pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2, name= 'pool2')
    # shape: [None,7,7,64]
    pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64], name= 'pool2_flat')
    # shape: [None,3136]
    dense1 = tf.layers.dense(inputs=pool2_flat, units=1024, activation=tf.nn.relu, name= 'dense1')
    # dropout只在当mode为tf.estimator.ModeKeys.TRAIN时才使用
    dropout = tf.layers.dropout(inputs=dense1, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)
    # shape: [None,1024]
    logits = tf.layers.dense(inputs=dropout, units=10, name= 'output')
    # shape: [None,10]

1.2. 循环层

定义两层循环层模型。

# shape: [None,28,28,1]
    # create RNN cells:
    rnn_cells = [tf.nn.rnn_cell.GRUCell(dim,kernel_initializer=tf.orthogonal_initializer) for dim in [128,256]]
    # stack cells for multi-layers RNN
    multi_rnn_cell = tf.nn.rnn_cell.MultiRNNCell(rnn_cells)
    # create RNN layers
    outputs, last_state = tf.nn.dynamic_rnn(cell=multi_rnn_cell,
                                   inputs=tf.reshape(features['image'],[-1,28,28]),
                                   dtype=tf.float32)
    # shape: outputs: [None,28,256]
    # shape: last_state: [None,256]
    dense1 = tf.layers.dense(inputs=last_state[1], units=1024, activation=tf.nn.relu, name= 'dense1')
    # shape: [None,1024]
    dropout = tf.layers.dropout(inputs=dense1, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)
    logits = tf.layers.dense(inputs=dense1, units=10, name= 'output')
    # shape: [None,10]

1.3. 双向循环层

定义两个双向循环层模型。

# shape: [None,28,28,1]
    # create RNN cells:
    rnn_fcells = [tf.nn.rnn_cell.GRUCell(dim,kernel_initializer=tf.orthogonal_initializer) for dim in [128,256]]
    rnn_bcells = [tf.nn.rnn_cell.GRUCell(dim,kernel_initializer=tf.orthogonal_initializer) for dim in [128,256]]
    # stack cells for multi-layers RNN
    multi_rnn_fcell = tf.nn.rnn_cell.MultiRNNCell(rnn_fcells)
    multi_rnn_bcell = tf.nn.rnn_cell.MultiRNNCell(rnn_bcells)
    # create RNN layers
    ((outputs_fw, outputs_bw),(last_state_fw, last_state_bw)) = tf.nn.bidirectional_dynamic_rnn(
                                   cell_fw=multi_rnn_fcell,
                                   cell_bw=multi_rnn_bcell,
                                   inputs=tf.reshape(features['image'],[-1,28,28]),
                                   dtype=tf.float32)
    # shape: outputs: [None,28,256]
    # shape: last_state: [None,256]
    dense1 = tf.layers.dense(inputs=last_state_fw[1]+last_state_bw[1], units=1024, activation=tf.nn.relu, name= 'dense1')
    # shape: [None,1024]
    dropout = tf.layers.dropout(inputs=dense1, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)
    logits = tf.layers.dense(inputs=dense1, units=10, name= 'output')
    # shape: [None,10]

1.4. 一维卷积层+循环层模型

定义一维卷基层+一维maxpool+循环层模型。

# shape: [None,28,28,1]
    conv1 = tf.layers.conv1d(
            inputs = tf.reshape(features['image'],[-1,28,28]), 
            filters = 32, 
            kernel_size = 5,
            padding="same",
            activation=tf.nn.relu,
            name = 'conv1')
    # shape: [None,28,32]
    pool1 = tf.layers.max_pooling1d(inputs = conv1, 
                          pool_size=2,
                          strides=2,
                          name = 'pool1')
    # shape: [None,14,32]
    # create RNN cells:
    rnn_cells = [tf.nn.rnn_cell.GRUCell(dim,kernel_initializer=tf.orthogonal_initializer) for dim in [128,256]]
    # stack cells for multi-layers RNN
    multi_rnn_cell = tf.nn.rnn_cell.MultiRNNCell(rnn_cells)
    # create RNN layers
    outputs, last_state = tf.nn.dynamic_rnn(cell=multi_rnn_cell,
                                   inputs=pool1,
                                   dtype=tf.float32)
    # shape: outputs: [None,14,256]
    # shape: last_state: [None,256]
    dense1 = tf.layers.dense(inputs=last_state[1], units=1024, activation=tf.nn.relu, name= 'dense1')
    # shape: [None,1024]
    dropout = tf.layers.dropout(inputs=dense1, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)
    logits = tf.layers.dense(inputs=dense1, units=10, name= 'output')
    # shape: [None,10]


想要换成不同的模型,只需改变正向传播部分的代码即可。

注:不同网络结构训练1epoch+评估的结构可以在CNN.ipynbRNN.ipynbbiRNN.ipynbCNN_RNN.ipynb中找到。

注:CNN之后的模型并不意味着更好,这里只是为了展示你可以使用任何模型结构来进行学习。还有残差网络的跳层链接,batchnorm层,注意力机制等,至于如何选择,主要是在于你的任务是否具有符合这些特殊层的结构特点。详细的请参考:

YJango:深层神经网络设计理念(在线+视频+幻灯片)

2. 预测分支

# 创建predictions字典,里面写进所有你想要在预测值输出的数值
    # 隐藏层的数值也可以,这里演示了输出所有隐藏层层结果。
    # 字典的key是模型,value给的是对应的tensor
    predictions = {
        "image":features['image'],
        "conv1_out":conv1,
        "pool1_out":pool1,
        "conv2_out":conv2,
        "pool2_out":pool2,
        "pool2_flat_out":pool2_flat,
        "dense1_out":dense1,
        "logits":logits,
        "classes": tf.argmax(input=logits, axis=1),
        "labels": features['label'],
        "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
        }
    # 当mode为tf.estimator.ModeKeys.PREDICT时,我们就让模型返回预测的操作
    if mode == tf.estimator.ModeKeys.PREDICT:
        return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

3. 训练分支

# 训练和评估时都会用到loss
    loss = tf.losses.sparse_softmax_cross_entropy(labels=features['label'], logits=logits)
    # 训练分支
    if mode == tf.estimator.ModeKeys.TRAIN:
        optimizer = tf.train.AdamOptimizer(learning_rate=1e-3)
        train_op = optimizer.minimize(
        loss=loss,
        # global_step用于记录训练了多少步
        global_step=tf.train.get_global_step())
        # 返回的tf.estimator.EstimatorSpec根据
        return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

4. 评估分支

# 注意评估的时候,模型和训练时一样,是一个循环的loop,不断累积计算评估指标。
    # 其中有两个局部变量total和count来控制
    # 把网络中的某个tensor结果直接作为字典的value是不好用的
    # loss的值是始终做记录的,eval_metric_ops中是额外想要知道的评估指标
    eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=features['label'], predictions=predictions["classes"])}
    # 不好用:eval_metric_ops = {"probabilities": predictions["probabilities"]}
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)


四、创建estimator

注意:送入的model_fn和input_fn一样是一个函数,不可以是model_fn()返回结果

# model_dir 表示模型要存到哪里
mnist_classifier = tf.estimator.Estimator(
    model_fn=model_fn, model_dir="mnist_model_cnn")

训练后的模型参数会保存在model_dir中,随着训练在目录下生成拥有类似下面内容的checkpoint文件。

model_checkpoint_path: "model.ckpt-860"
all_model_checkpoint_paths: "model.ckpt-1"
all_model_checkpoint_paths: "model.ckpt-430"
all_model_checkpoint_paths: "model.ckpt-431"
all_model_checkpoint_paths: "model.ckpt-860"

当你再次运行相同model_dir的Estimator时,它默认会读取model_checkpoint_path: "model.ckpt-860"的模型权重。

如果想要改变读取的检查点到之前的某个时刻,可以改变:

model_checkpoint_path: "model.ckpt-431"
all_model_checkpoint_paths: "model.ckpt-1"
all_model_checkpoint_paths: "model.ckpt-430"
all_model_checkpoint_paths: "model.ckpt-431"
all_model_checkpoint_paths: "model.ckpt-860"


五、训练

1. 日志

# 在训练或评估的循环中,每50次print出一次字典中的数值
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

2. 训练

  • hooks:如果不送值,则训练过程中不会显示字典中的数值
  • steps:指定了训练多少次,如果不送值,则训练到dataset API遍历完数据集为止
  • max_steps:指定了最大训练次数
mnist_classifier.train(input_fn=train_input_fn, hooks=[logging_hook])

如果再次运行,同时没有限制最大训练次数,那么网络会从最后一个checkpoint读取模型权重接着训练。


六、评估

# 训练集
eval_results = mnist_classifier.evaluate(input_fn=train_eval_fn, checkpoint_path=None)
print('train set')
print(eval_results)
# 测试集
# checkpoint_path是可以指定选择那个时刻保存的权重进行评估
eval_results = mnist_classifier.evaluate(input_fn=test_input_fn, checkpoint_path=None)
print('test set')
print(eval_results)

七、预测

predicts =list(mnist_classifier.predict(input_fn=test_input_fn))

predicts是一个list,list中的元素是dictionary

predicts[0].keys()
# 输出为:
dict_keys(['image', 'conv1_out', 'pool1_out', 'conv2_out', 'pool2_out', 'pool2_flat_out', 'dense1_out', 'logits', 'classes', 'labels', 'probabilities'])

如果想要输出4个第一个卷基层的输出,可以

plt.figure(num=4,figsize=(28,28))
for i in range(4):
    plt.subplot(1,4,i+1)
    plt.imshow(predicts[0]['conv1_out'][:,:,i],cmap = plt.cm.gray)
plt.savefig('conv1_out.png')


八、可视化

tensorboard --logdir=mnist_model_cnn
打开http://localhost:6006 

编辑于 2018-10-24

文章被以下专栏收录