入门深度学习——基于全连接神经网络的手写数字识别案例（python代码实现）

一、网络构建

1.1 问题导入

如图所示，数字五的图片作为输入，layer01层为输入层，layer02层为隐藏层，找出每列最大值对应索引为输出层。根据下图给出的网络结构搭建本案例用到的全连接神经网络

1.2 手写字数据集MINST

如图所示，MNIST数据集是机器学习领域中非常经典的一个数据集，由60000个训练样本和10000个测试样本组成，每个样本都是一张28 * 28像素的灰度手写数字图片。数据集也被嵌入到sklearn和pytorch框架中可以直接调用。这里我们默认已经安装了pytorch框架。不会使用的这里简单介绍一下。
大家可以用按住win+R键，打开运行窗口，输入cmd。

输入cmd，回车后，会显示如下。

输入以下的命令，可以看看自己的电脑的显卡是不是NVIDIA。如果是AMD的，那么就安装cpu的吧，毕竟CUDA内核，只支持NVIDIA的显卡。

#AMD显卡
pip install pytorch-cpu
#NVIDIA显卡
pip install pytorch
#如果速度慢的话，可以加入清华源的链接
pip install pytorch-cpu -i https://pypi.tuna.tsinghua.edu.cn/simple/
#NVIDIA显卡
pip install pytorch -i https://pypi.tuna.tsinghua.edu.cn/simple/

这样就完成了，仍然存在问题的小伙伴，可以参考小程序员推荐的这个up主的教程pytorch保姆级教程。
这里我们输出几张图片和对应的标签。作为对数据集的了解，也方便我们针对性的设计网络结构，做到心中有数。

二、采用Pytorch框架编写全连接神经网络代码实现手写字识别

2.1 导入必要的包

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

2.2 定义一些数据预处理操作

pipline=transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5],[0.5])])

2.3 下载数据集（训练集vs测试集）

train_dataset=datasets.MNIST('./data',train=True,transform=pipline,download=True)
test_dataset=datasets.MNIST('./data',train=False,transform=pipline,download=True)
print(len(train_dataset))
print(len(test_dataset))

60000
10000

2.4 分批加载训练集和测试集中的数据到内存里

train_loader=DataLoader(train_dataset,batch_size=32,shuffle=True)
test_loader=DataLoader(test_dataset,batch_size=32)

2.5 可视化数据集中的数据，做到心中有数

import matplotlib.pyplot as plt
examples=enumerate(train_loader)
_,(example_data,example_label)=next(examples)
print(example_data.shape)
for i in range(6):plt.subplot(2,3,i+1)plt.tight_layout()plt.imshow(example_data[i][0],cmap='gray')
#     plt.title('Ground Truth:{}'.format(example_label[i]))plt.title(f'Ground Truth:{example_label[i]}')

torch.Size([32, 1, 28, 28])

2.6 网络模型设计（有时也称为网络模型搭建）

class Net(nn.Module):def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):super(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.Sigmoid())self.layer3=nn.Linear(n_hidden_2,out_dim)    def forward(self,x):x=self.layer1(x)x=self.layer2(x)x=self.layer3(x)return x

model=Net(28*28,300,100,10)
model

以下结果来自Jupyter Notebook
Net(
(layer1): Sequential(
(0): Linear(in_features=784, out_features=300, bias=True)
(1): ReLU(inplace=True)
)
(layer2): Sequential(
(0): Linear(in_features=300, out_features=100, bias=True)
(1): Sigmoid()
)
(layer3): Linear(in_features=100, out_features=10, bias=True)
)

import torch.optim as optim
criterion=nn.CrossEntropyLoss()   #选用Pytorch中nn模块封装好的交叉熵损失函数
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)  #选用随机梯度下降法（SGD）作为本模型的梯度下降法
device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')   #确定代码运行设备究竟实在GPU还是CPU上跑
model.to(device)

2.7 训练网络模型

