14.正则化之weight_decay&Dropout

最新推荐文章于 2023-02-09 11:37:35 发布

oldmao_2000

最新推荐文章于 2023-02-09 11:37:35 发布

阅读量1k

点赞数

分类专栏： Pytorch框架（完结）

本文链接：https://blog.csdn.net/oldmao_2001/article/details/103180234

版权

Pytorch框架（完结）专栏收录该内容

22 篇文章 23 订阅

订阅专栏

文章目录

正则化与偏差方差分解
- Regularization
pytorch中的L2正则项-weight decay（权值衰减）
Dropout概念
- nn.Dropout
- 示例
Dropout注意事项

本课程来自深度之眼deepshare.net，部分截图来自课程视频。

正则化与偏差方差分解

Regularization

Regularization：减小方差（防止过拟合）的策略，先看下方差是什么东西。
误差可分解为：偏差，方差与噪声之和。即误差=偏差+方差+噪声之和
以下概念来自《西瓜书》
偏差度量了学习算法的期望预测与真实结果的偏离程度，即刻画了学习算法本身的拟合能力
方差度量了同样大小的训练集的变动所导致的学习性能的变化，即刻画了数据扰动所造成的影响
噪声则表达了在当前任务上任何学习算法所能达到的期望泛化误差的下界
其实在李宏毅的笔记里面也有讲这几个东西的关系，就是variance和bias。
在这里插入图片描述
上图中深红色是验证集的loss，下面橙色的是训练集的loss。
通常噪声是不考虑，然后用验证集与x轴的的差距记录为偏差
训练集和验证集的差距作为方差。Regularization就是解决方差过大的问题的。
下面的一元线性模型中，在train data set上模拟很好，但是在test data set 上表现就很差，是典型的过拟合现象，就是方差过大的一个例子。
在这里插入图片描述
损失函数：衡量模型输出与真实标签的差异
损失函数（Loss Function）：
$Loss=f(\widehat y,y)$
代价函数（Cost Function）：代表模型的拟合能力
$Cost=\frac{1}{N}\sum_i^N f((\widehat y_i,y_i)$
目标函数（Objective Function）：
$O b j = C o s t + R e g u l a r i z a t i o n T e r m$
常见Regularization Term有两种，分别是：
L1 Regularization Term: $\sum_i^N|w_i|$
L2 Regularization Term: $\sum_i^Nw^2_i$
下图中彩色部分就是cost的等高线，每个相同颜色代表cost的值一样，左边是L1、右边是L2
在这里插入图片描述

pytorch中的L2正则项-weight decay（权值衰减）

为什么L2正则项到了pytorch就有了新名字：weight decay（权值衰减），下面请看手推公式表演。。。
目标函数（Objective Function）：
$O b j = C o s t + R e g u l a r i z a t i o n T e r m$
$Obj=Loss+\frac{\lambda}{2}\sum_i^Nw^2_i$
其中Cost可以用Loss表示，然后 $\lambda$ 是超参数，1/2是为了消除求导带的一个系数。没有加正则项之前权值更新的公式为：
$w_{i+1}=w_i-\frac{\partial Obj}{\partial w_i}=w_i-\frac{\partial Loss}{\partial w_i}$
加入正则项之后，上式变成：
$w_{i+1}=w_i-\frac{\partial Obj}{\partial w_i}=w_i-(\frac{\partial Loss}{\partial w_i}+\lambda*w_i)$
由于这里我们只讨论一个参数，所以我们这里没有出现求和符号，如果把权重提取出来上式变成：
$w_i(1-\lambda)-\frac{\partial Loss}{\partial w_i}$
通常， $\lambda$ 取值范围为(0,1)，所以 $w_i(1-\lambda)$ 变小了。也就是为什么叫权重衰减的原因，变小了嘛。
下面是老师的代码示例：

# -*- coding:utf-8 -*-
"""
@file name  : L2_regularization.py
# @author   : TingsongYu https://github.com/TingsongYu
@date       : 2019-10-30
@brief      : weight decay使用实验
"""
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
from tools.common_tools import set_seed
from torch.utils.tensorboard import SummaryWriter

set_seed(1)  # 设置随机种子
n_hidden = 200
max_iter = 2000
disp_interval = 200
lr_init = 0.01


# ============================ step 1/5 构建数据 ============================
def gen_data(num_data=10, x_range=(-1, 1)):

    w = 1.5
    train_x = torch.linspace(*x_range, num_data).unsqueeze_(1)
    train_y = w*train_x + torch.normal(0, 0.5, size=train_x.size())
    test_x = torch.linspace(*x_range, num_data).unsqueeze_(1)
    test_y = w*test_x + torch.normal(0, 0.3, size=test_x.size())

    return train_x, train_y, test_x, test_y


train_x, train_y, test_x, test_y = gen_data(x_range=(-1, 1))#每个数据集合有10个数据，x轴的范围是-1到1


# ============================ step 2/5 模型 ============================
class MLP(nn.Module):
    def __init__(self, neural_num):
        super(MLP, self).__init__()
        self.linears = nn.Sequential(#三层全连接网络
            nn.Linear(1, neural_num),
            nn.ReLU(inplace=True),
            nn.Linear(neural_num, neural_num),
            nn.ReLU(inplace=True),
            nn.Linear(neural_num, neural_num),
            nn.ReLU(inplace=True),
            nn.Linear(neural_num, 1),
        )

    def forward(self, x):
        return self.linears(x)


net_normal = MLP(neural_num=n_hidden)
net_weight_decay = MLP(neural_num=n_hidden)

# ============================ step 3/5 优化器 ============================
#weight_decay是在优化器中实现的
optim_normal = torch.optim.SGD(net_normal.parameters(), lr=lr_init, momentum=0.9)
optim_wdecay = torch.optim.SGD(net_weight_decay.parameters(), lr=lr_init, momentum=0.9, weight_decay=1e-2)

# ============================ step 4/5 损失函数 ============================
loss_func = torch.nn.MSELoss()#使用均方误差作为损失函数

# ============================ step 5/5 迭代训练 ============================

writer = SummaryWriter(comment='_test_tensorboard', filename_suffix="12345678")
for epoch in range(max_iter):

    # forward
    pred_normal, pred_wdecay = net_normal(train_x), net_weight_decay(train_x)
    loss_normal, loss_wdecay = loss_func(pred_normal, train_y), loss_func(pred_wdecay, train_y)
    
    #梯度清零
    optim_normal.zero_grad()
    optim_wdecay.zero_grad()

    #反向传播
    loss_normal.backward()
    loss_wdecay.backward()

    #下一步更新
    optim_normal.step()
    optim_wdecay.step()

    if (epoch+1) % disp_interval == 0:

        # 可视化，使用直方图
        for name, layer in net_normal.named_parameters():
            writer.add_histogram(name + '_grad_normal', layer.grad, epoch)
            writer.add_histogram(name + '_data_normal', layer, epoch)

        for name, layer in net_weight_decay.named_parameters():
            writer.add_histogram(name + '_grad_weight_decay', layer.grad, epoch)
            writer.add_histogram(name + '_data_weight_decay', layer, epoch)

        test_pred_normal, test_pred_wdecay = net_normal(test_x), net_weight_decay(test_x)

        # 绘图
        plt.scatter(train_x.data.numpy(), train_y.data.numpy(), c='blue', s=50, alpha=0.3, label='train')
        plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='red', s=50, alpha=0.3, label='test')
        plt.plot(test_x.data.numpy(), test_pred_normal.data.numpy(), 'r-', lw=3, label='no weight decay')
        plt.plot(test_x.data.numpy(), test_pred_wdecay.data.numpy(), 'b--', lw=3, label='weight decay')
        plt.text(-0.25, -1.5, 'no weight decay loss={:.6f}'.format(loss_normal.item()), fontdict={'size': 15, 'color': 'red'})
        plt.text(-0.25, -2, 'weight decay loss={:.6f}'.format(loss_wdecay.item()), fontdict={'size': 15, 'color': 'red'})

        plt.ylim((-2.5, 2.5))
        plt.legend(loc='upper left')
        plt.title("Epoch: {}".format(epoch+1))
        plt.show()
        plt.close()

