经验总结1：过拟合问题以及优化技巧，炼丹进阶，面向新手，大佬们欢迎指正

P粉084495128

发布时间：2025-08-01 14:04:18

613人浏览过

来源于php中文网

原创

本文围绕深度学习中的过拟合问题展开，先说明其表现为训练集准确率高而泛化能力低，全连接网络易出现。通过半圆形数据集案例验证过拟合存在，进而分析原因，并介绍增大数据集、正则化、Dropout等解决策略及其实验效果。

☞☞☞AI 智能聊天, 问答助手, AI 智能搜索, 免费无限量使用 DeepSeek R1 模型☜☜☜

经验总结1：过拟合问题以及优化技巧，炼丹进阶，面向新手，大佬们欢迎指正 - php中文网

过拟合问题描述

在深度学习中，在训练集得到了很高的准确率，但当模型面对未知数据时，准确率却下降很多，这种情况下模型的一个泛化能力很低。

对于全连接网络，模型通道数越大，模型拟合能力越强，模型层数越深，模型泛化能力越强。

过拟合问题原因

这是由于模型的拟合度太强造成的，即模型不但学习样本的群体规律，而且学习了样本的个体规律，这种现象在全连接网络最容易出现。

本项目将基于这个问题进行整理，主要也是自己的整理学习，进行一个学习分享。

一个例子更好的说明这个问题

案例描述：

假设有这样的一组数据集样本，包含两种数据分布，每种数据分布都为半圆形状，让网络学习这些样本，并寻找其中规律，从而分开。接着重新用一组数据输入模型，验证模型准确率，观察是否出现过拟合现象。

构造数据集

In [10]

import sklearn.datasets     #引入数据集import paddleimport numpy as npimport matplotlib.pyplot as plt

np.random.seed(0)           #设置随机数种子X, Y = sklearn.datasets.make_moons(40,noise=0.2) #生成2组半圆形数据arg = np.squeeze(np.argwhere(Y==0),axis = 1)     #获取第1组数据索引arg2 = np.squeeze(np.argwhere(Y==1),axis = 1)#获取第2组数据索引plt.title("train moons data")
plt.scatter(X[arg,0], X[arg,1], s=100,c='b',marker='+',label='data1')
plt.scatter(X[arg2,0], X[arg2,1],s=40, c='r',marker='o',label='data2')
plt.legend()
plt.show()

<Figure size 432x288 with 1 Axes>

模型构造

In [2]

import paddleimport numpy as npimport matplotlib.pyplot as pltimport paddle.nn as nn#继承nn.Layer类，构建网络模型class LogicNet(nn.Layer):
    def __init__(self,inputdim,hiddendim,outputdim):#初始化网络结构
        super(LogicNet,self).__init__()
        self.Linear1 = nn.Linear(inputdim,hiddendim) #定义全连接层
        self.Linear2 = nn.Linear(hiddendim,outputdim)#定义全连接层
        self.criterion = nn.CrossEntropyLoss() #定义交叉熵函数

    def forward(self,x): #搭建用两层全连接组成的网络模型
        x = self.Linear1(x)#将输入数据传入第1层
        x = paddle.nn.Tanh()(x)#对第一层的结果进行非线性变换
        x = self.Linear2(x)#再将数据传入第2层#        print("LogicNet")
        return x    def predict(self,x):#实现LogicNet类的预测接口
        #调用自身网络模型，并对结果进行softmax处理,分别得出预测数据属于每一类的概率
        pred = paddle.nn.Softmax(axis=1)(self.forward(x))        return paddle.argmax(pred,axis=1)  #返回每组预测概率中最大的索引

    def getloss(self,x,y): #实现LogicNet类的损失值计算接口
        y_pred = self.forward(x)
        loss = self.criterion(y_pred,y)#计算损失值得交叉熵
        return loss

In [3]

def moving_average(a, w=10):#定义函数计算移动平均损失值
    if len(a) < w:        return a[:]    return [val if idx < w else sum(a[(idx-w):idx])/w for idx, val in enumerate(a)]

In [4]

def plot_decision_boundary(pred_func,X,Y):#在直角坐标系中可视化模型能力
    #计算取值范围
    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    h = 0.01
    #在坐标系中采用数据，生成网格矩阵，用于输入模型
    xx,yy=np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))    #将数据输入并进行预测
    Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)    #将预测的结果可视化
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
    plt.title("Linear predict")
    arg = np.squeeze(np.argwhere(Y==0),axis = 1)
    arg2 = np.squeeze(np.argwhere(Y==1),axis = 1)
    plt.scatter(X[arg,0], X[arg,1], s=100,c='b',marker='+')
    plt.scatter(X[arg2,0], X[arg2,1],s=40, c='r',marker='o')
    plt.show()def predict(model,x):   #封装支持Numpy的预测接口
    x = paddle.to_tensor(x).astype("float32")
    ans = model.predict(x)    return ans.numpy()

