09. 神经网络基础：模型训练的全流程(如何前向，如何反向)大总结

神经网络训练全景图

经过前面8章的学习，我们已经掌握了神经网络训练的各个核心环节。现在让我们站在山顶俯瞰整个训练流程，将所有知识点串联成一个完整的知识体系。

训练流程总览：工厂生产类比

完整生产流程

原材料准备 → 生产线调试 → 批量生产 → 质量检测 → 包装出厂
数据准备   → 模型构建   → 训练循环 → 性能评估 → 模型部署

详细流程图

第一阶段：数据准备（原材料处理）

1. 数据收集与理解

# 数据类型识别
数据类型 = {
    '结构化数据': '表格形式，特征明确',
    '图像数据': '像素矩阵，需要特征提取',
    '文本数据': '序列数据，需要编码',
    '时间序列': '有序数据，考虑时间依赖'
}

# 质量评估
质量指标 = {
    '完整性': '缺失值比例 < 5%',
    '一致性': '异常值检测通过',
    '代表性': '覆盖主要数据分布',
    '时效性': '数据在有效期内'
}

2. 数据清洗

# 清洗流程
def 数据清洗(原始数据):
    数据 = 处理缺失值(原始数据)
    数据 = 处理异常值(数据)
    数据 = 处理重复值(数据)
    数据 = 数据类型转换(数据)
    return 数据

# 清洗策略
清洗策略 = {
    '缺失值': ['删除', '填充', '预测'],
    '异常值': ['修正', '删除', '保留'],
    '重复值': ['去重', '合并', '标记']
}

3. 特征工程

# 特征处理流水线
def 特征工程(数据):
    # 数值特征处理
    数据['数值特征'] = 标准化(数据['数值特征'])
    
    # 分类特征处理
    数据 = 独热编码(数据, 分类列)
    
    # 特征选择
    选择特征 = 特征重要性分析(数据)
    
    # 特征组合
    数据 = 创建组合特征(数据)
    
    return 数据[选择特征]

4. 数据划分

# 标准划分比例
数据划分 = {
    '训练集': '70% - 学习知识',
    '验证集': '15% - 调整超参数',
    '测试集': '15% - 最终评估'
}

# 划分策略
划分方法 = {
    '随机划分': '数据独立同分布',
    '分层划分': '保持类别比例',
    '时间划分': '考虑时间顺序',
    '交叉验证': '小数据集使用'
}

第二阶段：模型构建（生产线搭建）

1. 网络架构设计

# 架构设计原则
架构设计 = {
    '输入层': '神经元数 = 特征数',
    '隐藏层': '逐层减少，金字塔结构',
    '输出层': '神经元数 = 类别数(分类) 或 1(回归)',
    '激活函数': 'ReLU(隐藏), Softmax(分类输出), Linear(回归输出)'
}

# 网络深度选择
深度选择 = {
    '浅层网络': '1-2隐藏层，适合简单问题',
    '中层网络': '3-5隐藏层，适合中等复杂度',
    '深层网络': '5+隐藏层，适合复杂问题'
}

2. 权重初始化

# 初始化方法选择
初始化方法 = {
    '随机初始化': '小随机数，打破对称性',
    'Xavier初始化': '考虑输入输出维度，适合tanh',
    'He初始化': '考虑输入维度，适合ReLU',
    '预训练初始化': '使用预训练权重，适合迁移学习'
}

# 初始化检查
def 检查初始化(模型):
    权重分布 = 获取权重分布(模型)
    if 权重分布太集中():
        return "需要更大的随机性"
    elif 权重分布太分散():
        return "需要更小的随机性"
    else:
        return "初始化良好"

3. 超参数设置

# 关键超参数
超参数 = {
    '学习率': '0.001-0.1，最重要参数',
    '批量大小': '32-256，影响训练稳定性',
    '训练轮数': '早停决定，避免过拟合',
    '正则化强度': 'L2: 0.0001-0.01, Dropout: 0.2-0.5'
}

# 调优策略
调优顺序 = [
    '先调学习率',
    '再调网络架构',
    '然后调正则化',
    '最后微调其他参数'
]

第三阶段：训练循环（批量生产）

1. 训练循环框架

