基于 YOLO12 的无人机航拍视角目标检测系统

基于 YOLO12 的无人机（航拍）视角的目标检测系统

【大作业 -46】基于 yolo12 的航拍 (无人机) 视角目标检测与追踪系统

本次教程主要介绍基于无人机视角下的目标检测，对常规的行人、车辆等目标进行检测，并说明 YOLO12 的新模块。教程包含标注好的数据集、训练好的 YOLOv5、YOLOv8、YOLO11 以及 YOLO12 的模型，还有一个配套的图形化界面。

本次的数据集包含的类别如下：

0: pedestrian 行人 1: people 人 2: bicycle 自行车 3: car 汽车 4: van 货车 5: truck 卡车 6: tricycle 三轮车 7: awning-tricycle 遮阳篷三轮车 8: bus 公交车 9: motor 摩托车 

以下是部分数据示例。

下面是部分实现效果，支持视频和图像检测。

项目实战

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

配置之前首先需要下载项目资源包，项目资源包请看从上方视频的置顶评论中或者是博客绑定资源获取即可。

环境配置

环境配置请参考官方文档或通用流程。

本地模型训练

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

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

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

GPU 服务器训练（可选）

推荐使用云 GPU 服务进行训练，新用户注册通常会有代金券优惠。

模型测试

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

图形化界面封装

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

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

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

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

对于 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
@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") # todo 需要在这个位置修改为你自己的模型地址
TITLE = "欢迎使用基于 YOLOv12 的无人机视角目标检测"

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=TITLE,
    description="Upload images for inference.",
)

if __name__ == "__main__":
    iface.launch()

文档

背景与意义

无人机航拍视角下的目标检测系统是近年来计算机视觉和无人机技术交叉领域的一个重要研究方向。随着无人机技术的快速发展，其在农业、交通、安防、灾害监测等领域的应用日益广泛。无人机能够快速覆盖大范围区域，获取高分辨率的航拍图像，为实时目标检测和监控提供了新的可能性。然而，航拍图像具有目标尺度小、背景复杂、光照变化大等特点，给目标检测带来了巨大挑战。因此，设计一个高效、准确的目标检测系统具有重要的现实意义。

YOLO（You Only Look Once）系列算法作为目标检测领域的代表性模型，以其高效性和准确性著称。YOLOv12 和 YOLOv11 作为 YOLO 系列的最新版本，进一步优化了模型架构和训练策略，在检测精度和速度上均有显著提升。基于 YOLOv12 和 YOLOv11 设计无人机航拍视角下的目标检测系统，可以充分利用其强大的特征提取能力和实时检测性能，有效应对航拍图像中的复杂场景。

VisDrone 数据集是无人机航拍目标检测领域的一个权威数据集，包含了丰富的场景和多样的目标类别，如行人、车辆、建筑物等。该数据集为模型训练和评估提供了高质量的数据支持，有助于提升系统的泛化能力和鲁棒性。通过在该数据集上训练和测试，可以验证系统在不同场景下的检测性能，并为实际应用提供可靠的技术保障。

该系统的设计与实现具有重要的应用价值。在智慧城市建设中，无人机航拍目标检测系统可以用于交通流量监测、违章行为识别、突发事件响应等任务，提升城市管理的智能化水平。在农业领域，系统可以用于作物生长监测、病虫害识别等，提高农业生产效率。在安防领域，系统可以用于区域监控、目标追踪等，增强安全保障能力。此外，该系统还可以为无人机自主导航、避障等高级功能提供基础支持，推动无人机技术的进一步发展。

总之，基于 YOLOv12 和 YOLOv11 的无人机航拍视角目标检测系统，结合 VisDrone 数据集的丰富资源，不仅能够有效解决航拍目标检测中的技术难题，还为无人机在多个领域的应用提供了强有力的技术支持，具有重要的理论意义和实际价值。

相关文献综述

