内容提要

MNIST数据集简介神经元常用函数深度神经网络卷积神经网络介绍循环神经网络

一、MNIST数据集简介

数据集（Dataset）是一类数据的集合。传统的数据集通常表现为表格或者文档形式，每个数值被称为数据资料。

MNIST数据集是一个含有手写数字的大型数据集，包含0～9共10个数字，通常用于训练图像处理系统。

MNIST数据集包含60000个训练图像和10000个测试图像。

MNIST数据集共有4个文件，分别是训练集数据、训练集标签以及测试集数据、测试集标签。MNIST数据集的图像以字节的形式进行存储，每幅图像都为单通道图像，由28×28个像素点构成。

MNIST数据集的测试集样本图像如图所示：

不同分类器使用MNIST数据集的错误率如表所示：

二、神经元常用函数

2.1 激活函数

1、sigmoid()函数

在之前的一段时间内，sigmoid()函数是非常常用的，因为它对神经元的激活有很好的解释，且它本身为单调连续，非常适合作为输出层。

缺陷：

第一，当输入稍微远离了坐标原点，函数的梯度就变得很小了，几乎为0，这会导致在反向传播过程中，梯度很小的时候接近0，神经网络无法更新参数，这个问题称为梯度饱和，也可以称为梯度弥散。

第二，sigmoid()函数的输出不是零中心的，这会影响梯度下降的运作。

2、tanh()函数

tanh()函数的数学公式为

，tanh()函数图像如图所示。

tanh()函数的定义域是实数域 ，值域是(-1,1)。其输入如果是很大的负数，其值就会无限接近于-1。

输入如果是很大的正数，其值就会无限接近于1。

和sigmoid()函数一样，tanh()也存在梯度饱和问题，但是tanh()的输出是零中心的，所以实际使用更多一些。

3、ReLU函数

ReLU函数的数学公式为

，ReLU函数图像如图所示。

ReLU函数的定义域是实数 ，值域是[0, +∞] 。这个激活函数可以理解为一个关于0的阈值。

2.2 池化函数

池化是用一个矩阵窗口在张量上进行扫描，通过取最大值或者平均值等方式来减少参数数量的方法。最大值池化和平均值池化的过程如图所示。

池化层主要对输入的图像进行降采样（Subsample），池化并不改变深度或维度，只改变大小。池化函数有平均值池化函数和最大值池化函数等。

1、平均值池化函数

TensorFlow函数：tf.nn.avg_pool(value,ksize,strides,padding,name=None)，该函数计算的是池化区域的平均值。

value：需要池化的输入，一般池化层接在卷积层后面，这是一个四维的张量，4个维度为[batch,height,width,channels]。

ksize：池化窗口的大小，是一个四维向量，一般是[1,height,width,1]。

strides：和卷积类似，是窗口在每一个维度上滑动的步长，一般是[1,stride,stride,1]。

padding：和卷积类似，可以取“VALID”或“SAME”。

name：该池化的名称。

2、最大值池化函数

TensorFlow函数：tf.nn.max_pool(value,ksize,strides,padding,name=None)，该函数计算的是池化区域的最大值。

在池化时一般选择最大值池化。

2.3 损失函数

1、hinge损失函数

hinge损失函数源自支持向量机，在支持向量机中，最终的目的是最大化分类间隔，减少错误分类的样本数目。

损失函数公式为

，其中，

， 是一个超参数，设置为1.0时，在绝大多数情况下都是安全的。

2、square损失函数

损失函数公式为

，大多用在线性回归中。

3、log损失函数

在使用似然函数最大化时，其形式是进行连乘，但是为了便于处理，一般会加上log，这样便可以将连乘转换为求和。

由于log函数是单调递增函数，因此不会改变优化结果。log类型的损失函数也是一种常见的损失函数。

4、交叉熵

如何判断输出的结果与期望结果有多接近呢？

交叉熵（Cross Entropy）是常用的方法之一。

交叉熵的公式为

， 是分类问题的真实分布概率， 是分类问题的预测分布概率，也就是说，交叉熵的输入是概率，范围是[0,1]。

交叉熵得到的值越小，真实分布概率和预测分布概率越接近，预测的结果就越真实。

由于网络的输出是任意的，如ReLU函数的值域为 ，所以在进行交叉熵计算之前还需要将输出结果转换为概率分布。

softmax()函数就是一个常用的方法，它的公式为

，该函数所有输出值的和为1，输入的负数会变成正数，然后外面嵌套 函数，就可以得到优化结果。

三、深度神经网络

深度神经网络（Deep Neural Networks，DNN）可以理解为有很多隐藏层的神经网络。

具有一层隐藏层的神经网络如图所示。

神经网络某个节点的计算公式是

，n为网络的第n层，

是权重矩阵，

是第一层的偏置矩阵，f()是激活函数，它会作用到每个元素。经过这些激活函数的转换后，由于每个节点不再是线性变换的，所以整个神经网络就成为非线性的了。

