【笔记】动手学深度学习-线性回归

 注：
期望(mean)（或均值，亦简称期望）：为试验中每次可能结果的概率乘以其结果的总和，是最基本的数学特征之一。它反映随机变量平均取值的大小。
方差：为各个数据与平均数之差的平方的和的平均数

梯度：数学上就是f(x,y)中，f对x的偏导和对y的偏导两者的和。图像上可以理解为指向f函数值最快增加方向。梯度讲解

 简洁实现

使用nn模具，和预处理模块来使得实现更为简单

1 

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)

2 调用框架特有的API读取数据，一次读取batch_size个样本

def load_array(data_arrays, batch_size, is_train=True):   #返回batch_size个样本
    """构造一个PyTorch数据迭代器。"""
    dataset = data.TensorDataset(*data_arrays) #将传入的特征和标签作为list传到TensorDataset里面得到一个pytorch的数据集（dataset）
    return data.DataLoader(dataset, batch_size, shuffle=is_train) #调用Dataloader每次从dataset里面挑选batch_size个样本出来（shuffle：是否随机）

batch_size = 10
data_iter = load_array((features, labels), batch_size) #将特征和标签传入load_array

next(iter(data_iter)) #转化成python的iter，在通过next函数

3 net

# `nn` 是神经网络的缩写
from torch import nn
net = nn.Sequential(nn.Linear(2, 1)) #输入维度为2（w），输出维度是1（label） 
#放入sequential容器内，其可以理解为list of layer，层组成的一个list 注：线性回归就一般就是只有一层

net[0].weight.data.normal_(0, 0.01) #net[0]表示第0层  .weight访问w  data就是w的值  .normal使用正态分布替换掉data的值
net[0].bias.data.fill_(0) #偏置b置为零

4 损失函数，计算均方误差使用的MSELoss类

loss = nn.MSELoss()

5 优化函数，“对应从零开始”的sgd函数

 在optim模具里面，需要传入至少两个参数

trainer = torch.optim.SGD(net.parameters(), lr=0.03) #net.parameters()：net里面的所有参数，包括w，b，然后指定学习率

6 训练

num_epochs = 3  
for epoch in range(num_epochs): #迭代3次
    for X, y in data_iter: #每次拿出一个小批量
        l = loss(net(X), y) #因为net自带参数，所以和之前不同的是不需要再传进去w和b
        trainer.zero_grad() #梯度清零
        l.backward() #计算梯度
        trainer.step() #调用step进行更新
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {l:f}')

从零开始实现

1 导入包

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

2 首先需要有一组需要去拟合的数据：所以生成一个带有噪声的人造数据集，将生成的数据保存在features和label向量中

def synthetic_data(w,b,num_examples): #定义函数，生成y=xw+b+噪音,1000个样本。其中wb为参数，x可以理解为利用正态分布随机生成的真实数据
    x=torch.normal(0,1,(num_examples,len(w))) #均值（期望）为0，方差为1的随机正态分布张量，生成数据。
    y=torch.matmul(x,w)+b
    y+=torch.normal(0,0.01,y.shape)  #噪音
    return x,y.reshape((-1,1)) #-1在前表示自己不知道是多少行，反正弄成一列

true_w=torch.tensor([2,-3.4]) #参数w b给定一个值
true_b=4.2
features,labels=synthetic_data(true_w,true_b,1000) #把synthetic_data函数返回的数据赋值给向量features和label

 3  

4 因为每次训练需要一定数量的样本，之前生成了许多样本不可能每次全部使用，所以需要一个函数提取部分样本用于训练：
定义一个data_iter函数，该函数接收一个小批量数据(batch_size为批量大小)
给我一些样本标号，每次随机从中选取b个样本返回出来，这样参与其他运算

def data_iter(batch_size,features,labels):
    num_examples=len(features) #样本数量n（num_example）
    indices=list(range(num_examples)) #转成list
    random.shuffle(indices) #把样本下标打乱，使之可以随机访问
    for i in range(0,num_examples,batch_size): #从0到n，间隔为batch_size
        #batch_indices表示就是一批的数量
        batch_indices=torch.tensor(indices[i:min(i+batch_size,num_examples)]) 
        yield features[batch_indices],labels[batch_indices] #产生并且返回batch_size个样本
        
batch_size=10

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

5 初始化参数

#初始化模型参数
w=torch.normal(0,0.01,size=(2,1),requires_grad=True) #w为一个二维向量
b=torch.zeros(1,requires_grad=True) #标量

6 函数定义

#定义线性回归模型
def linreg(x,w,b):
    return torch.matmul(x,w)+b

#定义损失函数
def squared_loss(y_hat,y): #y_hat为预测值，y为真实值
    return (y_hat-y.reshape(y_hat.shape))**2/2

#定义优化算法
def sgd(params,lr,batch_size): #patam为所有参数（list）包含w和b，lr为学习率，和batch_size批量大小 
    with torch.no_grad(): #不需要计算梯度
        for param in params:
            param-=lr*param.grad/batch_size #学习率*梯度/batch_size
            param.grad.zero_() #梯度设为0，为下一次计算    

7 训练

#训练过程
lr=0.03 #学习率
num_epochs=3 #数据扫3遍，3次回归运算
net=linreg 
loss=squared_loss #均方损失

for epoch in range(num_epochs): #进行3次训练
    for x,y in data_iter(batch_size,features,labels): #随机取出一定量（10个）样本到xy中
        l=loss(net(x,w,b),y) #net（也就是linreg）返回计算出的y的值，通过loss（squared_loss）计算损失，保存到长为批量大小的向量l中
        l.sum().backward() #算梯度（求导）
        sgd([w,b],lr,batch_size)
    with torch.no_grad(): #计算下损失（不需要计算梯度）
        train_1=loss(net(features,w,b),labels)
        print(f'epoch：{epoch + 1}, loss：{float(train_1.mean()):f}')

可以看到每一轮后损失值都在越来与小

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

 预测值和真实的w和b相比较可以发现两者相差已经很小