输出train los train acc test acc 图

好的，我们可以在训练过程中记录每个epoch的训练损失、训练精度和测试精度，并在训练完成后将其输出。以下是修改后的训练代码：

# 定义损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# 记录训练信息
train_losses = []
train_accuracies = []
test_accuracies = []

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    train_loss = 0.0
    train_total = 0
    train_correct = 0
    
    for i, (inputs, labels) in enumerate(data_loader):
        # 前向传播
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        # 记录训练信息
        train_loss += loss.item() * labels.size(0)
        _, predicted = torch.max(outputs.data, 1)
        train_total += labels.size(0)
        train_correct += (predicted == labels).sum().item()
        
        # 每训练10个batch，输出一次信息
        if (i + 1) % 10 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
                  .format(epoch+1, num_epochs, i+1, len(data_loader), loss.item()))
    
    # 计算训练精度和测试精度
    train_loss /= len(dataset)
    train_accuracy = train_correct / train_total
    test_accuracy = evaluate(model, './flower', batch_size)
    
    # 记录训练信息
    train_losses.append(train_loss)
    train_accuracies.append(train_accuracy)
    test_accuracies.append(test_accuracy)
    
    # 输出训练信息
    print('Epoch [{}/{}], Training Loss: {:.4f}, Train Accuracy: {:.4f}, Test Accuracy: {:.4f}'
          .format(epoch+1, num_epochs, train_loss, train_accuracy, test_accuracy))

# 保存模型参数
torch.save(model.state_dict(), './resnet18_iris.pth')

其中，`train_losses`、`train_accuracies`和`test_accuracies`分别记录了每个epoch的训练损失、训练精度和测试精度。

在每个epoch结束后，我们计算训练精度和测试精度，并将其记录到相应的列表中。

在训练完成后，我们输出每个epoch的训练损失、训练精度和测试精度。其中，`evaluate()`函数可以计算测试集上的精度，以下是该函数的代码：

def evaluate(model, data_path, batch_size):
    data_transforms = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    
    dataset = ImageFolder(data_path, transform=data_transforms)
    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
    
    correct = 0
    total = 0
    
    with torch.no_grad():
        for inputs, labels in data_loader:
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    accuracy = correct / total
    return accuracy

其中，`data_path`指定了待计算精度的数据集路径，`batch_size`指定了每个batch的大小。

在函数中，我们同样使用`ImageFolder`类加载数据集，并使用`DataLoader`类定义数据加载器。

计算精度时，我们需要关闭梯度计算，使用`torch.no_grad()`上下文管理器可以实现该功能。

最终，在训练完成后，我们输出每个epoch的训练损失、训练精度和测试精度。