大模型训时，主要是训练模型参数 权重 W, 和偏置b，训练过程中需要调试出一个合适的超参数（如下）

• Epoch（训练轮数）
• Batch Size（批大小）  --> 还有一个 Iteration（迭代次数）
• lr（Learning Rate 学习率）

1. Epoch（训练轮数）

🎯 1个Epoch = 模型完整遍历一次整个训练数据集的过程

1.1 举例

• 训练集大小 = 10,000个样本
• Epoch数量 = 10
• 总训练样本数 = 10,000 × 10 = 100,000次样本处理

1.2 为什么需要多个Epoch？

• 单Epoch的问题

• • 学习不充分: 模型只能看到一次数据，无法充分学习复杂模式
  • 容易过拟合: 如果强行拟合，可能记住噪声而非规律
  • 收敛不充分: 参数优化可能未达到最优状态

• 多Epoch的优势

• • 渐进式学习: 模型可以逐步 refine 对数据的理解
  • 更好的泛化: 通过多次见到数据，学习真正规律而非噪声
  • 稳定收敛: 参数优化更平滑，更容易找到全局最优

1.3 Epoch数量的选择策略

这是简单示意，实际上也得看模型复杂度，在本文第 5 章有介绍

数据集样本数	batch_size 适合范围	说明
< 1000	50-100	小数据集需要更多Epoch
< 10000	20-50	中等数据集
> 10000	10-30	大数据集可以较少Epoch

📌 早停法（Early Stopping）

最佳实践 = "监控验证集损失，当连续N个Epoch不再提升时停止训练"

2. Batch Size（批大小）

🎯 Batch Size = 每次模型参数更新前处理的样本数量

for epoch in range(num_epochs):  # Epoch循环
    for iteration, (batch_x, batch_y) in enumerate(dataloader):  # Iteration循环
        略（后文有关系介绍与代码示例）...

2.1 三种批处理模式对比

🎯 关于优化算法可以看👉 🎯 优化算法 torch.optim

1. 批梯度下降（Batch Gradient Descent）

• • Batch Size = 整个训练集大小
  • 优点：梯度方向准确，收敛稳定
  • 缺点：内存要求高，更新慢

1. 随机梯度下降（Stochastic Gradient Descent）

• • Batch Size = 1
  • 优点：更新快，有噪声帮助逃离局部最优
  • 缺点：震荡大，收敛不稳定

1. 小批量梯度下降（Mini-batch Gradient Descent）

• • Batch Size = 32, 64, 128等（最常用！）
  • 优点：平衡了稳定性和效率
  • 缺点：需要选择合适的批大小

2.2 Batch Size选择的影响

• 内存使用: 批大小↑ → 内存需求↑,
• 训练速度: 批大小↑ → 每次迭代计算量↑，但总迭代次数↓,
• 梯度质量: 批大小↑ → 梯度估计更准确，噪声更小",
• 泛化能力: 批大小↓ → 噪声↑ → 可能有助于泛化",
• 收敛稳定性: 批大小↑ → 训练曲线更平滑"

2.3 常见Batch Size设置

这是简单示意，实际上也得看模型复杂度，在本文第 5 章有介绍

2.3.1 根据硬件GPU内存选择

GPU内存大小	batch_size 适合范围
4GB	16-32
8GB	32-64
16GB	64-128
32	128-256

2.3.2 根据数据集大小调整

数据集样本数	batch_size 适合范围
< 1000	16-32
> 1000	32-128

3. Iteration（迭代次数）

🎯 1次Iteration = 完成一个Batch数据的正向传播 + 反向传播 + 参数更新

3.1 计算公式

def calculate_iterations(dataset_size, batch_size, num_epochs):
    """计算总迭代次数"""
    # 每个Epoch的迭代次数
    iterations_per_epoch = ceil(dataset_size / batch_size)

    # 总迭代次数  
    total_iterations = num_epochs * iterations_per_epoch

    return total_iterations

# 示例计算
dataset_size = 2000
batch_size = 64
num_epochs = 10

