3、深度神经网络（DNN）

1 DNN基本结构

​ 深度神经网络是基于上述MLP感知机的扩展，DNN可以理解为有很多隐藏层的神经网络。MLP可以视为DNN的前身，大致可以分为三层：输入层，隐藏层，输出层，MLP通常很浅，隐藏层就一二层。DNN一般隐藏层大于二，而且激活函数的种类更多。

2 DNN训练过程

​ 如图所示，我们在这里将DNN训练划分为4个过程，分别为前向传播(Forward-Propogation, FP), 反向传播(Backward-Propogation, BP ), 权重梯度计算(Weight Gradient, WG), （为了表述方便，后面会将BP和WG统称为反向过程） 和权重更新(Weight Update, WU)。

​ 首先将训练数据分批送入网络中，逐层进行前向计算，直至输出层，然后将当前网络输出与真实标签比较，并利用损失函数(Loss function)计算出损失，常见的损失函数包括均方误差损失 (Mean square error， MSE), 交叉熵损失(Cross Entropy)等；以典型的分类任务，Cross Entropy损失函数为例，前向计算如下:

$$\begin{gathered} {\hat{y}}^{(i)}=f^{[L]}(...f{f}^{[2]}(f{f}^{[1]}(x^{(i)}))),{\hat{y}}^{(i)}\in {\mathbb{R}}^{1\times C} \\ {p}_i=softmax({\hat{y}}^{(i)}) \\ Loss=-\frac{1}{m}\sum _i^m\sum _c^C{y}_{ic}\log (p_{ic}) \end{gathered}$$
其中 $m$ 表示样本数目， $C$ 表示类别数目，即$n_y$。

​ 反向过程则是根据链式法则，逐层计算出损失函数关于各层$W^{[l]},b^{[l]}$的梯度，BP和WG是反向过程的两条计算支路，分别用于计算损失函数对于激活值的梯度（文献中通常称之为error，也就是图中的 ${\sigma }_1$，${\sigma }_2$，${\sigma }_3$ ，和对于权重的梯度$W_{g0},W_{g1},W_{g2}$ ）。他们的计算原理分别如下面的公式:

$$\begin{gathered} {\sigma }_1=\frac{\partial L}{\partial {\alpha }_1}=\frac{\partial L}{\partial {\alpha }_2}\frac{\partial {\alpha }_2}{\partial {\alpha }_1}={\sigma }_2{W}_1^T \\ {W}_{g1}=\frac{\partial L}{\partial W_1}=\frac{\partial L}{\partial {\alpha }_2}\frac{\partial {\alpha }_2}{\partial W_1}={\sigma }_2{\alpha }_1 \end{gathered}$$
在pytorch中，反向过程是通过 $loss.backward()$内部直接完成

最后，根据反向过程中得到的权重梯度，来对权重进行更新。基本的随机梯度下降算法(SGD)：$W_1\prime$=$W_1-\eta W_{g1}$

补充说明：（此处 $W$ 应为$W^T$，为方便省去了转置符号）

1）DNN前向传播算法：针对一个样本描述

利用和感知机一样的思路，我们可以利用上一层的输出计算下一层的输出

