【深度学习】5：CNN卷积神经网络原理

一、机器如何识图

先给大家出个脑筋急转弯：在白纸上画出一个大熊猫，一共需要几种颜色的画笔？——大家应该都知道，只需要一种黑色的画笔，只需要将大熊猫黑色的地方涂上黑色，一个大熊猫的图像就可以展现出来。

我们画大熊猫的方式，其实和绣十字绣很接近——在给定的格子里，绣上不同的颜色，最后就可以展现出一幅特定的“图片”。而机器识图的方式正好和绣十字绣的方式相反，现在有了一幅图片，机器通过识别图片中每个格子（像素点）上的颜色，将每个格子里的颜色都用数字类型存储，得到一张很大的数字矩阵，图片信息也就存储在这张数字矩阵中。

上图中每一个格子代表一个像素点，像素点里的数字代表颜色码，颜色码范围是[0，255]，（各式各样的颜色都是由红、绿、蓝三色组成，每个颜色都是0~255之间数字）

我们在得到的一张大数字矩阵的基础上开展卷积神经网络识别工作：
机器识图的过程：机器识别图像并不是一下子将一个复杂的图片完整识别出来，而是将一个完整的图片分割成许多个小部分，把每个小部分里具有的特征提取出来（也就是识别每个小部分），再将这些小部分具有的特征汇总到一起，就可以完成机器识别图像的过程了

---

二、卷积神经网络原理

用CNN卷积神经网络识别图片，一般需要的步骤有：

1. 卷积层初步提取特征
2. 池化层提取主要特征
3. 全连接层将各部分特征汇总
4. 产生分类器，进行预测识别

2.1、卷积层工作原理

卷积层的作用：就是提取图片每个小部分里具有的特征

假定我们有一个尺寸为$6\ast 6$ 的图像，每一个像素点里都存储着图像的信息。我们再定义一个卷积核（相当于权重），用来从图像中提取一定的特征。卷积核与数字矩阵对应位相乘再相加，得到卷积层输出结果。

（429 = 18x1+54x0+51x1+55x0+121x1+75x0+35x1+24x0+204x1）
卷积核的取值在没有以往学习的经验下，可由函数随机生成，再逐步训练调整

当所有的像素点都至少被覆盖一次后，就可以产生一个卷积层的输出（下图的步长为1）

机器一开始并不知道要识别的部分具有哪些特征，是通过与不同的卷积核相作用得到的输出值，相互比较来判断哪一个卷积核最能表现该图片的特征——比如我们要识别图像中的某种特征（比如曲线），也就是说，这个卷积核要对这种曲线有很高的输出值，对其他形状（比如三角形）则输出较低。卷积层输出值越高，就说明匹配程度越高，越能表现该图片的特征。

卷积层具体工作过程：
比如我们设计的一个卷积核如下左，想要识别出来的曲线如下右：

现在我们用上面的卷积核，来识别这个简化版的图片——一只漫画老鼠

当机器识别到老鼠的屁股的时候，真实区域数字矩阵与卷积核相乘作用后，输出较大：6600

而用同一个卷积核，来识别老鼠的耳朵的时候，输出则很小：0

我们就可以认为：现有的这个卷积核保存着曲线的特征，匹配识别出来了老鼠的屁股是曲线的。我们则还需要其他特征的卷积核，来匹配识别出来老鼠的其他部分。卷积层的作用其实就是通过不断的改变卷积核，来确定能初步表征图片特征的有用的卷积核是哪些，再得到与相应的卷积核相乘后的输出矩阵

2.2、池化层工作原理

池化层的输入就是卷积层输出的原数据与相应的卷积核相乘后的输出矩阵
池化层的目的：

• 为了减少训练参数的数量，降低卷积层输出的特征向量的维度
• 减小过拟合现象，只保留最有用的图片信息，减少噪声的传递

最常见的两种池化层的形式：

• 最大池化：max-pooling——选取指定区域内最大的一个数来代表整片区域
• 均值池化：mean-pooling——选取指定区域内数值的平均值来代表整片区域

举例说明两种池化方式:（池化步长为2，选取过的区域，下一次就不再选取）

在$4\ast 4$的数字矩阵里，以步长$2\ast 2$选取区域，比如上左将区域[1,2,3,4]中最大的值4池化输出；上右将区域[1,2,3,4]中平均值5/2池化输出

