【深度学习】搭建类似LeNet-5网络识别Fashion-MNIST数据集(衣服，鞋子等)

---

前言

马上学期要结束了，准备把这一年学的一些内容按模块汇总一下，分享出来。题主课题研究方向：图像处理与模式识别，三维重建。本篇代码主要参考了《pytorch深度学习入门与实践》（作者：孙玉林老师），在我自己的理解基础上对代码做了部分改进（比如显示进度条，调用GPU等）。这是一本很好的书，我的前期学习也是从这本书开始的，强烈推荐。

关于深度学习环境配置这里就不赘述了，大家可以参考别人的博客，本文网络结构比较简单，不需要GPU应该也能带动（CPU就可以），后续正文会有说明。

---

一、基础知识

LeNet-5是一种经典的卷积神经网络结构，于1998年投入实际使用中，该网络最早应用于手写体字符识别应用中。手写体识别差不多算是神经网络里的“Hello world”，祖师爷级别的。
LeNet-5网络结构如下图所示（百度上随便找的）。

从上图可以看出，LeNet-5只有七层，按顺序是：卷积层，池化层，卷积层，池化层，全连接层，全连接层，输出层。
让我们看看具体大小怎么变化的
输入：32×32灰度图（既然是灰度图，就可以不考虑通道数了，只有宽高）
第一层：6个5×5卷积核，步长为1，padding为0，图片大小：32×32——>6×28×28
第二层：2×2池化核，步长为2，padding为0，图片大小：6×28×28——>6×14×14
第三层：16个5×5卷积核，步长为1，padding为0，图片大小：6×14×14——>16×10×10
第四层：2×2池化核，步长为2，padding为0，图片大小：16×10×10——>16×5×5
（此时需将16×5×5拉直为400维的向量，使用flatten函数）
第五层：全连接层，神经元数量为120
第六层：全连接层，神经元数量为84
第七层；全连接层（输出层），又叫分类器，神经元数量为10

以上网络能够很好应对识别手写数字的问题。
不过在本文中，识别FahsionMnist,我们会对七层结构中的部分参数进行修改（比如卷积核等），创造一个类似LeNet-5的网络（后面代码里就能看出哪里改变了）

二、train.py代码模块讲解

2.0.调库

代码如下（示例）：

#--------------------------------0.库文件---------------------------------#
import torch
import torch.nn as nn
import torch.utils.data as Data
from torchvision import transforms
from torchvision.datasets import FashionMNIST


import matplotlib.pyplot as plt
import time
import copy
import pandas as pd
import numpy as np
from tqdm import tqdm
import hiddenlayer as hl
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

部分重要库简介如下表

模块名	简介
torch	pytorch的最核心部分
torch.nn	包含准备好的网络层，可以像搭积木一样构建网络
torch.utils.data	数据预处理功能
torchvision	提供深度学习常用数据集、模型、转换函数等
torchvision. transforms	包含很多官方常用的数据集
torchvision.datasets	包含很多官方常用的数据集
matplotlib.pyplot	常见数据可视化库，画图工具
time	提供时间相关的函数
copy	提供模型参数复制的功能
pandas	数据分析工具
numpy	提供数组计算相关的功能
tqdm	提供进度条，深度学习训练过程可视化
hiddenlayer	深度学习训练过程可视化库

部从代码中我们也可以看到，存在以下两行：

import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

这样做是为了防止虚拟环境中dll文件冲突，如果不加这两行，在后续代码会报错。

2.1 数据载入

代码如下（示例）：

#--------------------------------1.准备数据---------------------------------#
#数据集准备
train_data = FashionMNIST(
    root = "./data/FashionMNIST",
    train = True,
    transform = transforms.ToTensor(),
    download = True #如果没下载数据，就下载数据；如果已经下载好，就换为False
)
#载入数据加载器
train_loader = Data.DataLoader(
    dataset = train_data,
    batch_size = 64,
    shuffle = False,
    num_workers = 0,  #设置进程数为0 不然后面可能会报错（根据电脑不同而不同）
)
test_data = FashionMNIST(
    root = "./data/FashionMNIST",
    train = False,
    transform = transforms.ToTensor(),
    download = True #如果没下载数据，就下载数据；如果已经下载好，就换为False
)
test_data_x=test_data.data.type(torch.FloatTensor)/255
test_data_x=torch.unsqueeze(test_data_x,dim=1)  #之所以要增加一个维度是因为，本来是28X28，缺少通道数，我们一般都是要用通道数的
test_data_y=test_data.targets

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") #调用cpu或者cuda
print(device)

