《动手学深度学习》——线性神经网络

参考资料：

• 《动手学深度学习》

3.1 线性回归

3.1.1 线性回归的基本元素

样本： n n n 表示样本数， x ( i ) = [ x 1 ( i ) , x 2 ( i ) , ⋯   , x d ( i ) ] x^{(i)}=[x^{(i)}_1,x^{(i)}_2,\cdots,x^{(i)}_d] x(i)=[x1(i),x2(i),⋯,xd(i)] 表示第 i i i 个样本。

预测： y ^ = w T x + b \hat{y}=w^Tx+b y^=wTx+b 表示单个样本的预测值， y ^ = X w + b \hat{y}=Xw+b y^=Xw+b 表示所有样本的预测值。

损失函数：
L ( w , b ) = ∑ i = 1 n 1 2 ( y ^ ( i ) − y ( i ) ) L(w,b)=\sum\limits_{i=1}^{n}\frac12\Big(\hat{y}^{(i)}-y^{(i)}\Big) L(w,b)=i=1∑n21(y^(i)−y(i))

随机梯度下降：在每次迭代中，我们首先随机抽样一个小批量 B \mathcal{B} B ， 它是由固定数量的训练样本组成的。然后按照如下方式更新参数：
( w , b ) ← ( w , b ) − η ∣ B ∣ ∑ i ∈ B ∂ ( w , b ) l ( i ) ( w , b ) (\mathbf{w},b) \leftarrow (\mathbf{w},b) - \frac{\eta}{|\mathcal{B}|} \sum\limits_{i \in \mathcal{B}} \partial_{(\mathbf{w},b)} l^{(i)}(\mathbf{w},b) (w,b)←(w,b)−∣B∣ηi∈B∑∂(w,b)l(i)(w,b)

其中， η \eta η 为学习率，是一个超参数。

3.1.2 矢量化加速

尽可能使用效率较高的线性代数库。

3.1.3 正态分布与平方损失

假设观测存在噪声 ϵ \epsilon ϵ ：
y = w ⊤ x + b + ϵ , y = \mathbf{w}^\top \mathbf{x} + b + \epsilon, y=w⊤x+b+ϵ,

且 ϵ ∼ N ( 0 , σ 2 ) \epsilon \sim N(0, \sigma^2) ϵ∼N(0,σ2)。

此时有条件概率为：
P ( y ∣ x ) = 1 2 π σ 2 exp ⁡ ( − 1 2 σ 2 ( y − w ⊤ x − b ) 2 ) P(y \mid \mathbf{x}) = \frac{1}{\sqrt{2 \pi \sigma^2}} \exp\left(-\frac{1}{2 \sigma^2} (y - \mathbf{w}^\top \mathbf{x} - b)^2\right) P(y∣x)=2πσ2 1exp(−2σ21(y−w⊤x−b)2)

于是似然函数为：
L ( w , b ) = ∏ i = 1 n p ( y ( i ) ∣ x ( i ) ) L(w,b) = \prod\limits_{i=1}^{n} p(y^{(i)}|\mathbf{x}^{(i)}) L(w,b)=i=1∏np(y(i)∣x(i))

取对数再加负号，得：
− l ( w , b ) = ∑ i = 1 n ( 1 2 log ⁡ ( 2 π σ 2 ) + 1 2 σ 2 ( y ( i ) − w ⊤ x ( i ) − b ) 2 ) . -l(w,b) = \sum\limits_{i=1}^n \bigg(\frac{1}{2} \log(2 \pi \sigma^2) + \frac{1}{2 \sigma^2} \left(y^{(i)} - \mathbf{w}^\top \mathbf{x}^{(i)} - b\right)^2\bigg). −l(w,b)=i=1∑n(21log(2πσ2)+2σ21(y(i)−w⊤x(i)−b)2).

由于 π , σ \pi,\sigma π,σ 均为常数，故由上式可知，对线性模型的最小化均方误差等价于极大似然估计。

3.1.4 从线性回归到深度网络

3.2 线性回归的从零开始实现

3.2.1 生成数据集

