tensorflow入门应用方法(三)——卷积网络搭建

前两篇文章tensorflow入门应用方法(二)——全连接深度网络搭建和tensorflow入门应用方法——线性回归和逻辑回归分别描述了应用tensorflow搭建拥有两层隐藏层的全连接型深度模型和单层逻辑回归和线性回归的方法流程。本文主要讲述应用tensorflow搭建卷积神经网络识别MNIST手写数字的模型训练方法。

卷积网络搭建

本文搭建的卷积网络模型主要有三层隐藏层，其中两层conv_layers和一层full_conn_layers，加上最后的输出层，一共为四层网络结构。

卷积网络结构图

如下图，四层网络模型分别是64层特征的卷积层+128层特征的卷积层+1024层特征的全连接层+输出层。输出层为10个特征层，分别代表手写数字0~9相关特征。

由图可知，每层卷积层后面连接max pool层，上采样可以:1. 保持特征处理的不变性，例如，图片特征的微小平移，旋转等不会收到影响；2. 减少参数和计算量，防止过拟合，增强模型泛化能力。

本文的卷积网络结构示意图

代码实现

首先，加载mnist数据

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data


mnist = input_data.read_data_sets('data/', one_hot=True)

trainimg = mnist.train.images
trainlabel = mnist.train.labels
testimg = mnist.test.images
testlabel = mnist.test.labels

print('MNIST loaded')

然后，参数初始化

# 输入输出
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_output])
keepratio = tf.placeholder(tf.float32)


Weights = {
    'wc1': tf.Variable(tf.random_normal([3,3,1,64], stddev=0.1)),
    # 3,3,1,64 -- f_hight, f_width, input_channel, output_channel
    'wc2': tf.Variable(tf.random_normal([3,3,64,128], stddev=0.1)),
    'wd1': tf.Variable(tf.random_normal([7*7*128, 1024], stddev=0.1)),
    # 两次max pool以后由28×28变成7×7   卷积特征核的大小变化公式：(input_(h,w) - f_(h,w) + 2*padding)/stride + 1，
    # 这里卷积对特征核大小没有影响
    'wd2': tf.Variable(tf.random_normal([1024, n_output], stddev=0.1))
}

biases = {
    'bc1': tf.Variable(tf.random_normal([64], stddev=0.1)),
    'bc2': tf.Variable(tf.random_normal([128], stddev=0.1)),
    'bd1': tf.Variable(tf.random_normal([1024], stddev=0.1)),
    'bd2': tf.Variable(tf.random_normal([n_output], stddev=0.1))
}

这里网络权重初始化时，参数的维度设计很重要。例如，在卷积层wc1中，[3,3,1,64]分别代表卷积核高度，卷积核宽度，输入通道，输出通道。因此，卷积核为一个四维的tensor。

在从卷积层到连接层时，连接层的参数设计也需要准确计算，需要从整个网络的输入数据的维度开始推算，例如，全连接层wd1，参数为7×7×128。原始输入数据维度是28×28,这里由于两次2×2的max pool操作之后，维度变成28/2/2=7,所以是7×7,而128是上一层输出的通道数量，因此这里维度是7×7×128。

此外，卷积操作也会影响特征大小的变化，其变化公式为：layer_(n+1)_(h,w) = (layer_n_(h,w) - f_(h,w) + 2padding)/stride + 1，layer_(n+1)_(h,w)代表n+1层特征的高和宽维度，layer_n_(h,w)代表n层特征的高和宽维度，f_(h,w)代表卷积核的高和宽，padding代表padding长度，stride代表卷积核移动的步长。这里，layer_(n+1)_(h,w)=(28 - 3 + 21)/1 + 1 = 28，所以每层卷积操作对特征层维度没有影响。

下面定义卷积层以及相关网络结构

