本文是看深度学习入门(基于python的理论与实现)这本书所做的学习笔记。本文忽略了神经网络的数学原理，着重于代码实现。

神经网络结构

神经网络结构由输入层，中间层，输出层组成。神经网络的基本构架如下图所示：

                                                                   

实现一个简单的神经网络主要实现激活函数，负责层与层之间的矩阵运算部分，输出函数这些部分的前向传播和误差后向传播，还有参数更新有损失函数部分。本文中后向传播backward() 函数返回的是参数梯度变化的值，公式的推导使用的是图计算。

激活函数

神经网络的激活函数主要有Sigmoid，ReLU函数等。

Sigmoid函数为：​

ReLU函数为：​

下图为几种激活函数的比较：

 

 

Sigmoid函数的实现代码如下所示：

class Sigmoid:"""Sigmoid激活函数实现正反向传播"""def __init__(self):self.out = None     # 反向传播需要def forward(self, x):"""根据公式计算激活函数的值"""self.out = out = 1/(1 + np.exp(-x))return outdef backward(self, dout):"""dx = dout * y * (1-y)"""return dout*self.out*(1-self.out)

ReLU函数 实现代码如下所示：

class Relu:"""Relu函数正反向传递forward():backward():"""def __init__(self):self.mask = Nonedef forward(self, x):"""当x>0时，返回x，x<=0时返回0x:为输入,是一个numpy类型"""self.mask = (x <= 0)out = x.copy()  # 产生一个备份out[self.mask] = 0return outdef backward(self, dout):"""当原输入x > 0时，反向传播直接为dout当x <= 0 时，反响传播输出0"""dout[self.mask] = 0return dout

矩阵运算Affine层

                                                                         

Affine层的图计算如图所示：

 

其中(1) 式为：​ ，(2) 式为：​ 

关于W 的梯度值的矩阵形状，即使是在mini-batch的训练下的大小也是两层节点之间的权重 W的数量，这是因为将多个样本的梯度加到了一起。因此在输出层误差反向传递时，各个节点的误差应该除以batch_size 。

​ 为后面网络的反向传递结果，看作一个已知的值。B是网络的偏置。

Affine层的代码实现如下所示。

class Affine:def __init__(self, w, b):self.W = w     # 网络之间的权重self.b = b     # 偏置self.x = None  # 输入self.dw = None # 关于x的梯度self.db = None # 关于B的梯度def forward(self, x):self.x = xreturn np.dot(x, self.W) + self.bdef backward1(self, dout):dx = np.dot(dout, self.W.T)self.dw = np.dot(self.x.T, dout)self.db = np.sum(dout, axis=0)return dxdef backward(self, dout):dx = np.dot(dout, self.W.T)if self.x.ndim == 1:self.dw = np.dot(self.x.reshape(len(self.x),1), dout.reshape(1, len(dout)))self.db = doutelse:self.dw = np.dot(self.x.T, dout)self.db = np.sum(dout, axis=0)return dx

输出层设计

一般情况下，回归问题使用恒等函数，分类问题用softmax函数。

softmax函数 的形式为：

与softmax函数一起使用的损失函数是交叉熵误差 。关于softmax函数的实现如下所示。

class SoftmaxWithLoss():"""softmax-with-loss前向后向传播实现，并计算交叉熵误差"""def __init__(self):self.loss = None # 误差self.y = None # 输出self.t = None # 监督数据def forward(self,x, t=None):"""x:输入t:标签,监督数据"""self.t = tself.y = softmax(x)self.loss = cross_entropy_error(self.y, t)return self.lossdef backward(self):return (self.y - self.t)/len(self.y)

梯度参数更新

梯度参数的更新的方法有SGD ，Momentum ，AdaGrad ，Adam 等。本文使用AdaGrad方法，实现如下所示（更新方式为所有参数一起更新）：

class AdaGrad:def __init__(self, lr=0.01):self.lr = lrself.h = Nonedef update(self, params, grads):if self.h is None:self.h = {}for key, val in params.items():self.h[key] = np.zeros_like(val)  # 给所有的梯度添加一个h，for key, val in params.items():self.h[key] += grads[key]**2params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)

初始化一个具体的神经网络

本文初始化一个四层的神经网络，初始代码如下所示。

