使用均方范数作为硬性限制

  使用限制参数值的选择范围来控制模型容量

  通常不限制偏移b（限不限制都差不多）
  小的θ意味着更强的正则项

使用均方范数作为柔性限制

对每个θ，都可以找到λ使得之前的目标函数等价于下面。

可以通过拉格朗日乘子来证明
超参数λ控制了正则项的重要程度
    λ=0：无作用
    λ→∞，$w^{\ast }$→0

演示最优解的影响

①绿色的线就是原始损失函数l的等高线，优化原始损失l的最优解(波浪号即最优解)在中心位置。

②当原始损失加入二分之λ的项后，这个项是一个二次项，假如w就两个值，x1(横轴)、x2(纵轴)，那么在图上这个二次项的损失以原点为中心的等高线为橙色的图所示。所以合并后的损失为绿色的和黄色的线加一起的损失。

③当加上损失项后，可以知道原来最优解对应的二次项的损失特别大，因此原来的最优解不是加上二次项后的公式的最优解了。若沿着橙色的方向走，原有l损失值会大一些，但是二次项罚（penalty→惩罚）的损失会变小，当拉到平衡点以内时，惩罚项减少的值不足以原有l损失增大的值，这样w * 就是加惩罚项后的最优解。

④ 损失函数加上正则项成为目标函数，目标函数最优解不是损失函数最优解。正则项就是防止达到损失函数最优导致过拟合，把损失函数最优点往外拉一拉。鼓励权重分散，将所有额特征运用起来，而不是依赖其中的少数特征，并且权重分散的话它的内积就小一些。

⑤ l2正则项会对大数值的权值进行惩罚。

---

参数更新法则

计算梯度:

时间t更新参数：
让损失函数减低就往梯度的反方向走，所以需要减去梯度。

所以

通常ηλ<1在深度学习中通常叫做权重衰退
把$w_{t+1}$=$w_t$-η梯度看成向量-η梯度表示的是沿着梯度这个向量反方向变化。

总结

权重衰退通过L2正则项使得模型参数不会过大，从而控制模型复杂度。
正则项权重是控制模型复杂度的超参数。

---

高纬线性回归

演示一下权重衰减，为了使过拟合的效果更加明显，我们可以将问题的维数增加到 𝑑=200 ， 并使用一个只包含20个样本的小训练集。

import torch
from torch import nn
from d2l import torch as d2l
n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5
true_w, true_b = torch.ones((num_inputs, 1)) * 0.01, 0.05
# 生成合成数据，每个样本生成一个随机的输入特征向量x以及对应的标签y
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)
# 生成数据迭代器，将train_data划分为大小为batch_size的多个批次
# 每次迭代时产生一个批次的样本，直到所有的样本都被遍历完为止
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size, is_train=False)

多项式的权重衰退从零开始实现

初始化模型参数