2.3、全连接层工作原理

卷积层和池化层的工作就是提取特征，并减少原始图像带来的参数。然而，为了生成最终的输出，我们需要应用全连接层来生成一个等于我们需要的类的数量的分类器。

全连接层的工作原理和之前的神经网络学习很类似，我们需要把池化层输出的张量重新切割成一些向量，乘上权重矩阵，加上偏置值，然后对其使用ReLU激活函数，用梯度下降法优化参数既可。

---

三、卷积神经网络代码解析

3.1、数据集的读取，以及数据预定义

from tensorflow.examples.tutorials.mnist import input_data
#读取MNIST数据集
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
#预定义输入值X、输出真实值Y    placeholder为占位符
x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
keep_prob = tf.placeholder(tf.float32)
x_image = tf.reshape(x, [-1,28,28,1])

• MNIST是Google的很经典的一个做图像识别的数据集，图片大小是$28\ast 28$的，需要先下载才能使用。
• x、y_现在都是用占位符表示，当程序运行到一定指令，向x、y_传入具体的值后，就可以代入进行计算了
• shape=[None, 784]是数据维度大小——因为MNIST数据集中每一张图片大小都是$28\ast 28$的，计算时候是将$28\ast 28$的二维数据转换成一个一维的、长度为784的新向量。None表示其值大小不定，意即选中的x、y_的数量暂时不定
• keep_prob 是改变参与计算的神经元个数的值。（下有详细说明）

3.2、权重、偏置值函数

def weight_variable(shape):
	# 产生随机变量
	initial = tf.truncated_normal(shape, stddev=0.1)
	return tf.Variable(initial)

def bias_variable(shape):
	initial = tf.constant(0.1, shape=shape)
	return tf.Variable(initial)

truncated_normal()函数：选取位于正态分布均值=0.1附近的随机值

3.3、卷积函数、池化函数定义

def conv2d(x, W):
	#stride = [1,水平移动步长,竖直移动步长,1]
	return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
	# stride = [1,水平移动步长,竖直移动步长,1]
	return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
						  strides=[1, 2, 2, 1], padding='SAME')

• 输入x是图片信息矩阵，W是卷积核的值
• 卷积层conv2d()函数里strides参数要求第一个、最后一个参数必须是1；
• 第二个参数表示：卷积核每次向右移动的步长
• 第三个参数表示：卷积核每次向下移动的步长

在上面卷积层的工作原理中，有展示strides=[1, 1, 1, 1]的动态图，
下面展示strides=[1, 2, 2, 1]时的情况：可以看到高亮的区域每次向右移动两格，向下移动两格

可以得到：当我们的卷积层步长值越大，得到的输出图像的规格就会越小。为了使得到的图像的规格和原图像保持一样的大，在输入图像四周填充足够多的 0 边界就可以解决这个问题，这时padding的参数就为“SAME”（利用边界保留了更多信息，并且也保留了图像的原大小）下图：

padding的另一个可选参数为“VALID”，和“SAME”不同的是：不用0来填充边界，这时得到的图像的规格就会小于原图像。新图像尺寸大小 = 原数据尺寸大小-卷积核尺寸大小+1（一般我们选用的padding都为“SAME”）

池化函数用简单传统的2x2大小的模板做max pooling，池化步长为2，选过的区域下次不再选取

3.4、第一次卷积+池化

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

# 卷积层1网络结构定义
# 卷积核1：patch=5×5;in size 1;out size 32;激活函数reLU非线性处理
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
# output size 28*28*32
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) 
# output size 14*14*32
h_pool1 = max_pool_2x2(h_conv1)    

• 图片集是黑白单色，x_image 中的图片尺寸参数最后一个 = 1，彩色 = 3
• 这里的卷积核大小是$5\ast 5$的，输入的通道数是1，输出的通道数是32
• 卷积核的值这里就相当于权重值，用随机数列生成的方式得到
• 由于MNIST数据集图片大小都是$28\ast 28$，且是黑白单色，所以准确的图片尺寸大小是$28\ast 28\ast 1$（1表示图片只有一个色层，彩色图片都RGB3个色层），所以经过第一次卷积后，输出的通道数由1变成32，图片尺寸变为：$28\ast 28\ast 32$（相当于拉伸了高）
• 再经过第一次池化，池化步长是$2\ast 2$，相当于每四个小格子池化成一个数值，所以经过池化后图片尺寸为$14\ast 14\ast 32$