def 训练模型(模型, 训练数据, 验证数据, 配置):
    训练历史 = {'train_loss': [], 'val_loss': [], 'train_acc': [], 'val_acc': []}
    最佳验证损失 = float('inf')
    耐心计数器 = 0
    
    for epoch in range(配置['最大轮数']):
        # 训练阶段
        模型.train()
        训练损失, 训练准确率 = 执行一个epoch(模型, 训练数据, 训练=True)
        
        # 验证阶段
        模型.eval()
        验证损失, 验证准确率 = 执行一个epoch(模型, 验证数据, 训练=False)
        
        # 记录历史
        训练历史['train_loss'].append(训练损失)
        训练历史['val_loss'].append(验证损失)
        训练历史['train_acc'].append(训练准确率)
        训练历史['val_acc'].append(验证准确率)
        
        # 早停检查
        if 验证损失 < 最佳验证损失:
            最佳验证损失 = 验证损失
            保存最佳模型(模型)
            耐心计数器 = 0
        else:
            耐心计数器 += 1
            
        if 耐心计数器 >= 配置['耐心值']:
            print(f"早停于第{epoch+1}轮")
            break
    
    return 加载最佳模型(), 训练历史

2. 单个Epoch详细流程

def 执行一个epoch(模型, 数据加载器, 训练=True):
    总损失 = 0
    总正确 = 0
    总样本 = 0
    
    for 批次数据, 批次标签 in 数据加载器:
        if 训练:
            梯度清零()
            
        # 前向传播
        预测输出 = 模型(批次数据)
        损失 = 计算损失(预测输出, 批次标签)
        
        if 训练:
            # 反向传播
            损失.backward()
            # 参数更新
            优化器.step()
        
        # 统计指标
        总损失 += 损失.item() * len(批次数据)
        总正确 += (预测输出.argmax(1) == 批次标签).sum().item()
        总样本 += len(批次数据)
    
    平均损失 = 总损失 / 总样本
    平均准确率 = 总正确 / 总样本
    
    return 平均损失, 平均准确率

3. 训练过程监控

# 关键监控指标
监控指标 = {
    '损失曲线': '训练和验证损失都应该下降',
    '准确率曲线': '训练和验证准确率都应该上升',
    '损失差距': '训练损失 < 验证损失，但差距不应过大',
    '收敛速度': '前几轮快速改善，后期趋于平稳'
}

# 异常检测
异常检测 = {
    '训练损失不下降': '学习率太小或模型太简单',
    '验证损失上升': '过拟合，需要更多正则化',
    '损失震荡严重': '学习率太大或批量太小',
    '梯度爆炸': '梯度值变成NaN或极大值'
}

第四阶段：核心算法（生产工艺）

1. 前向传播算法

def 前向传播(输入数据, 模型):
    """
    数据流向：输入层 → 隐藏层 → 输出层
    每层操作：线性变换 → 激活函数
    """
    当前输入 = 输入数据
    
    for 层 in 模型.层列表:
        # 线性变换：z = W·x + b
        线性输出 = 层.权重 @ 当前输入 + 层.偏置
        
        # 激活函数：a = f(z)
        激活输出 = 层.激活函数(线性输出)
        
        当前输入 = 激活输出
    
    return 当前输入  # 最终输出

2. 损失计算

def 计算损失(预测值, 真实值, 损失类型='交叉熵'):
    """
    根据任务类型选择合适的损失函数
    """
    if 损失类型 == '交叉熵':
        # 分类任务
        return -sum(真实值 * log(预测值 + 1e-7))
    
    elif 损失类型 == '均方误差':
        # 回归任务
        return mean((预测值 - 真实值)**2)
    
    elif 损失类型 == '平均绝对误差':
        # 鲁棒回归
        return mean(abs(预测值 - 真实值))

3. 反向传播算法

def 反向传播(损失, 模型):
    """
    梯度流向：输出层 → 隐藏层 → 输入层
    使用链式法则计算每层梯度
    """
    # 损失对输出的梯度
    梯度 = 计算输出梯度(损失)
    
    # 反向遍历各层
    for 层 in reversed(模型.层列表):
        # 计算该层参数梯度
        层.权重梯度 = 梯度 @ 层.输入.T
        层.偏置梯度 = sum(梯度, axis=1)
        
        # 计算对前一层的梯度（继续反向传播）
        梯度 = 层.权重.T @ 梯度
        梯度 *= 层.激活函数导数(层.线性输出)
    
    return 模型  # 所有梯度已存储在各层中

4. 参数更新算法

