实验五：全连接神经网络手写数字识别实验

【实验目的】

理解神经网络原理，掌握神经网络前向推理和后向传播方法；

掌握使用pytorch框架训练和推理全连接神经网络模型的编程实现方法。

【实验内容】

1.使用pytorch框架，设计一个全连接神经网络，实现Mnist手写数字字符集的训练与识别。

【实验报告要求】

修改神经网络结构，改变层数观察层数对训练和检测时间，准确度等参数的影响；
修改神经网络的学习率，观察对训练和检测效果的影响；
修改神经网络结构，增强或减少神经元的数量，观察对训练的检测效果的影响。

实验内容:

1 import torch
2 import numpy as np
3 from matplotlib import pyplot as plt
4 from torch.utils.data import DataLoader
5 from torchvision import transforms
6 from torchvision import datasets
7 import torch.nn.functional as F

 1 batch_size = 64
 2 learning_rate = 0.01
 3 momentum = 0.5
 4 EPOCH = 10
 5 transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
 6 train_dataset = datasets.MNIST(root='./data/mnist', train=True, transform=transform, download=True)  
 7 test_dataset = datasets.MNIST(root='./data/mnist', train=False, transform=transform, download=True)  
 8 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
 9 test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
10 class Net(torch.nn.Module):
11     def __init__(self):
12         super(Net, self).__init__()
13         self.conv1 = torch.nn.Sequential(
14             torch.nn.Conv2d(1, 10, kernel_size=5),
15             torch.nn.ReLU(),
16             torch.nn.MaxPool2d(kernel_size=2),
17         )
18         self.conv2 = torch.nn.Sequential(
19             torch.nn.Conv2d(10, 20, kernel_size=5),
20             torch.nn.ReLU(),
21             torch.nn.MaxPool2d(kernel_size=2),
22         )
23         self.fc = torch.nn.Sequential(
24             torch.nn.Linear(320, 50),
25             torch.nn.Linear(50, 10),
26         )
27 
28     def forward(self, x):
29         batch_size = x.size(0)
30         x = self.conv1(x)  # 一层卷积层,一层池化层,一层激活层
31         x = self.conv2(x)  
32         x = x.view(batch_size, -1)  
33         x = self.fc(x)
34         return x 
35 #实例化模型
36 model = Net()
37 criterion = torch.nn.CrossEntropyLoss()  # 交叉熵损失
38 optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)  # lr学习率，momentum冲量
39 
40 def train(epoch):
41     running_loss = 0.0  
42     running_total = 0
43     running_correct = 0
44     for batch_idx, data in enumerate(train_loader, 0):
45         inputs, target = data
46         optimizer.zero_grad()    
47         outputs = model(inputs)
48         loss = criterion(outputs, target)
49         loss.backward()
50         optimizer.step()
51         running_loss += loss.item()
52         # 把运行中的准确率acc算出来
53         _, predicted = torch.max(outputs.data, dim=1)
54         running_total += inputs.shape[0]
55         running_correct += (predicted == target).sum().item()
56         if batch_idx % 300 == 299:  # 不想要每一次都出loss，浪费时间，选择每300次出一个平均损失,和准确率
57             print('[%d, %5d]: loss: %.3f , acc: %.2f %%'
58                   % (epoch + 1, batch_idx + 1, running_loss / 300, 100 * running_correct / running_total))
59             running_loss = 0.0  # 这小批300的loss清零
60             running_total = 0
61             running_correct = 0  # 这小批300的acc清零
62 
63 #测试轮
64 def test():
65     correct = 0
66     total = 0
67     with torch.no_grad():  # 测试集不用算梯度
68         for data in test_loader:
69             images, labels = data
70             outputs = model(images)
71             _, predicted = torch.max(outputs.data, dim=1)  # dim = 1 列是第0个维度，行是第1个维度，沿着行(第1个维度)去找1.最大值和2.最大值的下标
72             total += labels.size(0)  # 张量之间的比较运算
73             correct += (predicted == labels).sum().item()
74     acc = correct / total
75     print('[%d / %d]: Accuracy on test set: %.1f %% ' % (epoch+1, EPOCH, 100 * acc))  # 求测试的准确率，正确数/总数
76     return acc
77 #主函数：共进行10轮次的训练：每训练一轮，就进行一次测试。
78 if __name__ == '__main__':
79     acc_list_test = []
80     for epoch in range(EPOCH):
81         train(epoch)
82         # if epoch % 10 == 9:  #每训练10轮 测试1次
83         acc_test = test()
84         acc_list_test.append(acc_test)

 1 #举例展示部分图
 2 import matplotlib.pyplot as plt;
 3 fig = plt.figure()
 4 for i in range(16):
 5     plt.subplot(4, 4, i+1)
 6     z=train_dataset.train_data[i]
 7     m=train_dataset.train_labels[i]
 8     plt.imshow(z, cmap='gray', interpolation='none')
 9     plt.title("Labels: {}".format(m))
10     plt.xticks([])
11     plt.yticks([])
12 plt.show()

1 y_test=acc_list_test
2 plt.plot(y_test)
3 plt.xlabel("Epoch")
4 plt.ylabel("Accuracy On TestSet")
5 plt.show()