深度学习入门笔记1

发表于 2023-07-08 更新于 2023-07-10

本文记录了本人阅读《深度学习入门：基于Python的理论与实现》（斋藤康毅）一书做的一些笔记。

1 感知机

感知机接收多个输入信号，输出一个信号。这里所说的“信号”可以想象成电流或河流那样具备“流动性”的东西。像电流流过导线，向前方输送电子一样，感知机的信号也会形成流，向前方输送信息。但是，和实际的电流不同的是，感知机的信号只有“流/不流 ”（ 1/0）两种取值。在《深度学习入门：基于Python的理论与实现》中，0 对应“不传递信号”，1对应“传递信号”。

而$w_1,w_2$是信号的权重，感知机的工作模式可以用以下公式描述。

$y = \begin{cases} 0, \ w_1x_1+w_2x_2 <= \theta \\ 1, \ otherwise \end{cases}$

此处的$\theta$应理解为一个阈值。

上式也可写作

$y = \begin{cases}0, b + w_1x_1+w_2x_2 <= 0 \\1, \ otherwise\end{cases}$

其中$b$称为偏差, 反应感知机易于激活的程度。

也可以将感知机中的偏差$b$显示地表达出来

将上式进一步简化后可表达为

$y = h(b+w_1x_1+w_2x_2) \\ h(x)= \begin{cases} 0, x \le 0 \\ 1, x > 1 \end{cases}$

2 神经网络

2.1 神经网络层

一个神经网络的例子，本书中将输入层，中间层，输出层依次作为0，1，2层

2.2 激活函数

在感知机部分中我们引入过$h(x)$, 这类函数一般都是将输入信号总和转为一个输出信号。

在感知机中的工作模式如下

$a = b + w_1x_1+w_2x_2 \\ y = h(a)$

在感知机中显示得表达出$h(x)$的工作

2.2.1 sigmod函数

$h(x) = \frac{1}{1+e^{-x}}$

sigmod函数是一种常见的激活函数。

2.2.2 阶跃函数

阶跃函数很简单，就是根据一个阈值将连续输入转为离散化的输出，和第一部分感知机中讲述的$h(x)$ 是一样的，类似于我们在学微积分时候的sign函数。

以下是阶跃函数和sigmod函数的图像对比。

2.2.3 ReLU

ReLU函数是近来使用较多的函数。

$h(x) = \begin{cases} x, x\ge 0 \\ 0, x < 0 \end{cases}$

2.3 神经网络的内积

神经网络的运算基础是通过矩阵的乘法，示意图如下

多层神经网络如下图

3 神经网络的学习

前面介绍了神经网络的工作模式，不难看出，保证神经网络正确工作（完成识别，分类等任务）的关键在于权重和神经元的数量。

神经网络的关键点就在于如何从数据中学习，获得正确的参数。

训练数据和测试数据

机器学习中，一般将数据分为训练数据和测试数据两部分来进行学习和实验等。首先，使用训练数据进行学习，寻找最优的参数；然后，使用测试数据评价训练得到的模型的实际能力。

为什么需要将数据分为训练数据和测试数据呢？因为我们追求的是模型的泛化能力。为了正确评价模型的泛化能力，就必须划分训练数据和测试数据。另外，训练数据也可以称为监督数据。

仅仅用一个数据集去学习和评价参数，是无法进行正确评价的。这样会导致可以顺利地处理某个数据集，但无法处理其他数据集的情况。顺便说一下，只对某个数据集过度拟合的状态称为过拟合（over fitting）。

损失函数

损失函数(loss function)描述的是神经网络性能的恶劣程度,一般使用均方误差和交叉熵。

均方误差

$E = \frac{1}{2}\sum_k(y_k-t_k)^2$

其中,$y_k,t_k$分别表示神经网络的输出，监督数据，神经网络的输出和监督数据的差异的均方体现为均方误差。

交叉熵误差

$E = - \sum _k t_k\log y_k$

采用交叉熵策略的道理是一般监督数据$t_k$往往采用独热码(one hot)，因此在正确标签的位是1，其余为0。

因此交叉熵误差事实上是测试的是在监督数据输出为正确的情况下，神经网络输出的误差。

根据自然对数图像，很自然地，神经网络输出值越接近1（即正确值），交叉熵误差就越小。

mini-batch

使用mini-batch的理由很自然，神经网络的训练数据集往往规模巨大，如果以全部数据为对象计算损失函数是成本巨大的。

因此我们往往从数据集中选出一部分来作为全部数据的近似，称为mini-batch,即小批量。

梯度法

关于函数，导数，偏导数，数值微分，梯度的概念自行查阅微积分资料。

机器学习的主要任务就是在学习时寻找最优参数（权重和偏置）

我们可以将神经网络的损失函数$L$看作是关于权重的多元函数.

$L = f(w_1,w_2,...,w_n)$

一般而言，神经网络参数空间巨大，$L$ 往往无法得到解析的表示，而我们只需要得到$L$的极小值点就可以达到优化的目的，我们认为$L$ 关于参数空间是连续且可微。

那么我们可以利用数值微分的方法得到$L$关于某参数$w_k$ 的数值微分

$\frac{\partial L}{\partial w_k} = \frac{L(w_k+\delta)-L(w_k)}{\delta}$

进而我们得到L的梯度

$grad(L) = (\frac{\partial L}{\partial w_1},\frac{\partial L}{\partial w_2},\frac{\partial L}{\partial w_3},...,\frac{\partial L}{\partial w_n})$

利用梯度下降进行优化的迭代步骤如下:

