在前面两篇文章介绍了深度学习的一些基本概念，本文则使用Python实现一个简单的深度神经网络，并使用MNIST数据库进行测试。
神经网络的实现，包括以下内容：

• 神经网络权值的初始化
• 正向传播
• 误差评估
• 反向传播
• 更新权值

主要是根据反向传播的4个基本方程，利用Python实现神经网络的反向传播。

初始化

首先定义代表神经网络的类NeuralNetwork,

class NeuralNetwork:def __init__(self,layers,alpha=0.1):self.W = []self.layers = layersself.alpha = alpha

有三个属性，

• W存储各个层之间的权值矩阵，也是神经网络要更新学习的
• layers 神经网络的结构，例如： [2,2,1]表示输入层有2个神经元，隐藏层2个神经元，输出层只有1个神经元。
• alpha 学习速率

接下来初始化各个层之间的权值矩阵

for i in np.arange(0,len(layers) - 2):w = np.random.randn(layers[i] + 1,layers[i + 1] + 1)self.W.append(w / np.sqrt(layers[i]))

注意上面生成权值矩阵的大小layers[i] + 1,layers[i + 1] + 1，都加了1。 这是将神经元的偏置和权值统一的放到了权值矩阵里面。
\[ \left[ \begin{array}{c}w_{11} & w_{12} \\ w_{21} & w_{22}\end{array} \right] \cdot \left[\begin{array}{c}x_1 \\ x_2\end{array}\right] + \left[\begin{array}{c}b_1 \\ b_2\end{array}\right] = \left[\begin{array}{c}w_{11}x_1 + w{12}x_2 + b_1 \\ w_{21}x_1 + w_{22}x_2 + b_2 \end{array}\right] \]

可以将上式写成齐次的形式
\[ \left[ \begin{array}{c}w_{11} & w_{12} & b_1 \\ w_{21} & w_{22} &b_2 \end{array} \right] \cdot \left[\begin{array}{c}x_1 \\ x_2 \\ 1\end{array}\right] \]

使用统一的矩阵运算，在正向反向传播的时候更方便。

在输出层的神经元并没有偏置，所以要单独初始化输出层的权值矩阵

        w = np.random.randn(layers[-2] + 1,layers[-1])self.W.append(w / np.sqrt(layers[-2]))

下面实现Python的magic function __repr__输出神经网络结构

    def __repr__(self):return "NeuralNetWork:{}".format("-".join(str(l) for l in self.layers))

激活函数

在神经网络中使用sigmoid作为激活函数，实现sigmoid及其导数

    def sigmoid(self,x):return 1.0 / (1 + np.exp(-x))def sigmoid_deriv(self,x):return x * (1 - x)

正向反向传播

这一部分是神经的网络的核心了。下面实现fit方法，在方法中完成神经网络权值更新（训练）的过程。

    def fit(self,X,y,epochs=1000,displayUpdate=100):X = np.c_[X,np.ones((X.shape[0]))]for epoch in np.arange(0,epochs):for(x,target) in zip(X,y):self.fit_partial(x,target)# check to see if we should display a training updateif epoch == 0 or (epoch + 1) % displayUpdate == 0:loss = self.calculate_loss(X,y)print("[INFO] epoch={},loss={:.7f}".format(epoch + 1,loss))

该函数有4个参数：

• X是输入的样本数据
• y是样本的真是值
• epochs训练的轮数
• displayUpdate 输出训练的loss值。

X = np.c_[X,np.ones((X.shape[0]))]将输入训练的样本表示为齐次向量（也就是在末尾添1）。fit_partial是对输入的每个样本进行训练，包括正向传播，反向传播以及权值的更新。

    def fit_partial(self,x,y):A = [np.atleast_2d(x)]# 正向传播# 层层之间的数据传递for layer in np.arange(0,len(self.W)):# 输入经过加权以及偏置后的值net = A[layer].dot(self.W[layer])# 神经元的输出out = self.sigmoid(net)# 保存下来，反向传播的时候使用A.append(out)

