李沐笔记（线性回归）

一个简化模型（权重和偏差的实际值在后面决定）：

 线性模型：

 线性模型可以看做是单层神经网络（输入维度是d，输出维度是1，每个箭头表示一个权重））：

 衡量预估质量：

 训练数据：

 参数学习：

 显示解：

 

 总结：

 基础优化算法：

梯度下降：

 选择学习率：

不能太小（每一步的步伐有限，到达一个点需要很多步（很贵））

不能太大（震荡，没有向一个方向下降）

小批量随机梯度下降:

 选择批量大小：

 总结：

从零开始实现整个方法，包括数据流水线、模型。损失函数和小批量随机梯度下降优化器。

import matplotlib.pyplot as plt
import random
import torch
from d2l import torch as d2l

# 根据带有噪声的线性模型构造一个人造数据集,使用线性模型参数生成数据集及其标签(y=Xw+b+噪声项)
def synthetic_data(w, b, num_examples):
    """ 生成y=Xw+b+噪声 """
    X = torch.normal(0, 1, (num_examples, len(w)))  # 均值为0，方差为1的随机数，行数是n个样本，列数是w个特征
    y = torch.matmul(X, w) + b
    y += torch.normal(0, 0.01, y.shape)   # 加入随机噪音，均值为0，方差为0.01
    return X, y.reshape((-1, 1))  # -1指行数自动推导，1指一列

true_w = torch.tensor([2,-3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)  # 生成特征和标注

# features中每一行都包含一个二维数据样本，labels中的每一行都包含一维标签值（一个标量）
print('features:', features[0], '\nlabel:', labels[0])

d2l.set_figsize()
# scatter(x,y,sz):绘制散点图,sz指定为长度等于 x和 y的长度的向量
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1)
d2l.plt.show()

# 定义一个data_iter函数，接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量
# 读取数据
def data_iter(batch_size, features, labels):
    num_examples = len(features)  # 多个样本
    indices = list(range(num_examples))
    # 这些样本是随机读取的，没有特定的顺序
    random.shuffle(indices)  # 打乱序列中的元素
    # 0到 n每次跳 batch_size
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i:min(i + batch_size, num_examples)])  # 从i开始到i+batch_size拿 b个indices
        yield features[batch_indices], labels[batch_indices]   # yield相当于return，不断调用返回直到完成

batch_size = 10

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

# 定义初始化模型参数
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   # 按元素做减法再平方再除法

# 定义优化算法(参数（list）、学习率、batch_size)
def sgd(params, lr, batch_size):
    """小批量随机梯度下降"""
    # 更新时不需要计算梯度
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()   # 梯度设置为 0

# 训练过程
lr = 0.03    # 学习率
num_epochs = 3   # 三次
net = linreg    # 模型
loss = squared_loss   # 均方损失

# 第一层是对每个数据扫一遍
for epoch in range(num_epochs):
    # 每次拿出一个批量大小的 X和 y
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)   #将X，w，b放进net中做预测，然后预测y与真实y做损失
        # 损失就是长为一个批量大小的向量（‘batch_size’,1）
        l.sum().backward()  # 求和之后算梯度
        sgd([w, b], lr, batch_size)   # 对w，b进行更新
    # 评价进度，不需要计算梯度
    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

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

# 调用框架中现有的API来读取数据
def load_array(data_arrays, batch_size, is_train=True):
    """构造一个pytorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)  # 将X和 y传进去
    # 得到数据集之后调用DataLoader
    # shuffle:是不是需要随机打乱顺序
    return data.DataLoader(dataset,batch_size,shuffle=is_train)

batch_size = 10
data_iter = load_array((features, labels), batch_size)

print(next(iter(data_iter)))   # 得到x和y

# 使用框架的预定义好的层
from torch import nn

net = nn.Sequential(nn.Linear(2,1))   # 输入和输出的维度

# 初始化模型参数
# net[0]访问linear，.weight访问w，.data真实值，normal_使用正态分布替换掉data值
print(net[0].weight.data.normal_(0,0.01))
# bias偏差设置为0
print(net[0].bias.data.fill_(0))

# 计算均方误差使用的是MSELoss类（L2范数）
loss = nn.MSELoss()

# 实例化SGD实例
# net.parameters():所有的参数
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)  # net本身带有模型参数
        trainer.zero_grad()   # 梯度清零
        l.backward()
        trainer.step()    # 模型更新
    l = loss(net(features), labels)
    print(f'epoch{epoch+1}, loss {l:f}')