李沐08线性回归和基础算法优化——自学笔记

线性回归简化模型

1. 输入、权重、偏差、输出
   给定n维输入： x=[x1, x2,…,xn]^T
   线性模型有一个n维权重和一个标量偏差： w=[w1, w2, …,wn]^T, b
   输出是输入的加权和： y=w1x1+w2x2+…+wnxn+b
   向量版： y=<w,x>+b

2. 平方损失：比较真实值和预估值

假设y是真实值，y^是估计值
l(y,y^)=0.5*(y-y)^2

3. 训练数据:收集一些数据点来决定参数值（权重和偏差，过去的值）

训练数据通常越多越好，假设有n个样本
X=[x1, x2, …,xn]^T
Y=[y1, y2, …,yn]^T

4. 训练损失

l(X,y,w,b)=1/2n * ||y-Xw-b||^2

5. 最小化损失来学习参数：找到w和b使得损失最小

w*,b*= {argmin(w,b) l(X,y,w,b)}

6. 最优解

w*=(X^TX)(-1) * X^T * y

7. 总结：

线性回归是n维输入的加权，外加偏差。
使用平方损失来衡量预测值和真实值的差异。
线性回归有显示解。
线性回归可以看作是单层神经网络。

基础优化方法

1. 梯度下降

挑选一个随机的初始值w0
不断更新w0，使之接近最优值
沿着梯度方向将增加损失函数值（梯度，上升最快的方向，负梯度：下降最快的方向）
学习率：步长的超参数，不能太小也不能太大

2. 小批量随机梯度下降

在整个训练集上算梯度太贵：一个深度神经网络模型可能需要数分钟甚至数小时
我们可以随机采样b个样本i1, i2,…,ib来近似损失
b是批量大小，另一个重要的超参数：不能太大，也不能太小

总结：

梯度下降通过不断沿着反梯度方向更新参数求解
小批量随机梯度下降是深度学习默认的求解算法
两个重要的超参数是批量大小和学习率

线性回归从零实现

从零实现整个方法：数据流水线、模型、损失函数、小批量随机梯度下降优化器

# matplotlib inline   # plot.show可以在pycharm里面显示图形
import random
import torch
from d2l import torch as d2l

根据带有噪音的线性模型，构造一个人造数据集。我们使用线性模型参数y=Xw+b+c,w=[2,-3.4]^T、b=4.2和噪声项c

def synthetic_data(w, b, num_examples):
    '''生成y=Xw+b+噪声 '''
    X = torch.normal(0,1,(num_examples,len(w)))  # 均值为0，标准差1的随机数，n个样本，大小是w的长度
    # X是个矩阵，行数表示多少个样本，；列数表示feature
    # normal是高斯分布
    y = torch.matmul(X,w)+b   # matmul: 矩阵乘法
    y+= torch.normal(0,0.01,y.shape)  # 此处是+随机噪声，形状和y一样
    return X,y.reshape((-1,1))  # X和y做成列向量返回（1列）

true_w = torch.tensor([2, -3.4])  # 真实的w
true_b = 4.2                      # 真实的b
features, labels=synthetic_data(true_w,true_b,1000)  # 函数synthetic_data生成特征和标号

补充：
reshape(1,-1)转化成1行；reshape(2,-1)转换成两行；
reshape(-1,1)转换成1列；reshape(-1,2)转化成两列
reshape(2,8)转化成两行八列

print('features: ', features[0], '\nlabels: ',labels[0])  # 第0个

# 为什么features有两个？
# 因为w=[2,-3.4]^T，X是一个 n*2 的矩阵，y是一个列表，后面转化为一个列向量

features:  tensor([ 0.1912, -0.3895]) 
labels:  tensor([5.8964])

d2l.set_figsize()    # 画图
d2l.plt.scatter(features[:,1].detach().numpy(),
               labels.detach().numpy(),1);   # 特征的第一列，detach()分离出数值，不再含有梯度
                                             # 最后的1表示散点面积

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=output_19_0.svg&p

定义一个data_iter函数，函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量

def data_iter(batch_size, features, labels):  # batch_size：批量大小、特征、标号
    num_examples=len(features)   # 样本数量
    indices=list(range(num_examples))  # 生成样本的indices，从0->n-1，转成python的list
    # 这些样本是随机读取，没有特定顺序
    random.shuffle(indices)           # 将下标随机打乱，因为可以用随机数访问样本
    for i in range(0,num_examples,batch_size):  # 从0开始，到n-1个样本，步长batch_size
        batch_indices=torch.tensor(
            indices[i:min(i+batch_size, num_examples)])  # min是因为i+batch_size可能会索引样本总量
        yield features[batch_indices], labels[batch_indices]  # yield循环每次返回一个features[]和labels[]
        
batch_size=10

for X, y in data_iter(batch_size,features,labels):
    print(X, '\n',y)
    break

tensor([[-1.6475,  1.8882],
        [ 0.4207,  0.4279],
        [-1.0449,  0.2339],
        [-1.0493,  1.0297],
        [ 1.7010,  0.1680],
        [-0.0903,  0.0558],
        [-0.6283, -1.9998],
        [ 0.9666, -1.2313],
        [-0.3562,  0.2566],
        [ 0.7690, -0.4405]]) 
 tensor([[-5.4932],
        [ 3.5779],
        [ 1.3211],
        [-1.3796],
        [ 7.0509],
        [ 3.8366],
        [ 9.7523],
        [10.3106],
        [ 2.6285],
        [ 7.2362]])