对于第二层的输出$a_1^{[2]},a_2^{[2]},a_3^{[2]}$，我们有：
$$\begin{gathered} a_1^{[2]}=\sigma (z_1^{[2]})=\sigma (w_{11}^{[2]}{x}_1+w_{12}^{[2]}{x}_2+w_{13}^{[2]}{x}_3+b_1^{[2]}) \\ {a}_2^{[2]}=\sigma (z_2^{[2]})=\sigma (w_{21}^{[2]}{x}_1+w_{22}^{[2]}{x}_2+w_{23}^{[2]}{x}_3+b_2^{[2]}) \\ {a}_3^{[2]}=\sigma (z_3^{[2]})=\sigma (w_{31}^{[2]}{x}_1+w_{32}^{[2]}{x}_2+w_{33}^{[2]}{x}_3+b_3^{[2]}) \end{gathered}$$
对于第三层的输出$a_1^{[3]}$,我们有：
$$a_1^{[3]}=\sigma (z_1^{[3]})=\sigma (w_{11}^{[3]}{a}_1^{[2]}+w_{12}^{[3]}{a}_2^{[2]}+w_{13}^{[3]}{a}_3^{[2]}+b_1^{[3]})$$
将上面的例子一般化，假设第$l-1$层共有$n_h^{[l-1]}$个神经元，则对于第$l$层的第$j$个神经元的输出$a_j^{[l]}$，我们有：
$$a_j^{[l]}=\sigma (z_j^{[l]})=\sigma (\sum _{k=1}^{n_h^{[l-1]}}{w}_{jk}^{[l]}{a}_k^{[l-1]}+b_j^{[l]})$$
其中，如果$l=2$，则对于$a_k^{[l]}$，即为输入层的$x_k$

2）DNN反向传播算法：损失以$m$个样本的平均损失计算，反向梯度公式按单个样本进行推导

​ 假设我们有$m$个训练样本 $(x^{(1)},y^{(1)}),(x^{(2)},y^{(2)}),...,(x^{(m)},y^{(m)})$ ，其中$x^{(i)}$为输入向量，特征维度为$n_{in}$，而$y^{(i)}$为输出向量，特征维度为$n_{out}$。我们需要利用这$m$个样本训练出一个模型，当有一个新的测试样本 $(x_{test},?)$ 时，可以预测 $y_{test}$ 向量的输出。

​ 如果我们采用DNN的模型，即我们使输入层$n_x$个神经元，而输出层有$n_y$个神经元。再加上一些含有若干神经元的隐藏层。此时需要找到合适的所有隐藏层和输出层对应的线性系数矩阵 $W$ ，偏倚向量 $b$ ，让所有的训练样本输入计算出的输出尽可能的等于或很接近样本输出。怎么找到合适的参数呢？

​ 可以用一个合适的损失函数来度量训练样本的输出损失，接着对这个损失函数进行优化求最小化的极值，对应的一系列线性系数矩阵$W$，偏倚向量$b$即为我们的最终结果。在DNN中，损失函数优化极值求解的过程最常见的一般是通过梯度下降法来一步步迭代完成的，也可以是其他的迭代方法比如牛顿法与拟牛顿法。

​ 在进行DNN反向传播算法前，我们需要选择一个损失函数，来度量训练样本计算出的输出和真实的训练样本输出之间的损失。DNN可选择的损失函数有不少，为了专注算法，这里使用最常见的均方差来度量损失。即对于每个样本，我们期望最小化下式：
$$J(W,b,x,y)=\frac{1}{2}||a^{[L]}-y|{|}_2^2$$
其中，$a^{[L]}$和$y$为特征维度为$n_{out}$的向量，而$||S|{|}_2$为$S$的$L2$范数

最终损失为所有样本损失的平均值，损失函数有了，用梯度下降法迭代求解每一层的$W^{[l]},b^{[l]}$。

（1）首先求输出层第 $L$ 层的$W^{[L]},b^{[L]}$的梯度：