iterations_per_epoch = ceil(2000 / 64) = 32  # 2000÷64=31.25 → 32个batch
total_iterations = 10 × 32 = 320

3.2 迭代次数的意义

• 模型更新次数: 每次迭代代表一次参数优化机会
• 计算资源衡量: 迭代次数比Epoch数更能反映实际计算量"
• 学习率调度: 有些学习率调度器基于迭代次数而非Epoch数
• 收敛判断: 观察损失随迭代次数的变化趋势

4. 学习率（Learning Rate, lr）

🎯 学习率 = 控制参数更新步长的超参数

4.1 数学表达

🧮 梯度下降公式：新参数 = 旧参数 - 学习率 × 梯度

# PyTorch中的优化器
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

4.2 学习率的重要性

• 学习率过大: 像下坡时步伐太大，可能越过最低点甚至发散,
• 学习率过小: 像下坡时小碎步，收敛极慢，可能卡在局部最优,
• 学习率合适: 能快速稳定地找到最优点

4.3 学习率选择策略

这是简单示意，实际上也得看模型复杂度，在本文第 5 章有介绍

4.3.1 不同优化器的典型学习率

优化器	学习率	说明
SGD	0.01	需要相对较大的学习率
SGD+Momentum	0.01	与SGD类似
RMSprop	0.001 或 1e-3	与Adam类似
Adam	0.001 或 1e-3	默认0.001通常效果很好
AdamW	0.001 或 1e-3	与Adam类似

4.3.2 学习率设置经验

场景	经验参考
从经典值开始	小数据集/复杂模型
使用学习率查找器	LR Finder
大数据集/简单任务	可尝试稍大学习率
小数据集/复杂模型	使用较小学习率
结合学习率调度器	scheduler

4.4 学习率调度策略

import torch.optim.lr_scheduler as lr_scheduler

# 1. 步长衰减
scheduler = lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

# 2. 指数衰减  
scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.95)

# 3. 余弦退火（当前最流行）
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)

# 4. 热启动（Warmup） + 余弦退火
def warmup_cosine_scheduler(optimizer, warmup_epochs, total_epochs):
    def lr_lambda(epoch):
        if epoch < warmup_epochs:
            return (epoch + 1) / warmup_epochs  # 线性热启动
        else:
            # 余弦退火
            progress = (epoch - warmup_epochs) / (total_epochs - warmup_epochs)
            return 0.5 * (1 + math.cos(math.pi * progress))

    return lr_scheduler.LambdaLR(optimizer, lr_lambda)

5. 四者关系总结

5.1 训练过程完整流程

🎯 通常我们会将超参数配置在配置文件中，然后调整配置文件，进行模型训练，找到最优的超参数； 当然这个过程中，优化器、损失函数等的选择也很重要，也是模型训练过程中要不断调试的内容

def train_model(model, dataset, batch_size, num_epochs, learning_rate)

# 伪代码展示完整训练流程
def train_model(model, dataset, batch_size, num_epochs, learning_rate):
    # 初始化优化器
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

    # 创建数据加载器
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    # 计算总迭代次数
    iterations_per_epoch = len(dataloader)
    total_iterations = num_epochs * iterations_per_epoch

    print(f"训练配置:")
    print(f"- 数据集大小: {len(dataset)}")
    print(f"- Batch Size: {batch_size}") 
    print(f"- Epoch数量: {num_epochs}")
    print(f"- 学习率: {learning_rate}")
    print(f"- 每Epoch迭代: {iterations_per_epoch}次")
    print(f"- 总迭代: {total_iterations}次")

    # 训练循环
    for epoch in range(num_epochs):  # Epoch循环
        for iteration, (batch_x, batch_y) in enumerate(dataloader):  # Iteration循环

            # 前向传播
            predictions = model(batch_x)
            loss = loss_function(predictions, batch_y)

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

            # 参数更新（使用当前学习率）
            optimizer.step()

            print(f"Epoch {epoch+1}/{num_epochs}, "
                  f"Iteration {iteration+1}/{iterations_per_epoch}, "
                  f"Loss: {loss.item():.4f}, "
                  f"LR: {optimizer.param_groups[0]['lr']:.6f}")

        # 每个Epoch结束后可更新学习率
        scheduler.step()

