零基础-动手学深度学习-3.2-3线性回归的代码实现

零基础生医转码，道行浅薄请见谅~

首先我们要用random，torch库，matplot画一下函数：

import matplotlib.pyplot as plt
#原文中%matplotlib inline 是jupyter notebook的魔法命令
import random
import torch
from d2l import torch as d2l

一、生成数据集

#定义生成噪声数据函数
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))
    #reshape确保 y 的形状是 (num_examples, 1)，使标签是一个独立的列，保持一致的维度结构。
    #同时注意这里的-1是自动监测其维度大小的意义

#生成数据集
true_w = torch.tensor([2, -3.4])
true_b = 4.2
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(),1);
#scatter绘制散点图
# .detach() 是 PyTorch 中用于分离张量的梯度计算。
#由于张量可能参与过某些计算图，使用 .detach() 来确保它不再参与梯度更新。
#但是李沐老师说这个detach是因为有些torch的版本需要把数据tach出来才能转到numpy中去
#.numpy() 是将 PyTorch 张量转换为 NumPy 数组。
plt.show()

二、读取数据集

#读取数据集
def data_iter(batch_size,features,labels):
    num_examples = len(features)#获取样本总数
    indices = list(range(num_examples))#生成样本索引列表，1-1000

    random.shuffle(indices)
    #打乱索引列表，因此老师这里标注了训练数据顺序是随机的
    
    for i in range(0,num_examples,batch_size)：
        batch_indices = torch.tensor(
        
        indices[i:min(i+batch_size,num_examples)])
        #对于每一个批次，提取索引中的部分元素，这些元素用于选择当前批次的数据
        #i:min(i+batch_size, num_examples)的作用是避免超出样本的总数
        #这些批次索引被转换为 PyTorch 张量，方便在后续的张量操作中使用
        
        yield features[batch_indices], labels[batch_indices]
        #使用了python生成器，每次返回一批数据
        #即从 features 和 labels 中提取与当前批次索引 batch_indices 对应的样本和标签。
        #生成器的好处是可以节省内存，因为它不会一次性将所有数据加载到内存中，而是按需生成。

三、初始化模型参数

w = torch.normal(0, 0.1, size=(2,1),requires_grad=True)
#requires_grad=True：
# 表示该张量在后续的计算中需要计算梯度。
# 这在神经网络训练中非常重要，因为我们希望在反向传播时能够根据损失函数对权重 w 进行更新
b = torch.zeros(1,requires_grad=True)

四、定义模型

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

六、定义优化算法

def sgd(params,lr,batch_size):
    #params：这是一个包含所有需要更新的模型参数（例如权重 w 和偏置 b）的列表或元组。
    # 每个参数都应该是 PyTorch 张量，并且 requires_grad=True，这样才能计算它们的梯度。
    with torch.no_grad():#torch.no_grad() 是一个上下文管理器，它告诉 PyTorch 在这个上下文中进行            
    的所有操作都不需要计算梯度。
        for param in params:
            #for param in params:：遍历所有需要更新的参数，params 通常包括模型的权重和偏置。
            param -= lr * param.grad / batch_size#核心步骤
            param.grad.zero_()
            #：在每次参数更新后，我们需要将该参数的梯度清零。
            #在 PyTorch 中，反向传播时计算的梯度会累积
            # 因此，如果不清除梯度，下一次计算梯度时，它会被累加到上一次的梯度中。

七、开始训练

#超参数设置
lr = 0.03
num_epochs = 3#训练轮数
net = linreg#将线性回归模型函数 linreg 赋值给 net。这个函数会接受输入特征 X 以及参数 w 和 b，并返回模型的预测结果。
loss = squared_loss

#训练循环
for epoch in range(num_epochs):#外层循环表示训练的轮数，即模型将会在数据集上重复多次训练，每个轮次会遍历所有数据一次。
    for X, y in data_iter(batch_size, features, labels):
        #内层循环从数据集中按 batch_size 逐批抽取数据，并进行参数更新。X 是当前批次的输入特征，y 
        是当前批次的标签。
        l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
        # 并以此计算关于[w,b]的梯度
        l.sum().backward()
        #将这些损失加和 l.sum()，然后调用 backward() 来计算损失函数对模型参数 w 和 b 的梯度。
        #backward() 会触发 PyTorch 的自动微分机制，计算 w.grad 和 b.grad。
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
        with torch.no_grad():
        #为了评估当前模型在整个数据集上的表现（训练误差），在这里我们不需要计算梯度，因此使用 
        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}')
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

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

#定义数据加载函数，data_arrays: 传入的特征和标签（features 和 labels）
def load_array(data_arrays, batch_size, is_train=True):  #@save
    """构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)
    #将特征和标签打包成一个 TensorDataset，这是 PyTorch 用于处理张量数据的常用形式。
    return data.DataLoader(dataset, batch_size, shuffle=is_train)
    #创建一个数据加载器，能够按批次加载数据。shuffle 参数控制是否在每个 epoch 之前对数据进行打乱。

batch_size = 10
data_iter = load_array((features, labels), batch_size)
# 调用 load_array 函数，生成一个数据迭代器，能够在后续训练过程中按批次获取数据。

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

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

net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

loss = nn.MSELoss()
trainer = torch.optim.SGD(net.parameters(), lr=0.03)

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X) ,y)
        trainer.zero_grad()
        #trainer.zero_grad(): 将模型的梯度缓存清零。
        # PyTorch 在每次计算梯度时是累积的，因此在每个批次计算之前，必须手动将梯度清零，否则会导致梯度累加，影响更新。
        l.backward()
        #无需手动sum了，因为这里MSE已经处理好了
        trainer.step()
        #trainer.step(): 调用优化器 trainer 来根据计算出的梯度更新模型的参数。这个步骤通常使用优化算法，比如随机梯度下降（SGD）、Adam 等。
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {l:f}')