目    录

第四章 ——— 多层感知机

1 多层感知机

1.1 线性模型

1.2 隐藏层

1.3 从线性到非线性

1.4 激活函数

1.4.1 ReLU函数

1.4.2 sigmoid函数

1.4.3  tanh函数

1.5小结

2 多层感知机的实现

2.1 初始化模型参数

2.2 代码

2.3 小结

3 模式与泛化

3.1 理论介绍

3.1.1 训练误差和泛化误差

3.1.2 统计学习理论

3.1.3 K折交叉验证

3.2 模型

3.2.1  模型复杂性

3.2.2 模型选择

3.2.3 验证集

3.3 拟合

3.3.1 数据集大小

3.4 多项式回归深刻理解

3.4.1 正常训练 - 三阶多项式函数拟合

3.4.2 非正常 - 线性函数拟合(欠拟合)

3.4.3 高阶多项式函数拟合(过拟合)

4 结语

---

第四章 ——— 多层感知机

章节导航：我们在本章将第一次学习真正的深度网络。 从最简单的深度网络开始学起，也就是多层感知机。之前的线性层将不足以满足我么的使用，因此会引入隐藏层的概念、再由线性到非线性。介绍了需要引入的几种激活函数。然后对于模型的再次选择、过拟合、欠拟合进行探讨。为了解决这些问题，后面还会引入权重衰减和暂退法等正则化技术。

1 多层感知机

1.1 线性模型

        先回顾一下，什么叫做线性模型。线性意味着单调假设，一条直线，输出与单个输入一一对应，任何特征的增大都会导致模型输出的增大或减小。但是有些情况下，线性模型不能满足我们的需求。例如人的体温正常范围在35.6~37摄氏度左右（假设），那么简单的线性模型无法预测人在什么体温下健康安全。

1.2 隐藏层

        现在可以选择尝试在只有输入层和输出层的网络中在加入一个或多个隐藏层来克服线性模型的限制， 使其能处理更普遍的函数关系类型。因此，最简单的方法就是我们在其之中再加一个全连接层，每一层的输出都作为下一层的输入，这种架构通常称为多层感知机，通常缩写为MLP（multilayer perceptron）。如下图，简单的可以理解为中间的层叫做隐藏层。

1.3 从线性到非线性

        同之前的学习一样，我们需要选取n个样本的小批量， 其中每个样本具有d个输入特征。 对于具有h个隐藏单元的单隐藏层多层感知机， 用H表示隐藏层的输出， 称为隐藏表示。因为隐藏层和输出层都是全连接的， 所以我们还需要多设置一个隐藏层权重W1和隐藏层偏置b1 以及输出层权重W2和输出层偏置b2。因此，有：

        但是像这样简单的设置隐藏层，除了多增加一层之外，并没有丝毫的益处。例如我们有z = z(y), y = y(x), 我们可以将y(x) 替换y，得到z = z(x), 还是线性函数，即：

        所以，为了发挥多层架构的潜力， 还需要引入一个额外的关键要素： 在仿射变换之后对每个隐藏单元应用非线性的激活函数σ。 激活函数的输出被称为活性值。 一般来说，有了激活函数，就不可能再将我们的多层感知机退化成线性模型：

        为了构建更通用的多层感知机， 我们可以继续堆叠这样的隐藏层， 一层叠一层，从而产生更有表达能力的模型。多层感知机可以通过隐藏神经元捕捉到输入之间复杂的相互作用， 这些神经元依赖于每个输入的值。即使是网络只有一个隐藏层，给定足够的神经元和正确的权重， 我们可以对任意函数建模，尽管实际中学习该函数是很困难的。

        虽然一个单隐层网络能学习任何函数， 但并不意味着我们应该尝试使用单隐藏层网络来解决所有问题。 事实上，通过使用更深（而不是更广）的网络，我们可以更容易地逼近许多函数。 

1.4 激活函数

        激活函数通过计算加权和并加上偏置来确定神经元是否应该被激活， 它们将输入信号转换为输出的可微运算。 大多数激活函数都是非线性的。 

1.4.1 ReLU函数

        最受欢迎的激活函数是修正线性单元， 因为它实现简单，同时在各种预测任务中表现良好。 ReLU提供了一种非常简单的非线性变换。 给定元素x，ReLU函数被定义为该元素与0的最大值：

        通俗地说，ReLU函数通过将相应的活性值设为0，仅保留正元素并丢弃所有负元素。 简单理解，该函数就是一个分段函数，图像如图所示：

