毕设项目分享深度学习口罩佩戴检测系统（源码+论文）

最新推荐文章于 2025-04-30 00:44:17 发布

bee_dc

最新推荐文章于 2025-04-30 00:44:17 发布

阅读量814

点赞数 27

文章标签：毕业设计毕设大数据

本文链接：https://blog.youkuaiyun.com/bee_dc/article/details/145661167

版权

文章目录

0 前言
1 项目运行效果
🚩 2 口罩佩戴算法实现
3 最后

0 前言

🔥这两年开始毕业设计和毕业答辩的要求和难度不断提升，传统的毕设题目缺少创新和亮点，往往达不到毕业答辩的要求，这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。

为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的是

🚩 毕业设计深度学习口罩佩戴检测系统（源码+论文）

🥇学长这里给一个题目综合评分(每项满分5分)

难度系数：3分
工作量：3分
创新点：4分

🧿 项目分享:见文末!

1 项目运行效果

在这里插入图片描述

视频效果：

毕业设计深度学习口罩佩戴检测

🚩 2 口罩佩戴算法实现

2.1 YOLO 模型概览

YOLO 的缩写是 You only look once。YOLO 模型可以直接根据图片输出包含对象的区域与区域对应的分类，一步到位，不像 RCNN 系列的模型需要先计算包含对象的区域，再根据区域判断对应的分类，YOLO 模型的速度比 RCNN 系列的模型要快很多。

YOLO 模型的结构如下：

在这里插入图片描述
是不是觉得有点熟悉？看上去就像 Faster-RCNN 的区域生成网络 (RPN) 啊。的确，YOLO 模型原理上就是寻找区域的同时判断区域包含的对象分类，YOLO 模型与区域生成网络有以下的不同：

YOLO 模型会输出各个区域是否包含对象中心，而不是包含对象的一部分
YOLO 模型会同时输出对象分类
YOLO 模型输出的区域偏移会根据对象中心点计算，具体算法在下面说明

YOLO 模型与 Faster-RCNN 的区域生成网络最大的不同是会判断各个区域是否包含对象中心，如下图中狗脸覆盖了四个区域，但只有左下角的区域包含了狗脸的中心，YOLO 模型应该只判断这个区域包含对象。

在这里插入图片描述

当然，如果对象中心非常接近区域的边界，那么判断起来将会很困难，YOLO 模型在训练的时候会忽略对象重叠率高于一定水平的区域，具体可以参考后面给出的代码。

YOLO 模型会针对各个区域输出以下的结果，这里假设有三个分类：

是否包含对象中心 (是为 1, 否为 0)
区域偏移 x
区域偏移 y
区域偏移 w
区域偏移 h
分类 1 的可能性 (0 ~ 1)
分类 2 的可能性 (0 ~ 1)
分类 3 的可能性 (0 ~ 1)

输出结果的维度是批次大小, 区域数量, 5 + 分类数量。

区域偏移用于调整输出的区域范围，例如上图中狗脸的中心点大约在区域的右上角，如果把区域左上角看作 (0, 0)，右下角看作 (1, 1)，那么狗脸中心点应该在 (0.95, 0.1) 的位置，而狗脸大小相对于区域长宽大概是 (1.3, 1.5) 倍，生成训练数据的时候会根据这 4 个值计算区域偏移，具体计算代码在下面给出。

在这里插入图片描述

看到这里你可能会想，YOLO 模型看起来很简单啊，我可以丢掉操蛋的 Faster-RCNN 模型了🤢。

不，没那么简单，以上介绍的只是 YOLOv1 模型，YOLOv1 模型的精度非常低，后面为了改进识别精度还发展出 YOLOv2, YOLOv3, YOLOv4, YOLOv5 模型😮，学长下面会给出 YOLOv3 模型的实现。Y

OLOv4 和 YOLOv5 模型主要改进了提取特征用的 CNN 模型 (也称骨干网络 Backbone Network)，原始的 YOLO 模型使用了 C 语言编写的 Darknet 作为骨干网络，而这篇使用 Resnet 作为骨干网络，所以今天学长只介绍到 YOLOv3。

2.2 YOLOv3