各个颜色图例已经写得很清楚，不啰嗦了。
在这里插入图片描述
用tensorboard看下权值的变化
第一个FC：
没有使用L2正则项，权值没有变化，都是在-1到1之间，右边是迭代次数，共2000次：

使用正则项后，看到权值在慢慢缩小。

第二个FC：

Dropout概念

文献：Dropout: A simple way to prevent neural networks from overfitting
Dropout：随机失活
随机：dropout probability
失活：weight=0
在这里插入图片描述
具体原理可以参考李宏毅的笔记，偷懒不写了。
数据尺度变化：测试时，所有权重乘以1-drop_prob drop_prob=0.3，1-drop prob=0.7
李宏毅笔记9中抓爆的科学解释

nn.Dropout

功能：Dropout层参数：
·p：被舍弃概率，失活概率

示例

# -*- coding:utf-8 -*-
"""
@file name  : dropout_regularization.py
# @author   : TingsongYu https://github.com/TingsongYu
@date       : 2019-10-31
@brief      : dropout 使用实验
"""
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
from tools.common_tools import set_seed
from torch.utils.tensorboard import SummaryWriter

set_seed(1)  # 设置随机种子
n_hidden = 200
max_iter = 2000
disp_interval = 400
lr_init = 0.01


# ============================ step 1/5 数据 ============================
def gen_data(num_data=10, x_range=(-1, 1)):

    w = 1.5
    train_x = torch.linspace(*x_range, num_data).unsqueeze_(1)
    train_y = w*train_x + torch.normal(0, 0.5, size=train_x.size())
    test_x = torch.linspace(*x_range, num_data).unsqueeze_(1)
    test_y = w*test_x + torch.normal(0, 0.3, size=test_x.size())

    return train_x, train_y, test_x, test_y


