基于YOLOv8的农作物病虫害识别系统【开源代码】

Python-牛马博士

1251人浏览 · 2025-12-18 19:10:47

Python-牛马博士 · 2025-12-18 19:10:47 发布

摘要

本文针对复杂农业环境下农作物病虫害检测难度大、实时性要求高等挑战，设计并实现了一种基于改进YOLOv8的轻量级病虫害识别系统。通过引入轻量级主干网络、注意力机制及针对性的数据增强策略，优化模型性能，并实现了从数据采集、模型训练到实际部署的全流程。在自建数据集上的实验表明，该系统在保持高精度的同时，显著提升了检测速度，为田间实时病虫害识别提供了有效解决方案。

一、绪论

1.1 研究背景与意义

农作物病虫害是制约农业生产的主要因素之一，每年导致巨大的经济损失。传统依赖人工经验的检测方法效率低下且主观性强。随着深度学习技术的发展，基于计算机视觉的自动识别技术为病虫害防治提供了新的途径。本研究旨在利用先进的YOLOv8目标检测算法，构建高效、准确的病虫害识别系统，对推动智慧农业发展和保障粮食安全具有重要意义。

1.2 国内外研究现状

近年来，基于深度学习的目标检测算法在农业领域得到广泛应用。早期研究多采用Faster R-CNN等两阶段算法，精度较高但速度较慢。YOLO系列算法因其优异的速度与精度平衡，逐渐成为研究热点。例如，有研究采用YOLOv5进行茶树病害识别，有研究对YOLOv8进行改进，用于小麦叶片病虫害检测，通过轻量化设计和注意力机制提升性能。然而，复杂田间环境下的多尺度、小目标病虫害检测仍是当前研究的难点和重点。

1.3 研究内容与论文结构

本研究主要内容包括：（1）构建一个涵盖多种常见农作物病虫害的图像数据集；（2）对YOLOv8模型进行轻量化和性能优化，使其更适合田间部署；（3）设计并实现一个完整的病虫害识别系统原型。论文结构安排如下：第二章介绍相关技术，第三章详述系统设计与模型改进，第四章展示实验与分析，第五章总结与展望。

二、相关理论与技术

2.1 YOLOv8算法原理

YOLOv8是YOLO系列的最新版本之一，采用无锚框（Anchor-Free）设计，简化了训练过程。其网络结构主要包括骨干网络（Backbone）、颈部网络（Neck）和检测头（Head）。骨干网络负责特征提取，颈部网络进行多尺度特征融合，检测头则完成目标的分类与定位。

2.2 卷积神经网络与注意力机制

卷积神经网络（CNN）是目标检测的基础。注意力机制（如SE、CBAM）通过建模通道间和空间上的依赖关系，让模型更关注图像中的关键信息区域，对于在复杂背景中识别小目标病虫害尤为有效。

2.3 模型轻量化技术

为了在计算资源有限的边缘设备（如无人机、移动终端）上部署模型，常采用模型轻量化技术，如使用深度可分离卷积、轻量级主干网络（如ShuffleNetV2）等来减少模型参数量和计算量。

三、系统设计与模型改进

3.1 系统总体架构

本系统采用端到端的设计，主要包括以下模块：

数据采集与预处理模块：负责图像收集、标注和数据增强。

模型训练与优化模块：核心是改进的YOLOv8模型，完成病虫害的定位与分类。

模型部署与推理模块：将训练好的模型部署到服务器或边缘设备，提供识别服务。

应用交互模块：提供Web界面或API，方便用户上传图像并查看识别结果。

3.2 数据集构建与增强

高质量的数据集是模型性能的保障。数据增强能有效提升模型的泛化能力。以下是一个针对农业场景的数据增强示例：

import albumentations as A
from albumentations.pytorch import ToTensorV2

# 定义训练集的数据增强管道
train_transform = A.Compose([
    A.RandomResizedCrop(640, 640, scale=(0.8, 1.0)), # 随机裁剪缩放，模拟不同拍摄距离
    A.HorizontalFlip(p=0.5),  # 水平翻转
    A.VerticalFlip(p=0.3),    # 垂直翻转
    A.RandomBrightnessContrast(p=0.5), # 随机亮度对比度，模拟不同光照条件
    A.HueSaturationValue(p=0.3), # 色相饱和度调整
    A.GaussNoise(var_limit=(10.0, 50.0), p=0.3), # 高斯噪声，模拟图像传感器噪声
    A.CLAHE(p=0.3), # 限制对比度自适应直方图均衡化
    A.ToGray(p=0.1), # 随机灰度化，增强颜色鲁棒性
    A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), # ImageNet标准归一化
    ToTensorV2(), # 转为Tensor
], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))

