神经网络学习（三）

神经网络学习（三）

损失函数介绍

前面我们讨论的实例和公式推导都是基于平方损失函数，但是上述案例中进行的是一个分类问题，平方损失函数一般不适用与分类问题，因此我们需要使用交叉熵损失函数(Cross-Entropy Loss Function)
平方损失函数：
$$\begin{array}{r}{E}_{(i)}=\frac{1}{2}\sum _{k=1}^{n_L}{\left(y_k^{(i)}-o_k^{(i)}\right)}^2\end{array}$$
交叉熵损失函数： 一般用于分类问题。
假设样本的标签 y ∈ { 1 , … , C } y \in \{ 1,\ldots ,C\} y∈{1,…,C}为离散的类别，模型$f(x,\theta )\in [0,1{]}^C$的输出为类别标签的条件概率分布，即
$$\begin{array}{r}p(y=c|x,\theta )=f_c(x,\theta )\end{array}$$
并且要满足
$$\begin{array}{r}{f}_c(x,\theta )\in [0,1],\sum _{c=1}^C{f}_c(x,\theta )=1\end{array}$$
因此就要引入softmax函数 作为输出层函数，满足所有概率的和为1。
softmax函数：
$$\begin{array}{r}p(y=c|x,\theta )=f_c(x,\theta )=\frac{e^{y_i}}{\sum _{c=1}^C{e}^y}\end{array}$$
交叉熵函数：
$$\begin{array}{r}{E}_{(i)}=-\sum _{c=1}^C\left(y_c\text{log}{f}_c(x,\theta )\right)\end{array}$$
由于只有一个样本取1，因此上式可以写为：
$$\begin{array}{r}{E}_{(i)}=-\text{log}{f}_c(x,\theta )\end{array}$$
根据第一篇笔记的[神经网络学习（一）的例子，可以写出代价函数表达式
$$\begin{array}{rl}E& =-\sum _{c=1}^C\left(y_c\text{log}{f}_c(x,\theta )\right)\\ & =-y_1\text{log}\frac{e^{z_1^3}}{e^{z_1^3+z_2^3}}-y_2\text{log}\frac{e^{z_2^3}}{e^{z_1^3+z_2^3}}\end{array}$$

反向传播推导

根据第一篇笔记的神经网络学习（一）.可以知道，我们首先要推导出输出层的
$$\begin{array}{r}{\delta }_i^{(L)}=\frac{\partial E}{\partial z_i^{(L)}}\end{array}$$
根据复合函数求导法则：
$$\begin{array}{rlr}{\delta }_i^{(L)}& =\frac{\partial E}{\partial z_i^{(L)}}& =\sum _{j=1}^{n_L}\left(\frac{\partial E_j}{\partial f_j^{(L)}}\frac{\partial f_j^{(L)}}{\partial z_i^{(L)}}\right)\end{array}$$
其中：
$$\begin{array}{rl}\frac{\partial f_j^{(L)}}{\partial z_i^{(L)}}& =\frac{\partial (-y_{j}log{f}_j)}{\partial f_j}\\ & =-y_i\frac{1}{f_i}\end{array}$$
商的求导法则：
$$\begin{array}{r}{\left(\frac{u}{v}\right)}^{\prime }=\frac{u^{\prime }v-u{v}^{\prime }}{v^2}\end{array}$$
下面就要需要分成两种情况：

1. 当$i=j$：
   $$\begin{array}{rl}\frac{\partial f_i}{\partial z_i}& =\frac{\partial \left(\frac{e^{z_i}}{\sum _{c=1}^C{e}^{(z_c)}}\right)}{\partial z_i}\\ & =\frac{\sum _{c=1}^C{e}^{(z_c)}{e}^{z_i}-(e^{z_i}{)}^2}{(\sum _{c=1}^C{e}^{(z_c)}{)}^2}\\ & =(\frac{e^{z_i}}{\sum _{c=1}^C{e}^{(z_c)}})(1-\frac{e^{z_i}}{\sum _{c=1}^C{e}^{(z_c)}})\\ & =f_i(1-f_i)\end{array}$$
2. 当$i\ne j$：
   $$\begin{array}{rl}\frac{\partial f_j}{\partial z_i}& =\frac{\partial \left(\frac{e^{z_j}}{\sum _{c=1}^C{e}^{(z_c)}}\right)}{\partial z_i}\\ & =-e^{z_j}{\left(\frac{1}{\sum _{c=1}^C{e}^{(z_c)}}\right)}^2{e}^{z_i}\\ & =-(\frac{e^{z_i}}{\sum _{c=1}^C{e}^{(z_c)}})(\frac{e^{z_j}}{\sum _{c=1}^C{e}^{(z_c)}})\\ & =-f_i{f}_j\end{array}$$
   故:
   $$\begin{array}{rl}{\delta }_i^{(L)}& =\frac{\partial E}{\partial z_i^{(L)}}\\ & =\sum _{c\ne i}^C-y_c\frac{1}{f_c}(-f_i{f}_c)+(-y_i\frac{1}{f_i})(f_i(1-f_i))\\ & =\sum _{c\ne i}^C{y}_c{f}_i+y_i{f}_i-y_i\\ & =f_i\sum _{c=1}^C{y}_c-y_i\end{array}$$
   由于$y_c$只有一个结果是1，因此结果可以写成：
   $$\begin{array}{rl}{\delta }_i^{(L)}& =\frac{\partial E}{\partial z_i^{(L)}}=f_i-y_i\end{array}\text{\hspace{1em}(1)}$$
   此时按照推导出的递推公式进行传递更新就好
   $$\begin{array}{rl}{\mathbf{\delta }}_i^{(l)}& =\left(({\mathbf{\omega }}^{l+1}{)}^{\text{T}}{\mathbf{\delta }}^{l+1}\right)\odot f^{\prime }({\mathbf{z}}^{(l)})\\ {\nabla }_{{\omega }^l}E& ={\mathbf{\delta }}^{(l)}({\mathbf{a}}^{(l-1)}{)}^{\text{T}}\end{array}$$

程序实例

import numpy as np
from sklearn.datasets import load_digits  #导入手写数字数据集
from sklearn.preprocessing import LabelBinarizer  # 标签二值化
from sklearn.model_selection import train_test_split  # 切割数据,交叉验证法
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))


