神经网络：误差反向传播算法基础学习

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 激活函数的神经元模型，其数学模型可以写为：

其中变量的上标表示层数，𝑜⁽¹⁾表示第一层的输出，𝒙表示网络的输入。

.

  神经元模型绘制如图，图中未画出偏置𝑏，输入节点数为 J。其中输入第𝑗个节点到输出 𝑜⁽¹⁾ 的权值连接记为 𝑤_j1⁽¹⁾ ，上标表示权值参数属于的层数，下标表示当前连接的起始节点号和终止节点号，如下标𝑗1表示上一层的第𝑗号节点到当前层的第 1 号节点。经过激活函数𝜎之前的变量叫做 𝑧₁⁽¹⁾ ，经过激活函数𝜎之后的变量叫o₁⁽¹⁾ ，由于只有一个输出节点，故o₁⁽¹⁾ = o⁽¹⁾ = o 。输出与真实标签之间通过误差函数函数计算误差值，误差值记为ℒ
  若采用均方误差函数，考虑到单个神经元只有一个输出o₁⁽¹⁾ ，则损失函数可以表达为：

其中𝑡为真实标签值，添加1/2并不影响梯度的方向，但计算更简便。
.
  以权值连接的第𝑗 ∈[1,𝐽]号节点的权值变量𝑤₁为例，考虑损失函数ℒ对其的偏导数：

  从上式可以看到，误差对权值𝑤₁的偏导数只与输出值𝑜₁、真实值𝑡以及当前权值连接的输入𝑥_j 有关。

4.2 全连接层梯度

  把单个神经元模型推广到单层的全连接层的网络上，输入层通过一个全连接层得到输出向量o₍₁₎，与真实标签向量𝒕计算均方误差。输入节点数为 J，输出节点数为𝐾。多输出的全连接网络层模型与单个神经元模型不同之处在于，它多了很多的输出节点𝑜₁⁽¹⁾，𝑜₂⁽¹⁾，𝑜₃⁽¹⁾，……，𝑜_k⁽¹⁾，每个输出节点分别对应到真实标签𝑡₁，𝑡₂，𝑡₃，……，𝑡_k。𝑤_k 是输入第 𝑗 号节点与输出第𝑘号节点的连接权值。

  均方误差可以表达为：

.
  以权值连接的第𝑗 ∈[1,𝐽]号节点的权值变量𝑤_k为例，考虑损失函数ℒ对其的偏导数：

由此可以看到，某条连接𝑤_𝑘上面的偏导数，只与当前连接的输出节点 𝑜_𝑘⁽¹⁾，对应的真实值节点的标签 𝑡_𝑘⁽¹⁾，以及对应的输入节点 𝑥 _j 有关。
.

其中 𝛿_𝑘 变量表征连接线的终止节点的误差梯度传播的某种特性，使用 𝛿_𝑘 表示后， 𝜕ℒ / 𝜕𝑤_j𝑘 偏导数只与当前连接的起始节点𝑥 ，终止节点处𝛿𝑘有关，理解起来比较简洁直观。

4.3 链式法则

  链式法则与高数中的定义相同，能在不显式推导神经网络的数学表达式的情况下逐层推导梯度。
.

  神经网络的损失函数ℒ来自于各个输出节点𝑜_𝑘^(𝐾)，如图所示，其中输出节点 𝑜_𝑘^(𝐾) 又与隐藏层的输出节点 𝑜 _j^J 相关联，因此链式法则非常适合于神经网络的梯度推导。
  前向传播时，数据经过𝑤_i.j^J 传到倒数第二层的节点 𝑜_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)=[𝑜₁^(𝐾),𝑜₂^(𝐾)……,𝑜_k^(𝐾)]，倒数第二层节点数为 J，输出为𝒐^(J)= [𝑜₁^(J),𝑜₂^(J)……,𝑜_J^(J)]，倒数第三层的节点数为 I，输出为𝒐^(𝐼)= [𝑜₁^(I),𝑜₂^(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()