基于卷积神经网络的人脸表情识别系统：ResNet50与MobileNet模型实现

基于卷积神经网络的人脸表情识别系统：ResNet50与MobileNet模型实现

引用

CSDN

1.

https://blog.csdn.net/lanbo_ai/article/details/144183867

基于卷积神经网络的人脸表情识别系统是一个完整的项目，使用PyTorch框架实现，包含ResNet50和MobileNet两个可选模型。项目包括代码、数据集、训练好的模型权重、模型训练记录、UI界面和各种模型指标图表等。GUI界面由PyQt5设计和实现，可以在PyCharm和Anaconda搭建的虚拟环境中执行。

一、简介

基于卷积神经网络的人脸表情识别系统是在PyTorch框架下实现的，这是一个完整的项目，包括代码，数据集，训练好的模型权重，模型训练记录，UI界面和各种模型指标图表等。该项目有两个可选模型：ResNet50和MobileNet，两个模型都在项目中；GUI界面由PyQt5设计和实现。此项目的两个模型可做对比分析，增加工作量。该项目是在PyCharm和Anaconda搭建的虚拟环境执行。

二、项目介绍

1. 项目结构

该项目可以使用已经训练好的模型权重，也可以自己重新训练，自己训练也比较简单。以训练ResNet50模型为例：

• 第一步：修改model_resnet50.py的数据集路径，模型名称、模型训练的轮数
• 第二步：模型训练和验证，即直接运行model_resnet50.py文件
• 第三步：使用模型，即运行gui_chinese.py文件即可通过GUI界面来展示模型效果

2. 数据结构

部分数据展示：

3. GUI界面（技术栈：PyQt5+Python+OpenCV）

1）GUI初始界面

2）GUI分类、识别界面

4. 模型训练和验证的一些指标及效果

1）模型训练和验证的准确率曲线，损失曲线

2）热力图

3）准确率、精确率、召回率、F1值

4）模型训练和验证记录

三、代码

由于篇幅有限，只展示核心代码

def main(self, epochs):
    # 记录训练过程
    log_file_name = './results/resnet50训练和验证过程.txt'
    # 记录正常的 print 信息
    sys.stdout = Logger(log_file_name)
 
    print("using {} device.".format(self.device))
    # 开始训练，记录开始时间
    begin_time = time()
    # 加载数据
    train_loader, validate_loader, class_names, train_num, val_num = self.data_load()
    print("class_names: ", class_names)
    train_steps = len(train_loader)
    val_steps = len(validate_loader)
    # 加载模型
    model = self.model_load()  # 创建模型
    # 修改全连接层的输出维度
    in_channel = model.fc.in_features
    model.fc = nn.Linear(in_channel, len(class_names))
 
    # 模型结构可视化
    x = torch.randn(16, 3, 224, 224)  # 随机生成一个输入
    # 模型结构保存路径
    model_visual_path = 'results/resnet50_visual.onnx'
    # 将 pytorch 模型以 onnx 格式导出并保存
    torch.onnx.export(model, x, model_visual_path)  
    # netron.start(model_visual_path)  # 浏览器会自动打开网络结构
 
 
    # 将模型放入GPU中
    model.to(self.device)
    # 定义损失函数
    loss_function = nn.CrossEntropyLoss()
    # 定义优化器
    params = [p for p in model.parameters() if p.requires_grad]
    optimizer = optim.Adam(params=params, lr=0.0001)
 
    train_loss_history, train_acc_history = [], []
    test_loss_history, test_acc_history = [], []
    best_acc = 0.0
 
    for epoch in range(0, epochs):
        # 下面是模型训练
        model.train()
        running_loss = 0.0
        train_acc = 0.0
        train_bar = tqdm(train_loader, file=sys.stdout)
        # 进来一个batch的数据，计算一次梯度，更新一次网络
        for step, data in enumerate(train_bar):
            # 获取图像及对应的真实标签
            images, labels = data
            # 清空过往梯度
            optimizer.zero_grad()
            # 得到预测的标签
            outputs = model(images.to(self.device))
            # 计算损失
            train_loss = loss_function(outputs, labels.to(self.device))
            # 反向传播，计算当前梯度
            train_loss.backward()
            # 根据梯度更新网络参数
            optimizer.step()  
 
            # 累加损失
            running_loss += train_loss.item()
            # 每行最大值的索引
            predict_y = torch.max(outputs, dim=1)[1]  
            # torch.eq()进行逐元素的比较，若相同位置的两个元素相同，则返回True；若不同，返回False
            train_acc += torch.eq(predict_y, labels.to(self.device)).sum().item()
            # 更新进度条
            train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
                                                                     epochs,
                                                                     train_loss)
        # 下面是模型验证
        # 不启用 BatchNormalization 和 Dropout，保证BN和dropout不发生变化
        model.eval()
        # accumulate accurate number / epoch
        val_acc = 0.0  
        testing_loss = 0.0
        # 张量的计算过程中无需计算梯度
        with torch.no_grad():  
            val_bar = tqdm(validate_loader, file=sys.stdout)
            for val_data in val_bar:
                # 获取图像及对应的真实标签
                val_images, val_labels = val_data
                # 得到预测的标签
                outputs = model(val_images.to(self.device))
                # 计算损失
                val_loss = loss_function(outputs, val_labels.to(self.device))  
                testing_loss += val_loss.item()
                # 每行最大值的索引
                predict_y = torch.max(outputs, dim=1)[1]  
                # torch.eq()进行逐元素的比较，若相同位置的两个元素相同，则返回True；若不同，返回False
                val_acc += torch.eq(predict_y, val_labels.to(self.device)).sum().item()
 
        train_loss = running_loss / train_steps
        train_accurate = train_acc / train_num
        test_loss = testing_loss / val_steps
        val_accurate = val_acc / val_num
 
        train_loss_history.append(train_loss)
        train_acc_history.append(train_accurate)
        test_loss_history.append(test_loss)
        test_acc_history.append(val_accurate)
 
        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
              (epoch + 1, train_loss, val_accurate))
        # 保存最佳模型
        if val_accurate > best_acc:
            best_acc = val_accurate
            torch.save(model.state_dict(), self.model_name)
 
    # 记录结束时间
    end_time = time()
    run_time = end_time - begin_time
    print('该循环程序运行时间：', run_time, "s")
    # 绘制模型训练过程图
    self.show_loss_acc(train_loss_history, train_acc_history,
                       test_loss_history, test_acc_history)
    # 画热力图
    test_real_labels, test_pre_labels = self.heatmaps(model, validate_loader, class_names)
    # 计算混淆矩阵
    self.calculate_confusion_matrix(test_real_labels, test_pre_labels, class_names)  

四、总结

以上即为整个项目的介绍，整个项目主要包括以下内容：完整的程序代码文件、训练好的模型、数据集、GUI界面和各种模型指标图表等。