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

1.线性回归

回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。 在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。

当函数为未知参数的线性函数时，称为线性回归模型。

1.1. 线性模型

线性假设是指目标可以表示为特征的加权和：

y：预测结果

x：元素特征

w：权重，决定了每个特征对我们预测值的影响

b：偏置，指当所有特征都取值为0时，预测值应该为多少

将所有特征放到向量x∈中， 并将所有权重放到向量w∈中， 我们可以用点积形式来简洁地表达模型：

此时向量x对应于单个数据样本的特征

对于特征集合X，预测值y^∈ 可以通过矩阵-向量乘法表示为：

1.2. 损失函数

损失函数（loss function）能够量化目标的实际值与预测值之间的差距。通常我们会选择非负数作为损失，且数值越小表示损失越小，完美预测时的损失为0。

回归问题中最常用的损失函数是平方误差函数。

平方误差可以定义为以下公式：

即用样本i的预测值减去真实标签值后平方再除以1/2
常数1/2便于我们在对损失函数（平方项）求导时，能够将系数化为1

由于平方误差函数中的二次方项， 估计值和观测值之间较大的差异将导致更大的损失。 为了度量模型在整个数据集上的质量，我们需计算在训练集n个样本上的损失均值（也等价于求和）。

在训练模型时，我们希望寻找一组参数w*，b*，能够最小化在所有训练样本上的总损失。

1.3. 随机梯度下降

对参数w，b更新的方法则是使用到一种叫做梯度下降的方法，它不断在损失函数递减的方向上更新参数，从而达到降低误差的目的

梯度下降最简单的用法是计算损失函数（数据集中所有样本的损失均值） 关于模型参数的导数（在这里也可以称为梯度）。 

因为在每一次更新参数之前，我们必须遍历整个数据集。 因此，我们通常会在每次需要计算更新的时候随机抽取一小批样本， 这种变体叫做小批量随机梯度下降。

每次迭代的过程为

1、随机抽样一个小批量， 它是由固定数量的训练样本组成的。

2、计算小批量的平均损失关于模型参数的导数（也可以称为梯度）。

3、我们将梯度乘以一个预先确定的正数，并从当前参数的值中减掉。

 ||表示每个小批量中的样本数，这也称为批量大小（batch size）。 表示学习率（learning rate）。 批量大小和学习率的值通常是手动预先指定，而不是通过模型训练得到的。这些可以调整但不在训练过程中更新的参数称为超参数。 调参是选择超参数的过程。 

1.4. 矢量化加速

在训练我们的模型时，我们经常希望能够同时处理整个小批量的样本。 为了实现这一点，需要我们对计算进行矢量化， 从而利用线性代数库，而不是在Python中编写开销高昂的for循环。

即使用重载的+运算符来计算按元素的和，而不是使用for循环。

2.线性回归的从零开始实现

2.1.生成数据集

生成一个包含1000个样本的数据集， 每个样本包含从标准正态分布中采样的2个特征。

#matplotlib包用于作图
%matplotlib inline
import random
import torch
from d2l import torch as d2l

