山大软院ai导论实验之采用BP神经网络分类MNIST数据集-EW帮帮网

实验代码

import matplotlib.pyplot as plt
from matplotlib import font_manager
import torch
from torch.utils.data import DataLoader
import torchvision
from torchvision import transforms

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])


train_data_path = 'E:\\小刘的桌面\\人工智能导论实验\\expr2_trainset'
train_dataset = torchvision.datasets.MNIST(root=train_data_path, train=True, download=True, transform=transform)
test_dataset = torchvision.datasets.MNIST(root=train_data_path, train=False, download=True, transform=transform)

# 使用DataLoader加载数据集
train_loader = DataLoader(dataset=train_dataset, shuffle=True, batch_size=100)
test_loader = DataLoader(dataset=test_dataset, shuffle=False, batch_size=100)

# 定义BP神经网络结构
class BPNetwork(torch.nn.Module):
    def __init__(self):
        super(BPNetwork, self).__init__()

        # # 4层
        # self.fc1 = torch.nn.Linear(784, 256)
        # self.activation1 = torch.nn.ReLU()
        # self.fc2 = torch.nn.Linear(256, 128)
        # self.activation2 = torch.nn.ReLU()
        # self.fc3 = torch.nn.Linear(128, 64)
        # self.activation3 = torch.nn.ReLU()
        # self.fc4 = torch.nn.Linear(64, 32)
        # self.activation4 = torch.nn.ReLU()
        # self.fc5 = torch.nn.Linear(32, 10)


        # #2层
        # self.fc1 = torch.nn.Linear(784,64)
        # self.activation1 = torch.nn.ReLU()
        # self.fc2 = torch.nn.Linear(64, 32)
        # self.activation2 = torch.nn.ReLU()
        # self.fc3 = torch.nn.Linear(32, 10)




        # self.softmax = torch.nn.LogSoftmax(dim=1)

    # def forward(self, x):
    #     x = x.view(x.size(0), -1)
    #     x = self.activation1(self.fc1(x))
    #     x = self.activation2(self.fc2(x))
    #     # x = self.activation3(self.fc3(x))
    #     x = self.softmax(self.fc3(x))
    #     return x
    # def forward(self, x):
    #     x = x.view(x.size(0), -1)
    #     x = self.activation1(self.fc1(x))
    #     x = self.activation2(self.fc2(x))
    #     x = self.activation3(self.fc3(x))
    #     x = self.activation4(self.fc4(x))
    #     x = self.softmax(self.fc5(x))  # 修改为使用fc5
    #     return x
        # 3个隐藏层
        self.fc1 = torch.nn.Linear(784, 128)
        self.activation1 = torch.nn.ReLU()
        self.fc2 = torch.nn.Linear(128, 64)
        self.activation2 = torch.nn.ReLU()
        self.fc3 = torch.nn.Linear(64, 32)
        self.activation3 = torch.nn.ReLU()
        self.fc4 = torch.nn.Linear(32, 10)

        self.softmax = torch.nn.LogSoftmax(dim=1)


    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.activation1(self.fc1(x))
        x = self.activation2(self.fc2(x))
        x = self.activation3(self.fc3(x))
        x = self.softmax(self.fc4(x))  # 使用fc4作为输出层
        return x

    #     # 5个隐藏层
    #     self.fc1 = torch.nn.Linear(784, 512)
    #     self.activation1 = torch.nn.ReLU()
    #     self.fc2 = torch.nn.Linear(512, 256)
    #     self.activation2 = torch.nn.ReLU()
    #     self.fc3 = torch.nn.Linear(256, 128)
    #     self.activation3 = torch.nn.ReLU()
    #     self.fc4 = torch.nn.Linear(128, 64)
    #     self.activation4 = torch.nn.ReLU()
    #     self.fc5 = torch.nn.Linear(64, 32)
    #     self.activation5 = torch.nn.ReLU()
    #     self.fc6 = torch.nn.Linear(32, 10)
    #
    #     self.softmax = torch.nn.LogSoftmax(dim=1)
    #
    #
    # def forward(self, x):
    #     x = x.view(x.size(0), -1)
    #     x = self.activation1(self.fc1(x))
    #     x = self.activation2(self.fc2(x))
    #     x = self.activation3(self.fc3(x))
    #     x = self.activation4(self.fc4(x))
    #     x = self.activation5(self.fc5(x))
    #     x = self.softmax(self.fc6(x))  # 使用fc6作为输出层
    #     return x


# 创建网络模型
model = BPNetwork()
# 定义损失函数与优化器
criterion = torch.nn.NLLLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.009, momentum=0.9)
num_epochs = 1
total_batches = 0

font = font_manager.FontProperties()


batch_steps = []
train_accuracies = []
test_accuracies = []

# 训练网络
for epoch in range(num_epochs):
    for images, labels in train_loader:
        total_batches += 1
        optimizer.zero_grad()  # 清空梯度
        outputs = model(images)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

        # 每50批次计算并记录准确率
        if total_batches % 50 == 0:
            # 计算训练集准确率
            train_correct = (outputs.argmax(dim=1) == labels).sum().item()
            train_accuracy = train_correct / len(images)

            # 计算测试集准确率
            test_correct = 0
            with torch.no_grad():
                for test_images, test_labels in test_loader:
                    test_outputs = model(test_images)
                    test_correct += (test_outputs.argmax(dim=1) == test_labels).sum().item()
            test_accuracy = test_correct / len(test_dataset)

            # 存储结果
            batch_steps.append(total_batches)
            train_accuracies.append(train_accuracy)
            test_accuracies.append(test_accuracy)

            print(f"Step {total_batches}, Training Accuracy: {train_accuracy:.2f}, Test Accuracy: {test_accuracy:.4f}")

# 绘制曲线
plt.figure(figsize=(10, 5))
plt.plot(batch_steps, train_accuracies, label='Training Accuracy', marker='o')
plt.plot(batch_steps, test_accuracies, label='Test Accuracy', marker='x')
plt.title('Training and Test Accuracy Over Time', fontproperties=font, fontsize=18)
plt.xlabel('Batch Steps', fontproperties=font, fontsize=12)
plt.ylabel('Accuracy', fontproperties=font, fontsize=12)
plt.legend()
plt.show()