YOLOv3 引入了多尺度检测机制 (Multi-Scale Detection)，这个机制可以说是 YOLO 模型的精华，引入这个机制之前 YOLO 模型的精度很不理想，而引入之后 YOLO 模型达到了接近 Faster-RCNN 的精度，并且速度还是比 Faster-RCNN 要快。

多尺度检测机制简单的来说就是按不同的尺度划分区域，然后再检测这些不同大小的区域是否包含对象，检测的时候大区域的特征会混合到小区域中，使得小区域判断时拥有一定程度的上下文信息。

在这里插入图片描述

2.3 YOLO 口罩佩戴检测实现

接下来学长带大家用 YOLO 模型把没带口罩的家伙抓出来吧。

数据集

在这里插入图片描述
学长的这个数据集包含了 8535 张图片 (部分图片没有使用)，其中各个分类的数量如下：

戴口罩的区域 (with_mask): 3232 个
不戴口罩的区域 (without_mask): 717 个
带了口罩但姿势不正确的区域 (mask_weared_incorrect): 123 个

因为带了口罩但姿势不正确的样本数量很少，所以都归到戴口罩里面去😠。

2.4 实现代码

使用这个数据集训练，并且训练成功以后使用模型识别图片或视频的完整代码如下：

import os
import sys
import torch
import gzip
import itertools
import random
import numpy
import math
import pandas
import json
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
from torch import nn
from matplotlib import pyplot
from collections import defaultdict
from collections import deque
import xml.etree.cElementTree as ET

# 缩放图片的大小
IMAGE_SIZE = (256, 192)
# 训练使用的数据集路径
DATASET_1_IMAGE_DIR = "./archive/images"
DATASET_1_ANNOTATION_DIR = "./archive/annotations"
DATASET_2_IMAGE_DIR = "./784145_1347673_bundle_archive/train/image_data"
DATASET_2_BOX_CSV_PATH = "./784145_1347673_bundle_archive/train/bbox_train.csv"
# 分类列表
# YOLO 原则上不需要 other 分类，但实测中添加这个分类有助于提升标签分类的精确度
CLASSES = [ "other", "with_mask", "without_mask" ]
CLASSES_MAPPING = {
    c: index for index, c in enumerate(CLASSES) }
# 判断是否存在对象使用的区域重叠率的阈值 (另外要求对象中心在区域内)
IOU_POSITIVE_THRESHOLD = 0.30
IOU_NEGATIVE_THRESHOLD = 0.30

# 用于启用 GPU 支持
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

