吸烟检测 yolov5开源推荐

男娘i 2022-09-03 04:24 380阅读 0赞

## 【项目实战】YOLOV5 +实时吸烟目标检测+手把手教学+开源全部 ##

标签： [实战项目][Link 1]  [【数据共享】][Link 2]  [目标检测精读][Link 3]  [人工智能][Link 4]  [深度学习][Link 5]  [pytorch][]  [神经网络][Link 6]  [机器学习][Link 7]

注意，数据集下载链接已经失效，可以联系我，咨询新的地址。

百度盘里存了升级版。

### 文章目录 ###

*   *   *  [本原创项目长期更新，旨在完成校园异常行为实时精检测，做到集成+N次开发+优化（不止局限于调包）为止，近期将不断更新以下模型+数据+标注文件+教程。关注博主，Star 一下github，一起开始美妙的目标检测之路吧~~][N_Star _github]
     *  [一、项目展示][Link 8]
     *  [二、项目资源共享][Link 9]
        
         *   *  [1：训练图片：香烟图片+吸烟手势+烟雾][1]
     *  [三、实践教学][Link 10]
        
         *  [3.1环境配置][3.1]
         *  [3.2数据标注与预处理][3.2]
            
             *  [3.2.1附上自己的Lablimg简易教学：][3.2.1_Lablimg]
             *  [3.2.2 几个自己写的脚本用于转换数据集与训练前准备][3.2.2]
             *  [3.2.3 切分训练集与测试集：][3.2.3]
     *  [四、开始训练][Link 11]
        
         *  [4.1：开始训练][4.1]
         *  [4.2：训练过程][4.2]
         *  [4.3：训练优化][4.3]
         *  [4.4 训练参数：][4.4]
     *  [五、实时检测][Link 12]
        
         *  [运行detect.py即可][detect.py]
     *  [六、YOLO系列可视化对比][YOLO]
     *  [七、写在后面][Link 13]
        
         *  [全部链接传送门][Link 14]

首先：附上Github传送门：[https://github.com/CVUsers/Smoke-Detect-by-YoloV5/tree/master][https_github.com_CVUsers_Smoke-Detect-by-YoloV5_tree_master]，然后根据本文手把手配置环境+训练自己数据，或者使用我训练好的模型进行使用。用yolov5s训练好的已经放在了里面，用大模型训练的由于大小原因，需要的话可以戳最下方微信私聊我，免费。

## 一、项目展示 ##

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fwpaKe70-1594698054779)(D:\\CSDN\\pic\\吸烟检测\\0.png)\]][img-fwpaKe70-1594698054779_D_CSDN_pic_0.png]

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hUenvq7F-1594698054781)(D:\\CSDN\\pic\\吸烟检测\\0.5.png)\]][img-hUenvq7F-1594698054781_D_CSDN_pic_0.5.png]

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JEV7mZfK-1594698054784)(D:\\CSDN\\pic\\吸烟检测\\1.png)\]][img-JEV7mZfK-1594698054784_D_CSDN_pic_1.png]

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Mgb0QwvX-1594698054788)(D:\\CSDN\\pic\\吸烟检测\\1594683546122.png)\]][img-Mgb0QwvX-1594698054788_D_CSDN_pic_1594683546122.png]

左图为原图，右图为推理后的图片，以图片方式展示，视频流和实时流也能达到这个效果，由于视频大小原因，暂不上传，感兴趣的朋友细细往下看，并点个关注哟！

测试配置：GTX1050ti，不堪入目，但是实验效果还不错，再这样弱的配置下，使用YOLOv5s，YOlov5m等皆能达到30fps。

## 二、项目资源共享 ##

1：训练图片：香烟图片+吸烟手势+烟雾

