BP神经网络训练数据集：从数据准备到模型优化的新手避坑指南

1次阅读

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

BP 神经网络对输入数据极其敏感。举个例子，如果输入特征的尺度差异很大（比如一个特征范围是 0 -1，另一个是 1000-10000），会导致梯度下降过程中各权重更新幅度不均衡，严重影响收敛速度。此外，数据中的噪声和缺失值会直接干扰网络学习真实的特征关系。

关键数据特征要求 ：

所有特征应具有相似的数值范围
数据分布应尽量接近正态分布
类别样本比例不宜过于悬殊（最好不超过 1:10）
特征之间应尽量避免高度相关性

使用 Pandas 进行数据清洗是最常见的方式。以下是一个包含完整异常值处理的示例：

import pandas as pd
import numpy as np

# 生成示例数据
data = pd.DataFrame({'feature1': [1, 2, np.nan, 4, 15], 
    'feature2': [0.1, 0.2, 0.3, 5.0, 0.5]
})

# 处理缺失值
data.fillna(data.mean(), inplace=True)

# 处理异常值 - 使用 3σ 原则
for col in data.columns:
    mean = data[col].mean()
    std = data[col].std()
    data[col] = np.where(abs(data[col] - mean) > 3*std,
        mean,
        data[col]
    )

标准化（Z-score） 适用于大多数情况：

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaled_data = scaler.fit_transform(data)

归一化（MinMax） 适合已知明确边界的情况：

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))
normalized_data = scaler.fit_transform(data)

推荐比例 ：

训练集：60-70%
验证集：15-20%
测试集：15-20%

使用 sklearn 的实现：

from sklearn.model_selection import train_test_split

# 首次分割：分出测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 二次分割：分出验证集
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=42)  # 0.25 x 0.8 = 0.2

过采样（SMOTE）示例 ：

from imblearn.over_sampling import SMOTE

smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X_train, y_train)

欠采样（RandomUnderSampler）示例 ：

from imblearn.under_sampling import RandomUnderSampler

rus = RandomUnderSampler(random_state=42)
X_res, y_res = rus.fit_resample(X_train, y_train)

L2 正则化实现（PyTorch 示例）：

import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 2)

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

# 定义优化器时加入 weight_decay 参数（L2 惩罚项）optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=0.01)

早停法（Early Stopping）实现 ：

from copy import deepcopy

best_loss = float('inf')
best_model = None
patience = 5
counter = 0

for epoch in range(100):
    # 训练过程...
    val_loss = validate(model, val_loader)

    if val_loss < best_loss:
        best_loss = val_loss
        best_model = deepcopy(model)
        counter = 0
    else:
        counter += 1
        if counter >= patience:
            print(f'Early stopping at epoch {epoch}')
            break

经验法则 ：

批量增大 N 倍时，学习率也应增大√N 倍
常见批量大小：32/64/128/256
学习率常用范围：0.1 到 0.0001

学习率预热示例 ：

from torch.optim.lr_scheduler import LambdaLR

# 前 1000 步线性增加学习率
warmup_steps = 1000
scheduler = LambdaLR(
    optimizer,
    lr_lambda=lambda step: min(1.0, step / warmup_steps)
)

激活函数	适用场景	注意事项
ReLU	大多数隐藏层	可能有 ” 死亡神经元 ” 问题
LeakyReLU	替代 ReLU	α 参数通常设 0.01
Sigmoid	二分类输出层	容易梯度消失
Tanh	- 1 到 1 输出	比 sigmoid 梯度更强
Softmax	多分类输出层	确保各概率和为 1

from torch.utils.data import Dataset, DataLoader
import torch

class CustomDataset(Dataset):
    def __init__(self, X, y):
        # 数据校验
        assert len(X) == len(y), "X 和 y 长度不一致"
        assert not torch.isnan(X).any(), "存在 NaN 值"

        self.X = torch.FloatTensor(X)
        self.y = torch.LongTensor(y)

    def __len__(self):
        return len(self.X)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

# 使用示例
try:
    train_set = CustomDataset(X_train, y_train)
    train_loader = DataLoader(train_set, batch_size=64, shuffle=True)
except AssertionError as e:
    print(f"数据加载失败: {e}")

def train(model, loader, optimizer, criterion):
    model.train()
    total_loss = 0

    for X_batch, y_batch in loader:
        optimizer.zero_grad()

        # 前向传播
        outputs = model(X_batch)
        loss = criterion(outputs, y_batch)

        # 反向传播
        loss.backward()
        optimizer.step()

        total_loss += loss.item()

    return total_loss / len(loader)