用pytorch绘制模型学习曲线的代码

以下是使用pytorch绘制模型学习曲线的代码：

import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# Load Data
transform = transforms.Compose([transforms.ToTensor(),
                               transforms.Normalize((0.5,), (0.5,)),
                              ])
train_set = datasets.MNIST('./data', download=True, train=True, transform=transform)
test_set = datasets.MNIST('./data', download=True, train=False, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=64, shuffle=True)

# Define Model
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 10)

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

model = Net()

# Define Criteria and Optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# Train and Test
train_loss = []
train_acc = []
test_loss = []
test_acc = []

epochs = 10
for epoch in range(epochs):
    running_loss = 0.0
    running_corrects = 0.0
    for images, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        _, preds = torch.max(outputs, 1)
        loss.backward()
        optimizer.step()

        running_loss += loss.item() * images.size(0)
        running_corrects += torch.sum(preds == labels.data)

    epoch_loss = running_loss / len(train_loader.dataset)
    epoch_acc = running_corrects.double() / len(train_loader.dataset)

    train_loss.append(epoch_loss)
    train_acc.append(epoch_acc)

    model.eval()
    with torch.no_grad():
        running_loss = 0.0
        running_corrects = 0.0
        for images, labels in test_loader:
            outputs = model(images)
            loss = criterion(outputs, labels)
            _, preds = torch.max(outputs, 1)

            running_loss += loss.item() * images.size(0)
            running_corrects += torch.sum(preds == labels.data)

        epoch_loss = running_loss / len(test_loader.dataset)
        epoch_acc = running_corrects.double() / len(test_loader.dataset)

        test_loss.append(epoch_loss)
        test_acc.append(epoch_acc)

    print('Epoch {}/{} - Training Loss: {:.4f} - Training Acc: {:.4f} - Test Loss: {:.4f} - Test Acc: {:.4f}'.format(epoch+1, epochs, epoch_loss, epoch_acc, epoch_loss, epoch_acc))

# Plot Accuracy
x = np.arange(1, epochs+1)
plt.plot(x, train_acc, label='Training Accuracy')
plt.plot(x, test_acc, label='Test Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

# Plot Loss
plt.plot(x, train_loss, label='Training Loss')
plt.plot(x, test_loss, label='Test Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()

这段代码会训练一个简单的网络在MNIST数据集上进行分类，并绘制出训练过程中的准确率和损失曲线。