【Pytorch】7. Pytorch搭建多层全连接神经网络实现MNIST图像分类任务

最新推荐文章于 2024-06-17 21:23:48 发布

马苏比拉米G

最新推荐文章于 2024-06-17 21:23:48 发布

阅读量5.4k

点赞数

分类专栏： Pytorch

本文链接：https://blog.csdn.net/weixin_44388679/article/details/102872001

版权

Pytorch 专栏收录该内容

13 篇文章 5 订阅

订阅专栏

一、全连接神经网络介绍

全连接神经网络是一种最基本的神经网络结构，英文为Full Connection，所以一般简称FC。FC的神经网络中除输入层之外的每个节点都和上一层的所有节点有连接。例如下面这个网络结构就是典型的全连接：
在这里插入图片描述
神经网络的第一层为输入层，最后一层为输出层，中间所有的层都为隐藏层。在计算神经网络层数的时候，一般不把输入层算做在内，所以上面这个神经网络为2层。其中输入层有3个神经元，隐层有4个神经元，输出层有2个神经元。

二、三层FC实现MNIST手写数字分类

先用 PyTorch 实现最简单的三层全连接神经网络，然后添加激活层查看试验结果，最后再加上批标准化验证是否能够更加有效。

import torch
import matplotlib.pyplot as plt
import torch.optim as optim
from torch.autograd import Variable
import torch.nn as nn
import numpy as np
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

1、简单的三层全连接神经网络

