权重衰减----添加正则化(多层感知机)

权重衰减

权重衰减，也即模型正则化操作，L2正则化的目的就是为了让权重衰减到更小的值，在一定程度上减少模型出现过拟合的问题。

权重衰减的理解

模型未进行正则化操作时，损失函数(这里我们假设为均方损失函数)的公式为

$$L(w,b)=\frac{1}{n}\sum _{i=1}^n\frac{1}{2}(w^T{x}_i+b-y_i{)}^2$$

现在我们加入 $L2$ 正则化，即 $\frac{\gamma }{2}||w|{|}^2$ ,此时的代价函数即为

$$L(w,b)+\frac{\gamma }{2}||w|{|}^2=\frac{1}{n}\sum _{i=1}^n\frac{1}{2}(w^T{x}_i+b-y_i{)}^2+\frac{\gamma }{2}||w|{|}^2$$

现在对上面的式子进行求偏导，可得新的 $L2$ 正则化回归的小批量随机梯度下降更新如下式

其中 $\eta$ 代表学习率(大于0)，$\gamma$ 代表正则化程度，可以清晰看到 $(1-\eta \gamma )<=1$，所以更新权重之后，权重是在衰减的，权重衰减意味着忽略某些特征带来的影响，模型将变得简单()，有效降低了过拟合程度，所以模型会更加稳定，泛化程度也更好。

高维线性回归

我们通过一个简单的例子来掩饰权重衰减。

import torch
from torch import nn
from d2l import torch as d2l

首先，我们像以前一样生成一些数据，生成公式如下

$$y=0.05+\sum _{i=1}^{d}0.01x_i+ϵϵ-N(0,0.01^2)$$

我们选择标签是关于输入的线性函数。 标签同时被均值为0，标准差为0.01高斯噪声破坏。 为了使过拟合的效果更加明显，我们可以将问题的维数增加到 $d=200$ ， 并使用一个只包含20个样本的小训练集。

#定义训练集样本个数，测试集样本个数，特征个数、小批量数据集大小
n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5

#生成真实的权重向量w、偏置量b
true_w, true_b = torch.ones((num_inputs, 1)) * 0.1, 0.05

#获取训练集迭代器
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)

#获取测试集迭代器
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size)

从零开始实现

下面我们将从头开始实现权重衰减，只需将 $L2$ 的平方惩罚添加到原始目标函数中。

初始化模型参数

首先，我们将定义一个函数来随机初始化模型参数。

def init_params():
    #正态分布的权重 w
    w = torch.normal(0, 1, size=(num_inputs, 1), requires_grad=True)
    
    #偏置量b初始化为 0
    b = torch.zeros(1, requires_grad=True)
    
    return [w,b]
'
运行
运行

定义$L_2$范数惩罚

实现这一惩罚最方便的方法是对所有项求平方后并将它们求和。

#返回w向量的L2范数惩罚
def l2_penalty(w):
    return torch.sum(w.pow(2)) / 2 
'
运行
运行

定义训练代码实现

下面的代码将模型拟合训练数据集，并在测试数据集上进行评估。 之前的线性网络和平方损失没有变化， 所以我们通过d2l.linreg和d2l.squared_loss导入它们。 唯一的变化是损失现在包括了惩罚项。

#训练带有L2范数的模型
def train(lambd):
    w, b = init_params()                #初始化参数权重w,偏置b
    
    """
    简单来说，编程中提到的 lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。
    """
    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss
    
    num_epochs, lr = 100, 0.003        #定义迭代次数和学习率
    
    #绘图工具类
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log', xlim=[5, num_epochs], legend=['train', 'test'])
    
    #进行100次迭代训练
    for epoch in range(num_epochs):
        for X,y in train_iter:
            
            # 增加了L2范数惩罚项，
            # 广播机制使l2_penalty(w)成为一个长度为batch_size的向量
            l = loss(net(X), y) + lambd * l2_penalty(w)                     #计算代价函数，包含正则化结果
            l.sum().backward()                                                    #进行反向传播，计算权重w和偏置的梯度
            d2l.sgd([w,b], lr, batch_size)                                        #更新参数w和偏置b
        
        if epoch % 5 == 0:
            
            #注意，此时的evaluate_accuracy()包含三个参数，分别为神经网络net, 数据集train_iter, 损失函数loss
            animator.add(epoch+1, (d2l.evaluate_loss(net, train_iter, loss),
                                  d2l.evaluate_loss(net, test_iter, loss)))
            
    #torch.norm(w)代表w的L2范数
    print('w的L2范数是：', torch.norm(w).item())
