神经网络之防止过拟合

今天我们来看一下神经网络中防止模型过拟合的方法 

在机器学习和深度学习中，过拟合是指模型在训练数据上表现得非常好，但在新的、未见过的数据上表现不佳的现象。这是因为模型过于复杂，以至于它学习了训练数据中的噪声和细节，而不是数据的潜在分布。为了解决这个问题，正则化技术被引入，它通过在损失函数中添加一个惩罚项来对模型的复杂度进行限制。

正则化

之前我们在机器学习中介绍过：

• 过拟合：一个假设 在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据 (体现在准确率下降)，此时认为这个假设出现了过拟合的现象。(模型过于复杂)
• 欠拟合：一个假设 在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据 ，此时认为这个假设出现了欠拟合的现象。

我们当时的解决办法是重新清洗数据，导致过拟合的一个原因有可能是数据不纯，如果出现了过拟合就需要重新清洗数据；第二：增大数据的训练量，还有一个原因就是我们用于训练的数据量太小导致的，训练数据占总数据的比例过小；第三是正则化；第四个办法是减少特征维度。 

from sklearn.linear_model import Lasso  # L1正则
from sklearn.linear_model import Ridge  # 岭回归 L2正则 
 
X10 = np.hstack([X2,X**3,X**4,X**5,X**6,X**7,X**8,X**9,X**10]) 
estimator_l1 = Lasso(alpha=0.005,normalize=True) # 调整alpha 正则化强度 查看正则化效果
estimator_l1.fit(X10,y) 
y_predict_l1 = estimator_l1.predict(X10) 
 
plt.scatter(x,y) 
plt.plot(np.sort(x),y_predict_l1[np.argsort(x)],color = 'r') 
plt.show()
 
estimator_l1.coef_  # Lasso 回归  L1正则 会将高次方项系数变为0

我们总结一下线性回归中正则化的API：

• L1正则化：可以将某些特征的回归系数变为0

• L1正则化API：Lasso回归

from sklearn.linear_model import Lasso 

• L2正则化：每次梯度下降迭代都减小特征前面的系数
• L2正则化API：岭回归

from sklearn.linear_model import Ridge

• alpha：控制正则化的强度，即惩罚项系数的大小。较小的值表示更强的正则化，较大的值表示较弱的正则化。
• normalize：是否对数据进行标准化处理。如果设置为True，则在训练之前会对输入数据进行标准化处理，即将每个特征的均值变为0，标准差变为1。这有助于提高模型的性能和稳定性。

 所以正则化的常用方法包括：

• L1正则化：也称为Lasso回归，它通过惩罚模型参数的绝对值之和来鼓励稀疏性，有助于特征选择。
• L2正则化：也称为岭回归，它通过惩罚模型参数的平方和的平方根（即权重的平方和）来鼓励模型参数接近于0但不等于0。
• Dropout：这是一种在训练过程中随机丢弃一部分神经元的方法，强迫网络不过分依赖于任何一个特定的神经元，从而提高了模型的鲁棒性。
• 早停法（Early Stopping）：在训练过程中监控验证集的性能，一旦发现性能不再提升或开始下降，就停止训练，以防止过拟合。
• 数据增强：通过对训练数据进行扩充，如旋转、缩放等变换，可以有效地增加数据的多样性，减少过拟合的风险。

对于决策树和支持向量机等模型，可以使用集成学习方法进行正则化。集成学习方法通过组合多个不同的模型来提高泛化能力。其中，常见的集成学习方法包括bagging和boosting。Bagging通过对训练数据进行随机抽样生成多个子集，然后分别训练多个模型，最后将这些模型的结果进行平均或投票得到最终结果。Boosting则是通过迭代地训练一系列弱分类器，并将它们的结果加权求和得到最终结果。 

对于神经网络，可以使用Dropout方法进行正则化。Dropout是一种随机丢弃神经元的方法，可以有效地减少模型的复杂度，并提高模型的泛化能力。在训练过程中，每个神经元都有一定的概率被随机丢弃，从而迫使网络不过分依赖于任何一个特定的神经元。