class BasicBlock(nn.Module):
    """ResNet 使用的基础块"""
    expansion = 1 # 定义这个块的实际出通道是 channels_out 的几倍，这里的实现固定是一倍
    def __init__(self, channels_in, channels_out, stride):
        super().__init__()
        # 生成 3x3 的卷积层
        # 处理间隔 stride = 1 时，输出的长宽会等于输入的长宽，例如 (32-3+2)//1+1 == 32
        # 处理间隔 stride = 2 时，输出的长宽会等于输入的长宽的一半，例如 (32-3+2)//2+1 == 16
        # 此外 resnet 的 3x3 卷积层不使用偏移值 bias
        self.conv1 = nn.Sequential(
            nn.Conv2d(channels_in, channels_out, kernel_size=3, stride=stride, padding=1, bias=False),
            nn.BatchNorm2d(channels_out))
        # 再定义一个让输出和输入维度相同的 3x3 卷积层
        self.conv2 = nn.Sequential(
            nn.Conv2d(channels_out, channels_out, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(channels_out))
        # 让原始输入和输出相加的时候，需要维度一致，如果维度不一致则需要整合
        self.identity = nn.Sequential()
        if stride != 1 or channels_in != channels_out * self.expansion:
            self.identity = nn.Sequential(
                nn.Conv2d(channels_in, channels_out * self.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(channels_out * self.expansion))

    def forward(self, x):
        # x => conv1 => relu => conv2 => + => relu
        # |                              ^
        # |==============================|
        tmp = self.conv1(x)
        tmp = nn.functional.relu(tmp, inplace=True)
        tmp = self.conv2(tmp)
        tmp += self.identity(x)
        y = nn.functional.relu(tmp, inplace=True)
        return y

class MyModel(nn.Module):
    """YOLO (基于 ResNet 的变种)"""
    Anchors = None # 锚点列表，包含 锚点数量 * 形状数量 的范围
    AnchorSpans = (16, 32, 64) # 尺度列表，值为锚点之间的距离
    AnchorAspects = ((1, 1), (1.5, 1.5)) # 锚点对应区域的长宽比例列表
    AnchorOutputs = 1 + 4 + len(CLASSES) # 每个锚点范围对应的输出数量，是否对象中心 (1) + 区域偏移 (4) + 分类数量
    AnchorTotalOutputs = AnchorOutputs * len(AnchorAspects) # 每个锚点对应的输出数量
    ObjScoreThreshold = 0.9 # 认为是对象中心所需要的最小分数
    IOUMergeThreshold = 0.3 # 判断是否应该合并重叠区域的重叠率阈值

    def __init__(self):
        super().__init__()
        # 抽取图片特征的 ResNet
        # 因为锚点距离有三个，这里最后会输出各个锚点距离对应的特征
        self.previous_channels_out = 4
        self.resnet_models = nn.ModuleList([
            nn.Sequential(
                nn.Conv2d(3, self.previous_channels_out, kernel_size=3, stride=1, padding=1, bias=False),
                nn.BatchNorm2d(self.previous_channels_out),
                nn.ReLU(inplace=True),
                self._make_layer(BasicBlock, channels_out=16, num_blocks=2, stride=1),
                self._make_layer(BasicBlock, channels_out=32, num_blocks=2, stride=2),
                self._make_layer(BasicBlock, channels_out=64, num_blocks=2, stride=2),
                self._make_layer(BasicBlock, channels_out=128, num_blocks=2, stride=2),
                self._make_layer(BasicBlock, channels_out=256, num_blocks=2, stride=2)),
            self._make_layer(BasicBlock, channels_out=256, num_blocks=2, stride=2),
            self._make_layer(BasicBlock, channels_out=256, num_blocks=2, stride=2)
        ])
        # 根据各个锚点距离对应的特征预测输出的卷积层
        # 大的锚点距离抽取的特征会合并到小的锚点距离抽取的特征
        # 这里的三个子模型意义分别是:
        # - 计算用于合并的特征
        # - 放大特征
        # - 计算最终的预测输出
        self.yolo_detectors = nn.ModuleList([
            nn.ModuleList([nn.Sequential(
                nn.Conv2d(256 if index == 0 else 512, 256, kernel_size=1, stride=1, padding=0, bias=True),
                nn.ReLU(inplace=True),
                nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1, bias=True),
                nn.ReLU(inplace=True),
                nn.Conv2d(512, 256, kernel_size=1, stride=1, padding=0, bias=True),
                nn.ReLU(inplace=True)),
            nn.Upsample(scale_factor=2, mode="nearest"),
            nn.Sequential(
                nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1, bias=True),
                nn.ReLU(inplace=True),
                nn.Conv2d(512, 256, kernel_size=3, stride=1, padding=1, bias=True),
                nn.ReLU(inplace=True),
                nn.Conv2d(256, MyModel.AnchorTotalOutputs, kernel_size=1, stride=1, padding=0, bias=True))])
            for index in range(len(self.resnet_models))
        ])
        # 处理结果范围的函数
        self.sigmoid = nn.Sigmoid()

    def _make_layer(self, block_type, channels_out, num_blocks, stride):
        """创建 resnet 使用的层"""
        blocks = []
        # 添加第一个块
        blocks.append(block_type(self.previous_channels_out, channels_out, stride))
        self.previous_channels_out = channels_out * block_type.expansion
        # 添加剩余的块，剩余的块固定处理间隔为 1，不会改变长宽
        for _ in range(num_blocks-1):
            blocks.append(block_type(self.previous_channels_out, self.previous_channels_out, 1))
            self.previous_channels_out *= block_type.expansion
        return nn.Sequential(*blocks)

    @staticmethod
    def _generate_anchors():
        """根据锚点和形状生成锚点范围列表"""
        w, h = IMAGE_SIZE
        anchors = []
        for span in MyModel.AnchorSpans:
            for x in range(0, w, span):
                for y in range(0, h, span):
                    xcenter, ycenter = x + span / 2, y + span / 2
                    for ratio in MyModel.AnchorAspects:
                        ww = span