def 参数更新(模型, 优化器):
    """
    使用计算出的梯度更新模型参数
    不同优化器有不同的更新策略
    """
    for 层 in 模型.层列表:
        if 优化器.类型 == 'SGD':
            # 随机梯度下降
            层.权重 -= 优化器.学习率 * 层.权重梯度
            层.偏置 -= 优化器.学习率 * 层.偏置梯度
            
        elif 优化器.类型 == 'Adam':
            # Adam优化器
            层.权重 -= 优化器.学习率 * 层.Adam权重更新
            层.偏置 -= 优化器.学习率 * 层.Adam偏置更新
            
        elif 优化器.类型 == 'Momentum':
            # 动量法
            层.速度 = 优化器.动量 * 层.速度 + 层.梯度
            层.权重 -= 优化器.学习率 * 层.速度

第五阶段：正则化与优化（质量控制）

1. 正则化策略

# L2正则化（权重衰减）
def L2正则化(模型, 正则化强度):
    for 层 in 模型.层列表:
        层.权重梯度 += 正则化强度 * 层.权重
    return 模型

# Dropout正则化
def Dropout(激活值, dropout比例, 训练模式):
    if 训练模式:
        # 训练时：随机失活
        掩码 = 随机生成(激活值.shape) > dropout比例
        return 激活值 * 掩码 / (1 - dropout比例)
    else:
        # 测试时：全部使用
        return 激活值

# 早停机制
def 早停检查(验证损失, 最佳损失, 耐心计数器, 耐心值):
    if 验证损失 < 最佳损失:
        return 验证损失, 0  # 重置计数器
    else:
        if 耐心计数器 >= 耐心值:
            return None, None  # 触发早停
        else:
            return 最佳损失, 耐心计数器 + 1

2. 学习率调度

