一、 问题描述

基于Numpy和函数im2col与col2im来实现一个简单的卷积神经网络，将其用于手写体识别。

二、 设计简要描述

机器学习的三个基本步骤——

程序设计思路——(此图放大可看清)

三、程序清单

1．卷积层实现

import numpy as np
from main import im2col, col2imclass Convolution:def __init__(self, W, b, stride=1, pad=0):self.W = Wself.b = bself.stride = strideself.pad = pad# 中间数据（backward时使用）self.x = Noneself.col = Noneself.col_W = None# 权重和偏置参数的梯度self.dW = Noneself.db = Nonedef forward(self, x):FN, C, FH, FW = self.W.shape  # 卷积核的形状N, C, H, W = x.shape  # 输入数据形状out_h = 1 + int((H + 2 * self.pad - FH) / self.stride)  # 输出数据的高out_w = 1 + int((W + 2 * self.pad - FW) / self.stride)  # 输出数据的宽col = im2col(x, FH, FW, self.stride, self.pad)  # 展开的数据col_W = self.W.reshape(FN, -1).T  # 卷积核展开为二维数组out = np.dot(col, col_W) + self.b  # 计算展开后的矩阵乘积# 输出大小转换为合适的形状# transpose会更改多维数组的轴的顺序，将输出数据形状由(N,H,W,C)转变为(N,C,H,W)# 索引(0,1,2,3)对应着(N,H,W,C)out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)# 更新backward过程需要用到的中间数据self.x = xself.col = colself.col_W = col_Wreturn out

2．池化层实现

import numpy as np
from main import im2col, col2imclass Pooling:def __init__(self, pool_h, pool_w, stride=1, pad=0):self.pool_h = pool_hself.pool_w = pool_wself.stride = strideself.pad = pad# 存储backward需用到的中间数据self.x = Noneself.arg_max = Nonedef forward(self, x):N, C, H, W = x.shapeout_h = int(1 + (H - self.pool_h) / self.stride)  # 输出数据的高out_w = int(1 + (W - self.pool_w) / self.stride)  # 输出数据的宽# 展开输入数据col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)col = col.reshape(-1, self.pool_h * self.pool_w)arg_max = np.argmax(col, axis=1)# 求出各行的最大值out = np.max(col, axis=1)# 通过reshape方法将数据转换为合适的形状out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)# 保存backward过程中需要用到的中间数据self.x = xself.arg_max = arg_maxreturn out# 反向传播def backward(self, dout):dout = dout.transpose(0, 2, 3, 1)pool_size = self.pool_h * self.pool_wdmax = np.zeros((dout.size, pool_size))dmax[np.arange(self.arg_max.size), self.arg_max.flatten()] = dout.flatten()dmax = dmax.reshape(dout.shape + (pool_size,))dcol = dmax.reshape(dmax.shape[0] * dmax.shape[1] * dmax.shape[2], -1)dx = col2im(dcol, self.x.shape, self.pool_h, self.pool_w, self.stride, self.pad)return dx

3．网络搭建