3.5、第二次卷积+池化

#卷积层2网络结构定义
#卷积核2：patch=5×5;in size 32;out size 64;激活函数reLU非线性处理
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
# output size 14*14*64
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) 
# output size 7 *7 *64
h_pool2 = max_pool_2x2(h_conv2)                          

• 这里的卷积核大小也是$5\ast 5$的，第二次输入的通道数是32，输出的通道数是64
• 第一次卷积+池化输出的图片大小是$14\ast 14\ast 32$，经过第二次卷积后图片尺寸变为：$14\ast 14\ast 64$
• 再经过第二次池化（池化步长也是$2\ast 2$），最后输出的图片尺寸为$7\ast 7\ast 64$

3.6、全连接层1、全连接层2

# 全连接层1
W_fc1 = weight_variable([7*7*64,1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1,7*7*64])  
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) 

# 全连接层2
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
prediction = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

• 全连接层的输入就是第二次池化后的输出，尺寸是$7\ast 7\ast 64$，全连接层1设置有1024个神经元
• tf.reshape(a,newshape)函数，当newshape = -1时，函数会根据已有的维度计算出数组的另外shape属性值
• keep_prob 是为了减小过拟合现象。每次只让部分神经元参与工作使权重得到调整。只有当keep_prob = 1时，才是所有的神经元都参与工作
• 全连接层2设置有10个神经元，相当于生成的分类器
• 经过全连接层1、2，得到的预测值存入prediction 中

3.7、梯度下降法优化、求准确率

#二次代价函数:预测值与真实值的误差
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=prediction))
#梯度下降法:数据太庞大,选用AdamOptimizer优化器
train_step = tf.train.AdamOptimizer(1e-4).minimize(loss)
#结果存放在一个布尔型列表中
correct_prediction = tf.equal(tf.argmax(prediction,1), tf.argmax(y_,1))
#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

• 由于数据集太庞大，这里采用的优化器是AdamOptimizer，学习率是1e-4
• tf.argmax(prediction,1)返回的是对于任一输入x预测到的标签值，tf.argmax(y_,1)代表正确的标签值
• correct_prediction 这里是返回一个布尔数组。为了计算我们分类的准确率，我们将布尔值转换为浮点数来代表对与错，然后取平均值。例如：[True, False, True, True]变为[1,0,1,1]，计算出准确率就为0.75

3.8、其他说明、保存参数

for i in range(1000):
	batch = mnist.train.next_batch(50)
	if i%100 == 0:
		train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0})
		print("step",i, "training accuracy",train_accuracy)
	train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

'''
#保存模型参数
saver.save(sess, './model.ckpt')
print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
'''

• batch 是来源于MNIST数据集，一个批次包含50条数据
• feed_dict=({x: batch[0], y_: batch[1], keep_prob: 0.5}语句：是将batch[0]，batch[1]代表的值传入x，y_；
• keep_prob = 0.5 只有一半的神经元参与工作

当完成训练时，程序会保存学习到的参数，不用下次再训练
特别提醒：运行非常占内存，而且运行到最后保存参数时，有可能卡死电脑

---

四、2018年内容：源码及效果展示

# -*- coding:utf-8 -*-
# -*- author：zzZ_CMing
# -*- 2018/01/24；14:14
# -*- python3.5

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

def weight_variable(shape):
	# 产生随机变量
	# truncated_normal：选取位于正态分布均值=0.1附近的随机值
	initial = tf.truncated_normal(shape, stddev=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):
	#stride = [1,水平移动步长,竖直移动步长,1]
	return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
	# stride = [1,水平移动步长,竖直移动步长,1]
	return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
						  strides=[1, 2, 2, 1], padding='SAME')

#读取MNIST数据集
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
sess = tf.InteractiveSession()

#预定义输入值X、输出真实值Y    placeholder为占位符
x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
keep_prob = tf.placeholder(tf.float32)
x_image = tf.reshape(x, [-1,28,28,1])
#print(x_image.shape)  #[n_samples,28,28,1]

#卷积层1网络结构定义
#卷积核1：patch=5×5;in size 1;out size 32;激活函数reLU非线性处理
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) #output size 28*28*32
h_pool1 = max_pool_2x2(h_conv1)                          #output size 14*14*32

