了解线性回归的关键思想之后，始通过代码来动手实现线性回归。
文章目录
1.1 从零开始实现
虽然现代的深度学习框架几乎可以自动化地进行所有这些工作，但从零开始实现可以确保你真正知道自己在做什么。 同时，了解更细致的工作原理将方便我们自定义模型、自定义层或自定义损失函数。
%matplotlib inline
import random
import torch
from d2l import torch as d2l
1.1.1 生成数据集
生成一个包含1000个样本的数据集， 每个样本包含从标准正态分布中采样的2个特征。
def synthetic_data(w, b, num_examples):
"""生成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)
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)
features中的每一行都包含一个二维数据样本， labels中的每一行都包含一维标签值（一个标量）。
print('features:', features[0],'\nlabel:', labels[0])
features: tensor([ 0.6631, -0.7805])
label: tensor([8.1842])
通过生成第二个特征features[:, 1]和labels的散点图， 可以直观观察到两者之间的线性关系。
d2l.set_figsize()
d2l.plt.scatter(features[:, (1)].detach().numpy(), labels.detach().numpy(), 1);
1.1.2 读取数据集
定义一个函数， 该函数能打乱数据集中的样本并以小批量方式获取数据。
data_iter函数， 该函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。 每个小批量包含一组特征和标签。
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]
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
print(X, '\n', y)
break
输出：
tensor([[-0.8841, 0.0372],
[-0.3387, 0.3164],
[ 0.3212, 2.0915],
[ 0.4819, -1.2344],
[-0.2791, -0.1832],
[ 1.6380, 0.6086],
[ 0.7341, 1.1638],
[ 1.0234, -1.5223],
[-2.6958, 0.1999],
[-1.5663, -2.0430]])
tensor([[ 2.2757],
[ 2.4552],
[-2.2666],
[ 9.3455],
[ 4.2686],
[ 5.4153],
[ 1.6975],
[11.4085],
[-1.8559],
[ 8.0139]])
1.1.3 初始化模型参数
通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重， 并将偏置初始化为0。
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
在初始化参数之后，我们的任务是更新这些参数，直到这些参数足够拟合我们的数据。
1.1.4 定义模型
计算线性模型的输出， 我们只需计算输入特征 X 和模型权重 w 的矩阵-向量乘法后加上偏置 b 。Xw 是一个向量，而 b 是一个标量。当我们用一个向量加一个标量时，标量会被加到向量的每个分量上。
def linreg(X, w, b):
"""线性回归模型"""
return torch.matmul(X, w) + b
1.1.5 定义损失函数
使用平方损失函数。
def squared_loss(y_hat, y):
"""均方损失"""
return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2
1.1.6 定义优化算法
在每一步中，使用从数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。 接下来，朝着减少损失的方向更新我们的参数。 下面的函数实现小批量随机梯度下降更新。 该函数接受模型参数集合、学习速率和批量大小作为输入。
def sgd(params, lr, batch_size):
"""小批量随机梯度下降"""
with torch.no_grad():
for param in params:
param -= lr * param.grad / batch_size
param.grad.zero_()
1.1.7 训练
在每次迭代中，我们读取一小批量训练样本，并通过我们的模型来获得一组预测。 计算完损失后，我们开始反向传播，存储每个参数的梯度。 最后，我们调用优化算法sgd来更新模型参数。概括一下，我们将执行以下循环：
- 初始化参数
- 重复以下训练，直到完成
使用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中的所有元素被加到一起，
# 并以此计算关于[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}')
epoch 1, loss 0.040067
epoch 2, loss 0.000148
epoch 3, loss 0.000049
print(f'w的估计误差: {
true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {
true_b - b}')
w的估计误差: tensor([ 0.0005, -0.0003], grad_fn=<SubBackward0>)
b的估计误差: tensor([-0.0001], grad_fn=<RsubBackward1>)
1.2 简洁实现
引用一些开源框架，这些框架可以自动化基于梯度的学习算法中重复性的工作。如数据迭代器、损失函数、优化器和神经网络层等等
1.2.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)
1.2.2 读取数据集
def load_array(data_arrays, batch_size, is_train=True):
"""构造一个PyTorch数据迭代器"""
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)
使用iter构造Python迭代器，并使用next从迭代器中获取第一项。
next(iter(data_iter))
[tensor([[ 0.3142, -0.9088],
[ 0.3454, -0.0573],
[ 0.6141, 0.2420],
[-0.6898, 1.4459],
[ 0.8067, -0.3340],
[ 0.4517, -0.0349],
[-0.0894, 1.7150],
[-0.2578, -1.3239],
[ 1.8576, -0.1634],
[-0.1818, -2.7210]]),
tensor([[ 7.9111],
[ 5.0854],
[ 4.6106],
[-2.0876],
[ 6.9367],
[ 5.2169],
[-1.8110],
[ 8.1817],
[ 8.4688],
[13.1087]])]
1.2.3 定义模型
对于标准深度学习模型，我们可以使用框架的预定义好的层。这使我们只需关注使用哪些层来构造模型，而不必关注层的实现细节。 我们首先定义一个模型变量net，它是一个Sequential类的实例。 Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。 在下面的例子中，我们的模型只包含一个层，因此实际上不需要Sequential。 但是由于以后几乎所有的模型都是多层的，在这里使用Sequential会让你熟悉“标准的流水线”。
在PyTorch中，全连接层在Linear类中定义。 值得注意的是，我们将两个参数传递到nn.Linear中。 第一个指定输入特征形状，即2，第二个指定输出特征形状，输出特征形状为单个标量，因此为1。
# nn是神经网络的缩写
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))
1.2.4 初始化模型参数
在使用net之前，我们需要初始化模型参数。 如在线性回归模型中的权重和偏置。 深度学习框架通常有预定义的方法来初始化参数。 在这里，我们指定每个权重参数应该从均值为0、标准差为0.01的正态分布中随机采样， 偏置参数将初始化为零。
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)
1.2.5 定义损失函数
计算均方误差使用的是MSELoss类，也称为平方 L2 范数。 默认情况下，它返回所有样本损失的平均值。
loss = nn.MSELoss()
1.2.6 定义优化算法
小批量随机梯度下降算法是一种优化神经网络的标准工具， PyTorch在optim模块中实现了该算法的许多变种。 当我们实例化一个SGD实例时，我们要指定优化的参数 （可通过net.parameters()从我们的模型中获得）以及优化算法所需的超参数字典。 小批量随机梯度下降只需要设置lr值，这里设置为0.03。
trainer = torch.optim.SGD(net.parameters(), lr=0.03)
1.2.7 训练
在每个迭代周期里，我们将完整遍历一次数据集（train_data）， 不停地从中获取一个小批量的输入和相应的标签。 对于每一个小批量，我们会进行以下步骤:
- 通过调用net(X)生成预测并计算损失l（前向传播）。
- 通过进行反向传播来计算梯度。
- 通过调用优化器来更新模型参数。
为了更好的衡量训练效果，我们计算每个迭代周期后的损失，并打印它来监控训练过程。
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}')
epoch 1, loss 0.000275
epoch 2, loss 0.000107
epoch 3, loss 0.000108
比较生成数据集的真实参数和通过有限数据训练获得的模型参数。 要访问参数，我们首先从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.0002, -0.0001])
b的估计误差： tensor([0.0014])