正则化 订阅
正则化(regularization),是指在线性代数理论中,不适定问题通常是由一组线性代数方程定义的,而且这组方程组通常来源于有着很大的条件数的不适定反问题。大条件数意味着舍入误差或其它误差会严重地影响问题的结果。 展开全文
正则化(regularization),是指在线性代数理论中,不适定问题通常是由一组线性代数方程定义的,而且这组方程组通常来源于有着很大的条件数的不适定反问题。大条件数意味着舍入误差或其它误差会严重地影响问题的结果。
信息
外文名
regularization
出    处
线性代数理论
属    于
代数几何中的一个概念
用    途
求解不适定问题
中文名
正则化
形    式
2种
正则化定义
正则化:代数几何中的一个概念。就是给平面不可约代数曲线以某种形式的全纯参数表示。即对于PC^2中的不可约代数曲线C,寻找一个紧Riemann面C*和一个全纯映射σ:C*→PC^2,使得σ(C*)=C设C是不可约平面代数曲线,S是C的奇点的集合。如果存在紧Riemann面C*及全纯映射σ:C*→PC^2,使得(1) σ(C*)=C (2) σ^(-1)(S)是有限点集 (3) σ:C*\σ^(-1)(S)→C\S是一对一的映射则称(C*,σ)为C的正则化。不至于混淆的时候,也可以称C*为C的正则化。正则化的做法,实际上是在不可约平面代数曲线的奇点处,把具有不同切线的曲线分支分开,从而消除这种奇异性。 [1] 
收起全文
精华内容
下载资源
问答
  • 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 ...

    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的直观理解

    展开全文
  • L1和L2正则化(regularization)

    万次阅读 2020-04-07 09:54:24
    L1和L2正则化   理论上来说,只要参数足够多,而且参数之间的关系足够复杂,模型就可以拟合任意的函数。如果连噪声也都拟合了,这就是过拟合。事实上,我们在学习的时候,需要学习的是数据的普遍特征,但是除了...

    L1和L2正则化

      理论上来说,只要参数足够多,而且参数之间的关系足够复杂,模型就可以拟合任意的函数。如果连噪声也都拟合了,这就是过拟合。事实上,我们在学习的时候,需要学习的是数据的普遍特征,但是除了普遍特征之外还存在一些少量数据独有的特征,这个特征,我们倾向称之为噪声。
      过拟合的具体表现就不细谈了,可以看到根本的原因就是建立的模型过于复杂了,我们想要让这个模型简单点,拟合的函数简单点,这个时候就需要给拟合的函数加一些约束了。机器学习模型里也是有好多种约束,来使得模型的参数不能那么复杂。
      直观的想,既然模型的参数构建出的函数过于复杂,那就把参数减掉一些,让一部分参数不起作用。这个思想就能产生很多防止过拟合的方法。但是回到数学的角度上,模型的学习过程,是最小化损失函数的过程。我们可以给模型加一个约束,这个约束通过损失来呈现,一旦学出来的模型过于复杂,就让模型产生较大的损失。我们可以通过参数的范数来解决这个问题。
      回想大名鼎鼎的0范数,就是矩阵中(向量)中的非零元素的个数。如果零元素较少,范数就大,可以直接把0范数加权组合进损失函数,就可以很自然的使得参数零的个数增多。因为为了减少损失,模型或多或少的想要去减少0范数,要减少,参数中就得更多的元素变成0。这样得到的模型就非常稀疏了。
      但是零范数的函数是个极限,难以近似。优化损失函数一般都是梯度下降法,0范数,不可导啊,既然不可导,没有导数,怎么下降。
      这个时候就需要使用一范数来近似了,就得到了L1正则化, ∣ ∣ w ∣ ∣ 1 = ∑ i ∣ w i ∣ ||w||_1=\sum_i|w_i| w1=iwi,对所有的参数的绝对值求和。直观来想,如果参数的绝对值之和比较大,也说明参数很复杂,如果让参数的1范数变得足够小,那么过拟合就没有那么严重了。
      这样模型的总损失就变成了 J ( w , b ) = J 0 ( W , b ) + λ ∣ ∣ w ∣ ∣ 1 J(w,b)=J_0(W,b)+\lambda||w||_1 J(w,b)=J0(W,b)+λw1,这样在让一范数变小的时候,自然就会有许多的参数被下降到0了。也就起到了正则化的作用。同时有足够多的参数值变成0,这就是一个稀疏的模型。所以L1正则化具有模型稀疏的特点。
      但是一范数使用绝对值,绝对值函数我们都知道在 w i = 0 w_i=0 wi=0点是一个不可导点,如果众多参数中有一个为0,这个时候就没法求梯度了,所以会给梯度下降带来阻力,需要使用其他技巧来优化,这样L1正则化的一个弊端就出来了,那就是优化的慢。
      范数之间有等价性,1范数可以正则化,2范数可以正则化算是一个比较自然的事情。(L2正则化并不是矩阵的2范数,而是矩阵的F范数),L2范数使用平方项的话,函数就是处处可导的,这样对于2范数做梯度下降就比较容易一些。所以相对于L1正则化,L2正则化收敛的更加快一点
      L2对参数约束,也能够使得部分参数变得小一点,起的影响就小,使得模型不是非常复杂,但是二范数的约束,可以让参数变得更小,可能参数小到一定程度,产生的影响已经被忽略了,这个参数就不是2范数的主要影响因素了,这个时候该参数就不会继续减小。所以L2 正则化能够得到比较小的参数,小到可以被忽略,但是无法小到0,也就不具有稀疏性
      使用L2正则化的时候,求导之后做梯度下降,参数的变化可以看成每次在原来的基础上乘一个小于1的因子,这样可以理解为L2正则化让参数衰减,所以L2正则化又叫权重衰减(Weight Decay)。
      网上有人解释说,L1正则化相当于一个菱形(参数的范数)和椭圆(损失函数的等高线)求最先交上的点,然后比较大概率的落到菱形的角上,使用L2正则化相当于圆(参数的参数)和椭圆求最先交上的点,事实上,这个观点是错误的。但是作为帮助理解记忆还是可以的。为什么L1范数比L2范数更容易得到稀疏性,这是由梯度下降算法和范数的特点决定的,具体原因这里不展开。
      了解了L1和L2正则化,这里做一个拓展。在机器学习中,线性回归模型,如果使用L1正则化,则得到的模型叫Lasso模型,如果使用L2正则化,则得到的模型叫岭(Ridge)回归。
      可能还有一个问题没解决,为什么说L1正则的先验分布是Laplace分布,L2正则先验是Gaussian分布,这个问题就得回到贝叶斯统计上。我们计算一个模型,用一个模型去对数据做判别,相当于求数据和参数的条件下,数据的标签y的最大后验分布。 p ( y ∣ x , w ) ∝ p ( w ∣ y , x ) / p ( w ) p(y|x,w)\propto p(w|y,x)/p(w) p(yx,w)p(wy,x)/p(w),对这个公式取对数得到 l o g p ( y ∣ x , w ) ∝ l o g p ( w ∣ y , x ) − l o g p ( w ) logp(y|x,w)\propto logp(w|y,x)-logp(w) logp(yx,w)logp(wy,x)logp(w),把正则化参数当成先验概率, L 1 = − l o g p ( w ) = ∣ w ∣ → p ( w ) = e − ∣ w ∣ L_1=-logp(w)=|w|\rightarrow p(w)=e^{-|w|} L1=logp(w)=wp(w)=ew,得到拉普拉斯分布的核。同理 L 2 = − l o g p ( w ) = w 2 → p ( w ) = e − w 2 L_2=-logp(w)=w^2\rightarrow p(w)=e^{-w^2} L2=logp(w)=w2p(w)=ew2,得到高斯分布的核。
      以上是我的个人理解,如果有不当的地方,请指出。

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

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

    万次阅读 多人点赞 2018-03-02 17:47:40
    什么是正则化,为什么使用正则化,如何实现正则化 ,外加一些对 范数 的直观理解并进行知识整理以供查阅 Why & What 正则化 我们总会在各种地方遇到正则化这个看起来很难理解的名词,其实它并没有那么高冷,很好理解...
  • 【机器学习】一文读懂正则化与LASSO回归,Ridge回归

    万次阅读 多人点赞 2018-10-10 20:53:35
    该文已经收录到专题机器学习进阶之路当中,欢迎大家关注。 1.过拟合 当样本特征很多,样本数相对较少时,模型容易陷入过拟合。为了缓解过拟合问题,有两种...正则化是结构风险(损失函数+正则化项)最小化策略的体...
  • 正则化的理解

    万次阅读 多人点赞 2018-08-13 21:07:02
    目录 一、Why &amp; What 正则化 1 概念 2、先讨论几个问题: ...首先,从使用正则化解决了一个什么问题的角度来看:正则化是为了防止过拟合, 进而增强泛化能力。用白话文转义,泛化误差(generalizatio...
  • 正则化

    千次阅读 2019-11-15 22:11:31
    正则化法4.1定义4.2 对正则化理解4.3正则化法分类4.3.1 L1/L2正则化法4.3.2 Dropout法4.3.3 从贝叶斯角度理解正则化5.提前终止法与正则化法之前关系参考资料 1.泛化问题   上一篇文章深入理解泛化提及了泛化问题...
  • 机器学习中正则项L1和L2的直观理解

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

    千次阅读 热门讨论 2021-08-29 15:17:41
    正则化逻辑回归-python实现机器学习前言一、基础概念二、构造损失函数三、梯度下降法求解最小值四、正则化逻辑回归总结 基于吴恩达机器学习的习题 逻辑回归github地址 前言 机器学习是从人工智能中产生的一个重要...
  • 归一化和正则化

    千次阅读 2019-08-05 15:11:30
    归一化和正则化1、归一化1.1为什么要归一化1.2 如何进行归一化2、正则化2.1、为什么要进行正则化2.2 如何进行正则化惩罚 1、归一化 1.1为什么要归一化 在做梯度下降的时候,我们用的数据集并不像前面给的数据集那么...
  • 一、什么是正则化,用来干嘛的? 正则化(regularization),是指在线性代数理论中,不适定问题通常是由一组线性代数方程定义的,而且这组方程组通常来源于有着很大的条件数的不适定反问题。大条件数意味着舍入误差或...
  • 线性回归中的L1与L2正则化

    千次阅读 2021-02-26 08:51:16
    描述回归建模中的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...
  • pytorch实现正则化

    万次阅读 2019-07-31 20:40:00
    机器学习中几乎都可以看到损失函数后面会添加一个额外项,常用的额外项一般有两种,称作**L1正则化和L2正则化,或者L1范数和L2范数**。 L1 正则化和 L2 正则化可以看做是损失函数的惩罚项。所谓 “惩罚” 是指对损失...
  • keras中添加正则化

    万次阅读 2019-04-08 10:53:25
    正则正则项在优化过程中层的参数或层的激活值添加惩罚项,这些惩罚项将与损失函数一起作为网络的最终优化目标 惩罚项基于层进行惩罚,目前惩罚项的接口与层有关,但Dense, Conv1D, Conv2D, Conv3D具有共同的...
  • 神经网络中的正则化 学习记录自:deeplearning.ai-andrewNG-master 在开始之前,先让我们来看看正则化模型与非正则化训练效果。 非正则化模型与正则化模型的比较 预分类数据 非正则化分类结果 损失函数迭代图: ...
  • 上篇分析了Keras实现Dropout层的原理Keras防止过...L2正则化比L1更适合解决过拟合问题(L2正则化最后可以得到一个参数都比较小的模型,抗扰动能力强),L1正则化则有利于产生稀疏矩阵、特征选择。所以在解决过拟合问题
  • 在数学,统计学和计算机科学中,特别是机器学习和反问题,正则化是为了解决不适定问题或防止过拟合而引入额外信息的过程。 1.不适定问题 图像处理中,不适定问题也称为反问题。上世纪90年代法国数学家阿达玛提出了...
  • 机器学习之正则化 (Regularization) 1.参数正则化 1.1 L2 Regularization(Ridge Regression,权重衰减) 1.2 L1 Regularization:将噪点相关权重系数设为0(也叫稀疏正则化) 1.3 L1/L2对比: 2. 经验正则化(早停...
  • Tikhonov正则化选取的方法

    万次阅读 多人点赞 2018-12-20 09:28:30
    Tikhonov正则化方法由Andrey Tikhonov命名,最常用来进行不适定问题的正则化。在统计学中,这种方法称为“岭回归”,在机器学习领域,被称为“weight decay”。在更多的独立研究中,同样称为Tikhonov-Miller方法、...
  • 深度学习中的正则化:你必须了解的一些基本概念 机器学习中的一个核心问题是设计不仅在训练数据上表现好,而且能在新输入上泛化好的算法。在机器学习中,许多策略被显示地设计来减少测试误差(可能会以增大训练误差...
  • 将L1、L2或L1和L2正则化同时应用于线性回归 你可能听说过“Ridge”、“Lasso”和“ElasticNet”这样的术语。这些技术术语背后的基本概念都是正规化。在这篇文章中我们将详细进行说明。 一般情况下,使用正则化的目的...
  • 先对“L1正则化和L2正则化的区别、应用场景”给出结论,具体见后面的原理解释: L1正则化会产生更稀疏的解,因此基于L1正则化的学习方法相当于嵌入式的特征选择方法. L2正则化计算更加方便,只需要计算向量内积,L1...
  • 深度神经网络之正则化

    万次阅读 多人点赞 2018-07-04 11:11:36
    之前介绍的文章之中,我们已多次接触到正则化方法,但没有详细的解释为什么要正则化,什么是正则化,以及L1正则化和L2正则化的区别。本次文章之中,我们将详解机器学习中正则化的概念和深度神经网络中的正则化方法。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 373,608
精华内容 149,443
关键字:

正则化