losses=[]
acces=[]eval_losses=[]
eval_acces=[]#训练轮数---epochfor epoch in range(10):train_loss=0train_acc=0model.train()   #启用网络模型隐藏层中的dropout和BN（批归一化）操作if epoch%5==0:   #控制训练轮数间隔optimizer.param_groups[0]['lr']*=0.9    #动态调整学习率for img,label in train_loader:img=img.to(device)   #将训练图片写到设备里label=label.to(device)  #将图片类别写到设备里img=img.view(img.size(0),-1)out=model(img)   #调用前向传播函数得到预测值loss=criterion(out,label)   #计算预测值和真实值的损失optimizer.zero_grad()  #在新一轮反向传播开始前，清空上一轮反向传播得到的梯度loss.backward()  #把上一部得到的损失执行反向传播，得到新的网络模型参数（权值）optimizer.step()   #把上一部得到的新的权值更新到网络模型里#在前面前向传播和反向传播的额基础上，计算一些训练算法性能指标train_loss+=loss.item()  #记录反向传播每一轮得到的损失_,pred=out.max(1)   #得到图片的预测类别num_correct=(pred==label).sum().item()   #获取预测正确的样本数量acc=num_correct/img.shape[0]      #每一批次的正确率train_acc+=acc       #每一轮次的额正确率losses.append(train_loss/len(train_loader))    #所有轮次训练完之后总的损失acces.append(train_acc/len(train_loader))     #所有轮次训练完之后总的正确率

2.8 在测试集上测试网络模型，检验模型效果

eval_loss=0
eval_acc=0
model.eval()   #继续沿用BN操作，但是不再使用dropout操作with torch.no_grad():for img,label in test_loader:img=img.to(device)label=label.to(device)img=img.view(img.size(0),-1)out=model(img)loss=criterion(out,label)eval_loss+=loss.item()   #记录每一批次的损失_,pred=out.max(1)num_correct=(pred==label).sum().item()acc=num_correct/img.shape[0]   #记录每一批次的准确率eval_acc+=acc     #记录每一轮的准确率eval_losses.append(eval_loss / len(test_loader))eval_acces.append(eval_acc / len(test_loader))print('epoch: {}, Train Loss: {:.4f}, Train Acc: {:.4f}, Test Loss: {:.4f}, Test Acc: {:.4f}'.format(epoch, train_loss / len(train_loader), train_acc / len(train_loader), eval_loss / len(test_loader), eval_acc / len(test_loader)))

epoch: 0, Train Loss: 1.1721, Train Acc: 0.6760, Test Loss: 0.4936, Test Acc: 0.8692
epoch: 1, Train Loss: 0.4093, Train Acc: 0.8866, Test Loss: 0.3368, Test Acc: 0.9020
epoch: 2, Train Loss: 0.3192, Train Acc: 0.9084, Test Loss: 0.2884, Test Acc: 0.9171
epoch: 3, Train Loss: 0.2755, Train Acc: 0.9194, Test Loss: 0.2552, Test Acc: 0.9271
epoch: 4, Train Loss: 0.2429, Train Acc: 0.9290, Test Loss: 0.2251, Test Acc: 0.9349
epoch: 5, Train Loss: 0.2160, Train Acc: 0.9367, Test Loss: 0.2001, Test Acc: 0.9405
epoch: 6, Train Loss: 0.1945, Train Acc: 0.9433, Test Loss: 0.1854, Test Acc: 0.9447
epoch: 7, Train Loss: 0.1761, Train Acc: 0.9494, Test Loss: 0.1716, Test Acc: 0.9504
epoch: 8, Train Loss: 0.1601, Train Acc: 0.9540, Test Loss: 0.1597, Test Acc: 0.9527
epoch: 9, Train Loss: 0.1468, Train Acc: 0.9572, Test Loss: 0.1434, Test Acc: 0.9567

2.10可视化训练及测试的损失值

plt.title('Train Loss')
plt.plot(np.arange(len(losses)),losses);
plt.legend(['Train Loss'],loc='upper right')                   

损失函数的结果：

三、代码文件

小程序员将代码文件和相关素材整理到了百度网盘里，因为文件大小基本不大，大家也不用担心限速问题。后期小程序员有能力的话，将在gitee或者github上上传相关素材。
链接：https://pan.baidu.com/s/1Ce14ZQYEYWJxhpNEP1ERhg?pwd=7mvf
提取码：7mvf