使用权重衰减缓解模型过拟合

高维线性回归实验

# 导入包和模块
%matplotlib inline
import torch
import torch.nn as nn
import numpy as np
import sys
sys.path.append("..")
import d2lzh_pytorch as d2l

print(torch.__version__)

# 定义训练集，测试集和输入特征数
n_train, n_test, num_inputs = 20,100, 200
# 设定权重，偏差的值
true_w, true_b = torch.ones(num_inputs, 1) * 0.01, 0.05
# 随机模拟训练集和测试集样本
features = torch.randn((n_train + n_test, num_inputs))
# 随机模拟标签和噪声项
labels = torch.matmul(features, true_w) + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()),
                      dtype=torch.float)
# 切割训练集和测试集
train_features, test_features = features[:n_train, :], features[n_train:, :]
train_labels, test_labels = labels[:n_train], labels[n_train:]

从零开始实现

# 随机初始化模型的参数，追踪梯度
def init_params():
#     初始化w：标准正态分布向量
    w = torch.randn((num_inputs, 1), requires_grad=True)
#     初始化b：全0标量
    b = torch.zeros(1, requires_grad=True)
    return [w, b]

定义L2惩罚项

# 定义L2惩罚项：（1/2）w范数的平方
def l2_penalty(w):
    return (w**2).sum() / 2

定义训练和测试

# 设定批量大小，训练周期和学习率
batch_size, num_epochs, lr = 1, 100, 0.003
# 定义模型，损失函数
net, loss = d2l.linreg, d2l.squared_loss
#  输入训练集
dataset = torch.utils.data.TensorDataset(train_features, train_labels)
train_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=True)
# 定义模型和作图函数
def fit_and_plot(lambd):
    w, b = init_params() #初始化w和b
    train_ls, test_ls = [], []  #训练和测试误差设为空列表
#     对周期进行循环
    for _ in range(num_epochs):
        for X, y in train_iter:
            l = loss(net(X, w, b), y) + lambd * l2_penalty(w)
            l = l.sum()
#             反向传播
            if w.grad is not None:
                w.grad.data.zero_()
                b.grad.data.zero_()
            l.backward()
            d2l.sgd([w, b], lr, batch_size) # 采用随机梯度下降算法
#             将误差添加到列表
        train_ls.append(loss(net(train_features, w, b),
                            train_labels).mean().item())
        test_ls.append(loss(net(test_features, w, b),
                            test_labels).mean().item())
#         绘制误差曲线
    d2l.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
               range(1, num_epochs + 1), test_ls, ['train', 'test'] )
    print('L2 norm of w:', w.norm().item())# 输出w的范数值

观察过拟合

fit_and_plot(lambd=0)  
# 训练集误差远小于测试集误差

使用权重衰减

fit_and_plot(lambd=3)  
# 过拟合现象有所缓解

简洁实现

# wd为权重衰减参数，相当于lambd
def fit_and_plot_pytorch(wd):
    net = nn.Linear(num_inputs, 1)
    nn.init.normal_(net.weight, mean=0, std=1)
    nn.init.normal_(net.bias, mean=0, std=1)
#     衰减权重参数
    optimizer_w = torch.optim.SGD(params=[net.weight],
                                 lr=lr, weight_decay=wd)
#     衰减偏差参数
    optimizer_b = torch.optim.SGD(params=[net.bias], lr=lr)
    
    train_ls, test_ls = [], []
    for _ in range(num_epochs):
        for X, y in train_iter:
            l = loss(net(X), y).mean()
#             梯度清零
            optimizer_w.zero_grad()
            optimizer_b.zero_grad()
            
            l.backward()
#             更新权重和偏差
            optimizer_w.step()
            optimizer_b.step()
#             将每次误差添加到列表中
        train_ls.append(loss(net(train_features),
                            train_labels).mean().item())
        test_ls.append(loss(net(test_features),
                   test_labels).mean().item())
#         绘制误差曲线 
    d2l.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
               range(1, num_epochs + 1), test_ls, ['train', 'test'])
#         输出w的范数值                    
    print('lambda:', wd, '\n','L2 norm of w:', net.weight.data.norm().item(),)

fit_and_plot_pytorch(0)
# 训练集误差远小于测试集误差

fit_and_plot_pytorch(3)
# 过拟合现象有所缓解