BP神经网络实战入门：从CSDN案例到Python实现

1次阅读

没有评论

共计 3109 个字符，预计需要花费 8 分钟才能阅读完成。

刚开始接触 BP 神经网络时，你可能遇到过这些问题：反向传播算法到底是怎么工作的？为什么有时候训练结果总是不理想？激活函数选哪个比较好？这些都是很常见的困惑。

BP 神经网络作为一种基础的前馈神经网络，理解它的工作原理对后续学习更复杂的深度学习模型非常重要。今天我们就通过一个实际的案例，来一步步解决这些困惑。

激活函数是神经网络中非常重要的组成部分，不同的选择会直接影响网络的训练效果：

Sigmoid 函数：输出范围在 0 - 1 之间，适合二分类问题。但容易出现梯度消失问题。
Tanh 函数：输出范围在 - 1 到 1 之间，比 Sigmoid 的梯度更强一些。
ReLU 函数：计算简单，能有效缓解梯度消失问题，是目前最常用的选择。

在大多数情况下，建议从 ReLU 开始尝试，如果遇到神经元 ” 死亡 ” 问题，可以考虑使用 Leaky ReLU 或 ELU 等变体。

import torch
import torch.nn as nn
import torch.optim as optim

class BPNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(BPNN, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.softmax = nn.Softmax(dim=1)

        # 初始化权重
        nn.init.xavier_uniform_(self.fc1.weight)
        nn.init.zeros_(self.fc1.bias)
        nn.init.xavier_uniform_(self.fc2.weight)
        nn.init.zeros_(self.fc2.bias)

def forward(self, x):
    out = self.fc1(x)
    out = self.relu(out)
    out = self.fc2(out)
    out = self.softmax(out)
    return out

# 定义模型
model = BPNN(input_size=784, hidden_size=128, output_size=10)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 学习率衰减
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)

# 训练循环
for epoch in range(100):
    for data, target in train_loader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
    scheduler.step()

from torchvision import datasets, transforms

# 数据转换
transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 加载数据集
train_dataset = datasets.MNIST(root='./data', 
                              train=True, 
                              transform=transform,
                              download=True)

test_dataset = datasets.MNIST(root='./data',
                             train=False,
                             transform=transform)

# 创建数据加载器
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                          batch_size=64,
                                          shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                         batch_size=64,
                                         shuffle=False)

建议在训练过程中记录 loss 和 accuracy，可以直观地观察训练效果：

train_losses = []
train_accuracies = []

for epoch in range(100):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    for data, target in train_loader:
        # 训练代码...

        # 计算准确率
        _, predicted = torch.max(output.data, 1)
        total += target.size(0)
        correct += (predicted == target).sum().item()
        running_loss += loss.item()

    # 记录数据
    train_losses.append(running_loss / len(train_loader))
    train_accuracies.append(100 * correct / total)

梯度爆炸问题：
使用梯度裁剪：torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
适当减小学习率
隐层神经元数量选择：
经验公式：隐层神经元数量 ≈ (输入维度 + 输出维度) / 2
也可以从较小的数量开始，逐步增加
早停法实现：
监控验证集准确率
当连续若干 epoch 验证集准确率不再提升时停止训练

批量归一化(Batch Normalization)：
在激活函数前加入 BN 层
可以加速训练并提高模型稳定性
Dropout：
随机丢弃部分神经元
防止过拟合的有效手段

class ImprovedBPNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(ImprovedBPNN, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.bn1 = nn.BatchNorm1d(hidden_size)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)
        self.fc2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out = self.fc1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.dropout(out)
        out = self.fc2(out)
        return out