全连接神经网络的表达能力与泛化能力_深度学习表达能力强是什么意思-CSDN博客

本文链接：https://blog.csdn.net/tagagi/article/details/121322636

本文通过实验揭示全连接神经网络的强大拟合能力可能导致过拟合，即使在随机噪声下，模型有时会表现出低于实际误差的测试性能。作者通过改变数据分布解释了这一现象，并讨论了其背后的原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在深度学习中，我们经常看到两个概念：表达能力和泛化能力
表达能力指的是模型拟合训练集的能力，可以用训练损失来衡量
而泛化集指的是模型迁移到测试集中的能力，可以用测试误差来衡量

一般来说，全连接的神经网络表达能力很强，很容易过拟合，导致泛化能力较弱

于是乎我就突发奇想，做一个小实验：
首先随便造一个测试集，输入是x，输出（标签）y是x^2
然后需要引入噪声，我的方法十分简单粗暴：直接将标签y随机按比例增加或减少10%以内，变为y*(0.9~1.1)
于是乎得到了数据集构造函数：

def generate(num): # num为数据集的大小
    x = np.random.randint(-10,10, num)
    y = x**2 * (1 + (random.random() - 0.5) / 5)
    return x,y

然后就是简单的使用全连接神经网络进行训练，为了过拟合，特意多跑了一些轮次

class DSnet(nn.Module):
    def __init__(self):
        super(DSnet, self).__init__()
        self.layer1 = nn.Linear(1, 20)
        self.layer2 = nn.Linear(20, 10)
        self.layer3 = nn.Linear(10, 1)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.layer1(x)
        x = torch.tanh(x)
        x = self.layer2(x)
        x = torch.tanh(x)
        x = self.layer3(x)
        return x


batchs = 100000
batch_size = 1000

global_step = 0
total_loss = 100000
model = DSnet()
viz = visdom.Visdom(port=8097, server="127.0.0.1", env="Test")
loss_win = viz.line(np.arange(1))
optimizer = torch.optim.SGD(model.parameters(), lr=0.0001, momentum=0.5)

model.train()
for i in range(batchs):
    data, lable = generate(batch_size)
    data = torch.Tensor(data).unsqueeze(1)
    lable = torch.Tensor(lable)
    optimizer.zero_grad()
    output = model(data)
    criterion = nn.MSELoss()
    
    loss = criterion(output.squeeze(dim=1), lable)
    loss.backward(torch.ones_like(loss))
    optimizer.step()
    
    truth = data**2
    loss2 = criterion(truth.squeeze(dim=1), lable)

    if i % 100 == 0:
        global_step += 1
        viz.line(Y=np.array([loss.item()]),
                 X=np.array([global_step]),
                 name='训练损失',
                 update='append',
                 win=loss_win)
                 
        viz.line(Y=np.array([loss2.item()]),
                 X=np.array([global_step]),
                  name='实际损失',
                 update='append',
                 win=loss_win)

训练的loss大致如下：
其中橙色的是训练损失，损失函数就是简单的均方差MSE
绿的是实际损失，计算的是x^2和y之间的均方差
在这里插入图片描述
在训练的最后，训练误差时不时会小于实际的误差了

然后，按常理来说，在训练集上跑的时候，由于过拟合，测试误差会大于实际误差才对，但实际操作中，经常发现测试误差小于实际误差的情况，于是我干脆跑了100000次，看测试误差大于实际误差的情况有多少次：

def eval():
    model.eval()
    data, lable = generate(100)
    data = torch.Tensor(data).unsqueeze(1)
    lable = torch.Tensor(lable)

    out = model(data)
    truth = data ** 2

    criterion = nn.MSELoss()
    loss_model = criterion(out.squeeze(1), lable)
    loss_truth = criterion(truth.squeeze(1), lable)
    return loss_model < loss_truth

cnt = 0
for i in range(100000):
    cnt += 1 if eval() else 0
    
cnt