**香烟图片**：自己编写爬虫爬了1w张，筛选下来有近1000张可用，以及其他途径获取到的，**总共暂时5k张**，未来会越来越多，后续需要的可以私聊我，现在先放出5k张图片，**另外加上自己辛辛苦苦使用Labelimg标注的几千张图片的XML文件也一并送上**，香烟图片质量可查传送门：链接：https://pan.baidu.com/s/1t8u94x51TO7pLciU8AoaiQ  
提取码：n2wr：如下图

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eruZx8Ri-1594698054790)(D:\\CSDN\\pic\\吸烟检测\\3.png)\]][img-eruZx8Ri-1594698054790_D_CSDN_pic_3.png]

**吸烟手势图片**：

![在这里插入图片描述][22e0d6aae6da125225303fcaba16f14b.png]

**火灾+烟雾数据集：**

这个数据集我已经有了10万左右数据，部分是朋友的，不知能不能开源，我可以送上自己收集的几万数据集。传送门：

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GFsXlbwe-1594698054792)(D:\\CSDN\\pic\\吸烟检测\\1594687477452.png)\]][img-GFsXlbwe-1594698054792_D_CSDN_pic_1594687477452.png]

**项目框架：YOLOV5——Pytorch实现**

送上作者源码传送门：https://github.com/ultralytics/yolov5，当然也可以直接使用我的：https://github.com/CVUsers/Smoke-Detect-by-YoloV5/tree/master。

**标注工具：Labelimg**

附上Windows工具：在我上面的github里面有哟：下载好放置桌面比较方便。

## 三、实践教学 ##

### 3.1环境配置 ###

本例以使用YOLov5作者源码步骤：

Cython
    numpy==1.17
    opencv-python
    torch>=1.4
    matplotlib
    pillow
    tensorboard
    PyYAML>=5.3
    torchvision
    scipy
    tqdm

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11

我的是torch 1.5 gpu版

在git clone下作者的v5源码后： 目录切至requirement.txt 下然后

pip install -U -r requirements.txt

*  1

**如果需要使用混合精度模型来做训练：安装Apex**

git clone https://github.com/NVIDIA/apex && cd apex 然后切换至目录下
    pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" . --user && cd .. && rm -rf apex

*  1
 *  2

### 3.2数据标注与预处理 ###

以吸烟数据集为例：

在百度网盘下载好我的数据集和XML

若是想重新训练的话

3.2.1附上自己的LABLIMG简易教学：

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ctuoGjSX-1594698054796)(D:\\CSDN\\pic\\吸烟检测\\7.png)\]][img-ctuoGjSX-1594698054796_D_CSDN_pic_7.png]

标注好会生成XML文件：XML里面包含了四个点坐标和图片的名字与size。

然后在data下新建几个文件夹：

![在这里插入图片描述][7d0ffac99f310fd0111cb97e14217421.png]

**将我们的XML文件放至Annotations**

**将我们的图片放到images**

**在ImageSets中新建Main 和test.txt 和train.txt**

**再新建labels存放接下来生成的标签**

3.2.2 几个自己写的脚本用于转换数据集与训练前准备

第一个：XML文件转label.txt文件

首先写个os操作读一下data/images中图片：这个几行搞定，要注意要写成我这样的哟 （不用生成.jpg）可以通过split(’.’)再复制到ImageXML中

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TUcelHlM-1594698054806)(D:\\CSDN\\pic\\吸烟检测\\10.png)\]][img-TUcelHlM-1594698054806_D_CSDN_pic_10.png]

**然后运行voc\_label.py脚本：**