# 验证集通常只需基础预处理
val_transform = A.Compose([
    A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
    ToTensorV2(),
], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))

代码说明：通过多种几何和色彩变换，模拟田间多变的拍摄环境，提升模型鲁棒性。验证集无需强烈增强以确保评估的准确性。

3.3 改进的YOLOv8模型设计

针对病虫害检测的难点，对YOLOv8进行以下改进：

3.3.1 轻量化主干网络

采用ShuffleNetV2等轻量级网络替换原版Backbone，大幅减少参数和计算量。

import torch
import torch.nn as nn

# 示例：一个简化的ShuffleNetV2基础模块
class ShuffleNetBlock(nn.Module):
    def __init__(self, inp, oup, stride):
        super(ShuffleNetBlock, self).__init__()
        self.stride = stride
        branch_features = oup // 2
        
        if stride > 1:
            self.branch1 = nn.Sequential(
                nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False),
                nn.BatchNorm2d(inp),
                nn.Conv2d(inp, branch_features, 1, 1, 0, bias=False),
                nn.BatchNorm2d(branch_features),
                nn.ReLU(inplace=True),
            )
        else:
            self.branch1 = nn.Sequential()
            
        self.branch2 = nn.Sequential(
            nn.Conv2d(inp if stride > 1 else branch_features, branch_features, 1, 1, 0, bias=False),
            nn.BatchNorm2d(branch_features),
            nn.ReLU(inplace=True),
            nn.Conv2d(branch_features, branch_features, 3, stride, 1, groups=branch_features, bias=False),
            nn.BatchNorm2d(branch_features),
            nn.Conv2d(branch_features, branch_features, 1, 1, 0, bias=False),
            nn.BatchNorm2d(branch_features),
            nn.ReLU(inplace=True),
        )
    
    def forward(self, x):
        if self.stride == 1:
            x1, x2 = x.chunk(2, dim=1)
            out = torch.cat((x1, self.branch2(x2)), dim=1)
        else:
            out = torch.cat((self.branch1(x), self.branch2(x)), dim=1)
        
        out = self.channel_shuffle(out, 2)
        return out
    
    def channel_shuffle(self, x, groups):
        batchsize, num_channels, height, width = x.data.size()
        channels_per_group = num_channels // groups
        x = x.view(batchsize, groups, channels_per_group, height, width)
        x = torch.transpose(x, 1, 2).contiguous()
        x = x.view(batchsize, -1, height, width)
        return x

代码说明：ShuffleNetV2通过通道分割和通道混洗操作，在保证精度的同时极大减少了计算量，非常适合边缘部署。

3.3.2 注意力机制集成

引入SE（Squeeze-and-Excitation）注意力机制，增强模型对病害区域的关注。

class SEAttention(nn.Module):
    """SE注意力机制模块"""
    def __init__(self, channel, reduction=16):
        super(SEAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel, bias=False),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y.expand_as(x)

# 将SE注意力嵌入到C2f模块中（YOLOv8的核心组件）
class C2f_SE(nn.Module):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__()
        # ... C2f原有结构 ...
        self.att = SEAttention(c2)  # 在输出前加入注意力
    
    def forward(self, x):
        # ... C2f前向传播 ...
        return self.att(output)

代码说明：SE模块通过显式建模通道间的相关性，自适应地校准通道特征响应，使模型更能聚焦于与病害相关的特征通道。

3.4 模型训练与优化

使用Ultralytics库进行模型训练，关键配置如下：

from ultralytics import YOLO

# 加载模型（可以是预训练模型或自定义模型）
model = YOLO('yolov8n.pt')  # 从预训练权重开始

