1. 基础知识

1.1 线性模型

线性模型可以看做是单层神经网络。
在这里插入图片描述

给定n维输入 $x=[x_1,x_2,\cdots,x_n]^T$ ，线性模型有一个n维权重 $w=[w_1,w_2,\cdots,w_n]$ 和一个标量偏差b，则模型的输出为：
$y=w_1x_1+w_2x_2+\cdots+w_nx_n+b=<w,x>+b$

1.2 模型评估

（1）平方损失MSE
假设y是真实值， $\hat{y}$ 是估计值，则平方损失为：
$\ell(y,\hat{y})=\frac{1}{2}(y-\hat{y})^2$

1.3 模型训练

假设有n个样本 $X=[x_1,x_2,\cdots,x_n]^T,y=[y_1,y_2,\cdots,y_n]^T$
损失函数
$\ell(X,y,w,b)=\frac{1}{2n}\sum_{i=1}^n(y_i-<x_i,w>-b)^2=\frac{1}{2n} \| y-Xw-b\|^2$

最小化损失函数
$w^*,b^*=\arg \min_{w,b} \ell(X,y,w,b)$

最优解
将偏差加入权重： $\leftarrow [X,1],w \leftarrow [w,b]^T$
$\ell(X,y,w)=\frac{1}{2n} \| y-Xw\|^2 \\ \frac{\partial}{ \partial w}\ell(X,y,w)=\frac{1}{n}(y-Xw)^TX$

因此最优解满足:
$\frac{1}{n}(y-Xw)^TX=0 \\ w^*=(X^TX)^{-1}X^Ty$

线性回归是对n维输入的加权和，外加偏差。线性回归有显示解。

1.4 优化方法——梯度下降

当问题没有显示解时，可以采用梯度下降法
步骤

挑选一个初始值 $w_0$
重复迭代参数 $t = 1, 2, 3$ ，更新参数值 $w_t=w_{t-1}-\eta \frac{\partial \ell}{\partial w_{t-1}}$

学习率 $\eta$ ： 步长的超参数

小批量随机梯度下降

每次计算梯度，都需要对损失函数求导。因为损失函数是对所有样本的平均，所有在整个训练集上算梯度太贵。
我们可以随机采样b个样本 $i_1,i_2,\cdots,i_b$ 来近似损失
$\frac{1}{b} \sum \ell(x_i,y_i,w)$
批量（batch）： 损失误差精度的超参数
在这里插入图片描述
小批量随机梯度下降是深度学习默认的求解算法。

2. 代码

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

2.1 构造人为数据集

# 构造人造数据集
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))

# 构造数据
true_w = torch.tensor([2, -3.4], dtype=torch.float32)
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)

2.2 构造Pytorch数据迭代器

# 构造一个Pytorch 数据迭代器
def load_array(data_arrays, batch_size, is_train = True):
    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)

2.3 初始化模型

# 初始化模型
net = nn.Sequential(nn.Linear(2, 1))   # Sequential is a list of layers
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)
# 误差计算
loss = nn.MSELoss()
# SGD
trainer = torch.optim.SGD(net.parameters(), lr = 0.03)

2.4 模型训练

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X), y)
        trainer.zero_grad()     # 梯度清零
        l.backward()            # 反向梯度计算
        trainer.step()          # 模型更新
    l = loss(net(features), labels)         # loss自动求和
    print(f'epoch {epoch + 1}, loss {l:f}')

代码总结

import imp
import torch
import numpy as np
from torch.utils import data
from d2l import torch as d2l
from torch import nn
# 构造人造数据集
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))
# 构造一个Pytorch 数据迭代器
def load_array(data_arrays, batch_size, is_train = True):
    dataset = data.TensorDataset(*data_arrays)     # 将列表元素分别当作参数传入
    return data.DataLoader(dataset, batch_size, shuffle=is_train)
# 构造数据
true_w = torch.tensor([2, -3.4], dtype=torch.float32)
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
# 获得数据迭代器
batch_size = 10
data_iter = load_array((features, labels), batch_size)
# 初始化模型
net = nn.Sequential(nn.Linear(2, 1))   # Sequential is a list of layers
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)
# 误差计算
loss = nn.MSELoss()
# SGD
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()     # 梯度清零
        l.backward()            # 反向梯度计算
        trainer.step()          # 模型更新
    l = loss(net(features), labels)         # loss自动求和
    print(f'epoch {epoch + 1}, loss {l:f}')