#生成数据集
def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+噪声"""
    X = torch.normal(0, 1, (num_examples, len(w)))  #X为均值是0，标准差为1，num_examples为行数，len（w)为列数的张量。定义了1000x2大小的数据集。相当于1000个（X1i,X2j)
    y = torch.matmul(X, w) + b   #torch.matmul 张量相乘
    y += torch.normal(0, 0.01, y.shape)   # y=y+均值为0，方差为0.1的矩阵。作用是加入随机噪声
    return X, y.reshape((-1, 1))

true_w = torch.tensor([2, -3.4])
true_b = 4.2
#feature里包含1000x2列的数据集，labels包含1000个标量.每个lebels = 2features1 - 3.4features2 + 4.2 还存在一个噪声
features, labels = synthetic_data(true_w, true_b, 1000)
print('features:', features[0],'\nlabel:', labels[0])

注意，features中的每一行都包含一个二维数据样本， labels中的每一行都包含一维标签值（一个标量）。

#看features的第0列和labels的相关性，理论是y=2x+4.2的相关
d2l.set_figsize()
d2l.plt.scatter(features[:,(0)].detach().numpy(),labels.detach().numpy(),1)

#看features的第1列和labels的相关性，理论是y=-3.4x+4.2的相关
d2l.set_figsize()
d2l.plt.scatter(features[:,(1)].detach().numpy(),labels.detach().numpy(), 1);

#看features的本身什么样
d2l.set_figsize()
d2l.plt.scatter(features[:,0].detach().numpy(),features[:,1].detach().numpy())

2.2.读取数据集

训练模型时要对数据集进行遍历，每次抽取一小批量样本，并使用它们来更新我们的模型。

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)])
        # 依次取出batch size个indice并组成张量
        yield features[batch_indices], labels[batch_indices]   #返回这tensor序号下对应的的features和labels
'''
一个带有 yield 的函数就是一个 generator，它和普通函数不同，生成一个 generator 看起来像函数调用，但不会
执行任何函数代码，直到对其调用 next()（在 for 循环中会自动调用 next()）才开始执行。虽然执行流程仍按函数
的流程执行，但每执行到一个 yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执
行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。
'''

2.3.初始化模型参数

我们通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重， 并将偏置初始化为0。

#定义初始化模型参数
#在 torch 中 对定义的变量 requires_grad 的属性赋为 True ，那么此变量即可进行梯度以及导数的求解
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

2.4.定义模型

我们必须定义模型，将模型的输入和参数同模型的输出关联起来。

线性回归模型：y=wx+b

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

2.5.定义损失函数

因为需要计算损失函数的梯度，所以我们应该先定义损失函数。

#定义损失函数
def squared_loss(y_hat, y):  #@save
    """均方损失"""
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

2.6.定义优化算法

使用小批量随机梯度下降

#定义优化算法
def sgd(params, lr, batch_size):  #@save
    """小批量随机梯度下降"""
    with torch.no_grad():  #在该模块下，所有计算得出的tensor的requires_grad都自动设置为False。
        for param in params:
            # param.grad是损失函数关于param的梯度。因为之前运行过l.sum().backward()，所以损失函数的反向传播的梯度均被计算了
            # 负梯度就是损失函数值下降最快的方向。方向就是是一个向量，再乘以学习率就得到了方向和步长。
            # 因此每执行一次就向当前损失下降最快的方向前进一步
            # 注意这里的l是10x1的向量，因此梯度计算也只是根据十个值的损失得到的下降最快的方向。
            param -= lr * param.grad / batch_size
            param.grad.zero_()

2.7.训练

训练过程大概为：

1、在每次迭代中，读取一小批量训练样本，并通过模型来获得一组预测。

2、计算完损失后，开始反向传播，存储每个参数的梯度。

3、调用优化算法sgd来更新模型参数。

#训练
batch_size = 10
lr = 0.02
num_epochs = 5
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}')
        print(f'w的估计误差:{true_w - w.reshape(true_w.shape)}')
        print(f'b的估计误差:{true_b - b}')

3.线性回归的简洁实现

使用深度学习框架来简洁地实现线性回归模型。

3.1.生成数据集

import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l
#生成数据集
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

3.2.读取数据集

#读取数据集
#is_train表示是否希望数据迭代器对象在每个迭代周期内打乱数据
def load_array(data_arrays, batch_size, is_train=True):  #@save
    """构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)  #将传入的特征和标签作为list传到TensorDataset里面得到一个pytorch的数据集（dataset）
    return data.DataLoader(dataset, batch_size, shuffle=is_train)  #调用Dataloader每次从dataset里面挑选batch_size个样本出来（shuffle：是否随机）

batch_size = 10
data_iter = load_array((features, labels), batch_size)
#使用iter构造Python迭代器，并使用next从迭代器中获取第一项
print(next(iter(data_iter)))

3.3.定义模型

对于标准深度学习模型，我们可以使用框架的预定义好的层。这使我们只需关注使用哪些层来构造模型，而不必关注层的实现细节。 

首先定义一个模型变量net，它是一个Sequential类的实例。 Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。 

#定义模型
# nn是神经网络的缩写
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))

3.4.初始化模型参数

在使用net之前，我们需要初始化模型参数。 如在线性回归模型中的权重和偏置。 

#初始化模型参数
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

3.5.定义损失函数

计算均方误差使用的是MSELoss类，也称为平方�2范数。 默认情况下，它返回所有样本损失的平均值。

loss = nn.MSELoss()

3.6.定义优化算法

小批量随机梯度下降算法是一种优化神经网络的标准工具， PyTorch在optim模块中实现了该算法的许多变种。 

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

3.7.训练

