Tensorflow2.0学习（5）---神经网络训练过程

来自书籍：TensorFlow深度学习

一、神经网络介绍

1、全连接层（前向传播）

（1）张量方式实现：tf.matmul

（2）层方式实现：

① layers.Dense(输出节点数,激活函数)，输入节点数函数自动获取

 

fc.kernel：获取权值矩阵 W

fc.bias：获取偏置向量 b

 

 fc.trainable_variables：返回待优化参数列表

fc.non_trainable_variables：不需要优化的参数列表，如Batch Normalization 层。

fc.variables :返回所有内部张量列表

② Sequence容器：可通过Sequence容器封装成一个网络大类对象。

 

# 导入 Sequential容器
from tensorflow.keras import layers,Sequential

# 通过 Sequential容器封装为一个网络类
model = Sequential([
    layers.Dense(256, activation=tf.nn.relu) , # 创建隐藏层 1
    layers.Dense(128, activation=tf.nn.relu) , # 创建隐藏层 2 
    layers.Dense(64, activation=tf.nn.relu) , # 创建隐藏层 3 
    layers.Dense(10, activation=None) , # 创建输出层
])

out = model(x) #  前向计算得到输出

 

2、激活函数

• tf.nn.sigmoid(x)：  
• tf.nn.softmax(x)： 
• tf.nn.relu(x) ：  
• tf.nn.leaky_relu(x,alpha)： ，alpha为p
• tf.nn.tanh(x)：     

3、误差计算

• 均方误差MSE：keras.losses.MSE(y_实际, y_预测) 或者 keras.losses.MeanSquaredError：

o = tf.random.normal([2,10]) # 构造网络输出 
y_onehot = tf.constant([1,3]) # 构造真实值 
y_onehot = tf.one_hot(y_onehot, depth=10)

#直接计算
loss = keras.losses.MSE(y_onehot, o) # 计算均方差 
loss = tf.reduce_mean(loss) # 计算 batch均方差 

#层方式
criteon = keras.losses.MeanSquaredError() 
loss = criteon(y_onehot,o) # 计算 batch均方差 

• 交叉熵误差：keras.losses.categorical_crossentropy(实际,预测）或者keras.losses.CategoricalCrossentropy(from_logits=True)

z = tf.random.normal([2,10]) # 构造输出层的输出
y_onehot = tf.constant([1,3]) # 构造真实值
y_onehot = tf.one_hot(y_onehot, depth=10) # one-hot编码
# 输出层未使用 Softmax函数，故 from_logits设置为 True

####方式一
# 这样 categorical_crossentropy函数在计算损失函数前，会先内部调用 Softmax函数
loss = keras.losses.categorical_crossentropy(y_onehot,z,from_logits=True) loss = tf.reduce_mean(loss) # 计算平均交叉熵损失

####方式二
# 创建 Softmax与交叉熵计算类，输出层的输出 z未使用 softmax 
criteon = keras.losses.CategoricalCrossentropy(from_logits=True) 
loss = criteon(y_onehot,z) # 计算损失

4、反向传播

（1）构建梯度记录器（梯度跟踪）：  with tf.GradientTape() as tape

（2）记录梯度信息（非 tf.Variable类型的张量需要人为设置记录梯度信息 ）：tape.watch([w1, b1, w2, b2])

（3）求解偏导（反向传播）：grads = tape.gradient(y, [w])[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 % 20 == 19:
        print ('step {}: x = {}, f(x) = {}'
               .format(step, x.numpy(), y.numpy()))

二、神经网络训练实战

（1）加载库

import tensorflow as tf
import numpy as np
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
import seaborn as sns
import matplotlib.pyplot as plt

（2）加载数据集

######利用scikit-learn 库的make_moons工具生成 2000 个线性不可分的 2 分类数据集，数据 的特征长度为 2，分布图如下图所示#####

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)
print(X.shape, y.shape) 



#######画数据分布图,可忽略#######

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.show()
    
    plt.close()
# 调用 make_plot函数绘制数据的分布，其中 X 为 2D坐标，y为标签 
make_plot(X, y, "Classification Dataset Visualization ") 

（3）构建单层全连接层网络

• 前向传播式子
• 激活函数输出
• 激活函数的导数

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

（4）搭建多层网络模型

• 前向传播（多层网络对象）
• 反向传播
• 网络训练

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
    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 
        mses = []
        accuracy = []
        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 % 100 == 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)))

                # 统计并打印准确率
                acc = self.accuracy(self.predict(X_test), y_test.flatten())
                print('Accuracy: %.2f%%'% (acc * 100))
                accuracy.append(acc*100)
                
        return mses , accuracy
    def accuracy(self, y_output, y_test):
        return np.mean((np.argmax(y_output, axis=1) == y_test))
    def predict(self, X_test):
        return self.feed_forward(X_test)

（5）执行代码，网络性能

learning_rate = 0.01
max_epochs = 1000
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
mses, accuracy = nn.train(X_train, X_test, y_train, y_test, learning_rate, max_epochs)

结果：

Epoch: #0, MSE: 0.248481
Accuracy: 49.50%
Epoch: #100, MSE: 0.096236
Accuracy: 88.83%
Epoch: #200, MSE: 0.096110
Accuracy: 88.83%
Epoch: #300, MSE: 0.095975
Accuracy: 88.83%
Epoch: #400, MSE: 0.095230
Accuracy: 88.83%
Epoch: #500, MSE: 0.092865
Accuracy: 89.17%
Epoch: #600, MSE: 0.089827
Accuracy: 90.00%
Epoch: #700, MSE: 0.083719
Accuracy: 92.50%
Epoch: #800, MSE: 0.080861
Accuracy: 92.67%
Epoch: #900, MSE: 0.076932
Accuracy: 92.83%