3.2&3.3 线性回归的从零开始实现|Pytorch简洁实现

学习链接：李沐老师的动手深度学习v2书、视频链接

代码部分的理解笔记。

• 1、生成数据
  2、读取数据集
  3、初始化模型参数
  4、定义模型
  5、定义损失函数
  6、定义优化算法
  7、训练

import random
import torch
from d2l import torch as d2l

# 1、生成数据
# 根据给定参数，生成带噪音的训练数据集
def synthetic_data(w, b, num_examples):

    X = torch.normal(mean=0, std=1, size=(num_examples, len(w)))
    # 以期望为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)) 
    # .reshape((-1,1))的-1是自动划分的意思，比如此处就是num_examples/1=num_examples

# 给定参数
true_w = torch.tensor([2, -3.4])
true_b = 4.2
# 生成1000个数据（X,y）
features, labels = synthetic_data(true_w, true_b, 1000)

# 看看生成的第一个数据
print('features:', features[0],'\nlabel:', labels[0])

d2l.set_figsize()
d2l.plt.scatter(features[:, (1)].detach().numpy(), labels.detach().numpy(), s=1)
# .detach()将torch的数据从计算图中剥离出来才能转换成numpy格式
# s=1是指图像散点的大小
# features[:,(1)]是只取第一列的数据出来画图
d2l.plt.show()
# VSCode需要上面的语句才能出现图像

# 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): # i步长为batch_size
        batch_indices = torch.tensor(indices[i : min(i + batch_size, num_examples)])
        # 以防最后一批的数据不够batch_size，这个处理好酷，i了i了~
        yield features[batch_indices], labels[batch_indices]
        # yeild以迭代器的方式，每调用一次，跑到下一个yeild的位置停止，直到函数结尾跳出for循环

batch_size = 10
# 看下第一个batch的数据
for X, y in data_iter(batch_size, features, labels):
    print(X, '\n', y)
    break

# 3、初始化模型参数
# 先随机初始化参数，之后用生成的数据训练出来
w = torch.normal(0, 0.01, size= (2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

# 4、定义模型
# 线性回归模型， 相当于神经网络的一层全连接层
def linreg(X, w, b):
    return torch.matmul(X, w) + b

# 5、定义损失函数
# 均方误差，本来应该还要除以批次大小求平均，这里在下面步骤**中做了
def squared_loss(y_hat, y):
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

# 6、定义优化算法
# SGD stochastic gradient descent随机梯度下降
def sgd(params, lr, batch_size):
    # with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，
    # 比如文件使用后自动关闭／线程中锁的自动获取和释放等。
    with torch.no_grad(): 
    # 更新参数的时候不需要计算梯度
        for param in params:
            param -= lr * param.grad / batch_size # 步骤**
            param.grad.zero_()
            # pytorch会不断的累加变量的梯度，所以每更新一次参数，就要让其对应的梯度清零

# 7、训练
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) # 计算这一批次的损失
        l.sum().backward()
        # 或者可以l.backward(torch.ones_like(l))
        # B站弹幕：求和本身让l以标量的形式表现出来。求梯度，对于l中的每一个分量都是单独求的。
        #         官方解释：如果需要计算导数，可以在Tensor上调用.backward()。		
        #  1. 如果Tensor是一个标量（即它包含一个元素的数据），则不需要为backward()指定任何参数
        #  2. 但是如果它有更多的元素，则需要指定一个gradient参数，它是形状匹配的张量。
        # 码一下链接：https://www.cnblogs.com/JeasonIsCoding/p/10164948.html
        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}')

运行结果：

import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l

# 1、生成数据集
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

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

# 3、定义模型
from torch import nn
# Sequential类将多个层串联在一起。 
# 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入
# 在PyTorch中，全连接层在Linear类中定义。 
# 第一个指定输入特征形状，即2，第二个指定输出特征形状，输出特征形状为单个标量，因此为1。
net = nn.Sequential(nn.Linear(2, 1))

# 4、初始化模型参数
# net[0]选择网络中的第一个图层
# 使用weight.data和bias.data方法访问参数
# 使用替换方法normal_和fill_来重写参数值
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

# 5、定义损失函数
# 计算均方误差使用的是MSELoss类，也称为平方L2范数。
loss = nn.MSELoss()

# 6、定义优化算法
# yTorch在optim模块中实现了该算法的许多变种。 
# 当我们实例化一个SGD实例时，我们要指定优化的参数 （可通过net.parameters()从我们的模型中获得）以及优化算法所需的超参数字典。
trainer = torch.optim.SGD(net.parameters(), lr=0.03)

# 7、训练
num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        # 通过调用net(X)生成预测并计算损失l（前向传播）。
        l = loss(net(X), y)
        trainer.zero_grad() # 梯度清零
        # 通过进行反向传播来计算梯度。此时loss中已经求了sum。
        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)