'
运行
运行

忽略正则化直接训练

我们现在用lambd = 0禁用权重衰减后运行这个代码。 注意，这里训练误差有了减少，但测试误差没有减少， 这意味着出现了严重的过拟合。

train(lambd=0)

w的L2范数是： 12.695174217224121

使用权重衰减

下面，我们使用权重衰减来运行代码。 注意，在这里训练误差增大，但测试误差减小。 这正是我们期望从正则化中得到的效果。

train(lambd=3)

w的L2范数是： 0.5665048956871033

简洁实现

由于权重衰减在神经网络优化中很常用， 深度学习框架为了便于我们使用权重衰减， 将权重衰减集成到优化算法中，以便与任何损失函数结合使用。 此外，这种集成还有计算上的好处， 允许在不增加任何额外的计算开销的情况下向算法中添加权重衰减。 由于更新的权重衰减部分仅依赖于每个参数的当前值， 因此优化器必须至少接触每个参数一次。

定义模型

在下面的代码中，我们在实例化优化器时直接通过weight_decay指定weight decay超参数。 默认情况下，PyTorch同时衰减权重和偏移。 这里我们只为权重设置了weight_decay，所以偏置参数 $b$ 不会衰减。

#简洁实现附带L2正则化的模型函数
def train_concise(wd):
    
    net = nn.Sequential(nn.Linear(num_inputs, 1))         #定义线性网络模型
    
    #标准正态分布函数初始化线性模型参数
    for param in net.parameters():
        param.data.normal_()
        
    loss = nn.MSELoss(reduction='none')                   #定义均方损失函数
    num_epochs, lr = 100, 0.003                           #定义迭代训练次数与学习率
    
    #定义模型优化方法，其中net[n].weight代表第n层的权重, net[n].bias
    updater = torch.optim.SGD([
        {"params":net[0].weight, "weight_decay":wd},
        {"params":net[0].bias}], lr=lr)
    
    #定义绘图对象
    animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
                           xlim=[5,num_epochs], legend=['train', 'test'])
    
    for epoch in range(num_epochs):
        for X,y in train_iter:
            updater.zero_grad()                            #清空之前累积的梯度
            l = loss(net(X), y)                            #计算预测值与真实值的损失
            l.mean().backward()                            #反向传播计算梯度
            updater.step()                                 #更新梯度
            
        if (epoch+1) % 5 == 0:
            
            animator.add(epoch+1, (d2l.evaluate_loss(net, train_iter, loss),
                                  d2l.evaluate_loss(net, test_iter, loss)))
            
    #norm()函数表示范式
    print('w的L2范数:', net[0].weight.norm().item())
            
            
'
运行
运行

忽略正则化直接训练

我们现在用lambd = 0禁用权重衰减后运行这个代码。 注意，这里训练误差有了减少，但测试误差没有减少， 这意味着出现了严重的过拟合。

train_concise(wd=0)

w的L2范数: 12.607193946838379

使用权重衰减

train_concise(wd=3)

w的L2范数: 0.6688593626022339

小结

正则化是处理过拟合的常用方法：在训练集的损失函数中加入惩罚项，以降低学习到的模型的复杂度。

保持模型简单的一个特别的选择是使用 $L_2$ 惩罚的权重衰减。这会导致学习算法更新步骤中的权重衰减。

权重衰减功能在深度学习框架的优化器中提供。

在同一训练代码实现中，不同的参数集可以有不同的更新行为。