定义初始化模型参数

w=torch.normal(0,0.01,size=(2,1),requires_grad=True)  # 正态分布，计算需记录
b=torch.zeros(1,requires_grad=True)  #偏差

定义模型

def linreg(X,w,b):
    '''线性回归模型'''
    return torch.matmul(X,w)+b

定义损失函数

def squared_loss(y_hat,y):
    '''均方损失'''
    return (y_hat-y.reshape(y_hat.shape))**2/2

定义优化算法

def sgd(params,lr,batch_size):
    '''小批量随机梯度下降'''
    with torch.no_grad():
        for param in params:
            param-=lr*param.grad/batch_size  # param.grad是梯度
            param.grad.zero_()  # 手动把梯度设置0，下一次计算不会和上一个梯度相关

训练过程

# 指定超参数
lr=0.03              # 学习率
num_epochs=3         # 整个数据扫3遍
net=linreg           # 模型：线性回归
loss=squared_loss    # 均方损失

for epoch in range(num_epochs):    # 每次数据扫1遍
    for X,y in data_iter(batch_size,features,labels):  # 拿出批量大小的X和y
        l=loss(net(X,w,b),y)  # X和y都是小批量损失，net(X,w,b)得到的是预测值Y，将Y和y进行比较得到损失l
        # 因为l形状是(batch_size,1)，而不是一个标量，l中的元素都被加到
        l.sum().backward()   # # 并以此计算关于[w,b]的梯度
        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}')
        
        # 出现loss nan：学习率太大了，超出范围

epoch 1,loss 0.047039
epoch 2,loss 0.000207
epoch 3,loss 0.000055

比较真实参数和通过训练学到的参数来评估训练的成功程度

print(f'w的估计误差： {true_w-w.reshape(true_w.shape)}')
print(f'b的估计误差：{true_b-b}')

w的估计误差： tensor([-0.0002, -0.0007], grad_fn=<SubBackward0>)
b的估计误差：tensor([0.0005], grad_fn=<RsubBackward1>)

线性回归的简洁实现

通过深度学习框架来简洁实现线性回归模型，生成数据集

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)

def load_array(data_arrays,batch_size,is_train=True):  
    # is_train=True时，表示系统处于训练状态，可以进行模型的训练和参数的更新。
    # is_train=False时，表示系统处于推理或者测试状态，不再进行模型的训练，而是使用已经训练好的模型进行推理或者测试。
    '''构造一个python数据迭代器'''
    dataset=data.TensorDataset(*data_arrays)  # 得到pytorch的dataset
    return data.DataLoader(dataset,batch_size,shuffle=is_train)  # DataLoader可以每次从中随机抽取batch_size个样本
                                                                 # shuffle: 是不是要随机打乱顺序？通过打乱数据的顺序，可以减少模型对数据的记忆和依赖，提高模型的泛化能力。

batch_size=10
# batchsize：批量大小。在深度学习中，一般采用SGD训练，即每次训练在训练集中取batchsize个样本训练；
# iteration：1个iteration等于使用batchsize个样本训练一次；
# epoch：1个epoch等于使用训练集中的全部样本训练一次。
data_iter=load_array((features,labels),batch_size)  # 1.先有了features和labels，传到TensorDataset

next(iter(data_iter))  # iter() 是一个内置函数，用于获取一个可迭代对象的迭代器。
                       # next() 是一个内置函数，用于获取迭代器的下一个元素。迭代器是一种可以逐个访问元素的对象。

[tensor([[ 0.3695,  0.8742],
         [-0.8576,  0.8135],
         [-0.2910, -0.6900],
         [-2.5741, -0.9491],
         [-0.9522,  0.7102],
         [ 0.9828,  0.0169],
         [-1.3844,  1.3968],
         [ 0.0194,  0.5305],
         [ 0.9125, -1.8712],
         [-0.3130,  0.6654]]),
 tensor([[ 1.9491],
         [-0.2733],
         [ 5.9796],
         [ 2.2876],
         [-0.1144],
         [ 6.1107],
         [-3.2957],
         [ 2.4370],
         [12.3972],
         [ 1.2990]])]

使用框架的预定好的层

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

net=nn.Sequential(nn.Linear(2,1))  # Sequential: list of layers, 按顺序放好的层

初始化模型参数：初始化权重和偏差

net[0].weight.data.normal_(0,0.01)  # weight:w, data:真实data, normal_:使用正态分布替换data的值
net[0].bias.data.fill_(0)  # 偏差设置成0

tensor([0.])

计算均方误差使用MSELoss，也称为平方范数

loss=nn.MSELoss()

实例化SGD实例

trainer=torch.optim.SGD(net.parameters(),lr=0.03)  # 传入2个参数：w和b(net.parameters)，学习率lr

训练过程（和从零实现很相似）

num_epochs=3    # 3个周期
for epoch in range(num_epochs):
    for X, y in data_iter:
        l=loss(net(X),y)  # net本身带了模型参数w和b，所以不需要再写
        trainer.zero_grad()  # 优化器把梯度清零
        l.backward()         # 求梯度
        trainer.step()      # 模型更新
    l=loss(net(features),labels)
    print(f'epoch{epoch+1}, loss {l:f}')  # loss是从L到f，不是1到f

epoch1, loss 0.000104
epoch2, loss 0.000103
epoch3, loss 0.000104