假定我们要生成一个包含 1000 个样本的数据集，每个样本包含从标准正态分布中采样 的 2 个特征，样本的标签为：
y = X w + b + ϵ \mathbf{y}= \mathbf{X} \mathbf{w} + b + \mathbf\epsilon y=Xw+b+ϵ

其中， w = [ 2 , − 3.4 ] ⊤ \mathbf{w} = [2, -3.4]^\top w=[2,−3.4]⊤、 b = 4.2 b = 4.2 b=4.2 ， ϵ \epsilon ϵ 服从均值为 0 ，标准差为 0.01 的正态分布。

def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+噪声"""
    X = torch.normal(0, 1, (num_examples, len(w)))
    y = torch.matmul(X, w) + b
    y += torch.normal(0, 0.01, y.shape)
    # 如果没有y.reshape，那么y将只有一个维度
    return X, y.reshape((-1, 1))

3.2.2 读取数据集

由于随机梯度下降法要求我们每次从样本中随机抽取一部分样本，所以我们可以定义 data_iter 用于样本的抽取：

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    # 这些样本是随机读取的，没有特定的顺序
    random.shuffle(indices)
    # 在一轮训练中要用到所有的样本
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i: min(i + batch_size, num_examples)])
        # 每次参数更新只用到一小部分样本
        yield features[batch_indices], labels[batch_indices]

上面的代码仅用于理解抽取样本的过程，实际实现时可以使用内置的迭代器。

3.2.3 初始化参数

w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

3.2.4 定义模型

def linreg(X, w, b):
    """线性回归模型"""
    return torch.matmul(X, w) + b

3.2.5 定义损失函数

def squared_loss(y_hat, y):
    """均方损失"""
    # 这里的y.reshape其实是没有必要的，因为labels在前面已经reshape过了
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

3.2.6 定义优化算法

def sgd(params, lr, batch_size):
    """小批量随机梯度下降"""
    # 表示下一个代码块不需要进行梯度计算
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            # 清空梯度
            param.grad.zero_()

3.2.7 训练

lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss

for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
        # 并以此计算关于[w,b]的梯度
        l.sum().backward()
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)
        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

3.3 线性回归的简洁实现

3.3.1 生成数据

这部分和 3.2.1 相同。

3.3.2 读取数据集

from torch.utils import data

我们可以直接使用 data 中的 API 来进行样本抽样：

def load_array(data_arrays, batch_size, is_train=True):
    """构造一个PyTorch数据迭代器"""
    # TensorDataset相当于把所有tensor打包，传入的tensor的第0维必须相同
    # *的作用是"解压"参数列表
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)

batch_size = 10
data_iter = load_array((features, labels), batch_size)
# 访问数据
for input,label in data_iter:
    print(input,label)

3.3.3 定义模型

# nn是神经网络的缩写
from torch import nn

net = nn.Sequential(nn.Linear(2, 1))

上面的代码中，Sequential 可以将多个层串联在一起；Linear 实现了全连接层，其参数 2,1 指定了输入的形状和输出的形状。

3.3.4 初始化模型参数

# net[0]表示选中网络中的第0层
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

3.3.5 定义损失函数

# 返回所有样本损失的均值
loss = nn.MSELoss()

3.3.6 定义优化算法

# SGD的输入为参数和超参数
trainer = torch.optim.SGD(net.parameters(), lr=0.03)

3.3.7 训练

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X) ,y)
        trainer.zero_grad()
        l.backward()
        # 使用优化器对参数进行更新
        trainer.step()
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {l:f}')

3.4 softmax回归

3.4.1 分类问题

一般将不同的类别用独热编码表示。

3.4.2 网络架构

假设每个样本有 4 个特征和 3 种可能的类别，则 softmax 回归的网络结构如下图所示：

3.4.3 全连接层的参数开销

一般而言全连接层有 d d d 个输入和 q q q 个输出，则其参数开销为 O ( d p ) O(dp) O(dp) 。

3.4.4 softmax运算

对于分类问题，我们想得到的是输入属于每一种类别的概率，所以我们要对输出进行一定的处理，使之满足概率基本公理：
y ^ = s o f t m a x ( o ) 其中 y ^ j = exp ⁡ ( o j ) ∑ k exp ⁡ ( o k ) \hat{\mathbf{y}} = \mathrm{softmax}(\mathbf{o})\quad \text{其中}\quad \hat{y}_j = \frac{\exp(o_j)}{\sum\limits_k \exp(o_k)} y^=softmax(o)其中y^j=k∑exp(ok)exp(oj)

显然， y ^ \hat{\mathbf{y}} y^ 的每个分量恒正且和为 1 1 1 ，且 softmax 不会改变 o \mathbf{o} o 之间的大小顺序。

3.4.5 小批量样本的矢量化

KaTeX parse error: Expected 'EOF', got '&' at position 13: \mathbf{O} &̲= \mathbf{X} \m...

3.4.6 损失函数

softmax 回归的似然函数为：
L ( θ ) = ∏ i = 1 n P ( y ( i ) ∣ x ( i ) ) L(\theta)=\prod\limits_{i=1}^n P(\mathbf{y}^{(i)} \mid \mathbf{x}^{(i)}) L(θ)=i=1∏nP(y(i)∣x(i))

取负对数，得：
− log ⁡ L ( θ ) = ∑ i = 1 n − log ⁡ P ( y ( i ) ∣ x ( i ) ) = ∑ i = 1 n ∑ j = 1 q − y j log ⁡ y ^ j \begin{align} -\log L(\theta)&=\sum\limits_{i=1}^n -\log P(\mathbf{y}^{(i)} \mid \mathbf{x}^{(i)})\notag\\ &=\sum\limits_{i=1}^n\sum\limits_{j=1}^q-y_j\log \hat{y}_j \end{align} −logL(θ)=i=1∑n−logP(y(i)∣x(i))=i=1∑nj=1∑q−yjlogy^j

解释以下上面的式子：因为样本的标签是一个长度为 q q q 的独热编码，所以里面的求和实际上就是求由输入推出其标签的条件的概率的负对数，这与 − log ⁡ P ( y ( i ) ∣ x ( i ) ) -\log P(\mathbf{y}^{(i)} \mid \mathbf{x}^{(i)}) −logP(y(i)∣x(i)) 是等价的。

称：
l ( y , y ^ ) = ∑ j = 1 q − y j log ⁡ y ^ j l(\mathbf{y}, \hat{\mathbf{y}})=\sum\limits_{j=1}^q-y_j\log \hat{y}_j l(y,y^)=j=1∑q−yjlogy^j

为交叉熵损失 （cross-entropy loss）。
l ( y , y ^ ) = − ∑ j = 1 q y j log ⁡ exp ⁡ ( o j ) ∑ k = 1 q exp ⁡ ( o k ) = ∑ j = 1 q y j log ⁡ ∑ k = 1 q exp ⁡ ( o k ) − ∑ j = 1 q y j o j = log ⁡ ∑ k = 1 q exp ⁡ ( o k ) − ∑ j = 1 q y j o j ∂ o j l ( y , y ^ ) = exp ⁡ ( o j ) ∑ k = 1 q exp ⁡ ( o k ) − y j = s o f t m a x ( o ) j − y j \begin{aligned} l(\mathbf{y}, \hat{\mathbf{y}}) &= - \sum_{j=1}^q y_j \log \frac{\exp(o_j)}{\sum_{k=1}^q \exp(o_k)}\notag \\ &= \sum_{j=1}^q y_j \log \sum_{k=1}^q \exp(o_k) - \sum_{j=1}^q y_j o_j\notag\\ &= \log \sum_{k=1}^q \exp(o_k) - \sum_{j=1}^q y_j o_j\notag\\ \partial_{o_j} l(\mathbf{y}, \hat{\mathbf{y}}) &= \frac{\exp(o_j)}{\sum_{k=1}^q \exp(o_k)} - y_j = \mathrm{softmax}(\mathbf{o})_j - y_j\notag \end{aligned} l(y,y^)∂ojl(y,y^)=−j=1∑qyjlog∑k=1qexp(ok)exp(oj)=j=1∑qyjlogk=1∑qexp(ok)−j=1∑qyjoj=logk=1∑qexp(ok)−j=1∑qyjoj=∑k=1qexp(ok)exp(oj)−yj=softmax(o)j−yj

可以看出，梯度是观测值 y y y 和估计值 y ^ \hat{y} y^ 之间的差异，这使梯度计算在实践中变得容易很多。

3.5 图像分类数据集

3.5.2 读取小批量数据

batch_size = 256

def get_dataloader_workers():
    """使用4个进程来读取数据"""
    return 4

train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True,
                             num_workers=get_dataloader_workers())

3.6 softmax回归的从零开始实现

3.6.1 初始化模型参数

输入是 28*28 的图像，可以看作长度为 784 的向量；输出为属于 10 个可能的类别的概率，故 W W W 应为 784*10 的矩阵， b b b 为 1*10 的行向量：

num_inputs = 784
num_outputs = 10

W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)

3.6.2 定义softmax操作

实现softmax由三个步骤组成：

1. 对每个项求幂；
2. 对每一行求和（小批量中每个样本是一行），得到每个样本的规范化常数；
3. 将每一行除以其规范化常数，确保结果的和为1。

对应的代码为：

def softmax(X):
    X_exp = torch.exp(X)
    # 确保求和之后张量的维度不变
    partition = X_exp.sum(1, keepdim=True)
    return X_exp / partition  # 这里应用了广播机制

3.6.3 定义模型

def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

这里的输入为什么只是一张图像呢？

3.6.4 定义损失函数

def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])

cross_entropy(y_hat, y)

其中，y 为标签列表，代表样例的类别编号，如 [0,1,3] 。

3.6.5 分类精度

精度（accuracy）= 正确预测数量 / 总预测数量

def accuracy(y_hat, y):
    """计算预测正确的数量"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