无人机航拍视角下的目标检测系统是计算机视觉和无人机技术交叉领域的热点研究方向，近年来吸引了大量学者的关注。YOLO 系列算法作为目标检测领域的代表性模型，因其高效性和准确性被广泛应用于无人机航拍场景。VisDrone 数据集作为无人机航拍目标检测的权威数据集，为相关研究提供了高质量的数据支持。以下是对该选题相关文献的综述。

在无人机航拍目标检测领域，早期研究主要基于传统图像处理方法和浅层机器学习模型。例如，使用 Haar 特征和 AdaBoost 算法进行行人检测，或基于 HOG 特征和 SVM 模型进行车辆识别。这些方法虽然在一定程度上能够实现目标检测，但在处理航拍图像中的小目标、复杂背景和光照变化时表现不佳。随着深度学习技术的发展，基于卷积神经网络（CNN）的目标检测方法逐渐成为主流。Faster R-CNN、SSD 和 YOLO 等算法在航拍目标检测中展现了显著的优势。

YOLO 系列算法因其'一次检测'的设计理念，在实时性和准确性之间取得了良好平衡。YOLOv1 首次提出将目标检测问题转化为回归问题，极大地提高了检测速度。后续版本如 YOLOv3、YOLOv4 和 YOLOv5 通过引入多尺度特征融合、注意力机制和更高效的网络架构，进一步提升了检测性能。YOLOv11 和 YOLOv12 作为最新版本，采用了更先进的训练策略和模型优化技术，在复杂场景下的检测能力显著增强。例如，YOLOv12 通过引入自适应特征提取模块和动态标签分配策略，有效解决了航拍图像中小目标检测的难题。

VisDrone 数据集是无人机航拍目标检测研究的重要基准。该数据集包含多种场景下的航拍图像，涵盖了行人、车辆、建筑物等多种目标类别，并提供了详细的标注信息。许多研究基于 VisDrone 数据集进行了模型训练和性能评估。例如，有学者提出了一种基于改进 YOLOv5 的航拍目标检测方法，通过引入注意力机制和多尺度特征融合，显著提高了小目标检测的精度。此外，还有研究结合 VisDrone 数据集和迁移学习技术，解决了航拍目标检测中数据不足的问题。

在无人机航拍目标检测系统的应用方面，已有研究探索了其在智慧城市、农业和安防等领域的潜力。例如，在智慧城市中，无人机航拍系统被用于交通流量监测和违章行为识别，提高了城市管理的效率。在农业领域，系统通过检测作物生长状态和病虫害，为精准农业提供了技术支持。在安防领域，无人机航拍系统被用于区域监控和目标追踪，增强了安全保障能力。这些研究为无人机航拍目标检测系统的实际应用提供了宝贵的经验。

综上所述，基于 YOLOv12 和 YOLOv11 的无人机航拍视角目标检测系统，结合 VisDrone 数据集的丰富资源，能够有效解决航拍目标检测中的技术难题。相关文献表明，该研究方向在算法优化、数据集构建和实际应用方面取得了显著进展，为后续研究提供了重要的理论基础和技术参考。

本文算法介绍

yolo12 算法介绍

yolo12 算法在原先 yolo11 的基础上进行了微调，引入了一种以注意力为中心的架构，它不同于以往 YOLO 模型中使用的基于 CNN 的传统方法，但仍保持了许多应用所必需的实时推理速度。该模型通过对注意力机制和整体网络架构进行新颖的方法创新，实现了最先进的物体检测精度，同时保持了实时性能。

• 区域注意机制：一种新的自我注意方法，能有效处理大的感受野。它可将特征图横向或纵向划分为 l 个大小相等的区域（默认为 4 个），从而避免复杂的操作，并保持较大的有效感受野。与标准自注意相比，这大大降低了计算成本。
• 剩余效率层聚合网络（R-ELAN）：基于 ELAN 的改进型特征聚合模块，旨在解决优化难题，尤其是在以注意力为中心的大规模模型中。R-ELAN 引入了
  • 具有缩放功能的块级残差连接（类似于图层缩放）。
  • 重新设计的特征聚合方法可创建类似瓶颈的结构。