# 坐标xml转txt
    import os
    import xml.etree.ElementTree as ET
    
    classes = ["smoke"]  # 输入名称，必须与xml标注名称一致
    
    def convert(size, box):
        print(size, box)
        dw = 1. / size[0]
        dh = 1. / size[1]
        x = (box[0] + box[1]) / 2.0
        y = (box[2] + box[3]) / 2.0
        w = box[1] - box[0]
        h = box[3] - box[2]
        x = x * dw
        w = w * dw
        y = y * dh
        h = h * dh
        return (x, y, w, h)
    
    
    def convert_annotation(image_id):
        print(image_id)
        in_file = open(r'./data/Annotations/%s.xml' % (image_id), 'rb')  # 读取xml文件路径
    
        out_file = open('./data/labels/%s.txt' % (image_id), 'w')  # 需要保存的txt格式文件路径
        tree = ET.parse(in_file)
        root = tree.getroot()
        size = root.find('size')
        w = int(size.find('width').text)
        h = int(size.find('height').text)
    
        for obj in root.iter('object'):
            cls = obj.find('name').text
            if cls not in classes:  # 检索xml中的名称
                continue
            cls_id = classes.index(cls)
            xmlbox = obj.find('bndbox')
            b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
                 float(xmlbox.find('ymax').text))
            bb = convert((w, h), b)
            out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
    
    
    image_ids_train = open('./ImageXML.txt').read().strip().split()  # 读取xml文件名索引
    
    for image_id in image_ids_train:
        print(image_id)
        convert_annotation(image_id)

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51

需要注意，若是有中文路径的话，请这样读文件：

open(r'./data/Annotations/%s.xml' % (image_id), 'rb')

*  1

接下来就会在data/labels中看到：所有的txt标签

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YGacBoN7-1594698054808)(C:\\Users\\acer\\AppData\\Roaming\\Typora\\typora-user-images\\1594690060070.png)\]][img-YGacBoN7-1594698054808_C_Users_acer_AppData_Roaming_Typora_typora-user-images_1594690060070.png]

每个txt文本会生成一共5个数字：第一个是整形的数，表示类别:0代表第一类，以此类推，后面四个数字是坐标通过归一化后的表示。

3.2.3 切分训练集与测试集：

执行train\_test\_split.py

import os
    import random
    
    trainval_percent = 1  # 可自行进行调节
    train_percent = 1
    xmlfilepath = './data/Annotations'
    txtsavepath = './data/ImageSets\Main'
    total_xml = os.listdir(xmlfilepath)
    
    num = len(total_xml)
    list = range(num)
    tv = int(num * trainval_percent)
    tr = int(tv * train_percent)
    trainval = random.sample(list, tv)
    train = random.sample(trainval, tr)
    
    # ftrainval = open('ImageSets/Main/trainval.txt', 'w')
    ftest = open('./data/ImageSets/Main/test.txt', 'w')
    ftrain = open('./data/ImageSets/Main/train.txt', 'w')
    # fval = open('ImageSets/Main/val.txt', 'w')
    
    for i in list:
        name = total_xml[i][:-4] + '\n'
        if i in trainval:
            # ftrainval.write(name)
            if i in train:
                ftest.write(name)
            # else:
            # fval.write(name)
        else:
            ftrain.write(name)
    
    # ftrainval.close()
    ftrain.close()
    # fval.close()
    ftest.close()

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37

其中trainval\_percent = 1表示验证集比例，1代表1：9 如果有5000张图片，就会切割成4500张训练集，和500张验证集。

trainval_percent = 1  # 可自行进行调节

*  1

**运行path\_trans补全路径，并写入train.txt**

import xml.etree.ElementTree as ET
    import pickle
    import os
    from os import listdir, getcwd
    from os.path import join
    
    sets = ['train', 'test']
    
    classes = ['smoke']  # 自己训练的类别
    
    
    def convert(size, box):
        dw = 1. / size[0]
        dh = 1. / size[1]
        x = (box[0] + box[1]) / 2.0
        y = (box[2] + box[3]) / 2.0
        w = box[1] - box[0]
        h = box[3] - box[2]
        x = x * dw
        w = w * dw
        y = y * dh
        h = h * dh
        return (x, y, w, h)
    
    
    def convert_annotation(image_id):
        in_file = open('data/Annotations/%s.xml' % (image_id), 'rb')
        out_file = open('data/labels/%s.txt' % (image_id), 'w')
        tree = ET.parse(in_file)
        root = tree.getroot()
        size = root.find('size')
        w = int(size.find('width').text)
        h = int(size.find('height').text)
    
        for obj in root.iter('object'):
            difficult = obj.find('difficult').text
            cls = obj.find('name').text
            if cls not in classes or int(difficult) == 1:
                continue
            cls_id = classes.index(cls)
            xmlbox = obj.find('bndbox')
            b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
                 float(xmlbox.find('ymax').text))
            bb = convert((w, h), b)
            out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
    
    
    wd = getcwd()
    for image_set in sets:
        if not os.path.exists('data/labels/'):
            os.makedirs('data/labels/')
        image_ids = open('data/ImageSets/Main/%s.txt' % (image_set)).read().strip().split()
        list_file = open('data/%s.txt' % (image_set), 'w')
        for image_id in image_ids:
            list_file.write('data/images/%s.jpg\n' % (image_id))
            convert_annotation(image_id)
        list_file.close()

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57

