本文跟随李沐老师的课程，从零开始实现整个线性回归方法， 以及利用深度学习框架来简洁地实现线性回归模型。

目录

一、线性回归的从零开始实现

1 数据集构建

2 读取数据集

3 初始化模型参数

4 定义模型

5 训练

二、线性回归的简洁实现

1 生成数据集

2 读取数据集

3 定义模型

4 训练

一、线性回归的从零开始实现

首先在这一节中从零开始实现整个线性回归方法， 包括数据流水线、模型、损失函数和小批量随机梯度下降优化器。 虽然现代的深度学习框架几乎可以自动化地进行所有这些工作，但从零开始实现可以确保我们真正知道自己在做什么。 同时，了解更细致的工作原理将方便我们自定义模型、自定义层或自定义损失函数。 这一节将只使用张量和自动求导。

%matplotlib inline    # IPython和Jupyter notebook特有的魔法命令，即matplotlib将所有图形都直接嵌入到notebook中         
import random
import torch
from d2l import torch as d2l

1 数据集构建

为简单起见，根据带有噪声的线性模型构造一个人造数据集。通过使用这个有限样本的数据集来恢复这个模型的参数。为方便可视化，只使用低维数据。下面生成一个包含1000个样本的数据集。使用线性模型参数 和噪声项生成数据集及其标签：

可以视为模型预测和标签时的潜在观测误差，这里将其设为服从均值0、标准差0.01的正态分布。

def synthetic_data(w, b, num_examples):  #@save
    """
    生成y=Xw+b+噪声
    @para w 权重
    @para b 偏差 
    @para num_examples 样本数量
    @return
        X 随机生成的特征数据，(num_examples, len(w))
        y X对应的标签 （num_examples，1）
    
    """
    # 生成均值为0，标准差为1，数据维度为（num_examples, len(w)）的随机数据作为训练样本    
    X = torch.normal(0, 1, (num_examples, len(w)))    # torch.Size([1000, 2])
    # 生成X对应的预测值y 
    y = torch.matmul(X, w) + b    # torch.Size([1000])
    y += torch.normal(0, 0.01, y.shape)    # 加入均值为0，标准差为0.01，维度与y.shape一致的噪音进行干扰
    return X, y.reshape((-1, 1))

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)    # torch.Size([1000, 2]) torch.Size([1000, 1])     

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

>>> print('features:', features[0],'\nlabel:', labels[0])    # 打印一个样本数据和对应标签    
    features: tensor([-1.2636, -1.2207]) 
    label: tensor([5.8615])

生成第二个特征features[:, 1]和labels的散点图， 可以直观观察到两者之间的线性关系。

#可视化数据
d2l.set_figsize() 
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1); 
# x轴为features的第一列，y轴为标签值，正相关

2 读取数据集

训练模型时要对数据集进行遍历，每次抽取一小批量样本，并使用它们来更新模型。该过程是训练机器学习算法的基础，因此需要定义一个函数，打乱数据集中的样本并以小批量方式获取数据。接下来，定义data_iter函数，将批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。 每个小批量包含一组特征和标签。

def data_iter(batch_size, features, labels):
    """
    随机获取一小批样本的数据
    @para batch_size 批量大小
    @para features 训练数据
    @para labels 训练数据对应的标签
    @return
        迭代器，每次返回batch_size大小的两组数据，一个是训练样本，一个是对应的标签   
        
    """
    num_examples = len(features)    # 获取样本大小
    indices = list(range(num_examples))    # 获取样本索引list
    # 这些样本是随机读取的，没有特定的顺序
    random.shuffle(indices)    # 随机打乱indices
    for i in range(0, num_examples, batch_size):    # 开始循环
        # 有可能不能整除，取i + batch_size和num_examples的较小值 
        batch_indices = torch.tensor(
            indices[i: min(i + batch_size, num_examples)])           
        yield features[batch_indices], labels[batch_indices]    
        # 相当于是一个迭代器，每次返回batch_size个样本

通常，我们利用GPU并行运算的优势，处理合理大小的“小批量”。 每个样本都可以并行地进行模型计算，且每个样本损失函数的梯度也可以被并行计算。 GPU可以在处理几百个样本时，所花费的时间不比处理一个样本时多太多。

接下来直观感受一下小批量运算：读取第一个小批量数据样本并打印。 每个批量的特征维度显示批量大小和输入特征数。 同样的，批量的标签形状与batch_size相等。

batch_size = 10
for X, y in data_iter(batch_size, features, labels):
    print(X, '\n', y)    # X为10 x 2的tensor，y为10 x 1的tensor
    break