• 优化注意力架构: YOLO12 简化了标准关注机制，以提高效率并与 YOLO 框架兼容。这包括
  • 使用 FlashAttention 尽量减少内存访问开销。
  • 去除位置编码，使模型更简洁、更快速。
  • 调整 MLP 比例（从通常的 4 调整为 1.2 或 2），以更好地平衡注意力层和前馈层之间的计算。
  • 减少堆叠区块的深度，提高优化效果。
  • 酌情利用卷积运算，提高计算效率。
  • 在注意力机制中加入 7x7 可分离卷积（'位置感知器'），对位置信息进行隐式编码。

在配置文件上，他和 yolo11 的区别就比较小了，主要体现在下图红框中所示的区域。

其中 A2C2F 就是 yolo12 中所提出的主要模块，A 表示的含义是 Area Attention。为了克服传统自注意力机制计算复杂度高的问题，YOLOv12 通过创新的区域注意力模块（Area Attention，A2），分辨率为 (H, W) 的特征图被划分为 l 个大小为 (H/l, W) 或 (H, W/l) 的段。这消除了显式的窗口划分，仅需要简单的重塑操作，从而实现更快的速度。将 l 的默认值设置为 4，将感受野减小到原来的 1/4，但仍保持较大的感受野。采用这种方法，注意力机制的计算成本从 2n²hd 降低到 1/2n²hd。尽管存在 n²的复杂度，但当 n 固定为 640 时（如果输入分辨率增加，则 n 会增加），这仍然足够高效，可以满足 YOLO 系统的实时要求。A2 降低了注意力机制的计算成本，同时保持较大的感受野，显著提升了检测精度。如下图所示，右侧的区域所表示的就是作者提出的注意力机制，相当于是以较少的计算量就捕捉到了相关的区域。

下面是 Area Attention 的实现，如下。