In [5]

xx,yy = np.meshgrid(np.arange(3,5, 0.1), np.arange(4, 6, 0.1))
np.c_[xx.ravel(), yy.ravel()].shape

(400, 2)

展示过拟合现象

In [6]

model = LogicNet(inputdim=2,hiddendim=500,outputdim=2)#初始化模型optimizer = paddle.optimizer.Adam(learning_rate = 0.01,parameters = model.parameters()) #定义优化器xt = paddle.to_tensor(X).astype("float32")#将Numpy数据转化为张量yt = paddle.to_tensor(Y).astype("int64")
epochs = 3000#定义迭代次数losses = []#定义列表，用于接收每一步的损失值for i in range(epochs):
    loss = model.getloss(xt,yt)
    losses.append(loss.numpy()[0])
    loss.backward()#反向传播损失值
    optimizer.step()#更新参数
    optimizer.clear_grad()#清空之前的梯度avgloss= moving_average(losses) #获得损失值的移动平均值plt.figure(1)
plt.subplot(211)
plt.plot(range(len(avgloss)), avgloss, 'b--')
plt.xlabel('step number')
plt.ylabel('Training loss')
plt.title('step number vs. Training loss')
plt.show()


plot_decision_boundary(lambda x : predict(model,x) ,X, Y)from sklearn.metrics import accuracy_scoreprint("训练时的准确率：",accuracy_score(model.predict(xt),yt))

Xtest, Ytest = sklearn.datasets.make_moons(80,noise=0.2) #生成2组半圆形数据plot_decision_boundary(lambda x : predict(model,x) ,Xtest, Ytest)
Xtest_t = paddle.to_tensor(Xtest).astype("float32")#将Numpy数据转化为张量Ytest_t = paddle.to_tensor(Ytest).astype("int64") 
print("测试时的准确率：",accuracy_score(model.predict(Xtest_t),Ytest_t))

<Figure size 432x288 with 1 Axes>

<Figure size 432x288 with 1 Axes>

训练时的准确率： 1.0

<Figure size 432x288 with 1 Axes>

测试时的准确率： 0.925

我们已经通过实验证明了过拟合的存在，接下来就是分析并解决

在深度学习中，模型的过拟合问题是普遍存在的，因为网络在训练的过程中只看到了有新的信息，在数据量不足的情况下，无法合理的区分哪些属于个体特征，哪些属于群体特征。真实场景下，所有的样本特征都是多样的，很难在训练数据集中将所有的样本情况全部包括。

但是我们仍然可以寻找到一些有效的改良过拟合的方法.类似early stopping 数据集增广，正则化，dropout 这些方法可以使模型的泛化能力大大提升。

early stopping：在发生过拟合之前提前结束训练，这个方法理论上是可行的，但是这个结束时间点很不好把控。
数据集扩增：就是让模型遇到更多的情况，可以最大满足样本，但实际应用中对于未来事件的预测却显得“力不从心”.
正则化通过引入范数的概念，增强模型的泛化能力，包含l1正则化，l2正则化.所谓正则化，就是在神经网络计算损失过程中，在损失后面再加一项，这样损失持所代表的输出与标准结果的误差，就会受到干扰，导致学习参数w和b 无法按照目标方向来调整，实现模型无法与样本完全拟合的结果，从而防止过拟合.干扰项需要满足以下特性：

PaperFake
AI写论文

下载
1. 当模型拟合能力不足时，希望他对模型误差尽量小，让模型快速拟合实际
2. 如果过拟合，那么希望他对模型误差影响要大，于是引入了两个范数l1范数和l2范数，如果放在损失函数中，就会产生一点变形，L1 所有学习参数w的绝对值的和，l2指的是所有学习参数w的平方的和。
```
# Example1: set Regularizer l1 in optimizer
```

import paddle from paddle.regularizer import L1Decay import numpy as np linear = paddle.nn.Linear(10, 10) inp = paddle.rand(shape=[10, 10], dtype="float32") out = linear(inp) loss = paddle.mean(out) beta1 = paddle.to_tensor([0.9], dtype="float32") beta2 = paddle.to_tensor([0.99], dtype="float32") momentum = paddle.optimizer.Momentum( learning_rate=0.1, parameters=linear.parameters(), weight_decay=L1Decay(0.0001)) back = out.backward() momentum.step() momentum.clear_grad()

# Example2: set Regularizer l2 in optimizer

