河湖无人机巡检监测基于YOLOv10无人机巡检技术

1import torch
2import torch.nn as nn
3
4class RiverLakeFPN(nn.Module):
5    """
6    针对河湖场景优化的特征金字塔网络
7    """
8    def __init__(self, in_channels_list=[256, 512, 1024]):
9        super(RiverLakeFPN, self).__init__()
10        
11        # 横向连接层
12        self.lateral_convs = nn.ModuleList([
13            nn.Conv2d(ch, 256, 1) for ch in in_channels_list
14        ])
15        
16        # 特征金字塔卷积层
17        self.fpn_convs = nn.ModuleList([
18            nn.Conv2d(256, 256, 3, padding=1) for _ in in_channels_list
19        ])
20        
21        # 高分辨率特征增强层
22        self.high_res_enhance = nn.Sequential(
23            nn.Conv2d(256, 128, 3, padding=1),
24            nn.BatchNorm2d(128),
25            nn.ReLU(inplace=True),
26            nn.Conv2d(128, 256, 3, padding=1)
27        )
28        
29    def forward(self, features):
30        """
31        features: list of feature maps from backbone
32        """
33        # 自上而下处理
34        lateral_features = []
35        for i, feature in enumerate(reversed(features)):
36            lateral_features.append(self.lateral_convs[i](feature))
37        
38        # 特征融合
39        for i in range(len(lateral_features) - 1):
40            upsampled = nn.functional.interpolate(
41                lateral_features[i], 
42                size=lateral_features[i+1].shape[2:], 
43                mode='nearest'
44            )
45            lateral_features[i+1] = lateral_features[i+1] + upsampled
46        
47        # FPN输出
48        fpn_outputs = []
49        for i, lateral in enumerate(lateral_features):
50            fpn_outputs.append(self.fpn_convs[i](lateral))
51        
52        # 高分辨率特征增强
53        fpn_outputs[0] = self.high_res_enhance(fpn_outputs[0])
54        
55        return fpn_outputs

1class ChannelAttention(nn.Module):
2    """
3    通道注意力机制
4    """
5    def __init__(self, channels, reduction=16):
6        super(ChannelAttention, self).__init__()
7        self.avg_pool = nn.AdaptiveAvgPool2d(1)
8        self.fc = nn.Sequential(
9            nn.Linear(channels, channels // reduction, bias=False),
10            nn.ReLU(inplace=True),
11            nn.Linear(channels // reduction, channels, bias=False),
12            nn.Sigmoid()
13        )
14    
15    def forward(self, x):
16        b, c, _, _ = x.size()
17        y = self.avg_pool(x).view(b, c)
18        y = self.fc(y).view(b, c, 1, 1)
19        return x * y.expand_as(x)
20
21class SpatialAttention(nn.Module):
22    """
23    空间注意力机制
24    """
25    def __init__(self, kernel_size=7):
26        super(SpatialAttention, self).__init__()
27        self.conv = nn.Conv2d(2, 1, kernel_size, padding=kernel_size//2, bias=False)
28        self.sigmoid = nn.Sigmoid()
29    
30    def forward(self, x):
31        avg_out = torch.mean(x, dim=1, keepdim=True)
32        max_out, _ = torch.max(x, dim=1, keepdim=True)
33        x_cat = torch.cat([avg_out, max_out], dim=1)
34        x_cat = self.conv(x_cat)
35        return x * self.sigmoid(x_cat).expand_as(x)

1import albumentations as A
2import cv2
3import numpy as np
4
5def river_lake_specific_augmentation():
6    """
7    河湖场景特有数据增强
8    """
9    return A.Compose([
10        # 水面波纹模拟
11        A.RandomRain(brightness_coefficient=0.9, drop_width=1, blur_value=1, p=0.2),
12        # 雾气效果模拟
13        A.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.3, alpha_coef=0.1, p=0.15),
14        # 水面反光模拟
15        A.RandomShadow(num_shadows_lower=1, num_shadows_upper=3, 
16                      shadow_dimension=5, shadow_roi=(0, 0.5, 1, 1), p=0.2),
17        # 常规增强
18        A.HorizontalFlip(p=0.5),
19        A.RandomRotate90(p=0.5),
20        A.RandomBrightnessContrast(p=0.3),
21        A.HueSaturationValue(p=0.3),
22        # 高斯噪声
23        A.GaussNoise(var_limit=(10.0, 50.0), p=0.2),
24    ], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))

1def adaptive_image_enhancement(img):
2    """
3    自适应图像增强处理
4    """
5    # CLAHE增强
6    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
7    
8    # 转换到LAB空间
9    lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
10    l, a, b = cv2.split(lab)
11    
12    # 增强L通道
13    l_enhanced = clahe.apply(l)
14    
15    # 合并
16    lab_enhanced = cv2.merge([l_enhanced, a, b])
17    img_enhanced = cv2.cvtColor(lab_enhanced, cv2.COLOR_LAB2BGR)
18    
19    return img_enhanced

1from ultralytics import YOLO
2
3def train_river_lake_detection_model():
4    """
5    河湖目标检测模型训练配置
6    """
7    model = YOLO('yolov10n.pt')  # 基于YOLOv10
8    
9    results = model.train(
10        data='river_lake_dataset.yaml',
11        epochs=150,
12        imgsz=1280,  # 大尺寸输入以适应小目标
13        batch=8,
14        multi_scale=True,  # 多尺度训练
15        augment=True,
16        # 数据增强参数
17        hsv_h=0.015,
18        hsv_s=0.7,
19        hsv_v=0.4,
20        degrees=10.0,
21        translate=0.1,
22        scale=0.5,
23        shear=2.0,
24        perspective=0.001,
25        flipud=0.0,
26        fliplr=0.5,
27        mosaic=1.0,
28        mixup=0.1,
29        copy_paste=0.1,
30        # 优化器参数
31        lr0=0.01,
32        lrf=0.01,
33        momentum=0.937,
34        weight_decay=0.0005,
35    )
36    
37    return results