上面的代码表示：如果 y_hat 是矩阵，那么假定第二个维度存储每个类的预测分数。 我们使用 argmax 获得每行中最大元素的索引来获得预测类别。 然后我们将预测类别与真实 y 元素进行比较。 由于等式运算符 "==" 对数据类型很敏感， 因此我们将 y_hat 的数据类型转换为与 y 的数据类型一致。 结果是一个包含0（错）和1（对）的张量。 最后，我们求和会得到正确预测的数量。

3.7 softmax回归的简洁实现

3.7.1 初始化模型参数

# PyTorch不会隐式地调整输入的形状。因此，
# 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

# apply会对net里的每一层执行init_weights函数
# 所以init_weights函数里的m是用来限定只初始化Linear层参数的
net.apply(init_weights);

3.7.2 定义损失函数

CorssEntropyLoss 的输入为 o \mathbf{o} o （未经过 softmax）和标签列表，输出为交叉熵。也就是说，我们在计算损失的时候不需要将输出通过 softmax 转化为概率，这是因为 softmax 中的指数运算非常容易溢出。

# none表示不合并结果，即loss为一个列表，元素为每个样本的交叉熵
# 这里之所以选择none，是因为后面既要用到损失的总和，又要用到损失的均值
loss = nn.CrossEntropyLoss(reduction='none')

3.7.3 优化算法

trainer = torch.optim.SGD(net.parameters(), lr=0.1)

3.7.4 训练

# 累加器类
class Accumulator:
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n
	
    # 将参数列表逐个加到累加器里
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

def train_epoch_ch3(net, train_iter, loss, updater):
    """训练模型一个迭代周期（定义见第3章）"""
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    # 训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()
            l.mean().backward()
            updater.step()
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失和训练精度
    return metric[0] / metric[2], metric[1] / metric[2]

def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):
        net.eval()  # 将模型设置为评估模式
    metric = Accumulator(2)  # 正确预测数、预测总数
    with torch.no_grad():
        for X, y in data_iter:
            # 这里的accuracy出自3.6.5
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    """训练模型（定义见第3章）"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        # 训练一轮
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        # 在测试集上测试精度
        test_acc = evaluate_accuracy(net, test_iter)
        animator.add(epoch + 1, train_metrics + (test_acc,))
    train_loss, train_acc = train_metrics
    # 这条代码的意思是：如果train_loss<0.5则继续执行，否则报错，报错内容为"train_loss"
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc

num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

3.7.5 预测

使用 y_hat.argmax(axis=1) 即可。