解释：
1）首先，会进行Fashion-MNIST数据的下载和准备。系统会使用封装好的函数torchvision.datasets.FashionMNIST，在root设置的文件路径中下载，并将其转为张量。数据集下载完后如下图所示。和另外一个数据集MNIST类似，它们分别是训练集数据，训练集标签，测试集数据，测试集标签。

重要的一点，我们看看怎么调用查看这些图像和标签呢：（我们以train_data为例）

train_data = FashionMNIST(
    root = "./data/FashionMNIST",
    train = True,
    transform = transforms.ToTensor(),
    download = True #如果没下载数据，就下载数据；如果已经下载好，就换为False
)

train_data_x=train_data.data
train_data_y=train_data.targets
print(type(train_data_x))
print(train_data_x)
print(type(train_data_y))
print(train_data_y)

很简单，使用train_data_x=train_data.data，train_data_y=train_data.targets 两句话就行
我们顺便检查一下训练集测试集的数量，以及形状

train_data = FashionMNIST(
    root = "./data/FashionMNIST",
    train = True,
    transform = transforms.ToTensor(),
    download = True #如果没下载数据，就下载数据；如果已经下载好，就换为False
)

test_data = FashionMNIST(
    root = "./data/FashionMNIST",
    train = False,
    transform = transforms.ToTensor(),
    download = True #如果没下载数据，就下载数据；如果已经下载好，就换为False
)

train_data_x=train_data.data
train_data_y=train_data.targets
test_data_x=test_data.data
test_data_y=test_data.targets

print(train_data_x.shape)
print(train_data_y.shape)
print(test_data_x.shape)
print(test_data_y.shape)

分别是60000，10000，大小是28X28

当然对取到的图像和标签还有一部分呢操作，在这里可以体现：

test_data_x=test_data.data.type(torch.FloatTensor)/255
test_data_x=torch.unsqueeze(test_data_x,dim=1)  #之所以要增加一个维度是因为，本来是28X28，缺少通道数，我们一般都是要用通道数的
test_data_y=test_data.targets

2）然后，系统会使用数据加载器DataLoader加载数据，设置batch批次大小等等…
一般来说batch不能设置太小，也不能设置太大。
num_workers的作用就是设置多线程，在有些数据量大的深度学习平台（YOLO等），我一般会把num_workes设置为0，不然有时候数据溢出会报错。

DataLoader的构造函数部分如下：

这里只对train_data进行了加载，而test_data，是因为test_data不进训练
3）最后，device = torch.device(“cuda:0” if torch.cuda.is_available() else “cpu”)是调用GPU的意思。电脑中有显卡的同学可以用CUDA运算，会快很多。没有显卡也没关系，本文网络结构简单，用CPU一样可以。我的电脑用GPU两分钟就可以训练完，而CPU需要五分钟。

---

2.2 网络搭建

class MyConvNet(nn.Module):
    def __init__(self):
        super(MyConvNet, self).__init__()
        ## 定义第一个卷积层
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1,  
                out_channels=16,  
                kernel_size=3,  
                stride=1,  
                padding=1,  
            ),  ##  (1*28*28) ->(16*28*28) （经典311结构 不改变宽高 ）
            nn.ReLU(), 
            nn.AvgPool2d(
                kernel_size=2,  
                stride=2,  #经典22结构
            ),  ##(16*28*28)->(16*14*14)
        )
        ## 定义第二个卷积层
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 32, 3, 1, 0),  ## (16*14*14)->(32*12*12)  计算过程：（14+2*0-3）/1+1=12
            nn.ReLU(),  # 激活函数
            nn.AvgPool2d(2, 2)  ## (32*12*12)->(32*6*6)
        )
        ## 定义全连接层
        self.classifier = nn.Sequential(
            nn.Linear(32 * 6 * 6, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )

    ## 定义网络的向前传播路径
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)  # 展平多维的卷积图层，经过卷积操作进入全连接层都可能会使用此操作
        output = self.classifier(x)
        return output
Lenet = MyConvNet()
Lenet = Lenet.cuda()

解释
1）我们定义的网络MyConvNet是从模块nn.Module中继承而来的，此模块包含准备好的网络层，可以像搭积木一样构建网络
2）我们这里的结构是仿制Let-5的，实际上与其还是有点区别，这是因为Lenet网络的输入是13232 （灰度图），但是我们这里Fashion数据集的输入是28*28

2.3 网络训练

#--------------------------------3.网络训练---------------------------------#

