1. Johngo学长首页
  2. 技术点详细复盘专题
  3. 人工智能

卷积神经网络实战——表情识别（Pytorch）超详细理解，含Pyqt5的可操作界面

• 人工智能 • 阅读 72

卷积神经网络实战——表情识别（Pytorch） 这里作一下申明，之前对于神经网络的搭建解释的不够全面，这里进行补充，训练过程的代码可能太过繁琐不好理解，现在进行补充和修改，然后关于数据集用的是阿里天池公开课里面的表情识别数据集。 变化的部分会以红色字体标出

日志：

2022.6.20：添加exp_lr_scheduler.step()，更新学习率，不加这一步学习率不会更新。

前面六篇文章详细介绍了神经网络的基础，下面就一个简单的识别案例对前六章进行一个总结（可能有人对前六章在具体的网络中是干什么的有疑惑，下面进行具体代码分析）。

一、数据集

二、构建神经网络

首先我们要构建一个搭建网络的类，在类中主要实现网络的两部分，一部分是网络层的定义，另一部分将网络层连接起来构成网络

在之前的篇章神经网络基础篇中我们知道网络的构建需要以下：
（1）卷积层
（2）激活
（3）池化
（4）全连接
（5）Batch Normalization
当然不同的网络构造采用的方式不一样，有的只包含其中的几层。
接下来对要构造的神经网络进行一个说明：
我们要构造的是一个3层卷积，3层全连接的网络，其中包含激活，以及Batch Normalization。
下图是网络结构的整体流程图，后面的部分没有画图，直接写了尺寸大小：

卷积神经网络实战——表情识别（Pytorch）超详细理解，含Pyqt5的可操作界面
下面是构建网络层的代码（网络并不绝对，可以尝试不同的网络构建）
关于网络的python基础构建可以参考我的这篇文章（要想不借助别人的代码自己构建这一点很重要）
卷积神经网络构建的python基础-详细理解（Pytorch）

这里解释一下torch.nn，和 torch.nn.functional
前者可以自动提取可学习的参数，模型有可学习的参数可以采用（像卷积、全连接这些），后者进行简单的数学运算，适合像Relu这样的激活函数（激活函数无参数）直接运算。

import torch.nn as nn
import torch.nn.functional as F