class A2C2f(nn.Module):
    """ Area-Attention C2f module for enhanced feature extraction with area-based attention mechanisms. This module extends the C2f architecture by incorporating area-attention and ABlock layers for improved feature processing. It supports both area-attention and standard convolution modes.
    Attributes:
        cv1 (Conv): Initial 1x1 convolution layer that reduces input channels to hidden channels.
        cv2 (Conv): Final 1x1 convolution layer that processes concatenated features.
        gamma (nn.Parameter | None): Learnable parameter for residual scaling when using area attention.
        m (nn.ModuleList): List of either ABlock or C3k modules for feature processing.
    Methods:
        forward: Processes input through area-attention or standard convolution pathway.
    Examples:
        >>> m = A2C2f(512, 512, n=1, a2=True, area=1)
        >>> x = torch.randn(1, 512, 32, 32)
        >>> output = m(x)
        >>> print(output.shape)
        torch.Size([1, 512, 32, 32])
    """
    def __init__(self, c1, c2, n=1, a2=True, area=1, residual=False, mlp_ratio=2.0, e=0.5, g=1, shortcut=True):
        """ Area-Attention C2f module for enhanced feature extraction with area-based attention mechanisms.
        Args:
            c1 (int): Number of input channels.
            c2 (int): Number of output channels.
            n (int): Number of ABlock or C3k modules to stack.
            a2 (bool): Whether to use area attention blocks. If False, uses C3k blocks instead.
            area (int): Number of areas the feature map is divided.
            residual (bool): Whether to use residual connections with learnable gamma parameter.
            mlp_ratio (float): Expansion ratio for MLP hidden dimension.
            e (float): Channel expansion ratio for hidden channels.
            g (int): Number of groups for grouped convolutions.
            shortcut (bool): Whether to use shortcut connections in C3k blocks.
        """
        super().__init__()
        c_ = int(c2 * e) # hidden channels
        assert c_ % 32 == 0, "Dimension of ABlock be a multiple of 32."
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv((1+ n)* c_, c2, 1)
        self.gamma = nn.Parameter(0.01* torch.ones(c2), requires_grad=True) if a2 and residual else None
        self.m = nn.ModuleList(
            nn.Sequential(*(ABlock(c_, c_ // 32, mlp_ratio, area) for _ in range(2))) if a2 else C3k(c_, c_, 2, shortcut, g) for _ in range(n))
    def forward(self, x):
        """Forward pass through R-ELAN layer."""
        y = [self.cv1(x)]
        y.extend(m(y[-1]) for m in self.m)
        y = self.cv2(torch.cat(y, 1))
        if self.gamma is not None:
            return x + self.gamma.view(-1, len(self.gamma), 1, 1) * y
        return y

yolo11 算法介绍

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

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

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

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

• 颈部网络（Neck）
  • input：输入的张量，通常是 4D 的张量，形状为 (batch_size, channels, height, width)。
  • size：输出的目标尺寸，可以是整型的高度和宽度（如 (height, width)），表示希望将特征图调整到的具体尺寸。
  • scale_factor：上采样的缩放因子。例如，scale_factor=2 表示特征图的高度和宽度都扩大 2 倍。如果设置了 scale_factor，则不需要再设置 size。
    • 'nearest'：最近邻插值（默认）。直接复制最近的像素值，计算简单，速度快，但生成图像可能比较粗糙。
    • 'linear'：双线性插值，适用于 3D 输入（即 1D 特征图）。
    • 'bilinear'：双线性插值，适用于 4D 输入（即 2D 特征图）。
    • 'trilinear'：三线性插值，适用于 5D 输入（即 3D 特征图）。
    • 'bicubic'：双三次插值，计算更复杂，但生成的图像更平滑。
  • align_corners：在使用双线性、三线性等插值时决定是否对齐角点。如果为 True，输入和输出特征图的角点会对齐，通常会使插值结果更加精确。

头部（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"

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)

mode：插值的方式，有多种可选插值算法：

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)

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

C3k2C3k2 块被放置在头部的几个通道中，用于处理不同深度的多尺度特征。他的优势有两个方面。一个方面是这个模块提供了更快的处理：与单个大卷积相比，使用两个较小的卷积可以减少计算开销，从而更快地提取特征。另一个方面是这个模块提供了更好的参数效率：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 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 模块，网络结构图如下所示。

该网络的实现代码如下。

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 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))

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))

主干网络（BackBone）在这个基础上添加给原先的 C2 模块上添加一个 PSA 的旁路则构成了 C2PSA 的模块，该模块的示意图如下。

网络实现如下：

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 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))

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

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

实验结果分析

数据集介绍

本次我们使用的数据集为 visdrone 数据集，数据集的分布如下。

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

path: H:/raspi/0000-38-visdrone-detect-yolo12/visdrone # dataset root dir
train: VisDrone2019-DET-train/images # train images (relative to 'path') 6471 images
val: VisDrone2019-DET-val/images # val images (relative to 'path') 548 images
test: VisDrone2019-DET-test-dev/images # test images (optional) 1610 images
# Classes
names:
0: pedestrian
1: people
2: bicycle
3: car
4: van
5: truck
6: tricycle
7: awning-tricycle
8: bus
9: motor

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

指标结果分析

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

如果只指标图的定义不清晰，请参考官方文档。

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 阈值下的性能都在提升，这是一个更严格的性能指标。

当 iou 阈值为 0.5 的时候，模型在测试集上的 map 可以达到右上角所示的数值。下面是一个预测图像，可以看出，我们的模型可以有效的预测出这些尺度比较多变的目标。

结论