#参数配置
model = myconvnet #网络模型
traindataloader =  train_loader #训练数据集
train_rate = 0.8 #训练集和测试集比例
num_epochs = 25 # 最大训练轮数
optimizer = torch.optim.Adam(myconvnet.parameters(), lr=0.0003) #优化器
criterion = nn.CrossEntropyLoss()   # 损失函数
criterion = criterion.cuda()
history1 = hl.History()
canvas1 = hl.Canvas()


## 计算训练使用的batch数量
batch_num = len(traindataloader)
train_batch_num = round(batch_num * train_rate)

## 复制模型的参数
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
train_loss_all = []
train_acc_all = []
val_loss_all = []
val_acc_all = []
since = time.time()
for epoch in range(num_epochs):

    # 每个epoch有两个训练阶段
    train_loss = 0.0
    train_corrects = 0
    train_num = 0
    val_loss = 0.0
    val_corrects = 0
    val_num = 0
    loop = tqdm(enumerate(traindataloader), total=batch_num-1)
    for step,(b_x,b_y) in loop:  #对训练器的数据进行迭代计算（step这里要理解）
        b_x = b_x.cuda()
        b_y = b_y.cuda()
        if step < train_batch_num:
            model.train() ## 设置模型为训练模式
            output = model(b_x)  #计算batch上的输出
            output = output.cuda()
            pre_lab = torch.argmax(output,1)
            loss = criterion(output, b_y) #计算batch的误差
            optimizer.zero_grad() #优化器梯度优化为0
            loss.backward() #损失后向传播计算梯度
            optimizer.step() #使用梯度进行优化
            train_loss += loss.item() * b_x.size(0)
            train_corrects += torch.sum(pre_lab == b_y.data)
            train_num += b_x.size(0)

        else:
            model.eval() ## 设置模型为训练模式评估模式
            output = model(b_x)
            output = output.cuda()
            pre_lab = torch.argmax(output,1)
            loss = criterion(output, b_y)
            val_loss += loss.item() * b_x.size(0)
            val_corrects += torch.sum(pre_lab == b_y.data)
            val_num += b_x.size(0)
        loop.set_description(f'Epoch [{epoch}/{num_epochs - 1}]')
        loop.set_postfix(train_loss=train_loss / train_num)
        #动态显示的，每增加一个就除一下
    train_loss_all.append(train_loss / train_num)  # 四个数据存放到列表中，方便后面画图
    train_acc_all.append(train_corrects.double().item() / train_num)
    val_loss_all.append(val_loss / val_num)
    val_acc_all.append(val_corrects.double().item() / val_num)
    # 拷贝模型最高精度下的参数
    if  val_acc_all[-1] > best_acc:
        best_acc = val_acc_all[-1]
        best_model_wts = copy.deepcopy(model.state_dict())
    time_use = time.time() - since
    print("Train and val complete in {:.0f}m {:.0f}s".format(
        time_use // 60, time_use % 60))

    history1.log((epoch),
                train_loss=train_loss/train_num,
                test_acc=val_corrects/(train_num / 4),
                hidden_weight=myconvnet.classifier[2].weight)
    with canvas1:
        canvas1.draw_plot(history1["train_loss"])
        canvas1.draw_plot(history1["test_acc"])
        canvas1.draw_image(history1["hidden_weight"])
    # 使用最好模型的参数
model.load_state_dict(best_model_wts)

训练过程可视乎如下所示：

大概只用了两分钟就训练完了

2.4 train.py总体代码

#--------------------------------0.库文件---------------------------------#
import torch
import torch.nn as nn
import torch.utils.data as Data
from torchvision import transforms
from torchvision.datasets import FashionMNIST
from sklearn.metrics import accuracy_score

import matplotlib.pyplot as plt
import time
import copy
import pandas as pd
import numpy as np
from tqdm import tqdm
import hiddenlayer as hl
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

#--------------------------------1.准备数据---------------------------------#
#数据集准备
train_data = FashionMNIST(
    root = "./data/FashionMNIST",
    train = True,
    transform = transforms.ToTensor(),
    download = True #如果没下载数据，就下载数据；如果已经下载好，就换为False
)
#载入数据加载器
train_loader = Data.DataLoader(
    dataset = train_data,
    batch_size = 64,
    shuffle = False,
    num_workers = 0,  #设置进程数为0 不然后面可能会报错（根据电脑不同而不同）
)
test_data = FashionMNIST(
    root = "./data/FashionMNIST",
    train = False,
    transform = transforms.ToTensor(),
    download = True #如果没下载数据，就下载数据；如果已经下载好，就换为False
)
test_data_x=test_data.data.type(torch.FloatTensor)/255
test_data_x=torch.unsqueeze(test_data_x,dim=1)  #之所以要增加一个维度是因为，本来是28X28，缺少通道数，我们一般都是要用通道数的
test_data_y=test_data.targets

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") #调用cpu或者cuda
print(device)

#--------------------------------2.网络搭建---------------------------------#
class MyConvNet(nn.Module):
    def __init__(self):
        super(MyConvNet, self).__init__()
        ## 定义第一个卷积层
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1,  ## 输入的feature map
                out_channels=16,  ## 输出通道数
                kernel_size=3,  ##卷积核尺寸
                stride=1,  ##卷积核步长
                padding=1,  # 进行填充
            ),  ## 卷积后： (1*28*28) ->(16*28*28) （经典311结构 不改变宽高 ）
            nn.ReLU(),  # 激活函数
            nn.AvgPool2d(
                kernel_size=2,  ## 平均值池化层,使用 2*2
                stride=2,  ## 池化步长为2
            ),  ## 池化后：(16*28*28)->(16*14*14)
        )
        ## 定义第二个卷积层
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 32, 3, 1, 0),  ## 卷积操作(16*14*14)->(32*12*12)  计算过程：（14+2*0-3）/1+1=12
            nn.ReLU(),  # 激活函数
            nn.AvgPool2d(2, 2)  ## 最大值池化操作(32*12*12)->(32*6*6)
        )
        ## 定义全连接层
        self.classifier = nn.Sequential(
            nn.Linear(32 * 6 * 6, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )

    ## 定义网络的向前传播路径
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)  # 展平多维的卷积图层，经过卷积操作进入全连接层都可能会使用此操作
        output = self.classifier(x)
        return output