反向传播过程：如果有表达式

，现在需要求出

，先将这个复合函数的表达式分解为

和

，根据链式求导法则可知

，所以需要分别求出

和

，可以求得

，

，故得到

。前向传播与反向传播过程如图所示。

四、卷积神经网络介绍

卷积神经网络（Convolutional Neural Networks，CNN）是一类深度神经网络，最常用于分析视觉图像。

一个简单的卷积神经网络是由各种层按一定顺序排列的。

卷积神经网络主要由卷积层（Convolutional Layers）、池化层（Pooling Layers）、全连接层（Fully Connected Layers，FC Layers）构成。将这些层按一定的顺序排列，就可以搭建一个卷积神经网络。

4.1 LeNet-5模型及其实现

LeNet-5模型是由杨立昆（YannLeCun）教授于1998年在论文Gradient-Based Learning Applied to Document Recognition中提出的，是一种用于手写体字符识别的非常高效的卷积神经网络。

网络实现过程如图。

卷积层是一个将卷积运算和加法运算组合在一起的隐藏层，在图像识别里提到的卷积是二维卷积，即离散二维滤波器（也称作卷积核）与二维图像做卷积操作。

简单地讲是二维滤波器滑动到二维图像上的所有位置，并在每个位置上与该像素点及其领域像素点做内积，卷积运算过程如图所示：

1、LeNet-5实现的过程

（1） 输入层

（2）卷积层（第一层）

（3）池化层（第二层）

（4）卷积层（第三层）

（5）池化层（第四层）

（6）全连接层（第五层）

（7）全连接层（第六层）

（8）全连接层，输出层（第七层）

2、欠拟合

欠拟合（Under Fitting）是由于特征维度过少，模型过于简单，使神经网络没办法完全满足数据集的特征提取要求，体现在训练以及预测时表现不佳、成功率低。欠拟合解决方法如下。

（1）将模型复杂化。

（2）增加更多特征，使输入数据的特征更明显。

（3）调整超参数。

（4）减弱正则化约束或者去掉正则化约束。

3、过拟合

过拟合是指模型在训练集上表现很好，但在验证和测试阶段效果比较差，即模型的泛化能力很差。过拟合的解决方法如下。

（1）增加训练数据量。

（2）减少数据特征，去掉数据中非共性的特征。

（3）调整超参数。

（4）使用正则化约束或者增强正则化约束。

（5）降低模型的复杂度。

（6）使用Dropout。

（7）Early Stopping，即提前结束训练。

4、卷积神经网络的TensorFlow实现

通过TensorFlow框架实现一个类似于LeNet-5的神经网络，来解决MNIST数据集上的数字识别问题。

本网络与原LeNet-5的区别是：卷积核的个数不同；激活函数不同，

此处用的是ReLU，输出层选择softmax()函数，二者的整体过程是一致的。

案例1：在TensorFlow目录下新建文件，命名为LeNet-5.py，利用TensorFlow解决类似于LeNet-5在MNIST数据集上进行数字识别的问题，在PyCharm中编写以下代码。

<code># -×- coding: utf-8 -×-

# 载入MINIST数据需要的库

from tensorflow.examples.tutorials.mnist import input_data

# 保存模型需要的库

from tensorflow.python.framework.graph_util import convert_variables_to_constants

from tensorflow.python.framework import graph_util

# 导入其他库

import tensorflow as tf

import time

import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# 获取MINIST数据

mnist = input_data.read_data_sets("./MNIST_data", one_hot=True)

# 占位符

# x是特征值，也就是像素

# 使用一个28×28=784列的数据来表示一个图像的构成

# 每一个点都是这个图像的一个特征

# 因为每一个点都会对图像的外观和表达的含义有影响，只是影响的大小不同而已

x = tf.placeholder("float", shape=[None, 784], name="Mul") # 输入28×28=784code>

# y_是真实数据[0,0,0,0,1,0,0,0,0]，为4

y_ = tf.placeholder("float", shape=[None, 10], name="y_") # 输出code>

# 变量 784×10的矩阵

# W表示每一个特征值（像素点）影响结果的权重

# 这个值很重要，因为深度学习的过程就是发现特征

# 经过一系列训练，得出每一个特征值对结果影响的权重

W = tf.Variable(tf.zeros([784, 10]), name='x')code>

b = tf.Variable(tf.zeros([10]), 'y_')

# 权重

def weight_variable(shape):

# 生成的值服从具有指定平均值和标准偏差的正态分布

# 如果生成的值大于平均值的两个标准偏差的值，则丢弃重新选择

initial = tf.truncated_normal(shape, stddev=0.1) # 标准差为0.1

return tf.Variable(initial)

# 偏差

def bias_variable(shape):

initial = tf.constant(0.1, shape=shape)

return tf.Variable(initial)

# 卷积

def conv2d(x, W):

# 参数x指需要做卷积的输入图像，要求它是一个Tensor

