【改进YOLOv8】融合可扩张残差（DWR）注意力模块的小麦病害检测系统

1.研究背景与意义

项目参考AAAI Association for the Advancement of Artificial Intelligence

研究背景与意义：

随着计算机视觉技术的快速发展，深度学习在图像识别和目标检测领域取得了巨大的突破。其中，YOLO（You Only Look Once）是一种非常流行的目标检测算法，以其快速且准确的特点受到了广泛关注。然而，YOLO算法在小目标检测和遮挡目标检测方面仍然存在一些挑战。

在农业领域，小麦病害的检测对于保障粮食安全和提高农作物产量具有重要意义。传统的小麦病害检测方法需要大量的人力和时间，效率低下且易受主观因素的影响。因此，开发一种高效准确的小麦病害检测系统对于农业生产具有重要意义。

目前，基于YOLO算法的小麦病害检测系统已经取得了一定的成果。然而，由于小麦病害通常具有较小的目标尺寸和复杂的纹理特征，传统的YOLO算法在小麦病害检测中仍然存在一些问题。例如，由于YOLO算法的多尺度特性，较小的目标往往容易被忽略或错误分类。此外，遮挡目标的检测也是一个具有挑战性的问题。

因此，本研究旨在改进YOLOv8算法，提出一种融合可扩张残差（DWR）注意力模块的小麦病害检测系统。该系统将利用DWR注意力模块来增强YOLOv8算法对小目标和遮挡目标的检测能力。DWR注意力模块通过引入可扩张残差结构，能够更好地捕捉目标的细节信息，并提高目标的检测精度。

本研究的意义主要体现在以下几个方面：

首先，通过改进YOLOv8算法，提出一种融合DWR注意力模块的小麦病害检测系统，可以提高小目标和遮挡目标的检测准确率。这将有助于农业生产中对小麦病害的快速准确检测，提高农作物的产量和质量。

其次，DWR注意力模块的引入可以增强目标的细节信息捕捉能力，提高目标的检测精度。这对于小麦病害的检测尤为重要，因为小麦病害通常具有复杂的纹理特征，传统的目标检测算法往往难以准确识别。

此外，本研究的成果还可以为其他农作物的病害检测提供借鉴和参考。虽然本研究主要关注小麦病害检测，但所提出的改进算法和注意力模块可以应用于其他农作物的病害检测，提高农业生产的效率和质量。

综上所述，本研究旨在改进YOLOv8算法，提出一种融合DWR注意力模块的小麦病害检测系统。该系统的研究意义主要体现在提高小目标和遮挡目标的检测准确率，增强目标的细节信息捕捉能力，以及为其他农作物的病害检测提供借鉴和参考。这将有助于提高农业生产的效率和质量，保障粮食安全。

2.图片演示

3.视频演示

【改进YOLOv8】融合可扩张残差（DWR）注意力模块的小麦病害检测系统_哔哩哔哩_bilibili

4.数据集的采集＆标注和整理

图片的收集

首先，我们需要收集所需的图片。这可以通过不同的方式来实现，例如使用现有的公开数据集WheatDatasets。

labelImg是一个图形化的图像注释工具，支持VOC和YOLO格式。以下是使用labelImg将图片标注为VOC格式的步骤：

（1）下载并安装labelImg。
（2）打开labelImg并选择“Open Dir”来选择你的图片目录。
（3）为你的目标对象设置标签名称。
（4）在图片上绘制矩形框，选择对应的标签。
（5）保存标注信息，这将在图片目录下生成一个与图片同名的XML文件。
（6）重复此过程，直到所有的图片都标注完毕。

由于YOLO使用的是txt格式的标注，我们需要将VOC格式转换为YOLO格式。可以使用各种转换工具或脚本来实现。

下面是一个简单的方法是使用Python脚本，该脚本读取XML文件，然后将其转换为YOLO所需的txt格式。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import xml.etree.ElementTree as ET
import os