将第$L$层式子$a^{[L]}=\sigma (z^{[L]})=\sigma (W^{[L]}{a}^{[L-1]}+b^{[L]})$代入到损失函数中，损失函数变为：
$$J(W,b,x,y)=\frac{1}{2}||a^{[L]}-y|{|}_2^2=\frac{1}{2}||\sigma (z^{[L]})-y|{|}_2^2=\frac{1}{2}||\sigma (W^{[L]}{a}^{[L-1]}+b^{[L]})-y|{|}_2^2$$
求解$W^{[L]},b^{[L]}$的梯度有：
$$\begin{gathered} \frac{\partial J(W,b,x,y)}{\partial W^{[L]}}=\frac{\partial J(W,b,x,y)}{\partial z^{[L]}}\frac{\partial z^{[L]}}{\partial W^{[L]}} \\ \frac{\partial J(W,b,x,y)}{\partial b^{[L]}}=\frac{\partial J(W,b,x,y)}{\partial z^{[L]}}\frac{\partial z^{[L]}}{\partial b^{[L]}} \end{gathered}$$
其中，记${\sigma }^{[L]}=\frac{\partial J(W,b,x,y)}{\partial z^{[L]}}$，由$J(W,b,x,y)=\frac{1}{2}||\sigma (z^{[L]})-y|{|}_2^2$，$z^{[L]}=W^{[L]}{a}^{[L-1]}+b^{[L]}$分别得
$$\begin{gathered} {\sigma }^{[L]}=\frac{\partial J(W,b,x,y)}{\partial z^{[L]}}=(a^{[L]}-y)\odot {\sigma }^{\prime }(z^{[L]}) \\ \frac{\partial z^{[L]}}{\partial W^{[L]}}=(a^{[L-1]}{)}^T \\ \frac{\partial z^{[L]}}{\partial b^{[L]}}=1 \end{gathered}$$
式中$\odot$表示Hadamard积，对于两个维度相同的向量$A=(a_1,a_2,...,a_n{)}^T$和$B=(b_1,b_2,...,b_n{)}^T$，有$A\odot B=(a_1{b}_1,a_2{b}_2,...,a_n{b}_n{)}^T$。因此，将上式代入到$W^{[L]},b^{[L]}$的梯度求解式子中可得：
$$\begin{gathered} \frac{\partial J(W,b,x,y)}{\partial W^{[L]}}=\frac{\partial J(W,b,x,y)}{\partial z^{[L]}}\frac{\partial z^{[L]}}{\partial W^{[L]}}=(a^{[L]}-y)(a^{[L-1]}{)}^T\odot {\sigma }^{\prime }(z^{[L]}) \\ \frac{\partial J(W,b,x,y)}{\partial b^{[L]}}=\frac{\partial J(W,b,x,y)}{\partial z^{[L]}}\frac{\partial z^{[L]}}{\partial b^{[L]}}=(a^{[L]}-y)\odot {\sigma }^{\prime }(z^{[L]}) \end{gathered}$$
（2）求第 $l$ 层的$W^{[l]},b^{[l]}$的梯度：

计算完输出层$W^{[L]},b^{[L]}$的梯度后，可以依次计算每一层$W^{[l]},b^{[l]}$的梯度。第$l$层的未激活输出$z^{[l]}$的梯度为：
$${\sigma }^{[l]}=\frac{\partial J(W,b,x,y)}{\partial z^{[l]}}$$
根据前向传播算法，$z^{[l]}=W^{[l]}{a}^{[l-1]}+b^{[l]}$，计算第$l$层$W^{[l]},b^{[l]}$的梯度如下：
$$\begin{gathered} \frac{\partial J(W,b,x,y)}{\partial W^{[l]}}=\frac{\partial J(W,b,x,y)}{\partial z^{[l]}}\frac{\partial z^{[l]}}{\partial W^{[l]}}={\sigma }^{[l]}(a^{[l-1]}{)}^T \\ \frac{\partial J(W,b,x,y)}{\partial b^{[l]}}=\frac{\partial J(W,b,x,y)}{\partial z^{[l]}}\frac{\partial z^{[l]}}{\partial b^{[l]}}={\sigma }^{[l]} \end{gathered}$$
对于第$l$层的未激活输出$z^{[l]}$的梯度${\sigma }^{[l]}$，它还可以表示为：
$${\sigma }^{[l]}=\frac{\partial J(W,b,x,y)}{\partial z^{[l]}}=\frac{\partial J(W,b,x,y)}{\partial z^{[L]}}\frac{\partial z^{[L]}}{\partial z^{[L-1]}}\frac{\partial z^{[L-1]}}{\partial z^{[L-2]}}...\frac{\partial z^{[l+1]}}{\partial z^{[l]}}=\frac{\partial J(W,b,x,y)}{\partial z^{[l+1]}}\frac{\partial z^{[l+1]}}{\partial z^{[l]}}={\sigma }^{[l+1]}\frac{\partial z^{[l+1]}}{\partial z^{[l]}}$$
对于$\frac{\partial z^{[l+1]}}{\partial z^{[l]}}$，由$z^{[l+1]}$与$z^{[l+1]}$的关系：$z^{[l+1]}=W^{[l+1]}{a}^{[l]}+b^{[l+1]}=W^{[l+1]}\sigma (z^{[l]})+b^{[l+1]}$，得到：
$$\frac{\partial z^{[l+1]}}{\partial z^{[l]}}=(W^{[l+1]}{)}^T\odot {\sigma }^{\prime }(z^{[l]})$$
代入上面${\sigma }^{[l]}$和${\sigma }^{[l+1]}$的关系式中得到：
$${\sigma }^{[l]}={\sigma }^{[l+1]}\frac{\partial z^{[l+1]}}{\partial z^{[l]}}=(W^{[l+1]}{)}^T{\sigma }^{[l+1]}\odot {\sigma }^{\prime }(z^{[l]})$$
得到${\sigma }^{[l]}$递推关系式后，通过第$L$层的未激活输出$z^{[L]}$的梯度 ${\sigma }^{[L]}=(a^{[L]}-y)\odot {\sigma }^{\prime }(z^{[L]})$，依次求出每一层的${\sigma }^{[l]}$，代入$W^{[l]},b^{[l]}$的梯度求解式子中即可。

