鸿蒙原生应用开发-网络管理Socket连接（三）-CFANZ编程社区

1.目的

找到一个可运行的代码，可以每个epoch打印训练数据，但是不会保存。因为在改进模型需要这些训练数据进行对比，所以需要将每个epoch的训练数据保存下来，写到一个文件中。

2.解决方案

直接问ChatGPT，提示词如下：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import json

# 定义一个简单的网络
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(32 * 28 * 28, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = x.view(x.size(0), -1)
        x = self.fc1(x)
        return x

# 设置超参数
batch_size = 64
num_epochs = 10
learning_rate = 0.01

# 创建数据集和数据加载器
transform = transforms.Compose([transforms.ToTensor()])
train_dataset = datasets.MNIST(root='data/', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# 创建网络、损失函数和优化器
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

# 文件名
output_file = "training_data.json"

# 开始训练
training_data = []

for epoch in range(num_epochs):
    epoch_loss = 0.0
    correct = 0
    total = 0

    # 训练一个 epoch
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        epoch_loss += loss.item() * inputs.size(0)
        _, predicted = outputs.max(1)
        correct += predicted.eq(labels).sum().item()
        total += labels.size(0)

    # 计算平均损失和准确度
    avg_loss = epoch_loss / total
    accuracy = correct / total

    # 将 epoch 的数据添加到列表中
    epoch_data = {
        "epoch": epoch + 1,
        "avg_loss": avg_loss,
        "accuracy": accuracy
    }
    training_data.append(epoch_data)

    # 打印 epoch 的训练结果
    print(f"Epoch {epoch + 1}: Avg Loss: {avg_loss:.4f}, Accuracy: {accuracy:.4f}")

# 将所有 epoch 的训练数据保存到文件中
with open(output_file, 'w') as f:
    json.dump(training_data, f)

print(f"Training data saved to {output_file}")

由于缺少数据集，也懒得去找一个数据集，就将自己py文件中训练部分摘出来给ChatGPT，让它在训练方法中实现这个功能。

def train():
    data_format(os.path.join(config.root_path, './data/train.txt'),
    os.path.join(config.root_path, './data/data'), os.path.join(config.root_path, './data/train.json'))
    data = read_from_file(config.train_data_path, config.data_dir, config.only)
    train_data, val_data = train_val_split(data)
    train_loader = processor(train_data, config.train_params)
    val_loader = processor(val_data, config.val_params)

    best_acc = 0
    epoch = config.epoch
    for e in range(epoch):
        print('-' * 20 + ' ' + 'Epoch ' + str(e+1) + ' ' + '-' * 20)
        # 训练模型
        tloss, tloss_list = trainer.train(train_loader)
        print('Train Loss: {}'.format(tloss))
        # writer.add_scalar('Training/loss', tloss, e)
        # 验证模型
        vloss, vacc = trainer.valid(val_loader)
        print('Valid Loss: {}'.format(vloss))
        print('Valid Acc: {}'.format(vacc))
        # writer.add_scalar('Validation/loss', vloss, e)
        # writer.add_scalar('Validacc/acc', vacc, e)
        # 保存训练数据
        training_data = {
            "epoch": e + 1,
            "train_loss": tloss,
            "valid_loss": vloss,
            "valid_acc": vacc
        }
        with open('training_data.json', 'a') as f:
            json.dump(training_data, f)
            f.write('\n')
        print("数据保存完成")
        # 保存最佳模型
        if vacc > best_acc:
            best_acc = vacc
            save_model(config.output_path, config.fuse_model_type, model)
            print('Update best model!')


     
    print('-' * 20 + ' ' + 'Training Finished' + ' ' + '-' * 20)
    print('Best Validation Accuracy: {}'.format(best_acc))

在我的代码中具体加入的是下列几行代码

代码意思如下：