欠拟合、过拟合概念以及示例

欠拟合、过拟合概念以及示例

引用

CSDN

1.

https://blog.csdn.net/weixin_61904259/article/details/139751172

在机器学习中，模型的拟合程度是一个非常重要的概念。欠拟合、过拟合和正常拟合分别代表了模型复杂度与数据之间关系的三种不同情况。本文将通过一个简单的实验，使用Python代码来展示这三种拟合情况，并通过训练和测试误差曲线进行直观展示。

过拟合欠拟合的直观展示

欠拟合（Underfitting）:

第一个模型LinearRegression是一个线性回归模型，它只有一层线性变换，没有非线性激活函数。因此，这个模型只能学习线性关系，而无法捕捉到数据中的非线性模式。

对于一个非线性问题（如你的例子中y = x^2 + 1加上噪声），线性模型显然是不够复杂的，它无法很好地拟合这种非线性关系。因此，这个模型会表现出欠拟合，即模型在训练数据上的性能也不佳，因为它没有足够的能力去学习数据的底层结构。

正常拟合（Good Fit）:

第二个模型MLP是一个多层感知机，具有一个隐藏层，该隐藏层有8个神经元，并使用了ReLU激活函数。

这个模型有足够的复杂度去学习数据中的非线性模式，同时又不是过于复杂，因此可以在训练数据上达到良好的性能，并且有较好的泛化能力到未见过的数据。

过拟合（Overfitting）:

第三个模型MLPOverfitting是一个更复杂的多层感知机，具有两个隐藏层，每层都有256个神经元。

这个模型非常复杂，具有大量的参数。虽然它可能在训练数据上表现得非常好，甚至能够几乎完美地拟合训练数据，但这种高度的复杂性可能导致模型在未见过的数据上泛化能力下降。

过拟合发生时，模型会学习到训练数据中的噪声和细节，而不是数据的底层结构或规律。因此，当面对新的、未见过的数据时，模型可能无法做出准确的预测。

总的来说，模型的复杂度需要与问题的复杂度相匹配。如果模型太简单（如线性模型用于非线性问题），则会发生欠拟合；如果模型太复杂（如具有大量参数的深层网络用于相对简单的问题），则可能会发生过拟合。

import numpy as np
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader,TensorDataset
from sklearn.model_selection import train_test_split

np.random.seed(32) #设置随机种子 保证每次结果可以复现
#生成满足 y = x^2 + 1 的数据
num_samples = 100 #生成100个样本点
X = np.random.uniform(-5,5,(num_samples,1)) #均匀分布
Y=X**2 + 1 +5 *np.random.normal(0,1,(num_samples,1)) #正态分布噪声
#将NumPy 变量转化为浮点型 Pytorch 变量
X = torch.from_numpy(X).float()
Y = torch.from_numpy(Y).float()
#绘制数据散点图
plt.scatter(X,Y)
plt.show()

#将数据划分为训练集和测试集
train_X,test_X,train_Y,test_Y=train_test_split(X,Y,test_size=0.3,random_state=0)
#将数据封装成数据加载器
train_dataloader = DataLoader(TensorDataset(train_X,train_Y),batch_size=32,shuffle=True)
test_dataloader = DataLoader(TensorDataset(test_X,test_Y),batch_size=32,shuffle=False)

#定义线性回归模型（欠拟合）
class LinearRegression(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(1,1)
        
    def forward(self,x):
        return self.linear(x)
#定义多层感知机（正常）
class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(1,8)
        self.output = nn.Linear(8,1)
    
    def forward(self,x):
        x = torch.relu(self.hidden(x))
        return self.output(x)
#定义更复杂的多层感知机（过拟合）
class MLPOverfitting(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden1 = nn.Linear(1,256)
        self.hidden2 = nn.Linear(256,256)
        self.output = nn.Linear(256,1)
    
    def forward(self,x):
        x = torch.relu(self.hidden1(x))
        x = torch.relu(self.hidden2(x))
        return self.output(x)

def plot_errors(models,num_epochs,train_dataloader,test_dataloader):
    #定义损失函数
    loss_fn = nn.MSELoss()
    
    #定义训练和测试误差数组
    train_losses = []
    test_losses = []
    
    #遍历每类模型
    for model in models:
        optimizer = torch.optim.SGD(model.parameters(),lr=0.005)
        
        train_losses_per_model = []
        test_losses_per_model = []
        
        for epoch in range(num_epochs):
            #在训练数据上迭代
            model.train()
            train_loss = 0 
            for inputs,targets in train_dataloader:
                optimizer.zero_grad()
                outputs = model(inputs)
                loss = loss_fn(outputs,targets)
                loss.backward()
                optimizer.step()
                #记录loss
                train_loss += loss.item()
            
            train_loss/=len(train_dataloader)
            train_losses_per_model.append(train_loss)
            
            model.eval()
            test_loss = 0
            with torch.no_grad():
                for inputs,targets in test_dataloader:
                    outputs = model(inputs)
                    loss = loss_fn(outputs,targets)
                    test_loss += loss.item()
                test_loss/=len(test_dataloader)
                test_losses_per_model.append(test_loss)
        
        
        #记录当前模型每轮的训练测试误差
        train_losses.append(train_losses_per_model)
        test_losses.append(test_losses_per_model)
    return train_losses,test_losses

num_epochs=200
models = [LinearRegression(),MLP(),MLPOverfitting()]
train_losses,test_losses = plot_errors(models,num_epochs,train_dataloader,test_dataloader)

for i,model in enumerate(models):
    plt.figure(figsize=(8,4))
    plt.plot(range(num_epochs),train_losses[i],label=f"Train{model.__class__.__name__}")
    plt.plot(range(num_epochs),test_losses[i],label=f"Test{model.__class__.__name__}")
    plt.legend()
    plt.legend()
    plt.ylim((0,200))
    plt.show()