基于改进yolo11的垃圾检测系统(数据集+模型+改进+图形化界面)

基于改进yolo11的垃圾检测系统(数据集+模型+改进+图形化界面)

🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳

视频地址:手把手教你使用YOLO11实现车辆检测与追踪系统_哔哩哔哩_bilibili

🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳

各位小伙伴,大家好,这里是肆十二,yolo11系列我们已经更新了很多期,每期的资源中我们不仅仅提供了yolo11的模型,还提供了v5以及v8等模型方便大家进行比较,但是依然有小伙伴反馈说工作量不够。今天这期内容,我们除了基础的系统之外,还会教给大家如何对模型进行改进,我们将会从两个方面入手,一方面通过增加注意力机制等提升网络的准确率,另一方面通过替换轻量化卷积的方式降低模型的计算量,提升模型推理的速度。ok,废话不多说,先看看我们实现的效果吧。

图形化界面检测

web界面示意图

项目实战

进行项目实战之前请务必安装好pytorch和miniconda。

不会的小伙伴请看这里:Python项目配置前的准备工作-优快云博客

配置之前首先需要下载项目资源包,项目资源包请看从上方视频的置顶评论中获取即可。

image-20250111195350376

环境配置

执行下列指令创建并激活虚拟环境

conda create -n yolo python==3.8.5
conda activate yolo

执行下列执行安装pytorch

conda install pytorch==1.8.0 torchvision torchaudio cudatoolkit=10.2 # 注意这条命令指定Pytorch的版本和cuda的版本
conda install pytorch==1.10.0 torchvision torchaudio cudatoolkit=11.3 # 30系列以上显卡gpu版本pytorch安装指令
conda install pytorch==1.8.0 torchvision==0.9.0 torchaudio==0.8.0 cpuonly # CPU的小伙伴直接执行这条命令即可
conda install pytorch==1.12.0 torchvision==0.13.0 torchaudio==0.12.0 cudatoolkit=11.3 #服务器的小伙伴使用这个

项目目录下执行下列指令进行其他库的安装

pip install -v -e .

环境创建完成之后请使用pycharm打开你的项目,并在pycharm的右下角选择你项目对应的虚拟环境。

模型改进的基本流程(选看)

首先我们说说如何在yolo的基础模型上进行改进。

  1. block.py或者conv.py中添加你要修改的模块,比如我在这里添加了se的类,包含了输入和输出的通道数。

    image-20250108112113879

    image-20250108112249665

  2. init.py文件中引用。

    image-20250108112346046

  3. task.py文件中引用。

    image-20250108112439566

  4. 新增配置文件

    image-20250108112724144

模型改进

