动手学深度学习--课堂笔记线性回归的从零开始实现

1.导入所需的包和模块

%matplotlib inline
import random
import torch
from d2l import torch as d2l

%matplotlib inline：内嵌绘图，将matplotlib的图表内嵌到Notebook里面，省略plt.show()

2.建立数据集（用有限样本的数据集来恢复模型的参数  ）

使用线性模型参数w=,b=4.2 和噪声项 ϵ 生成数据集及其标签： y = X w + b + ϵ

ϵ用来观测误差，服从均值为0的正态分布，是噪声项。

def synthetic_data(w, b, num_examples):  
    X = torch.normal(0, 1, (num_examples, len(w))) #标准正态分布N~（0，1），提取一个矩阵，矩阵的行数为num_examples,列数为len(w)
    y = torch.matmul(X, w) + b #y=Xw+b
    y += torch.normal(0, 0.01, y.shape) #y的值再加上随机噪声，即为一个均值为0，标准差为0.01的正态分布，矩阵的形状和y一样。再加上随即噪声是为了增加难度
    return X, y.reshape((-1, 1))#返回x的矩阵形状为（num_examples,*len(w)），y的矩阵形状为(num_examples)，y返回的是列向量

torch.normal（mean,std,*,generator=None,out=None):该函数返回从单独的正态分布中提取的随机数的张量，该正态分布的均值是mean，标准差是std.(注释：正态分布总是以平均值为中心，而曲线的宽度则由标准差（SD）决定）

torch.matmul():两个张量矩阵相乘，利用python中的广播机制，处理一些维度不同的tensor结构进行相乘操作。

3.代入真实值，生成数据集

数据集的目的是找到相对合适的b和w

labels(标签):试图预测的目标;features(特征):预测所依据的自变量；w:权重；b:偏移量

true_w = torch.tensor([2, -3.4])#权重为一个一维数组
true_b = 4.2#偏置量b
features, labels = synthetic_data(true_w, true_b, 1000)#运行synthetic_data函数来生成数据集，features为1000*2的二维矩阵，labels为一维数组

4. 查看具体的样本和散点图

print('features:', features[0],'\nlabel:', labels[0])#打印第一个样本和它的标号

d2l.set_figsize()#d2l包中的一个函数
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1);#features[:,1]表示特征的第一列即x,labels表示标签即y，1表示的是绘制原点的直径

plt.scatter()的原型为matplotlib.pyplot.scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None, *, data=None, **kwargs)：主要用于生成一个散点图

5.读取数据集

定义函数data_iter来获取小批量的数据，每个小批量包含一组特征和标签

def data_iter(batch_size, features, labels):
    num_examples = len(features)             #样本个数为特征图的数据长度,已知features是1000*2的矩阵，len(features)取第一维度长度
    indices = list(range(num_examples))          #建立列表存放样本，下标为0~num_examples-1
    random.shuffle(indices)                      #这些样本是随机读取的，没有特定的顺序
    for i in range(0, num_examples, batch_size):#i从0~num_examples中取值,每次跳batch_size大小
        batch_indices = torch.tensor(              #每次获取batch_size个索引
            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

random.shuffle():用于将个列表中的元素打乱顺序，只是将原列表的次序打乱，不会生成新的列表。

indices[i:min(i+batch_size,nu_examples)]:截取切片。开始位置为i，结束位置为min的返回值（i+batch_size,num_examples中值最小的）

yield:理解成return，带yield的函数是一个生成器，而不是一个函数，使用next（）就会从上次执行结束的地方继续执行

6.初始化模型参数

在进行优化模型之前要先定义一下参数，从均值为0，标准差为0.01的正态分布中来采样来初始化权重，将偏置初始化为0.

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

 w=torch.normal(0,0.01,size=(2,1),requires_grad=True):w为从标准正态分布N~（0，0.01）中提取一个2*1的向量，并可以进行梯度计算

b=torch.zeros(1,requires_grad=True):b为一个标量，并也可以进行梯度计算

注意：在初始化参数后，就要更新参数，直到这些参数足够拟合我们的数据，每次更新都需要计算损失函数关于模型参数的的梯度，而梯度就可以减小损失的方向更新每个参数。

7.定义模型:y=Xw+b

def linreg(X, w, b):  
    return torch.matmul(X, w) + b 

8.定义损失函数：(,)=.

def squared_loss(y_hat, y):  
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2#y_hat:预测值；y:真实值,并将预测值与真实值的形状转为相同的

9.定义优化算法

sgd函数主要用来更新参数

def sgd(params, lr, batch_size): #params包含w,b;lr为学习率；batch_size为小批量样本大小
    with torch.no_grad():
        for param in params:#对于列表params中的w或者b进行运算
            param -= lr * param.grad / batch_size
            param.grad.zero_()#手动设置为0，为下次计算做准备

with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源.

with torch.no_grad():在该模块下，所有计算结果为requires_grad=False，不调用Tensor.backward()时，减少计算所用的内存消耗

10.训练

lr = 0.03
num_epochs = 3   #对整个数据集扫描三次
net = linreg     #定义的线性模型
loss = squared_loss#定义损失函数

for epoch in range(num_epochs):                         #迭代训练3次
    for X, y in data_iter(batch_size, features, labels):#多次训练小批量数据集
        l = loss(net(X, w, b), y)  #把X，w,b放在net中形成预测值y;再与真实值y放在loss中做损失。l是一个大小为批量的向量
        l.sum().backward()#将l求和后求导
        sgd([w, b], lr, batch_size)  # 将小批量数据集更新
    with torch.no_grad():  #更新优化后进行评估，此时不需要梯度
        train_l = loss(net(features, w, b), labels)#将整个features，真实值w,真实值b做预测，再做损失
        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}')