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

【实验目的】

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

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

【实验内容】

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

 

【实验报告要求】

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

 代码：

pip install torch

　

 

pip install torchvision

　

 

import torch
import numpy as np
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import torch.nn.functional as F

　

 

#超参数：用到的超参数主要有小批量数据的batch size，
#梯度下降算法中用到的学习率(learning rate)和冲量(momentum)，同时定义进行10轮次的训练。
batch_size = 64
learning_rate = 0.01
momentum = 0.5
EPOCH = 10
# softmax归一化指数函数,其中0.1307是mean均值和0.3081是std标准差
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
#下载/获取数据集，其中root为数据集存放路径，train=True即训练集否则为测试集。
train_dataset = datasets.MNIST(root='./data/mnist', train=True, transform=transform, download=True)  # 本地没有就加上download=True
test_dataset = datasets.MNIST(root='./data/mnist', train=False, transform=transform, download=True)  # train=True训练集，=False测试集
#实例化一个dataset后，然后用Dataloader 包起来，即载入数据集
#shuffle=True即打乱数据集，这里我们打乱训练集进行训练，而对测试集进行顺序测试。
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
# 训练集乱序，测试集有序
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Sequential(
            torch.nn.Conv2d(1, 10, kernel_size=5),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = torch.nn.Sequential(
            torch.nn.Conv2d(10, 20, kernel_size=5),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2),
        )
        self.fc = torch.nn.Sequential(
            torch.nn.Linear(320, 50),
            torch.nn.Linear(50, 10),
        )

    def forward(self, x):
        batch_size = x.size(0)
        x = self.conv1(x)  # 一层卷积层,一层池化层,一层激活层(图是先卷积后激活再池化，差别不大)
        x = self.conv2(x)  # 再来一次
        x = x.view(batch_size, -1)  # flatten 变成全连接网络需要的输入 (batch, 20,4,4) ==> (batch,320), -1 此处自动算出的是320
        x = self.fc(x)
        return x  # 最后输出的是维度为10的，也就是（对应数学符号的0~9）
#实例化模型
model = Net()
#损失函数使用交叉熵损失
#参数优化使用随机梯度下降
criterion = torch.nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)  # lr学习率，momentum冲量
# 把单独的一轮一环封装在函数类里
#训练轮
def train(epoch):
    running_loss = 0.0  # 这整个epoch的loss清零
    running_total = 0
    running_correct = 0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()
        # forward + backward + update
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        # 把运行中的loss累加起来，为了下面300次一除
        running_loss += loss.item()
        # 把运行中的准确率acc算出来
        _, predicted = torch.max(outputs.data, dim=1)
        running_total += inputs.shape[0]
        running_correct += (predicted == target).sum().item()
        if batch_idx % 300 == 299:  # 不想要每一次都出loss，浪费时间，选择每300次出一个平均损失,和准确率
            print('[%d, %5d]: loss: %.3f , acc: %.2f %%'
                  % (epoch + 1, batch_idx + 1, running_loss / 300, 100 * running_correct / running_total))
            running_loss = 0.0  # 这小批300的loss清零
            running_total = 0
            running_correct = 0  # 这小批300的acc清零
        # torch.save(model.state_dict(), './model_Mnist.pth')
        # torch.save(optimizer.state_dict(), './optimizer_Mnist.pth')
#测试轮
def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 测试集不用算梯度
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)  # dim = 1 列是第0个维度，行是第1个维度，沿着行(第1个维度)去找1.最大值和2.最大值的下标
            total += labels.size(0)  # 张量之间的比较运算
            correct += (predicted == labels).sum().item()
    acc = correct / total
    print('[%d / %d]: Accuracy on test set: %.1f %% ' % (epoch+1, EPOCH, 100 * acc))  # 求测试的准确率，正确数/总数
    return acc
#主函数：共进行10轮次的训练：每训练一轮，就进行一次测试。
if __name__ == '__main__':
    acc_list_test = []
    for epoch in range(EPOCH):
        train(epoch)
        # if epoch % 10 == 9:  #每训练10轮 测试1次
        acc_test = test()
        acc_list_test.append(acc_test)

 

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

 

y_test=acc_list_test
plt.plot(y_test)
plt.xlabel("Epoch")
plt.ylabel("Accuracy On TestSet")
plt.show()

修改神经网络的学习率，观察对训练和检测效果的影响；

学习率设置太大会造成网络不能收敛，在最优值附近徘徊，也就是说直接跳过最低的地方跳到对称轴另一边，从而忽视了找到最优值的位置，学习率设置太小，网络收敛非常缓慢，会增大找到最优值的时间，也就是说从山坡上像蜗牛一样慢慢地爬下去。虽然设置非常小的学习率是可以到达，但是这很可能会进入局部极值点就收敛，没有真正找到的最优解。

修改神经网络结构，增强或减少神经元的数量，观察对训练的检测效果的影响。

一般条件下，在调参合理的情况下，层数和神经元数越多，正确率越高，但随之对应的是，容易出现过拟合