PyTorch 训练和验证循环 - 准确率和损失计算

num_epochs = 50
for epoch in range(num_epochs):
    train_running_loss = 0.0
    train_correct_total = 0
    train_total = 0

    # 训练阶段
    network.train()

    for i, input_tensor in enumerate(train_tensors):
        optimizer.zero_grad()

        input_tensor = input_tensor.to(device)  # 将输入张量移动到GPU上
        output = network(input_tensor)

        loss = custom_loss(output, tensor_list[i])

        loss.backward()
        optimizer.step()

        # 统计准确率
        target_similarity = F.cosine_similarity(output, tensor_list[i].unsqueeze(0), dim=1)
        label_list = [torch.tensor([1, 0, 0]), torch.tensor([0, 1, 0]), torch.tensor([0, 0, 1])]
        other_list = []
        for label_tensor in label_list:
            if not torch.all(torch.eq(tensor_list[i], label_tensor)):
                other_list.append(label_tensor)

        if target_similarity > torch.max(torch.stack([F.cosine_similarity(output, other.unsqueeze(0), dim=1) for other in other_list]), dim=0).values:
            train_correct_total += 1

        train_total += 1

        train_running_loss += loss.item()

    # 计算训练集的准确率和损失
    train_accuracy = train_correct_total / train_total
    train_loss = train_running_loss / len(train_tensors)

    # 保存网络参数
    if epoch == num_epochs - 1:
        torch.save(network.state_dict(), 'final_model.pt')

    # 打印训练集的准确率和损失
    print('Train Accuracy: %.2f%%' % (100 * train_accuracy))
    print('Epoch: %d, Train Loss: %.3f' % (epoch + 1, train_loss))

    network.eval()
    val_correct_total = 0
    val_total = 0
    val_running_loss = 0.0

    with torch.no_grad():
        for j, val_input_tensor in enumerate(val_tensors):
            val_input_tensor = val_input_tensor.to(device)  # 将输入张量移动到GPU上
            val_output = network(val_input_tensor)

            label_list = [torch.tensor([1, 0, 0]), torch.tensor([0, 1, 0]), torch.tensor([0, 0, 1])]
            val_target_similarity = F.cosine_similarity(val_output, tensor_list[j].unsqueeze(0), dim=1)
            other_list = []
            for label_tensor in label_list:
                if not torch.all(torch.eq(tensor_list[j], label_tensor)):
                    other_list.append(label_tensor)

            if val_target_similarity > torch.max(torch.stack([F.cosine_similarity(val_output, other.unsqueeze(0), dim=1) for other in other_list]), dim=0).values:
                val_correct_total += 1

            val_total += 1

            loss = custom_loss(val_output, tensor_list[j])
            val_running_loss += loss.item()

        # 计算验证集的准确率和损失
        val_accuracy = val_correct_total / val_total
        val_loss = val_running_loss / len(val_tensors)

        # 打印验证集的准确率和损失
        print('Validation Accuracy: %.2f%%' % (100 * val_accuracy))
        print('Epoch: %d, Validation Loss: %.3f' % (epoch + 1, val_loss))

这段代码展示了如何使用 PyTorch 实现一个基本的训练和验证循环，包括以下关键步骤：

1. 训练阶段
   • 设置模型为训练模式 (network.train())
   • 迭代训练数据集
   • 计算损失
   • 反向传播和参数更新
   • 统计训练准确率
   • 计算训练损失
2. 验证阶段
   • 设置模型为评估模式 (network.eval())
   • 迭代验证数据集
   • 计算验证准确率
   • 计算验证损失

该代码示例还包含了以下要点：

• 自定义损失函数: 使用 custom_loss 函数计算损失，根据具体任务进行调整。
• 准确率计算: 代码使用余弦相似度来计算准确率，可根据实际任务进行调整。
• 模型保存: 在训练结束时保存模型参数。
• 打印训练和验证信息: 在每个 epoch 结束时打印训练集和验证集的准确率和损失，方便监控训练过程。

注意：这段代码只是示例代码，需要根据具体的任务进行调整和完善。例如，需要根据任务选择合适的优化器、损失函数和评价指标。此外，还可以根据需要添加一些功能，例如学习率衰减、早停等。

其他相关知识:

• PyTorch 文档: https://pytorch.org/
• PyTorch 教程: https://pytorch.org/tutorials/
• 深度学习基础知识: https://www.deeplearningbook.org/