$W = W-\eta \frac{\partial L}{\partial W}$

其中$\eta$为学习率，即权重向梯度方向迭代的步长。

总结

总结神经网络的学习算法，步骤如下：

mini-batch
计算梯度
更新参数
重复步骤1，2，3到阈值

由于使用的数据是随机的mini-batch数据，因此上述方法又称为随机梯度下降法。

误差反向传播法

计算图

这是一个最简单的计算图，描述的是买苹果的过程中，在苹果数量，单价，消费税三者作用下如何得到最终开销。

使用计算图描述计算过程的好处一是能够进行局部计算，二是能够通过误差反向传播法求导数。

利用误差反向传播求导

上图是一个用误差反向传播求出导数的例子（苹果的单价，总价对最终价格影响的贡献）。

链式法则

利用计算图进行反向传播计算导数的过程是从右向左传递，与我们日常接触的计算恰恰相反。

传递导数的原理在于链式法则。

假设存在$y=f(x)$的计算，反向传播如上图所示。

$E$信号是右侧传来的信号，乘以$f$节点的局部导数$\frac{\partial y}{\partial x}$ 后作为新的导数信号向左侧传递。

事实上可以看出反向传播的过程遵循链式法则。

即$z = f(t),t=f(x)$,那么$\frac{\partial z}{\partial x} = \frac{\partial z}{\partial t} \frac{\partial t}{\partial x} $

链式法则是复合函数求导的性质，具体查阅微积分教材。

使用链式法则表示的计算图过程如上。

加法节点的反向传播

以$z = x+y$为对象，那么$\frac{\partial z}{\partial x} = \frac{\partial z}{\partial y} = 1$

乘法节点的反向传播

以$z = xy$为对象，那么$\frac{\partial z}{\partial x} =y, \frac{\partial z}{\partial y} = x$

实例代码

有反向传播机制的加法层和乘法层。

class AddLayer:
    def __init__(self):
        pass
    def forward(self, x, y):
        out = x + y
        return out
    def backward(self, dout):
        dx = dout * 1
        dy = dout * 1
        return dx, dy

class MulLayer:
    def __init__(self):
        self.x = None
        self.y = None
    def forward(self, x, y):
        self.x = x
        self.y = y
        out = x * y
        return out
    def backward(self, dout):
        dx = dout * self.y # 翻转x和y
        dy = dout * self.x
        return dx, dy

考虑激活层的情形

考虑ReLU

$y=\begin{cases} x, x>0 \\ 0, x\le 0 \end{cases}$

那么，

$\frac{\partial y}{\partial x} = \begin{cases} 1, x>0 \\ 0, x\le 0 \end{cases}$

对于sigmoid,

$y = \frac{1}{1+e^{-x}} \\ \frac{dy}{dx} = - (\frac{1}{1+e^{-x}})^2 \cdot (-e^{-x}) = \frac{e^{-x}}{(1+e^{-x})^2} = y(1-y)$

考虑Affine层的实现

Affine层实际上就是考虑了矩阵运算的清醒，事实上对于矩阵运算的反向传播，有下式

$\frac{\partial L}{\partial X} = \frac{\partial L}{\partial Y} \cdot W^T \\ \frac{\partial L}{\partial W} = X^T \cdot \frac{\partial L}{\partial Y}$

使用误差反向传播法的学习

两层神经网络层的实现

class TwoLayerNet:
    def __init__(self, input_size, hidden_size, output_size,
                 weight_init_std=0.01):
        # 初始化权重
        self.params = {}
        self.params['W1'] = weight_init_std * \
                            np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * \
                            np.random.randn(hidden_size, output_size)
        self.params['b2'] = np.zeros(output_size)
        # 生成层
        self.layers = OrderedDict()
        self.layers['Affine1'] = \
            Affine(self.params['W1'], self.params['b1'])
        self.layers['Relu1'] = Relu()
        self.layers['Affine2'] = \
            Affine(self.params['W2'], self.params['b2'])
        self.lastLayer = SoftmaxWithLoss()
    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        return x
    # x: 输入数据, t:监督数据
    def loss(self, x, t):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        if t.ndim != 1 : t = np.argmax(t, axis=1)
accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
    # x: 输入数据, t:监督数据
    def numerical_gradient(self, x, t):
        loss_W = lambda W: self.loss(x, t)
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        return grads
    def gradient(self, x, t):
        # forward
        self.loss(x, t)
        # backward
        dout = 1
        dout = self.lastLayer.backward(dout)
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)
        #设定 
        grads = {}
        grads['W1'] = self.layers['Affine1'].dW
        grads['b1'] = self.layers['Affine1'].db
        grads['W2'] = self.layers['Affine2'].dW
        grads['b2'] = self.layers['Affine2'].db
        return grads

将前文中利用梯度下降求梯度的方法替换为使用误差反向传播。

import sys, os
 sys.path.append(os.pardir)
 import numpy as np
 from dataset.mnist import load_mnist
 from two_layer_net import TwoLayerNet
 # 读入数据
(x_train, t_train), (x_test, t_test) = \
    load_mnist(normalize=True, one_hot_label=True)
 network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
 iters_num = 10000
 train_size = x_train.shape[0]
 batch_size = 100
 learning_rate = 0.1
 train_loss_list = []
 train_acc_list = []
 test_acc_list = []
 iter_per_epoch = max(train_size / batch_size, 1)
 for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    # 通过误差反向传播法求梯度
	grad = network.gradient(x_batch, t_batch)
    # 更新
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)
    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print(train_acc, test_acc)