from collections import OrderedDictimport numpy as np
from Convolution import Convolution
from Pooling import Pooling
from SoftmaxWithLoss import SoftmaxWithLoss
from Relu import Relu
from Affine import Affineclass SimpleConvNet:"""简单的ConvNetconv - relu - pool - linear - relu - linear - softmaxParameters----------input_size : 输入大小（MNIST的情况下为784）conv_param : 保存卷积层的超参数（字典）hidden_size_list : 隐藏层的神经元数量的列表（e.g. [100, 100, 100]）output_size : 输出大小（MNIST的情况下为10）activation : 'relu' or 'sigmoid'weight_init_std : 指定权重的标准差（e.g. 0.01）指定'relu'或'he'的情况下设定“He的初始值”指定'sigmoid'或'xavier'的情况下设定“Xavier的初始值”"""# input_dim是输入数据的通道，高，长# conv_param是卷积层的超参数# hidden_size是倒数第二个全连接层神经元数量# output_size是最后一个全连接层神经元数量# weight_init_std是权重的标准差def __init__(self, input_dim=(1, 28, 28),conv_param={'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1},hidden_size=100, output_size=10, weight_init_std=0.01):"""
这里将由初始化参数传入的卷积层的超参数从字典中取了出来（以方便后面使用），然后，计算卷积层和池化层的输出大小。"""filter_num = conv_param['filter_num']  # conv_param―卷积层的超参数（字典）。filter_size = conv_param['filter_size']  # 卷积核的大小filter_pad = conv_param['pad']  # 步幅filter_stride = conv_param['stride']  # 填充input_size = input_dim[1]conv_output_size = (input_size - filter_size + 2 * filter_pad) / filter_stride + 1pool_output_size = int(filter_num * (conv_output_size / 2) * (conv_output_size / 2))# 初始化权重"""学习所需的参数是第1层的卷积层和剩余两个全连接层的权重和偏置。将这些参数保存在实例变量的params字典中。将第1层的卷积层的权重设为关键字W1，偏置设为关键字b1。同样，分别用关键字W2、b2和关键字W3、b3来保存第2个和第3个全连接层的权重和偏置。"""# 卷积层的参数初始化self.params = {}self.params['W1'] = weight_init_std * \np.random.randn(filter_num, input_dim[0], filter_size, filter_size)self.params['b1'] = np.zeros(filter_num)# 两个Linear层的参数的初始化self.params['W2'] = weight_init_std * \np.random.randn(pool_output_size,hidden_size)self.params['b2'] = np.zeros(hidden_size)self.params['W3'] = weight_init_std * \np.random.randn(hidden_size, output_size)self.params['b3'] = np.zeros(output_size)# 生成层self.layers = OrderedDict()# 向有序字典（OrderedDict）的layers中添加层# 依次命名为'Conv1'、'Relu1'、'Pool1'、'Linear1'、'Relu2'、'Affine2'self.layers['Conv1'] = Convolution(self.params['W1'],self.params['b1'],conv_param['stride'],conv_param['pad'])self.layers['Relu1'] = Relu()self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)self.layers['Affine1'] = Affine(self.params['W2'],self.params['b2'])self.layers['Relu2'] = Relu()self.layers['Affine2'] = Affine(self.params['W3'],self.params['b3'])self.lastLayer = SoftmaxWithLoss()"""
参数x是输入数据，t是教师标签。
用于推理的predict方法从头开始依次调用已添加的层，并将结果传递给下一层。
在求损失函数的loss方法中，除了使用 forward方法进行的前向传播处理之外，还会继续进行forward处理，直到到达最后的SoftmaxWithLoss层。"""def forward(self, x):for layer in self.layers.values():x = layer.forward(x)return xdef loss(self, x, t):"""求损失函数参数x是输入数据、t是数据标签"""y = self.forward(x)return self.lastLayer.forward(y, t)def accuracy(self, x, t, batch_size=100):if t.ndim != 1: t = np.argmax(t, axis=1)acc = 0.0for i in range(int(x.shape[0] / batch_size)):tx = x[i * batch_size:(i + 1) * batch_size]tt = t[i * batch_size:(i + 1) * batch_size]y = self.forward(tx)y = np.argmax(y, axis=1)acc += np.sum(y == tt)return acc / x.shape[0]"""参数的梯度通过误差反向传播法（反向传播）求出，通过把正向传播和反向传播组装在一起来完
成。因为已经在各层正确实现了正向传播和反向传播的功能，所以这里只需要以合适的顺序调用
即可。最后，把各个权重参数的梯度保存到grads字典中。"""def backward(self, x, t):# 运用误差反向传播法求取梯度# forwardself.loss(x, t)# backwarddout = 1dout = self.lastLayer.backward(dout)layers = list(self.layers.values())layers.reverse()for layer in layers:dout = layer.backward(dout)# 将学习过程中计算出的权重参数梯度保存到grads字典中grads = {}grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].dbgrads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].dbgrads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].dbreturn grads

4．训练模型与结果展示

import numpy as np
import matplotlib.pyplot as plt
from mnist import load_mnist
from optimizer import *
from SimpleConvNet import SimpleConvNet# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)# 处理花费时间较长的情况下减少数据
x_train, t_train = x_train[:5000], t_train[:5000]
x_test, t_test = x_test[:1000], t_test[:1000]class Trainer:"""进行神经网络的训练的类"""def __init__(self, network, x_train, t_train, x_test, t_test,epochs=20, mini_batch_size=100, optimizer='Adam', optimizer_param={'lr': 0.01},evaluate_sample_num_per_epoch=None, verbose=True):self.network = networkself.verbose = verboseself.x_train = x_trainself.t_train = t_trainself.x_test = x_testself.t_test = t_testself.epochs = epochsself.batch_size = mini_batch_sizeself.evaluate_sample_num_per_epoch = evaluate_sample_num_per_epoch# 选择优化方式optimizer_class_dict = {'sgd': SGD, 'momentum': Momentum, 'nesterov': Nesterov,'adagrad': AdaGrad, 'rmsprpo': RMSprop, 'adam': Adam}self.optimizer = optimizer_class_dict[optimizer.lower()](**optimizer_param)self.train_size = x_train.shape[0]self.iter_per_epoch = max(self.train_size / mini_batch_size, 1)self.max_iter = int(epochs * self.iter_per_epoch)self.current_iter = 0self.current_epoch = 0self.train_loss_list = []self.train_acc_list = []self.test_acc_list = []def train_step(self):batch_mask = np.random.choice(self.train_size, self.batch_size)x_batch = self.x_train[batch_mask]t_batch = self.t_train[batch_mask]# 调用网络的backward函数获取梯度grads = self.network.backward(x_batch, t_batch)# 使用优化器更新参数self.optimizer.update(self.network.params, grads)loss = self.network.loss(x_batch, t_batch)self.train_loss_list.append(loss)if self.verbose: print("train loss:" + str(loss))if self.current_iter % self.iter_per_epoch == 0:self.current_epoch += 1x_train_sample, t_train_sample = self.x_train, self.t_trainx_test_sample, t_test_sample = self.x_test, self.t_testif not self.evaluate_sample_num_per_epoch is None:t = self.evaluate_sample_num_per_epochx_train_sample, t_train_sample = self.x_train[:t], self.t_train[:t]x_test_sample, t_test_sample = self.x_test[:t], self.t_test[:t]# 计算训练精度train_acc和测试精度test_acctrain_acc = self.network.accuracy(x_train_sample, t_train_sample)test_acc = self.network.accuracy(x_test_sample, t_test_sample)self.train_acc_list.append(train_acc)self.test_acc_list.append(test_acc)if self.verbose: print("=== epoch:" + str(self.current_epoch) + ", train acc:" + str(train_acc) +", test acc:" + str(test_acc) + " ===")self.current_iter += 1def train(self):for i in range(self.max_iter):  # 训练循环self.train_step()test_acc = self.network.accuracy(self.x_test, self.t_test)if self.verbose:print("=============== Final Test Accuracy ===============")print("test acc:" + str(test_acc))max_epochs = 20# 将之前定义的SimpleConvNet网络实例化
network = SimpleConvNet(input_dim=(1, 28, 28),conv_param={'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1},hidden_size=100, output_size=10, weight_init_std=0.01)trainer = Trainer(network, x_train, t_train, x_test, t_test,epochs=max_epochs, mini_batch_size=100, optimizer='Adam', optimizer_param={'lr': 0.001},evaluate_sample_num_per_epoch=1000)
trainer.train()# 绘制图形
markers = {'train': 'o', 'test': 's'}
x = np.arange(max_epochs)
plt.plot(x, trainer.train_acc_list, marker='o', label='train', markevery=2)
plt.plot(x, trainer.test_acc_list, marker='s', label='test', markevery=2)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

四、结果分析

实验结果符合预期

五、调试报告

1.控制台报错
Traceback (most recent call last):
File “E:/project/pythonProject/08_CNN/Trainer.py”, line 101, in
trainer = Trainer(network, x_train, t_train, x_test, t_test,
File “E:/project/pythonProject/08_CNN/Trainer.py”, line 35, in init
self.optimizer = optimizer_class_dictoptimizer.lower()
TypeError: type object argument after ** must be a mapping, not float
解决：应该将训练类在初始化参数时的lr = 0.001改为optimizer_param={‘lr’:0.01}

2. 控制台报错
   Traceback (most recent call last):
   File “E:/project/pythonProject/08_CNN/Trainer.py”, line 104, in
   trainer.train()
   File “E:/project/pythonProject/08_CNN/Trainer.py”, line 85, in train
   self.train_step()
   File “E:/project/pythonProject/08_CNN/Trainer.py”, line 53, in train_step
   grads = self.network.backward(x_batch, t_batch)
   File “E:\project\pythonProject\08_CNN\SimpleConvNet.py”, line 124, in backward
   self.loss(x, t)
   File “E:\project\pythonProject\08_CNN\SimpleConvNet.py”, line 99, in loss
   return self.lastLayer.forward(y, t)
   AttributeError: ‘SimpleConvNet’ object has no attribute ‘lastLayer’

原因：定义网络时参数用的是

解决：改为lastLayer即可

六、实验小结

本次实验使用numpy和两个展开函数实现了CNN的卷积和池化层，进一步理解了CNN的内部结构，并结合之前的实验搭建了一个简单的卷积神经网络进行手写体识别，采用反向传播和Adam来优化，在较短的时间内得到了较好的实验精度，可见CNN的优势所在。最大的收获是对卷积层和池化层原理的透彻理解。