神经网络：误差反向传播算法基础学习
1、导数与梯度
从几何角度来看，一元函数在某处的导数就是函数的切线在此处的斜率，即函数值沿着方向的变化率。而梯度表示某一函数在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大（为该梯度的模）。梯度下降算法一般是寻找函数ℒ的最小值，因此，其数学表达式为：
根据梯度下降算法，参数可以按着梯度方向进行更新：
lr参数叫学习率，代表每次更新的跨度
2、常见激活函数导数
2.1 Sigmoid 函数导数
Sigmoid函数表达式：
经推导得导数推导式：
代码实现：
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams["axes.unicode_minus"] = False
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def derivative(x):
return sigmoid(x)*(1-sigmoid(x))
sigmoid_inputs = np.arange(-10,10,0.01)
sigmoid_outputs = sigmoid(sigmoid_inputs)
sigmoid_d=derivative(sigmoid_inputs)
plt.plot(sigmoid_inputs,sigmoid_outputs)
plt.plot(sigmoid_inputs,sigmoid_d)
plt.xlabel("Sigmoid Inputs")
plt.ylabel("Sigmoid Outputs")
plt.legend(['Sigmoid函数','Sigmoid函数导数'],loc='best')
plt.show()
2.2 ReLU 函数导数
ReLU函数表达式：
经推导得导数推导式：
代码实现：
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams["axes.unicode_minus"] = False
def ReLU(x):
return np.maximum(0, x)
def derivative(x):
d = np.array(x, copy=True)
d[x < 0] = 0 # 为负的导数为 0
d[x >= 0] = 1 # 为正的导数为 1
return d
inputs = np.arange(-5,5,0.01)
outputs = ReLU(inputs)
dd=derivative(inputs)
plt.plot(inputs,outputs)
plt.plot(inputs,dd)
plt.xlabel("Inputs")
plt.ylabel("Outputs")
plt.legend(['ReLU函数','ReLU函数导数'],loc='best')
plt.show()
2.3 LeakyReLU 函数导数
LeakyReLU 函数的表达式：
经推导得导数推导式：
代码实现：
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams["axes.unicode_minus"] = False
def LeakyReLU(x):
return np.maximum(0.1*x,x)
def derivative(x, p):
d = np.array(x, copy=True)
d[x < 0] = p # 元素为负的导数为 p
d[x >= 0] = 1 # 为正的导数为 1
return d
inputs = np.arange(-5,5,0.01)
outputs = LeakyReLU(inputs)
dd=derivative(inputs,0.1)
plt.plot(inputs,outputs)
plt.plot(inputs,dd)
plt.xlabel("Inputs")
plt.ylabel("Outputs")
plt.legend(['LeakyReLU函数','LeakyReLU函数导数'],loc='best')
plt.show()
2.4 Tanh 函数导数
tanh 函数表达式：
经推导得导数推导式：
代码实现：
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams["axes.unicode_minus"] = False
def tanh(x):
return (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))
def derivative(x):
return 1-tanh(x)**2
inputs = np.arange(-5,5,0.01)
outputs = tanh(inputs)
dd=derivative(inputs)
plt.plot(inputs,outputs)
plt.plot(inputs,dd)
plt.xlabel("Inputs")
plt.ylabel("Outputs")
plt.legend(['tanh函数','tanh函数导数'],loc='best')
plt.show()
3、神经网络损失函数梯度
3.1 均方差损失函数梯度
均方误差损失函数表达式为：
经推导得均方差导数推导式：
3.2 交叉熵函数梯度
在计算交叉熵损失函数时，一般将 Softmax 函数与交叉熵函数统一实现。因此，要先推导Softmax 函数的梯度，再推导交叉熵函数的梯度。
Softmax 函数的表达式：
经推导得Softmax 函数导数推导式：
交叉熵函数的表达式：
经推导得交叉熵函数导数推导式：
4、全连接梯度传播规律
神经网络结构多种多样，不可能一一分析其梯度表达式。将以全连接层网络、激活函数采用 Sigmoid 函数、误差函数为 Softmax+MSE 损失函数的神经网络为例，推导其梯度传播规律。
4.1 单神经元梯度
对于Sigmoid 激活函数的神经元模型，其数学模型可以写为：
其中变量的上标表示层数，(1)表示第一层的输出，表示网络的输入。
.
神经元模型绘制如图，图中未画出偏置，输入节点数为 J。其中输入第个节点到输出 (1) 的权值连接记为 j1(1) ，上标表示权值参数属于的层数，下标表示当前连接的起始节点号和终止节点号，如下标1表示上一层的第号节点到当前层的第 1 号节点。经过激活函数之前的变量叫做 1(1) ，经过激活函数之后的变量叫o1(1) ，由于只有一个输出节点，故o1(1) = o(1) = o 。输出与真实标签之间通过误差函数函数计算误差值，误差值记为ℒ
若采用均方误差函数，考虑到单个神经元只有一个输出o1(1) ，则损失函数可以表达为：
其中为真实标签值，添加1/2并不影响梯度的方向，但计算更简便。
.
以权值连接的第 ∈[1,]号节点的权值变量1为例，考虑损失函数ℒ对其的偏导数：
从上式可以看到，误差对权值1的偏导数只与输出值1、真实值以及当前权值连接的输入j 有关。
4.2 全连接层梯度
把单个神经元模型推广到单层的全连接层的网络上，输入层通过一个全连接层得到输出向量o(1)，与真实标签向量计算均方误差。输入节点数为 J，输出节点数为。多输出的全连接网络层模型与单个神经元模型不同之处在于，它多了很多的输出节点1(1)，2(1)，3(1)，……，k(1)，每个输出节点分别对应到真实标签1，2，3，……，k。k 是输入第 号节点与输出第号节点的连接权值。
均方误差可以表达为：
.
以权值连接的第 ∈[1,]号节点的权值变量k为例，考虑损失函数ℒ对其的偏导数：
由此可以看到，某条连接上面的偏导数，只与当前连接的输出节点 (1)，对应的真实值节点的标签 (1)，以及对应的输入节点 j 有关。
.
其中 变量表征连接线的终止节点的误差梯度传播的某种特性，使用 表示后， ℒ / j 偏导数只与当前连接的起始节点 ，终止节点处有关，理解起来比较简洁直观。
4.3 链式法则
链式法则与高数中的定义相同，能在不显式推导神经网络的数学表达式的情况下逐层推导梯度。
.
神经网络的损失函数ℒ来自于各个输出节点()，如图所示，其中输出节点 () 又与隐藏层的输出节点 jJ 相关联，因此链式法则非常适合于神经网络的梯度推导。
前向传播时，数据经过i.jJ 传到倒数第二层的节点 j(k) ，再传播到输出层的节点 ()。在每层只有一个节点时， ℒ/.j() 可以利用链式法则，逐层分解为：
代码实现链式法则：
import tensorflow as tf
# 构建待优化变量
x = tf.constant(1.)
w1 = tf.constant(2.)
b1 = tf.constant(1.)
w2 = tf.constant(2.)
b2 = tf.constant(1.)
# 构建梯度记录器
with tf.GradientTape(persistent=True) as tape:
# 非 tf.Variable 类型的张量需要人为设置记录梯度信息
tape.watch([w1, b1, w2, b2])
# 构建 2 层线性网络
y1 = x * w1 + b1
y2 = y1 * w2 + b2
# 独立求解出各个偏导数
dy2_dy1 = tape.gradient(y2, [y1])[0]
dy1_dw1 = tape.gradient(y1, [w1])[0]
dy2_dw1 = tape.gradient(y2, [w1])[0]
# 验证链式法则，2 个输出应相等
print(dy2_dy1 * dy1_dw1)
print(dy2_dw1)
tf.Tensor(2.0, shape=(), dtype=float32)
tf.Tensor(2.0, shape=(), dtype=float32)
5、反向传播算法
输出层的偏导数公式：
同理，可以反推隐藏层的梯度传播规律。
如图，输出层节点数为 K，输出为(K)=[1(),2()……,k()]，倒数第二层节点数为 J，输出为(J)= [1(J),2(J)……,J(J)]，倒数第三层的节点数为 I，输出为()= [1(I),2(I)……,I(I)]。则倒数第二层的偏导数经推导得：
倒数第二层的偏导数为当前连接的起始节点的输出值 与终止节点 的梯度变量信息 j(J) 的简单相乘运算。可以看到，通过定义 变量，每一层的梯度表达式变得更加清晰简洁，其中 可以简单理解为当前连接 j 对误差函数的贡献值。
多层偏导数的传播规律
其中为倒数第三层的输入，即倒数第四层的输出。依照此规律，只需要循环迭代计算每一层每个节点的 ()、j(J)、~~()^ 等值即可求得当前层的偏导数，从而得到每层权值矩阵的梯度，再通过梯度下降算法迭代优化网络参数即可。
5、反向传播实例
5.1 TensorFlow 自动求导优化 Himmelblau 函数
Himmelblau 函数是用来测试优化算法的常用样例函数之一，它包含了两个自变量和，数学表达式是：
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams["axes.unicode_minus"] = False
def himmelblau(x):
# himmelblau 函数实现，传入参数 x 为 2 个元素的 List
H = (x[0] ** 2 + x[1] - 11) ** 2 + (x[0] + x[1] ** 2 - 7) ** 2
return H
#通过 np.meshgrid 函数(TensorFlow 中也有meshgrid 函数)生成二维平面网格点坐标
x = np.arange(-6, 6, 0.01) # 可视化的 x 坐标范围
y = np.arange(-6, 6, 0.01) # 可视化的 y 坐标范围
# 生成 x-y 平面采样网格点，方便可视化
X, Y = np.meshgrid(x, y)
Z = himmelblau([X, Y]) # 计算网格点上的函数值
ax = plt.axes(projection='3d')
ax.plot_surface(X,Y,Z) # 3D 曲面图
ax.view_init(60, -30)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.show()
# 用 TensorFlow 自动求导来求出函数在和的偏导数，并循环迭代更新和值来优化 Himmelblau 函数的极小值数值解
# 参数的初始化值对优化的影响不容忽视，可以通过尝试不同的初始化值，以[4, 0.]为例
x = tf.constant([4., 0.]) # 初始化参数
for step in range(200):# 循环优化 200 次
with tf.GradientTape() as tape: #梯度跟踪
tape.watch([x]) # 加入梯度跟踪列表
y = himmelblau(x) # 前向传播
# 反向传播
grads = tape.gradient(y, [x])[0]
# 更新参数,0.01 为学习率
x -= 0.01*grads
# 打印优化的极小值
if step == 199:
print ('step {}: x = {}, f(x) = {}'.format(step, x.numpy(), y.numpy()))
5.2 Numpy 实现反向传播算法
在实践中更多是利用自动求导工具计算，因为手动推导梯度方法局限性较大。现以一个 4 层的全连接网络用于二分类为例。网络输入节点数为 2，隐藏层的节点数设计为：25、50和25，输出层为2，分别表示属于类别 1 的概率和类别 2的概率。为了能直接利用我们的梯度传播公式，这里并没有采用 Softmax 函数将网络输出概率值之和进行约束，而是直接利用均方误差函数计算与 One-hot 编码的真实标签之间的误差，所有的网络激活函数全部采用 Sigmoid 函数。
5.2.1 数据集
通过 scikit-learn 库提供的便捷工具生成 2000 个线性不可分的 2 分类数据集，数据的特征长度为 2，按着7: 3比例切分训练集和测试集，其中600个样本点用于测试，不参与训练，剩下的 1400 个点用于网络的训练。
import numpy as np
import seaborn as sns
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams["axes.unicode_minus"] = False
N_SAMPLES = 2000 # 采样点数
TEST_SIZE = 0.3 # 测试数量比率
# 利用工具函数直接生成数据集
X, y = make_moons(n_samples = N_SAMPLES, noise=0.2, random_state=100)
# 将 2000 个点按着 7:3 分割为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=TEST_SIZE,random_state=42)
# 绘制数据集的分布，X 为 2D 坐标，y 为数据点的标签
def make_plot(X, y, plot_name, file_name=None, XX=None, YY=None, preds=None,dark=False):
if (dark):
plt.style.use('dark_background')
else:
sns.set_style("whitegrid")
plt.figure(figsize=(16,12))
axes = plt.gca()
axes.set(xlabel="$x_1$", ylabel="$x_2$")
plt.title(plot_name, fontsize=30)
plt.subplots_adjust(left=0.20)
plt.subplots_adjust(right=0.80)
if(XX is not None and YY is not None and preds is not None):
plt.contourf(XX, YY, preds.reshape(XX.shape), 25, alpha = 1,cmap=cm.Spectral)
plt.contour(XX, YY, preds.reshape(XX.shape), levels=[.5],cmap="Greys", vmin=0, vmax=.6)
# 绘制散点图，根据标签区分颜色
plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), s=40, cmap=plt.cm.Spectral, edgecolors='none')
plt.savefig('dataset.svg')
# 调用 make_plot 函数绘制数据的分布，其中 X 为 2D 坐标，y 为标签
make_plot(X, y, "data set")
plt.show()
5.2.2 网络层
通过新建类 Layer 实现一个网络层，需要传入网络层的输入节点数、输出节点数、激活函数类型等参数，权值 weights 和偏置张量 bias 在初始化时根据输入、输出节点数自动生成并初始化。代码如下：
class Layer:
# 全连接网络层
def __init__(self, n_input, n_neurons, activation=None, weights=None, bias=None):
"""
:param int n_input: 输入节点数
:param int n_neurons: 输出节点数
:param str activation: 激活函数类型
:param weights: 权值张量，默认类内部生成
:param bias: 偏置，默认类内部生成
"""
# 通过正态分布初始化网络权值，初始化非常重要，不合适的初始化将导致网络不收敛
self.weights = weights if weights is not None else np.random.randn(n_input, n_neurons) * np.sqrt(1 / n_neurons)
self.bias = bias if bias is not None else np.random.rand(n_neurons) * 0.1
self.activation = activation # 激活函数类型，如’sigmoid’
self.last_activation = None # 激活函数的输出值 o
self.error = None # 用于计算当前层的 delta 变量的中间变量
self.delta = None # 记录当前层的 delta 变量，用于计算梯度
def activate(self, x):
# 前向传播函数
r = np.dot(x, self.weights) + self.bias # X@W+b
# 通过激活函数，得到全连接层的输出 o
self.last_activation = self._apply_activation(r)
return self.last_activation
def _apply_activation(self, r):
# 计算激活函数的输出
if self.activation is None:
return r # 无激活函数，直接返回
# ReLU 激活函数
elif self.activation == 'relu':
return np.maximum(r, 0)
# tanh 激活函数
elif self.activation == 'tanh':
return np.tanh(r)
# sigmoid 激活函数
elif self.activation == 'sigmoid':
return 1 / (1 + np.exp(-r))
return r
def apply_activation_derivative(self, r):
# 计算激活函数的导数
# 无激活函数，导数为 1
if self.activation is None:
return np.ones_like(r)
# ReLU 函数的导数实现
elif self.activation == 'relu':
grad = np.array(r, copy=True)
grad[r > 0] = 1.
grad[r <= 0] = 0.
return grad
# tanh 函数的导数实现
elif self.activation == 'tanh':
return 1 - r ** 2
# Sigmoid 函数的导数实现
elif self.activation == 'sigmoid':
return r * (1 - r)
return r
5.2.3 网络模型
创建单层网络类后，实现网络模型的 NeuralNetwork 类，它内部维护各层的网络层 Layer 类对象，可以通过 add_layer 函数追加网络层，实现创建不同结构的网络模型目的。代码如下：
class NeuralNetwork:
# 神经网络模型大类
def __init__(self):
self._layers = [] # 网络层对象列表
def add_layer(self, layer):
# 追加网络层
self._layers.append(layer)
# 网络的前向传播只需要循环调各个网络层对象的前向计算函数即可
def feed_forward(self, X):
# 前向传播
for layer in self._layers:
# 依次通过各个网络层
X = layer.activate(X)
return X
# 用 NeuralNetwork 类创建网络对象，并添加 4 层全连接层
nn = NeuralNetwork() # 实例化网络类
nn.add_layer(Layer(2, 25, 'sigmoid')) # 隐藏层 1, 2=>25
nn.add_layer(Layer(25, 50, 'sigmoid')) # 隐藏层 2, 25=>50
nn.add_layer(Layer(50, 25, 'sigmoid')) # 隐藏层 3, 50=>25
nn.add_layer(Layer(25, 2, 'sigmoid')) # 输出层, 25=>2
# 网络模型的反向传播从最末层开始，计算每层的变量，然后根据推导出的梯度公式，将计算出的变量存储在 Layer 类的 delta 变量中
def backpropagation(self, X, y, learning_rate):
# 反向传播算法实现
# 前向计算，得到输出值
output = self.feed_forward(X)
for i in reversed(range(len(self._layers))): # 反向循环
layer = self._layers[i] # 得到当前层对象
# 如果是输出层
if layer == self._layers[-1]: # 对于输出层
layer.error = y - output # 计算 2 分类任务的均方差的导数
# 关键步骤：计算最后一层的 delta，参考输出层的梯度公式
layer.delta = layer.error * layer.apply_activation_derivative(output)
else: # 如果是隐藏层
next_layer = self._layers[i + 1] # 得到下一层对象
layer.error = np.dot(next_layer.weights, next_layer.delta)
# 关键步骤：计算隐藏层的 delta，参考隐藏层的梯度公式
layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation)
def backpropagation(self, X, y, learning_rate):
# 循环更新权值
for i in range(len(self._layers)):
layer = self._layers[i]
# o_i 为上一网络层的输出
o_i = np.atleast_2d(X if i == 0 else self._layers[i -1].last_activation)
# 梯度下降算法，delta 是公式中的负数，故这里用加号
layer.weights += layer.delta * o_i.T * learning_rate
5.2.4 网络训练
&emsp二分类任务网络设计为两个输出节点，因此需要将真实标签进行 One-hot 编码，代码如下：
def train(self, X_train, X_test, y_train, y_test, learning_rate, max_epochs):
# 网络训练函数
# one-hot 编码
y_onehot = np.zeros((y_train.shape[0], 2))
y_onehot[np.arange(y_train.shape[0]), y_train] = 1
# 将 One-hot 编码后的真实标签与网络的输出计算均方误差，并调用反向传播函数更新网络参数，循环迭代训练集 1000 遍
mses = []
accuracys = []
for i in range(max_epochs): # 训练 1000 个 epoch
for j in range(len(X_train)): # 一次训练一个样本
self.backpropagation(X_train[j], y_onehot[j], learning_rate)
if i % 10 == 0:
# 打印出 MSE Loss
mse = np.mean(np.square(y_onehot - self.feed_forward(X_train)))
mses.append(mse)
print('Epoch: %s, MSE: %f' % (i, float(mse)))
# 打印准确率
accuracy = self.accuracy(self.predict(X_test), y_test.flatten())
accuracys.append(accuracy)
print('Accuracy: %.2f%%' % (self.accuracy(self.predict(X_test), y_test.flatten()) * 100))
return mses,accuracys
完整代码
import numpy as np
import seaborn as sns
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams["axes.unicode_minus"] = False
N_SAMPLES = 2000 # 采样点数
TEST_SIZE = 0.3 # 测试数量比率
# 利用工具函数直接生成数据集
X, y = make_moons(n_samples = N_SAMPLES, noise=0.2, random_state=100)
# 将 2000 个点按着 7:3 分割为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=TEST_SIZE,random_state=42)
# 绘制数据集的分布，X 为 2D 坐标，y 为数据点的标签
def make_plot(X, y, plot_name, file_name=None, XX=None, YY=None, preds=None,dark=False):
if (dark):
plt.style.use('dark_background')
else:
sns.set_style("whitegrid")
plt.figure(figsize=(10,10))
axes = plt.gca()
axes.set(xlabel="$x_1$", ylabel="$x_2$")
plt.title(plot_name, fontsize=30)
plt.subplots_adjust(left=0.20)
plt.subplots_adjust(right=0.80)
if(XX is not None and YY is not None and preds is not None):
plt.contourf(XX, YY, preds.reshape(XX.shape), 25, alpha = 1,cmap=cm.Spectral)
plt.contour(XX, YY, preds.reshape(XX.shape), levels=[.5],cmap="Greys", vmin=0, vmax=.6)
# 绘制散点图，根据标签区分颜色
plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), s=40, cmap=plt.cm.Spectral, edgecolors='none')
plt.savefig('dataset.svg')
class Layer:
# 全连接网络层
def __init__(self, n_input, n_neurons, activation=None, weights=None, bias=None):
"""
:param int n_input: 输入节点数
:param int n_neurons: 输出节点数
:param str activation: 激活函数类型
:param weights: 权值张量，默认类内部生成
:param bias: 偏置，默认类内部生成
"""
# 通过正态分布初始化网络权值，初始化非常重要，不合适的初始化将导致网络不收敛
self.weights = weights if weights is not None else np.random.randn(n_input, n_neurons) * np.sqrt(1 / n_neurons)
self.bias = bias if bias is not None else np.random.rand(n_neurons) * 0.1
self.activation = activation # 激活函数类型，如’sigmoid’
self.last_activation = None # 激活函数的输出值 o
self.error = None # 用于计算当前层的 delta 变量的中间变量
self.delta = None # 记录当前层的 delta 变量，用于计算梯度
def activate(self, x):
# 前向传播函数
r = np.dot(x, self.weights) + self.bias # X@W+b
# 通过激活函数，得到全连接层的输出 o
self.last_activation = self._apply_activation(r)
return self.last_activation
def _apply_activation(self, r):
# 计算激活函数的输出
if self.activation is None:
return r # 无激活函数，直接返回
# ReLU 激活函数
elif self.activation == 'relu':
return np.maximum(r, 0)
# tanh 激活函数
elif self.activation == 'tanh':
return np.tanh(r)
# sigmoid 激活函数
elif self.activation == 'sigmoid':
return 1 / (1 + np.exp(-r))
return r
def apply_activation_derivative(self, r):
# 计算激活函数的导数
# 无激活函数，导数为 1
if self.activation is None:
return np.ones_like(r)
# ReLU 函数的导数实现
elif self.activation == 'relu':
grad = np.array(r, copy=True)
grad[r > 0] = 1.
grad[r <= 0] = 0.
return grad
# tanh 函数的导数实现
elif self.activation == 'tanh':
return 1 - r ** 2
# Sigmoid 函数的导数实现
elif self.activation == 'sigmoid':
return r * (1 - r)
return r
class Network:
# 神经网络模型大类
def __init__(self):
self._layers = [] # 网络层对象列表
def add_layer(self, layer):
# 追加网络层
self._layers.append(layer)
# 网络的前向传播只需要循环调各个网络层对象的前向计算函数即可
def feed_forward(self, X):
# 前向传播
for layer in self._layers:
# 依次通过各个网络层
X = layer.activate(X)
return X
def predict(self,x):
return self.feed_forward(x)
def accuracy(self,x,y):
# 计算精确度，统计每一轮所有概率为1的个数
return np.sum(np.equal(np.argmax(x, axis=1), y)) / y.shape[0]
# 网络模型的反向传播从最末层开始，计算每层的变量，然后根据推导出的梯度公式，将计算出的变量存储在 Layer 类的 delta 变量中
def backpropagation(self, X, y, learning_rate):
# 反向传播算法实现
# 前向计算，得到输出值
output = self.feed_forward(X)
for i in reversed(range(len(self._layers))): # 反向循环
layer = self._layers[i] # 得到当前层对象
# 如果是输出层
if layer == self._layers[-1]: # 对于输出层
layer.error = y - output # 计算 2 分类任务的均方差的导数
# 关键步骤：计算最后一层的 delta，参考输出层的梯度公式
layer.delta = layer.error * layer.apply_activation_derivative(output)
else: # 如果是隐藏层
next_layer = self._layers[i + 1] # 得到下一层对象
layer.error = np.dot(next_layer.weights, next_layer.delta)
# 关键步骤：计算隐藏层的 delta，参考隐藏层的梯度公式
layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation)
# 循环更新权值
for i in range(len(self._layers)):
layer = self._layers[i]
# o_i 为上一网络层的输出
o_i = np.atleast_2d(X if i == 0 else self._layers[i -1].last_activation)
# 梯度下降算法，delta 是公式中的负数，故这里用加号
layer.weights += layer.delta * o_i.T *learning_rate
def train(self, X_train, X_test, y_train, y_test, learning_rate, max_epochs):
# 网络训练函数
# one-hot 编码
y_onehot = np.zeros((y_train.shape[0], 2))
y_onehot[np.arange(y_train.shape[0]), y_train] = 1
# 将 One-hot 编码后的真实标签与网络的输出计算均方误差，并调用反向传播函数更新网络参数，循环迭代训练集 1000 遍
mses = []
accuracys = []
for i in range(max_epochs): # 训练 1000 个 epoch
for j in range(len(X_train)): # 一次训练一个样本
self.backpropagation(X_train[j], y_onehot[j], learning_rate)
if i % 10 == 0:
# 打印出 MSE Loss
mse = np.mean(np.square(y_onehot - self.feed_forward(X_train)))
mses.append(mse)
print('Epoch: %s, MSE: %f' % (i, float(mse)))
# 打印准确率
accuracy = self.accuracy(self.predict(X_test), y_test.flatten())
accuracys.append(accuracy)
print('Accuracy: %.2f%%' % (self.accuracy(self.predict(X_test), y_test.flatten()) * 100))
return mses,accuracys
nn=Network()
nn.add_layer(Layer(2, 25, 'sigmoid')) # 隐藏层1, 2=>25
nn.add_layer(Layer(25, 50, 'sigmoid')) # 隐藏层2, 25=>50
nn.add_layer(Layer(50, 25, 'sigmoid')) # 隐藏层3, 50=>25
nn.add_layer(Layer(25, 2, 'sigmoid')) # 输出层, 25=>2
mse,accuracy = nn.train(X_train,X_test,y_train,y_test,0.01,1000)
x = [i for i in range(0, 101, 10)]
# 绘制MES曲线
plt.title("MES Loss")
plt.plot(x, mse[:11], color='blue')
plt.xlabel('Epoch')
plt.ylabel('MSE')
plt.show()
# 绘制Accuracy曲线
plt.title("Accuracy")
plt.plot(x, accuracy[:11], color='blue')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.show()
