精华内容
下载资源
问答
  • pytorch实现L2和L1正则化regularization的方法
    万次阅读 多人点赞
    2019-03-14 16:44:27

    pytorch实现L2和L1正则化的方法

    目录

    目录

    pytorch实现L2和L1正则化的方法

    1.torch.optim优化器实现L2正则化

    2. 如何判断正则化作用了模型?

    2.1 未加入正则化loss和Accuracy

    2.1 加入正则化loss和Accuracy 

    2.3 正则化说明

    3.自定义正则化的方法

    3.1 自定义正则化Regularization类

    3.2 Regularization使用方法

    4. Github项目源码下载


    1.torch.optim优化器实现L2正则化

    torch.optim集成了很多优化器,如SGD,Adadelta,Adam,Adagrad,RMSprop等,这些优化器自带的一个参数weight_decay,用于指定权值衰减率,相当于L2正则化中的λ参数,注意torch.optim集成的优化器只有L2正则化方法,你可以查看注释,参数weight_decay 的解析是:

            weight_decay (float, optional): weight decay (L2 penalty) (default: 0)

     使用torch.optim的优化器,可如下设置L2正则化

        optimizer = optim.Adam(model.parameters(),lr=learning_rate,weight_decay=0.01)
    

    但是这种方法存在几个问题,

    (1)一般正则化,只是对模型的权重W参数进行惩罚,而偏置参数b是不进行惩罚的,而torch.optim的优化器weight_decay参数指定的权值衰减是对网络中的所有参数,包括权值w偏置b同时进行惩罚。很多时候如果对b 进行L2正则化将会导致严重的欠拟合,因此这个时候一般只需要对权值w进行正则即可。(PS:这个我真不确定,源码解析是 weight decay (L2 penalty) ,但有些网友说这种方法会对参数偏置b也进行惩罚,可解惑的网友给个明确的答复

    (2)缺点:torch.optim的优化器固定实现L2正则化,不能实现L1正则化。如果需要L1正则化,可如下实现:

    (3)根据正则化的公式,加入正则化后,loss会变原来大,比如weight_decay=1的loss为10,那么weight_decay=100时,loss输出应该也提高100倍左右。而采用torch.optim的优化器的方法,如果你依然采用loss_fun= nn.CrossEntropyLoss()进行计算loss,你会发现,不管你怎么改变weight_decay的大小,loss会跟之前没有加正则化的大小差不多。这是因为你的loss_fun损失函数没有把权重W的损失加上。

    (4)采用torch.optim的优化器实现正则化的方法,是没问题的!只不过很容易让人产生误解,对鄙人而言,我更喜欢TensorFlow的正则化实现方法,只需要tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES),实现过程几乎跟正则化的公式对应的上。

    (5)Github项目源码:https://github.com/PanJinquan/pytorch-learning-tutorials/blob/master/image_classification/train_resNet.py麻烦给个“Star”

    为了,解决这些问题,我特定自定义正则化的方法,类似于TensorFlow正则化实现方法。


    2. 如何判断正则化作用了模型?

    一般来说,正则化的主要作用是避免模型产生过拟合,当然啦,过拟合问题,有时候是难以判断的。但是,要判断正则化是否作用了模型,还是很容易的。下面我给出两组训练时产生的loss和Accuracy的log信息,一组是未加入正则化的,一组是加入正则化:

    2.1 未加入正则化loss和Accuracy

    优化器采用Adam,并且设置参数weight_decay=0.0,即无正则化的方法

        optimizer = optim.Adam(model.parameters(),lr=learning_rate,weight_decay=0.0)

    训练时输出的 loss和Accuracy信息

    step/epoch:0/0,Train Loss: 2.418065, Acc: [0.15625]
    step/epoch:10/0,Train Loss: 5.194936, Acc: [0.34375]
    step/epoch:20/0,Train Loss: 0.973226, Acc: [0.8125]
    step/epoch:30/0,Train Loss: 1.215165, Acc: [0.65625]
    step/epoch:40/0,Train Loss: 1.808068, Acc: [0.65625]
    step/epoch:50/0,Train Loss: 1.661446, Acc: [0.625]
    step/epoch:60/0,Train Loss: 1.552345, Acc: [0.6875]
    step/epoch:70/0,Train Loss: 1.052912, Acc: [0.71875]
    step/epoch:80/0,Train Loss: 0.910738, Acc: [0.75]
    step/epoch:90/0,Train Loss: 1.142454, Acc: [0.6875]
    step/epoch:100/0,Train Loss: 0.546968, Acc: [0.84375]
    step/epoch:110/0,Train Loss: 0.415631, Acc: [0.9375]
    step/epoch:120/0,Train Loss: 0.533164, Acc: [0.78125]
    step/epoch:130/0,Train Loss: 0.956079, Acc: [0.6875]
    step/epoch:140/0,Train Loss: 0.711397, Acc: [0.8125]

    2.1 加入正则化loss和Accuracy 

    优化器采用Adam,并且设置参数weight_decay=10.0,即正则化的权重lambda =10.0

        optimizer = optim.Adam(model.parameters(),lr=learning_rate,weight_decay=10.0)
    

    这时,训练时输出的 loss和Accuracy信息:

    step/epoch:0/0,Train Loss: 2.467985, Acc: [0.09375]
    step/epoch:10/0,Train Loss: 5.435320, Acc: [0.40625]
    step/epoch:20/0,Train Loss: 1.395482, Acc: [0.625]
    step/epoch:30/0,Train Loss: 1.128281, Acc: [0.6875]
    step/epoch:40/0,Train Loss: 1.135289, Acc: [0.6875]
    step/epoch:50/0,Train Loss: 1.455040, Acc: [0.5625]
    step/epoch:60/0,Train Loss: 1.023273, Acc: [0.65625]
    step/epoch:70/0,Train Loss: 0.855008, Acc: [0.65625]
    step/epoch:80/0,Train Loss: 1.006449, Acc: [0.71875]
    step/epoch:90/0,Train Loss: 0.939148, Acc: [0.625]
    step/epoch:100/0,Train Loss: 0.851593, Acc: [0.6875]
    step/epoch:110/0,Train Loss: 1.093970, Acc: [0.59375]
    step/epoch:120/0,Train Loss: 1.699520, Acc: [0.625]
    step/epoch:130/0,Train Loss: 0.861444, Acc: [0.75]
    step/epoch:140/0,Train Loss: 0.927656, Acc: [0.625]
    

    当weight_decay=10000.0

    step/epoch:0/0,Train Loss: 2.337354, Acc: [0.15625]
    step/epoch:10/0,Train Loss: 2.222203, Acc: [0.125]
    step/epoch:20/0,Train Loss: 2.184257, Acc: [0.3125]
    step/epoch:30/0,Train Loss: 2.116977, Acc: [0.5]
    step/epoch:40/0,Train Loss: 2.168895, Acc: [0.375]
    step/epoch:50/0,Train Loss: 2.221143, Acc: [0.1875]
    step/epoch:60/0,Train Loss: 2.189801, Acc: [0.25]
    step/epoch:70/0,Train Loss: 2.209837, Acc: [0.125]
    step/epoch:80/0,Train Loss: 2.202038, Acc: [0.34375]
    step/epoch:90/0,Train Loss: 2.192546, Acc: [0.25]
    step/epoch:100/0,Train Loss: 2.215488, Acc: [0.25]
    step/epoch:110/0,Train Loss: 2.169323, Acc: [0.15625]
    step/epoch:120/0,Train Loss: 2.166457, Acc: [0.3125]
    step/epoch:130/0,Train Loss: 2.144773, Acc: [0.40625]
    step/epoch:140/0,Train Loss: 2.173397, Acc: [0.28125]

    2.3 正则化说明

    就整体而言,对比加入正则化和未加入正则化的模型,训练输出的loss和Accuracy信息,我们可以发现,加入正则化后,loss下降的速度会变慢,准确率Accuracy的上升速度会变慢,并且未加入正则化模型的loss和Accuracy的浮动比较大(或者方差比较大),而加入正则化的模型训练loss和Accuracy,表现的比较平滑。并且随着正则化的权重lambda越大,表现的更加平滑。这其实就是正则化的对模型的惩罚作用,通过正则化可以使得模型表现的更加平滑,即通过正则化可以有效解决模型过拟合的问题。


    3.自定义正则化的方法

    为了解决torch.optim优化器只能实现L2正则化以及惩罚网络中的所有参数的缺陷,这里实现类似于TensorFlow正则化的方法。

    3.1 自定义正则化Regularization类

    这里封装成一个实现正则化的Regularization类,各个方法都给出了注释,自己慢慢看吧,有问题再留言吧

    # 检查GPU是否可用
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    # device='cuda'
    print("-----device:{}".format(device))
    print("-----Pytorch version:{}".format(torch.__version__))
    
    
    class Regularization(torch.nn.Module):
        def __init__(self,model,weight_decay,p=2):
            '''
            :param model 模型
            :param weight_decay:正则化参数
            :param p: 范数计算中的幂指数值,默认求2范数,
                      当p=0为L2正则化,p=1为L1正则化
            '''
            super(Regularization, self).__init__()
            if weight_decay <= 0:
                print("param weight_decay can not <=0")
                exit(0)
            self.model=model
            self.weight_decay=weight_decay
            self.p=p
            self.weight_list=self.get_weight(model)
            self.weight_info(self.weight_list)
    
        def to(self,device):
            '''
            指定运行模式
            :param device: cude or cpu
            :return:
            '''
            self.device=device
            super().to(device)
            return self
    
        def forward(self, model):
            self.weight_list=self.get_weight(model)#获得最新的权重
            reg_loss = self.regularization_loss(self.weight_list, self.weight_decay, p=self.p)
            return reg_loss
    
        def get_weight(self,model):
            '''
            获得模型的权重列表
            :param model:
            :return:
            '''
            weight_list = []
            for name, param in model.named_parameters():
                if 'weight' in name:
                    weight = (name, param)
                    weight_list.append(weight)
            return weight_list
    
        def regularization_loss(self,weight_list, weight_decay, p=2):
            '''
            计算张量范数
            :param weight_list:
            :param p: 范数计算中的幂指数值,默认求2范数
            :param weight_decay:
            :return:
            '''
            # weight_decay=Variable(torch.FloatTensor([weight_decay]).to(self.device),requires_grad=True)
            # reg_loss=Variable(torch.FloatTensor([0.]).to(self.device),requires_grad=True)
            # weight_decay=torch.FloatTensor([weight_decay]).to(self.device)
            # reg_loss=torch.FloatTensor([0.]).to(self.device)
            reg_loss=0
            for name, w in weight_list:
                l2_reg = torch.norm(w, p=p)
                reg_loss = reg_loss + l2_reg
    
            reg_loss=weight_decay*reg_loss
            return reg_loss
    
        def weight_info(self,weight_list):
            '''
            打印权重列表信息
            :param weight_list:
            :return:
            '''
            print("---------------regularization weight---------------")
            for name ,w in weight_list:
                print(name)
            print("---------------------------------------------------")
    

    3.2 Regularization使用方法

    使用方法很简单,就当一个普通Pytorch模块来使用:例如

    # 检查GPU是否可用
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    print("-----device:{}".format(device))
    print("-----Pytorch version:{}".format(torch.__version__))
    
    weight_decay=100.0 # 正则化参数
    
    model = my_net().to(device)
    # 初始化正则化
    if weight_decay>0:
       reg_loss=Regularization(model, weight_decay, p=2).to(device)
    else:
       print("no regularization")
    
    
    criterion= nn.CrossEntropyLoss().to(device) # CrossEntropyLoss=softmax+cross entropy
    optimizer = optim.Adam(model.parameters(),lr=learning_rate)#不需要指定参数weight_decay
    
    # train
    batch_train_data=...
    batch_train_label=...
    
    out = model(batch_train_data)
    
    # loss and regularization
    loss = criterion(input=out, target=batch_train_label)
    if weight_decay > 0:
       loss = loss + reg_loss(model)
    total_loss = loss.item()
    
    # backprop
    optimizer.zero_grad()#清除当前所有的累积梯度
    total_loss.backward()
    optimizer.step()

    训练时输出的 loss和Accuracy信息:

    (1)当weight_decay=0.0时,未使用正则化

    step/epoch:0/0,Train Loss: 2.379627, Acc: [0.09375]
    step/epoch:10/0,Train Loss: 1.473092, Acc: [0.6875]
    step/epoch:20/0,Train Loss: 0.931847, Acc: [0.8125]
    step/epoch:30/0,Train Loss: 0.625494, Acc: [0.875]
    step/epoch:40/0,Train Loss: 2.241885, Acc: [0.53125]
    step/epoch:50/0,Train Loss: 1.132131, Acc: [0.6875]
    step/epoch:60/0,Train Loss: 0.493038, Acc: [0.8125]
    step/epoch:70/0,Train Loss: 0.819410, Acc: [0.78125]
    step/epoch:80/0,Train Loss: 0.996497, Acc: [0.71875]
    step/epoch:90/0,Train Loss: 0.474205, Acc: [0.8125]
    step/epoch:100/0,Train Loss: 0.744587, Acc: [0.8125]
    step/epoch:110/0,Train Loss: 0.502217, Acc: [0.78125]
    step/epoch:120/0,Train Loss: 0.531865, Acc: [0.8125]
    step/epoch:130/0,Train Loss: 1.016807, Acc: [0.875]
    step/epoch:140/0,Train Loss: 0.411701, Acc: [0.84375]
    

    (2)当weight_decay=10.0时,使用正则化

    ---------------------------------------------------
    step/epoch:0/0,Train Loss: 1563.402832, Acc: [0.09375]
    step/epoch:10/0,Train Loss: 1530.002686, Acc: [0.53125]
    step/epoch:20/0,Train Loss: 1495.115234, Acc: [0.71875]
    step/epoch:30/0,Train Loss: 1461.114136, Acc: [0.78125]
    step/epoch:40/0,Train Loss: 1427.868164, Acc: [0.6875]
    step/epoch:50/0,Train Loss: 1395.430054, Acc: [0.6875]
    step/epoch:60/0,Train Loss: 1363.358154, Acc: [0.5625]
    step/epoch:70/0,Train Loss: 1331.439697, Acc: [0.75]
    step/epoch:80/0,Train Loss: 1301.334106, Acc: [0.625]
    step/epoch:90/0,Train Loss: 1271.505005, Acc: [0.6875]
    step/epoch:100/0,Train Loss: 1242.488647, Acc: [0.75]
    step/epoch:110/0,Train Loss: 1214.184204, Acc: [0.59375]
    step/epoch:120/0,Train Loss: 1186.174561, Acc: [0.71875]
    step/epoch:130/0,Train Loss: 1159.148438, Acc: [0.78125]
    step/epoch:140/0,Train Loss: 1133.020020, Acc: [0.65625]

    (3)当weight_decay=10000.0时,使用正则化

    step/epoch:0/0,Train Loss: 1570211.500000, Acc: [0.09375]
    step/epoch:10/0,Train Loss: 1522952.125000, Acc: [0.3125]
    step/epoch:20/0,Train Loss: 1486256.125000, Acc: [0.125]
    step/epoch:30/0,Train Loss: 1451671.500000, Acc: [0.25]
    step/epoch:40/0,Train Loss: 1418959.750000, Acc: [0.15625]
    step/epoch:50/0,Train Loss: 1387154.000000, Acc: [0.125]
    step/epoch:60/0,Train Loss: 1355917.500000, Acc: [0.125]
    step/epoch:70/0,Train Loss: 1325379.500000, Acc: [0.125]
    step/epoch:80/0,Train Loss: 1295454.125000, Acc: [0.3125]
    step/epoch:90/0,Train Loss: 1266115.375000, Acc: [0.15625]
    step/epoch:100/0,Train Loss: 1237341.000000, Acc: [0.0625]
    step/epoch:110/0,Train Loss: 1209186.500000, Acc: [0.125]
    step/epoch:120/0,Train Loss: 1181584.250000, Acc: [0.125]
    step/epoch:130/0,Train Loss: 1154600.125000, Acc: [0.1875]
    step/epoch:140/0,Train Loss: 1128239.875000, Acc: [0.125]
    

    对比torch.optim优化器的实现L2正则化方法,这种Regularization类的方法也同样达到正则化的效果,并且与TensorFlow类似,loss把正则化的损失也计算了。

    此外更改参数p,如当p=0表示L2正则化,p=1表示L1正则化。

    4. Github项目源码下载

    《Github项目源码》https://github.com/PanJinquan/pytorch-learning-tutorials/blob/master/image_classification/train_resNet.py

    麻烦给个“Star”:


    如果你觉得该帖子帮到你,还望贵人多多支持,鄙人会再接再厉,继续努力的~

    更多相关内容
  • 这样, 我们从图像化的角度,分析了 L2 正则化的物理意义,解释了带 L2 正则化项的损失函数是如何推导而来的。 2. L1 正则化直观解释 L1 正则化公式也很简单,直接在原来的损失函数基础上加上权重参数的...

    个人网站:红色石头的机器学习之路
    CSDN博客:红色石头的专栏
    知乎:红色石头
    微博:RedstoneWill的微博
    GitHub:RedstoneWill的GitHub
    微信公众号:AI有道(ID:redstonewill)

    机器学习中,如果参数过多,模型过于复杂,容易造成过拟合(overfit)。即模型在训练样本数据上表现的很好,但在实际测试样本上表现的较差,不具备良好的泛化能力。为了避免过拟合,最常用的一种方法是使用使用正则化,例如 L1 和 L2 正则化。但是,正则化项是如何得来的?其背后的数学原理是什么?L1 正则化和 L2 正则化之间有何区别?本文将给出直观的解释。

    1. L2 正则化直观解释

    L2 正则化公式非常简单,直接在原来的损失函数基础上加上权重参数的平方和:

    L=Ein+λjw2j L = E i n + λ ∑ j w j 2

    其中,Ein 是未包含正则化项的训练样本误差,λ 是正则化参数,可调。但是正则化项是如何推导的?接下来,我将详细介绍其中的物理意义。

    我们知道,正则化的目的是限制参数过多或者过大,避免模型更加复杂。例如,使用多项式模型,如果使用 10 阶多项式,模型可能过于复杂,容易发生过拟合。所以,为了防止过拟合,我们可以将其高阶部分的权重 w 限制为 0,这样,就相当于从高阶的形式转换为低阶。

    为了达到这一目的,最直观的方法就是限制 w 的个数,但是这类条件属于 NP-hard 问题,求解非常困难。所以,一般的做法是寻找更宽松的限定条件:

    jw2jC ∑ j w j 2 ≤ C

    上式是对 w 的平方和做数值上界限定,即所有w 的平方和不超过参数 C。这时候,我们的目标就转换为:最小化训练样本误差 Ein,但是要遵循 w 平方和小于 C 的条件。

    下面,我用一张图来说明如何在限定条件下,对 Ein 进行最小化的优化。


    这里写图片描述

    如上图所示,蓝色椭圆区域是最小化 Ein 区域,红色圆圈是 w 的限定条件区域。在没有限定条件的情况下,一般使用梯度下降算法,在蓝色椭圆区域内会一直沿着 w 梯度的反方向前进,直到找到全局最优值 wlin。例如空间中有一点 w(图中紫色点),此时 w 会沿着 -∇Ein 的方向移动,如图中蓝色箭头所示。但是,由于存在限定条件,w 不能离开红色圆形区域,最多只能位于圆上边缘位置,沿着切线方向。w 的方向如图中红色箭头所示。

    那么问题来了,存在限定条件,w 最终会在什么位置取得最优解呢?也就是说在满足限定条件的基础上,尽量让 Ein 最小。

    我们来看,w 是沿着圆的切线方向运动,如上图绿色箭头所示。运动方向与 w 的方向(红色箭头方向)垂直。运动过程中,根据向量知识,只要 -∇Ein 与运行方向有夹角,不垂直,则表明 -∇Ein 仍会在 w 切线方向上产生分量,那么 w 就会继续运动,寻找下一步最优解。只有当 -∇Ein 与 w 的切线方向垂直时,-∇Ein在 w 的切线方向才没有分量,这时候 w 才会停止更新,到达最接近 wlin 的位置,且同时满足限定条件。


    这里写图片描述

    -∇Ein 与 w 的切线方向垂直,即 -∇Ein 与 w 的方向平行。如上图所示,蓝色箭头和红色箭头互相平行。这样,根据平行关系得到:

    Ein+λw=0 − ∇ E i n + λ w = 0

    移项,得:

    Ein+λw=0 ∇ E i n + λ w = 0

    这样,我们就把优化目标和限定条件整合在一个式子中了。也就是说只要在优化 Ein 的过程中满足上式,就能实现正则化目标。

    接下来,重点来了!根据最优化算法的思想:梯度为 0 的时候,函数取得最优值。已知 ∇Ein 是 Ein 的梯度,观察上式,λw 是否也能看成是某个表达式的梯度呢?

    当然可以!λw 可以看成是 1/2λw*w 的梯度:

    w(12λw2)=λw ∂ ∂ w ( 1 2 λ w 2 ) = λ w

    这样,我们根据平行关系求得的公式,构造一个新的损失函数:

    Eaug=Ein+λ2w2 E a u g = E i n + λ 2 w 2

    之所以这样定义,是因为对 Eaug 求导,正好得到上面所求的平行关系式。上式中等式右边第二项就是 L2 正则化项。

    这样, 我们从图像化的角度,分析了 L2 正则化的物理意义,解释了带 L2 正则化项的损失函数是如何推导而来的。

    2. L1 正则化直观解释

    L1 正则化公式也很简单,直接在原来的损失函数基础上加上权重参数的绝对值:

    L=Ein+λj|wj| L = E i n + λ ∑ j | w j |

    我仍然用一张图来说明如何在 L1 正则化下,对 Ein 进行最小化的优化。


    这里写图片描述

    Ein 优化算法不变,L1 正则化限定了 w 的有效区域是一个正方形,且满足 |w| < C。空间中的点 w 沿着 -∇Ein 的方向移动。但是,w 不能离开红色正方形区域,最多只能位于正方形边缘位置。其推导过程与 L2 类似,此处不再赘述。

    3. L1 与 L2 解的稀疏性

    介绍完 L1 和 L2 正则化的物理解释和数学推导之后,我们再来看看它们解的分布性。


    这里写图片描述

    以二维情况讨论,上图左边是 L2 正则化,右边是 L1 正则化。从另一个方面来看,满足正则化条件,实际上是求解蓝色区域与黄色区域的交点,即同时满足限定条件和 Ein 最小化。对于 L2 来说,限定区域是圆,这样,得到的解 w1 或 w2 为 0 的概率很小,很大概率是非零的。

    对于 L1 来说,限定区域是正方形,方形与蓝色区域相交的交点是顶点的概率很大,这从视觉和常识上来看是很容易理解的。也就是说,方形的凸点会更接近 Ein 最优解对应的 wlin 位置,而凸点处必有 w1 或 w2 为 0。这样,得到的解 w1 或 w2 为零的概率就很大了。所以,L1 正则化的解具有稀疏性。

    扩展到高维,同样的道理,L2 的限定区域是平滑的,与中心点等距;而 L1 的限定区域是包含凸点的,尖锐的。这些凸点更接近 Ein 的最优解位置,而在这些凸点上,很多 wj 为 0。

    关于 L1 更容易得到稀疏解的原因,有一个很棒的解释,请见下面的链接:

    https://www.zhihu.com/question/37096933/answer/70507353

    4. 正则化参数 λ

    正则化是结构风险最小化的一种策略实现,能够有效降低过拟合。损失函数实际上包含了两个方面:一个是训练样本误差。一个是正则化项。其中,参数 λ 起到了权衡的作用。


    这里写图片描述

    以 L2 为例,若 λ 很小,对应上文中的 C 值就很大。这时候,圆形区域很大,能够让 w 更接近 Ein 最优解的位置。若 λ 近似为 0,相当于圆形区域覆盖了最优解位置,这时候,正则化失效,容易造成过拟合。相反,若 λ 很大,对应上文中的 C 值就很小。这时候,圆形区域很小,w 离 Ein 最优解的位置较远。w 被限制在一个很小的区域内变化,w 普遍较小且接近 0,起到了正则化的效果。但是,λ 过大容易造成欠拟合。欠拟合和过拟合是两种对立的状态。



    这里写图片描述

    展开全文
  • 正则化的作用以及L1和L2正则化的区别

    万次阅读 多人点赞 2019-08-21 20:06:16
    0 正则化的作用 正则化的主要作用是防止过拟合,对模型添加正则化项可以限制模型的复杂度,使得模型在复杂度和性能达到平衡。 常用的正则化方法有L1正则化和L2正则化。L1正则化和L2正则化可以看做是损失函数的惩罚...

    0 正则化的作用

    正则化的主要作用是防止过拟合,对模型添加正则化项可以限制模型的复杂度,使得模型在复杂度和性能达到平衡。
    常用的正则化方法有L1正则化和L2正则化。L1正则化和L2正则化可以看做是损失函数的惩罚项。所谓『惩罚』是指对损失函数中的某些参数做一些限制。 L1正则化的模型建叫做Lasso回归,使用L2正则化的模型叫做Ridge回归(岭回归。但是使用正则化来防止过拟合的原理是什么?L1和L2正则化有什么区别呢?

    1 L1正则化与L2正则化

    L1正则化的表达如下,其中 α ∣ ∣ w ∣ ∣ 1 \alpha||w||_1 αw1为L1正则化项,L1正则化是指权值向量w 中各个元素的绝对值之和。
    在这里插入图片描述
    L2正则化项表达式如下,其中 α ∣ ∣ w ∣ ∣ 2 2 \alpha||w||_2^2 αw22为L2正则化项,L2正则化是指权值向量w 中各个元素的平方和然后再求平方根。
    在这里插入图片描述
    L1和L2正则化的作用:

    • L1正则化可以产生稀疏权值矩阵,即产生一个稀疏模型,可以用于特征选择,一定程度上,L1也可以防止过拟合
    • L2正则化可以防止模型过拟合(overfitting)

    下面看李飞飞在CS2312中给的更为详细的解释:

    • L2正则化可以直观理解为它对于大数值的权重向量进行严厉惩罚,倾向于更加分散的权重向量。由于输入和权重之间的乘法操作,这样就有了一个优良的特性:使网络更倾向于使用所有输入特征,而不是严重依赖输入特征中某些小部分特征。 L2惩罚倾向于更小更分散的权重向量,这就会鼓励分类器最终将所有维度上的特征都用起来,而不是强烈依赖其中少数几个维度。。这样做可以提高模型的泛化能力,降低过拟合的风险。
    • L1正则化有一个有趣的性质,它会让权重向量在最优化的过程中变得稀疏(即非常接近0)。也就是说,使用L1正则化的神经元最后使用的是它们最重要的输入数据的稀疏子集,同时对于噪音输入则几乎是不变的了。相较L1正则化,L2正则化中的权重向量大多是分散的小数字。
    • 在实践中,如果不是特别关注某些明确的特征选择,一般说来L2正则化都会比L1正则化效果好。

    2 L1和L2正则化的原理

    上面讲到L1倾向于学得稀疏的权重矩阵,L2倾向于学得更小更分散的权重?但是L1和L2是怎样起到这样的作用的呢?背后的数学原理是什么呢?
    模型的学习优化的目标是最小化损失函数,学习的结果是模型参数。在原始目标函数的基础上添加正则化相当于,在参数原始的解空间添加了额外的约束。
    L1正则化对解空间添加的约束是:
    ∑ ∣ ∣ w ∣ ∣ 1 &lt; = C \sum||w||_1 &lt;= C w1<=C
    L2正则化对解空间添加的约束是:
    ∑ ∣ ∣ w ∣ ∣ 2 2 &lt; = C \sum||w||_2^2 &lt;= C w22<=C
    为了形象化的说明以假设有两个空间,以二维参数空间为例,假设有两个参数W1和W2。
    则L1正则化对解空间的约束为:
    ∣ w 1 ∣ + ∣ w 2 ∣ &lt; = C |w1| + |w2| &lt;= C w1+w2<=C
    L2对解空间的约束为:
    w 1 2 + w 2 2 &lt; = C w1^2 + w2^2 &lt;= C w12+w22<=C
    在二维平面上绘制以上两个式子的图像,可得L1约束的范围是一个顶点在坐标轴上的菱形,L2约束的范围是一个圆形。
    在这里插入图片描述
    上面的图,左面是L2约束下解空间的图像,右面是L1约束下解空间的图像。
    蓝色的圆圈表示损失函数的等值线。同一个圆上的损失函数值相等的,圆的半径越大表示损失值越大,由外到内,损失函数值越来越小,中间最小。
    如果没有L1和L2正则化约束的话,w1和w2是可以任意取值的,损失函数可以优化到中心的最小值的,此时中心对应的w1和w2的取值就是模型最终求得的参数。
    但是填了L1和L2正则化约束就把解空间约束在了黄色的平面内。黄色图像的边缘与损失函数等值线的交点,便是满足约束条件的损失函数最小化的模型的参数的解。 由于L1正则化约束的解空间是一个菱形,所以等值线与菱形端点相交的概率比与线的中间相交的概率要大很多,端点在坐标轴上,一些参数的取值便为0。L2正则化约束的解空间是圆形,所以等值线与圆的任何部分相交的概率都是一样的,所以也就不会产生稀疏的参数。
    但是L2为什么倾向于产生分散而小的参数呢?那是因为求解模型的时候要求,在约束条件满足的情况下最小化损失函数, ∑ ∣ ∣ w ∣ ∣ 2 2 \sum||w||_2^2 w22也应该尽可能的小。
    看这样一个例子:
    设输入向量x=[1,1,1,1],两个权重向量w_1=[1,0,0,0],w_2=[0.25,0.25,0.25,0.25]。那么 w 1 T x = w 2 T x = 1 w^T_1x=w^T_2x=1 w1Tx=w2Tx=1,两个权重向量都得到同样的内积,但是 w 1 w_1 w1的L2惩罚是1.0,而 w 2 w_2 w2的L2惩罚是0.25。因此,根据L2惩罚来看, w 2 w_2 w2更好,因为它的正则化损失更小。从直观上来看,这是因为 w 2 w_2 w2的权重值更小且更分散。所以L2正则化倾向于是特征分散,更小。

    3 正则化参数 λ

    我们一般会为正则项参数添加一个超参数λ或者α,用来平衡经验风险和结构风险(正则项表示结构风险)。
    在这里插入图片描述以 L2 为例,若 λ 很小,就是说我们考虑经验风险更多一些,对于结构风险没有那么重视,约束条件更为宽松。对应上文中的 C 值就很大。这时候,圆形区域很大,能够让 w 更接近中心最优解的位置。若 λ 近似为 0,相当于圆形区域覆盖了最优解位置,这时候,正则化失效,容易造成过拟合。
    相反,若 λ 很大,约束条件更为严格,对应上文中的 C 值就很小。这时候,圆形区域很小,w 离中心最优解的位置较远。w 被限制在一个很小的区域内变化,w 普遍较小且接近 0,起到了正则化的效果。但是,λ 过大容易造成欠拟合。欠拟合和过拟合是两种对立的状态。

    4 总结

    1. 添加正则化相当于参数的解空间添加了约束,限制了模型的复杂度
    2. L1正则化的形式是添加参数的绝对值之和作为结构风险项,L2正则化的形式添加参数的平方和作为结构风险项
    3. L1正则化鼓励产生稀疏的权重,即使得一部分权重为0,用于特征选择;L2鼓励产生小而分散的权重,鼓励让模型做决策的时候考虑更多的特征,而不是仅仅依赖强依赖某几个特征,可以增强模型的泛化能力,防止过拟合。
    4. 正则化参数 λ越大,约束越严格,太大容易产生欠拟合。正则化参数 λ越小,约束宽松,太小起不到约束作用,容易产生过拟合。
    5. 如果不是为了进行特征选择,一般使用L2正则化模型效果更好。

    参考文章:
    1.【通俗易懂】机器学习中 L1 和 L2 正则化的直观解释
    2. 机器学习中正则化项L1和L2的直观理解

    展开全文
  • 机器学习之正则化 (Regularization) 1.参数正则化 1.1 L2 Regularization(Ridge Regression,权重衰减) 1.2 L1 Regularization:将噪点相关权重系数设为0(也叫稀疏正则化) 1.3 L1/L2对比: 2. 经验正则化(早停...


    机器学习:正则化 (Regularization)

    先一波总结:

    • 为什么要正则化:让模型不要过于依赖样本数据
    • 正则化主要思想:降低模型的复杂度
    • 正则化主要目的:防止模型过拟合
    • 正则化实现思路:最小化损失Loss+ 最小复杂度
    • 正则化终极目标:提升模型泛化Generalization的能力

    在这里插入图片描述
    图自台湾大学林轩田老师 Machine Learning Techniques (机器学习技法)

    那么正则化是啥,为什么需要正则化?:因为要让AI模型不过于信赖样本数据,否则是不是就不能好好学习了,

    举个栗子,比如让模型小A备考一个考试,学习过程他每天过于研究历年真题,真题固定题型完全不在话下,学到只会做真题,那么真正考试中出现新题型,悲剧 , 不会了,这里也是一样。这时候老师就说了,小A要使用正则化方法,平衡真题学习力度,做到既研究好真题,又不只限于真题。。。嗯 好像老师真这样说过。。

    所以说Regularization 本质上是防止模型过拟合

    正则化的方法

    正则化有不同的策略,目前来讲主要有参数正则化、经验正则化

    1.参数正则化

    参数正则的L2/L1 Regularization 范数正则化目前用的是最多的。。。

    参数正则化方法的核心主要是对损失函数Loss Function 添加惩罚项 Penalty
    在这里插入图片描述
    L2/L1正则化都是通过添加一个惩罚项,来调节模型参数(权重w),使loss最小,(例如w一开始数值大,则loss会变大,则在反向传播每次更新权重时,就会对这个w进行惩罚,既降低w,直到模型认为loss已经最优)

    1.0 范数

    上面所谓的L1/L2是数学中向量空间的范数

    • L1范数,其表示某个向量中所有元素绝对值的和。
    • L2范数, 表示某个向量中所有元素平方和再开根, 也就是欧氏距离

    常用的最小二乘法(LS算法)就是L2的一个具体应用
    在这里插入图片描述

    在学习参数正则化前, 回顾下正则化核心思想和目标

    • 思想:降低模型复杂度,(根据奥卡姆剃刀定律
    • 目标:最小化 损失+复杂度 为目标(结构风险最小化)

    即:在这里插入图片描述

    为避免离群值这种影响,引入Lambda(又称正则化率)来调制正则化项的整体影响
    则变成:
    在这里插入图片描述
    Lambda值需要在模型简单化和训练数据拟合之间达到适当的平衡
    • Lambda高,模型简单,数据欠拟合
    • Lambda低,模型复杂,数据过拟合

    模型学习速率和Lambda之间强相关

    现在训练优化算法有2项内容组成:损失项 + 正则化项
    • 损失项:用于衡量算法模型与数据的拟合度
    • 正则化项:衡量算法模型的复杂度

    1.1 L2 Regularization(Ridge Regression,权重衰减)

    L2范数在回归里面,它的回归叫“岭回归”(Ridge Regression),也叫它“权值衰减weight decay”
    L2范数向量各元素的平方和然后求平方根。我们让L2范数的规则项||W||2最小,可以使得W的每个元素都很小,都接近于0,即前面所说的惩罚项为:

    在这里插入图片描述
    L2实现上,直接在原来的损失函数基础上加上权重参数的平方和如下,这样调节权重w变小,实现最小化loss 损失+复杂度的小目标:
    在这里插入图片描述

    这个过程中,更小的权值w,即表示模型的复杂度更低,对数据的拟合就不会过于强烈

    L2正则化核心是量化模型复杂度:L2 = 所有特征权重的平方和

    在这里插入图片描述
    加入L2正则化结果:测试Lost明显减少,训练损失有所上升,特征权重的绝对值降低(模型复杂度降低)
    例如大多数LR(逻辑回归)模型都会使用L2正则化来降低模型复杂度,并且LR非常容易过拟合,因为LR会尝试让所有样本的Lost减少到0,但始终达不到,所以每个LR指示器特征的权重就会不断增大到正无穷或负无穷

    在L2正则中,接近于0的权重对复杂度几乎没有影响,而离群值权重会产生巨大影响,所以是时候回引申出L1 Regularization了:

    1.2 L1 Regularization:将噪点相关权重系数设为0(也叫稀疏正则化)

    L1范数是指向量中各个元素绝对值之和,也有个美称叫“稀疏规则算子”(Lasso regularization)。所以L1正则化可以产生稀疏模型。

    在原始的损失函数后面加上一个L1正则化项
    在这里插入图片描述

    为什么需要用L1:
    特征组合可能会包含许多维度,模型太庞大占用大量RAM,因此,对权重降为0,既可以节省空间,也可以减少模型中的噪点

    L1核心思想:将无意义的特征维度降为0

    在这里插入图片描述

    1.3 L1/L2对比:

    • L2只能将权重变小,但是不能将他们降为0
    • 采用不同方式降低权重w:L2会降低w的平方,L1是减w的绝对值,因此L2与L1具有不同的导数

    2. 经验正则化(早停、丢弃Dropout)

    还有一些通过经验实现正则化,例如早停法(但该方法实际操作起来困难)

    另一种形式的正则是丢弃法Dropout,经常用于神经网络:
    https://howiexue.blog.csdn.net/article/details/104271227

    其原理就是:在梯度下降法的每一步中,随机丢弃一些网络单元,丢弃的越多,正则化效果越强

    • 0 = 无丢弃正则化
    • 1 = 丢弃所有内容,模型学不到任何规律

    博主热门文章推荐:

    一篇读懂系列:

    LoRa Mesh系列:

    网络安全系列:

    嵌入式开发系列:

    AI / 机器学习系列:


    在这里插入图片描述

    展开全文
  • L1正则化和L2正则化的详细直观解释

    万次阅读 多人点赞 2018-08-09 15:13:18
    正则化(Regularization) 转:此处 机器学习中几乎都可以看到损失函数后面会添加一个额外项,常用的额外项一般有两种,一般英文称作ℓ1ℓ1-norm和ℓ2ℓ2-norm,中文称作L1正则化和L2正则化,或者L1范数和L2范数...
  • 机器学习中正则项L1和L2的直观理解

    万次阅读 多人点赞 2019-03-02 11:15:39
    正则化(Regularization) 机器学习中几乎都可以看到损失函数后面会添加一个额外项,常用的额外项一般有两种,一般英文称作ℓ1ℓ1\ell_1-norm和ℓ2ℓ2\ell_2-norm,中文称作L1正则化和L2正则化,或者L1范数和L2范数...
  • 目标函数 = 损失函数+正则化

    万次阅读 2021-10-20 09:12:50
    即最优化经验风险(训练集的平均损失:即拟合的好坏)和结构风险(用来度量模型的复杂度,机器学习中叫做正则化:模型不要太复杂,否则过拟合) 首先给出结论:损失函数和代价函数是同一个东西(损失函数只针对...
  • L1正则化和L2正则化讲解

    千次阅读 2020-10-16 21:29:10
    L1正则化和L2正则化讲解   在机器学习实践过程中,训练模型的时候往往会出现过拟合现象,为了减小或者避免在训练中出现过拟合现象,通常在原始的损失函数之后附加上正则项,通常使用的正则项有两种:L1正则化和L2...
  • L1正则化和L2正则化

    千次阅读 2022-04-01 10:15:53
    在机器学习以及深度学习中我们经常会看到正则化这一名词,下面就浅谈一下什么是正则化?以及正则化的意义所在? 一、什么是正则化正则化项 (又称惩罚项),惩罚的是模型的参数,其值恒为非负 λ是正则化系数,是...
  • 正则化的原理以及正则化pytorch实现

    千次阅读 2022-03-22 20:44:17
    谈到机器学习中的正则化,大部分谈论的都是L1正则化和L2正则化,下面谈论一下其中的原理,只有明白原理才能更好的应用。 首先应该看一下这个知乎上的高赞回答: 机器学习中常常提到的正则化到底是什么意思? - 陶...
  • 【机器学习】一文读懂正则化与LASSO回归,Ridge回归

    万次阅读 多人点赞 2018-10-10 20:53:35
    该文已经收录到专题机器学习进阶之路当中,欢迎大家关注。 1.过拟合 当样本特征很多,样本数相对较少时,模型容易陷入过拟合。为了缓解过拟合问题,有两种...正则化是结构风险(损失函数+正则化项)最小化策略的体...
  • 在进行矩阵求逆等计算时遇到矩阵条件数较大导致病态时,常用的各种解决病态方程方法
  • 损失正则化简单易懂

    千次阅读 2018-07-24 21:21:44
    众所周知,同样表现下模型参数值(变量系数)越小越好,因为y = 214124x1 + 24421x2 + 3x3 这样的x有轻微变化都会引起y剧烈抖动,在高维情况更为明显。因此,在损失函数后加入正则可以减少这个问题从而防止过拟合...
  • 正则化综述(L2\L1正则化、弹性网络正则化,数据增强、k折交叉验证、dropout、early stopping、injecting noise)
  • L1和L2正则化(regularization)

    万次阅读 2020-04-07 09:54:24
    L1和L2正则化   理论上来说,只要参数足够多,而且参数之间的关系足够复杂,模型就可以拟合任意的函数。如果连噪声也都拟合了,这就是过拟合。事实上,我们在学习的时候,需要学习的是数据的普遍特征,但是除了...
  • 相信大部分人都见到过,下面的这两张对比图,用来解释为什么L1正则化比L2正则化更容易得到稀疏解,然而很多人会纠结于"怎么证明相切是在角点上?",呃,不必就纠结于此,请注意结论中的"容易"二字,配图只是为了说明...
  • 详解L1和L2正则化

    千次阅读 2020-11-24 20:23:14
    对参数进行L1和L2正则化的作用与区别 pytorch实现L1与L2正则化 对特征进行L2正则化的作用 L1和L2的区别以及范数   使用机器学习方法解决实际问题时,我们通常要用L1或L2范数做正则化(regularization),从而限制...
  • Scikit-learn实例之理解SVM正则化系数C

    万次阅读 2017-01-16 16:53:01
    SVM中正则系数C的理解
  • 【直观详解】什么是正则化

    万次阅读 多人点赞 2018-03-02 17:47:40
    :https://charlesliuyx.github.io/2017/10/03/%E3%80%90%E7%9B%B4%E8%A7%82%E8%AF%A6%E8%A7%A3%E3%80%91%E4%BB%80%E4%B9%88%E6%98%AF%E6%AD%A3%E5%88%99%E5%8C%96/https://www.zhihu.com/question/20924039...
  • L1正则化和L2正则化的区别

    千次阅读 2021-04-24 10:57:12
    文章目录前言一、L1和L2正则化是什么?二、区别三、其他问题 前言 在防止过拟合的方法中有L1正则化和L2正则化,那么这两者有什么区别呢? 一、L1和L2正则化是什么? L1和L2是正则化项,又叫做惩罚项,是为了限制...
  • L1正则化与L2正则化的区别

    万次阅读 多人点赞 2018-12-10 20:45:36
    本文从正则化的本质p-范数入手,解释了L1正则化和L2正则化的区别。 正则化 在Cost Function上添加了正则化项,就能降低模型的过拟合程度,这就是正则化的作用。 关于正则化更细节的讲述,请参考为什么正则化能减少...
  • 机器学习中的正则化

    2017-06-14 22:20:56
    机器学习中的正则化正则化(regularization)是机器学习中进行模型选择的典型方法。正则化是模型损失函数结构风险最小化策略的实现,是在经验风险上加一个正则化项(regularized item)或罚项(penalty term)。正则...
  • 正则化(L1正则化、L2参数正则化)L1范数正则化L2参数正则化 正则化是机器学习中通过显式的控制模型复杂度来避免模型过拟合、确保泛化能力的一种有效方式。 L1范数正则化 L1范数正则化( L1 regularization 或 ...
  • sklearn中svc与逻辑回归的正则化系数

    千次阅读 2019-06-30 11:17:54
    而sklearn中逻辑回归的正则化系数则是公式推导中正则化系数的倒数,参数C是在损失函数的前面,通过调控损失函数本身的大小,来调节对模型的惩罚 。C越小,损失函数会越小,模型对损失函数的惩罚越重,正则化的效力越...
  • keras中添加正则化

    万次阅读 2019-04-08 10:53:25
    正则正则项在优化过程中层的参数或层的激活值添加惩罚项,这些惩罚项将与损失函数一起作为网络的最终优化目标 惩罚项基于层进行惩罚,目前惩罚项的接口与层有关,但Dense, Conv1D, Conv2D, Conv3D具有共同的...
  • 一篇文章完全搞懂正则化(Regularization)

    万次阅读 多人点赞 2020-03-16 12:38:06
    什么是正则化? Regularization,中文翻译过来可以称为正则化,或者是规范化。什么是规则?闭卷考试中不能查书,这就是规则,一个限制。同理,在这里,规则化就是说给损失函数加上一些限制,通过这种规则去规范他们...
  • 一、什么是正则化,用来干嘛的? 正则化(regularization),是指在线性代数理论中,不适定问题通常是由一组线性代数方程定义的,而且这组方程组通常来源于有着很大的条件数的不适定反问题。大条件数意味着舍入误差或...
  • pytorch实现正则化

    万次阅读 2019-07-31 20:40:00
    机器学习中几乎都可以看到损失函数后面会添加一个额外项,常用的额外项一般有两种,称作**L1正则化和L2正则化,或者L1范数和L2范数**。 L1 正则化和 L2 正则化可以看做是损失函数的惩罚项。所谓 “惩罚” 是指对损失...
  • l1正则化和l2正则化I have read many articles on the topic to find out which is better out of two and what should I use for my model. I wasn’t satisfied with any of them and that left my brain confused...
  • L1/L2正则化的作用 L1正则化作用到参数会产生更稀疏的解,既能使参数在训练过程中尽量靠近最优解的同时,一些参数为0。L1正则化的稀疏性质被广泛应用于特征选择,可从特征集合中选出具有代表的特征子集,以此简化...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 412,485
精华内容 164,994
关键字:

自正则化