生成代码：

%matplotlib inline
import torch
from d2l import torch as d2l

x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)
y = torch.relu(x)
d2l.plot(x.detach(), y.detach(), 'x', 'relu(x)', figsize=(5, 2.5))

当输入为负时，ReLU函数的导数为0

当输入为正时，ReLU函数的导数为1

输入值精确等于0时，ReLU函数不可导

那在输入等于0时，怎么算呢。书本上的解释：默认使用左侧的导数，即当输入为0时导数为0。

但是我们可以忽略这种情况，因为输入可能永远都不会是0。 

ReLU导数图像如下：

生成代码： 

y.backward(torch.ones_like(x), retain_graph=True)
d2l.plot(x.detach(), x.grad, 'x', 'grad of relu', figsize=(5, 2.5))

优点：

求导表现得好，要么让参数消失，要么让参数通过。

并且ReLU减轻了困扰以往神经网络的梯度消失问题

1.4.2 sigmoid函数

        对于一个定义域在R中的输入， sigmoid函数将输入变换为区间(0, 1)上的输出。 因此，sigmoid通常称为挤压函数：将范围（-inf, inf）中的任意输入压缩到区间（0, 1）中的某个值。

        为什么会想到这样的一个函数呢？因为当人们逐渐关注到到基于梯度的学习时， sigmoid函数是一个自然的选择，因为它是一个平滑的、可微的阈值单元近似。 当我们想要将输出视作二元分类问题的概率时， sigmoid仍然被广泛用作输出单元上的激活函数。 然而，sigmoid在隐藏层中已经较少使用， 它在大部分时候被更简单、更容易训练的ReLU所取代。 

绘制sigmoid函数图像如下。 当输入接近0时，sigmoid函数接近线性变换。

生成代码： 

y = torch.sigmoid(x)
d2l.plot(x.detach(), y.detach(), 'x', 'sigmoid(x)', figsize=(5, 2.5))

sigmoid函数导数：

sigmoid函数的导数图像如下所示。

当输入为0时，sigmoid函数的导数达到最大值0.25

 而输入在任一方向上越远离0点时，导数越接近0。

 生成代码：

# 清除以前的梯度
x.grad.data.zero_()
y.backward(torch.ones_like(x),retain_graph=True)
d2l.plot(x.detach(), x.grad, 'x', 'grad of sigmoid', figsize=(5, 2.5))

1.4.3  tanh函数

        与sigmoid函数类似， tanh(双曲正切)函数也能将其输入压缩转换到区间(-1, 1)上。tanh函数的公式如下：

绘制tanh函数如下：

• 当输入在0附近时，tanh函数接近线性变换
• 函数的形状类似于sigmoid函数， 不同的是tanh函数关于坐标系原点中心对称。

生成代码：

y = torch.tanh(x)
d2l.plot(x.detach(), y.detach(), 'x', 'tanh(x)', figsize=(5, 2.5))

tanh函数的导数是：

tanh函数的导数图像如图所示

• 当输入接近0时，tanh函数的导数接近最大值1
• 与sigmoid函数图像类似， 输入在任一方向上越远离0点，导数越接近0

生成代码： 

# 清除以前的梯度
x.grad.data.zero_()
y.backward(torch.ones_like(x),retain_graph=True)
d2l.plot(x.detach(), x.grad, 'x', 'grad of tanh', figsize=(5, 2.5))

1.5小结

        多层感知机在输出层和输入层之间增加一个或多个全连接隐藏层，并通过激活函数转换隐藏层的输出。

常用的激活函数包括ReLU函数、sigmoid函数和tanh函数。

运算

计算pReLU激活函数的导数。

证明tanh(x)+1=2sigmoid(2x)

2 多层感知机的实现

2.1 初始化模型参数

        我们可以将每个图像视为具有784个输入特征 和10个类的简单分类数据集。 首先，我们将实现一个具有单隐藏层的多层感知机， 它包含256个隐藏单元。 注意，我们可以将这两个变量都视为超参数。 我们选择2的若干次幂作为层的宽度。 因为内存在硬件中的分配和寻址方式，这么做往往可以在计算上更高效。为了确保我们对模型的细节了如指掌， 我们将实现ReLU激活函数， 而不是直接调用内置的relu函数。多层感知机的训练过程与softmax回归的训练过程完全相同。 

2.2 代码

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# 初始化模型参数
num_inputs, num_outputs, num_hiddens = 784, 10, 256