def init_params():
    w = torch.normal(0, 1, size=(num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    return [w, b]

定义L2范数惩罚

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

def l2_penalty(w):
    return torch.sum(w.pow(2)) / 2

定义训练代码实现

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

def train(lambd):
    w, b = init_params()
    # 用lambda匿名函数定义net，输入为X，输出为d2l.linreg(X, w, b)
    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'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
        	# lambd是L2正则化项系数，是为了调整正则化的强度
            # 增加了L2范数惩罚项，
            # 广播机制使l2_penalty(w)成为一个长度为batch_size的向量
            l = loss(net(X), y) + lambd * l2_penalty(w)
            l.sum().backward() # 对参数进行反向传播，以计算权重和偏置的梯度。
            d2l.sgd([w, b], lr, batch_size) # 使用SGD更新权重和偏置
        if (epoch + 1) % 5 == 0:
        	# 每5轮将训练集和测试集上的损失添加到animator中
            animator.add(epoch + 1, (d2l.evaluate_loss(net, train_iter, loss),
                                     d2l.evaluate_loss(net, test_iter, loss)))
    # .item() 方法用于将包含单个元素的张量转换为 Python 标量（普通的整数或浮点数）
    print('w的L2范数是：', torch.norm(w).item())

忽略正则化直接训练

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

train(lambd=0)

输出：

使用权重衰减

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

train(lambd=3)

输出：

之间还是有一定的过拟合，大约在50轮后，就开始缓和了。

从零开始代码实现

import torch
from d2l import torch as d2l


def init_params():
    w = torch.normal(0, 1, size=(num_inputs, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    return [w, b]


def l2_penalty(w):
    return torch.sum(w.pow(2)) / 2


def train(lambd):
    w, b = init_params()
    # 用lambda匿名函数定义net，输入为X，输出为d2l.linreg(X, w, b)
    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'])
    for epoch in range(num_epochs):
        for X, y in train_iter:
            # lambd是L2正则化项系数，是为了调整正则化的强度
            # 增加了L2范数惩罚项，
            # 广播机制使l2_penalty(w)成为一个长度为batch_size的向量
            l = loss(net(X), y) + lambd * l2_penalty(w)
            l.sum().backward()  # 对参数进行反向传播，以计算权重和偏置的梯度。
            d2l.sgd([w, b], lr, batch_size)  # 使用SGD更新权重和偏置
        if (epoch + 1) % 5 == 0:
            # 每5轮将训练集和测试集上的损失添加到animator中
            animator.add(epoch + 1, (d2l.evaluate_loss(net, train_iter, loss),
                                     d2l.evaluate_loss(net, test_iter, loss)))
    # .item() 方法用于将包含单个元素的张量转换为 Python 标量（普通的整数或浮点数）
    print('w的L2范数是：', torch.norm(w).item())


n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5
true_w, true_b = torch.ones((num_inputs, 1)) * 0.01, 0.05
# 生成合成数据，每个样本生成一个随机的输入特征向量x以及对应的标签y
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)
# 生成数据迭代器，将train_data划分为大小为batch_size的多个批次
# 每次迭代时产生一个批次的样本，直到所有的样本都被遍历完为止
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size, is_train=False)
train(lambd=3)
d2l.plt.show()

---

多项式的权重衰退的简洁实现

    由于权重衰减在神经网络优化中很常用， 深度学习框架为了便于我们使用权重衰减， 将权重衰减集成到优化算法中，以便与任何损失函数结合使用。 此外，这种集成还有计算上的好处， 允许在不增加任何额外的计算开销的情况下向算法中添加权重衰减。 由于更新的权重衰减部分仅依赖于每个参数的当前值， 因此优化器必须至少接触每个参数一次。
    在下面的代码中，我们在实例化优化器时直接通过weight_decay指定weight decay超参数。 默认情况下，PyTorch同时衰减权重和偏移。 这里我们只为权重设置了weight_decay，所以偏置参数b不会衰减。

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
    # 偏置参数没有衰减
    trainer = torch.optim.SGD([
    	# net[0].weight是权重衰退的强度，wd是正则化项的系数
        {"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:
            trainer.zero_grad()
            #通过net(X)前向传播，然后进行损失计算
            l = loss(net(X), y)
            # 反向传播，计算平均损失的梯度
            l.mean().backward()
            trainer.step()
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1,
                         (d2l.evaluate_loss(net, train_iter, loss),
                          d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数：', net[0].weight.norm().item())

简洁函数代码

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
    # 偏置参数没有衰减
    trainer = torch.optim.SGD([
    	# net[0].weight是权重衰退的强度，wd是正则化项的系数
        {"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:
            trainer.zero_grad()
            #通过net(X)前向传播，然后进行损失计算
            l = loss(net(X), y)
            # 反向传播，计算平均损失的梯度
            l.mean().backward()
            trainer.step()
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1,
                         (d2l.evaluate_loss(net, train_iter, loss),
                          d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数：', net[0].weight.norm().item())

train_concise(0)

输出：

train_concise(3)

输出：

这些图看起来和我们从零开始实现权重衰减时的图相同。 然而，它们运行得更快，更容易实现。 对于更复杂的问题，这一好处将变得更加明显。
当wd（即：λ）为0时

当wd（即：λ）为3时

简洁代码实现

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


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
    # 偏置参数没有衰减
    trainer = torch.optim.SGD([
        # net[0].weight是权重衰退的强度，wd是正则化项的系数
        {"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:
            trainer.zero_grad()
            # 通过net(X)前向传播，然后进行损失计算
            l = loss(net(X), y)
            # 反向传播，计算平均损失的梯度
            l.mean().backward()
            trainer.step()
        if (epoch + 1) % 5 == 0:
            animator.add(epoch + 1,
                         (d2l.evaluate_loss(net, train_iter, loss),
                          d2l.evaluate_loss(net, test_iter, loss)))
    print('w的L2范数：', net[0].weight.norm().item())


n_train, n_test, num_inputs, batch_size = 20, 100, 200, 5
true_w, true_b = torch.ones((num_inputs, 1)) * 0.01, 0.05
# 生成合成数据，每个样本生成一个随机的输入特征向量x以及对应的标签y
train_data = d2l.synthetic_data(true_w, true_b, n_train)
train_iter = d2l.load_array(train_data, batch_size)
# 生成数据迭代器，将train_data划分为大小为batch_size的多个批次
# 每次迭代时产生一个批次的样本，直到所有的样本都被遍历完为止
test_data = d2l.synthetic_data(true_w, true_b, n_test)
test_iter = d2l.load_array(test_data, batch_size, is_train=False)
train_concise(3)
d2l.plt.show()

---

问题

①为什么参数不大，复杂度就低呢？
其实不是参数不大，复杂度就低，是说限制整个模型在优化的时候只在一个很小的范围里面取参数。如果在很小的范围里取参数那么整个模型就会变小。

②如果是用L1范数的话如何更新权重？
其实是差不多的，但是这个L1好像更好一点

输出：

L1：

L2：

③实践中权重衰减的值一般设置多少为好呢？之前在跑代码的时候总感觉权重衰减的效果并不是那么好。
一般是取1e-3，1e-4。
其实权重衰退就是一点点效果，之后还有处理权重衰退的方法。

④⭐为什么要把w往小了拉？如果最优解的w就是比较大的数，那权重衰减是不是会有反作用？

假设图中的这个点为最优解，但是实际上数据是有噪音的，实际上学不到这个点。真正学到的如下图所示：


通过控制λ的大小来决定将往回拉多少

拉到这个地方,不够，还是太大了，λ太小。

λ太大可能会拉到这个地方。




数学的最优解就是假设的那个点（图中绿色中心），实际上求解求不到最优解，因为数据有噪音，所以用λ来处理噪音。


⑤L2 norm是让w变得更平均吗？没有突出的值为什么这种调整可以使得拟合更好呢？
不是，它不会让变得平均，而是往里拉。


⑥噪音越大，w就比较，这个是经验所得还是可以证明的？
是可以证明的。