基于 YOLOv12 和 YOLOv11 设计的无人机航拍视角目标检测系统，结合 VisDrone 数据集进行训练和测试，取得了显著的实验结果。该系统在航拍图像中的目标检测任务中展现了较高的准确性和鲁棒性，尤其是在处理小目标、复杂背景和光照变化等挑战时表现突出。YOLOv12 和 YOLOv11 的先进架构和优化策略有效提升了检测性能，使得系统在检测精度和实时性之间达到了良好的平衡。

实验结果表明，YOLOv12 在小目标检测方面表现尤为出色，其引入的自适应特征提取模块和动态标签分配策略显著提高了小目标的召回率和定位精度。而 YOLOv11 在复杂场景下的检测能力也表现优异，其多尺度特征融合和注意力机制有效增强了模型对目标的识别能力。在 VisDrone 数据集上的测试中，两个模型均实现了较高的平均精度（mAP），验证了其在无人机航拍目标检测任务中的有效性。

此外，系统在实际应用场景中的表现也得到了验证。例如，在智慧城市交通监测任务中，系统能够准确识别车辆和行人，并实时输出检测结果；在农业场景中，系统成功检测了作物生长状态和病虫害目标，为精准农业提供了技术支持；在安防领域，系统实现了对特定区域的高效监控和目标追踪，展现了其在实际应用中的潜力。

然而，实验也揭示了系统在某些极端场景下的局限性，例如在光照强烈变化或目标密集重叠的情况下，检测精度会有所下降。未来的研究可以进一步优化模型架构，引入更先进的数据增强技术和训练策略，以提升系统在复杂环境下的鲁棒性。此外，结合多模态数据（如红外图像或雷达数据）也可能进一步提高系统的检测性能。

总体而言，基于 YOLOv12 和 YOLOv11 的无人机航拍视角目标检测系统在 VisDrone 数据集上展现了优异的性能，为无人机航拍目标检测任务提供了高效、可靠的解决方案。该系统的成功设计和实现不仅验证了 YOLO 系列算法在航拍场景中的适用性，也为无人机在智慧城市、农业、安防等领域的应用奠定了技术基础。

参考文献

[1] Zhang Y , Li H , Bu R ,et al.Fuzzy Multi-objective Requirements for NRP Based on Particle Swarm Optimization[C]//2020.DOI:10.1007/978-3-030-57881-7_13. [2] Zhao N , Cao M , Song C ,et al.Trusted Component Decomposition Based on OR-Transition Colored Petri Net[C]//International Conference on Artificial Intelligence and Security.Springer, Cham, 2019.DOI:10.1007/978-3-030-24268-8_41. DOI: 10.1109/ACCESS.2020.2973568 [3] Song C, Chang H. RST R-CNN: a triplet matching few-shot remote sensing object detection framework[C]//Fourth International Conference on Computer Vision, Application, and Algorithm (CVAA 2024). SPIE, 2025, 13486: 553-568. [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.

---

模型改进的基本流程（选看）

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

新增配置文件

在 task.py 文件中引用。

在 init.py 文件中引用。

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

模型改进（选看）

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

速度方面的改进：GhostConv Ghost Convolution 是一种轻量化卷积操作，首次提出于论文《GhostNet: More Features from Cheap Operations》（CVPR 2020）。GhostConv 的核心思想是利用便宜的操作生成额外的特征图，以减少计算复杂度和参数量。GhostConv 的核心思想如是，卷积操作会生成冗余的特征图。许多特征图之间存在高相关性。GhostConv 的目标是通过减少冗余特征图的计算来加速网络的推理。GhostConv 的结构如下：

主特征图: 使用标准卷积生成一部分特征图。副特征图: 从主特征图中通过简单的线性操作（如深度卷积）生成。代码实现如下：

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

准确率方面的改进：CBAM 论文地址：[1807.06521] CBAM: Convolutional Block Attention Module

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