W1 = nn.Parameter(torch.randn(
    num_inputs, num_hiddens, requires_grad=True) * 0.01)
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))
W2 = nn.Parameter(torch.randn(
    num_hiddens, num_outputs, requires_grad=True) * 0.01)
b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))

params = [W1, b1, W2, b2]

# 激活函数
def relu(X):
    a = torch.zeros_like(X)
    return torch.max(X, a)

# 模型
def net(X):
    X = X.reshape((-1, num_inputs))
    H = relu(X@W1 + b1)  # 这里“@”代表矩阵乘法
    return (H@W2 + b2)

# 损失函数
loss = nn.CrossEntropyLoss(reduction='none')

# 训练
num_epochs, lr = 10, 0.1
updater = torch.optim.SGD(params, lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

d2l.predict_ch3(net, test_iter)

2.3 小结

可以使用高级API更简洁地实现多层感知机。

对于相同的分类问题，多层感知机的实现与softmax回归的实现相同，只是多层感知机的实现里增加了带有激活函数的隐藏层。

3 模式与泛化

        机器学习的目标是发现模式。 但是，如何才能确定模型是真正发现了一种泛化的模式， 而不是简单地记住了数据？ 正式地说，我们的目标是发现某些模式， 这些模式捕捉到了我们训练集潜在总体的规律。然后对以前从未遇到过的个体， 模型也可以成功地评估风险。 如何发现可以泛化的模式是机器学习的根本问题。

        简单理解就是我们需要寻找一个合适的模型，可以用于我们再从未见过的数据或者现实中实现正确或者极大程度上可以成功地评估风险，即泛化。

        将模型在训练数据上拟合的比在潜在分布中更接近的现象称为过拟合， 用于对抗过拟合的技术称为正则化。在实验中调整模型架构或超参数时会发现： 如果有足够多的神经元、层数和训练迭代周期， 模型最终可以在训练集上达到完美的精度，此时测试集的准确性却下降了。

3.1 理论介绍

3.1.1 训练误差和泛化误差

训练误差：模型在训练数据集上计算得到的误差

泛化误差：模型应用在同样从原始样本的分布中抽取的无限多数据样本时，模型误差的期望。

        问题是，我们永远不能准确地计算出泛化误差。 因为无限多的数据样本是一个虚构的对象。 在实际中，我们只能通过将模型应用于一个独立的测试集来估计泛化误差， 该测试集由随机选取的、未曾在训练集中出现的数据样本构成。

        类似地，考虑一个简单地使用查表法来回答问题的模型。 如果允许的输入集合是离散的并且相当小， 那么也许在查看许多训练样本后，该方法将执行得很好。 但当这个模型面对从未见过的例子时，它表现的可能比随机猜测好不到哪去。 这是因为输入空间太大了，远远不可能记住每一个可能的输入所对应的答案。

3.1.2 统计学习理论

        由于泛化是机器学习中的基本问题，在同名定理中， 格里文科和坎特利推导出了训练误差收敛到泛化误差的速率。 我们假设训练数据和测试数据都是从相同的分布中独立提取的。 这通常被称为独立同分布假设， 这意味着对数据进行采样的过程没有进行“记忆”。 换句话说，抽取的第2个样本和第3个样本的相关性， 并不比抽取的第2个样本和第200万个样本的相关性更强。

        假设是存在漏洞的，即很容易找出假设失效的情况。 有时候我们即使轻微违背独立同分布假设，模型仍将继续运行得非常好。 比如，我们有许多有用的工具已经应用于现实，如人脸识别、语音识别和语言翻译。 毕竟，几乎所有现实的应用都至少涉及到一些违背独立同分布假设的情况。

        有些违背独立同分布假设的行为肯定会带来麻烦。 比如，我们试图只用来自大学生的人脸数据来训练一个人脸识别系统， 然后想要用它来监测疗养院中的老人。 这不太可能有效，因为大学生看起来往往与老年人有很大的不同。

3.1.3 K折交叉验证

        当训练数据稀缺时，我们甚至可能无法提供足够的数据来构成一个合适的验证集。 这个问题的一个流行的解决方案是采用K折交叉验证。 这里，原始训练数据被分成K个不重叠的子集。 然后执行K次模型训练和验证，每次在K−1个子集上进行训练， 并在剩余的一个子集（在该轮中没有用于训练的子集）上进行验证。 最后，通过对K次实验的结果取平均来估计训练和验证误差。

3.2 模型

3.2.1  模型复杂性

        当我们有简单的模型和大量的数据时，我们期望泛化误差与训练误差相近。 当我们有更复杂的模型和更少的样本时，我们预计训练误差会下降，但泛化误差会增大。 模型复杂性由什么构成是一个复杂的问题。 一个模型是否能很好地泛化取决于很多因素。

• 具有更多参数的模型可能被认为更复杂
• 参数有更大取值范围的模型可能更为复杂

        通常对于神经网络，我们认为需要更多训练迭代的模型比较复杂， 而需要早停的模型就不那么复杂。我们很难比较本质上不同大类的模型之间的复杂性。

        如果一个理论能拟合数据，且有具体的测试可以用来证明它是错误的，那么它就是好的。 这一点很重要，因为所有的统计估计都是事后归纳。 也就是说，我们在观察事实之后进行估计，因此容易受到相关谬误的影响。

几个倾向于影响模型泛化的因素：

• 可调整参数的数量
• 参数采用的值
• 训练样本的数量

3.2.2 模型选择

        在机器学习中，我们通常在评估几个候选模型后选择最终的模型。 这个过程叫做模型选择。 有时，需要进行比较的模型在本质上是完全不同的。 又有时，我们需要比较不同的超参数设置下的同一类模型。

        例如，训练多层感知机模型时，我们可能希望比较具有 不同数量的隐藏层、不同数量的隐藏单元以及不同的激活函数组合的模型。 为了确定候选模型中的最佳模型，我们通常会使用验证集。

3.2.3 验证集

个人理解：感觉可以理解为测试集的测试集。

        原则上，在我们确定所有的超参数之前，我们不希望用到测试集。 如果我们在模型选择过程中使用测试数据，可能会有过拟合测试数据的风险，那就麻烦大了。 如果我们过拟合了训练数据，还可以在测试数据上的评估来判断过拟合。 但是如果我们过拟合了测试数据，我们又该怎么知道呢？因此，我们决不能依靠测试数据进行模型选择。 然而，我们也不能仅仅依靠训练数据来选择模型，因为我们无法估计训练数据的泛化误差。

        虽然理想情况下我们只会使用测试数据一次， 以评估最好的模型或比较一些模型效果，但现实是测试数据很少在使用一次后被丢弃。 我们很少能有充足的数据来对每一轮实验采用全新测试集。

        解决此问题的常见做法是将我们的数据分成三份：训练和测试数据集，增加一个验证数据集， 也叫验证集。

3.3 拟合

当我们比较训练和验证误差时，我们要注意两种常见的情况。

        训练误差和验证误差都很严重， 但它们之间仅有一点差距。 如果模型不能降低训练误差，这可能意味着模型过于简单（即表达能力不足）， 无法捕获试图学习的模式。 此外，由于我们的训练和验证误差之间的泛化误差很小， 我们有理由相信可以用一个更复杂的模型降低训练误差。 这种现象被称为欠拟合。

        当我们的训练误差明显低于验证误差时要小心， 这表明严重的过拟合。过拟合并不总是一件坏事。 特别是在深度学习领域，众所周知， 最好的预测模型在训练数据上的表现往往比在保留（验证）数据上好得多。 最终，我们通常更关心验证误差，而不是训练误差和验证误差之间的差距。

3.3.1 数据集大小

        另一个重要因素是数据集的大小。 训练数据集中的样本越少，我们就越有可能过拟合。 随着训练数据量的增加，泛化误差通常会减小。 此外，一般来说，更多的数据不会有什么坏处。 对于固定的任务和数据分布，模型复杂性和数据集大小之间通常存在关系。 给出更多的数据，我们可能会尝试拟合一个更复杂的模型。 能够拟合更复杂的模型可能是有益的。 如果没有足够的数据，简单的模型可能更有用。 对于许多任务，深度学习只有在有数千个训练样本时才优于线性模型。 从一定程度上来说，深度学习目前的生机要归功于 廉价存储、互联设备以及数字化经济带来的海量数据集。

3.4 多项式回归深刻理解

给定x，我们将使用以下三阶多项式来生成训练和测试数据的标签：

噪声项ϵ服从均值为0且标准差为0.1的正态分布。 

        同样，存储在poly_features中的单项式由gamma函数重新缩放， 其中Γ(n)=(n−1)！。从生成的数据集中查看一下前2个样本， 第一个值是与偏置相对应的常量特征。然后对模型进行训练和测试。

代码如下：

import math
import numpy as np
import torch
from torch import nn
from d2l import torch as d2l

max_degree = 20  # 多项式的最大阶数
n_train, n_test = 100, 100  # 训练和测试数据集大小
true_w = np.zeros(max_degree)  # 分配大量的空间
true_w[0:4] = np.array([5, 1.2, -3.4, 5.6])

features = np.random.normal(size=(n_train + n_test, 1))
np.random.shuffle(features)
poly_features = np.power(features, np.arange(max_degree).reshape(1, -1))
for i in range(max_degree):
    poly_features[:, i] /= math.gamma(i + 1)  # gamma(n)=(n-1)!
# labels的维度:(n_train+n_test,)
labels = np.dot(poly_features, true_w)
labels += np.random.normal(scale=0.1, size=labels.shape)

# NumPy ndarray转换为tensor
true_w, features, poly_features, labels = [torch.tensor(x, dtype=
    torch.float32) for x in [true_w, features, poly_features, labels]]

features[:2], poly_features[:2, :], labels[:2]

def evaluate_loss(net, data_iter, loss):  #@save
    """评估给定数据集上模型的损失"""
    metric = d2l.Accumulator(2)  # 损失的总和,样本数量
    for X, y in data_iter:
        out = net(X)
        y = y.reshape(out.shape)
        l = loss(out, y)
        metric.add(l.sum(), l.numel())
    return metric[0] / metric[1]

def train(train_features, test_features, train_labels, test_labels,
          num_epochs=400):
    loss = nn.MSELoss(reduction='none')
    input_shape = train_features.shape[-1]
    # 不设置偏置，因为我们已经在多项式中实现了它
    net = nn.Sequential(nn.Linear(input_shape, 1, bias=False))
    batch_size = min(10, train_labels.shape[0])
    train_iter = d2l.load_array((train_features, train_labels.reshape(-1,1)),
                                batch_size)
    test_iter = d2l.load_array((test_features, test_labels.reshape(-1,1)),
                               batch_size, is_train=False)
    trainer = torch.optim.SGD(net.parameters(), lr=0.01)
    animator = d2l.Animator(xlabel='epoch', ylabel='loss', yscale='log',
                            xlim=[1, num_epochs], ylim=[1e-3, 1e2],
                            legend=['train', 'test'])
    for epoch in range(num_epochs):
        d2l.train_epoch_ch3(net, train_iter, loss, trainer)
        if epoch == 0 or (epoch + 1) % 20 == 0:
            animator.add(epoch + 1, (evaluate_loss(net, train_iter, loss),
                                     evaluate_loss(net, test_iter, loss)))
    print('weight:', net[0].weight.data.numpy())

3.4.1 正常训练 - 三阶多项式函数拟合

• 使用三阶多项式函数，它与数据生成函数的阶数相同 
• 结果表明，该模型能有效降低训练损失和测试损失。

代码如下：

# 从多项式特征中选择前4个维度，即1,x,x^2/2!,x^3/3!
train(poly_features[:n_train, :4], poly_features[n_train:, :4],
      labels[:n_train], labels[n_train:])

3.4.2 非正常 - 线性函数拟合(欠拟合)

再看看线性函数拟合

• 减少该模型的训练损失相对困难
• 在最后一个迭代周期完成后，训练损失仍然很高
• 当用来拟合非线性模式时，线性模型容易欠拟合

因此，可以知道很荒谬，表达能力不够

# 从多项式特征中选择前2个维度，即1和x
train(poly_features[:n_train, :2], poly_features[n_train:, :2],
      labels[:n_train], labels[n_train:])

3.4.3 高阶多项式函数拟合(过拟合)

尝试使用一个阶数过高的多项式来训练模型 

        在这种情况下，没有足够的数据用于学到高阶系数应该具有接近于零的值。 因此，这个过于复杂的模型会轻易受到训练数据中噪声的影响。 虽然训练损失可以有效地降低，但测试损失仍然很高。 结果表明，复杂模型对数据造成了过拟合。

# 从多项式特征中选取所有维度
train(poly_features[:n_train, :], poly_features[n_train:, :],
      labels[:n_train], labels[n_train:], num_epochs=1500)

4 结语

本章链接：4. 多层感知机 — 动手学深度学习 2.0.0 documentation

学习链接：【视频+教材】原著大佬李沐带你读《动手学习深度学习》真的通俗易懂！深度学习入门必看！（人工智能、机器学习、神经网络、计算机视觉、图像处理、AI）_哔哩哔哩_bilibili

如果你有任何建议或疑问，欢迎留言讨论，最近每天基本上都会看留言，看到会及时回复。