TensorFlow深度学习4—反向传播算法实战

       我们将实现一个4层的全连接网络，来完成二分类任务。网络输入节点数为2，隐藏层的节点数设计为：25、50和25，输出层两个节点，分别表示属于类别1的概率和类别2的概率，如图1所示。这里并没有采用Softmax函数将网络输出概率值之和进行约束，而是直接利用均方误差函数计算与One-hot编码的真实标签之间的误差，所有的网络激活函数全部采用 Sigmoid函数，这些设计都是为了能直接利用我们的梯度传播公式。

 

                                                                                     图1 网络结构示意图

1、数据集

       通过scikit-learn库提供的便捷工具生成2000个线性不可分的2分类数据集，数据的特征长度为2，采样出的数据分布如图2所示，所有的红色点为一类，所有的蓝色点为一类，可以看到每个类别数据的分布呈月牙状，并且是是线性不可分的，无法用线性网络获得较好效果。为了测试网络的性能，我们按着7: 3比例切分训练集和测试集，其中2000 ∙ 0 3 = 600个样本点用于测试，不参与训练，剩下的1400个点用于网络的训练。

                                                                                                图2 数据集分布

         数据集的采集直接使用scikit-learn提供的make_moons函数生成，设置采样点数和切割比率，代码如下：

def load_dataset():
    # 采样点数
    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)
    return X, y, X_train, X_test, y_train, y_test

         可以通过如下可视化代码绘制数据集的分布，如图2所示。

def make_plot(X, y, plot_name, XX=None, YY=None, preds=None, dark=False):
    # 绘制数据集的分布， X 为 2D 坐标， y 为数据点的标签
    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=plt.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('数据集分布.svg')
    plt.show()
    plt.close()

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 变量，用于计算梯度

3、网络模型

       创建单层网络类后，我们实现网络模型的NeuralNetwork类，它内部维护各层的网络层Layer类对象，可以通过add_layer函数追加网络层，实现创建不同结构的网络模型目的。代码如下：

class NeuralNetwork:
    def __init__(self):
        self._layers = []  # 网络层对象列表

    def add_layer(self, layer):
        # 追加网络层
        self._layers.append(layer)

        根据图1的网络结构配置，利用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

4、网络训练

        这里的二分类任务网络设计为两个输出节点，因此需要将真实标签y进行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 + 1):  # 训练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)
                accuracy = self.accuracy(self.predict(X_test), y_test.flatten())
                accuracys.append(accuracy)
                print('Epoch: #%s, MSE: %f' % (i, float(mse)))
                # 统计并打印准确率
                print('Accuracy: %.2f%%' % (accuracy * 100))
        return mses, accuracys

5、网络性能

      我们将每个Epoch的训练损失ℒ值记录下，并绘制为曲线，如图3所示。

                                                                                        图 3 训练误差曲线

      在训练完1000个Epoch后，在测试集600个样本上得到的准确率为：

Epoch: #990, MSE: 0.024335

Accuracy: 97.67%

       可以看到，通过手动计算梯度公式并手动更新网络参数的方式，我们在简单的二分类任务上也能获得了较低的错误率。通过精调网络超参数等技巧，还可以获得更好的网络性能。

       在每个Epoch中，我们在测试集上完成一次准确度测试，并绘制成曲线，如图4所示。可以看到，随着Epoch的进行，模型的准确率稳步提升，开始阶段提升较快，后续提升较为平缓。

                                                                       图 4 网络测试准确率

        通过这个基于Numpy手动计算梯度而实现的二分类全连接网络，相信朋友们能够更加深刻地体会到深度学习框架在算法实现中的角色。没有诸如TensorFlow这些框架，我们同样能够实现复杂的神经网络，但是灵活性、稳定性、开发效率和计算效率都较差，基于这些深度学习框架进行算法设计与训练，将大大提升算法开发人员的工作效率。同时我们也能意识到，框架只是一个工具，更重要的是，我们对算法本身的理解，这才是算法开发者最重要的能力。