运行迭代时，会连续地获得不同的小批量，直至遍历完整个数据集。 上面实现的迭代对于教学来说很好，但它的执行效率很低，可能会在实际问题上陷入麻烦。 例如，它要求我们将所有数据加载到内存中，并执行大量的随机内存访问。 在深度学习框架中实现的内置迭代器效率要高得多， 它可以处理存储在文件中的数据和数据流提供的数据。 

3 初始化模型参数

在开始用小批量随机梯度下降优化模型参数之前，先定义模型参数。通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重， 并将偏置初始化为0。使用自动微分来计算梯度。

# 由于训练的时候需要更细参数，计算梯度，所以requires_grad=True
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)    # w初始化为符合均值为0，标准差为0.01的正态分布的数组，维度为2 x 1    
b = torch.zeros(1, requires_grad=True)    # b初始化为0，维度为1，就是一个标量

4 定义模型

接下来定义模型，将模型的输入和参数同输出关联起来。 要计算线性模型的输出， 只需计算输入特征X和模型权重w的矩阵-向量乘法后加上偏置b。

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

定义损失函数

这里使用平方损失函数。 在实现中需要将真实值y的形状转换为和预测值y_hat的形状相同。

def squared_loss(y_hat, y):  #@save
    """
    均方损失
    @para y_hat 训练数据的真实值（num，1）
    @para y 训练数据的预测值
    @return
        均方误差，没有除以样本数目 (batch_size,1)
    """
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

定义优化算法

这里介绍小批量随机梯度下降的使用。在每一步中，从数据集中随机抽取一个小批量，然后根据参数计算损失的梯度。 接下来，朝着减少损失的方向更新参数。 下面实现小批量随机梯度下降更新的函数，该函数接受模型参数集合、学习速率和批量大小，每 一步更新的大小由学习速率lr决定。 因为计算的损失是一个批量样本的总和，所以用批量大小（batch_size） 来规范化步长，这样步长大小就不会取决于对批量大小的选择。

def sgd(params, lr, batch_size):  #@save
    """
    小批量随机梯度下降
    @para params 参数集合
    @para lr 学习率，人为指定
    @para batch_size 批量大小
    @return 
    """
    with torch.no_grad():    # 更新参数时不需要计算梯度，这里表示关闭自动梯度计算
        for param in params:
            param -= lr * param.grad / batch_size    # 梯度下降法更新参数
            param.grad.zero_()    # 手动梯度归零，防止影响下一次梯度计算

5 训练

每次迭代读取一小批量训练样本，并通过模型来获得一组预测。 计算完损失后，开始反向传播，存储每个参数的梯度。 最后，调用优化算法sgd来更新模型参数。概括一下，将执行以下循环：

• 初始化参数

• 重复以下训练，直到完成

  • 计算梯度

  • 更新参数

在每个迭代周期（epoch）中，使用data_iter函数遍历整个数据集， 并将训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。 这里的迭代周期个数num_epochs和学习率lr都是超参数，分别设为3和0.03。 设置超参数很棘手，需要通过反复试验进行调整。

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中的所有元素相加来计算关于参数的梯度
        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}')

epoch 1, loss 9.187869
epoch 2, loss 4.966934
epoch 3, loss 2.685649

比较真实参数和通过训练学到的参数来评估训练的成功程度

print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

w的估计误差: tensor([ 0.3431, -0.5157], grad_fn=<SubBackward0>)
b的估计误差: tensor([0.6689], grad_fn=<RsubBackward1>)

注意，我们不应该想当然地认为我们能够完美地求解参数。 在机器学习中，通常不太关心恢复真正的参数，而更关心如何高度准确预测参数。 幸运的是，即使是在复杂的优化问题上，随机梯度下降通常也能找到非常好的解。 其中一个原因是，在深度网络中存在许多参数组合能够实现高度精确的预测。

二、线性回归的简洁实现

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    # 真实偏差
# 应用liner-regression-concise里面的函数，生成训练数据
features, labels = d2l.synthetic_data(true_w, true_b, 1000) 

def load_array(data_arrays, batch_size, is_train=True):  #@save
    """
    构造一个PyTorch数据迭代器
    @para data_arrays 训练数据
    @para batch_size 批量大小
    @para is_train=True 是否训练，选择True会随机选择数据
    @return
        迭代器，每次返回batch_size大小的两组数据，一个是训练样本，一个是对应的标签 
    """
    dataset = data.TensorDataset(*data_arrays)    # 数据集
    return data.DataLoader(dataset, batch_size, shuffle=is_train) 
    # dataloader可以理解为数据的一个接口，说明见https://blog.csdn.net/lipengfei0427/article/details/109547241    

batch_size = 10 #批量大小
data_iter = load_array((features, labels), batch_size) #随机返回的数据

