在分批训练中，计算每个 epoch 的损失通常涉及以下步骤：

1. 初始化累积损失：在开始处理每个 epoch 之前，初始化一个变量来累积损失。
2. 批次训练：逐个批次地处理数据，计算每个批次的损失，并将其累加到累积损失中。
3. 计算平均损失：在处理完所有批次后，将累积的损失除以批次的数量，得到该 epoch 的平均损失。

详细步骤

1. 初始化累积损失：在每个 epoch 的开头，设置一个变量 running_loss 为 0。

2. 逐个批次处理：

   • 前向传播：使用当前的模型参数计算预测输出。
   • 计算损失：使用损失函数计算预测输出和真实标签之间的损失。
   • 反向传播：执行反向传播，计算损失相对于模型参数的梯度。
   • 参数更新：使用优化器更新模型参数。
   • 累积损失：将当前批次的损失累加到 running_loss 中。

3. 计算平均损失：在处理完所有批次后，计算平均损失，即 epoch_loss = running_loss / len(train_loader)。

示例代码

下面是一个使用 PyTorch 实现分批训练并计算损失的完整示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 定义一个简单的神经网络
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 10)

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

# 生成指定大小的数据集
def generate_dataset(size):
    input_data = torch.randn(size, 784)
    labels = torch.randint(0, 10, (size,))
    return TensorDataset(input_data, labels)

# 训练函数
def train_model(dataset, batch_size, num_epochs=20):
    train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
    
    model = SimpleNet()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.01)
    
    for epoch in range(num_epochs):
        model.train()
        running_loss = 0.0
        for inputs, targets in train_loader:
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, targets)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
        
        # 计算每个epoch的平均训练损失
        avg_loss = running_loss / len(train_loader)
        print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {avg_loss:.4f}')

# 生成数据集并进行训练
dataset = generate_dataset(10000)
train_model(dataset, batch_size=32, num_epochs=20)

解释

1. 初始化累积损失：在每个 epoch 的开头，running_loss 被初始化为 0。
2. 批次训练：对于每个批次，执行前向传播、计算损失、反向传播和参数更新，然后将当前批次的损失累加到 running_loss 中。
3. 计算平均损失：在处理完所有批次后，计算该 epoch 的平均损失，并打印出来。

通过这种方法，可以有效地跟踪每个 epoch 的训练进展，并确保模型在训练过程中的稳定性和收敛性。