class LayerNet:def __init__(self, input_size, hide, out_size,lr = 0.001):"""hide:隐藏层，表示为一个元组（）"""self.params = {}# 参数初始化，ReLU的权重初始化为标准差为 根号(2/n)。n为前一层的节点数self.params["W1"] = np.sqrt(2)*np.random.randn(input_size, hide[0])/np.sqrt(input_size)self.params["b1"] = np.zeros(hide[0])self.params["W2"] = np.sqrt(2)*np.random.randn(hide[0], hide[1])/np.sqrt(hide[0])self.params["b2"] = np.zeros(hide[1])self.params["W3"] = np.sqrt(2)*np.random.randn(hide[1], out_size)/np.sqrt(hide[1])self.params["b3"] = np.zeros(out_size)#生成层self.Layer = OrderedDict()    # 有序字典self.Layer["Affine1"] = Affine(self.params["W1"], self.params["b1"])self.Layer["Relu1"] = Relu()self.Layer["Affine2"] = Affine(self.params["W2"], self.params["b2"])self.Layer["Relu2"] = Relu()self.Layer["Affine3"] = Affine(self.params["W3"], self.params["b3"])self.lastLayer = SoftmaxWithLoss()self.gradchange = AdaGrad(lr)  # 梯度更新def predict(self, x, t):for layer in self.Layer.values():x = layer.forward(x)return xdef loss(self, x,t):y = self.predict(x, t)return self.lastLayer.forward(y, t)def accuracy(self,x, t):y = self.predict(x,t)mask = np.argmax(y, axis=1)t = np.argmax(t, axis = 1)return np.sum(mask == t)/float(len(t))def gradient(self, x, t):# 前向传播self.loss(x, t)# 后向传播dout = self.lastLayer.backward()layers = list(self.Layer.values())layers.reverse()for layer in layers:dout = layer.backward(dout)grad = {}grad["W1"] = self.Layer["Affine1"].dwgrad["b1"] = self.Layer["Affine1"].dbgrad["W2"] = self.Layer["Affine2"].dwgrad["b2"] = self.Layer["Affine2"].dbgrad["W3"] = self.Layer["Affine3"].dwgrad["b3"] = self.Layer["Affine3"].dbreturn graddef update_gradient(self,x, t):grad = self.gradient(x, t)self.gradchange.update(self.params, grad)

运行

本文采用的数据为sk-learn的digits dataset，是8X8的格式。图片如下图所示。

 

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import numpy as py
​
data, target = load_digits(return_X_y=True)   # 导入数据
target1 = np.array(pd.get_dummies(target))    # 把数字2形式转换为向量形式[0,0,1,0,0,0...]
X_train, X_test, y_train, y_test = train_test_split(data, target1, test_size=0.3, random_state=0)
​
network = LayerNet(64,(1000, 1000), 10, 0.0001)   # 初始化网络
iters_num = 1000                     # 迭代次数
train_size = len(X_train)
batch_size = 25                     # mini_batch的大小
iters_per_epoch = max(train_size//batch_size, 1)    # 每经过一个epoch的迭代次数
train_acc_list = []             # 对于每次epoch迭代，训练数据集的精度
test_acc_list = []              # 对于每次epoch迭代，测试数据集的精度
​
for i in range(iters_num):# 分裂数据，提取簇batch_mask = np.random.choice(train_size, batch_size)batch_X = X_train[batch_mask]batch_y = y_train[batch_mask]network.update_gradient(batch_X, batch_y)if i % iters_per_epoch == 0:train_acc_list.append(network.accuracy(X_train, y_train))test_acc_list.append(network.accuracy(X_test, y_test))

绘制学习曲线

绘制学习曲线的代码如下所示。

# 学习曲线
plt.figure()
plt.title("learn-curves")
plt.xlabel("Training epoch")
plt.ylabel("Score")
train_scores_std = np.std(train_acc_list)
test_scores_std = np.std(test_acc_list)
plt.grid()
plt.plot(np.arange(len(train_acc_list)), train_acc_list, 'o-', color="r",label="Training score")
plt.plot(np.arange(len(test_acc_list)), test_acc_list, 'o-', color="g",label="test score")
​
plt.legend(loc="best")

用上面的参数，学习曲线如下图所示。