上面完成了神经玩过的正向传播过程，下面根据反向传播的4个基本方程进行反向传播。
首先根据\(BP1\),
\[ \delta^L = \frac{\partial e}{\partial a^L} \odot \sigma'(z^L) \tag{BP1} \]
计算输出层的误差\(\delta^L\)

        error = A[-1] - y # 输出层的误差，均值方差作为损失函数D = [error * self.sigmoid_deriv(A[-1])]

得到输出层的误差D后，根据\(BP2\)计算各个层的误差
\[ \delta^{L-1} = (W^L)^T\delta^L \odot \sigma'(z^{L-1}) \tag{BP2} \]

        for layer in np.arange(len(A) - 2,0 ,-1):delta = D[-1].dot(self.W[layer].T)delta = delta * self.sigmoid_deriv(A[layer])D.append(delta)D = D[::-1]

将D反转，和各个层的索引对应起来，下面根据\(BP3,BP4\)计算权值矩阵和偏置的导数
\[ \frac{\partial e}{b_j^l} = \delta_j^l \tag{BP3} \]
\[ \frac{\partial e}{w_{jk}^l} = \delta_j^l a_k^{l-1} \tag{BP4} \]

        for layer in np.arange(0,len(self.W)):self.W[layer] += -self.alpha * A[layer].T.dot(D[layer])

首先求得权值和偏置的导数（权值和偏置统一到同一个矩阵中）A[layer].T.dot(D[layer]，然后将梯度乘以学习速率alpha 每次权值减小的步长。

上述就完成利用反向传播算法更新权值的过程。 关于反向传播四个基本方程的推导过程，可以参考文章深度学习与计算机视觉： 搞懂反向传播算法的四个基本方程

误差评估

上面代码已经实现了深度学习的训练过程，下面实现predict输出使用训练好的模型预测的结果，calculate_loss评估训练后模型的评估

    def predict(self,X,addBias=True):p = np.atleast_2d(X)if addBias:p = np.c_[p,np.ones((p.shape[0]))]for layer in np.arange(0,len(self.W)):p = self.sigmoid(np.dot(p,self.W[layer]))return p def calculate_loss(self,X,targets):targets = np.atleast_2d(targets)predictions = self.predict(X,addBias=False)loss = 0.5 * np.sum((predictions - targets) ** 2)return loss 

MNIST分类识别

使用上面实现的深度神经网络对MNIST手写体进行识别，首先导入必要的包

import NeuralNetwork
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn import datasets

需要使用sklearn包中的一些工具，进行数据的处理。

# load MNIST数据集，并使用min/max对数据进行归一化
digits = datasets.load_digits()
data = digits.data.astype("float")
data = (data - data.min()) / (data.max() - data.min())print("[INFO] samples: {}, dim: {}".format(data.shape[0], data.shape[1]))

将数据拆分为训练集和测试集，并对MNIST的类别进行编码

(trainX, testX, trainY, testY) = train_test_split(data, digits.target, test_size=0.25)# convert the labels from integers to vectors
trainY = LabelBinarizer().fit_transform(trainY)
testY = LabelBinarizer().fit_transform(testY)

下面构建神经网络结构，并使用训练集进行训练

nn = NeuralNetwork([data.shape[1], 32,16, 10])print ("[INFO] {}".format(nn))nn.fit(trainX, trainY, epochs=1000)

神经网络结构为：64-32-16-10，其中64为输入数据的大小，10输出类别的个数。

最后评估训练得到的模型

predictions = nn.predict(testX)print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1)))

最终的输出结果：

[INFO] loading MNIST (sample) dataset...
[INFO] samples: 1797, dim: 64
[INFO] training network...
[INFO] NeuralNetWork:64-32-16-10
[INFO] epoch=1,loss=607.1711647
[INFO] epoch=100,loss=7.1082795
[INFO] epoch=200,loss=4.0731690
[INFO] epoch=300,loss=3.1401868
[INFO] epoch=400,loss=2.8801101
[INFO] epoch=500,loss=1.8738122
[INFO] epoch=600,loss=1.7461474
[INFO] epoch=700,loss=1.6624043
[INFO] epoch=800,loss=1.1852884
[INFO] epoch=900,loss=0.6710255
[INFO] epoch=1000,loss=0.6336826
[INFO] evaluating network...precision    recall  f1-score   support0       1.00      0.95      0.97        391       0.84      1.00      0.92        382       1.00      0.98      0.99        413       0.93      0.98      0.95        524       0.91      0.97      0.94        405       0.98      0.98      0.98        416       1.00      0.96      0.98        517       1.00      0.98      0.99        488       0.98      0.89      0.93        559       0.98      0.93      0.95        45micro avg       0.96      0.96      0.96       450macro avg       0.96      0.96      0.96       450
weighted avg       0.96      0.96      0.96       450

如上测试结果，在测试集的上表现还算不错。

总结

本文使用Python简单的实现了一个神经网络。 主要是利用反向传播的4个基本方程，实现反向传播算法，更新各个神经元的权值。 最后使用该网络，对MNIST数据进行识别分类。

上面实现的神经网络只是“玩具”，用以加深对深度学习的训练过程以及反向传播算法的理解。后面将使用Keras和PyTorch来构建神经网络。

本文代码在git库 https://github.com/brookicv/machineLearningSample