# 学习率衰减
def 学习率衰减(初始学习率, 当前轮数, 衰减率):
    return 初始学习率 * (衰减率 ** (当前轮数 // 10))

# 余弦退火
def 余弦退火(初始学习率, 当前轮数, 总轮数):
    return 初始学习率 * (1 + cos(π * 当前轮数 / 总轮数)) / 2

# 热重启
def 热重启(初始学习率, 当前轮数, 重启周期):
    if 当前轮数 % 重启周期 == 0:
        return 初始学习率
    else:
        return 余弦退火(初始学习率, 当前轮数 % 重启周期, 重启周期)

3. 梯度优化技巧

# 梯度裁剪
def 梯度裁剪(梯度, 最大范数):
    总范数 = sqrt(sum(g**2 for g in 梯度))
    if 总范数 > 最大范数:
        缩放因子 = 最大范数 / 总范数
        return [g * 缩放因子 for g in 梯度]
    return 梯度

# 梯度累积
def 梯度累积(模型, 小批量数据, 累积步数):
    累积梯度 = 零初始化(模型.参数形状)
    
    for i, (数据, 标签) in enumerate(小批量数据):
        损失 = 模型(数据, 标签)
        梯度 = 反向传播(损失, 模型)
        累积梯度 += 梯度
        
        if (i + 1) % 累积步数 == 0:
            平均梯度 = 累积梯度 / 累积步数
            参数更新(模型, 平均梯度)
            累积梯度 = 零初始化(模型.参数形状)

第六阶段：模型评估（质量检测）

1. 评估指标

# 分类任务指标
分类指标 = {
    '准确率': '正确预测比例',
    '精确率': '正例中真正例比例',
    '召回率': '真正例被找出比例',
    'F1分数': '精确率和召回率调和平均',
    'AUC-ROC': 'ROC曲线下面积'
}

# 回归任务指标
回归指标 = {
    'MSE': '均方误差',
    'RMSE': '均方根误差',
    'MAE': '平均绝对误差',
    'R²': '决定系数',
    'MAPE': '平均绝对百分比误差'
}

2. 评估方法

# 混淆矩阵分析
def 混淆矩阵分析(真实标签, 预测标签):
    混淆矩阵 = 计算混淆矩阵(真实标签, 预测标签)
    
    # 计算各项指标
    精确率 = 对角线元素 / 列和
    召回率 = 对角线元素 / 行和
    F1分数 = 2 * 精确率 * 召回率 / (精确率 + 召回率)
    
    return {
        '混淆矩阵': 混淆矩阵,
        '精确率': 精确率,
        '召回率': 召回率,
        'F1分数': F1分数
    }

# 学习曲线分析
def 学习曲线分析(训练历史):
    训练损失 = 训练历史['train_loss']
    验证损失 = 训练历史['val_loss']
    
    # 过拟合检测
    最小验证损失轮数 = argmin(验证损失)
    最终验证损失 = 验证损失[-1]
    
    if 最终验证损失 > 最小验证损失轮数 * 1.1:
        return "存在过拟合，考虑提前停止"
    
    # 收敛速度分析
    快速下降期 = 找到快速下降区间(训练损失)
    平稳期 = 找到平稳区间(训练损失)
    
    return {
        '收敛速度': len(快速下降期),
        '过拟合程度': 最终验证损失 - min(验证损失),
        '建议': 生成改进建议(分析结果)
    }

第七阶段：问题诊断与解决（故障排除）

1. 常见问题诊断

# 问题诊断手册
问题诊断 = {
    '训练损失不下降': {
        '可能原因': ['学习率太小', '模型太简单', '数据有问题'],
        '检查步骤': ['检查学习率', '增加模型复杂度', '检查数据质量'],
        '解决方案': ['增大学习率', '增加隐藏层/神经元', '清洗数据']
    },
    
    '验证损失远高于训练损失': {
        '可能原因': ['过拟合', '数据分布不一致', '验证集太小'],
        '检查步骤': ['绘制学习曲线', '检查数据划分', '增加验证集'],
        '解决方案': ['增加正则化', '重新划分数据', '使用交叉验证']
    },
    
    '损失震荡严重': {
        '可能原因': ['学习率太大', '批量太小', '数据噪声大'],
        '检查步骤': ['减小学习率测试', '增大批量大小', '检查数据噪声'],
        '解决方案': ['减小学习率', '增大批量', '数据平滑处理']
    },
    
    '梯度爆炸': {
        '可能原因': ['学习率太大', '权重初始化不当', '网络太深'],
        '检查步骤': ['检查梯度范数', '检查权重分布', '检查网络深度'],
        '解决方案': ['梯度裁剪', '改进初始化', '添加残差连接']
    }
}

2. 调试技巧

# 逐步调试法
def 逐步调试(模型, 数据):
    # 步骤1：小数据过拟合测试
    小批量数据 = 取前10个样本(数据)
    模型小 = 简化模型(模型)
    
    # 应该能快速过拟合
    历史 = 训练(模型小, 小批量数据, 轮数=100)
    
    if 历史['train_acc'][-1] < 0.99:
        return "模型无法过拟合小数据，检查模型实现"
    
    # 步骤2：逐步增加数据
    for 数据比例 in [0.1, 0.3, 0.5, 1.0]:
        部分数据 = 按比例采样(数据, 数据比例)
        历史 = 训练(模型, 部分数据)
        
        if 数据比例 < 0.5 and 历史['val_acc'][-1] < 0.8:
            return f"在{数据比例}数据上表现不佳，需要调整模型"
    
    return "模型调试通过"

# 可视化调试
def 可视化调试(模型, 数据, 训练历史):
    # 绘制损失曲线
    绘制双曲线(训练历史['train_loss'], 训练历史['val_loss'], 
              '训练损失', '验证损失', '损失曲线')
    
    # 绘制预测结果
    样本预测 = 模型(数据[:20])
    绘制预测对比(样本预测, 数据标签[:20])
    
    # 绘制权重分布
    权重列表 = 提取所有权重(模型)
    绘制权重分布(权重列表)

第八阶段：模型优化与部署（产品优化与交付）

1. 模型优化

# 超参数自动调优
def 超参数调优(模型模板, 数据, 参数空间):
    from sklearn.model_selection import RandomizedSearchCV
    
    # 定义参数分布
    参数分布 = {
        '学习率': [0.1, 0.01, 0.001, 0.0001],
        '隐藏层大小': [64, 128, 256, 512],
        'dropout比例': [0.2, 0.3, 0.4, 0.5],
        '批量大小': [32, 64, 128, 256]
    }
    
    # 随机搜索
    随机搜索 = RandomizedSearchCV(
        模型模板, 参数分布, 
        n_iter=20, cv=3, scoring='accuracy'
    )
    
    随机搜索.fit(数据.训练集)
    
    return 随机搜索.best_params_, 随机搜索.best_score_

# 模型集成
def 模型集成(基础模型列表, 训练数据):
    预测列表 = []
    
    for 模型 in 基础模型列表:
        # 训练每个模型
        训练(模型, 训练数据)
        
        # 收集预测
        预测 = 模型.predict(训练数据.验证集)
        预测列表.append(预测)
    
    # 简单平均集成
    集成预测 = mean(预测列表, axis=0)
    
    return 集成预测

2. 模型压缩

# 知识蒸馏
def 知识蒸馏(教师模型, 学生模型, 数据, 温度=3.0):
    # 教师模型生成软标签
    with torch.no_grad():
        教师预测 = 教师模型(数据)
        软标签 = softmax(教师预测 / 温度)
    
    # 学生模型学习软标签
    蒸馏损失 = KL散度(softmax(学生模型(数据) / 温度), 软标签)
    
    return 学生模型

# 剪枝优化
def 权重剪枝(模型, 剪枝比例):
    # 计算权重重要性
    权重重要性 = abs(模型.权重)
    
    # 确定剪枝阈值
    阈值 = percentile(权重重要性, 剪枝比例 * 100)
    
    # 创建掩码
    掩码 = 权重重要性 > 阈值
    
    # 应用掩码
    模型.权重 *= 掩码
    
    return 模型

3. 模型部署

# 模型保存与加载
def 保存模型(模型, 路径, 元数据):
    保存内容 = {
        '模型状态': 模型.state_dict(),
        '模型配置': 模型.配置,
        '训练配置': 元数据,
        '性能指标': 元数据['性能'],
        '预处理参数': 元数据['预处理']
    }
    torch.save(保存内容, 路径)

def 加载模型(路径):
    保存内容 = torch.load(路径)
    模型 = 创建模型(保存内容['模型配置'])
    模型.load_state_dict(保存内容['模型状态'])
    return 模型, 保存内容['预处理参数']

# 推理优化
def 优化推理(模型):
    # 切换到评估模式
    模型.eval()
    
    # 使用TorchScript优化
    优化模型 = torch.jit.script(模型)
    
    # 量化优化（如果支持）
    if 支持量化(模型):
        量化模型 = torch.quantization.quantize_dynamic(
            优化模型, {nn.Linear}, dtype=torch.qint8
        )
        return 量化模型
    
    return 优化模型

完整训练流程实例

房价预测完整案例

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import numpy as np

# 1. 数据准备阶段
print("=== 数据准备阶段 ===")
# 加载数据（示例数据）
X, y = 加载房价数据()  # 假设已有此函数

# 数据划分
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.3, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

# 特征标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_val_scaled = scaler.transform(X_val)
X_test_scaled = scaler.transform(X_test)

# 转换为PyTorch数据集
train_dataset = TensorDataset(torch.FloatTensor(X_train_scaled), torch.FloatTensor(y_train))
val_dataset = TensorDataset(torch.FloatTensor(X_val_scaled), torch.FloatTensor(y_val))
test_dataset = TensorDataset(torch.FloatTensor(X_test_scaled), torch.FloatTensor(y_test))

# 数据加载器
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 2. 模型构建阶段
print("=== 模型构建阶段 ===")
class 房价预测模型(nn.Module):
    def __init__(self, 输入维度):
        super(房价预测模型, self).__init__()
        self.网络 = nn.Sequential(
            nn.Linear(输入维度, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1)
        )
    
    def forward(self, x):
        return self.网络(x)

# 创建模型
输入维度 = X_train.shape[1]
模型 = 房价预测模型(输入维度)

# 3. 训练配置
print("=== 训练配置 ===")
损失函数 = nn.MSELoss()
优化器 = torch.optim.Adam(模型.parameters(), lr=0.001, weight_decay=0.0001)
调度器 = torch.optim.lr_scheduler.ReduceLROnPlateau(优化器, patience=5, factor=0.5)

# 4. 训练循环
print("=== 开始训练 ===")
训练历史 = {'train_loss': [], 'val_loss': []}
最佳验证损失 = float('inf')
耐心计数器 = 0
最大耐心值 = 15

for epoch in range(200):
    # 训练阶段
    模型.train()
    训练损失 = 0
    for 批次X, 批次y in train_loader:
        优化器.zero_grad()
        预测 = 模型(批次X).squeeze()
        损失 = 损失函数(预测, 批次y)
        损失.backward()
        优化器.step()
        训练损失 += 损失.item() * len(批次X)
    
    平均训练损失 = 训练损失 / len(train_loader.dataset)
    
    # 验证阶段
    模型.eval()
    验证损失 = 0
    with torch.no_grad():
        for 批次X, 批次y in val_loader:
            预测 = 模型(批次X).squeeze()
            损失 = 损失函数(预测, 批次y)
            验证损失 += 损失.item() * len(批次X)
    
    平均验证损失 = 验证损失 / len(val_loader.dataset)
    
    # 学习率调度
    调度器.step(平均验证损失)
    
    # 记录历史
    训练历史['train_loss'].append(平均训练损失)
    训练历史['val_loss'].append(平均验证损失)
    
    # 早停检查
    if 平均验证损失 < 最佳验证损失:
        最佳验证损失 = 平均验证损失
        torch.save(模型.state_dict(), '最佳房价预测模型.pth')
        耐心计数器 = 0
    else:
        耐心计数器 += 1
    
    if 耐心计数器 >= 最大耐心值:
        print(f"早停于第{epoch+1}轮")
        break
    
    if (epoch + 1) % 10 == 0:
        print(f"轮次 {epoch+1}: 训练损失 = {平均训练损失:.4f}, 验证损失 = {平均验证损失:.4f}")

# 5. 模型评估
print("=== 模型评估 ===")
模型.load_state_dict(torch.load('最佳房价预测模型.pth'))
模型.eval()

测试预测 = []
测试真实 = []

with torch.no_grad():
    for 批次X, 批次y in test_loader:
        预测 = 模型(批次X).squeeze()
        测试预测.extend(预测.numpy())
        测试真实.extend(批次y.numpy())

# 计算评估指标
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

mse = mean_squared_error(测试真实, 测试预测)
rmse = np.sqrt(mse)
mae = mean_absolute_error(测试真实, 测试预测)
r2 = r2_score(测试真实, 测试预测)

print(f"测试集评估结果:")
print(f"MSE: {mse:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"MAE: {mae:.2f}")
print(f"R²: {r2:.4f}")

# 6. 结果可视化
print("=== 结果可视化 ===")
import matplotlib.pyplot as plt

# 损失曲线
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(训练历史['train_loss'], label='训练损失')
plt.plot(训练历史['val_loss'], label='验证损失')
plt.xlabel('轮次')
plt.ylabel('MSE损失')
plt.title('训练过程损失曲线')
plt.legend()
plt.grid(True)

# 预测结果对比
plt.subplot(1, 2, 2)
plt.scatter(测试真实, 测试预测, alpha=0.5)
plt.plot([min(测试真实), max(测试真实)], [min(测试真实), max(测试真实)], 'r--', lw=2)
plt.xlabel('真实价格')
plt.ylabel('预测价格')
plt.title('预测值 vs 真实值')
plt.grid(True)

plt.tight_layout()
plt.savefig('训练结果可视化.png')
plt.show()

print("=== 训练完成！===")

训练流程最佳实践总结

1. 数据为先

数据质量检查清单：
□ 数据完整性检查（缺失值处理）
□ 数据一致性检查（异常值处理）
□ 数据分布分析（训练/验证/测试集）
□ 特征工程充分（标准化、编码、特征选择）
□ 数据增强考虑（图像、文本等）

2. 渐进式训练

训练策略：
□ 先小数据过拟合测试（验证模型能力）
□ 逐步增加数据量（观察学习曲线）
□ 从简单模型开始（避免过度复杂）
□ 逐步添加正则化（防止过早正则化）
□ 监控训练过程（及时发现问题）

3. 系统调优

调优顺序：
1. 学习率调优（最重要）
2. 网络架构调整（宽度/深度）
3. 正则化强度调整（L2/Dropout）
4. 其他超参数微调（批量大小等）
5. 优化算法选择（SGD/Adam等）

4. 全面评估

评估维度：
□ 训练集表现（学习能力）
□ 验证集表现（泛化能力）
□ 测试集表现（最终性能）
□ 学习曲线分析（过拟合/欠拟合）
□ 错误样本分析（改进方向）

5. 文档记录

实验记录：
□ 实验配置（超参数设置）
□ 训练过程（损失曲线截图）
□ 最终结果（评估指标）
□ 问题与解决（经验教训）
□ 改进建议（未来方向）

小结

神经网络训练是一个系统工程，需要统筹规划、分步实施、持续优化。通过掌握这个完整的训练流程，你将能够：

1. 系统性地解决各种机器学习问题
2. 快速定位和解决训练过程中的问题
3. 持续改进模型性能和泛化能力
4. 高效地开发深度学习应用

记住：理论指导实践，实践验证理论。在学习了这个完整流程后，最重要的是通过实际项目来巩固和深化理解。

恭喜你完成了神经网络基础的学习！接下来，我们将进入PyTorch实战环节，通过具体的代码实现来加深理解。