Dropout

import torch
import torch.nn as nn
 
 
def func():
 
    
    dropout = nn.Dropout(p=0.8)
    
    inputs = torch.randint(0, 10, size=[5, 8]).float()
    print(inputs)
    print('-' * 50)
 
    outputs = dropout(inputs)
    print(outputs)
 
 
if __name__ == '__main__':
    func()
 
 
tensor([[1., 0., 3., 6., 7., 7., 5., 7.],
        [6., 8., 4., 6., 2., 0., 4., 1.],
        [1., 4., 6., 9., 3., 1., 2., 1.],
        [0., 6., 3., 7., 1., 7., 8., 9.],
        [5., 6., 8., 4., 1., 7., 5., 5.]])
--------------------------------------------------
tensor([[ 0.,  0., 15.,  0.,  0.,  0.,  0.,  0.],
        [ 0.,  0.,  0.,  0., 10.,  0.,  0.,  0.],
        [ 0.,  0.,  0., 45.,  0.,  0.,  0.,  0.],
        [ 0.,  0., 15.,  0.,  0.,  0.,  0.,  0.],
        [25.,  0.,  0.,  0.,  0.,  0.,  0., 25.]])

我们将 Dropout 层的概率 p 设置为 0.8，此时经过 Dropout 层计算的张量中就出现了很多 0 , 概率 p 设置值越大，则张量中出现的 0 就越多。上面结果的计算过程如下：

1. 先按照 p 设置的概率，随机将部分的张量元素设置为 0
2. 为了校正张量元素被设置为 0 带来的影响，需要对非 0 的元素进行缩放，其缩放因子为: 1/(1-p)，上面代码中 p 的值为 0.8， 根据公式缩放因子为：1/(1-0.8) = 5
3. 比如：第 3 个元素，原来是 5，乘以缩放因子之后变成 25。

丢弃概率 p 的值越大，缩放因子的值就越大，相对其他未被设置的元素就要更多的变大。丢弃概率 P 的值越小，则缩放因子的值就越小，相对应其他未被置为 0 的元素就要有较小的变大。通常Dropout的概率p设置为0.5。

import torch
import torch.nn as nn
 
 
# 设置随机数种子
torch.manual_seed(0)
 
 
def caculate_gradient(x, w):
 
    y = x @ w
    y = y.sum()
    y.backward()
    print('Gradient:', w.grad.reshape(1, -1).squeeze().numpy())
 
 
def func01():
 
 
    # 初始化权重
    w = torch.randn(15, 1, requires_grad=True)
    # 初始化输入数据
    x = torch.randint(0, 10, size=[5, 15]).float()
    # 计算梯度
    caculate_gradient(x, w)
 
 
def func02():
 
    # 初始化权重
    w = torch.randn(15, 1, requires_grad=True)
    # 初始化输入数据
    x = torch.randint(0, 10, size=[5, 15]).float()
    # 初始化丢弃层
    dropout = nn.Dropout(p=0.8)
    x = dropout(x)
    # 计算梯度
    caculate_gradient(x, w)
 
 
if __name__ == '__main__':
    func01()
    print('-' * 60)
    func02()
 
Gradient: [19. 15. 16. 13. 34. 23. 20. 22. 23. 26. 21. 29. 28. 22. 29.]
----------------------------------------------------------------------
Gradient: [ 5.  0. 35.  0.  0. 45. 40. 40.  0. 20. 25. 45. 55.  0. 10.]

我们可以总结出，Dropout会影响神经网络中每个神经元的梯度计算，由于每次迭代都有不同的神经元被随机“丢弃”，这相当于在训练多个不同的网络结构。因此，每个神经元的权重更新会变得更加稳健，因为它们必须在不同的网络配置中都能表现良好。通过随机丢弃神经元，Dropout减少了模型对特定训练样本的依赖，从而降低了过拟合的风险。这种正则化效果使得模型能够更好地泛化到新的数据上。