接下来编写yaml文本：  
见smoke.yaml

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SNIdxzTn-1594698054813)(D:\\CSDN\\pic\\吸烟检测\\1594691005832.png)\]][img-SNIdxzTn-1594698054813_D_CSDN_pic_1594691005832.png]

**将我们上一步生成的train.txt 和test.txt 补全路径后的这两个txt路径写入到yaml中，然后nc：修改为自己类别的数量，以及names【‘smoke’】**

## 四、开始训练 ##

### 4.1：开始训练 ###

在上面我们做好数据预处理后，就可以开始训练了，上面的一些处理步骤，每个人都可能不同，不过大体上思路是一致的。

接下来我们可以进行预训练，下载官方的预训练模型：  
yolov5s yolov5m yolov5l yolov5x来 我在我的github中方了yolov5s，比较小，只有25mb，专门为移动端考虑了，真好。

当然也可以不使用预训练模型，使用与否，在总时间上是差不多的，不过

**为什么要使用预训练模型？**

作者已尽其所能设计了基准模型。我们可以在自己的数据集上使用预训练模型，而不是从头构建模型来解决类似的自然语言处理问题。

尽管仍然需要进行一些微调，但它已经为我们节省了大量的时间：**通常是每个损失下降更快和计算资源节省**。

**加快梯度下降的收敛速度**

**更有可能获得一个低模型误差，或者低泛化误差的模型**

**降低因未初始化或初始化不当导致的梯度消失或者梯度爆炸问题。此情况会导致模型训练速度变慢，崩溃，直至失败。**

**其中随机初始化，可以打破对称性，从而保证不同的隐藏单元可以学习到不同的东西**

接下来开始训练：

python train.py --data data/smoke.yaml --cfg models/yolov5s.yaml --weights weights/yolov5s.pt --batch-size 10 --epochs 100

*  1
 *  2

解释一下：

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vuVhuRvJ-1594698054817)(D:\\CSDN\\pic\\吸烟检测\\1594693318445.png)\]][img-vuVhuRvJ-1594698054817_D_CSDN_pic_1594693318445.png]

我们–data data/smoke.yaml 中就是在smoke.yaml中撰写的训练代码路径和类别等data，通过这个获取训练的图片和label标签等。

然后-cfg models/yolov5s.yaml 和 --weights weights/yolov5s.pt是获取配置和预训练模型权重

batch-size 10 大家都懂，default是16，大家可以改成16，在yolov5s中模型参施不多，百万左右，所以显存消耗不多，我的配置很差，显存4g，在使用yolov5m中以及不能调到16。

**会报cuda out of memory 报错，就把batch size降低就行。**

然后最后是epoch，这个也不用解释，我在使用yolov5m训练5k张图片在100epoch中花费 了24小时，一个epoch13分钟。

训练过程中，会慢慢在runs中生成tensorboard，可视化损失下降

当然也可以在本地稍微看看：

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tSjJFqPI-1594698054819)(D:\\CSDN\\pic\\吸烟检测\\1594694078732.png)\]][img-tSjJFqPI-1594698054819_D_CSDN_pic_1594694078732.png]

