精华内容
下载资源
问答
  • 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”:


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

    展开全文
  • 首先我们看一下在机器学习中的损失函数上述公式中的第二项就是正则项我们为什么要使用正则化? 我们对梯度下降的式子进行推导一下: 故: θj:=θj−[1m∑i=1n(hθ(x(i))−y(i))2+2λθj] 由上可以看出,当正则项...

    首先我们看一下在机器学习中的损失函数

    82b24208d63448de1b5189c115e5f346.png

    上述公式中的第二项就是正则项

    我们为什么要使用正则化?

    b791601211256c93e6c21f7b0638f862.png

    b2cb3c7aa82074142e5371b3b1245937.png


    我们对梯度下降的式子进行推导一下:

    8c049ecfdd4bc39cc12e94099662f03a.png

    故: θj:=θj−[1mi=1n((x(i))−y(i))2+2λθj]

    由上可以看出,当正则项系数 λ 很大时,对参数的惩罚也将很大,导致在梯度更新后对应的 θj 值很小。由此可以使得对某些参数最终接近于 0 。而正则项系数 λ 即为模型复杂度的惩罚项,当其很大时,模型复杂度将变小,也就是模型将更为简单,不会使得对数据过于拟合。

    从结构风险最小化角度来说,就是在经验风险最小化的基础上(即训练误差最小化),尽可能采用简单的模型,以此提高泛化预测精度。

    使用正则化,我们通常用L1正则化和L2正则化,那么它们有什么区别呢?

    d548d9a8a79dd82788bc438958756c62.png

    8f47741d6200cad9afdad05d2c0baf44.png
    • L1是模型各个参数的绝对值之和。
    • L2是模型各个参数的平方和的开方值。
    • L1会趋向于产生少量的特征,而其他的特征都是零,因为最优的参数值很大概率出现在坐标轴上,这样就会导致某一维的权重为零,产生稀疏权重矩阵。
    • L2会选择更多的特征,这些特征都会接近于零,最优的参数值很小概率出现在坐标轴上,因此每一维的参数都不会是零,当最小化‖w‖时,就会使每一项趋近于零。
    展开全文
  • L1正则化和L2正则化的详细直观解释

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

    正则化(Regularization)

    转自:此处

    机器学习中几乎都可以看到损失函数后面会添加一个额外项,常用的额外项一般有两种,一般英文称作ℓ1ℓ1-normℓ2ℓ2-norm,中文称作L1正则化L2正则化,或者L1范数L2范数

    L1正则化和L2正则化可以看做是损失函数的惩罚项。所谓『惩罚』是指对损失函数中的某些参数做一些限制。对于线性回归模型,使用L1正则化的模型建叫做Lasso回归,使用L2正则化的模型叫做Ridge回归(岭回归)。下图是Python中Lasso回归的损失函数,式中加号后面一项α||w||1α||w||1即为L1正则化项。

    lasso regression

    下图是Python中Ridge回归的损失函数,式中加号后面一项α||w||22α||w||22即为L2正则化项。

    ridge regression

    一般回归分析中回归ww表示特征的系数,从上式可以看到正则化项是对系数做了处理(限制)。L1正则化和L2正则化的说明如下:

    • L1正则化是指权值向量ww中各个元素的绝对值之和,通常表示为||w||1||w||1
    • L2正则化是指权值向量ww中各个元素的平方和然后再求平方根(可以看到Ridge回归的L2正则化项有平方符号),通常表示为||w||2||w||2

    一般都会在正则化项之前添加一个系数,Python中用αα表示,一些文章也用λλ表示。这个系数需要用户指定。

    那添加L1和L2正则化有什么用?下面是L1正则化和L2正则化的作用,这些表述可以在很多文章中找到。

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

    稀疏模型与特征选择

    上面提到L1正则化有助于生成一个稀疏权值矩阵,进而可以用于特征选择。为什么要生成一个稀疏矩阵?

    稀疏矩阵指的是很多元素为0,只有少数元素是非零值的矩阵,即得到的线性回归模型的大部分系数都是0. 通常机器学习中特征数量很多,例如文本处理时,如果将一个词组(term)作为一个特征,那么特征数量会达到上万个(bigram)。在预测或分类时,那么多特征显然难以选择,但是如果代入这些特征得到的模型是一个稀疏模型,表示只有少数特征对这个模型有贡献,绝大部分特征是没有贡献的,或者贡献微小(因为它们前面的系数是0或者是很小的值,即使去掉对模型也没有什么影响),此时我们就可以只关注系数是非零值的特征。这就是稀疏模型与特征选择的关系。

    L1和L2正则化的直观理解

    这部分内容将解释为什么L1正则化可以产生稀疏模型(L1是怎么让系数等于零的),以及为什么L2正则化可以防止过拟合

    L1正则化和特征选择

    假设有如下带L1正则化的损失函数: 


    其中J0是原始的损失函数,加号后面的一项是L1正则化项,α是正则化系数。注意到L1正则化是权值的绝对值之和,JJ是带有绝对值符号的函数,因此JJ是不完全可微的。机器学习的任务就是要通过一些方法(比如梯度下降)求出损失函数的最小值。当我们在原始损失函数J0J0后添加L1正则化项时,相当于对J0J0做了一个约束。令L=α∑w|w|L=α∑w|w|,则J=J0+LJ=J0+L,此时我们的任务变成在L约束下求出J0取最小值的解。考虑二维的情况,即只有两个权值w1和w2,此时L=|w1|+|w2|L=|w1|+|w2|对于梯度下降法,求解J0J0的过程可以画出等值线,同时L1正则化的函数LL也可以在w1w2的二维平面上画出来。如下图:

     

    @图1 L1正则化 
    图1 L1正则化

    图中等值线是J0的等值线,黑色方形是L函数的图形。在图中,当J0等值线与L图形首次相交的地方就是最优解。上图中J0与L在L的一个顶点处相交,这个顶点就是最优解。注意到这个顶点的值是(w1,w2)=(0,w)(w1,w2)=(0,w)。可以直观想象,因为L函数有很多『突出的角』(二维情况下四个,多维情况下更多),J0与这些角接触的机率会远大于与L其它部位接触的机率,而在这些角上,会有很多权值等于0,这就是为什么L1正则化可以产生稀疏模型,进而可以用于特征选择。

    而正则化前面的系数α,可以控制L图形的大小。α越小,L的图形越大(上图中的黑色方框);α越大,L的图形就越小,可以小到黑色方框只超出原点范围一点点,这是最优点的值(w1,w2)=(0,w)(w1,w2)=(0,w)中的w可以取到很小的值。

    类似,假设有如下带L2正则化的损失函数: 


    同样可以画出他们在二维平面上的图形,如下:

     

    @图2 L2正则化 
    图2 L2正则化

    二维平面下L2正则化的函数图形是个圆,与方形相比,被磨去了棱角。因此J0J0与LL相交时使得w1或w2等于零的机率小了许多,这就是为什么L2正则化不具有稀疏性的原因。

    L2正则化和过拟合

    拟合过程中通常都倾向于让权值尽可能小,最后构造一个所有参数都比较小的模型。因为一般认为参数值小的模型比较简单,能适应不同的数据集,也在一定程度上避免了过拟合现象。可以设想一下对于一个线性回归方程,若参数很大,那么只要数据偏移一点点,就会对结果造成很大的影响;但如果参数足够小,数据偏移得多一点也不会对结果造成什么影响,专业一点的说法是『抗扰动能力强』。

    那为什么L2正则化可以获得值很小的参数?

    以线性回归中的梯度下降法为例。假设要求的参数为θ,hθ(x)是我们的假设函数,那么线性回归的代价函数如下: 


    那么在梯度下降法中,最终用于迭代计算参数θ的迭代式为: 


    其中α是learning rate. 上式是没有添加L2正则化项的迭代公式,如果在原始代价函数之后添加L2正则化,则迭代公式会变成下面的样子: 


    其中λλ就是正则化参数。从上式可以看到,与未添加L2正则化的迭代公式相比,每一次迭代,θj都要先乘以一个小于1的因子,从而使得θj不断减小,因此总得来看,θ是不断减小的。

     

    最开始也提到L1正则化一定程度上也可以防止过拟合。之前做了解释,当L1的正则化系数很小时,得到的最优解会很小,可以达到和L2正则化类似的效果。

    正则化参数的选择

    L1正则化参数

    通常越大的λλ可以让代价函数在参数为0时取到最小值。下面是一个简单的例子,这个例子来自Quora上的问答。为了方便叙述,一些符号跟这篇帖子的符号保持一致。

    假设有如下带L1正则化项的代价函数: 


    其中xx是要估计的参数,相当于上文中提到的ww以及θθ. 注意到L1正则化在某些位置是不可导的,当λλ足够大时可以使得F(x)F(x)在x=0x=0时取到最小值。如下图:

     

    @图3 L1正则化参数的选择 
    图3 L1正则化参数的选择

    分别取λ=0.5和λ=2,可以看到越大的λλ越容易使F(x)在x=0时取到最小值。

    L2正则化参数

    从公式5可以看到,λλ越大,θj衰减得越快。另一个理解可以参考图2,λ越大,L2圆的半径越小,最后求得代价函数最值时各参数也会变得很小。

    Reference

    过拟合的解释: 
    https://hit-scir.gitbooks.io/neural-networks-and-deep-learning-zh_cn/content/chap3/c3s5ss2.html

    正则化的解释: 
    https://hit-scir.gitbooks.io/neural-networks-and-deep-learning-zh_cn/content/chap3/c3s5ss1.html

    正则化的解释: 
    http://blog.csdn.net/u012162613/article/details/44261657

    正则化的数学解释(一些图来源于这里): 
    http://blog.csdn.net/zouxy09/article/details/24971995

    展开全文
  • 考虑一个非常简单的优化问题 L2正则化约束加上L2正则化约束后,优化问题变成了 ,该问题的最优解为 ,当且仅当 时,最优解为0.L1正则化约束加上L1正则化约束后,优化问题成为 ,简单分类讨论一下,有三种情况:其中...

    本学期是机器学习课的助教,布置作业过程中看到这个有趣的问题。

    考虑一个非常简单的优化问题

    L2正则化约束

    加上L2正则化约束后,优化问题变成了

    ,该问题的最优解为
    ,当且仅当
    时,最优解为0.

    L1正则化约束

    加上L1正则化约束后,优化问题成为

    ,简单分类讨论一下,有三种情况:

    a57c6a75544e5e940ea1f694a87bc517.png

    其中,

    时,最优解均为0.

    总结

    由此可以看到,采用L1正则化,最优解为0的条件为

    ;而在L2正则化时,最优解为0当且仅当
    。所以,
    采用L1正则化,最优解为0的概率极大增加,这使得得到的解更可能是稀疏的

    这里仅对一维的简单情况进行了分析,但是它可以拓展到高维情况,以至于一般的线性回归的情况。

    展开全文
  • L1 正则化与嵌入式特征选择 (稀疏性)岭回归的历史可追溯到 1943 年由 A.Tikhonov 发表在苏联科学院院刊上的一篇文章, 我们知道计算机是在 1946 年发明出来的, 由此可见, 这是一个历史悠久的算法, 至今依旧有生命力, ...
  • 转:L1正则化与稀疏性 L1正则化使得模型参数具有稀疏性的原理是什么? 机器学习经典之作《pattern recognition and machine learning》中的第三章作出的一个解释无疑是权威且直观的,我们也经常都是从这个角度出发,...
  • 线性模型和广义线性模型已广泛地用于社会经济、生产实践和科学研究中的数据分析和数据挖掘等领域,如公司财务...实验结果表明L1正则化Logistic回归模型的有效性,其在保证模型预测精度的同时提高模型的解释性. 更多还原
  • L1正则化技术F(w;x,y)=J(w;x,y)+α∣∣w∣∣1=J(w;x,y)+α∑i=1n∣wi∣假设w∗是损失函数J(w;x,y)最优解,J(w;x,y)在w∗处泰勒展J(w;x,y)=J(w∗;x,y)+J′(w∗;x,y)(w−w∗)+12!J′′(w∗;x,y)(w−w∗)2 ∵w∗是J(w;...
  • python机器学习库sklearn——Lasso回归(L1正则化

    万次阅读 多人点赞 2018-04-06 09:00:56
    全栈工程师开发手册 (作者:栾鹏) python数据挖掘系列教程 The Lasso 是估计稀疏系数的线性模型。 它在一些情况下是有用的,因为它倾向...在数学公式表达上,它由一个带有ℓ1 \ell_1 先验的正则项的线性模型组成。
  • # 首先给大家推荐一个比较直观地搞懂L1和L2正则化的思考,有视频有图像,手动赞! ... ... 回到问题,为什么L1...要使得J(θ)在坐标轴之外的地方和L1正则化的框框相交,只有在J(θ)的长轴的斜率是-1的时候(为了方便说明,
  • 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...
  • 1、L1正则化(稀疏矩阵) 权值向量w中各个元素的绝对值之和: 2、L2正则化(权重衰减) 权值向量w中各个元素的平方和: 3、L1正则化 VS L2正则化 L1正则化可以产生稀疏权值矩阵,即产生一个稀疏模型,可以用于特征选择...
  • L1正则化和L2正则化

    2021-01-10 00:32:38
    【深度学习】L1正则化和L2正则化 在机器学习中,我们非常关心模型的预测能力,即模型在新数据上的表现,而不希望过拟合现象的的发生,我们通常使用正则化(regularization)技术来防止过拟合情况。正则化是机器学习...
  • # L2正则化 from keras import regularizers model = models.Sequential() # l2(0.001)是指该层权重矩阵每个系数都会使网络总损失增加0.001*weight_coefficient_value # 由于这个惩罚项只在...
  • 一、参数方法和非参数方法在讲正则化之前,需要介绍2个概念。机器学习的方法,可以大致分成两类。参数方法(Parametric Methods)通过训练来确定一组参数。当我们参数的值定下来,可以说预测的过程已经跟之前的训练集...
  • 损失函数的惩罚项机器学习中,一般损失函数后边会添加一个额外项,一般称作L1正则化L2正则化或者L1范数L2范数。L1、L2正则化可以看做是损失函数的惩罚项。对于线性回归模型,使用L1正则化得模型称作Lasso回归,使用...
  • 从实际角度来看,L1倾向于将系数缩小到零,而L2倾向于均匀地缩小系数。因此,L1对于特征选择很有用,因为我们可以删除任何与系数趋于零相关的变量。另一方面,当你有共线/相互依赖的特性时,L2是有用的。 一般来说,...
  • L1正则化与L2正则化

    2020-08-04 23:22:20
      分为L1正则化和L2正则化两种。首先,我们假定网络中原本的损失函数为:    其中,w为网络的权重值,b为偏置值。   添加L1正则化后损失函数的形式可以表示为:   即在最后添加了权重绝对值的和。 其中,...
  • L1正则化 L2正则化的Python 实现

    千次阅读 2019-01-11 21:21:34
    上一篇文档 ... 本文介绍L1, L2 正则化的实现 L1正则化 代码 def L1Norm(l, theta): return np.dot(np.abs(theta), np.ones(theta.size)) * l def L1N...
  • L1正则化和L2正则化讲解   在机器学习实践过程中,训练模型的时候往往会出现过拟合现象,为了减小或者避免在训练中出现过拟合现象,通常在原始的损失函数之后附加上正则项,通常使用的正则项有两种:L1正则化和L2...
  • L1正则化与L2正则化的区别

    千次阅读 2018-12-10 20:45:36
    本文从正则化的本质p-范数入手,解释了L1正则化和L2正则化的区别。 正则化 在Cost Function上添加了正则化项,就能降低模型的过拟合程度,这就是正则化的作用。 关于正则化更细节的讲述,请参考为什么正则化能减少...
  • 损失函数的惩罚项机器学习中,一般损失函数后边会添加一个额外项,一般称作L1正则化L2正则化或者L1范数L2范数。L1、L2正则化可以看做是损失函数的惩罚项。对于线性回归模型,使用L1正则化得模型称作Lasso回归,使用...
  • L1正则化和L2正则化可以看做是损失函数的惩罚项。所谓“惩罚”是指对损失函数中的某些参数做一些限制 L1正则化是指权值向量w中各个元素的绝对值之和 L2正则化是指权值向量w中各个元素的平方和然后再求平方根 L1正则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,518
精华内容 1,007
关键字:

l1正则化