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

【实验目的】

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

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

【实验内容】

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

 

【实验报告要求】

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

 

#构建一个类线性模型类，继承自nn.Module,nn.m中封装了许多方法
#本模型所用的包含库
import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt
import torchvision
import numpy as np
import torch.optim as optim
from torch.utils.data import Dataset    #这是一个抽象类，无法实例化
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import os
#构建一个compose类的实例，包含转tensor（张量），后面那个是标准化，两个参数分别是均值和标准差
train_transform = transforms.Compose([
                                transforms.RandomAffine(degrees = 0,translate=(0.1, 0.1)),#对照片进行随机平移
                                transforms.RandomRotation((-10,10)),        #随机旋转
                                transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])
test_transform = transforms.Compose([transforms.ToTensor(),
                                    transforms.Normalize((0.1307,),(0.3081,))])
#这2个值也是调参重灾区……
train_batch_size = 256
learning_rate = 0.006
test_batch_size = 100
random_seed = 2         # 随机种子，设置后可以得到稳定的随机数
torch.manual_seed(random_seed)
torch.cuda.manual_seed_all(random_seed) #为gpu提供随机数
# 下载训练集 MNIST 手写数字训练集
# 数据是datasets类型的
train_dataset = datasets.FashionMNIST(
    root='../datasets', train=True, transform=transforms.ToTensor(), download=False)

test_dataset = datasets.FashionMNIST(
    root='../datasets', train=False, transform=transforms.ToTensor(),download=False)

train_loader = DataLoader(dataset=train_dataset,batch_size=train_batch_size,shuffle=True,pin_memory=True)
test_loader = DataLoader(dataset=test_dataset,batch_size=test_batch_size,shuffle=False,pin_memory=True)
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #卷积层
        self.conv1 = nn.Conv2d(1  ,32, kernel_size=5,padding=2)
        self.conv2 = nn.Conv2d(32 ,64, kernel_size=5,padding=2)
        self.conv3 = nn.Conv2d(64 ,128,kernel_size=5,padding=2)
        self.conv4 = nn.Conv2d(128,192,kernel_size=5,padding=2)

        #残差神经网络层，其中已经包含了relu
        self.rblock1 = ResidualBlock(32)
        self.rblock2 = ResidualBlock(64)
        self.rblock3 = ResidualBlock(128)
        self.rblock4 = ResidualBlock(192)
        
        #BN层，归一化，使数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定
        self.bn1 = nn.BatchNorm2d(32)
        self.bn2 = nn.BatchNorm2d(64)
        self.bn3 = nn.BatchNorm2d(128)
        self.bn4 = nn.BatchNorm2d(192)
        
        #最大池化，一般最大池化效果都比平均池化好些
        self.mp = nn.MaxPool2d(2)
        
        #fully connectected全连接层
        self.fc1 = nn.Linear(192*7*7, 256)  # 线性
        self.fc6 = nn.Linear(256, 10)  # 线性

    def forward(self, x):
        in_size = x.size(0)
        
        x = self.conv1(x)   #channels:1-32  w*h:28*28  
        x = self.bn1(x)
        x = F.relu(x) 
        x = self.rblock1(x)
        
        x = self.conv2(x)   #channels:32-64 w*h:28*28
        x = F.relu(x)   
        x = self.bn2(x)
        x = self.rblock2(x)
        
        x = self.mp(x)      #最大池化,channels:64-64    w*h:28*28->14*14
        

        x = self.conv3(x)   #channels:64-128    w*h:14*14
        x = self.bn3(x)
        x = F.relu(x)
        x = self.rblock3(x)

        x = self.conv4(x)   #channels:128-192   w*h:14*14
        x = self.bn4(x)
        x = F.relu(x)
        x = self.rblock4(x)
        
        x = self.mp(x)      #最大池化,channels:192-192  w*h:14*14->7*7

        x = x.view(in_size, -1)     #展开成向量
        x = F.relu(self.fc1(x))  # 使用relu函数来激活
        
        return self.fc6(x)

#调用GPU
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
torch.backends.cudnn.benchmark = True       #启用cudnn底层算法
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
#print(device)
torch.cuda.empty_cache()        #释放显存

