【YOLOv5/v7改进系列】替换上采样层为转置卷积

已于 2024-06-09 01:36:54 修改
阅读量1k 收藏 21
点赞数 28
分类专栏： YOLO改进指南 文章标签： YOLO python 人工智能 机器学习 目标检测 计算机视觉
于 2024-05-17 19:23:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84870184/article/details/139010981
版权

一、导言

转置卷积，又称为分数步长卷积或错位卷积，在深度学习和图像处理中有以下几个显著优点：

  1. 尺寸上采样：转置卷积最直接的优势在于能够有效地执行上采样操作，即从低分辨率特征图生成高分辨率特征图。这对于诸如语义分割、图像超分辨率和生成模型等任务至关重要，这些任务需要生成与原始输入尺寸匹配的高分辨率输出。

  2. 学习上采样模式：与传统的插值方法（如双线性插值或最近邻插值）不同，转置卷积的上采样过程是可学习的，这意味着网络可以通过训练自动学习最佳的上采样策略。卷积核的参数在训练过程中调整，以适应特定任务的需求，这可能导致更高质量的上采样结果。

  3. 保持感受野：转置卷积能够恢复特征图的空间维度，同时保持特征之间的空间关系，这对于需要精确空间对应的任务（如像素级预测）尤为重要。它允许网络“反向传播”信息，从较粗糙的特征表示恢复到更精细的细节。

  4. 灵活的特征映射：通过调整转置卷积的参数（如卷积核大小、步长和填充），可以灵活控制输出特征图的尺寸，这为设计多尺度特征融合和层级结构提供了便利。

  5. 表达能力：由于转置卷积具有可学习参数，它能够捕捉更复杂的上采样模式，理论上具有更大的表达能力，相比于固定模式的上采样方法，可能在某些任务上获得更好的性能。

  6. 实现逆过程：虽然转置卷积不是卷积运算的严格数学逆，但在某些上下文中，它可以被视为一种近似逆过程，用于恢复或近似原始输入的尺寸和特征分布，这对于某些逆向建模任务有益。

尽管转置卷积在某些应用场景中表现出色，但也存在计算成本较高和可能引入额外噪声（由于学习过程中可能出现的不稳定性）的缺点，因此在实际应用中，选择转置卷积还是传统上采样方法需要根据具体任务需求权衡。

需要注意的是，转置卷积也是一种卷积。同时，它常常被用于上采样操作。

附、示例代码

以下是一个示例的转置卷积应用代码：

import torch
import torchvision
from torchvision import transforms
from PIL import Image
import matplotlib.pyplot as plt

# 加载并预处理图像
def load_image(image_path):
    img = Image.open(image_path).convert('RGB')
    transform = transforms.Compose([
        transforms.Resize((256, 256)),  # 将图像调整到一个适合的尺寸
        transforms.ToTensor(),          # 转换为Tensor
    ])
    return transform(img)

# 定义转置卷积层
class TransposedConvolution(torch.nn.Module):
    def __init__(self):
        super(TransposedConvolution, self).__init__()
        self.conv_transpose = torch.nn.ConvTranspose2d(in_channels=3, out_channels=3, 
                                                   kernel_size=4, stride=2, padding=1, bias=False)

    def forward(self, x):
        return self.conv_transpose(x)

# 主程序
def main():
    # 加载图像
    img_tensor = load_image('test.jpg')
    img_tensor.unsqueeze_(0)  # 添加批次维度

    # 创建转置卷积实例
    conv_transpose = TransposedConvolution()

    # 应用转置卷积
    output_tensor = conv_transpose(img_tensor)
    
    # 显示原图和转置卷积后的图像
    plt.figure(figsize=(10, 5))
    plt.subplot(1, 2, 1)
    plt.imshow(transforms.ToPILImage()(img_tensor.squeeze()))
    plt.title('Original Image')
    plt.axis('off')

    plt.subplot(1, 2, 2)
    plt.imshow(transforms.ToPILImage()(output_tensor.squeeze().clamp(0, 1)))
    plt.title('After Transposed Convolution')
    plt.axis('off')

    plt.show()