3 DNN优缺点

①DNN优点

​ 由于DNN几乎可以拟合任何函数，所以DNN的非线性拟合能力非常强。

②DNN缺点

• 参数数量膨胀。由于DNN采用的是全连接的形式，结构中的连接带来了数量级的权值参数，这不仅容易导致过拟合，也容易造成陷入局部最优。

• 局部最优。随着神经网络的加深，优化函数更容易陷入局部最优，且偏离真正的全局最优，对于有限的训练数据，性能甚至不如浅层网络。

• 梯度消失。使用$sigmoid$激活函数（传递函数），在BP反向传播梯度时，梯度会衰减，随着神经网络层数的增加，衰减累积下，到底层时梯度基本为0。

• 无法对时间序列上的变化进行建模。对于样本的时间顺序对于自然语言处理、语音识别、手写体识别等应用非常重要。

4 DNN代码实现（手写数字识别）

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets,transforms
from torch.autograd import Variable

#training setting
batch_size = 16
# MNIST Dataset
train_dataset = datasets.MNIST(root='./mnist_data/',
                               train = True ,
                               transform = transforms.ToTensor(),
                               download=True)

test_dataset = datasets.MNIST(root='./mnist_data/',
                              train=False,
                              transform=transforms.ToTensor())

# Data Loader (Input Pipeline)

train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                           batch_size=batch_size,
                                           shuffle=False)

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.l1 = nn.Linear(784,520)
        self.l2 = nn.Linear(520, 320)
        self.l3 = nn.Linear(320, 240)
        self.l4 = nn.Linear(240, 120)
        self.l5 = nn.Linear(120, 10)

    def forward(self, x):
        x = x.view(-1,784) # Flattern the (n,1,28,28) to (n,784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))

        return self.l5(x)
model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr= 0.01 , momentum= 0.5)

def train(epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        print(len(train_loader))
        data,target = Variable(data), Variable(target)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output,target)
        loss.backward()
        optimizer.step()
        if batch_idx % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))


def test():
    model.eval()
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data, target = Variable(data,volatile=True),Variable(target)
        output = model(data)
        # sum up batch loss
        test_loss += criterion(output, target).data.item()
        # get the index of the max
        pred = output.data.max(1, keepdim=True)[1]
        correct += pred.eq(target.data.view_as(pred)).cpu().sum()
    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

for epoch in range(1, 10):
    train(epoch)
    test()