#卷积层2网络结构定义
#卷积核2：patch=5×5;in size 32;out size 64;激活函数reLU非线性处理
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) #output size 14*14*64
h_pool2 = max_pool_2x2(h_conv2)                          #output size 7 *7 *64

# 全连接层1
W_fc1 = weight_variable([7*7*64,1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1,7*7*64])   #[n_samples,7,7,64]->>[n_samples,7*7*64]
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) # 减少计算量dropout

# 全连接层2
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
prediction = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
#prediction = tf.nn.softmax(stf.matmul(h_fc1_drop, W_fc2) + b_fc2)

#二次代价函数:预测值与真实值的误差
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=prediction))
#梯度下降法:数据太庞大,选用AdamOptimizer优化器
train_step = tf.train.AdamOptimizer(1e-4).minimize(loss)
#结果存放在一个布尔型列表中
correct_prediction = tf.equal(tf.argmax(prediction,1), tf.argmax(y_,1))
#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

saver = tf.train.Saver()  # defaults to saving all variables
sess.run(tf.global_variables_initializer())

for i in range(1000):
	batch = mnist.train.next_batch(50)
	if i%100 == 0:
		train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0})
		print("step",i, "training accuracy",train_accuracy)
	train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

'''
#保存模型参数
saver.save(sess, './model.ckpt')
print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
'''

效果展示如下：

训练700次时候，成功率已经到达98%，越往后学习，准确率越高

---

五、2024年内容：

import numpy as np
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.utils import to_categorical

# 加载 MNIST 数据集
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 数据预处理
X_train = X_train.reshape(-1, 28, 28, 1).astype("float32") / 255  # 重塑并归一化
X_test = X_test.reshape(-1, 28, 28, 1).astype("float32") / 255    # 重塑并归一化
y_train = to_categorical(y_train, 10)  # 将标签转换为one-hot编码
y_test = to_categorical(y_test, 10)

# 构建卷积神经网络模型
model = Sequential([
    Conv2D(32, (3, 3), activation="relu", input_shape=(28, 28, 1)),  # 第1个卷积层
    MaxPooling2D(pool_size=(2, 2)),                                  # 最大池化层
    Conv2D(64, (3, 3), activation="relu"),                           # 第2个卷积层
    MaxPooling2D(pool_size=(2, 2)),                                  # 最大池化层
    Flatten(),                                                       # 展平层
    Dense(128, activation="relu"),                                   # 全连接层
    Dropout(0.5),                                                    # Dropout层
    Dense(10, activation="softmax")                                  # 输出层
])

# 编译模型
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])

# 训练模型
model.fit(X_train, y_train, epochs=10, batch_size=128, validation_data=(X_test, y_test))

# 评估模型
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print(f"Test accuracy: {test_accuracy * 100:.2f}%")

代码详解：

数据预处理：

• 使用 mnist.load_data() 加载MNIST数据集，包含6万张训练图片和1万张测试图片。
• 将图片数据重塑为 (28, 28, 1) 的格式，以适应卷积层的输入形状，同时将像素值归一化到[0, 1]范围。
• 使用 to_categorical() 将标签转换为one-hot编码。

CNN模型构建：

• 第一层是一个卷积层 Conv2D，有32个3x3的过滤器，使用 relu 激活函数，输入形状为 (28, 28, 1)。
• 然后是一个2x2的最大池化层 MaxPooling2D，用于减少特征图的尺寸。
• 第二个卷积层 Conv2D 有64个3x3的过滤器，后接一个最大池化层。
• 使用 Flatten() 将特征图展平，以输入到全连接层。
• 全连接层 Dense 有128个神经元，并应用 relu 激活函数。
• Dropout(0.5) 用于在训练期间随机忽略50%的神经元，以减少过拟合。
• 最后一层是一个具有10个神经元的输出层，使用 softmax 激活函数输出分类概率。

模型编译：

• 使用Adam优化器和 categorical_crossentropy 损失函数，评估指标为 accuracy。

模型训练和评估：

• 使用 model.fit 进行模型训练，训练周期为10，每批次128个样本，使用测试集验证模型效果。
• 通过 model.evaluate 输出测试集上的准确率。

结果

• 通常情况下，使用10个周期的训练，模型能在测试集上达到98%左右的准确率。