这幅图中，我们的类别只有1个，第三幅图显示了我们数据中的宽高比，归一化后，普遍在0.1左右，说明数据确实很小，也会面临模糊问题，导致数据质量降低。

### 4.2：训练过程 ###

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AwsYh6Fd-1594698054821)(D:\\CSDN\\pic\\吸烟检测\\1594694802784.png)\]][img-AwsYh6Fd-1594698054821_D_CSDN_pic_1594694802784.png]

分别是epoch，显存消耗…其他的大家可以查看源码

### 4.3：训练优化 ###

使用混合精度模型

在前面配置好环境后：

mixed_precision = True
    try:  # Mixed precision training https://github.com/NVIDIA/apex
        from apex import amp
    except:
        print('Apex recommended for faster mixed precision training: https://github.com/NVIDIA/apex')
        mixed_precision = False  # not installed

*  1
 *  2
 *  3
 *  4
 *  5
 *  6

判断是否可用apex做混合精度模型训练

然后

if mixed_precision:
            model, optimizer = amp.initialize(model, optimizer, opt_level='O1', verbosity=0)

*  1
 *  2

在optimizer中amp初始化一下 o1代表级别，注意是欧 不是零。

接着：

if mixed_precision:
                    with amp.scale_loss(loss, optimizer) as scaled_loss:
                        scaled_loss.backward()

*  1
 *  2
 *  3

优化反向传播。

组装到cuda训练

opt.img_size.extend([opt.img_size[-1]] * (2 - len(opt.img_size)))  # extend to 2 sizes (train, test)
        device = torch_utils.select_device(opt.device, apex=mixed_precision, batch_size=opt.batch_size)
        if device.type == 'cpu':
            mixed_precision = False

*  1
 *  2
 *  3
 *  4

### 4.4 训练参数： ###

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BRPhpP1F-1594698054825)(D:\\CSDN\\pic\\吸烟检测\\1594695858251.png)\]][img-BRPhpP1F-1594698054825_D_CSDN_pic_1594695858251.png]

详情参见注释。

## 五、实时检测 ##

### 运行DETECT.PY即可 ###

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kxk153R0-1594698054828)(D:\\CSDN\\pic\\吸烟检测\\1594696030729.png)\]][img-kxk153R0-1594698054828_D_CSDN_pic_1594696030729.png]

**其中，推理一张图片，那么就在–source中的default写上图片路径，**

**也可以如图写上整个图片文件夹，这样会检测所有图片。**

**也可以写上视频地址和视频文件夹，检测所有视频，存放于inference 的out中。**

**改成0 就是实时检测了~默认电脑摄像头，当然也可以改成手机。这个也很简单，需要的可以私聊我，微信会放在最下方。**

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gaXEwy1a-1594698054830)(D:\\CSDN\\pic\\吸烟检测\\1594696346542.png)\]][img-gaXEwy1a-1594698054830_D_CSDN_pic_1594696346542.png]

帧率很高，普通设备也能达到30+，可谓是速度极快，要是大家设备好一些，可以试一下YOLOv5L和YOLOV5x，跑完了可以私聊分享一下，与我交流。

## 六、YOLO系列可视化对比 ##

类别100类

每类300张图片

测试图片1087张，阀值0.5 ,预测正确

yolov3-tiny      yolov4       yolov5

*  1

预测结果 737 954 955

模型大小 33.97M 246.19M 28.99M(yolov5s.pt)

**yolov5s的精度和yolov4差不多，但模型大小只有yolov4的11.77%（个人数据集，数据可能有点偏差，但还是能说明问题的）**

实时对比

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-soSpEIJF-1594698054832)(D:\\CSDN\\pic\\吸烟检测\\1594697092978.png)\]][img-soSpEIJF-1594698054832_D_CSDN_pic_1594697092978.png]

附上视频：https://www.bilibili.com/video/av328439400/

## 七、写在后面 ##