class simpleconv(nn.Module):
    def __init__(self, nclass):
        super().__init__()

        self.conv1 = nn.Conv2d(3, 12, 3, 2)
        self.bn1 = nn.BatchNorm2d(12)

        self.conv2 = nn.Conv2d(12, 24, 3, 2)
        self.bn2 = nn.BatchNorm2d(24)

        self.conv3 = nn.Conv2d(24, 48, 3, 2)
        self.bn3 = nn.BatchNorm2d(48)

        self.fc1 = nn.Linear(48 * 5 * 5, 1200)
        self.fc2 = nn.Linear(1200, 128)
        self.fc3 = nn.Linear(128,nclass)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = F.relu(self.bn3(self.conv3(x)))
        x = x.view(-1 , 48*5*5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

if __name__ == '__main__':
    import torch
    x = torch.randn(128,3,48,48)
    model = simpleconv(4)
    y = model(x)

关于压缩维度的操作，可以参考我的这一篇博客神经网络中view()，torch.flatten(),torch.nn.Flatten()详解

更改：

将super(simpleconv, self). _init__()更换为super(). _init__()，目前大部分采用的python版本大都是python3,因此可以改用
【注】
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx

那么这里简单总结一下，网络构建所学的东西
（1）python的基础，要知道 类的创建，继承，_ _init__(), forward(), self 这些的具体原理，作用
（2）要知道神经网络结果，层与层之间是怎么操作的，激活，池化等都具有怎样的作用，以及他们尺寸通道的变化。
这些之前的文章都有讲解过。

三、网络训练（理解）

我们在训练卷积神经网络的时候，主要串联以下几点，就不会太过迷茫
（1）输入数据（处理过后），数据在网络中进行卷积等操作（网络的构建）
（2）卷积，全连接操作过后得到最终的预测值，并与真实标签值计算损失（损失函数）
（3）根据损失值计算梯度进而更新参数（优化器，即梯度下降的方式）
下面我将详细的描述各个训练部分
网络的训练主要包含以下部分：
1、定义分类网络初始化相关训练参数
2、数据输入网络前的准备（数据，真实标签）
3、模型准备
4、选用损失函数
5、选用的优化器，学习率
6、训练

1、分类网络的初始化相关训练参数

关于训练参数，我们想到的有如下几条：
（1）训练轮数：就是我们想要将整个数据集训练几遍。
（2）batchsize：就是我们想要一次性输入多少数据（根据电脑性能进行选择）。
（3）类别：要识别的类别数量。
（5）数据路径：这个路径是存放训练集和测试集的根目录。


batch_size = 128
nclass = 4
data_dir = './data'
num_epochs = 100

2、数据输入网络前的准备（数据，真实标签）

这一部分我们主要考虑什么样的数据才能输入到pytorch网络中进行训练呢？
（1）数据加载器：torchvision库中的datasets.ImageFolder，该库可以完成数据的读取和处理，有如下几个属性：
self.classes：一般来说是文件的名字
self.class_to_idx：类别对应的索引，从0开始
self.imgs：保存(img-path, class) tuple的列表

需要注意的是下面的transforms操作，transforms.Normalize只能对PIL、tensor格式进行操作，因此需要放在ToTensor之后，详情见我的另一篇博客
神经网络数据增强transforms的相关操作（持续更新）


data_transforms = transforms.Compose([transforms.Resize((64, 64)),
                            transforms.RandomSizedCrop(48),
                            transforms.RandomHorizontalFlip(),
                            transforms.ToTensor(),
                            transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])

image_datasets = datasets.ImageFolder(os.path.join(data_dir, 'train'), data_transforms)

print(image_datasets.classes)
print(image_datasets.class_to_idx)
print(image_datasets.imgs)

>> ['expression_none', 'mouth_open', 'pouting', 'smile']
>>{'expression_none': 0, 'mouth_open': 1, 'pouting': 2, 'smile': 3}
>>[('./data\\train\\expression_none\\1000none.jpg', 0)...]

（2）上一步可以得到图片数据和标签，但是我们输入网络需要的是批量的图片数据以及对应标签的，因此还需将图片及标签进行batchsize分批。

dataloaders = torch.utils.data.DataLoader(image_datasets,
                                          batch_size,
                                          shuffle=True,
                                          num_workers=0)

此时我们的数据就已经准备好了，可能有的小伙伴还不太理解，下面画一幅图进行理解。

卷积神经网络实战——表情识别（Pytorch）超详细理解，含Pyqt5的可操作界面
总的来说如上图，这只是我个人的理解，有不对的地方望指教。

3、模型准备

模型这里主要是是否使用GPU


if torch.cuda.is_available():
    device = "cuda"
else:
    device = "cpu"
model = simpleconv(nclass).to(device)

4、选用损失函数

一般来说分类损失采用交叉熵损失函数，关于交叉熵损失见我的这篇博客。
卷积神经网络的深入理解-优化目标（损失函数）篇

criterion = nn.CrossEntropyLoss()

5、选用的优化器，学习率

优化器即梯度更新的方式，详细见我的这篇博客
卷积神经网络的深入理解-最优化方法（梯度下降篇）（持续更新）
这里采用的是一个基本方法SGD，优化器和学习率主要是用于更新网络模型的参数，这里设置学习率每200轮变为原来的1/10。

optimizer_ft = optim.SGD(model.parameters(), lr=0.1, momentum=0.8)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=200, gamma=0.1)

6、训练和验证

将模型，数据，损失，优化器（主要是这四大部分）…传入训练函数
这里，去掉了Variable以及.data，理由是版本大于等于0.4.0的Pytorch将Variable与Tensor合并了，具体见我的这篇文章
Variable与Tensor合并后，关于训练、验证的相关变化