# 开始训练
results = model.train(
    data='path/to/your/data.yaml',  # 数据集配置文件
    epochs=150,
    batch=32,                       # 根据GPU显存调整
    imgsz=640,
    optimizer='AdamW',              # 使用AdamW优化器
    lr0=0.001,                     # 初始学习率
    weight_decay=0.0005,
    augment=True,                   # 开启数据增强
    hsv_h=0.015,                    # 色调扰动幅度
    hsv_s=0.7,                      # 饱和度扰动幅度
    hsv_v=0.4,                      # 亮度扰动幅度
    degrees=10.0,                   # 随机旋转角度
    fliplr=0.5,                     # 水平翻转概率
    mosaic=1.0,                     # Mosaic数据增强概率
    mixup=0.1,                      # MixUp数据增强概率
    copy_paste=0.1,                 # Copy-Paste增强，对小目标有效
    dropout=0.2,                    # 防止过拟合
    cos_lr=True,                    # 使用余弦退火学习率调度
    patience=10,                     # 早停耐心值
    device=0,                       # 使用GPU设备
    workers=4,                       # 数据加载线程数
    project='runs/train',
    name='exp1',
    save=True,
    pretrained=True                 # 使用预训练权重
)

代码说明：合理的超参数设置和丰富的数据增强是模型收敛和性能提升的关键。针对农业图像特点调整HSV增强参数尤为重要。

四、系统实现与实验结果

4.1 系统工作流程

输入：用户通过Web界面或API上传农作物图像。
预处理：图像缩放、归一化等。
模型推理：加载训练好的最优权重，对输入进行前向传播。
后处理：非极大值抑制（NMS）过滤重叠框。
输出：在图像上绘制边界框、类别标签、置信度，并生成检测报告。

4.2 核心推理代码

from ultralytics import YOLO
import cv2
import numpy as np

class DiseaseDetectionSystem:
    def __init__(self, model_path, conf_threshold=0.5):
        self.model = YOLO(model_path)  # 加载训练好的模型
        self.conf_threshold = conf_threshold
        # 假设的类别名称，需与训练时一致
        self.class_names = ['healthy', 'powdery_mildew', 'rust', 'aphid']  

    def predict_image(self, image_path, save_result=True):
        """对单张图像进行预测"""
        # 使用模型进行预测
        results = self.model(image_path, conf=self.conf_threshold, iou=0.5)[0]
        
        detections = []
        if results.boxes is not None:
            for box in results.boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0].cpu().numpy())
                conf = float(box.conf[0].cpu().numpy())
                cls_id = int(box.cls[0].cpu().numpy())
                
                detections.append({
                    'bbox': [x1, y1, x2, y2],
                    'confidence': conf,
                    'class_id': cls_id,
                    'class_name': self.class_names[cls_id]
                })
        
        # 绘制结果
        result_image = self.draw_detections(results.orig_img, detections)
        
        if save_result:
            cv2.imwrite('result.jpg', result_image)
        
        return result_image, detections

    def draw_detections(self, image, detections):
        """在图像上绘制检测框和标签"""
        result_image = image.copy()
        for det in detections:
            x1, y1, x2, y2 = det['bbox']
            conf = det['confidence']
            cls_name = det['class_name']
            
            # 根据类别选择颜色
            color_map = {
                'healthy': (0, 255, 0),    # 绿色-健康
                'powdery_mildew': (0, 0, 255), # 红色-白粉病
                'rust': (0, 165, 255),     # 橙色-锈病
                'aphid': (255, 0, 0)       # 蓝色-蚜虫
            }
            color = color_map.get(cls_name, (255, 255, 255))
            
            # 绘制边界框
            cv2.rectangle(result_image, (x1, y1), (x2, y2), color, 2)
            
            # 绘制标签背景
            label = f'{cls_name}: {conf:.2f}'
            label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)[0]
            cv2.rectangle(result_image, (x1, y1 - label_size[1] - 10), (x1 + label_size[0], y1), color, -1)
            # 绘制标签文字
            cv2.putText(result_image, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)
        return result_image

# 使用示例
if __name__ == "__main__":
    detector = DiseaseDetectionSystem('path/to/your/best.pt')
    result_img, detections = detector.predict_image('test_image.jpg')
    print(f"检测到 {len(detections)} 个目标")
    for det in detections:
        print(f"- {det['class_name']}: 置信度 {det['confidence']:.2f}")

代码说明：该类封装了模型加载、推理和结果可视化的完整流程，可以方便地集成到Web应用或移动端APP中。