0
0

机器学习：过拟合、欠拟合、正则化之间的纸短情长～

机器学习：过拟合与欠拟合是如何被解决的？

什么是过拟合与欠拟合

机器学习的主要挑战是我们的算法能够在为观测的数据上误差较小，而不是在只在训练集上表现良好，我们这种能力我们称之为泛化。
在这里插入图片描述

过拟合

如上右图所示，模型通过训练集很好的拟合了观测数据，训练误差很小，但是由于过度的在训练集上拟合，当其用于推理测试数据时，误差很可能会变大，因为数据是有噪声的并且其本身与真实概率分布也有一定偏差，训练集的概率分布与真实概率分布还是有一定差距的，当模型过度的接近训练集的概率分布，那么他就会随着训练轮数的增加而远离真实的概率分布（这里我们假设测试集复合真实概率分布），以上的情况我们称之为过拟合。

欠拟合

如上左图所示，模型通过训练集拟合的直线不能很好的拟合图中的观测值，训练误差和泛化误差都非常高，我们称之为欠拟合。

如何解决过拟合

L2正则化（权重衰减）

谈到正则化，我们继续观察上面过拟合图像，函数过度的复杂了（太弯弯绕了～），我们首先想到的一定是降低他的复杂度，也就是说我们要减少权重参数的维度与大小（权重衰减），它的维度决定了图像他有个拐点，大小则决定了图像弯曲程度。那么我们就有了一个想法了💡！
我们从权重衰减的方向入手（也就是参数的大小）：
我们让权重参数的二范数小于某个值来约束它。在优化损失函数（以MSE为例）的时候可得如下方程组：

  1.      {
  2.     
  3.     
  4.      
  5.       
  6.        
  7.         
  8.          
  9.           min
  10.          
  11.          
  12.           ⁡
  13.          
  14.          
  15.           
  16.            
  17.             1
  18.            
  19.            
  20.             n
  21.            
  22.           
  23.          
  24.          
  25.           
  26.            ∑
  27.           
  28.           
  29.            
  30.             i
  31.            
  32.            
  33.             =
  34.            
  35.            
  36.             1
  37.            
  38.           
  39.           
  40.            n
  41.           
  42.          
  43.          
  44.           
  45.            
  46.             (
  47.            
  48.            
  49.             
  50.              w
  51.             
  52.             
  53.              i
  54.             
  55.            
  56.            
  57.             
  58.              x
  59.             
  60.             
  61.              i
  62.             
  63.            
  64.            
  65.             −
  66.            
  67.            
  68.             
  69.              y
  70.             
  71.             
  72.              i
  73.             
  74.            
  75.            
  76.             )
  77.            
  78.           
  79.           
  80.            2
  81.           
  82.          
  83.         
  84.        
  85.       
  86.      
  87.      
  88.       
  89.        
  90.         
  91.          
  92.           
  93.            
  94.             ∥
  95.            
  96.            
  97.             w
  98.            
  99.            
  100.             ∥
  101.            
  102.           
  103.           
  104.            2
  105.           
  106.           
  107.            2
  108.           
  109.          
  110.          
  111.           <
  112.          
  113.          
  114.           =
  115.          
  116.          
  117.           σ
  118.          
  119.         
  120.        
  121.       
  122.      
  123.     
  124.    
  125.    
  126.     \begin{cases}\min \dfrac{1}{n}\sum ^{n}_{i=1}\left( w_{i}x_{i}-y_{i}\right) ^{2}\\ \left\| w\right\| _{2}^{2}<= \sigma\end{cases}
  127.    
  128.   
  129.  ⎩⎨⎧​minn1​∑i=1n​(wi​xi​−yi​)2∥w∥22​<=σ​

这里我们根据拉格朗日乘子法 ，可以把在约束内求最值，改成无范围求最值。得到下方方程（lambda为惩罚系数）：

  1.      L
  2.     
  3.     
  4.      
  5.       (
  6.      
  7.      
  8.       w
  9.      
  10.      
  11.       )
  12.      
  13.     
  14.     
  15.      =
  16.     
  17.     
  18.      
  19.       1
  20.      
  21.      
  22.       n
  23.      
  24.     
  25.     
  26.      
  27.       ∑
  28.      
  29.      
  30.       
  31.        i
  32.       
  33.       
  34.        =
  35.       
  36.       
  37.        1
  38.       
  39.      
  40.      
  41.       n
  42.      
  43.     
  44.     
  45.      
  46.       (
  47.      
  48.      
  49.       
  50.        w
  51.       
  52.       
  53.        i
  54.       
  55.      
  56.      
  57.       
  58.        x
  59.       
  60.       
  61.        i
  62.       
  63.      
  64.      
  65.       −
  66.      
  67.      
  68.       
  69.        y
  70.       
  71.       
  72.        i
  73.       
  74.      
  75.      
  76.       )
  77.      
  78.     
  79.     
  80.      +
  81.     
  82.     
  83.      
  84.       1
  85.      
  86.      
  87.       2
  88.      
  89.     
  90.     
  91.      λ
  92.     
  93.     
  94.      
  95.       ∑
  96.      
  97.      
  98.       
  99.        i
  100.       
  101.       
  102.        =
  103.       
  104.       
  105.        1
  106.       
  107.      
  108.      
  109.       n
  110.      
  111.     
  112.     
  113.      
  114.       
  115.        (
  116.       
  117.       
  118.        
  119.         w
  120.        
  121.        
  122.         i
  123.        
  124.       
  125.       
  126.        )
  127.       
  128.      
  129.      
  130.       2
  131.      
  132.     
  133.    
  134.    
  135.     L\left( w\right) =\dfrac{1}{n}\sum ^{n}_{i=1}\left( w_{i}x_{i}-y_{i}\right) + \dfrac{1}{2} \lambda\sum ^{n}_{i=1}\left( w_{i}\right) ^{2}
  136.    
  137.   
  138.  L(w)=n1​i=1∑n​(wi​xi​−yi​)+21​λi=1∑n​(wi​)2

根据梯度下降法(

  1.     α
  2.    
  3.   
  4.   
  5.    \alpha
  6.   
  7.  
  8. α为learning rate)，我们继续化简：
  10.  
  11.   
  12.    
  13.     
  14.      
  15.       
  16.        
  17.         
  18.          
  19.           W
  20.          
  21.          
  22.           
  23.            n
  24.           
  25.           
  26.            e
  27.           
  28.           
  29.            w
  30.           
  31.          
  32.         
  33.         
  34.          =
  35.         
  36.         
  37.          W
  38.         
  39.         
  40.          −
  41.         
  42.         
  43.          α
  44.         
  45.         
  46.          L
  47.         
  48.         
  49.          
  50.           
  51.            (
  52.           
  53.           
  54.            w
  55.           
  56.           
  57.            )
  58.           
  59.          
  60.          
  61.           ′
  62.          
  63.         
  64.        
  65.       
  66.      
  67.     
  68.     
  69.      
  70.       
  71.        
  72.         
  73.          =
  74.         
  75.         
  76.          W
  77.         
  78.         
  79.          −
  80.         
  81.         
  82.          α
  83.         
  84.         
  85.          x
  86.         
  87.         
  88.          −
  89.         
  90.         
  91.          λ
  92.         
  93.         
  94.          α
  95.         
  96.         
  97.          w
  98.         
  99.        
  100.       
  101.      
  102.     
  103.     
  104.      
  105.       
  106.        
  107.         
  108.          =
  109.         
  110.         
  111.          
  112.           (
  113.          
  114.          
  115.           1
  116.          
  117.          
  118.           −
  119.          
  120.          
  121.           α
  122.          
  123.          
  124.           x
  125.          
  126.          
  127.           )
  128.          
  129.         
  130.         
  131.          w
  132.         
  133.         
  134.          −
  135.         
  136.         
  137.          α
  138.         
  139.         
  140.          x
  141.         
  142.        
  143.       
  144.      
  145.     
  146.    
  147.    
  148.     \begin{aligned}W_{new}=W-\alpha L\left( w\right)^\prime \\ =W-\alpha x-\lambda \alpha w\\ =\left( 1-\alpha x\right) w-\alpha x\end{aligned}
  149.    
  150.   
  151.  Wnew​=W−αL(w)′=W−αx−λαw=(1−αx)w−αx​

我们发现，参数w每回合都在慢慢减少，权重系数减少，也就是对数据与噪声变得不敏感（曲线越平滑，根据泰勒展开可知），相对来讲，也就是降低了数据的拟合程度从而缓解过拟合。

这里我们要注意，其中衰减的参数包含偏置系数b，因为权重系数决定了模型推理结果的方差，而偏置系数决定了偏差，不能缓解过拟合。

代码实现

  1. %matplotlib inline
  2. import torch
  3. from torch import nn
  4. from d2l import torch as d2l
  6. n_train, n_test, num_inputs, batch_size =20,100,200,5
  7. true_w, true_b = torch.ones((num_inputs,1))*0.05,0.05
  8. train_data = d2l.synthetic_data(true_w, true_b,n_train)
  9. train_iter = d2l.load_array(train_data, batch_size)
  10. test_data = d2l.synthetic_data(true_w, true_b, n_train)
  11. test_iter = d2l.load_array(test_data,batch_size, is_train=False)definit_params():
  12.     w = torch.normal(0,1,size=(num_inputs,1),requires_grad =True)
  13.     b = torch.zeros(1,requires_grad =True)return[w,b]defl2_penalty(w):return torch.sum(torch.abs(w))
  14. num_epochs, lr =1000,0.003deftrain(lambd):
  15.     w,b = init_params()
  16.     net,loss =lambda X : d2l.linreg(X,w,b), d2l.squared_loss
  17.     animator = d2l.Animator(xlabel='epochs', ylabel='loss', yscale='log',
  18.                             xlim=[5, num_epochs], legend=['train','test'])for epoch inrange(num_epochs):for X,y in train_iter:
  19.             l = loss(net(X),y)+lambd*l2_penalty(w)
  20.             l.sum().backward()
  21.             d2l.sgd([w,b],lr,batch_size)if(epoch +1)%5==0:
  22.             animator.add(epoch +1,(d2l.evaluate_loss(net, train_iter, loss),
  23.                                      d2l.evaluate_loss(net, test_iter, loss)))print('w的L2范数是：', torch.norm(w).item())
  24.  train(lambd=1)

降维

剔除掉冗余的特征和比重不大的特征，原因。
2. 采用合适的模型（控制模型的复杂度）

采用合适的模型

过于复杂的模型会带来过拟合问题。对于模型的设计，目前公认的一个深度学习规律"deeper is better"。国内外各种大牛通过实验和竞赛发现，对于CNN来说，层数越多效果越好，但是也更容易产生过拟合，并且计算所耗费的时间也越长。

根据奥卡姆剃刀法则：在同样能够解释已知观测现象的假设中，我们应该挑选“最简单”的那一个。对于模型的设计而言，我们应该选择简单、合适的模型解决复杂的问题。

数据增强

如何解决欠拟合

欠拟合的问题一般出现在训练开始，随着训练的深入，一般此问题会不攻自破，我们一般采用：

  1. 增加模型的复杂度（比如从直线->曲线）。
  2. 增加数据维度（维度数应该远远小于数据的数量，否则可能出现过拟合）。
  3. 增加数据量。
标签： 机器学习 人工智能 深度学习
本文转载自: https://blog.csdn.net/qq_18555105/article/details/126810216
版权归原作者 HanZee 所有， 如有侵权，请联系我们删除。
登录后发布评论

“机器学习：过拟合、欠拟合、正则化之间的纸短情长～”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？