YOLO骨干网络优化与创新：从Darknet到动态架构的演进

import torch
import torch.nn as nn

class Darknet53(nn.Module):
    def __init__(self):
        super(Darknet53, self).__init__()
        
        # 初始卷积层
        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(32),
            nn.LeakyReLU(0.1)
        )
        
        # 残差块组
        self.layer1 = self._make_residual_block(32, 64, 1)
        self.layer2 = self._make_residual_block(64, 128, 2)
        self.layer3 = self._make_residual_block(128, 256, 8)
        self.layer4 = self._make_residual_block(256, 512, 8)
        self.layer5 = self._make_residual_block(512, 1024, 4)
    
    def _make_residual_block(self, in_channels, out_channels, num_blocks):
        """创建残差块组"""
        layers = []
        
        # 下采样卷积
        layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False))
        layers.append(nn.BatchNorm2d(out_channels))
        layers.append(nn.LeakyReLU(0.1))
        
        # 残差块
        for _ in range(num_blocks):
            layers.append(self._make_residual_unit(out_channels))
        
        return nn.Sequential(*layers)
    
    def _make_residual_unit(self, channels):
        """创建单个残差块"""
        return nn.Sequential(
            nn.Conv2d(channels, channels//2, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(channels//2),
            nn.LeakyReLU(0.1),
            nn.Conv2d(channels//2, channels, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(channels),
            nn.LeakyReLU(0.1)
        )
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        x = self.layer5(x)
        return x

class CSPDarknet(nn.Module):
    def __init__(self, depth_multiple=1.0, width_multiple=1.0):
        super(CSPDarknet, self).__init__()
        
        # 初始卷积层
        self.stem = nn.Sequential(
            nn.Conv2d(3, int(64 * width_multiple), kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(int(64 * width_multiple)),
            nn.LeakyReLU(0.1)
        )
        
        # CSP模块组
        self.layer1 = self._make_csp_block(int(64 * width_multiple), int(128 * width_multiple), int(3 * depth_multiple))
        self.layer2 = self._make_csp_block(int(128 * width_multiple), int(256 * width_multiple), int(9 * depth_multiple))
        self.layer3 = self._make_csp_block(int(256 * width_multiple), int(512 * width_multiple), int(9 * depth_multiple))
        self.layer4 = self._make_csp_block(int(512 * width_multiple), int(1024 * width_multiple), int(3 * depth_multiple))
    
    def _make_csp_block(self, in_channels, out_channels, num_blocks):
        """创建CSP模块"""
        # 下采样卷积
        downsample_conv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(0.1)
        )
        
        # 跨阶段连接
        split_conv1 = nn.Sequential(
            nn.Conv2d(out_channels, out_channels//2, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(out_channels//2),
            nn.LeakyReLU(0.1)
        )
        
        split_conv2 = nn.Sequential(
            nn.Conv2d(out_channels, out_channels//2, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(out_channels//2),
            nn.LeakyReLU(0.1)
        )
        
        # 残差块组
        residual_blocks = []
        for _ in range(num_blocks):
            residual_blocks.append(self._make_residual_unit(out_channels//2))
        residual_blocks = nn.Sequential(*residual_blocks)
        
        # 融合卷积
        fuse_conv = nn.Sequential(
            nn.Conv2d(out_channels, out_channels, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(0.1)
        )
        
        return nn.Sequential(
            downsample_conv,
            nn.Sequential(
                split_conv1,
                residual_blocks
            ),
            split_conv2,
            fuse_conv
        )
    
    def _make_residual_unit(self, channels):
        """创建单个残差块"""
        return nn.Sequential(
            nn.Conv2d(channels, channels//2, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(channels//2),
            nn.LeakyReLU(0.1),
            nn.Conv2d(channels//2, channels, kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(channels),
            nn.LeakyReLU(0.1)
        )
    
    def forward(self, x):
        x = self.stem(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        return x

class RepVGGBlock(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):
        super(RepVGGBlock, self).__init__()
        
        # 3x3卷积
        self.conv3x3 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=padding, bias=False),
            nn.BatchNorm2d(out_channels)
        )
        
        # 1x1卷积
        self.conv1x1 = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, padding=0, bias=False),
            nn.BatchNorm2d(out_channels)
        )
        
        # 恒等映射（如果输入输出通道数和步长相同）
        self.identity = nn.BatchNorm2d(out_channels) if in_channels == out_channels and stride == 1 else None
        
        self.relu = nn.LeakyReLU(0.1)
    
    def forward(self, x):
        # 训练时使用多分支
        out = self.conv3x3(x)
        out += self.conv1x1(x)
        if self.identity is not None:
            out += self.identity(x)
        out = self.relu(out)
        return out
    
    def rep_params(self):
        """将多分支结构转换为单分支结构"""
        # 合并3x3卷积和1x1卷积的参数
        # 这里简化实现，实际会更复杂
        pass

class RepVGGStyleBackbone(nn.Module):
    def __init__(self, width_multiple=1.0):
        super(RepVGGStyleBackbone, self).__init__()
        
        # 初始卷积层
        self.stem = nn.Sequential(
            nn.Conv2d(3, int(64 * width_multiple), kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(int(64 * width_multiple)),
            nn.LeakyReLU(0.1)
        )
        
        # RepVGG模块组
        self.layer1 = self._make_repvgg_block(int(64 * width_multiple), int(128 * width_multiple), 3, stride=2)
        self.layer2 = self._make_repvgg_block(int(128 * width_multiple), int(256 * width_multiple), 4, stride=2)
        self.layer3 = self._make_repvgg_block(int(256 * width_multiple), int(512 * width_multiple), 6, stride=2)
        self.layer4 = self._make_repvgg_block(int(512 * width_multiple), int(1024 * width_multiple), 3, stride=2)
    
    def _make_repvgg_block(self, in_channels, out_channels, num_blocks, stride=1):
        """创建RepVGG模块组"""
        layers = []
        
        # 第一个模块可能需要下采样
        layers.append(RepVGGBlock(in_channels, out_channels, stride=stride))
        
        # 后续模块
        for _ in range(num_blocks - 1):
            layers.append(RepVGGBlock(out_channels, out_channels))
        
        return nn.Sequential(*layers)
    
    def forward(self, x):
        x = self.stem(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        return x

class ELANBlock(nn.Module):
    def __init__(self, in_channels, out_channels, num_layers=4):
        super(ELANBlock, self).__init__()
        
        self.num_layers = num_layers
        
        # 输入卷积
        self.input_conv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(0.1)
        )
        
        # 卷积层组
        self.conv_layers = nn.ModuleList()
        for i in range(num_layers):
            self.conv_layers.append(nn.Sequential(
                nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),
                nn.BatchNorm2d(out_channels),
                nn.LeakyReLU(0.1)
            ))
        
        # 输出卷积
        self.output_conv = nn.Sequential(
            nn.Conv2d(out_channels * (num_layers + 1), out_channels, kernel_size=1, stride=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(0.1)
        )
    
    def forward(self, x):
        x = self.input_conv(x)
        
        # 保存所有层的输出
        outputs = [x]
        
        # 依次通过卷积层
        for i in range(self.num_layers):
            x = self.conv_layers[i](x)
            outputs.append(x)
        
        # 融合所有输出
        out = torch.cat(outputs, dim=1)
        out = self.output_conv(out)
        
        return out

class ELANBackbone(nn.Module):
    def __init__(self, width_multiple=1.0):
        super(ELANBackbone, self).__init__()
        
        # 初始卷积层
        self.stem = nn.Sequential(
            nn.Conv2d(3, int(64 * width_multiple), kernel_size=3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(int(64 * width_multiple)),
            nn.LeakyReLU(0.1)
        )
        
        # ELAN模块组
        self.layer1 = self._make_elan_block(int(64 * width_multiple), int(128 * width_multiple), 3, stride=2)
        self.layer2 = self._make_elan_block(int(128 * width_multiple), int(256 * width_multiple), 4, stride=2)
        self.layer3 = self._make_elan_block(int(256 * width_multiple), int(512 * width_multiple), 6, stride=2)
        self.layer4 = self._make_elan_block(int(512 * width_multiple), int(1024 * width_multiple), 3, stride=2)
    
    def _make_elan_block(self, in_channels, out_channels, num_blocks, stride=1):
        """创建ELAN模块组"""
        layers = []
        
        # 下采样卷积
        layers.append(nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.LeakyReLU(0.1)
        ))
        
        # ELAN模块
        for _ in range(num_blocks):
            layers.append(ELANBlock(out_channels, out_channels))
        
        return nn.Sequential(*layers)
    
    def forward(self, x):
        x = self.stem(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        return x

class DynamicConv(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):
        super(DynamicConv, self).__init__()
        
        # 卷积层权重
        self.weight = nn.Parameter(torch.randn(out_channels, in_channels, kernel_size, kernel_size))
        
        # 动态调整参数
        self.dynamic_scale = nn.Parameter(torch.ones(1))
        
        # 其他层
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.LeakyReLU(0.1)
    
    def forward(self, x):
        # 根据输入图像动态调整卷积权重
        dynamic_weight = self.weight * self.dynamic_scale
        
        # 卷积操作
        out = nn.functional.conv2d(x, dynamic_weight, stride=1, padding=1)
        out = self.bn(out)
        out = self.relu(out)
        
        return out

class DynamicBackbone(nn.Module):
    def __init__(self, width_multiple=1.0):
        super(DynamicBackbone, self).__init__()
        
        # 初始卷积层
        self.stem = nn.Sequential(
            DynamicConv(3, int(64 * width_multiple)),
            DynamicConv(int(64 * width_multiple), int(64 * width_multiple))
        )
        
        # 动态模块组
        self.layer1 = self._make_dynamic_block(int(64 * width_multiple), int(128 * width_multiple), 3, stride=2)
        self.layer2 = self._make_dynamic_block(int(128 * width_multiple), int(256 * width_multiple), 4, stride=2)
        self.layer3 = self._make_dynamic_block(int(256 * width_multiple), int(512 * width_multiple), 6, stride=2)
        self.layer4 = self._make_dynamic_block(int(512 * width_multiple), int(1024 * width_multiple), 3, stride=2)
        
        # 动态调整控制器
        self.controller = nn.Sequential(
            nn.AdaptiveAvgPool2d(1),
            nn.Flatten(),
            nn.Linear(int(1024 * width_multiple), 128),
            nn.LeakyReLU(0.1),
            nn.Linear(128, 4)  # 控制4个动态模块组
        )
    
    def _make_dynamic_block(self, in_channels, out_channels, num_blocks, stride=1):
        """创建动态模块组"""
        layers = []
        
        # 动态下采样卷积
        layers.append(DynamicConv(in_channels, out_channels, stride=stride))
        
        # 动态残差块
        for _ in range(num_blocks):
            layers.append(self._make_dynamic_residual_unit(out_channels))
        
        return nn.ModuleList(layers)
    
    def _make_dynamic_residual_unit(self, channels):
        """创建动态残差块"""
        return nn.Sequential(
            DynamicConv(channels, channels//2, kernel_size=1, padding=0),
            DynamicConv(channels//2, channels)
        )
    
    def forward(self, x):
        # 初始特征提取
        x = self.stem(x)
        
        # 动态调整各模块组
        control_params = self.controller(x)
        
        # 通过动态模块组
        for i, layer in enumerate(self.layer1):
            x = layer(x) * control_params[0]
        
        for i, layer in enumerate(self.layer2):
            x = layer(x) * control_params[1]
        
        for i, layer in enumerate(self.layer3):
            x = layer(x) * control_params[2]
        
        for i, layer in enumerate(self.layer4):
            x = layer(x) * control_params[3]
        
        return x

import torch
from torchviz import make_dot
from yolov10 import YOLOv10

# 加载模型
model = YOLOv10(weights='yolov10n.pt')

# 准备输入数据
x = torch.randn(1, 3, 640, 640)

# 获取模型输出
output = model.backbone(x)

# 可视化骨干网络
dot = make_dot(output, params=dict(model.backbone.named_parameters()))
dot.render('yolov10_backbone', format='png')

import torch
import time
from yolov5 import YOLOv5
from yolov8 import YOLOv8
from yolov10 import YOLOv10

# 加载模型
models = {
    'YOLOv5 Backbone': YOLOv5(weights='yolov5n.pt').backbone,
    'YOLOv8 Backbone': YOLOv8(weights='yolov8n.pt').backbone,
    'YOLOv10 Backbone': YOLOv10(weights='yolov10n.pt').backbone
}

# 准备测试数据
test_data = torch.randn(1, 3, 640, 640)

# 测试性能
for name, model in models.items():
    model.eval()
    
    # 预热
    with torch.no_grad():
        for _ in range(10):
            model(test_data)
    
    # 测试推理速度
    start_time = time.time()
    with torch.no_grad():
        for _ in range(100):
            output = model(test_data)
    end_time = time.time()
    
    # 计算FPS
    fps = 100 / (end_time - start_time)
    
    # 计算参数量和FLOPs
    params = sum(p.numel() for p in model.parameters()) / 1e6  # 转换为百万
    
    print(f'{name}:')
    print(f'  FPS: {fps:.2f}')
    print(f'  Parameters: {params:.2f} M')
    print()