在每个迭代周期里，我们将完整遍历一次数据集（train_data）， 不停地从中获取一个小批量的输入和相应的标签。 对于每一个小批量，我们会进行以下步骤:

1、通过调用net(X)生成预测并计算损失l（前向传播）。

2、通过进行反向传播来计算梯度。

3、通过调用优化器来更新模型参数。

#训练
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}')
    w = net[0].weight.data
    print('w的估计误差：', true_w - w.reshape(true_w.shape))
    b = net[0].bias.data
    print('b的估计误差：', true_b - b)

3.8.小结

使用PyTorch的高级API可以更简洁的实现模型，省去了很多自定义的过程，在需要的时候可以直接调用

4.softmax回归

回归可以用于预测多少，分类是问哪一个。

4.1. 网络架构

为了估计所有可能类别的条件概率，我们需要一个有多个输出的模型，每个类别对应一个输出。

在例子（猫，鸡，狗）中，由于有4个特征和3个可能的输出类别，我们将需要12个标量来表示权重（带下标的w），3个标量来表示偏置（带下标的b）。下面是为每个输入计算三个未规范化的预测（logit）：o1、o2和o3。

用神经网络来描述这个计算过程，与线性回归一样，softmax回归也是一个单层神经网络。由于计算每个输出o1、o2和o3取决于所有输入x1，x2，x3和x4，所以softmax回归的输出层也是全连接层。

o为类别，x为特征

4.2. softmax运算

我们将优化参数以最大化观测数据的概率。 为了得到预测结果，我们将设置一个阈值，如选择具有最大概率的标签。

要将输出视为概率，我们必须保证在任何数据上的输出都是非负的且总和为1。 要将输出视为概率，我们必须保证在任何数据上的输出都是非负的且总和为1。 

softmax函数能够将未规范化的预测变换为非负数并且总和为1，同时让模型保持可导的性质。首先对每个未规范化的预测求幂，这样可以确保输出非负。 为了确保最终输出的概率值总和为1，我们再让每个求幂后的结果除以它们的总和。

 softmax运算不会改变未规范化的预测o之间的大小次序，只会确定分配给每个类别的概率。 因此，在预测过程中，我们仍然可以用下式来选择最有可能的类别。

尽管softmax是一个非线性函数，但softmax回归的输出仍然由输入特征的仿射变换决定。 因此，softmax回归是一个线性模型（linear model）。

6.softmax回归的简洁实现

通过深度学习框架的高级API也能更方便地实现softmax回归模型。 

6.1.初始化模型参数

softmax回归的输出层是一个全连接层。为了实现我们的模型， 我们只需在Sequential中添加一个带有10个输出的全连接层。 

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)

# 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)

net.apply(init_weights);

展平层：Flatten层用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。

apply()：当一个函数的参数存在于一个元组或者一个字典中时，用来间接的调用这个函数，并肩元组或者字典中的参数按照顺序传递给参数

6.2.重新审视softmax的实现

softmax函数的分母或分子可能变成无穷大，需要优化。这里没有将softmax概率传递到损失函数中， 而是在交叉熵损失函数中传递未规范化的预测，并同时计算softmax及其对数。

loss = nn.CrossEntropyLoss(reduction='none')

该损失函数整合了nn.LogSoftmax()和nn.NLLLoss()，常用于训练分类任务。特别是在神经网络做分类问题时，经常使用交叉熵作为损失函数，此外，由于交叉熵涉及到计算每个类别的概率，所以交叉熵几乎每次都和sigmoid(或softmax)函数一起出现。

①先经过softmax函数，求出每个类别的概率值，取值到0-1之间

②再经过log函数，取对数，原来的变化趋势保持不变，但所有值都会变成负的，原来概率大的，成为负值也大，但是它取绝对值后就是最小的，我们想要的是最小损失，正好贴合

上边两步，可以直接用函数nn.LogSoftmax代替;

③最后使用nn.NLLLoss函数求损失，它就是求每个样本的标签处的预测值之和，然后取平均，变为正数

6.3.优化算法

仍然使用小批量随机梯度下降作为优化算法。 这与我们在线性回归例子中的相同，这说明了优化器的普适性。

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

6.4.训练

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):  #@save
    """训练模型（定义见第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
    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)

assert断言，条件为true时正常执行，为false时触发异常

6.5.小结

softmax回归主要用于分类问题，他的训练过程和线性回归相似，同样的他也可以使用高级API进行简洁实现。