if __name__ == '__main__':
    main()

运行该代码后，返回的图像如图所示：

二、准备工作

在YOLOv5/v7源文件下的models/yolo.py改进如下区域：

同时，此处YOLOv7或许不需要，YOLOv5必须需要：

            elif m is nn.ConvTranspose2d:
                if len(args) >= 7:
                    args[6] = make_divisible(args[6] * gw, 8)

本文下文改进的参数不一定选择这个，根据文档还可以选择自己需要的参数等。

三、YOLOv7-tiny改进工作

完成二后，在YOLOv7项目文件下的models文件夹下创建新的文件yolov7-tiny-transposedconv.yaml，导入如下代码。

# parameters
nc: 80  # number of classes
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple

# anchors
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# yolov7-tiny backbone
backbone:
  # [from, number, module, args] c2, k=1, s=1, p=None, g=1, act=True
  [[-1, 1, Conv, [32, 3, 2, None, 1, nn.LeakyReLU(0.1)]],  # 0-P1/2  
  
   [-1, 1, Conv, [64, 3, 2, None, 1, nn.LeakyReLU(0.1)]],  # 1-P2/4    
   
   [-1, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 7
   
   [-1, 1, MP, []],  # 8-P3/8
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 14
   
   [-1, 1, MP, []],  # 15-P4/16
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 21
   
   [-1, 1, MP, []],  # 22-P5/32
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [512, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 28
  ]

# yolov7-tiny head
head:
  [[-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, SP, [5]],
   [-2, 1, SP, [9]],
   [-3, 1, SP, [13]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -7], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 37
  
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.ConvTranspose2d, [128, 2, 2, 0, 0, 128]],
   [21, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]], # route backbone P4
   [[-1, -2], 1, Concat, [1]],
   
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 47
  
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, nn.ConvTranspose2d, [64, 2, 2, 0, 0, 64]],
   [14, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]], # route backbone P3
   [[-1, -2], 1, Concat, [1]],
   
   [-1, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [32, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [32, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 57
   
   [-1, 1, Conv, [128, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 47], 1, Concat, [1]],
   
   [-1, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [64, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [64, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 65
   
   [-1, 1, Conv, [256, 3, 2, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, 37], 1, Concat, [1]],
   
   [-1, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-2, 1, Conv, [128, 1, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [-1, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [[-1, -2, -3, -4], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1, None, 1, nn.LeakyReLU(0.1)]],  # 73
      
   [57, 1, Conv, [128, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [65, 1, Conv, [256, 3, 1, None, 1, nn.LeakyReLU(0.1)]],
   [73, 1, Conv, [512, 3, 1, None, 1, nn.LeakyReLU(0.1)]],

   [[74,75,76], 1, IDetect, [nc, anchors]],   # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1       928  models.common.Conv                      [3, 32, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
  1                -1  1     18560  models.common.Conv                      [32, 64, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
  2                -1  1      2112  models.common.Conv                      [64, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  3                -2  1      2112  models.common.Conv                      [64, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  4                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  5                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  6  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
  7                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
  8                -1  1         0  models.common.MP                        []                            
  9                -1  1      4224  models.common.Conv                      [64, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 10                -2  1      4224  models.common.Conv                      [64, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 11                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 12                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 13  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 14                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 15                -1  1         0  models.common.MP                        []                            
 16                -1  1     16640  models.common.Conv                      [128, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 17                -2  1     16640  models.common.Conv                      [128, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 19                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 20  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 21                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 22                -1  1         0  models.common.MP                        []                            
 23                -1  1     66048  models.common.Conv                      [256, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 24                -2  1     66048  models.common.Conv                      [256, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 25                -1  1    590336  models.common.Conv                      [256, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 26                -1  1    590336  models.common.Conv                      [256, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 27  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 28                -1  1    525312  models.common.Conv                      [1024, 512, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 29                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 30                -2  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 31                -1  1         0  models.common.SP                        [5]                           
 32                -2  1         0  models.common.SP                        [9]                           
 33                -3  1         0  models.common.SP                        [13]                          
 34  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 35                -1  1    262656  models.common.Conv                      [1024, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 36          [-1, -7]  1         0  models.common.Concat                    [1]                           
 37                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 38                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 39                -1  1       640  torch.nn.modules.conv.ConvTranspose2d   [128, 128, 2, 2, 0, 0, 128]   
 40                21  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 41          [-1, -2]  1         0  models.common.Concat                    [1]                           
 42                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 43                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 44                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 45                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 46  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 47                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 48                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 49                -1  1       320  torch.nn.modules.conv.ConvTranspose2d   [64, 64, 2, 2, 0, 0, 64]      
 50                14  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 51          [-1, -2]  1         0  models.common.Concat                    [1]                           
 52                -1  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 53                -2  1      4160  models.common.Conv                      [128, 32, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 54                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 55                -1  1      9280  models.common.Conv                      [32, 32, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 56  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 57                -1  1      8320  models.common.Conv                      [128, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 58                -1  1     73984  models.common.Conv                      [64, 128, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 59          [-1, 47]  1         0  models.common.Concat                    [1]                           
 60                -1  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 61                -2  1     16512  models.common.Conv                      [256, 64, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 62                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 63                -1  1     36992  models.common.Conv                      [64, 64, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 64  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 65                -1  1     33024  models.common.Conv                      [256, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 66                -1  1    295424  models.common.Conv                      [128, 256, 3, 2, None, 1, LeakyReLU(negative_slope=0.1)]
 67          [-1, 37]  1         0  models.common.Concat                    [1]                           
 68                -1  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 69                -2  1     65792  models.common.Conv                      [512, 128, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 70                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 71                -1  1    147712  models.common.Conv                      [128, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 72  [-1, -2, -3, -4]  1         0  models.common.Concat                    [1]                           
 73                -1  1    131584  models.common.Conv                      [512, 256, 1, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 74                57  1     73984  models.common.Conv                      [64, 128, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 75                65  1    295424  models.common.Conv                      [128, 256, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 76                73  1   1180672  models.common.Conv                      [256, 512, 3, 1, None, 1, LeakyReLU(negative_slope=0.1)]
 77      [74, 75, 76]  1     17132  models.yolo.IDetect                     [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]

Model Summary: 263 layers, 6015948 parameters, 6015948 gradients, 13.2 GFLOPS

运行后若打印出如上文本代表改进成功。

四、YOLOv5s改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov5s-transposedconv.yaml，导入如下代码。

# Parameters
nc: 1  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.ConvTranspose2d, [512, 2, 2, 0, 0, 512]],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.ConvTranspose2d, [256, 2, 2, 0, 0, 256]],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]


                 from  n    params  module                                  arguments                     
  0                -1  1      3520  models.common.Conv                      [3, 32, 6, 2, 2]              
  1                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                
  2                -1  1     18816  models.common.C3                        [64, 64, 1]                   
  3                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  4                -1  2    115712  models.common.C3                        [128, 128, 2]                 
  5                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              
  6                -1  3    625152  models.common.C3                        [256, 256, 3]                 
  7                -1  1   1180672  models.common.Conv                      [256, 512, 3, 2]              
  8                -1  1   1182720  models.common.C3                        [512, 512, 1]                 
  9                -1  1    656896  models.common.SPPF                      [512, 512, 5]                 
 10                -1  1    131584  models.common.Conv                      [512, 256, 1, 1]              
 11                -1  1      1280  torch.nn.modules.conv.ConvTranspose2d   [256, 256, 2, 2, 0, 0, 256]   
 12           [-1, 6]  1         0  models.common.Concat                    [1]                           
 13                -1  1    361984  models.common.C3                        [512, 256, 1, False]          
 14                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              
 15                -1  1       640  torch.nn.modules.conv.ConvTranspose2d   [128, 128, 2, 2, 0, 0, 128]   
 16           [-1, 4]  1         0  models.common.Concat                    [1]                           
 17                -1  1     90880  models.common.C3                        [256, 128, 1, False]          
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 21                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1   1182720  models.common.C3                        [512, 512, 1, False]          
 24      [17, 20, 23]  1     16182  models.yolo.Detect                      [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]

Model Summary: 270 layers, 7024246 parameters, 7024246 gradients, 16.0 GFLOPs

运行后若打印出如上文本代表改进成功。

五、YOLOv5n改进工作

完成二后，在YOLOv5项目文件下的models文件夹下创建新的文件yolov5n-transposedconv.yaml，导入如下代码。

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [64, 6, 2, 2]],  # 0-P1/2
   [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
   [-1, 3, C3, [128]],
   [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
   [-1, 6, C3, [256]],
   [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
   [-1, 9, C3, [512]],
   [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
   [-1, 3, C3, [1024]],
   [-1, 1, SPPF, [1024, 5]],  # 9
  ]

# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.ConvTranspose2d, [512, 2, 2, 0, 0, 512]],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.ConvTranspose2d, [256, 2, 2, 0, 0, 256]],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

                 from  n    params  module                                  arguments                     
  0                -1  1      1760  models.common.Conv                      [3, 16, 6, 2, 2]              
  1                -1  1      4672  models.common.Conv                      [16, 32, 3, 2]                
  2                -1  1      4800  models.common.C3                        [32, 32, 1]                   
  3                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                
  4                -1  2     29184  models.common.C3                        [64, 64, 2]                   
  5                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  6                -1  3    156928  models.common.C3                        [128, 128, 3]                 
  7                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              
  8                -1  1    296448  models.common.C3                        [256, 256, 1]                 
  9                -1  1    164608  models.common.SPPF                      [256, 256, 5]                 
 10                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              
 11                -1  1       640  torch.nn.modules.conv.ConvTranspose2d   [128, 128, 2, 2, 0, 0, 128]   
 12           [-1, 6]  1         0  models.common.Concat                    [1]                           
 13                -1  1     90880  models.common.C3                        [256, 128, 1, False]          
 14                -1  1      8320  models.common.Conv                      [128, 64, 1, 1]               
 15                -1  1       320  torch.nn.modules.conv.ConvTranspose2d   [64, 64, 2, 2, 0, 0, 64]      
 16           [-1, 4]  1         0  models.common.Concat                    [1]                           
 17                -1  1     22912  models.common.C3                        [128, 64, 1, False]           
 18                -1  1     36992  models.common.Conv                      [64, 64, 3, 2]                
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1     74496  models.common.C3                        [128, 128, 1, False]          
 21                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 24      [17, 20, 23]  1      8118  models.yolo.Detect                      [1, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [64, 128, 256]]

Model Summary: 270 layers, 1766230 parameters, 1766230 gradients, 4.2 GFLOPs

运行后打印如上代码说明改进成功。

更多文章产出中，主打简洁和准确，欢迎关注我，共同探讨！

拿下Nahida
关注
  • 28
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
改进YOLO系列：YOLOv5结合转置卷积，实现小目标涨点
qq_44224801的博客
04-06 1446
该函数是用来进行转置卷积的，它主要做了这几件事：首先，对输入的feature map进行padding操作，得到新的feature map；然后，随机初始化一定尺寸的卷积核；最后，用随机初始化的一定尺寸的卷积核在新的feature map上进行卷积操作。补充一下，卷积核确实是随机初始的，但是后续可以对卷积核进行单独的修改，比如使用双线性卷积核，这样的话卷积核的参数是固定的，不可以进行学习修改。下面对上面的过程进行演示。
特征融合篇 | YOLOv5/v7 更换上采样方式 | 最近邻 / 双线性 / 双立方 / 三线性 / 转置卷积
YOLOv8项目贡献者
06-22 1万+
YOLOv5/v7 更换上采样方式 | 最近邻 / 双线性 / 双立方 / 三线性 / 转置卷积
【目标检测实验系列】YOLOv5创新点改进实验：通过转置卷积，动态学习参数，减少上采用过程特征丢失，提高模型对目标的检测精度！（超详细改进代码流程）
弗兰-随风小欢的博客
12-03 1677
【目标检测实验系列】YOLOv5创新点改进实验：通过转置卷积，动态学习参数，减少上采用过程特征丢失，提高模型对目标的检测精度！（超详细改进代码流程）
Yolov5更换上采样方式( 最近邻 / 双线性 / 双立方 / 三线性 / 转置卷积)
@bangbang的博客
06-07 2679
l 1.2. 双线性插值(Bi-Linear interpolation) 1.3. 双立方插值(Bi-Cubic interpolation) 1.4 三线性插值(Trilinear Interpolation) 当align_corners = True时，线性插值模式(线性、双线性、双三线性和三线性)不按比例对齐输出和输入像素，因此输出值可以依赖于输入的大小 这里我将原本的最近邻插值的上采样方式替换为转置卷积；有人
YOLOv7改进：RefConv | 即插即用重参数化重聚焦卷积替代常规卷积，无额外推理成本下涨点明显
m0_51530640的博客
11-11 810
​我们提出了重新参数化的重聚焦卷积（RefConv）作为常规卷积层的替代品，常规卷积层是一个即插即用的模块，可以在不需要任何推理成本的情况下提高性能。具体来说，给定一个预先训练的模型，RefConv对从预先训练的模型继承的基核应用一个可训练的重新聚焦转换，以建立参数之间的连接。例如，一个深度级的RefConv可以将卷积核的一个特定通道的参数与另一个核的参数联系起来，也就是说，使它们重新关注它们从未关注过的模型的其他部分，而不是只关注输入特性。
yolov5/v7 车牌数据集
11-17
yolov5/v7 车牌数据集
可用于YOLOv5/v6/v7/v8训练的农作物杂草数据集
10-21
可用于YOLOv5/v6/v7/v8训练的农作物杂草数据集
真实场景下煤矸石目标检测数据集，可直接用于YOLOv5/v6/v7/v8训练
最新发布
03-18
真实场景下采集的煤矸石训练数据集：891...煤炭mAP@.5：0.896 矸石mAP@.5：0.811 煤炭和矸石的混合物mAP@.5：0.919 可见博客：https://blog.csdn.net/m0_51004308/article/details/136811369?spm=1001.2014.3001.5502
基于yolov5的戴口罩检测系统
06-02
yolov5口罩检测，数据集训练结果，包含训练好的权重文件和各种训练曲线图，保存在runs/train文件夹中，附有代码和检测结果以及测试数据集，类别为戴口罩：face_mask 和不戴口罩。
基于YOLOv5-v7用于SpireVision SDK训练（源码+说明文档）.rar
04-15
1、资源内容：基于YOLOv5-v7用于SpireVision SDK训练（完整源码+说明文档+数据）.rar 2、代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 3、适用对象：计算机，电子信息工程、数学等专业的...
YOLOV5/V7/V8改进：添加CARAFE: 轻量级通用上采样算子
m0_51530640的博客
04-22 2848
特征上采样是许多现代卷积网络体系结构中的一个关键操作，例如特征金字塔。它的设计对于目标检测和语义/实例分割等密集的预测任务至关重要。在这项工作中，我们提出了内容感知的特征重组（CARAFE），一个通用的、轻量级的和高效的操作符来实现这一目标。CARAFE有几个吸引人的特性： (1)大视野。与以前只利用亚像素邻域的工作（例如双线性插值）不同，CARAFE可以在一个大的接受域内聚合上下文信息。(2)具有内容感知的处理。
学习记录09：快速上手简单改进yolov5目标检测网络
我的鱼呀的博客
01-20 4001
简单快速上手修改4层yolov5，以及添加注意力，希望这里能教会你如何运用，授人以鱼不如授人以渔。
YOLOv5/v7/v8 的改进点合集导航页
热门推荐
YOLOv8项目贡献者
05-17 3万+
🚀🚀🚀YOLOv5/v7/v8 的改进点合集导航页🚀🚀🚀
YOLOv5、v7改进之二十七：解决小目标问题——校正卷积取代特征提取网络中的常规卷积
m0_70388905的博客
09-21 9756
作为当前先进的深度学习目标检测算法YOLOv5、v7系列算法，已经集合了大量的trick，但是在处理一些复杂背景问题的时候，还是容易出现错漏检的问题。此后的系列文章，将重点对YOLO系列算法的如何改进进行详细的介绍，目的是为了给那些搞科研的同学需要创新点或者搞工程项目的朋友需要达到更好的效果提供自己的微薄帮助和参考。系列改进算法不仅仅是可以添加进YOLOv5，也可以添加进任何其他的深度学习网络，不管是分类还是检测还是分割，主要是计算机视觉领域，都可能会有不同程度的提升效果。有效果有提升的情况占大多数。
目标检测算法——YOLOv5/YOLOv7改进之结合ConvNeXt结构（纯卷积|超越Swin）
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
10-19 1万+
深度学习Tricks，第一时间送达。纯卷积主干网络！可与大火的分层视觉Transformer竞争！多个任务性能超越Swin！
CSDN芒果独家原创YOLOv5改进、YOLOv7改进（适用YOLOv8改进）专栏 | 《芒果YOLO改进系列进阶指南》来自人工智能专家老师联袂推荐专栏
包括YOLOv5、YOLOv7、YOLOv8等模型改进
09-29 9527
芒果改进YOLO进阶指南，更快的改进YOLO模型
YOLOv5的Tricks | 【Trick4】参数重结构化（融合Conv+BatchNorm2d）
Clichong
06-02 3179
如有错误，恳请指出。这篇文章是想要记录yolov5在模型搭建过程中的一个融合模块，就是把卷积与批归一化的参数进行融合，想卷积带有批归一化的性质，使得推理过程中可以加快模型推理速度，简化整个模型结构，实现训练与推理两个阶段的解耦。我最早接触参数重结构化这个词是看见了大佬丁霄汉发表的几篇论文：RepVGG，RepMLP，RepLKNet，这些构建新backbone的论文无一例外的全部使用了参数重结构化的思想。RepVGG将3x3,1x1，identity分支的残差结果利用数学计算方法等价为一个3x3的卷积结构，
yolov5 加入可形变卷积
shuaijieer的博客
08-09 5972
找到parse_model函数，把DCNConv加入进去。修改yolov5s.yaml文件。修改common.py 文件。运行下面命令查看网络结构。修改yolo.p文件。
yolov5的上采样层改为反卷积层
qiumokucao的博客
12-22 4502
对于有的硬件不支持上采样层的，可以将上采样层改为反卷积层。 修改配置文件： # parameters nc: 80 # number of classes depth_multiple: 0.33 # model depth multiple width_multiple: 0.50 # layer channel multiple # anchors anchors: - [10,13, 16,30, 33,23] # P3/8 - [30,61, 62,45, 59,119]
yolo spd卷积
10-09
YOLO-SPD卷积是一种通用物体检测算法中使用的一种卷积操作。该算法的核心是在传统的卷积操作基础上，引入了空间金字塔池化操作。 YOLO-SPD卷积在输入特征图上运行，通过划分不同大小的网格来捕捉不同尺度的物体。每个网格单元都有多个输出通道，用于预测不同种类的物体。 与传统的卷积操作相比，YOLO-SPD卷积主要引入了两个新的操作：空间金字塔池化和通道分解。 首先，空间金字塔池化将每个网格单元分别进行不同尺度的池化操作。通过这种操作，YOLO-SPD可以更好地捕捉不同大小物体的空间信息。 其次，通道分解操作对每个输出通道进行分解，以增加网络的灵活性。通过通道分解，YOLO-SPD可以对每个物体类别进行更准确的预测。 总之，YOLO-SPD卷积是一种基于空间金字塔池化和通道分解的卷积操作。它在物体检测任务中的应用可以提高模型的准确性和鲁棒性，使得算法能够有效地检测到不同尺度和种类的物体。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值