# 定义卷积层
def conv_basic(_input, _w, _b, _keepratio):
    # input
    _input_r = tf.reshape(_input, shape=[-1, 28, 28, 1])
    # shape=[batch_size, input_height, input_width, input_channel]
    # conv layer1
    _conv1 = tf.nn.conv2d(_input_r, _w['wc1'], strides=[1,1,1,1], padding='SAME')
    # strides = [batch_size_stride, height_stride, width_stride, channel_stride]
    _conv1 = tf.nn.relu(tf.nn.bias_add(_conv1, _b['bc1']))
    _pool1 = tf.nn.max_pool(_conv1, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
    # padding = 'SAME' 代表会填补0, padding = 'VALID' 代表不会填补，丢弃最后的行列元素
    _pool_dr1 = tf.nn.dropout(_pool1, _keepratio)
    # conv layer2
    _conv2 = tf.nn.conv2d(_pool_dr1, _w['wc2'], strides=[1,1,1,1], padding='SAME')
    _conv2 = tf.nn.relu(tf.nn.bias_add(_conv2, _b['bc2']))
    _pool2 = tf.nn.max_pool(_conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    # ksize = [batch_size_stride, height_stride, width_stride, channel_stride]
    _pool_dr2 = tf.nn.dropout(_pool2, _keepratio)
    # vectorize
    _dense1 = tf.reshape(_pool_dr2, [-1, _w['wd1'].get_shape().as_list()[0]]) # reshape
    # full connection layer
    _fc1 = tf.nn.relu(tf.add(tf.matmul(_dense1, _w['wd1']), _b['bd1']))
    _fc_dr1 = tf.nn.dropout(_fc1, _keepratio)
    _out = tf.add(tf.matmul(_fc_dr1, _w['wd2']), _b['bd2'])
    # result
    out = {
        'input_r': _input_r, 'conv1': _conv1, 'pool1': _pool1, 'pool_dr1': _pool_dr1,
        'conv2': _conv2, 'pool2': _pool2, 'pool_dr2': _pool_dr2, 'dense1': _dense1,
        'fc1': _fc1, 'fc_dr1': _fc_dr1, 'out': _out
    }
    return out

print('CNN ready')

每一层卷积中，主要包括卷积操作，池化，dropout。其中，dropout操作主要随机删除一定比率的w参数，使得w参数有更强的泛化能力。

网络结构的定义

# 网络定义
_pred = conv_basic(x, Weights, biases, keepratio)['out']
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=_pred, labels=y))
optm = tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)
_corr = tf.equal(tf.arg_max(_pred, 1), tf.arg_max(y, 1))
accr = tf.reduce_mean(tf.cast(_corr, tf.float32))
init = tf.global_variables_initializer()

print('graph ready')

与前几篇文章相似，网络结构主要包括：

1. 前向计算
2. 损失值计算
3. 梯度优化
4. 计算模型精确度
5. 初始化所有参数操作

最后，进行迭代

# 迭代计算
training_epochs = 30
batch_size = 20
display_step = 5
sess = tf.Session()
sess.run(init)

for epoch in range(training_epochs):
    avg_cost = 0
    # total_batch = int(mnist.train.num_examples/batch_size)
    total_batch = 5
    for i in range(total_batch):
        batch_xs, batch_ys = mnist.train.next_batch(batch_size)
        feeds = {x: batch_xs, y: batch_ys, keepratio: 0.5}
        sess.run(optm, feed_dict=feeds)
        avg_cost += sess.run(cost, feed_dict=feeds)/total_batch
    # 显示结果
    if (epoch+1) % display_step == 0:
        print('Epoch: %03d/%03d cost: %.9f' % (epoch+1, training_epochs, avg_cost))
        feeds = {x: batch_xs, y: batch_ys, keepratio: 1.0}
        train_acc = sess.run(accr, feed_dict=feeds)
        print('Train accuracy: %.3f' % train_acc)
        # feeds = {x: mnist.test.images, y: mnist.test.labels, keepratio: 1.0}
        # test_acc = sess.run(accr, feed_dict=feeds)
        # print('Test accuracy: %.3f' % test_acc)

print('optmization finished')

迭代操作中，定义dropout比率为0.5。

结果输出

由于笔记本内存不足，在以上代码中的total_batch变量手动将赋值改为5，下面是迭代30次输出的训练结果。

Epoch: 005/030 cost: 2.127988672
Train accuracy: 0.450
Epoch: 010/030 cost: 1.514546847
Train accuracy: 0.600
Epoch: 015/030 cost: 1.691785026
Train accuracy: 0.600
Epoch: 020/030 cost: 1.580975151
Train accuracy: 0.750
Epoch: 025/030 cost: 1.391473675
Train accuracy: 0.800
Epoch: 030/030 cost: 1.286683488
Train accuracy: 0.750
optmization finished