classes = []  # 初始化为空列表

CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))

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('./label_xml\%s.xml' % (image_id), encoding='UTF-8')
    out_file = open('./label_txt\%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:
            classes.append(cls)  # 如果类别不存在，添加到classes列表中
        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')

xml_path = os.path.join(CURRENT_DIR, './label_xml/')

# xml list
img_xmls = os.listdir(xml_path)
for img_xml in img_xmls:
    label_name = img_xml.split('.')[0]
    print(label_name)
    convert_annotation(label_name)

print("Classes:")  # 打印最终的classes列表
print(classes)  # 打印最终的classes列表

整理数据文件夹结构

我们需要将数据集整理为以下结构：

-----data
   |-----train
   |   |-----images
   |   |-----labels
   |
   |-----valid
   |   |-----images
   |   |-----labels
   |
   |-----test
       |-----images
       |-----labels

确保以下几点：

所有的训练图片都位于data/train/images目录下，相应的标注文件位于data/train/labels目录下。
所有的验证图片都位于data/valid/images目录下，相应的标注文件位于data/valid/labels目录下。
所有的测试图片都位于data/test/images目录下，相应的标注文件位于data/test/labels目录下。
这样的结构使得数据的管理和模型的训练、验证和测试变得非常方便。

模型训练

 Epoch   gpu_mem       box       obj       cls    labels  img_size
 1/200     20.8G   0.01576   0.01955  0.007536        22      1280: 100%|██████████| 849/849 [14:42<00:00,  1.04s/it]
           Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100%|██████████| 213/213 [01:14<00:00,  2.87it/s]
             all       3395      17314      0.994      0.957      0.0957      0.0843

 Epoch   gpu_mem       box       obj       cls    labels  img_size
 2/200     20.8G   0.01578   0.01923  0.007006        22      1280: 100%|██████████| 849/849 [14:44<00:00,  1.04s/it]
           Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100%|██████████| 213/213 [01:12<00:00,  2.95it/s]
             all       3395      17314      0.996      0.956      0.0957      0.0845

 Epoch   gpu_mem       box       obj       cls    labels  img_size
 3/200     20.8G   0.01561    0.0191  0.006895        27      1280: 100%|██████████| 849/849 [10:56<00:00,  1.29it/s]
           Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100%|███████   | 187/213 [00:52<00:00,  4.04it/s]
             all       3395      17314      0.996      0.957      0.0957      0.0845

5.核心代码讲解

5.2 predict.py

from ultralytics.engine.predictor import BasePredictor
from ultralytics.engine.results import Results
from ultralytics.utils import ops

class DetectionPredictor(BasePredictor):
    def postprocess(self, preds, img, orig_imgs):
        preds = ops.non_max_suppression(preds,
                                        self.args.conf,
                                        self.args.iou,
                                        agnostic=self.args.agnostic_nms,
                                        max_det=self.args.max_det,
                                        classes=self.args.classes)

        if not isinstance(orig_imgs, list):
            orig_imgs = ops.convert_torch2numpy_batch(orig_imgs)

        results = []
        for i, pred in enumerate(preds):
            orig_img = orig_imgs[i]
            pred[:, :4] = ops.scale_boxes(img.shape[2:], pred[:, :4], orig_img.shape)
            img_path = self.batch[0][i]
            results.append(Results(orig_img, path=img_path, names=self.model.names, boxes=pred))
        return results

这个程序文件是一个名为predict.py的文件，它是一个用于预测基于检测模型的类DetectionPredictor的扩展。该类继承自BasePredictor类，并包含了一个postprocess方法用于后处理预测结果并返回Results对象的列表。

在postprocess方法中，首先对预测结果进行非最大抑制操作，根据设定的置信度阈值和IOU阈值进行筛选，并根据设定的参数进行类别筛选和边界框缩放操作。然后，将原始图像、图像路径、类别名称和筛选后的边界框信息作为参数，创建Results对象并添加到结果列表中。

该文件还包含了一个示例用法，通过创建DetectionPredictor对象并传入相关参数，可以进行预测操作。

该程序文件使用了Ultralytics YOLO库，遵循AGPL-3.0许可证。

5.4 backbone\convnextv2.py

import torch
import torch.nn as nn
import torch.nn.functional as F
from timm.models.layers import trunc_normal_, DropPath

class LayerNorm(nn.Module):
    def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"):
        super().__init__()
        self.weight = nn.Parameter(torch.ones(normalized_shape))
        self.bias = nn.Parameter(torch.zeros(normalized_shape))
        self.eps = eps
        self.data_format = data_format
        if self.data_format not in ["channels_last", "channels_first"]:
            raise NotImplementedError 
        self.normalized_shape = (normalized_shape, )
    
    def forward(self, x):
        if self.data_format == "channels_last":
            return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
        elif self.data_format == "channels_first":
            u = x.mean(1, keepdim=True)
            s = (x - u).pow(2).mean(1, keepdim=True)
            x = (x - u) / torch.sqrt(s + self.eps)
            x = self.weight[:, None, None] * x + self.bias[:, None, None]
            return x

class GRN(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.gamma = nn.Parameter(torch.zeros(1, 1, 1, dim))
        self.beta = nn.Parameter(torch.zeros(1, 1, 1, dim))

    def forward(self, x):
        Gx = torch.norm(x, p=2, dim=(1,2), keepdim=True)
        Nx = Gx / (Gx.mean(dim=-1, keepdim=True) + 1e-6)
        return self.gamma * (x * Nx) + self.beta + x

class Block(nn.Module):
    def __init__(self, dim, drop_path=0.):
        super().__init__()
        self.dwconv = nn.Conv2d(dim, dim, kernel_size=7, padding=3, groups=dim)
        self.norm = LayerNorm(dim, eps=1e-6)
        self.pwconv1 = nn.Linear(dim, 4 * dim)
        self.act = nn.GELU()
        self.grn = GRN(4 * dim)
        self.pwconv2 = nn.Linear(4 * dim, dim)
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()

    def forward(self, x):
        input = x
        x = self.dwconv(x)
        x = x.permute(0, 2, 3, 1)
        x = self.norm(x)
        x = self.pwconv1(x)
        x = self.act(x)
        x = self.grn(x)
        x = self.pwconv2(x)
        x = x.permute(0, 3, 1, 2)

        x = input + self.drop_path(x)
        return x

class ConvNeXtV2(nn.Module):
    def __init__(self, in_chans=3, num_classes=1000, 
                 depths=[3, 3, 9, 3], dims=[96, 192, 384, 768], 
                 drop_path_rate=0., head_init_scale=1.
                 ):
        super().__init__()
        self.depths = depths
        self.downsample_layers = nn.ModuleList()
        stem = nn.Sequential(
            nn.Conv2d(in_chans, dims[0], kernel_size=4, stride=4),
            LayerNorm(dims[0], eps=1e-6, data_format="channels_first")
        )
        self.downsample_layers.append(stem)
        for i in range(3):
            downsample_layer = nn.Sequential(
                    LayerNorm(dims[i], eps=1e-6, data_format="channels_first"),
                    nn.Conv2d(dims[i], dims[i+1], kernel_size=2, stride=2),
            )
            self.downsample_layers.append(downsample_layer)

        self.stages = nn.ModuleList()
        dp_rates=[x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] 
        cur = 0
        for i in range(4):
            stage = nn.Sequential(
                *[Block(dim=dims[i], drop_path=dp_rates[cur + j]) for j in range(depths[i])]
            )
            self.stages.append(stage)
            cur += depths[i]

        self.norm = nn.LayerNorm(dims[-1], eps=1e-6)
        self.head = nn.Linear(dims[-1], num_classes)

        self.apply(self._init_weights)
        self.channel = [i.size(1) for i in self.forward(torch.randn(1, 3, 640, 640))]

    def _init_weights(self, m):
        if isinstance(m, (nn.Conv2d, nn.Linear)):
            trunc_normal_(m.weight, std=.02)
            nn.init.constant_(m.bias, 0)

    def forward(self, x):
        res = []
        for i in range(4):
            x = self.downsample_layers[i](x)
            x = self.stages[i](x)
            res.append(x)
        return res

该程序文件是一个用于构建ConvNeXt V2模型的Python脚本。它定义了一系列的类和函数，用于构建不同规模的ConvNeXt V2模型。

文件中定义了以下类和函数：

1. LayerNorm类：支持两种数据格式（channels_last和channels_first）的LayerNorm层。

2. GRN类：全局响应归一化（Global Response Normalization）层。

3. Block类：ConvNeXtV2模型的基本块。

4. ConvNeXtV2类：ConvNeXt V2模型的主体部分。

5. update_weight函数：用于更新模型权重。

6. convnextv2_atto函数：构建ConvNeXt V2模型（规模为atto）的函数。

7. convnextv2_femto函数：构建ConvNeXt V2模型（规模为femto）的函数。

8. convnextv2_pico函数：构建ConvNeXt V2模型（规模为pico）的函数。

9. convnextv2_nano函数：构建ConvNeXt V2模型（规模为nano）的函数。

10. convnextv2_tiny函数：构建ConvNeXt V2模型（规模为tiny）的函数。

11. convnextv2_base函数：构建ConvNeXt V2模型（规模为base）的函数。

12. convnextv2_large函数：构建ConvNeXt V2模型（规模为large）的函数。

13. convnextv2_huge函数：构建ConvNeXt V2模型（规模为huge）的函数。

这些函数可以根据输入的参数构建不同规模的ConvNeXt V2模型，并且可以选择加载预训练的权重。

5.5 backbone\CSwomTramsformer.py

class CSWinTransformer(nn.Module):
    def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000, embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24], mlp_ratio=4., qkv_bias=True, qk_scale=None, drop_rate=0., attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm):
        super().__init__()
        self.num_classes = num_classes
        self.depths = depths
        self.num_features = self.embed_dim = embed_dim

        self.patch_embed = PatchEmbed(
            img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
        self.pos_drop = nn.Dropout(p=drop_rate)

        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
        self.blocks = nn.ModuleList([
            CSWinBlock(
                dim=embed_dim, reso=img_size // patch_size, num_heads=num_heads[i], mlp_ratio=mlp_ratio,
                qkv_bias=qkv_bias, qk_scale=qk_scale, drop=drop_rate, attn_drop=attn_drop_rate,
                drop_path=dpr[sum(depths[:i]):sum(depths[:i + 1])], norm_layer=norm_layer,
                last_stage=(i == len(depths) - 1))
            for i in range(len(depths))])

        self.norm = norm_layer(embed_dim)

        self.feature_info = [dict(num_chs=embed_dim, reduction=0, module='head')]
        self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity()

        trunc_normal_(self.head.weight, std=.02)
        zeros_(self.head.bias)

    def forward_features(self, x):
        x = self.patch_embed(x)
        x = self.pos_drop(x)

        for blk in self.blocks:
            x = blk(x)

        x = self.norm(x)  # B L C
        return x

    def forward(self, x):
        x = self.forward_features(x)
        x = x.mean(dim=1)  # B C
        if self.num_classes > 0:
            x = self.head(x)
        return x

这个程序文件是一个用于图像分类的CSWin Transformer模型。它实现了CSWinBlock和LePEAttention两个模块，并定义了Mlp和Merge_Block两个辅助模块。CSWinBlock模块是CSWin Transformer的基本构建块，它包含了一个多头注意力机制和一个多层感知机，用于处理输入特征。LePEAttention模块是一个特殊的注意力机制，它使用了局部位置编码（Local Position Encoding）来增强注意力的表达能力。Mlp模块是一个多层感知机，用于对输入特征进行非线性变换。Merge_Block模块是一个用于特征融合的模块，它使用了一个卷积层和一个归一化层来将多个分支的特征融合成一个输出特征。整个模型的输入是一个图像，输出是图像的分类结果。

5.6 backbone\EfficientFormerV2.py

import torch
import torch.nn as nn
import torch.nn.functional as F
import math
from typing import Dict
import itertools
import numpy as np
from timm.models.layers import DropPath, trunc_normal_, to_2tuple

class Attention4D(torch.nn.Module):
    def __init__(self, dim=384, key_dim=32, num_heads=8,
                 attn_ratio=4,
                 resolution=7,
                 act_layer=nn.ReLU,
                 stride=None):
        super().__init__()
        self.num_heads = num_heads
        self.scale = key_dim ** -0.5
        self.key_dim = key_dim
        self.nh_kd = nh_kd = key_dim * num_heads

        if stride is not None:
            self.resolution = math.ceil(resolution / stride)
            self.stride_conv = nn.Sequential(nn.Conv2d(dim, dim, kernel_size=3, stride=stride, padding=1, groups=dim),
                                             nn.BatchNorm2d(dim), )
            self.upsample = nn.Upsample(scale_factor=stride, mode='bilinear')
        else:
            self.resolution = resolution
            self.stride_conv = None
            self.upsample = None

        self.N = self.resolution ** 2
        self.N2 = self.N
        self.d = int(attn_ratio * key_dim)
        self.dh = int(attn_ratio * key_dim) * num_heads
        self.attn_ratio = attn_ratio
        h = self.dh + nh_kd * 2
        self.q = nn.Sequential(nn.Conv2d(dim, self.num_heads * self.key_dim, 1),
                               nn.BatchNorm2d(self.num_heads * self.key_dim), )
        self.k = nn.Sequential(nn.Conv2d(dim, self.num_heads * self.key_dim, 1),
                               nn.BatchNorm2d(self.num_heads * self.key_dim), )
        self.v = nn.Sequential(nn.Conv2d(dim, self.num_heads * self.d, 1),
                               nn.BatchNorm2d(self.num_heads * self.d),
                               )
        self.v_local = nn.Sequential(nn.Conv2d(self.num_heads * self.d, self.num_heads * self.d,
                                               kernel_size=3, stride=1, padding=1, groups=self.num_heads * self.d),
                                     nn.BatchNorm2d(self.num_heads * self.d), )
        self.talking_head1 = nn.Conv2d(self.num_heads, self.num_heads, kernel_size=1, stride=1, padding=0)
        self.talking_head2 = nn.Conv2d(self.num_heads, self.num_heads, kernel_size=1, stride=1, padding=0)

        self.proj = nn.Sequential(act_layer(),
                                  nn.Conv2d(self.dh, dim, 1),
                                  nn.BatchNorm2d(dim), )

        points = list(itertools.product(range(self.resolution), range(self.resolution)))
        N = len(points)
        attention_offsets = {}

EfficientFormerV2.py是一个用于图像分类的模型文件。该文件定义了EfficientFormerV2模型的结构和各个组件的实现。

EfficientFormerV2模型是基于EfficientNet和Transformer的结构进行改进的。它包含了一个Embedding模块、多个EfficientFormerBlock模块和一个分类头部。

Embedding模块用于将输入图像进行特征提取和编码。它包含了一个卷积层和一个归一化层。

EfficientFormerBlock模块是EfficientFormerV2模型的核心组件，用于构建多层的Transformer模块。每个EfficientFormerBlock模块包含了多个Attention4D模块和一个MLP模块。

Attention4D模块是一个四维的注意力机制模块，用于捕捉图像特征之间的关系。它包含了多个卷积层和归一化层。

MLP模块是一个多层感知机模块，用于对特征进行非线性变换和映射。

分类头部用于将特征映射到类别概率分布。

整个EfficientFormerV2模型的结构是一个串联的模块序列，其中每个EfficientFormerBlock模块之间使用残差连接进行连接。最后一个EfficientFormerBlock模块的输出经过分类头部进行分类。

EfficientFormerV2模型的输入是一个图像张量，输出是一个类别概率分布张量。

6.系统整体结构

根据以上分析，该程序是一个用于视觉项目中小麦病害检测系统的工程。它包含了多个文件，每个文件都有不同的功能，用于实现整个系统的各个模块和功能。

下面是每个文件的功能的整理：

文件路径	功能
export.py	导出YOLOv8模型为其他格式的文件
predict.py	进行目标检测的预测操作
ui.py	创建图形用户界面，并实现与用户的交互
backbone\convnextv2.py	构建ConvNeXt V2模型
backbone\CSwomTramsformer.py	构建CSWin Transformer模型
backbone\EfficientFormerV2.py	构建EfficientFormerV2模型
backbone\efficientViT.py	构建EfficientViT模型
backbone\fasternet.py	构建FasterNet模型
backbone\lsknet.py	构建LSKNet模型
backbone\repvit.py	构建RepVIT模型
backbone\revcol.py	构建RevCoL模型
backbone\SwinTransformer.py	构建Swin Transformer模型
backbone\VanillaNet.py	构建VanillaNet模型
extra_modules\afpn.py	实现AFPN模块
extra_modules\attention.py	实现注意力机制模块
extra_modules\block.py	实现基本块模块
extra_modules\dynamic_snake_conv.py	实现动态蛇形卷积模块
extra_modules\head.py	实现模型的头部模块
extra_modules\kernel_warehouse.py	存储不同模型的卷积核
extra_modules\orepa.py	实现OREPA模块
extra_modules\rep_block.py	实现REP模块
extra_modules\RFAConv.py	实现RFAConv模块
extra_modules_init_.py	初始化extra_modules模块
extra_modules\ops_dcnv3\setup.py	安装DCNv3模块
extra_modules\ops_dcnv3\test.py	测试DCNv3模块
extra_modules\ops_dcnv3\functions\dcnv3_func.py	实现DCNv3模块的函数
extra_modules\ops_dcnv3\functions_init_.py	初始化DCNv3模块的函数
extra_modules\ops_dcnv3\modules\dcnv3.py	实现DCNv3模块
extra_modules\ops_dcnv3\modules_init_.py	初始化DCNv3模块
models\common.py	包含通用的模型函数和类
models\experimental.py	包含实验性的模型函数和类
models\tf.py	包含TensorFlow模型函数和类
models\yolo.py	包含YOLO模型函数和类
models_init_.py	初始化models模块
utils\activations.py	包含各种激活函数
utils\augmentations.py	包含数据增强函数
utils\autoanchor.py	包含自动锚框生成函数
utils\autobatch.py	包含自动批处理函数
utils\callbacks.py	包含回调函数
utils\datasets.py	包含数据集处理函数
utils\downloads.py	包含下载函数
utils\general.py	包含通用的辅助函数
utils\loss.py	包含损失函数
utils\metrics.py	包含评估指标函数
utils\plots.py	包含绘图函数
utils\torch_utils.py	包含PyTorch的辅助函数
utils_init_.py	初始化utils模块
utils\aws\resume.py	实现AWS的恢复函数
utils\aws_init_.py	初始化AWS模块
utils\flask_rest_api\example_request.py	实现Flask REST API的示例请求
utils\flask_rest_api\restapi.py	实现Flask REST API的功能
utils\loggers_init_.py	初始化log

7.YOLOv8简介

Yolov8网络模型

Yolov8n的网络分为输入端、主干网( Back-bone) 、Neck模块和输出端4个部分（图4)。输
人端主要有马赛克( Mosaic）数据增强、自适应锚框计算和自适应灰度填充。主干网有Conv、C2和SPPF结构，其中，C2r模块是对残差特征进行学习的主要模块，该模块仿照Yolov7的ELAN结构,通过更多的分支跨层连接，丰富了模型的梯度流，可形成一个具有更强特征表示能力的神经网络模
块。Neck模块采用PAN ( path aggregation nelwOrk ,结构，可加强网络对不同缩放尺度对象特征融合的
能力。输出端将分类和检测过程进行解耦，主要包括损失计算和目标检测框筛选，其中，损失计算过程主要包括正负样本分配策略和 Loss计算，Yolov8n 网络主要使用TaskAlignedAssignerl 10]方法，即根据分类与回归的分数加权结果选择正样本;Loss计算包括分类和回归2个分支，无Ob-jecIness分支。分类分支依然采用BCE Loss，回归分支则使用了Distribution Focal Loss!11〕和CIOU( complele inlersection over union)损失函数。

8.可扩张残差（DWR）注意力模块

当前的许多工作直接采用多速率深度扩张卷积从一个输入特征图中同时捕获多尺度上下文信息，从而提高实时语义分割的特征提取效率。 然而，这种设计可能会因为结构和超参数的不合理而导致多尺度上下文信息的访问困难。 为了降低绘制多尺度上下文信息的难度，我们提出了一种高效的多尺度特征提取方法，该方法分解了原始的单步特征提取方法方法分为两个步骤，区域残差-语义残差。 在该方法中，多速率深度扩张卷积在特征提取中发挥更简单的作用：根据第一步提供的每个简明区域形式特征图，在第二步中使用一个所需的感受野执行简单的基于语义的形态过滤 一步，提高他们的效率。 此外，扩张率和扩张卷积的容量每个网络阶段都经过精心设计，以充分利用所有可以实现的区域形式的特征图。 因此，我们分别为高层和低层网络设计了一种新颖的扩张式残差（DWR）模块和简单倒置残差（SIR）模块。

首先，该博客引入了一个Dilation-wise Residual（DWR）模块，用于提取网络高层的特征，如图2a所示。多分支结构用于扩展感受野，其中每个分支采用不同空洞率的空洞深度卷积。
然后，专门设计了一个Simple Inverted Residual（SIR）模块来提取网络低层的特征，如图2b所示。该模块仅具有3×3的微小感受野，但使用inverted bottleneck式结构来扩展通道数量，确保更强的特征提取能力。
最后，基于DWR和SIR模块，构建了一个编码器-解码器风格的网络DWRSeg，其中解码器采用了简单的类似FCN的结构。解码器使用来自最后两个阶段的强语义信息直接对特征图进行上采样，然后将它们与来自较低阶段的特征图（包含丰富的详细信息）拼接起来，以进行最终预测。

9.训练结果可视化分析

评价指标

epoch：训练过程中的epoch号。
train/box_loss、、、train/obj_loss：train/cls_loss训练期间边界框、对象和类预测的损失。
metrics/precision、metrics/recall、metrics/mAP_0.5、metrics/mAP_0.5:0.95：不同 IoU（并集交集）阈值下的精度、召回率和平均精度 (mAP)。
val/box_loss、val/obj_loss、val/cls_loss：边界框、对象和类的验证损失。
x/lr0, x/lr1, x/lr2：网络不同部分的学习率。

训练结果可视化

我将通过为这些指标创建可视化来进行详细分析，以了解模型在训练期间的性能和行为。这将包括损失指标的趋势、精确度、召回率和 mAP 分数的改进，以及学习率在不同时期的变化。让我们首先可视化训练和验证损失。

import matplotlib.pyplot as plt

# Setting up the plots
fig, ax = plt.subplots(3, 1, figsize=(12, 18))

# Plotting training losses
ax[0].plot(data['epoch'], data['train/box_loss'], label='Box Loss', color='blue')
ax[0].plot(data['epoch'], data['train/obj_loss'], label='Object Loss', color='red')
ax[0].plot(data['epoch'], data['train/cls_loss'], label='Class Loss', color='green')
ax[0].set_xlabel('Epoch')
ax[0].set_ylabel('Training Loss')
ax[0].set_title('Training Losses per Epoch')
ax[0].legend()

# Plotting validation losses
ax[1].plot(data['epoch'], data['val/box_loss'], label='Box Loss', color='blue')
ax[1].plot(data['epoch'], data['val/obj_loss'], label='Object Loss', color='red')
ax[1].plot(data['epoch'], data['val/cls_loss'], label='Class Loss', color='green')
ax[1].set_xlabel('Epoch')
ax[1].set_ylabel('Validation Loss')
ax[1].set_title('Validation Losses per Epoch')
ax[1].legend()

# Plotting precision, recall, and mAP
ax[2].plot(data['epoch'], data['metrics/precision'], label='Precision', color='purple')
ax[2].plot(data['epoch'], data['metrics/recall'], label='Recall', color='orange')
ax[2].plot(data['epoch'], data['metrics/mAP_0.5'], label='mAP at 0.5 IoU', color='cyan')
ax[2].plot(data['epoch'], data['metrics/mAP_0.5:0.95'], label='mAP at 0.5:0.95 IoU', color='magenta')
ax[2].set_xlabel('Epoch')
ax[2].set_ylabel('Metrics')
ax[2].set_title('Precision, Recall, and mAP per Epoch')
ax[2].legend()

plt.tight_layout()
plt.show()

每个时期的训练损失：

该图显示了训练过程中框、对象和类损失的趋势。理想情况下，这些应该随着时间的推移而减少，表明学习和收敛。
每个时期的验证损失：

与训练损失类似，这些反映了模型在未见过的数据上的性能。重要的是要看看这些损失是否随着训练损失而减少，这表明具有良好的泛化性。

每个 Epoch 的精度、召回率和 mAP：

精度和召回率是对象检测任务的关键指标，分别表示检测到的对象的准确性和完整性。
不同 IoU 阈值下的平均精度 (mAP) 提供了模型性能的全面视图，结合了精度和召回率方面。
分析和观察：
损失：如果训练和验证损失正在减少，则表明模型正在有效地学习。然而，如果验证损失与训练损失不同，这可能表明过度拟合。
精确率和召回率：这些指标的增长趋势是可取的。精度侧重于模型预测的准确性，而召回率则衡量模型识别所有相关案例的能力。
mAP（平均精度）：这是对象检测任务中的一个关键指标。mAP 跨时代的改进表明，该模型在准确检测具有正确边界框的对象方面变得越来越好。

10.系统整合

下图完整源码＆数据集＆环境部署视频教程＆自定义UI界面

参考博客《【改进YOLOv8】融合可扩张残差（DWR）注意力模块的小麦病害检测系统》

11.参考文献

---

[1]王书献,张胜茂,朱文斌,等.基于深度学习YOLOV5网络模型的金枪鱼延绳钓电子监控系统目标检测应用[J].大连海洋大学学报.2021,(5).DOI:10.16535/j.cnki.dlhyxb.2020-333 .

[2]佚名.Deep neural networks for analysis of fisheries surveillance video and automated monitoring of fish discards[J].ICES Journal of Marine Science.2020,77(4).1340-1353.DOI:10.1093/icesjms/fsz149 .

[3]Aloysius T.M. van Helmond,Lars O. Mortensen,Kristian S. Plet&#x2010,等.Electronic monitoring in fisheries: Lessons from global experiences and future opportunities[J].Fish & Fisheries.2020,21(1).162-189.DOI:10.1111/faf.12425 .

[4]Needle, Coby L.,Dinsdale, Rosanne,Buch, Tanja B.,等.Scottish science applications of Remote Electronic Monitoring[J].ICES journal of marine science.2015,72(4).1214-1229.DOI:10.1093/icesjms/fsu225 .

[5]François Chollet.Xception: Deep Learning with Depthwise Separable Convolutions[C].