这篇文章大致介绍了yolov5的自训练，接下来我们可以进行调优。已经做消融对比实验，慢慢的更熟悉目标检测。继续我会在下篇中介绍文中的一些技术栈，让大家知根知底。

### 全部链接传送门 ###

最后再发一次所有的链接！

香烟数据集：链接：[https://pan.baidu.com/s/1t8u94x51TO7pLciU8AoaiQ][https_pan.baidu.com_s_1t8u94x51TO7pLciU8AoaiQ]  
提取码：n2wr

吸烟手势数据集：链接：[https://pan.baidu.com/s/1BSH4yn3GBzF3hDTWAqKzDQ][https_pan.baidu.com_s_1BSH4yn3GBzF3hDTWAqKzDQ]  
提取码：9r8t

烟雾数据集：链接：[https://pan.baidu.com/s/1RKvkkmfpHiPunkFMAEdoAQ][https_pan.baidu.com_s_1RKvkkmfpHiPunkFMAEdoAQ]  
提取码：ag0x

YOLOv5 原作者github：[https://github.com/ultralytics/yolov5][https_github.com_ultralytics_yolov5]

我的github ：[https://github.com/CVUsers/Smoke-Detect-by-YoloV5/tree/master][https_github.com_CVUsers_Smoke-Detect-by-YoloV5_tree_master] 欢迎star ，将长期更新！

最后还有很多知识点没分享，关注一下博主，下次分享。

另外欢迎加入深度学习算法交流群，与群内工程师朋友门一起交流学术，共商算法，加油！

[Link 1]: https://www.freesion.com/tag/%E5%AE%9E%E6%88%98%E9%A1%B9%E7%9B%AE/
[Link 2]: https://www.freesion.com/tag/%E3%80%90%E6%95%B0%E6%8D%AE%E5%85%B1%E4%BA%AB%E3%80%91/
[Link 3]: https://www.freesion.com/tag/%E7%9B%AE%E6%A0%87%E6%A3%80%E6%B5%8B%E7%B2%BE%E8%AF%BB/
[Link 4]: https://www.freesion.com/tag/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/
[Link 5]: https://www.freesion.com/tag/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/
[pytorch]: https://www.freesion.com/tag/pytorch/
[Link 6]: https://www.freesion.com/tag/%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C/
[Link 7]: https://www.freesion.com/tag/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/
[N_Star _github]: https://www.freesion.com/article/23201063581/#NStar_github_2
[Link 8]: https://www.freesion.com/article/23201063581/#_12
[Link 9]: https://www.freesion.com/article/23201063581/#_30
[1]: https://www.freesion.com/article/23201063581/#1_32
[Link 10]: https://www.freesion.com/article/23201063581/#_66
[3.1]: https://www.freesion.com/article/23201063581/#31_68
[3.2]: https://www.freesion.com/article/23201063581/#32_107
[3.2.1_Lablimg]: https://www.freesion.com/article/23201063581/#321Lablimg_117
[3.2.2]: https://www.freesion.com/article/23201063581/#322__135
[3.2.3]: https://www.freesion.com/article/23201063581/#323__213
[Link 11]: https://www.freesion.com/article/23201063581/#_334
[4.1]: https://www.freesion.com/article/23201063581/#41_336
[4.2]: https://www.freesion.com/article/23201063581/#42_389
[4.3]: https://www.freesion.com/article/23201063581/#43_395
[4.4]: https://www.freesion.com/article/23201063581/#44__444
[Link 12]: https://www.freesion.com/article/23201063581/#_450
[detect.py]: https://www.freesion.com/article/23201063581/#detectpy_452
[YOLO]: https://www.freesion.com/article/23201063581/#YOLO_470
[Link 13]: https://www.freesion.com/article/23201063581/#_494
[Link 14]: https://www.freesion.com/article/23201063581/#_498
[https_github.com_CVUsers_Smoke-Detect-by-YoloV5_tree_master]: https://github.com/CVUsers/Smoke-Detect-by-YoloV5/tree/master
[img-fwpaKe70-1594698054779_D_CSDN_pic_0.png]: /images/20220829/9da1c7404ac04e949025f6dccb2eb0d8.png
[img-hUenvq7F-1594698054781_D_CSDN_pic_0.5.png]: /images/20220829/28093fe67932485992ec0cf3f5a81cbf.png
[img-JEV7mZfK-1594698054784_D_CSDN_pic_1.png]: /images/20220829/b28e88afb35d44df811e26473d0cad6f.png
[img-Mgb0QwvX-1594698054788_D_CSDN_pic_1594683546122.png]: /images/20220829/d410ac13d1a34df49a16844bd138b995.png
[img-eruZx8Ri-1594698054790_D_CSDN_pic_3.png]: /images/20220829/80e7aad65434431d8ee08db41ac784b0.png
[22e0d6aae6da125225303fcaba16f14b.png]: /images/20220829/df35e9e54a9142378e82da1d131a30f3.png
[img-GFsXlbwe-1594698054792_D_CSDN_pic_1594687477452.png]: /images/20220829/a8bb7bd5c6dc40619424fbfa46fda4e8.png
[img-ctuoGjSX-1594698054796_D_CSDN_pic_7.png]: /images/20220829/bdd36b8970d14a59820f4c2acb3c2c57.png
[7d0ffac99f310fd0111cb97e14217421.png]: /images/20220829/59190a1aaf114870b47377c736bd0448.png
[img-TUcelHlM-1594698054806_D_CSDN_pic_10.png]: /images/20220829/8ebf45e2b7c94851a3dd34f8376b17be.png
[img-YGacBoN7-1594698054808_C_Users_acer_AppData_Roaming_Typora_typora-user-images_1594690060070.png]: /images/20220829/6d926e8fa2f042c696b3745819b81974.png
[img-SNIdxzTn-1594698054813_D_CSDN_pic_1594691005832.png]: /images/20220829/efe7f31db6334fc1ba16b37fc6de3ca8.png
[img-vuVhuRvJ-1594698054817_D_CSDN_pic_1594693318445.png]: /images/20220829/18e7bfd0576a406b95b61c71a813dcb5.png
[img-tSjJFqPI-1594698054819_D_CSDN_pic_1594694078732.png]: /images/20220829/6b243a39c3eb4856b4b5b2643d9478ba.png
[img-AwsYh6Fd-1594698054821_D_CSDN_pic_1594694802784.png]: /images/20220829/1856082fd7644d3d949ea8bdd3a28710.png
[img-BRPhpP1F-1594698054825_D_CSDN_pic_1594695858251.png]: /images/20220829/fc0783414dd74ac3a427da9e89384fb6.png
[img-kxk153R0-1594698054828_D_CSDN_pic_1594696030729.png]: /images/20220829/9c14120d006f4bd0b27a9f72adf9112a.png
[img-gaXEwy1a-1594698054830_D_CSDN_pic_1594696346542.png]: /images/20220829/f2570ed439c64646b0b7a7078ab0bf80.png
[img-soSpEIJF-1594698054832_D_CSDN_pic_1594697092978.png]: /images/20220829/0789c6fe549a4ccda139e03a9f6682f2.png
[https_pan.baidu.com_s_1t8u94x51TO7pLciU8AoaiQ]: https://pan.baidu.com/s/1t8u94x51TO7pLciU8AoaiQ
[https_pan.baidu.com_s_1BSH4yn3GBzF3hDTWAqKzDQ]: https://pan.baidu.com/s/1BSH4yn3GBzF3hDTWAqKzDQ
[https_pan.baidu.com_s_1RKvkkmfpHiPunkFMAEdoAQ]: https://pan.baidu.com/s/1RKvkkmfpHiPunkFMAEdoAQ
[https_github.com_ultralytics_yolov5]: https://github.com/ultralytics/yolov5