5.2 参数关系公式

🎯 参数关系公式

• 总迭代次数 = Epoch数 × ceil(数据集大小 / Batch Size)
• 总训练样本数 = Epoch数 × 数据集大小
• 参数更新次数 = 总迭代次数
• 实际训练时间 ∝ 总迭代次数 × 每次迭代时间

5.3 实用选择指南

5.3.1 Epoch数量选择

模型复杂度	数据集样本数	batch_size 适合范围	说明
high	< 10000	50-100	复杂模型+小数据 → 需要更多Epoch
low	> 50000	10-20	简单模型+大数据 → 较少Epoch足够
一般情况	一般情况	20-50	一般情况

5.3.2 Batch Size选择

GPU内存大小	batch_size 适合范围
4GB	16-32
8GB	32-64
16GB	64-128
32	128-256

def recommend_batch_size(available_memory_gb, dataset_size):
    """根据可用内存推荐Batch Size"""
    memory_to_batch = {
        4: 16-32,    # 4GB内存 → Batch Size 16-32
        8: 32-64,    # 8GB内存 → Batch Size 32-64  
        16: 64-128,  # 16GB内存 → Batch Size 64-128
        32: 128-256  # 32GB+内存 → 可以更大
    }
    
    base_size = memory_to_batch.get(available_memory_gb, 32)
    
    # 根据数据集大小微调
    if dataset_size < 1000:
        return min(base_size, 32)  # 小数据集用较小Batch
    else:
        return base_size

5.3.3 学习率选择

Batch Size越大，学习率可以适当增大（线性缩放规则）

优化器	学习率	说明
SGD	0.01	需要相对较大的学习率
SGD+Momentum	0.01	与SGD类似
RMSprop	0.001 或 1e-3	与Adam类似
Adam	0.001 或 1e-3	默认0.001通常效果很好
AdamW	0.001 或 1e-3	与Adam类似

def recommend_learning_rate(optimizer_name, batch_size):
    """根据优化器和Batch Size推荐学习率"""
    base_lr = {
        'SGD': 0.01,
        'Adam': 0.001, 
        'AdamW': 0.001,
        'RMSprop': 0.001
    }[optimizer_name]

    # Batch Size越大，学习率可以适当增大（线性缩放规则）
    scaled_lr = base_lr * (batch_size / 32)  # 以32为基准

    return min(scaled_lr, 0.1)  # 设置上限

6. 实际项目配置示例

6.1 图像分类项目（CIFAR-10）

cifar10_config = {
    "数据集大小": 50000,
    "推荐Batch Size": 128,      # 平衡内存和效率
    "推荐Epoch数": 100,         # 充分训练
    "推荐学习率": 0.001,        # Adam优化器
    "学习率调度": "CosineAnnealing",  # 余弦退火
    "预计迭代次数": ceil(50000/128)×100 ≈ 40000
}

6.2 自然语言处理项目（文本分类）

nlp_config = {
    "数据集大小": 20000, 
    "推荐Batch Size": 32,       # 通常比图像任务小
    "推荐Epoch数": 20,          # 文本数据通常需要较少Epoch
    "推荐学习率": 0.0001,       # 更小的学习率
    "学习率调度": "LinearWarmup", # 线性热启动
    "预计迭代次数": ceil(20000/32)×20 ≈ 12500
}

本文涵盖了深度学习训练的核心超参数，理解这些概念之间的关系对于有效训练模型至关重要。在实际项目中，建议先用这些经验值作为起点，然后根据具体任务进行调优。

更多推荐

• 知识库原文：https://www.yuque.com/lhyyh/ai/mtu181alxykfrhzc
• 工信部 · AIGC证书：https://www.yuque.com/lhyyh/ai/ins6gx3o7hck7shb
• AI 工具集导航：https://tools.lhagi.com/
• AI 大模型全栈 50 万字知识库：https://www.yuque.com/lhyyh/ai

3 年打磨，全是精华，从普通职场人士到大模型算法，应有尽有！