next(iter(data_iter))    # iter构造Python迭代器，并使用next从迭代器中获取第一项。

[ tensor ( [ [ -0.4062,  1.1038],
                 [ 1.9097,  0.8225],
                 [ 0.3240, -1.4191],
                 [-0.2455,  0.9178],
                 [ 1.5611, -0.2885],
                 [ 1.4176,  0.8724],
                 [ 0.6095,  0.4139],
                 [-0.1278,  0.6620],
                 [-1.3231,  0.5073],
                 [ 0.8187,  0.3404] ] ),
  tensor ( [ [-0.3626],
                 [ 5.2240],
                 [ 9.6825],
                 [ 0.6034],
                 [ 8.3074],
                 [ 4.0649],
                 [ 4.0101],
                 [ 1.6942],
                 [-0.1670],
                 [ 4.6654] ] ) ]

3 定义模型

对于标准深度学习模型，可以使用框架的预定义好的层。这样只需关注使用哪些层来构造模型，而不必关注层的实现细节。这里首先定义一个模型变量net，它是一个Sequential类的实例。（Sequential类将多个层串联在一起。当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。）

本例的模型只包含一个层，因此实际上不需要Sequential。但由于以后几乎所有的模型都是多层的，在这里使用Sequential来熟悉“标准的流水线”。线性回归是单层网络架构， 这一单层被称为全连接层（fully-connected layer）， 因为其每一个输入都通过矩阵-向量乘法得到它的每个输出。

在PyTorch中，全连接层在Linear类中定义。 nn.Linear中需要传递两个参数，第一个指定输入特征形状，即2；第二个指定输出特征形状，输出特征形状为单个标量，因此为1。

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

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

初始化模型参数

深度学习框架通常有预定义的方法来初始化参数。 这里指定每个权重参数应该从均值为0、标准差为0.01的正态分布中随机采样， 偏置参数将初始化为零。

net[0].weight.data.normal_(0, 0.01)    # 权重初始化，用normal方式
net[0].bias.data.fill_(0)    # 初始化偏差为0

正如在构造nn.Linear时指定输入和输出尺寸一样， 现在能直接访问参数以设定它们的初始值。 通过net[0]选择网络中的第一个层， 然后使用weight.data和bias.data方法访问参数，使用替换方法normal_和fill_来重写参数值。

weight: tensor( [ [ -0.0157, -0.0097 ] ] )
data: tensor( [ 0. ] )

定义损失函数

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

loss = nn.MSELoss()    # 均方误差函数

定义优化算法

小批量随机梯度下降算法是一种优化神经网络的标准工具， PyTorch在optim模块中实现了该算法的许多变种。 实例化SGD时，要指定优化的参数 （可通过net.parameters()从模型中获得）以及优化算法所需的超参数字典。 小批量随机梯度下降只需要设置lr值，这里设置为0.03。

trainer = torch.optim.SGD(net.parameters(), lr=0.03)    # 随机梯度下降优化算法SGD，传入模型的参数，学习率lr

4 训练

通过深度学习框架的高级API来实现线性回归模型只需要相对较少的代码。 我们不必单独分配参数、不必定义损失函数，也不必手动实现小批量随机梯度下降。 当面对更复杂的模型时，高级API的优势将大大增加。 训练过程代码与从零开始实现时所做的非常相似。

每个迭代周期都会完整遍历一次数据集， 每次从中获取一个小批量的输入和相应的标签，然后：

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

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

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

为了更好的衡量训练效果，计算每个迭代周期后的损失，并打印它来监控训练过程。

num_epochs = 3    # 迭代周期为3
for epoch in range(num_epochs):
    for X, y in data_iter:    # 返回batch_size大小的数据
        l = loss(net(X) ,y)    # 计算损失函数
        trainer.zero_grad()    # 梯度清零
        l.backward()    # 计算梯度
        trainer.step()    # 更新参数
    l = loss(net(features), labels)    # 计算所有样本的loss
    print(f'epoch {epoch + 1}, loss {l:f}')

epoch 1, loss 0.000414
epoch 2, loss 0.000110
epoch 3, loss 0.000109

比较生成数据集的真实参数和通过有限数据训练获得的模型参数

要访问参数，首先从net访问所需的层，然后读取该层的权重和偏置。

w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)

w的估计误差： tensor( [-0.0006,  0.0003] )
b的估计误差： tensor( [0.0006] )

 总结：

• 可以使用PyTorch的高级API更简洁地实现模型。

• PyTorch中，data模块提供了数据处理工具，nn模块定义了大量的神经网络层和常见损失函数。

• 可以通过“_”结尾的方法将参数替换，从而初始化参数。