虽然现在的深度学习框架几乎可以自动化实现下面的工作，但从零开始实现可以更了解工作原理，方便我们自定义模型、自定义层或自定义损失函数。
import random
import torch
from d2l import torch as d2l
生成数据集
根据带有噪声的线性模型构造一个人造数据集。任务是使用这个数据集来恢复模型的参数。我们使用低维数据，可以更容易地进行可视化。
在下面代码中，我们生成一个包含1000个样本的数据集，每个样本包含从标准正态分布中采样的2个特征。我们的数据集是一个1000×2的矩阵X。
使用线性模型参数 w = [ 2 , − 3.4 ] T 、 b = 4.2 和噪声项 δ 生成数据集及标签： y = X w + b + δ 使用线性模型参数w=[2,-3.4]^T、b=4.2和噪声项\delta生成数据集及标签：\\ y=Xw+b+\delta 使用线性模型参数w=[2,−3.4]T、b=4.2和噪声项δ生成数据集及标签：y=Xw+b+δ
其中，δ可以视为模型预测和标签时的潜在观测误差。在这里我们认为标准假设成立，即δ服从均值为0的正态分布。为简化问题，将标准差设为0.01。下面的代码生成合成数据集：
def synthetic_data(w, b, num_examples): #@save
"""生成y=Xw+b+δ"""
# 生成均值为0，标准差为1（标准正态分布）且大小1000*2的数据集
X = torch.normal(0, 1, (num_examples, len(w)))
# 生成y函数，生成1000*1的矩阵
y = torch.matmul(X, w) + b
# 再加上服从均值为0的正态分布的δ
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.5829, -0.2094])
label: tensor([3.7491])
通过生成第二个特征features[:, 1]和labels的散点图，可以直观看出两者之间的线性关系：
d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1)
d2l.plt.show()
读取数据集
训练模型时，要对数据集进行遍历，每次抽取一小批量样本，并使用它们来更新模型。因此，需要定义一个函数，该函数能打乱数据集中的样本并以小批量方式获取数据。
在下面代码中，定义一个data_iter函数，接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。每个小批量包含一组特征和标签。
def data_iter(batch_size, features, labels):
num_examples = len(features)
indices = list(range(num_examples)) # 0到999的顺序
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]
# yield返回一个可以用来迭代for循环的生成器，而不是直接return
通常我们会利用CPU并行运算的优势，处理合理大小的“小批量”。每个样本都可以并行进行模型计算，且每个样本损失函数的梯度也可以被并行计算。
可以直观感受一下小批量运算：读取第一个小批量数据样本并打印：
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
print(X, '\n', y)
break
结果：
tensor([[-1.0186, 1.8338],
[ 0.6455, 1.1226],
[-0.5020, 0.2105],
[ 1.3583, 0.6979],
[ 0.3024, -0.8929],
[ 0.4045, -0.4207],
[ 0.5201, -0.3263],
[ 0.6037, -0.1332],
[ 1.6171, 0.2449],
[-0.6540, 1.0338]])
tensor([[-4.0795],
[ 1.6835],
[ 2.5014],
[ 4.5346],
[ 7.8678],
[ 6.4298],
[ 6.3537],
[ 5.8528],
[ 6.6194],
[-0.6216]])
当我们进行迭代时，我们会连续地获得不同的小批量，直到遍历完整个数据集。但上面实现的迭代执行效率很低，可能会出问题。在深度学习框架中实现的内置迭代器效率要高得多，它可以处理存储在文件中的数据和数据流提供的数据
初始化模型参数
通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重，并将偏置初始化为0：
w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
在初始化参数后，我们的任务是更新这些参数，直到这些参数足够拟合我们的数据。每次更新都需要计算损失函数关于模型参数的梯度，有了这个梯度就可以向减小损失的方向来更新每个参数
定义模型
定义模型，就要将模型的输入和参数同模型的输出关联起来。
而要计算线性模型的输出，只需要计算输入特征X与模型权重w的矩阵-向量乘法后再加上偏置b。（Xw是一个向量，而b是标量）当我们用一个向量加上一个标量时，标量会加到向量的每个分量上（广播机制）：
def linreg(X, w, b): #@save
"""线性回归模型"""
return torch.matmul(X, w) + b
定义损失函数
要计算损失函数的梯度，自然要先定义损失函数，下面定义了平方损失函数：
def squared_loss(y_hat, y): #@save
"""均方损失"""
return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2
定义优化算法
线性回归是有解析解的，但是其他模型基本没有，因此还是用随机梯度下降法来进行优化。
在每一步中，使用数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。接下来朝着减小损失的方向来更新参数。
下面就是随机梯度下降更新的函数，该函数接受模型参数集合、学习速率和批量大小作为输入。每一步更新的大小由学习率lr决定。因为我们计算的损失是一个批量样本的综合，因此用批量大小batch_size来规范步长，这样步长大小就不会取决于我们对批量大小的选择：
def sgd(params, lr, batch_size): #@save
"""小批量随机梯度下降"""
with torch.no_grad():
for param in params:
param -= lr * param.grad / batch_size
param.grad.zero_()
其中，torch.no_grad()是上下文管理器，用来指定在其内部的代码块中不进行梯度计算。当不需要计算梯度时，使用该上下文管理器可以提高代码执行效率。
训练
在每次迭代中，我们读取一小批训练样本，并通过我们的模型来获得一组预测。计算完损失后，我们开始反向传播，存储每个参数的梯度。最后调用优化算法sgd来更新模型参数。
概括一下，就是执行下面的循环：
1、初始化参数
2、重复一下训练，直到完成：
计算梯度 g ← ∂ ( w , b ) 1 ∣ B ∣ ∑ i ∈ B l ( x ( i ) , y ( i ) , w , b ) 更新参数 ( w , b ) ← ( w , b ) − η g 计算梯度g←\partial_{(w,b)}\frac{1}{|B|}\sum_{i∈B}l(x^{(i)},y^{(i)},w,b)\\ 更新参数(w,b)←(w,b)-ηg 计算梯度g←∂(w,b)∣B∣1i∈B∑l(x(i),y(i),w,b)更新参数(w,b)←(w,b)−ηg
在每个迭代周期中，我们使用deta_iter函数遍历整个数据集，并将训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。这里的迭代周期个数num_epoches和学习率lr都是超参数，分别设为3和0.03。（超参数设置很麻烦，现在忽略细节）
batch_size = 10
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.040672
epoch 2, loss 0.000146
epoch 3, loss 0.000047
事实上，真实参数和通过训练得到的参数很接近：
print(f'w的估计误差: {
true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {
true_b - b}')
结果：
w的估计误差: tensor([ 0.0006, -0.0002], grad_fn=)
b的估计误差: tensor([0.0004], grad_fn=)