1.使用PyTorch实现LeNet网络 2.使用本地文件夹的 Fashion MNIST 对LeNet进行训练和测试，优化算法采用SGD或Adam，torch.optim.SGD 或 torch.optim.Adam 3.分别绘制训练和测试的损失函数曲线和分类正确率曲线 4.调节BatchSize、学习率，并依据测试损失曲线的拐点确定最佳模型，保存该模型 5.使用测试集测试所保存模型的性能，以混淆矩阵展示

好的，我来给你讲解一下使用PyTorch实现LeNet网络的具体步骤：

1.导入所需要的库

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

2.定义LeNet网络

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(16 * 4 * 4, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool1(torch.relu(self.conv1(x)))
        x = self.pool2(torch.relu(self.conv2(x)))
        x = x.view(-1, 16 * 4 * 4)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

3.加载数据集

batch_size = 64

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5,), (0.5,))])

trainset = torchvision.datasets.FashionMNIST(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.FashionMNIST(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                         shuffle=False, num_workers=2)

4.定义优化器和损失函数

net = LeNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

5.训练模型并绘制损失函数曲线和分类正确率曲线

epochs = 10
train_losses = []
train_accs = []
test_losses = []
test_accs = []

for epoch in range(epochs):
    running_loss = 0.0
    running_acc = 0.0

    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        running_acc += (predicted == labels).sum().item()

    train_loss = running_loss / len(trainloader.dataset)
    train_acc = running_acc / len(trainloader.dataset)
    train_losses.append(train_loss)
    train_accs.append(train_acc)

    test_loss = 0.0
    test_acc = 0.0
    with torch.no_grad():
        for data in testloader:
            inputs, labels = data
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            test_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            test_acc += (predicted == labels).sum().item()

        test_loss /= len(testloader.dataset)
        test_acc /= len(testloader.dataset)
        test_losses.append(test_loss)
        test_accs.append(test_acc)

    print('Epoch [%d/%d], Train Loss: %.4f, Train Accuracy: %.4f, Test Loss: %.4f, Test Accuracy: %.4f'
          % (epoch + 1, epochs, train_loss, train_acc, test_loss, test_acc))

plt.plot(train_losses, label='Training Loss')
plt.plot(test_losses, label='Testing Loss')
plt.legend()
plt.show()

plt.plot(train_accs, label='Training Accuracy')
plt.plot(test_accs, label='Testing Accuracy')
plt.legend()
plt.show()

6.保存最佳模型

best_test_loss = min(test_losses)
best_epoch = test_losses.index(best_test_loss)

print('Best Epoch: %d, Best Test Loss: %.4f' % (best_epoch + 1, best_test_loss))

torch.save(net.state_dict(), 'best_model.pth')

7.使用混淆矩阵展示模型性能

confusion_matrix = torch.zeros(10, 10)
with torch.no_grad():
    for data in testloader:
        inputs, labels = data
        outputs = net(inputs)
        _, predicted = torch.max(outputs, 1)
        for i in range(len(labels)):
            confusion_matrix[labels[i]][predicted[i]] += 1

classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot')
plt.figure(figsize=(10, 10))
plt.imshow(confusion_matrix, interpolation='nearest', cmap=plt.cm.Blues)
plt.title('Confusion Matrix')
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
plt.xlabel('Predicted label')
plt.ylabel('True label')
plt.show()

通过以上步骤，我们就可以完成使用PyTorch实现LeNet网络的训练和测试，并且得到最佳模型，最后使用混淆矩阵展示模型性能。