def train(train_loader,model,criterion,optimizer,device,len_train,batch_size):
   num_loss = 0.0
   num_corrects = 0.0
   model.train()
   for i ,(data,target) in enumerate(train_loader):
       data = data.to(device)
       target = target.to(device)

       optimizer.zero_grad()
       outputs = model(data)
       _, preds = torch.max(outputs, 1)
       loss = criterion(outputs,target)
       loss.backward()
       optimizer.step()
       num_corrects += torch.sum(preds==target).item()
       num_loss = num_loss + loss.item()

   train_loss = num_loss / (len_train//batch_size+1)
   train_acc = num_corrects / len_train
   return train_loss,train_acc

def val(val_loader,model,criterion,device,len_val,batch_size):
   num_loss = 0.0
   num_corrects = 0.0
   model.eval()
   with torch.no_grad():
       for i ,(data,target) in enumerate(val_loader):
           data = data.to(device)
           target = target.to(device)
           outputs = model(data)
           _, preds = torch.max(outputs.data, 1)
           loss = criterion(outputs, target)
           num_corrects += torch.sum(preds == target).item()
           num_loss = num_loss + loss.item()
   val_loss = num_loss / (len_val//batch_size+1)
   val_acc = num_corrects / len_val
   return val_loss,val_acc

四、网络训练测试总代码

原先代码进行了重写，同时也发现了原先的一些错误，
（1）打印的loss不太对，之前是直接计算总的loss然后除以数据量，但是这和batch有关，因为不管是多少个batch得到的loss都只是一个，所以做了如下操作：
num_loss / (len_train//batch_size+1)
（2）将训练与验证分开，更加方便理解
网络见二、构建神经网络

import torch

from net import simpleconv
from torchvision import transforms, datasets
import os

def train(train_loader,model,criterion,optimizer,device,len_train,batch_size):
    num_loss = 0.0
    num_corrects = 0.0
    model.train()
    for i ,(data,target) in enumerate(train_loader):
        data = data.to(device)
        target = target.to(device)

        optimizer.zero_grad()
        outputs = model(data)
        _, preds = torch.max(outputs, 1)
        loss = criterion(outputs,target)
        loss.backward()
        optimizer.step()
        num_corrects += torch.sum(preds==target).item()
        num_loss = num_loss + loss.item()

    train_loss = num_loss / (len_train//batch_size+1)
    train_acc = num_corrects / len_train
    return train_loss,train_acc

def val(val_loader,model,criterion,device,len_val,batch_size):
    num_loss = 0.0
    num_corrects = 0.0
    model.eval()
    with torch.no_grad():
        for i ,(data,target) in enumerate(val_loader):
            data = data.to(device)
            target = target.to(device)
            outputs = model(data)
            _, preds = torch.max(outputs.data, 1)
            loss = criterion(outputs, target)
            num_corrects += torch.sum(preds == target).item()
            num_loss = num_loss + loss.item()
    val_loss = num_loss / (len_val//batch_size+1)
    val_acc = num_corrects / len_val
    return val_loss,val_acc

batch_size = 128
nclass = 4
num_epochs = 300
data_dir = './data'

if torch.cuda.is_available():
    device = "cuda"
else:
    device = "cpu"
model = simpleconv(nclass).to(device)

train_transforms = transforms.Compose([
    transforms.Resize((64, 64)),
    transforms.RandomSizedCrop(48),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
val_transforms = transforms.Compose([
    transforms.Resize((64, 64)),
    transforms.CenterCrop(48),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])

train_datasets = datasets.ImageFolder(os.path.join(data_dir, 'train'), train_transforms)
val_datasets = datasets.ImageFolder(os.path.join(data_dir, 'val'), val_transforms)
len_train = len(train_datasets)
len_val = len(val_datasets)

train_loaders = torch.utils.data.DataLoader(
    dataset=train_datasets,
    batch_size=batch_size,
    shuffle=True,
    num_workers=0
)
val_loaders = torch.utils.data.DataLoader(
    dataset=val_datasets,
    batch_size=batch_size,
    shuffle=True,
    num_workers=0
)

import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
criterion = nn.CrossEntropyLoss()
optimizer_ft = optim.SGD(model.parameters(), lr=0.1, momentum=0.8)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=200, gamma=0.1)

from tensorboardX import SummaryWriter
import time
writer = SummaryWriter()
best_acc = 0.0
for epoch in range(num_epochs):
    start = time.time()
    train_loss,train_acc = train(train_loaders,model,criterion,optimizer_ft,device,len_train,batch_size)
    exp_lr_scheduler .step()
    val_loss,val_acc = val(val_loaders,model,criterion,device,len_val,batch_size)

    if val_acc > best_acc:
        best_acc = val_acc
        torch.save(model.state_dict(), './best.pth')
    writer.add_scalar('trainloss', train_loss, epoch)
    writer.add_scalar('trainacc', train_acc, epoch)
    writer.add_scalar('valloss', val_loss, epoch)
    writer.add_scalar('valacc', val_acc, epoch)
    end = time.time()
    print('[{}/{}]: train_loss:{:.3f}, train_acc:{:.3f},eval_loss:{:.3f}, eval_acc:{:.3f},  time:{:.3f}'.format(epoch+1,num_epochs,train_loss,train_acc,val_loss,val_acc,end-start))
writer.close()

下面是有关结果

卷积神经网络实战——表情识别（Pytorch）超详细理解，含Pyqt5的可操作界面

五、基于Pyqt5的Gui设计

这是界面的设计代码参考的
这篇博客

from PyQt5.QtWidgets import (QGridLayout, QPushButton, QLabel)
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
import sys
from PyQt5.QtCore import Qt

import torch
import torchvision.transforms as transforms
from PIL import Image
from net import simpleconv
import numpy as np

def predict(img):
    device = torch.device('cpu')
    data_tranform = transforms.Compose([transforms.Resize((48, 48)),
                                        transforms.ToTensor(),
                                        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])
    img = data_tranform(img)
    img = torch.unsqueeze(img, dim=0)

    model = simpleconv(4)
    model_weight_pth = './best.pth'
    model.load_state_dict(torch.load(model_weight_pth))
    model.to(device)
    model.eval()

    class_indict = {'0': '无表情',
                    '1': '张口',
                    '2': '撅嘴',
                    '3': '笑'}

    output = torch.squeeze(model(img))
    output = torch.softmax(output, dim=0)
    pro, preds = torch.max(output, 0)
    pro = pro.data.item()
    pred = preds.item()
    return class_indict[str(pred)],str(pro)

class Ui_example(QWidget):
    def __init__(self):
        super().__init__()
        self.window_pale = QPalette()

        self.layout = QGridLayout(self)
        self.label_image = QLabel(self)
        self.label_predict_result = QLabel('识别结果', self)
        self.label_predict_result_display = QLabel(self)
        self.label_predict_acc = QLabel('识别准确率', self)
        self.label_predict_acc_display = QLabel(self)

        self.button_search_image = QPushButton('选择图片',self)
        self.button_run = QPushButton('识别表情',self)

        self.setLayout(self.layout)
        self.initUi()

    def initUi(self):

        self.layout.addWidget(self.label_image,1,1,3,2)
        self.layout.addWidget(self.button_search_image,1,3,1,2)
        self.layout.addWidget(self.button_run,3,3,1,2)
        self.layout.addWidget(self.label_predict_result, 4, 3, 1, 1)
        self.layout.addWidget(self.label_predict_result_display, 4, 4, 1, 1)
        self.layout.addWidget(self.label_predict_acc, 5, 3, 1, 1)
        self.layout.addWidget(self.label_predict_acc_display, 5, 4, 1, 1)

        self.button_search_image.clicked.connect(self.openimage)
        self.button_run.clicked.connect(self.run)

        self.setGeometry(500,500,500,500)
        self.setWindowTitle('表情识别')

        self.window_pale.setBrush(QPalette.Background, QBrush(QPixmap("./win.jpg")))
        self.setPalette(self.window_pale)

        self.show()

    def openimage(self):
        global fname
        imgName, imgType = QFileDialog.getOpenFileName(self, "选择图片", "", "*.jpg;;*.png;;All Files(*)")
        jpg = QPixmap(imgName).scaled(self.label_image.width(), self.label_image.height(), Qt.KeepAspectRatio,Qt.SmoothTransformation)
        self.label_image.setPixmap(jpg)
        fname = imgName

    def run(self):
        global fname
        file_name = str(fname)
        img = Image.open(file_name)

        pred, pro = predict(img)
        self.label_predict_result_display.setText(pred)
        self.label_predict_acc_display.setText(pro)

if __name__ == '__main__':
    '''
    app.exec_()其实就是QApplication的方法，
    这个exec_()方法的作用是"进入程序的主循环直到exit()被调用"
    '''
    app = QApplication(sys.argv)
    ex = Ui_example()
    sys.exit(app.exec_())

下面是可视话界面的结果图：

卷积神经网络实战——表情识别（Pytorch）超详细理解，含Pyqt5的可操作界面
虽然文章只是简单的实现了一个网络，但是涉及的基础内容比较多，如有错误还望指教，最后希望获得一个免费的赞，谢谢。

Original: https://blog.csdn.net/hjkdh/article/details/123069024
Author: 燃烧吧哥们
Title: 卷积神经网络实战——表情识别（Pytorch）超详细理解，含Pyqt5的可操作界面

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/707486/

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
0

【自取】最近整理的，有需要可以领取学习：



Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言 刷题答案下载！

大家都在看

亲爱的 Coder【最近整理，可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球