def dsigmoid(x):
    return x * (1 - x)

def softmax(x):
    sum = 0
    temp = np.zeros(len(x[0]))
    for i in range(len(x[0])):
        sum += np.exp(x[0][i]) 
        
    for i in range(len(x[0])):
        temp[i] = np.exp(x[0][i]) / sum 
        
    temp = np.atleast_2d(temp)
    return temp 
    

class NeuralNetwork:
    def __init__(self, layers):  # (64,100,10)
        # 权重的初始化,范围-1到1：+1的一列是偏置值
        self.V = np.random.random((layers[0] + 1, layers[1] + 1)) * 2 - 1
        self.W = np.random.random((layers[1] + 1, layers[2])) * 2 - 1

    def train(self, X, y, lr=0.11, epochs=10000):
        # 添加偏置值：最后一列全是1
        temp = np.ones([X.shape[0], X.shape[1] + 1])
        temp[:, 0:-1] = X
        X = temp

        for n in range(epochs + 1):
            # 在训练集中随机选取一行(一个数据)：randint()在范围内随机生成一个int类型
            i = np.random.randint(X.shape[0])
            x = [X[i]]
            # 转为二维数据：由一维一行转为二维一行
            x = np.atleast_2d(x)

            # L1：输入层传递给隐藏层的值；输入层64个节点，隐藏层100个节点
            # L2：隐藏层传递到输出层的值；输出层10个节点
            L1 = sigmoid(np.dot(x, self.V))
            L2 = softmax(np.dot(L1, self.W))
            # L2_delta：输出层对隐藏层的误差改变量
            # L1_delta：隐藏层对输入层的误差改变量
            L2_delta = y[i] - L2
            L1_delta = L2_delta.dot(self.W.T) * dsigmoid(L1)
            #print(L2)
            # 计算改变后的新权重
            self.W += lr * L1.T.dot(L2_delta)
            self.V += lr * x.T.dot(L1_delta)
            if n > 40000:
                lr = lr * 0.99
            # 每训练1000次输出一次准确率
            if n % 1000 == 0:
                predictions = []
                for j in range(X_test.shape[0]):
                    # 获取预测结果：返回与十个标签值逼近的距离，数值最大的选为本次的预测值
                    o = self.predict(X_test[j])
                    # 将最大的数值所对应的标签返回
                    predictions.append(np.argmax(o))
                # np.equal()：相同返回true，不同返回false
                accuracy = np.mean(np.equal(predictions, y_test))
                print('迭代次数：', n, '准确率：', accuracy)

    def predict(self, x):
        # 添加偏置值：最后一列全是1
        temp = np.ones([x.shape[0] + 1])
        temp[0:-1] = x
        x = temp
        # 转为二维数据：由一维一行转为二维一行
        x = np.atleast_2d(x)

        # L1：输入层传递给隐藏层的值；输入层64个节点，隐藏层100个节点
        # L2：隐藏层传递到输出层的值；输出层10个节点
        L1 = sigmoid(np.dot(x, self.V))
        L2 = softmax(np.dot(L1, self.W))
        return L2
# 载入数据:8*8的数据集
digits = load_digits()
X = digits.data
Y = digits.target
# 输入数据归一化：当数据集数值过大，乘以较小的权重后还是很大的数，代入sigmoid激活函数就趋近于1，不利于学习
X -= X.min()
X /= X.max()

NN = NeuralNetwork([64, 80, 10])
# sklearn切分数据
X_train, X_test, y_train, y_test = train_test_split(X, Y)
# 标签二值化：将原始标签(十进制)转为新标签(二进制)
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)

print('开始训练')
NN.train(X_train, labels_train, epochs=40000)
print('训练结束')

结论

通过上面推导后，对训练方式进行更改，精度可以很容易就达到98%，并且收敛速度加快，说明刚刚的推导是有效的。
但是有一个问题，为什么换了这个代价函数，整个程序就会训练的效果变好了呢？