Lenet = MyConvNet()
Lenet = Lenet.cuda()

#--------------------------------3.网络训练---------------------------------#

#参数配置
model = Lenet #网络模型
traindataloader =  train_loader #训练数据集
train_rate = 0.8 #训练集和测试集比例
num_epochs = 25 # 最大训练轮数
optimizer = torch.optim.Adam(Lenet.parameters(), lr=0.0003) #优化器
criterion = nn.CrossEntropyLoss()   # 损失函数
criterion = criterion.cuda()
history1 = hl.History()
canvas1 = hl.Canvas()


## 计算训练使用的batch数量
batch_num = len(traindataloader)
train_batch_num = round(batch_num * train_rate)

## 复制模型的参数
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
train_loss_all = []
train_acc_all = []
val_loss_all = []
val_acc_all = []
since = time.time()
for epoch in range(num_epochs):

    # 每个epoch有两个训练阶段
    train_loss = 0.0
    train_corrects = 0
    train_num = 0
    val_loss = 0.0
    val_corrects = 0
    val_num = 0
    loop = tqdm(enumerate(traindataloader), total=batch_num-1)
    for step,(b_x,b_y) in loop:  #对训练器的数据进行迭代计算（step这里要理解）
        b_x = b_x.cuda()
        b_y = b_y.cuda()
        if step < train_batch_num:
            model.train() ## 设置模型为训练模式
            output = model(b_x)  #计算batch上的输出
            output = output.cuda()
            pre_lab = torch.argmax(output,1)
            loss = criterion(output, b_y) #计算batch的误差
            optimizer.zero_grad() #优化器梯度优化为0
            loss.backward() #损失后向传播计算梯度
            optimizer.step() #使用梯度进行优化
            train_loss += loss.item() * b_x.size(0)
            train_corrects += torch.sum(pre_lab == b_y.data)
            train_num += b_x.size(0)

        else:
            model.eval() ## 设置模型为训练模式评估模式
            output = model(b_x)
            output = output.cuda()
            pre_lab = torch.argmax(output,1)
            loss = criterion(output, b_y)
            val_loss += loss.item() * b_x.size(0)
            val_corrects += torch.sum(pre_lab == b_y.data)
            val_num += b_x.size(0)
        loop.set_description(f'Epoch [{epoch}/{num_epochs - 1}]')
        loop.set_postfix(train_loss=train_loss / train_num)
        #动态显示的，每增加一个就除一下
    train_loss_all.append(train_loss / train_num)  # 四个数据存放到列表中，方便后面画图
    train_acc_all.append(train_corrects.double().item() / train_num)
    val_loss_all.append(val_loss / val_num)
    val_acc_all.append(val_corrects.double().item() / val_num)
    # 拷贝模型最高精度下的参数
    if  val_acc_all[-1] > best_acc:
        best_acc = val_acc_all[-1]
        best_model_wts = copy.deepcopy(model.state_dict())
    time_use = time.time() - since
    print("Train and val complete in {:.0f}m {:.0f}s".format(
        time_use // 60, time_use % 60))

    history1.log((epoch),
                train_loss=train_loss/train_num,
                test_acc=val_corrects/(train_num / 4),
                hidden_weight=Lenet.classifier[2].weight)
    with canvas1:
        canvas1.draw_plot(history1["train_loss"])
        canvas1.draw_plot(history1["test_acc"])
        canvas1.draw_image(history1["hidden_weight"])
    # 使用最好模型的参数


#torch.save(model.state_dict(), '1.path')
#训练完后，网络立马进入训练模式


Lenet.eval()
test_data_x=test_data_x.to(device)
output=Lenet(test_data_x) #向网络中输入测试集的图像
output=output.cpu()
pre_lab=torch.argmax(output,1)
acc=accuracy_score(test_data_y,pre_lab)
print("测试集上的准确率为{}".format(acc))

三、test.py代码模块讲解

3.1 第一种测试方法

那就是模型训练后，直接在代码后面加上这些语句，直接预测

Lenet.eval()
test_data_x=test_data_x.to(device)
output=Lenet(test_data_x) #向网络中输入测试集的图像
output=output.cpu()
pre_lab=torch.argmax(output,1)
acc=accuracy_score(test_data_y,pre_lab)
print("测试集上的准确率为{}".format(acc))

当让这里可能有点绕：
1）首先我们需要把测试集扔到显卡上去
2）测试数据进入显卡进行预测
3）预测的结果是cuda型的数据，我们需要转到cpu上才能进行后续操作，不然会报错（numpy仅能在CPU）
4) torch.argmax(output,1)

3.2 第二种测试方法（保存模型，调用）

首先在训练完成后，保存模型参数

torch.save(model.state_dict(), '1.path')

然后新建test.py进行测试：

#--------------------------------0.库文件---------------------------------#
import torch
import torch.nn as nn
import torch.utils.data as Data
from torchvision import transforms
from torchvision.datasets import FashionMNIST
from sklearn.metrics import accuracy_score

import matplotlib.pyplot as plt
import time
import copy
import pandas as pd
import numpy as np
from tqdm import tqdm
import hiddenlayer as hl
import torch.utils.data as Data
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
#数据集准备
test_data = FashionMNIST(
    root = "./data/FashionMNIST",
    transform = transforms.ToTensor(),
    download = True, #如果没下载数据，就下载数据；如果已经下载好，就换为False
    train=False
)
test_data_x=test_data.data.type(torch.FloatTensor)/255
test_data_x=torch.unsqueeze(test_data_x,dim=1)  #之所以要增加一个维度是因为，本来是28X28，缺少通道数，我们一般都是要用通道数的
test_data_y=test_data.targets

class MyConvNet(nn.Module):
    def __init__(self):
        super(MyConvNet, self).__init__()
        ## 定义第一个卷积层
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1,  ## 输入的feature map
                out_channels=16,  ## 输出通道数
                kernel_size=3,  ##卷积核尺寸
                stride=1,  ##卷积核步长
                padding=1,  # 进行填充
            ),  ## 卷积后： (1*28*28) ->(16*28*28) （经典311结构 不改变宽高 ）
            nn.ReLU(),  # 激活函数
            nn.AvgPool2d(
                kernel_size=2,  ## 平均值池化层,使用 2*2
                stride=2,  ## 池化步长为2
            ),  ## 池化后：(16*28*28)->(16*14*14)
        )
        ## 定义第二个卷积层
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 32, 3, 1, 0),  ## 卷积操作(16*14*14)->(32*12*12)  计算过程：（14+2*0-3）/1+1=12
            nn.ReLU(),  # 激活函数
            nn.AvgPool2d(2, 2)  ## 最大值池化操作(32*12*12)->(32*6*6)
        )
        ## 定义全连接层
        self.classifier = nn.Sequential(
            nn.Linear(32 * 6 * 6, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )

    ## 定义网络的向前传播路径
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0), -1)  # 展平多维的卷积图层，经过卷积操作进入全连接层都可能会使用此操作
        output = self.classifier(x)
        return output
myconvnet = MyConvNet()

myconvnet.load_state_dict(torch.load('1.path')) #加载模型参数

output = myconvnet(test_data_x)
pre_lab=torch.argmax(output,1)
acc=accuracy_score(test_data_y,pre_lab)
print("整个数据集上的精度：{}".format(acc))

最后结果：

这里最关键的是myconvnet.load_state_dict(torch.load(‘1.path’)) #加载模型参数