train_x, train_y, test_x, test_y = gen_data(x_range=(-1, 1))


# ============================ step 2/5 模型 ============================
class MLP(nn.Module):
    def __init__(self, neural_num, d_prob=0.5):
        super(MLP, self).__init__()
        self.linears = nn.Sequential(

            nn.Linear(1, neural_num),
            nn.ReLU(inplace=True),

            nn.Dropout(d_prob),#Dropout是接在第二个Linear层的前面的。也就是说哪层需要抓爆，就放他的前面
            nn.Linear(neural_num, neural_num),#这三层可以看成一个小模块
            nn.ReLU(inplace=True),

            nn.Dropout(d_prob),
            nn.Linear(neural_num, neural_num),
            nn.ReLU(inplace=True),

            nn.Dropout(d_prob),
            nn.Linear(neural_num, 1),
        )

    def forward(self, x):
        return self.linears(x)


net_prob_0 = MLP(neural_num=n_hidden, d_prob=0.)#一个不设置dropout，作为对比
net_prob_05 = MLP(neural_num=n_hidden, d_prob=0.5)

# ============================ step 3/5 优化器 ============================
optim_normal = torch.optim.SGD(net_prob_0.parameters(), lr=lr_init, momentum=0.9)
optim_reglar = torch.optim.SGD(net_prob_05.parameters(), lr=lr_init, momentum=0.9)

# ============================ step 4/5 损失函数 ============================
loss_func = torch.nn.MSELoss()

# ============================ step 5/5 迭代训练 ============================

writer = SummaryWriter(comment='_test_tensorboard', filename_suffix="12345678")
for epoch in range(max_iter):

    pred_normal, pred_wdecay = net_prob_0(train_x), net_prob_05(train_x)
    loss_normal, loss_wdecay = loss_func(pred_normal, train_y), loss_func(pred_wdecay, train_y)

    optim_normal.zero_grad()
    optim_reglar.zero_grad()

    loss_normal.backward()
    loss_wdecay.backward()

    optim_normal.step()
    optim_reglar.step()

    if (epoch+1) % disp_interval == 0:

        net_prob_0.eval()#抓爆在测试时要设置测试状态
        net_prob_05.eval()

        # 可视化
        for name, layer in net_prob_0.named_parameters():
            writer.add_histogram(name + '_grad_normal', layer.grad, epoch)
            writer.add_histogram(name + '_data_normal', layer, epoch)

        for name, layer in net_prob_05.named_parameters():
            writer.add_histogram(name + '_grad_regularization', layer.grad, epoch)
            writer.add_histogram(name + '_data_regularization', layer, epoch)

        test_pred_prob_0, test_pred_prob_05 = net_prob_0(test_x), net_prob_05(test_x)

        # 绘图
        plt.scatter(train_x.data.numpy(), train_y.data.numpy(), c='blue', s=50, alpha=0.3, label='train')
        plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='red', s=50, alpha=0.3, label='test')
        plt.plot(test_x.data.numpy(), test_pred_prob_0.data.numpy(), 'r-', lw=3, label='d_prob_0')
        plt.plot(test_x.data.numpy(), test_pred_prob_05.data.numpy(), 'b--', lw=3, label='d_prob_05')
        plt.text(-0.25, -1.5, 'd_prob_0 loss={:.8f}'.format(loss_normal.item()), fontdict={'size': 15, 'color': 'red'})
        plt.text(-0.25, -2, 'd_prob_05 loss={:.6f}'.format(loss_wdecay.item()), fontdict={'size': 15, 'color': 'red'})

        plt.ylim((-2.5, 2.5))
        plt.legend(loc='upper left')
        plt.title("Epoch: {}".format(epoch+1))
        plt.show()
        plt.close()

        net_prob_0.train()#测试完毕后要设置会训练状态
        net_prob_05.train()

结果如下：
在这里插入图片描述
再次看下每一层的权重变化：
不带dropout

带dropout，有类似L2收缩权重的效果。

Dropout注意事项

训练时权重均乘以 $\frac{1}{1-p}$ ，即除以 $1 - p$ ，什么意思呢？就是在原版论文中，是在测试的时候对权重乘了一个系数 $1 - p$ ，为了使得训练过程更快，所以把这个系数挪到了训练过程中，就是将训练的权重乘以 $\frac{1}{1-p}$

oldmao_2000

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
14.正则化之weight_decay&Dropout

文章目录正则化与偏差方差分解Regularizationpytorch中的L2正则项-weight decay（权值衰减）Dropout概念nn.Dropout示例Dropout注意事项本课程来自深度之眼deepshare.net，部分截图来自课程视频。正则化与偏差方差分解RegularizationRegularization：减小方差（防止过拟合）的策略，先看下方差是什么东西。误差可...
复制链接

扫一扫