'''
输入的维度：in_dim；
第一层神经网络的神经元个数n_hidden_1；
第二层神经网络神经元的个数n_hidden_2,out_dim
第三层网络(输出成)神经元的个数
'''
class simpleNet(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(simpleNet,self).__init__()
        self.layer1 = nn.Linear(in_dim,n_hidden_1)
        self.layer2 = nn.Linear(n_hidden_1,n_hidden_2)
        self.layer3= nn.Linear(n_hidden_2,out_dim)
        
    def forward(self,x):
        hidden_1_out = self.layer1(x)
        hidden_2_out = self.layer2(hidden_1_out)
        out = self.layer3(hidden_2_out)
        return out

2、添加激活函数

#nn.Sequential将网络的层组合到一起里面,按顺序进行网络构建。
#激活层和池化从都不需要参数。
class Activation_Net(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(Activation_Net,self).__init__()
        self.layer1 = nn.Sequential(
            nn.Linear(in_dim,n_hidden_1),nn.ReLU(True))
        self.layer2 = nn.Sequential(
            nn.Linear(n_hidden_1,n_hidden_2),nn.ReLU(True))
        self.layer3 = nn.Sequential(nn.Linear(nn_hidden_2,out_dim))
        
    def forward(self,x):
        hidden_1_out = self.layer1(x)
        hidden_2_out = self.layer2(hidden_1_out)
        out = self.layer3(hidden_2_out)  #输出层不能添加激活函数，因为输出的结果表示真实的得分
        return out

3、添加批标准化

nn.Sequential将nn.BathNorm1d()组合到网络层中，批标准化函数加快收敛。-般放在全连接层的后面、非线性层(激活函数)的前面。

class Batch_Net(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(Baych_Net,self).__init__()
        self.layer1 = nn.Sequential(
            nn.Linear(in_dim,n_hidden_1),
            nn.BatchNorm1d(n_hidden_1),
            nn.ReLU(True))
        self.layer2 = nn.Sequential(
            nn.Linear(n_hidden_1,n_hidden_2),
            nn.BatchNorm1d(n_hidden_2),
            nn.ReLU(True))
        self.layer3 = nn.Sequential(
            nn.Linear(n_hidden_2,out_dim))
            
    def forward(self,x):
        hidden_1_out = self.layer1(x)
        hidden_2_out = self.layer2(hidden_2_out)
        out = self.layer3(hidden_2_out)
        return out

4、模型训练

#定义超参数
batch_size = 64
learning_rate = 0.02

#定义图片格式转化为Tenson格式：
'''
1.transforms.Compose()将各种预处理操作组合到一起
2.transform.ToTensor()将图片转换成 PyTorch 中处理的对象 Tensor.在转化的过程中 PyTorch 自动将图片标准化了，也就是说Tensor的范用是(0,1)之间
3.transforms.Normalize()要传入两个参数:均值、方差，做的处理就是减均值，再除以方差。将图片转化到了(-1,1)之间
4.注意因为图片是灰度图，所以只有一个通道，如果是彩色图片，有三个通道，transforms.Normalize([a,b,c],[d,e,f])来表示每个通道对应的均值和方差。
'''
data_tf = transforms.Compose([transforms.ToTensor(),
                              transforms.Normalize([0.5],[0.5])])
#PyTorch 的内置函数 torchvision.datasets.MN工ST 导人数据集
train_dataset = datasets.MNIST(
    root='./data',train=True,transform=data_tf,download=True)
test_dataset = datasets.MNIST(
    root='./data',train=False,transform=data_tf)
#注意：测试集为如下形式，评估的准确率为5.0，损失也很高。为什么：test_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=False)DataLoader(train_dataset, batch_size=batch_size, shuffle=False)
#torch.utils.data.DataLoader 建立一个数据迭代器，传入数据集和 batch size, 通过 shuffle=True 来表示每次迭代数据的时候是否将数据打乱。

#测试集无需打乱顺序；训练集打乱顺序，为了增加训练模型的泛化能力
train_loader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
test_loader = DataLoader(test_dataset,batch_size=batch_size,shuffle=False)

#定义模型、损失函数和优化函数
#输入的图片尺寸为28*28；两个隐层分别为300和100；最后输出维度是10，因为是10分类问题。
model = simpleNet(28*28,300,100,10)  
#可以根据需要选择不同的模型进行分类任务
# model = Activation_Net(28 * 28, 300, 100, 10)
# model = Batch_Net(28 * 28, 300, 100, 10)
if torch.cuda.is_available():
    model = model.cuda()

criterion = nn.CrossEntropyLoss()  #交叉熵损失
optimizer = optim.SGD(model.parameters(),lr=learning_rate) #优化函数为随机梯度下降

#训练模型
epoch = 0
for data in train_loader:
    img, label = data
#     print(img.size())  #torch.Size([64, 1, 28, 28])
    img = img.view(img.size(0), -1)  #将维度变为(64,1*28*28)----(batch,in_dim)
    if torch.cuda.is_available():
        img = img.cuda()
        label = label.cuda()
    else:
        img = Variable(img)
        label = Variable(label)
    out = model(img)
    loss = criterion(out, label)
    print_loss = loss.data.item()
 
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    epoch+=1
    if epoch%50 == 0:
        print(f'epoch: {epoch},Train Loss:{loss.data.item():.6f}')  

#模型评估
model.eval()
eval_loss = 0
eval_acc = 0
for data in test_loader:
    img,label = data
    img = img.view(img.size(0),-1)  
    if torch.cuda.is_available():
        # volatile=True表示前向传播时不会保留缓存。测试集不需要做反向传播，所以可以在前向传播时释放掉内存，节约内存空间c
        img = Variable(img,volatile=True).cuda()
        label = Variable(label,volatile=True).cuda()
    else:
        img = Variable(img,volatile=True)
        label = Variable(label,volatile=True)
    out = model(img)
    loss = criterion(out,label)
    eval_loss += loss.data.item() * label.size(0)
    _,pred = torch.max(out,1)
    num_correct = (pred==label).sum()
    eval_acc += num_correct.data.item()
print(f'Test Loss:{eval_loss/(len(test_dataset)):.6f},Acc:{eval_acc/(len(test_dataset)):.6f}')

4、评估结果分析

（1）simpleNet模型训练输出：
epoch: 50,Train Loss:1.595231
epoch: 100,Train Loss:0.950533
epoch: 150,Train Loss:0.809296
epoch: 200,Train Loss:0.545413
epoch: 250,Train Loss:0.572281
epoch: 300,Train Loss:0.566130
epoch: 350,Train Loss:0.685561
epoch: 400,Train Loss:0.415027
epoch: 450,Train Loss:0.299463
epoch: 500,Train Loss:0.468632
epoch: 550,Train Loss:0.433178
epoch: 600,Train Loss:0.465388
epoch: 650,Train Loss:0.474563
epoch: 700,Train Loss:0.542842
epoch: 750,Train Loss:0.249261
epoch: 800,Train Loss:0.442701
epoch: 850,Train Loss:0.368949
epoch: 900,Train Loss:0.572368

（2）simpleNet模型评估输出：
Test Loss:0.348315,Acc:0.902200
（3）三种模型评估对比
simpleNet===>Test Loss:0.348315,Acc:0.902200
Activation_Net===>Test Loss:0.423769,Acc:0.880900
Batch_Net ===>Test Loss:0.166504,Acc:0.958100

参考文献：
1、零基础入门深度学习(3) - 神经网络和反向传播算法https://www.zybuluo.com/hanbingtao/note/476663
2、《深度学习之Pytorch》

马苏比拉米G

关注

0
点赞
踩
31

收藏

觉得还不错? 一键收藏
0
评论
【Pytorch】7. Pytorch搭建多层全连接神经网络实现MNIST图像分类任务

一、全连接神经网络介绍全连接神经网络是一种最基本的神经网络结构，英文为Full Connection，所以一般简称FC。FC的神经网络中除输入层之外的每个节点都和上一层的所有节点有连接。例如下面这个网络结构就是典型的全连接：神经网络的第一层为输入层，最后一层为输出层，中间所有的层都为隐藏层。在计算神经网络层数的时候，一般不把输入层算做在内，所以上面这个神经网络为2层。其中输入层有3个神经元，...
复制链接

扫一扫

专栏目录