import paddle from paddle.regularizer import L2Decay import numpy as np linear = paddle.nn.Linear(10, 10) inp = paddle.rand(shape=[10, 10], dtype="float32") out = linear(inp) loss = paddle.mean(out) beta1 = paddle.to_tensor([0.9], dtype="float32") beta2 = paddle.to_tensor([0.99], dtype="float32") momentum = paddle.optimizer.Momentum( learning_rate=0.1, parameters=linear.parameters(), weight_decay=L2Decay(0.0001)) back = out.backward() momentum.step() momentum.clear_grad()

```

Dropout每次训练舍弃一些节点增强泛化能力。

增大数据集策略

In [7]

model = LogicNet(inputdim=2,hiddendim=500,outputdim=2)#初始化模型optimizer = paddle.optimizer.Adam(learning_rate = 0.01,parameters = model.parameters()) #定义优化器epochs = 3000#定义迭代次数losses = []#定义列表，用于接收每一步的损失值for i in range(epochs):
    X, Y = sklearn.datasets.make_moons(40,noise=0.2) #生成2组半圆形数据

    xt = paddle.to_tensor(X).astype("float32")#将Numpy数据转化为张量
    yt = paddle.to_tensor(Y).astype("int64")
    loss = model.getloss(xt,yt)
    losses.append(loss.item())
    loss.backward()#反向传播损失值
    optimizer.step()#更新参数
    optimizer.clear_grad()#清空之前的梯度avgloss= moving_average(losses) #获得损失值的移动平均值plt.figure(1)
plt.subplot(211)
plt.plot(range(len(avgloss)), avgloss, 'b--')
plt.xlabel('step number')
plt.ylabel('Training loss')
plt.title('step number vs. Training loss')
plt.show()

plot_decision_boundary(lambda x : predict(model,x) ,X, Y)from sklearn.metrics import accuracy_scoreprint("训练时的准确率：",accuracy_score(model.predict(xt),yt))

Xtest, Ytest = sklearn.datasets.make_moons(80,noise=0.2) #生成2组半圆形数据plot_decision_boundary(lambda x : predict(model,x) ,Xtest, Ytest)
Xtest_t = paddle.to_tensor(Xtest).astype("float32")#将Numpy数据转化为张量Ytest_t = paddle.to_tensor(Ytest).astype("int64") 
print("测试时的准确率：",accuracy_score(model.predict(Xtest_t),Ytest_t))

<Figure size 432x288 with 1 Axes>

<Figure size 432x288 with 1 Axes>

训练时的准确率： 0.95

<Figure size 432x288 with 1 Axes>

测试时的准确率： 0.9625

使用正则化策略

在这里，像我这种新手一般对于优化器的更加详细的使用存在疑惑，这里我进行了一定的整理：

请结合下方代码块看

optimizer = paddle.optimizer.Adam(learning_rate = 0.01,parameters = 
                  [{'params': weight_p, 'weight_decay':0.001,"learning_rate":1},
                      {'params': bias_p, 'weight_decay':0.},],weight_decay=L2Decay(0.001)) #定义优化器

对于weight_p 来说这个实际的学习率到底是多少？应该是单独设置的学习率乘以一个基础设置的学习率，即1*0.01，但是对于对于weight_p的weight_decay可以是完全独立设置的。如果你传入的是float（如果是某个参数不想参与正则化就设置为0. ,而不是0），那么默认使用的正则化就是L2正则化.个人感觉L2正则化更好用一点。

这是源代码解释：

地址：https://github.com/PaddlePaddle/Paddle/blob/b79c6a9b3315742283a923ed52a5934c231beeff/python/paddle/optimizer/optimizer.py#L177

然后也可以写成

# 实现只对权重w进行正则化（如果对b进行正则化有可能会导致欠拟合）optimizer = paddle.optimizer.Adam(learning_rate = 0.01,parameters = [{'params': weight_p, 'weight_decay':L2Decay(0.001),"learning_rate":1},
                      {'params': bias_p, 'weight_decay':0.},],weight_decay=L1Decay(0.001)) #定义优化器

In [8]

from paddle.regularizer import L2Decay,L1Decay
paddle.seed(0)
model = LogicNet(inputdim=2,hiddendim=500,outputdim=2)#初始化模型weight_p, bias_p = [],[]for name, p in model.named_parameters():    if 'bias' in name:
        bias_p += [p]    else:
        weight_p += [p]

optimizer = paddle.optimizer.Adam(learning_rate = 0.01,parameters = 
                  [{'params': weight_p, 'weight_decay':0.001,"learning_rate":1},
                      {'params': bias_p, 'weight_decay':0.},],weight_decay=L2Decay(0.001)) #定义优化器xt = paddle.to_tensor(X).astype("float32")#将Numpy数据转化为张量yt = paddle.to_tensor(Y).astype("int64")
epochs = 3000#定义迭代次数losses = []#定义列表，用于接收每一步的损失值for i in range(epochs):
    loss = model.getloss(xt,yt)
    losses.append(loss.numpy()[0])
    loss.backward()#反向传播损失值
    optimizer.step()#更新参数
    optimizer.clear_grad()#清空之前的梯度avgloss= moving_average(losses) #获得损失值的移动平均值plt.figure(1)
plt.subplot(211)
plt.plot(range(len(avgloss)), avgloss, 'b--')
plt.xlabel('step number')
plt.ylabel('Training loss')
plt.title('step number vs. Training loss')
plt.show()


plot_decision_boundary(lambda x : predict(model,x) ,X, Y)from sklearn.metrics import accuracy_scoreprint("训练时的准确率：",accuracy_score(model.predict(xt),yt))

Xtest, Ytest = sklearn.datasets.make_moons(80,noise=0.2) #生成2组半圆形数据plot_decision_boundary(lambda x : predict(model,x) ,Xtest, Ytest)
Xtest_t = paddle.to_tensor(Xtest).astype("float32")#将Numpy数据转化为张量Ytest_t = paddle.to_tensor(Ytest).astype("int64") 
print("测试时的准确率：",accuracy_score(model.predict(Xtest_t),Ytest_t))

<Figure size 432x288 with 1 Axes>

<Figure size 432x288 with 1 Axes>

训练时的准确率： 0.975

<Figure size 432x288 with 1 Axes>

测试时的准确率： 0.9125

最后展示一下使用Dropout策略

In [9]

import paddleimport numpy as npimport matplotlib.pyplot as pltimport paddle.nn as nn#继承nn.Layer类，构建网络模型class LogicNet(nn.Layer):
    def __init__(self,inputdim,hiddendim,outputdim):#初始化网络结构
        super(LogicNet,self).__init__()
        self.Linear1 = nn.Linear(inputdim,hiddendim) #定义全连接层
        self.Linear2 = nn.Linear(hiddendim,outputdim)#定义全连接层
        self.criterion = nn.CrossEntropyLoss() #定义交叉熵函数

    def forward(self,x): #搭建用两层全连接组成的网络模型
        x = self.Linear1(x)#将输入数据传入第1层
        x = paddle.nn.Tanh()(x)#对第一层的结果进行非线性变换
        x = nn.Dropout(0.2)(x)
        x = self.Linear2(x)#再将数据传入第2层#        print("LogicNet")
        return x    def predict(self,x):#实现LogicNet类的预测接口
        #调用自身网络模型，并对结果进行softmax处理,分别得出预测数据属于每一类的概率
        pred = paddle.nn.Softmax(axis=1)(self.forward(x))        return paddle.argmax(pred,axis=1)  #返回每组预测概率中最大的索引

    def getloss(self,x,y): #实现LogicNet类的损失值计算接口
        y_pred = self.forward(x)
        loss = self.criterion(y_pred,y)#计算损失值得交叉熵
        return loss

model = LogicNet(inputdim=2,hiddendim=500,outputdim=2)#初始化模型optimizer = paddle.optimizer.Adam(learning_rate = 0.01,parameters = model.parameters()) #定义优化器xt = paddle.to_tensor(X).astype("float32")#将Numpy数据转化为张量yt = paddle.to_tensor(Y).astype("int64")
epochs = 3000#定义迭代次数losses = []#定义列表，用于接收每一步的损失值for i in range(epochs):
    loss = model.getloss(xt,yt)
    losses.append(loss.numpy()[0])
    loss.backward()#反向传播损失值
    optimizer.step()#更新参数
    optimizer.clear_grad()#清空之前的梯度avgloss= moving_average(losses) #获得损失值的移动平均值plt.figure(1)
plt.subplot(211)
plt.plot(range(len(avgloss)), avgloss, 'b--')
plt.xlabel('step number')
plt.ylabel('Training loss')
plt.title('step number vs. Training loss')
plt.show()


plot_decision_boundary(lambda x : predict(model,x) ,X, Y)from sklearn.metrics import accuracy_scoreprint("训练时的准确率：",accuracy_score(model.predict(xt),yt))

Xtest, Ytest = sklearn.datasets.make_moons(80,noise=0.2) #生成2组半圆形数据plot_decision_boundary(lambda x : predict(model,x) ,Xtest, Ytest)
Xtest_t = paddle.to_tensor(Xtest).astype("float32")#将Numpy数据转化为张量Ytest_t = paddle.to_tensor(Ytest).astype("int64") 
print("测试时的准确率：",accuracy_score(model.predict(Xtest_t),Ytest_t))