# 具有[batch, in_height, in_width, in_channels]这样的shape

# 具体含义是[训练时一个batch的图像数量, 图像高度, 图像宽度, 图像通道数]

# 注意这是一个4维的Tensor，batch和in_channels在卷积层中通常设为1

# 参数W相当于CNN中的卷积核，要求它是一个Tensor

# 具有[filter_height, filter_width, in_channels, out_channels]这样的shape

# 具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]

# 注意，第三维in_channels就是参数x的第四维

return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='VALID')code>

# 参数strides：卷积时在图像每一维的步长，这是一个一维的向量，长度为4

# 参数padding：string类型的量，只能是“VALID”，不补零

# 最大池化

def max_pool_2x2(x):

# x：input

# ksize：filter，滤波器大小为2×2

# strides：步长，2×2，表示filter窗口每次水平移动两格，每次垂直移动两格

# padding：填充方式，补零

return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')code>

# 第一层卷积

# 权重+偏置+激活+池化

# patch为5×5；in_size为1，即图像的厚度，如果是彩色的，则为3；32个卷积核（滤波器）

W_conv1 = weight_variable([5, 5, 1, 32])

b_conv1 = bias_variable([32])

# 对数据进行重新排列，形成图像

x_image = tf.reshape(x, [-1, 28, 28, 1])

# print("x",x)

# print("x_image",x_image)

# ReLU操作，输出大小为28×28×32

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

# Pooling操作，输出大小为14×14×32

h_pool1 = max_pool_2x2(h_conv1)

# 第二层卷积

# 权重+偏置+激活+池化

# patch为5×5；in_size为32，即图像的厚度；out_size是64，即输出的大小

W_conv2 = weight_variable([5, 5, 32, 64])

b_conv2 = bias_variable([64])

# ReLU操作，输出大小为14×14×64

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

# Pooling操作，输出大小为7×7×64

h_pool2 = max_pool_2x2(h_conv2)

# 全连接一

W_fc1 = weight_variable([7 × 7 × 64, 1024])

b_fc1 = bias_variable([1024])

# 全连接二

W_fc2 = weight_variable([1024, 10])

b_fc2 = bias_variable([10])

# 输入数据变换

# 变换为m×n，列n为7×7×64

h_pool2_flat = tf.reshape(h_pool2, [-1, 7 × 7 × 64])

# 进行全连接操作

# tf.nn.relu()函数可将大于0的数保持不变，将小于0的数置为0

h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

# Dropout可防止过拟合，它一般用在全连接层，训练用，测试不用

# Dropout就是在不同的训练过程中随机扔掉一部分神经元

# Dropout可以让某个神经元的激活值以一定的概率p停止工作

# 参数keep_prob：设置神经元被选中的概率，在初始化时keep_prob是一个占位符

# TensorFlow在运行时设置keep_prob具体的值，如keep_prob: 0.5

keep_prob = tf.placeholder("float", name='rob')code>

h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

# 用于训练的softmax()函数将所有数据归一化到0～1之间，大的数据特征更明显

y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2, name='res')code>

# 训练完成后，进行测试用的softmax()函数

y_conv2 = tf.nn.softmax(tf.matmul(h_fc1, W_fc2) + b_fc2, name="final_result")code>

# 交叉熵的计算，返回包含了损失值/误差的Tensor

# 熵是衡量事物混乱程度的一个值

cross_entropy = -tf.reduce_sum(y_ × tf.log(y_conv))

# 优化器，负责最小化交叉熵

train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

# tf.argmax()：取出该数组最大值的下角标

correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))

# 计算准确率

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

# 创建会话

with tf.Session() as sess:

time_begin = time.time()

# 初始化所有变量

sess.run(tf.global_variables_initializer())

# print(sess.run(W_conv1))

# 保存输入/输出，可以在之后用

tf.add_to_collection('res', y_conv)

tf.add_to_collection('output', y_conv2)

tf.add_to_collection('x', x)

### 训练开始 ###

for i in range(10000):

# 取出MNIST数据集中的50个数据

batch = mnist.train.next_batch(50)

# run()可以看作输入相关值到函数中的占位符，然后计算出结果

# 这里将batch[0]给x，将batch[1]给y_

# 执行训练过程并传入真实数据

train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

if i % 100 == 0:

train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})

print("step %d, training accuracy %g" % (i, train_accuracy))

time_elapsed = time.time() - time_begin

print("训练所用时间：%d秒" % time_elapsed)

# 用saver 保存模型

saver = tf.train.Saver()

saver.save(sess, "model_data/model")

执行该程序，如果计算机安装的是CPU版本的TensorFlow，建议将训练步数调少，否则会训练非常久。

训练完成后的准确率如图所示。

生成的模型在TensorFlow目录下的model_data目录中，模型文件如图所示。

提示：

LeNet-5模型的结构比较清晰，即输入层→卷积层（池化层）→全连接层→输出层，但是有些网络中是没有池化层的。

4.2 AlexNet介绍