本文围绕深度学习中的过拟合问题展开，先说明其表现为训练集准确率高而泛化能力低，全连接网络易出现。通过半圆形数据集案例验证过拟合存在，进而分析原因，并介绍增大数据集、正则化、Dropout等解决策略及其实验效果。
☞☞☞AI 智能聊天, 问答助手, AI 智能搜索, 免费无限量使用 DeepSeek R1 模型☜☜☜
过拟合问题描述
在深度学习中，在训练集得到了很高的准确率，但当模型面对未知数据时，准确率却下降很多，这种情况下模型的一个泛化能力很低。
对于全连接网络，模型通道数越大，模型拟合能力越强，模型层数越深，模型泛化能力越强。
过拟合问题原因
这是由于模型的拟合度太强造成的，即模型不但学习样本的群体规律，而且学习了样本的个体规律，这种现象在全连接网络最容易出现。
本项目将基于这个问题进行整理，主要也是自己的整理学习，进行一个学习分享。
一个例子更好的说明这个问题
案例描述：
假设有这样的一组数据集样本，包含两种数据分布，每种数据分布都为半圆形状，让网络学习这些样本，并寻找其中规律，从而分开。接着重新用一组数据输入模型，验证模型准确率，观察是否出现过拟合现象。
构造数据集
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()
模型构造
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))
训练时的准确率： 1.0
测试时的准确率： 0.925
我们已经通过实验证明了过拟合的存在，接下来就是分析并解决
在深度学习中，模型的过拟合问题是普遍存在的，因为网络在训练的过程中只看到了有新的信息，在数据量不足的情况下，无法合理的区分哪些属于个体特征，哪些属于群体特征。真实场景下，所有的样本特征都是多样的，很难在训练数据集中将所有的样本情况全部包括。
但是我们仍然可以寻找到一些有效的改良过拟合的方法.类似early stopping 数据集增广，正则化，dropout 这些方法可以使模型的泛化能力大大提升。
early stopping： 在发生过拟合之前提前结束训练，这个方法理论上是可行的，但是这个结束时间点很不好把控。
数据集扩增：就是让模型遇到更多的情况，可以最大满足样本，但实际应用中对于未来事件的预测却显得“力不从心”.
-
正则化通过引入范数的概念，增强模型的泛化能力，包含l1正则化，l2正则化.所谓正则化，就是在神经网络计算损失过程中，在损失后面再加一项，这样损失持所代表的输出与标准结果的误差，就会受到干扰，导致学习参数w和b 无法按照目标方向来调整，实现模型无法与样本完全拟合的结果，从而防止过拟合.干扰项需要满足以下特性：
- 当模型拟合能力不足时，希望他对模型误差尽量小，让模型快速拟合实际
- 如果过拟合，那么希望他对模型误差影响要大，于是引入了两个范数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))
训练时的准确率： 0.95
测试时的准确率： 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))
训练时的准确率： 0.975
测试时的准确率： 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))
训练时的准确率： 0.95
测试时的准确率： 0.9