model.to(device)

# #构建损失函数
criterion = torch.nn.CrossEntropyLoss()      #交叉熵
#
# #构建优化器,参数1：模型权重，参数二，learning rate
optimizer = optim.SGD(model.parameters(),lr=learning_rate,momentum=0.5)    #带动量0.5

#optimizer = optim.RMSprop(model.parameters(),lr=learning_rate,alpha=0.99,momentum = 0.5)
# optimizer = torch.optim.Adam(model.parameters(),
#                              lr=0.05,
#                              betas=(0.9, 0.999),
#                              eps=1e-08,
#                              weight_decay=0,
#                              amsgrad=False)
#设置学习率梯度下降，如果连续2个epoch测试准确率没有上升，则降低学习率，系数0.5
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=2, verbose=True, threshold=0.00005, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)
#把训练封装成一个函数
def train(epoch):
    running_loss =0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,target = data
        inputs,target = inputs.to(device),target.to(device)
        optimizer.zero_grad()

        #forward,backward,update
        outputs = model(inputs)
        loss = criterion(outputs,target)
        loss.backward()
        optimizer.step()

        running_loss+=loss.item()
        if batch_idx%300==299:
            train_loss_val.append((running_loss/300))
            #print('[%d,%5d] loss:%3f'%(epoch+1,batch_idx+1,running_loss/300))
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0
#把测试封装成函数
def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images,labels = data
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            #torch.max()返回的是两个值，第一个是用_接受(蚌埠住了),第二个是pre
            _, predicted = torch.max(outputs.data,dim=1)       #从第一维度开始搜索
            total += labels.size(0)
            correct += (predicted==labels).sum().item()
    print('Accuracy on test set: %f %% [%d/%d]' % (100 * correct / total, correct, total))

    return correct/total
train_epoch = []
model_accuracy = []
temp_acc = 0.0
train_loss_val = []
for epoch in range(30):
    train(epoch)
    acc = test()

    print(epoch + 1,acc)
    train_epoch.append(epoch)
    model_accuracy.append(acc)
    scheduler.step(acc)

plt.figure(1)
plt.plot(train_epoch, model_accuracy)  # 传入列表，plt类用来画图
plt.grid(linestyle=':')
plt.ylabel('accuracy')  # 定义y坐标轴的名字
plt.xlabel('epoch')  # 定义x坐标
plt.show()  # 显示

Output exceeds the size limit. Open the full output data in a text editor
Accuracy on test set: 89.560000 % [8956/10000]
1 0.8956
Accuracy on test set: 89.340000 % [8934/10000]
2 0.8934
Accuracy on test set: 89.360000 % [8936/10000]
3 0.8936
Accuracy on test set: 89.380000 % [8938/10000]
4 0.8938
Epoch     4: reducing learning rate of group 0 to 3.0000e-03.
Accuracy on test set: 89.340000 % [8934/10000]
5 0.8934
Accuracy on test set: 89.470000 % [8947/10000]
6 0.8947
Accuracy on test set: 89.430000 % [8943/10000]
7 0.8943
Epoch     7: reducing learning rate of group 0 to 1.5000e-03.
Accuracy on test set: 89.360000 % [8936/10000]
8 0.8936
Accuracy on test set: 89.470000 % [8947/10000]
9 0.8947
Accuracy on test set: 89.440000 % [8944/10000]
10 0.8944
Epoch    10: reducing learning rate of group 0 to 7.5000e-04.
Accuracy on test set: 89.410000 % [8941/10000]
11 0.8941
...
Accuracy on test set: 89.400000 % [8940/10000]
14 0.894
Accuracy on test set: 89.510000 % [8951/10000]
15 0.8951

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

在训练神经网络时，需要设置学习率（learning rate）控制参数的更新速度，学习速率设置过小，会极大降低收敛速度，增加训练时间；学习率太大，可能导致参数在最优解两侧来回振荡。学习率和训练次数同样也会影响正确率。学习率太高，代价函数不容易降低到最低点（会不断越过最低点）。

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

一般来说，在调参合理的情况下，层数和神经元数越多，正确率越高，不过相应地，容易出现过拟合