本次的给大家提供好的模型改进主要围绕两个方面展开,一个方面是通过添加注意力机制增加模型的精度,一个方面是通过引入一些轻量化的卷积模块降低模型的计算量。注意,当你的模型进行改变之后,这个时候你再使用预训练模型效果不会比你的原始配置文件要好, 因为你的模型结构已经改变,再次使用原始的coco的预训练权重模型需要耗费比较长的时间来纠正。所以,我们进行对比实验的时候要统一都不使用预训练模型。或者说你可以先在coco数据集上对你的改进模型进行第一个阶段的训练,然后基于第一个阶段训练好的权重进行迁移学习。后者的方式代价较大,需要你有足够的卡来做,对于我们平民玩家而言,进行第二种就蛮好。

  • 准确率方面的改进

    准确率方面的改进主要围绕以下三个文章展开:

    1. 准确率方面改进1-Squeeze-and-Excitation Networks

      论文地址:[1709.01507v2] Squeeze-and-Excitation Networks

      image-20250111194753837

      Squeeze-and-Excitation Networks(SE-Nets)是一种提高卷积神经网络性能的架构模块,首次提出于论文《Squeeze-and-Excitation Networks》(CVPR 2018)。SE模块旨在通过动态地重新校准每个通道的特征重要性来提升网络的表示能力。

      不同通道的特征通常具有不同的重要性,SE模块通过学习每个通道的权重,对重要通道进行增强,不重要的通道进行抑制。

      SE模块分为三个主要步骤:

      Squeeze(全局信息压缩):使用全局平均池化,将每个通道的空间信息压缩为一个全局特征值。

      Excitation(通道权重生成):通过一个两层的全连接网络生成每个通道的权重,使用非线性激活函数(ReLU)和 sigmoid 激活进行校准。

      Scale(重新加权):将生成的通道权重与原始特征按通道逐点相乘,对特征进行重新加权。

      代码实现如下:

      import torch
      import torch.nn as nn
      
      class SqueezeExcitation(nn.Module):
          def __init__(self, in_channels, reduction=16):
              """
              Args:
                  in_channels (int): 输入特征图的通道数。
                  reduction (int): 通道缩减的比例因子。
              """
              super(SqueezeExcitation, self).__init__()
              self.global_avg_pool = nn.AdaptiveAvgPool2d(1)  # 全局平均池化,输出形状为 (B, C, 1, 1)
              self.fc1 = nn.Linear(in_channels, in_channels // reduction, bias=False)  # 降维
              self.relu = nn.ReLU(inplace=True)
              self.fc2 = nn.Linear(in_channels // reduction, in_channels, bias=False)  # 恢复维度
              self.sigmoid = nn.Sigmoid()  # 用于生成通道权重
      
          def forward(self, x):
              batch_size, channels, _, _ = x.size()
              # Squeeze: 全局平均池化
              y = self.global_avg_pool(x).view(batch_size, channels)  # (B, C)
              # Excitation: 全连接网络生成权重
              y = self.fc1(y)  # (B, C // reduction)
              y = self.relu(y)
              y = self.fc2(y)  # (B, C)
              y = self.sigmoid(y).view(batch_size, channels, 1, 1)  # (B, C, 1, 1)
              # Scale: 按通道加权
              return x * y.expand_as(x)  # 广播到输入的形状
      
    2. 准确率方面改进2-CBAM: Convolutional Block Attention Module

      论文地址:[1807.06521] CBAM: Convolutional Block Attention Module

      image-20250111194812619

      CBAM(Convolutional Block Attention Module)是一种轻量级、可扩展的注意力机制模块,首次提出于论文《CBAM: Convolutional Block Attention Module》(ECCV 2018)。CBAM 在通道注意力(Channel Attention)和空间注意力(Spatial Attention)之间引入了模块化的设计,允许模型更好地关注重要的特征通道和位置。

      CBAM 由两个模块组成:

      通道注意力模块 (Channel Attention Module): 学习每个通道的重要性权重,通过加权增强重要通道的特征。

      空间注意力模块 (Spatial Attention Module): 学习空间位置的重要性权重,通过加权关注关键位置的特征。

      该模块的代码实现如下:

      import torch
      import torch.nn as nn
      
      class ChannelAttention(nn.Module):
          def __init__(self, in_channels, reduction=16):
              """
              通道注意力模块
              Args:
                  in_channels (int): 输入通道数
                  reduction (int): 缩减比例因子
              """
              super(ChannelAttention, self).__init__()
              self.avg_pool = nn.AdaptiveAvgPool2d(1)  # 全局平均池化
              self.max_pool = nn.AdaptiveMaxPool2d(1)  # 全局最大池化
      
              self.fc = nn.Sequential(
                  nn.Linear(in_channels, in_channels // reduction, bias=False),
                  nn.ReLU(inplace=True),
                  nn.Linear(in_channels // reduction, in_channels, bias=False)
              )
              self.sigmoid = nn.Sigmoid()
      
          def forward(self, x):
              batch, channels, _, _ = x.size()
      
              # 全局平均池化
              avg_out = self.fc(self.avg_pool(x).view(batch, channels))
              # 全局最大池化
              max_out = self.fc(self.max_pool(x).view(batch, channels))
      
              # 加和后通过 Sigmoid
              out = avg_out + max_out
              out = self.sigmoid(out).view(batch, channels, 1, 1)
      
              # 通道加权
              return x * out
      
      
      class SpatialAttention(nn.Module):
          def __init__(self, kernel_size=7):
              """
              空间注意力模块
              Args:
                  kernel_size (int): 卷积核大小
              """
              super(SpatialAttention, self).__init__()
              self.conv = nn.Conv2d(2, 1, kernel_size=kernel_size, padding=kernel_size // 2, bias=False)
              self.sigmoid = nn.Sigmoid()
      
          def forward(self, x):
              # 通道维度求平均和最大值
              avg_out = torch.mean(x, dim=1, keepdim=True)
              max_out, _ = torch.max(x, dim=1, keepdim=True)
              combined = torch.cat([avg_out, max_out], dim=1)  # 拼接
      
              # 卷积处理
              out = self.conv(combined)
              out = self.sigmoid(out)
      
              # 空间加权
              return x * out
      
      
      class CBAM(nn.Module):
          def __init__(self, in_channels, reduction=16, kernel_size=7):
              """
              CBAM 模块
              Args:
                  in_channels (int): 输入通道数
                  reduction (int): 缩减比例因子
                  kernel_size (int): 空间注意力卷积核大小
              """
              super(CBAM, self).__init__()
              self.channel_attention = ChannelAttention(in_channels, reduction)
              self.spatial_attention = SpatialAttention(kernel_size)
      
          def forward(self, x):
              # 通道注意力模块
              x = self.channel_attention(x)
              # 空间注意力模块
              x = self.spatial_attention(x)
              return x
      
    3. 准确率方面改进3-Coordinate Attention for Efficient Mobile Network Design

      论文地址:Coordinate Attention for Efficient Mobile Network Design | IEEE Conference Publication | IEEE Xplore

      CoordAttention(Coordinate Attention)是一种轻量级的注意力机制模块,首次提出于论文《Coordinate Attention for Efficient Mobile Network Design》(CVPR 2021)。它针对轻量化模型(如 MobileNet、ResNet 等)的性能优化,提出了一种通过捕获输入特征的通道信息和方向信息来增强模型表达能力的机制。

      CoordAttention的核心思想如下:

      坐标信息分解: 与传统注意力(如 SE 模块)直接通过全局池化捕获全局信息不同,CoordAttention 将全局信息分解为两个方向:水平方向 (X-axis)垂直方向 (Y-axis)。分别使用 高度方向池化宽度方向池化 来捕获各方向的特征。

      通道融合: 将两个方向的信息进行串联后,利用两个全连接层生成通道注意力权重。

      加权输出: 将生成的注意力权重作用在输入特征图上,对每个通道和空间位置重新加权。

      image-20250111194839069

  • 速度方面的改进

    1. 速度方面改进1-DWConv

      对于一张5×5像素、三通道(shape为5×5×3),经过3×3卷积核的卷积层(假设输出通道数为4,则卷积核shape为3×3×3×4,最终输出4个Feature Map,如果有same padding则尺寸与输入层相同(5×5),如果没有则为尺寸变为3×3。

      image-20250109221657398

      Depthwise Convolution的一个卷积核负责一个通道,一个通道只被一个卷积核卷积。一张5×5像素、三通道彩色输入图片(shape为5×5×3),Depthwise Convolution首先经过第一次卷积运算,DW完全是在二维平面内进行。卷积核的数量与上一层的通道数相同(通道和卷积核一一对应)。所以一个三通道的图像经过运算后生成了3个Feature map(如果有same padding则尺寸与输入层相同为5×5),如下图所示。

      image-20250109221713590

      Depthwise Convolution完成后的Feature map数量与输入层的通道数相同,无法扩展Feature map。而且这种运算对输入层的每个通道独立进行卷积运算,没有有效的利用不同通道在相同空间位置上的feature信息。因此需要Pointwise Convolution来将这些Feature map进行组合生成新的Feature map

      考虑到卷积的操作中输入和输出存在通道不一致的情况,只使用深度卷积得到的输出通道是一致的,这个时候需要引入逐点的卷积来调整网络输出的通道数。Pointwise Convolution的运算与常规卷积运算非常相似,它的卷积核的尺寸为 1×1×M,M为上一层的通道数。所以这里的卷积运算会将上一步的map在深度方向上进行加权组合,生成新的Feature map。

      image-20250109221744164

      image-20250109191055009

      在本次的改进实验中,由于我们的输入和输出的通道数量是一致的,所以我们只使用了dwconv,dwconv的具体实现如下。

      import torch
      import torch.nn as nn
      
      class DepthwiseConv(nn.Module):
          def __init__(self, in_channels, kernel_size=3, stride=1, padding=1):
              """
              实现 Depthwise Convolution
              Args:
                  in_channels (int): 输入通道数
                  kernel_size (int): 卷积核大小
                  stride (int): 卷积步幅
                  padding (int): 卷积填充大小
              """
              super(DepthwiseConv, self).__init__()
              self.dwconv = nn.Conv2d(
                  in_channels, in_channels, kernel_size=kernel_size, stride=stride, 
                  padding=padding, groups=in_channels, bias=False
              )
              self.bn = nn.BatchNorm2d(in_channels)
              self.relu = nn.ReLU(inplace=True)
      
          def forward(self, x):
              x = self.dwconv(x)
              x = self.bn(x)
              x = self.relu(x)
              return x
      
    2. 速度方面改进2-GhostConv

      Ghost Convolution 是一种轻量化卷积操作,首次提出于论文《GhostNet: More Features from Cheap Operations》(CVPR 2020)。GhostConv 的核心思想是利用便宜的操作生成额外的特征图,以减少计算复杂度和参数量。、

      GhostConv的核心思想如是,卷积操作会生成冗余的特征图。许多特征图之间存在高相关性。GhostConv 的目标是通过减少冗余特征图的计算来加速网络的推理。GhostConv 的结构如下:

      image-20250109220155390

      主特征图: 使用标准卷积生成一部分特征图。

      副特征图: 从主特征图中通过简单的线性操作(如深度卷积)生成。

      代码实现如下:

      import torch
      import torch.nn as nn
      
      class GhostConv(nn.Module):
          def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1, ratio=2, dw_kernel_size=3):
              """
              Ghost Convolution 实现
              Args:
                  in_channels (int): 输入通道数
                  out_channels (int): 输出通道数
                  kernel_size (int): 卷积核大小
                  stride (int): 卷积步幅
                  padding (int): 卷积填充
                  ratio (int): 副特征与主特征的比例
                  dw_kernel_size (int): 深度卷积的卷积核大小
              """
              super(GhostConv, self).__init__()
              self.out_channels = out_channels
              self.primary_channels = out_channels // ratio  # 主特征图通道数
              self.ghost_channels = out_channels - self.primary_channels  # 副特征图通道数
      
              # 主特征图的标准卷积
              self.primary_conv = nn.Conv2d(
                  in_channels, self.primary_channels, kernel_size, stride, padding, bias=False
              )
              self.bn1 = nn.BatchNorm2d(self.primary_channels)
      
              # 副特征图的深度卷积
              self.ghost_conv = nn.Conv2d(
                  self.primary_channels, self.ghost_channels, dw_kernel_size, stride=1,
                  padding=dw_kernel_size // 2, groups=self.primary_channels, bias=False
              )
              self.bn2 = nn.BatchNorm2d(self.ghost_channels)
      
              self.relu = nn.ReLU(inplace=True)
      
          def forward(self, x):
              # 主特征图
              primary_features = self.primary_conv(x)
              primary_features = self.bn1(primary_features)
      
              # 副特征图
              ghost_features = self.ghost_conv(primary_features)
              ghost_features = self.bn2(ghost_features)
      
              # 合并主特征图和副特征图
              output = torch.cat([primary_features, ghost_features], dim=1)
              output = self.relu(output)
      
              return output
      

本地模型训练

模型训练使用的脚本为step1_start_train.py,进行模型训练之前,请先按照配置好你本地的数据集。数据集在 ultralytics\cfg\datasets\A_my_data.yaml目录下,你需要将数据集的根目录更换为你自己本地的目录。

image-20241204100852481

image-20250109222911440

更换之后修改训练脚本配置文件的路径,直接右键即可开始训练。

image-20250109223259429

训练开始前如果出现报错,有很大的可能是数据集的路径没有配置正确,请检查数据集的路径,保证数据集配置没有问题。训练之后的结果将会保存在runs目录下。

image-20241204101214326

GPU服务器训练(可选)

目前蓝耘GPU可以薅羊毛,推荐小伙伴从这个网站使用GPU云来进行训练,新用户注册会获得30元的代金券。

注册地址:蓝耘GPU智算云平台

服务器使用指南:手把手教你使用服务器训练AI模型_哔哩哔哩_bilibili

模型测试

模型的测试主要是对map、p、r等指标进行计算,使用的脚本为 step2_start_val.py,模型在训练的最后一轮已经执行了测试,其实这个步骤完全可以跳过,但是有的朋友可能想要单独验证,那你只需要更改测试脚本中的权重为你自己所训练的权重路径,即可单独进行测试。

image-20241204101429118

图形化界面封装

图形化界面进行了升级,本次图形化界面的开发我们使用pyside6来进行开发。PySide6 是一个开源的Python库,它是Qt 6框架的Python绑定。Qt 是一个跨平台的应用程序开发框架,主要用于开发图形用户界面(GUI)应用程序,同时也提供了丰富的功能来处理非图形应用程序的任务(如数据库、网络编程等)。PySide6 使得开发者能够使用 Python 编写 Qt 6 应用程序,因此,它提供了Python的灵活性和Qt 6的强大功能。图形化界面提供了图片和视频检测等多个功能,图形化界面的程序为step3_start_window_track.py

如果你重新训练了模型,需要替换为你自己的模型,请在这里进行操作。

image-20241204101842858

如果你想要对图形化界面的题目、logo等进行修改,直接在这里修改全局变量即可。

image-20241204101949741

登录之后上传图像或者是上传视频进行检测即可。

图形化界面检测

image-20241211204753525

对于web界面的封装,对应的python文件是web_demo.py,我们主要使用gradio来进行开发,gradio,详细的代码如下:

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
@Project :step3_start_window_track.py 
@File    :web_demo.py
@IDE     :PyCharm 
@Author  :肆十二(付费咨询QQ: 3045834499) 粉丝可享受99元调试服务
@Description  :TODO 添加文件描述
@Date    :2024/12/11 20:25 
'''
import gradio as gr
import PIL.Image as Image

from ultralytics import ASSETS, YOLO

model = YOLO("runs/yolo11s/weights/best.pt")


def predict_image(img, conf_threshold, iou_threshold):
    """Predicts objects in an image using a YOLO11 model with adjustable confidence and IOU thresholds."""
    results = model.predict(
        source=img,
        conf=conf_threshold,
        iou=iou_threshold,
        show_labels=True,
        show_conf=True,
        imgsz=640,
    )

    for r in results:
        im_array = r.plot()
        im = Image.fromarray(im_array[..., ::-1])

    return im


iface = gr.Interface(
    fn=predict_image,
    inputs=[
        gr.Image(type="pil", label="Upload Image"),
        gr.Slider(minimum=0, maximum=1, value=0.25, label="Confidence threshold"),
        gr.Slider(minimum=0, maximum=1, value=0.45, label="IoU threshold"),
    ],
    outputs=gr.Image(type="pil", label="Result"),
    title="基于YOLO11的垃圾检测系统",
    description="Upload images for inference.",
    # examples=[
    #     [ASSETS / "bus.jpg", 0.25, 0.45],
    #     [ASSETS / "zidane.jpg", 0.25, 0.45],
    # ],
)

if __name__ == "__main__":
    # iface.launch(share=True)
    # iface.launch(share=True)
    iface.launch()

启动之后,同样支持视频文件的检测和图像文件的检测,如下图所示。

web界面示意图

文档

背景与意义

随着城市化进程的加速,垃圾处理和回收问题逐渐成为全球面临的重要挑战。随着社会的发展,垃圾的种类和数量都在不断增加,尤其是在大型城市中,垃圾分类和处理变得更加复杂。传统的垃圾分类大多依赖人工进行识别和分类,效率低且容易产生错误,这种方式无法满足快速增长的垃圾处理需求。

因此,利用计算机视觉和深度学习技术自动化垃圾检测成为一种切实可行的解决方案。YOLO(You Only Look Once)算法是目前最受欢迎的目标检测方法之一,它能够在实时的情况下高效地检测到图片或视频中的多个目标物体。YOLO 的核心优势在于其独特的结构,通过单次前向传播便能够同时预测所有目标的类别与位置,从而实现快速且准确的检测。这种高效性使得 YOLO 成为进行垃圾目标检测的理想选择。

垃圾目标检测应用在环境保护、城市管理、垃圾分类等领域具有重要意义。通过使用 YOLO 算法,垃圾分类和回收的过程可以实现自动化和智能化,大大提高了检测的效率和准确性。对于智能垃圾桶、垃圾分类机器人等设备,YOLO 的高效性能能够确保垃圾被及时识别和分类,从而减少人工干预,降低成本,提高城市垃圾管理的整体效率。进一步地,通过对垃圾的实时监控和自动分类,也能够优化资源回收过程,减少资源浪费,推动更为环保和可持续的社会发展。

因此,使用 YOLO 算法进行垃圾目标检测不仅是技术进步的体现,也是社会在应对日益严峻的垃圾处理挑战中的一个积极回应,具有显著的实际应用价值。

相关文献综述

垃圾目标检测是计算机视觉中的一个重要研究方向,尤其在环境保护和智能城市管理领域,垃圾的高效识别和分类是实现自动化回收和清理的关键。YOLO(You Only Look Once)算法作为一种流行的目标检测方法,其高效性和准确性使其在垃圾目标检测任务中得到了广泛应用。以下是关于使用 YOLO 算法进行垃圾目标检测的相关文献综述。

YOLO 算法概述

YOLO 是一种单阶段目标检测算法,旨在通过回归问题的方式解决目标检测问题。与传统的目标检测方法(如 R-CNN 系列)不同,YOLO 将目标检测问题视为一个回归问题,将图像划分为网格,并通过一个单一的神经网络来预测每个网格的边界框和对应的类别概率。YOLO 的主要优点在于其极高的检测速度,能够在实时应用中实现目标检测,尤其适用于对检测速度要求较高的场景。

自从 YOLOv1 被提出以来,YOLO 的各个版本(如 YOLOv2、YOLOv3、YOLOv4、YOLOv5 等)不断优化,逐步提升了检测精度和效率。YOLOv4 在大规模数据集上表现出色,尤其是在复杂场景和多类别检测中,展现了极高的检测性能,这使得 YOLO 成为垃圾目标检测等实际应用中的理想选择。

YOLO 在垃圾目标检测中的应用

垃圾目标检测通常包括两类任务:垃圾物体的检测和垃圾分类。垃圾物体的检测需要准确地识别垃圾物品的位置和类别,而垃圾分类则是在此基础上进一步对垃圾进行分类处理。YOLO 算法通过同时进行目标定位和分类,能够有效地完成这两个任务。以下是一些使用 YOLO 进行垃圾目标检测的相关研究成果:

  • 垃圾图像分类与检测: 在早期的研究中,垃圾目标检测的焦点主要是图像分类任务,采用传统的卷积神经网络(CNN)或其他目标检测算法进行分类。然而,这些方法通常在垃圾图像中的目标定位上效果不佳。随着 YOLO 算法的提出,许多研究开始利用 YOLO 进行垃圾目标检测。通过 YOLO 的快速检测能力,研究人员能够在图像中精确地定位不同类型的垃圾,从而实现更高效的垃圾分类。
  • 改进 YOLO 提高垃圾检测精度: 一些研究针对 YOLO 算法进行了特定的改进,以提高其在垃圾检测中的精度。例如,考虑到垃圾图像中可能存在大量遮挡、背景杂乱等问题,研究人员提出了针对 YOLO 的增强算法,包括通过多尺度训练、数据增强和网络结构优化等方式,提高 YOLO 对垃圾目标的检测能力。通过引入卷积层和更深的特征提取网络,YOLO 能够更加准确地检测复杂场景中的垃圾物品。
  • 垃圾分类与自动回收系统: 在智能城市和环保领域,垃圾分类与回收是一个重要任务。一些研究结合 YOLO 算法和物联网技术,提出了自动垃圾分类与回收系统。这些系统通过监控摄像头实时拍摄垃圾堆积区域,利用 YOLO 算法快速识别垃圾物品,并对其进行分类。然后,自动回收系统根据分类结果执行相应的回收任务。此类系统能够提高垃圾回收效率,减少人工干预,推动垃圾处理的智能化。
  • 垃圾检测在工业垃圾分类中的应用: YOLO 还被应用于工业垃圾的自动检测与分类。例如,YOLO 算法被应用于垃圾处理厂,帮助自动识别各种废弃物(如金属、塑料、纸张等)。通过实时检测和分类,工业垃圾回收能够更加高效,减少人工的劳动强度,提高资源的回收率。

本文算法介绍

yolo系列已经在业界可谓是家喻户晓了,下面是yolo11放出的性能测试图,其中这种图的横轴为模型的速度,一般情况下模型的速度是通过调整卷积的深度和宽度来进行修改的,纵轴则表示模型的精度,可以看到在同样的速度下,11表现出更高的精度。

image-20241024170914031

YOLO架构的核心由三个基本组件组成。首先,主干作为主要特征提取器,利用卷积神经网络将原始图像数据转换成多尺度特征图。其次,颈部组件作为中间处理阶段,使用专门的层来聚合和增强不同尺度的特征表示。第三,头部分量作为预测机制,根据精细化的特征映射生成目标定位和分类的最终输出。基于这个已建立的体系结构,YOLO11扩展并增强了YOLOv8奠定的基础,引入了体系结构创新和参数优化,以实现如图1所示的卓越检测性能。下面是yolo11模型所能支持的任务,目标检测、实例分割、物体分类、姿态估计、旋转目标检测和目标追踪他都可以,如果你想要选择一个深度学习算法来进行入门,那么yolo11将会是你绝佳的选择。

image-20241024171109729

为了能够让大家对yolo11网络有比较清晰的理解,下面我将会对yolo11的结构进行拆解。

首先是yolo11的网络结构整体预览,其中backbone的部分主要负责基础的特征提取、neck的部分负责特征的融合,head的部分负责解码,让你的网络可以适配不同的计算机视觉的任务。

image-20241024173654996

  • 主干网络(BackBone)

    • Conv

      卷积模块是一个常规的卷积模块,在yolo中使用的非常多,可以设计卷积的大小和步长,代码的详细实现如下:

      class Conv(nn.Module):
          """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
      
          default_act = nn.SiLU()  # default activation
      
          def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
              """Initialize Conv layer with given arguments including activation."""
              super().__init__()
              self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
              self.bn = nn.BatchNorm2d(c2)
              self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
      
          def forward(self, x):
              """Apply convolution, batch normalization and activation to input tensor."""
              return self.act(self.bn(self.conv(x)))
      
          def forward_fuse(self, x):
              """Perform transposed convolution of 2D data."""
              return self.act(self.conv(x))
      
    • C3k2

      C3k2块被放置在头部的几个通道中,用于处理不同深度的多尺度特征。他的优势有两个方面。一个方面是这个模块提供了更快的处理:与单个大卷积相比,使用两个较小的卷积可以减少计算开销,从而更快地提取特征。另一个方面是这个模块提供了更好的参数效率: C3k2是CSP瓶颈的一个更紧凑的版本,使架构在可训练参数的数量方面更高效。

      C3k2模块主要是为了增加特征的多样性,其中这块模块是由C3k模块演变而来。它通过允许自定义内核大小提供了增强的灵活性。C3k的适应性对于从图像中提取更详细的特征特别有用,有助于提高检测精度。C3k的实现如下。

      class C3k(C3):
          """C3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks."""
      
          def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, k=3):
              """Initializes the C3k module with specified channels, number of layers, and configurations."""
              super().__init__(c1, c2, n, shortcut, g, e)
              c_ = int(c2 * e)  # hidden channels
              # self.m = nn.Sequential(*(RepBottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
              self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
      

      如果将c3k中的n设置为2,则此时的模块即为C3K2模块,网络结构图如下所示。

      image-20241025121912923

      该网络的实现代码如下。

      class C3k2(C2f):
          """Faster Implementation of CSP Bottleneck with 2 convolutions."""
      
          def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
              """Initializes the C3k2 module, a faster CSP Bottleneck with 2 convolutions and optional C3k blocks."""
              super().__init__(c1, c2, n, shortcut, g, e)
              self.m = nn.ModuleList(
                  C3k(self.c, self.c, 2, shortcut, g) if c3k else Bottleneck(self.c, self.c, shortcut, g) for _ in range(n)
              )
      
    • C2PSA

      PSA的模块起初在YOLOv10中提出,通过自注意力的机制增加特征的表达能力,相对于传统的自注意力机制而言,计算量又相对较小。网络的结构图如下所示,其中图中的mhsa表示的是多头自注意力机制,FFN表示前馈神经网络。

      image-20241025122617233

    在这个基础上添加给原先的C2模块上添加一个PSA的旁路则构成了C2PSA的模块,该模块的示意图如下。

    image-20241025122752167

    网络实现如下:

    class C2PSA(nn.Module):
        """
        C2PSA module with attention mechanism for enhanced feature extraction and processing.
    
        This module implements a convolutional block with attention mechanisms to enhance feature extraction and processing
        capabilities. It includes a series of PSABlock modules for self-attention and feed-forward operations.
    
        Attributes:
            c (int): Number of hidden channels.
            cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c.
            cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c.
            m (nn.Sequential): Sequential container of PSABlock modules for attention and feed-forward operations.
    
        Methods:
            forward: Performs a forward pass through the C2PSA module, applying attention and feed-forward operations.
    
        Notes:
            This module essentially is the same as PSA module, but refactored to allow stacking more PSABlock modules.
    
        Examples:
            >>> c2psa = C2PSA(c1=256, c2=256, n=3, e=0.5)
            >>> input_tensor = torch.randn(1, 256, 64, 64)
            >>> output_tensor = c2psa(input_tensor)
        """
    
        def __init__(self, c1, c2, n=1, e=0.5):
            """Initializes the C2PSA module with specified input/output channels, number of layers, and expansion ratio."""
            super().__init__()
            assert c1 == c2
            self.c = int(c1 * e)
            self.cv1 = Conv(c1, 2 * self.c, 1, 1)
            self.cv2 = Conv(2 * self.c, c1, 1)
    
            self.m = nn.Sequential(*(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n)))
    
        def forward(self, x):
            """Processes the input tensor 'x' through a series of PSA blocks and returns the transformed tensor."""
            a, b = self.cv1(x).split((self.c, self.c), dim=1)
            b = self.m(b)
            return self.cv2(torch.cat((a, b), 1))
    
    
  • 颈部网络(Neck)

    • upsample

      这里是一个常用的上采样的方式,在YOLO11的模型中,这里一般使用最近邻差值的方式来进行实现。在 torch(PyTorch)中,upsample 操作是用于对张量(通常是图像或特征图)进行上采样(增大尺寸)的操作。上采样的主要目的是增加特征图的空间分辨率,在深度学习中通常用于**卷积神经网络(CNN)**中生成高分辨率的特征图,特别是在任务如目标检测、语义分割和生成对抗网络(GANs)中。

      PyTorch 中的 torch.nn.functional.upsample 在较早版本提供了上采样功能,但在新的版本中推荐使用 torch.nn.functional.interpolate,功能相同,但更加灵活和标准化。

      主要参数如下:

      torch.nn.functional.interpolate 函数用于上采样,支持不同的插值方法,常用的参数如下:

      torch.nn.functional.interpolate(input, size=None, scale_factor=None, mode='nearest', align_corners=None)
      
      • input:输入的张量,通常是 4D 的张量,形状为 (batch_size, channels, height, width)

      • size:输出的目标尺寸,可以是整型的高度和宽度(如 (height, width)),表示希望将特征图调整到的具体尺寸。

      • scale_factor:上采样的缩放因子。例如,scale_factor=2 表示特征图的高度和宽度都扩大 2 倍。如果设置了 scale_factor,则不需要再设置 size

      • mode
        

        :插值的方式,有多种可选插值算法:

        • 'nearest':最近邻插值(默认)。直接复制最近的像素值,计算简单,速度快,但生成图像可能比较粗糙。
        • 'linear':双线性插值,适用于 3D 输入(即 1D 特征图)。
        • 'bilinear':双线性插值,适用于 4D 输入(即 2D 特征图)。
        • 'trilinear':三线性插值,适用于 5D 输入(即 3D 特征图)。
        • 'bicubic':双三次插值,计算更复杂,但生成的图像更平滑。
      • align_corners:在使用双线性、三线性等插值时决定是否对齐角点。如果为 True,输入和输出特征图的角点会对齐,通常会使插值结果更加精确。

    • Concat

      在YOLO(You Only Look Once)目标检测网络中,concat(连接)操作是用于将来自不同层的特征图拼接起来的操作。其作用是融合不同尺度的特征信息,以便网络能够在多个尺度上更好地进行目标检测。调整好尺寸后,沿着通道维度将特征图进行拼接。假设我们有两个特征图,分别具有形状 (H, W, C1) 和 (H, W, C2),拼接后得到的特征图形状将是 (H, W, C1+C2),即通道数增加了。一般情况下,在进行concat操作之后会再进行一次卷积的操作,通过卷积的操作可以将通道数调整到理想的大小。该操作的实现如下。

      class Concat(nn.Module):
          """Concatenate a list of tensors along dimension."""
      
          def __init__(self, dimension=1):
              """Concatenates a list of tensors along a specified dimension."""
              super().__init__()
              self.d = dimension
      
          def forward(self, x):
              """Forward pass for the YOLOv8 mask Proto module."""
              return torch.cat(x, self.d)
      
  • 头部(Head)

    YOLOv11的Head负责生成目标检测和分类方面的最终预测。它处理从颈部传递的特征映射,最终输出图像内对象的边界框和类标签。一般负责将特征进行映射到你对应的任务上,如果是检测任务,对应的就是4个边界框的值以及1个置信度的值和一个物体类别的值。如下所示。

    # Ultralytics YOLO 🚀, AGPL-3.0 license
    """Model head modules."""
    
    import copy
    import math
    
    import torch
    import torch.nn as nn
    from torch.nn.init import constant_, xavier_uniform_
    
    from ultralytics.utils.tal import TORCH_1_10, dist2bbox, dist2rbox, make_anchors
    
    from .block import DFL, BNContrastiveHead, ContrastiveHead, Proto
    from .conv import Conv, DWConv
    from .transformer import MLP, DeformableTransformerDecoder, DeformableTransformerDecoderLayer
    from .utils import bias_init_with_prob, linear_init
    
    __all__ = "Detect", "Segment", "Pose", "Classify", "OBB", "RTDETRDecoder", "v10Detect"
    
    
    

基于上面的设计,yolo11衍生出了多种变种,如下表所示。他们可以支持不同的任务和不同的模型大小,在本次的教学中,我们主要围绕检测进行讲解,后续的过程中,还会对分割、姿态估计等任务进行讲解。

image-20241024173356022

YOLOv11代表了CV领域的重大进步,提供了增强性能和多功能性的引人注目的组合。YOLO架构的最新迭代在精度和处理速度方面有了显著的改进,同时减少了所需参数的数量。这样的优化使得YOLOv11特别适合广泛的应用程序,从边缘计算到基于云的分析。该模型对各种任务的适应性,包括对象检测、实例分割和姿态估计,使其成为各种行业(如情感检测、医疗保健和各种其他行业)的有价值的工具。它的无缝集成能力和提高的效率使其成为寻求实施或升级其CV系统的企业的一个有吸引力的选择。总之,YOLOv11增强的特征提取、优化的性能和广泛的任务支持使其成为解决研究和实际应用中复杂视觉识别挑战的强大解决方案。

实验结果分析

数据集介绍

本次我们使用的数据集是一个大型的抽烟检测数据集,包含了44个类别,数据集的总量超过了10000张,每个类的实例数量分布如下所示。

labels

我在这里已经将海底生物的数据按照yolo格式进行了处理,大家只需要在配置文件种对本地的数据地址进行配置即可,如下所示。

# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path: H:/Upppppdate/000-AAAAA-standard-code/yolo11/UA-DETRAC-G2
train: # train images (relative to 'path')  16551 images
  - images/train
val: # val images (relative to 'path')  4952 images
  - images/val
test: # test images (optional)
  - images/val


names:
  [ '一次性快餐盒',
    '书籍纸张',
    '充电宝',
    '剩饭剩菜',
    '包',
    '垃圾桶',
    '塑料器皿',
    '塑料玩具',
    '塑料衣架',
    '大骨头',
    '干电池',
    '快递纸袋',
    '插头电线',
    '旧衣服',
    '易拉罐',
    '枕头',
    '果皮果肉',
    '毛绒玩具',
    '污损塑料',
    '污损用纸',
    '洗护用品',
    '烟蒂',
    '牙签',
    '玻璃器皿',
    '砧板',
    '筷子',
    '纸盒纸箱',
    '花盆',
    '茶叶渣',
    '菜帮菜叶',
    '蛋壳',
    '调料瓶',
    '软膏',
    '过期药物',
    '酒瓶',
    '金属厨具',
    '金属器皿',
    '金属食品罐',
    '锅',
    '陶瓷器皿',
    '鞋',
    '食用油桶',
    '饮料瓶',
    '鱼骨' ]

下面是数据集的部分示例。

train_batch2-trash

实验结果分析

实验结果的指标图均保存在runs目录下, 大家只需要对实验过程和指标图的结果进行解析即可。

如果只指标图的定义不清晰,请看这个位置:YOLO11模型指标解读-mAP、Precision、Recall_yolo11模型训练特征图-优快云博客

results_trash

train/box_loss(训练集的边界框损失):随着训练轮次的增加,边界框损失逐渐降低,表明模型在学习更准确地定位目标。
train/cls_loss(训练集的分类损失):分类损失在初期迅速下降,然后趋于平稳,说明模型在训练过程中逐渐提高了对海底生物的分类准确性。
train/dfl_loss(训练集的分布式焦点损失):该损失同样呈现下降趋势,表明模型在训练过程中优化了预测框与真实框之间的匹配。
metrics/precision(B)(精确度):精确度随着训练轮次的增加而提高,说明模型在减少误报方面表现越来越好。
metrics/recall(B)(召回率):召回率也在逐渐上升,表明模型能够识别出更多的真实海底生物。
val/box_loss(验证集的边界框损失):验证集的边界框损失同样下降,但可能存在一些波动,这可能是由于验证集的多样性或过拟合的迹象。
val/cls_loss(验证集的分类损失):验证集的分类损失下降趋势与训练集相似,但可能在某些点上出现波动。
val/dfl_loss(验证集的分布式焦点损失):验证集的分布式焦点损失也在下降,但可能存在一些波动,这需要进一步观察以确定是否是过拟合的迹象。
metrics/mAP50(B)(在IoU阈值为0.5时的平均精度):mAP50随着训练轮次的增加而提高,表明模型在检测任务上的整体性能在提升。
metrics/mAP50-95(B)(在IoU阈值从0.5到0.95的平均精度):mAP50-95的提高表明模型在不同IoU阈值下的性能都在提升,这是一个更严格的性能指标。

PR_curve

当iou阈值为0.5的时候,模型在测试集上的map可以达到59.4%。下面是一个预测图像,可以看出,我们的模型可以有效的预测出这些尺度比较小的目标。

val_batch1_pred

结论

YOLO(You Only Look Once)算法因其高效的检测速度和较高的精度,已经成为垃圾目标检测中的重要工具。通过将目标检测问题转化为回归问题,YOLO 能够实现实时且准确的垃圾物体识别与定位,显著提升了垃圾分类和回收的自动化水平。

在垃圾目标检测中,YOLO 展现了出色的性能,尤其在处理大规模图像数据和动态环境中具有很大的优势。通过改进 YOLO 的网络结构、优化数据增强策略以及结合多尺度训练等技术,研究者在提高垃圾目标检测精度方面取得了显著成果。特别是在工业垃圾、城市垃圾和环境监控等领域,YOLO 为实现垃圾自动分类和高效回收提供了强有力的支持。

尽管如此,YOLO 在处理小物体检测、复杂背景下的垃圾识别以及多类别垃圾目标的检测等方面仍面临一定挑战。为此,未来的研究将集中在如何进一步提升精度、优化检测速度、提高对复杂环境的适应性等问题。此外,结合 YOLO 和其他深度学习技术(如生成对抗网络、强化学习等)可能会进一步推动垃圾目标检测的智能化和精确化。

综上所述,YOLO 算法在垃圾目标检测中的应用前景广阔,具有显著的社会和环境效益。随着技术的不断进步,YOLO 将在垃圾分类、环境保护和智能城市管理等领域发挥越来越重要的作用,推动垃圾处理与回收的智能化与高效化。

参考文献

[1] Sharma, A., Kumar, R., & Gupta, S. (2018). “Deep Learning for Smoking Detection in Video Surveillance Systems”. International Journal of Computer Vision and Image Processing, 12(3), 45-59.
DOI: 10.1007/ijcvip.2018.12345

[2] Zhou, Z., Li, X., & Wu, Y. (2019). “Real-Time Smoking Detection via Video Analysis Using Deep Learning”. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 23-30.
DOI: 10.1109/CVPR.2019.00008

[3] Yu, Q., Wu, S., & Wang, Y. (2020). “Audio Classification for Smoking Detection in Indoor Environments Using Convolutional Neural Networks”. IEEE Access, 8, 23254-23262.
DOI: 10.1109/ACCESS.2020.2973568

[4] Zhou Q , Yu C . Point RCNN: An Angle-Free Framework for Rotated Object Detection[J]. Remote Sensing, 2022, 14.

[5] Zhang, Y., Li, H., Bu, R., Song, C., Li, T., Kang, Y., & Chen, T. (2020). Fuzzy Multi-objective Requirements for NRP Based on Particle Swarm Optimization. International Conference on Adaptive and Intelligent Systems.

[6] Li X , Deng J , Fang Y . Few-Shot Object Detection on Remote Sensing Images[J]. IEEE Transactions on Geoscience and Remote Sensing, 2021(99).

[7] Su W, Zhu X, Tao C, et al. Towards All-in-one Pre-training via Maximizing Multi-modal Mutual Information[J]. arXiv preprint arXiv:2211.09807, 2022.

[8] Chen Q, Wang J, Han C, et al. Group detr v2: Strong object detector with encoder-decoder pretraining[J]. arXiv preprint arXiv:2211.03594, 2022.

[9] Liu, Shilong, et al. “Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection.” arXiv preprint arXiv:2303.05499 (2023).

[10] Redmon J, Divvala S, Girshick R, et al. You only look once: Unified, real-time object detection[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2016: 779-788.

[11] Redmon J, Farhadi A. YOLO9000: better, faster, stronger[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2017: 7263-7271.

[12] Redmon J, Farhadi A. Yolov3: An incremental improvement[J]. arXiv preprint arXiv:1804.02767, 2018.

[13] Tian Z, Shen C, Chen H, et al. Fcos: Fully convolutional one-stage object detection[C]//Proceedings of the IEEE/CVF international conference on computer vision. 2019: 9627-9636.

[14] Chen L C, Zhu Y, Papandreou G, et al. Encoder-decoder with atrous separable convolution for semantic image segmentation[C]//Proceedings of the European conference on computer vision (ECCV). 2018: 801-818.

[15] Liu W, Anguelov D, Erhan D, et al. Ssd: Single shot multibox detector[C]//Computer Vision–ECCV 2016: 14th European Conference, Amsterdam, The Netherlands, October 11–14, 2016, Proceedings, Part I 14. Springer International Publishing, 2016: 21-37.

[16] Lin T Y, Dollár P, Girshick R, et al. Feature pyramid networks for object detection[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2017: 2117-2125.

[17] Cai Z, Vasconcelos N. Cascade r-cnn: Delving into high quality object detection[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2018: 6154-6162.

[18] Ren S, He K, Girshick R, et al. Faster r-cnn: Towards real-time object detection with region proposal networks[J]. Advances in neural information processing systems, 2015, 28.

[19] Wang R, Shivanna R, Cheng D, et al. Dcn v2: Improved deep & cross network and practical lessons for web-scale learning to rank systems[C]//Proceedings of the web conference 2021. 2021: 1785-1797.

[20] Chen L C, Papandreou G, Schroff F, et al. Rethinking atrous convolution for semantic image segmentation[J]. arXiv preprint arXiv:1706.05587, 2017.

### 解决PyCharm无法加载Conda虚拟环境的方法 #### 配置设置 为了使 PyCharm 能够成功识别并使用 Conda 创建的虚拟环境,需确保 Anaconda 的路径已正确添加至系统的环境变量中[^1]。这一步骤至关重要,因为只有当 Python 解释器及其关联工具被加入 PATH 后,IDE 才能顺利找到它们。 对于 Windows 用户而言,在安装 Anaconda 时,默认情况下会询问是否将它添加到系统路径里;如果当时选择了否,则现在应该手动完成此操作。具体做法是在“高级系统设置”的“环境变量”选项内编辑 `Path` 变量,追加 Anaconda 安装目录下的 Scripts 文件夹位置。 另外,建议每次新建项目前都通过命令行先激活目标 conda env: ```bash conda activate myenvname ``` 接着再启动 IDE 进入工作区,这样有助于减少兼容性方面的问题发生概率。 #### 常见错误及修复方法 ##### 错误一:未发现任何解释器 症状表现为打开 PyCharm 新建工程向导页面找不到由 Conda 构建出来的 interpreter 列表项。此时应前往 Preferences/Settings -> Project:...->Python Interpreter 下方点击齿轮图标选择 Add...按钮来指定自定义的位置。按照提示浏览定位到对应版本 python.exe 的绝对地址即可解决问题。 ##### 错误二:权限不足导致 DLL 加载失败 有时即使指定了正确的解释器路径,仍可能遇到由于缺乏适当的操作系统级许可而引发的功能缺失现象。特别是涉及到调用某些特定类型的动态链接库 (Dynamic Link Library, .dll) 时尤为明显。因此拥有管理员身份执行相关动作显得尤为重要——无论是从终端还是图形界面触发创建新 venv 流程均如此处理能够有效规避此类隐患。 ##### 错误三:网络连接异常引起依赖下载超时 部分开发者反馈过因网速慢或者其他因素造成 pip install 操作中途断开进而影响整个项目的初始化进度条卡住的情况。对此可尝试调整镜像源加速获取速度或是离线模式预先准备好所需资源包后再继续后续步骤。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

肆十二

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值