devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

YOLOX运行demo及细节理解_yolox demo

作者：花生_TL007 | 2024-06-07 07:33:10

赞

踩

yolox demo

目录

1. 代码结构和流程

2. 网络结构解析

2.1 Backbone-YOLOPAFPN

2.1.1 主干网络CSPDarknet

2.1.1.1 Focus

2.1.1.2 CSPlayer

2.2 head-YOLOXHead

2.3 YOLOX

3. 训练细节

3.1 坐标回归

3.2 正负样本和loss

1. 代码结构和流程

pytorch版yolox代码解析，以yolox-s为例，走一遍demo的运行流程。首先设置命令行参数：

运行demo.py，第一步解析参数，第二步，调用get_exp(), 

get_exp函数根据输入的实验名称或者实验文件描述文件来获取对应网络的Exp对象。类似于paddle里面用的反射机制。我们这里指定了args.name参数为：yolox-s，所以调用get_exp_by_name(exp_name) 

get_exp_by_name(exp_name) 会根据字典里的键值对，找输入的实验名（网络名）对应的python文件。

 

 这些文件都存在：YOLOX\exps\default\ 文件夹下。

 在来看下这个yolox_s.py文件：

里面定义了Exp类，继承自MyExp类，再看看MyExp类：

init函数里面定义了网络结构配置参数，数据加载相关参数 ，网络训练和测试参数等。其他成员函数用来获取网络结构，获取数据加载器，已经其他的处理。

 找到路径下面的py文件之后，根据这个文件来生成对应的Exp对象（疑似反射机制）

然后返回exp（对象，也就是返回了一个网络类的对象。

 

进入main函数，调用exp.get_model()来获取网络结构定义

这里需要调用网络的各个组件的类，YOLOPAFPN，YOLOXHead，然后组成一个完整的网络。

 网络结构获得之后，打印网络结构，加载预训练模型：

 然后，arg.fuse判断是否需要将conv和bn后推理，args.trt判断是否需要做TensorRT后推理。以上两个选项都是用来加速推理的。接下来实例化预测器类：

 

预测器对输入数据进行处理热火调用网络，进行推理，然后可视化最后的预测结果。如果指定了预测结果保存，则会将结果图片保存在

 

这里用yolo3Darknet53的来展示图片，不知道什么原因，还没细看，用yolox-s和yolox-m,yolox-l这三个网络跑出来的demo都没预测出结果。可能是预训练模型加载出错了。

至此，整个demo的流程走完。下面就开始解析几个重点模块。

2. 网络结构解析

2.1 Backbone-YOLOPAFPN

  1. class YOLOPAFPN(nn.Module):
  2.     """
  3.     YOLOv3 model. Darknet 53 is the default backbone of this model.
  4.     """
  5.  
  6.     def __init__(
  7.         self,
  8.         depth=1.0,
  9.         width=1.0,
  10.         in_features=("dark3", "dark4", "dark5"),
  11.         in_channels=[256, 512, 1024],
  12.         depthwise=False,
  13.         act="relu",
  14.     ):
  15.         super().__init__()
  16.         self.backbone = CSPDarknet(depth, width, depthwise=depthwise, act=act)
  17.         self.in_features = in_features
  18.         self.in_channels = in_channels
  19.         Conv = DWConv if depthwise else BaseConv
  20.  
  21.         self.upsample = nn.Upsample(scale_factor=2, mode="nearest")
  22.         self.lateral_conv0 = BaseConv(
  23.             int(in_channels[2] * width), int(in_channels[1] * width), 1, 1, act=act
  24.         )
  25.         self.C3_p4 = CSPLayer(
  26.             int(2 * in_channels[1] * width),
  27.             int(in_channels[1] * width),
  28.             round(3 * depth),
  29.             False,
  30.             depthwise=depthwise,
  31.             act=act,
  32.         )  # cat
  33.  
  34.         self.reduce_conv1 = BaseConv(
  35.             int(in_channels[1] * width), int(in_channels[0] * width), 1, 1, act=act
  36.         )
  37.         self.C3_p3 = CSPLayer(
  38.             int(2 * in_channels[0] * width),
  39.             int(in_channels[0] * width),
  40.             round(3 * depth),
  41.             False,
  42.             depthwise=depthwise,
  43.             act=act,
  44.         )
  45.  
  46.         # bottom-up conv
  47.         self.bu_conv2 = Conv(
  48.             int(in_channels[0] * width), int(in_channels[0] * width), 3, 2, act=act
  49.         )
  50.         self.C3_n3 = CSPLayer(
  51.             int(2 * in_channels[0] * width),
  52.             int(in_channels[1] * width),
  53.             round(3 * depth),
  54.             False,
  55.             depthwise=depthwise,
  56.             act=act,
  57.         )
  58.  
  59.         # bottom-up conv
  60.         self.bu_conv1 = Conv(
  61.             int(in_channels[1] * width), int(in_channels[1] * width), 3, 2, act=act
  62.         )
  63.         self.C3_n4 = CSPLayer(
  64.             int(2 * in_channels[1] * width),
  65.             int(in_channels[2] * width),
  66.             round(3 * depth),
  67.             False,
  68.             depthwise=depthwise,
  69.             act=act,
  70.         )
  71.  
  72.     def forward(self, input):
  73.         """
  74.         Args:
  75.             inputs: input images.
  77.         Returns:
  78.             Tuple[Tensor]: FPN feature.
  79.         """
  80.  
  81.         #  backbone
  82.         out_features = self.backbone(input)
  83.         features = [out_features[f] for f in self.in_features]
  84.         [x2, x1, x0] = features
  85.  
  86.         fpn_out0 = self.lateral_conv0(x0)  # 1024->512/32
  87.         f_out0 = self.upsample(fpn_out0)  # 512/16
  88.         f_out0 = torch.cat([f_out0, x1], 1)  # 512->1024/16
  89.         f_out0 = self.C3_p4(f_out0)  # 1024->512/16
  90.  
  91.         fpn_out1 = self.reduce_conv1(f_out0)  # 512->256/16
  92.         f_out1 = self.upsample(fpn_out1)  # 256/8
  93.         f_out1 = torch.cat([f_out1, x2], 1)  # 256->512/8
  94.         pan_out2 = self.C3_p3(f_out1)  # 512->256/8
  95.  
  96.         p_out1 = self.bu_conv2(pan_out2)  # 256->256/16
  97.         p_out1 = torch.cat([p_out1, fpn_out1], 1)  # 256->512/16
  98.         pan_out1 = self.C3_n3(p_out1)  # 512->512/16
  99.  
  100.         p_out0 = self.bu_conv1(pan_out1)  # 512->512/32
  101.         p_out0 = torch.cat([p_out0, fpn_out0], 1)  # 512->1024/32
  102.         pan_out0 = self.C3_n4(p_out0)  # 1024->1024/32
  103.  
  104.         outputs = (pan_out2, pan_out1, pan_out0)
  105.         return outputs

PA指的是PANet的结构，FPN指的是特征金字塔结构。

backbone-YOLOPAFPN部分网络结构如下图所示：

2.1.1 主干网络CSPDarknet

2.1.1.1 Focus

参考：4、Focus模块-in YOLO - 知乎 (zhihu.com)

代码实现：

  1. class Focus(nn.Module):
  2.     """Focus width and height information into channel space."""
  3.  
  4.     def __init__(self, in_channels, out_channels, ksize=1, stride=1, act="silu"):
  5.         super().__init__()
  6.         self.conv = BaseConv(in_channels * 4, out_channels, ksize, stride, act=act)
  7.  
  8.     def forward(self, x):
  9.         # shape of x (b,c,w,h) -> y(b,4c,w/2,h/2)
  10.         patch_top_left = x[..., ::2, ::2]
  11.         patch_top_right = x[..., ::2, 1::2]
  12.         patch_bot_left = x[..., 1::2, ::2]
  13.         patch_bot_right = x[..., 1::2, 1::2]
  14.         x = torch.cat(
  15.             (
  16.                 patch_top_left,
  17.                 patch_bot_left,
  18.                 patch_top_right,
  19.                 patch_bot_right,
  20.             ),
  21.             dim=1,
  22.         )
  23.         return self.conv(x)

这个模块位于网络backbone(干)的一开始，紧接着数据层，称为stem（茎）。

 这一层具体做了什么，可以先看下代码：

  1. # shape of x (b,c,w,h) -> y(b,4c,w/2,h/2)
  2. patch_top_left = x[..., ::2, ::2]
  3. patch_top_right = x[..., ::2, 1::2]
  4. patch_bot_left = x[..., 1::2, ::2]
  5. patch_bot_right = x[..., 1::2, 1::2]

x就表示输入的图像，维度是（b,c,w,h），实际是（b,3,640,640）,这里四个变量的名字，分别代表 左上，右上，左下，右下，四个小块，因此刚开始误以为是直接把输入图片按照宽高，分成4个部分，每个部分大小为320x320,如下图所示：

 但是仔细看代码发现，这里对输入x的切片是对后面两个维度（w，h）采用了::2和1::2的操作，而这两个操作的含义分别是：

 所以依次看下上面的四个切片操作，可以参考这张图来理解：

（1）patch_top_left = x[..., ::2, ::2]，就是前两维度不变，后面两个维度取偶数下标的对应的值，对于输入的一张3通道的图片，分别取第0,2,4,6,...行（列）的值，对应图中红色像素的值。

（2）patch_top_right = x[..., ::2, 1::2]，表示前两个维度不变，w维度，取第0,2,4,6..行的值，而h维度，取第1,3,5,7,...列的值。对应上图中黄色像素的值。

（3）patch_bot_left = x[..., 1::2, ::2]，表示前两个维度不变，w维度，取第1,3,5,7,...行的值，而h维度，取第0,2,4,6..列的值。对应上图中绿色像素的值。

（4）patch_bot_right = x[..., 1::2, 1::2]，表示前两个维度不变，w维度，取第1,3,5,7,...行的值，而h维度，取第1,3,5,7,...列的值。对应上图中蓝色像素的值。

切片结束后，得到4个3通道的子图，维度为（b,3,320,320），然后按照通道维度拼接起来，得到一个（b,12,320,320）的特征图，再接一个3x3卷积，就构成了整个focus模块。

再回头看下代码里的focus类的注释：

"""Focus width and height information into channel space."""

字面翻译是将宽高信息聚焦到通道空间，通俗理解就是SpaceToDepth，也就是将空间信息转换到通道信息。这里引用一下别人的理解：

1、“Focus的作用无非是使图片在下采样的过程中，不带来信息丢失的情况下，将W、H的信息集中到通道上，再使用3 × 3的卷积对其进行特征提取，使得特征提取得更加的充分。虽然增加了一点点的计算量，但是为后续的特征提取保留了更完整的图片下采样信息”。

2、“Focus模块在v5中是图片进入backbone前，对图片进行切片操作，具体操作是在一张图片中每隔一个像素拿到一个值，类似于邻近下采样，这样就拿到了四张图片，四张图片互补，长的差不多，但是没有信息丢失，这样一来，将W、H信息就集中到了通道空间，输入通道扩充了4倍，即拼接起来的图片相对于原先的RGB三通道模式变成了12个通道，最后将得到的新图片再经过卷积操作，最终得到了没有信息丢失情况下的二倍下采样特征图”。

3、看下原作者的解释

 只是用于减少FLOPS和加速，不用来增加mAP。还有就是用来减少层数，1个Focus层可以替代3个yolo3或yolo4里面的层。

2.1.1.2 CSPlayer

CSPlayer在yolo v4中就已经使用，其论文中的原理如下图：

也就是将输入的特征图，按通道一分为二，分别经过两个分支，最后合并通道。而实际在pytorch的实现中，都是下面这种版本：

 输入通道先按原通达走两个分支，再在各自分支中将输出通道减半（1x1卷积通道降维），最后再合并通道。代码如下所示：

  1. class CSPLayer(nn.Module):
  2.     """C3 in yolov5, CSP Bottleneck with 3 convolutions"""
  3.  
  4.     def __init__(
  5.         self,
  6.         in_channels,
  7.         out_channels,
  8.         n=1,
  9.         shortcut=True,
  10.         expansion=0.5,
  11.         depthwise=False,
  12.         act="silu",
  13.     ):
  14.         """
  15.         Args:
  16.             in_channels (int): input channels.
  17.             out_channels (int): output channels.
  18.             n (int): number of Bottlenecks. Default value: 1.
  19.         """
  20.         # ch_in, ch_out, number, shortcut, groups, expansion
  21.         super().__init__()
  22.         hidden_channels = int(out_channels * expansion)  # hidden channels
  23.         self.conv1 = BaseConv(in_channels, hidden_channels, 1, stride=1, act=act)
  24.         self.conv2 = BaseConv(in_channels, hidden_channels, 1, stride=1, act=act)
  25.         self.conv3 = BaseConv(2 * hidden_channels, out_channels, 1, stride=1, act=act)
  26.         module_list = [
  27.             Bottleneck(
  28.                 hidden_channels, hidden_channels, shortcut, 1.0, depthwise, act=act
  29.             )
  30.             for _ in range(n)
  31.         ]
  32.         self.m = nn.Sequential(*module_list)
  33.  
  34.     def forward(self, x):
  35.         x_1 = self.conv1(x)
  36.         x_2 = self.conv2(x)
  37.         x_1 = self.m(x_1)
  38.         x = torch.cat((x_1, x_2), dim=1)
  39.         return self.conv3(x)

 两个分支中，其中一个分支只有1x1卷积，另外一个分支经过1x1卷积+bottleneck。

2.2 head-YOLOXHead

    YOLO模型的cls，obj和reg都是在同一个卷积层来预测，但其实其它的one-stage检测模型其实都采用decoupled head（这个其实是从RetinaNet开始的，后面的FCOS和ATSS都沿用），即将分类和回归任务分开来预测，因为这个两个任务其实是有冲突的。论文中做的第一个改进就是将YOLO改成了decoupled head，对于输入的FPN特征，首先通过1x1卷积将特征维度降低到256，然后分成两个并行的分支，每个分支包含2个3x3卷积，其中分类分支预测cls，而回归分支预测reg和obj（图中显示的是IoU分支，但实际上从代码来看和原始YOLO一样都是obj，不过按YOLO的本意其实obj里面也包含了定位准确性)。

2.3 YOLOX

3. 训练细节

3.1 坐标回归

网络预测层输出（共3层），每层输出

Output[...,:2]------>tx,ty

Output[...,2:4]---->tw,th

Output[...,4]------->object

Output[...,5:]------>class

坐标基于当前输出层的特征图大小，如80x80,40x40,20x20

Grid 是特征图分辨率大小的矩阵（用meshGrid方法生成），表示特征图的每个点（0-79）。映射回原图，表示将原图切分成一个个的格子，grid坐标映射回去，对应格子的左上角点。

bx,by,bw,bh为网络输出结果转换到特征图上的最终预测结果。tx,ty为相对于特征图中对应grid点的偏移量,tw和th表示特征图尺寸下的宽高，pw和ph是yolo2和yolo3中的anchor映射在特征图尺寸的宽高，这张图是从yolo2拿过来的，因此有很多的anchor，而YOLOX是anchor-free的，或者说是只有一个anchor，且大小为1x1。这里再借助yolov2里面的图来理解。

 用上面的公式转换后就将偏移量转换成了特征图中的坐标值，然后通过乘以缩放倍数将四个值放大获得原图中的x,y,w,h坐标。下图以特征图大小为8x8为示例：

3.2 正负样本和loss

3.2.1 get_in_boxes_info

功能：计算每个anchor的中心（格子的中心点），是否位于gtbox内，以及anchor是否位于gtbox的半径范围内（2.5*stride），最终返回的是候选区域，也就是与gtbox较为接近的anchor，如下图中的非白色区域的anchor（格子）。

图解：

3.2.2 bboxes_iou

计算gtbox和经过第一步筛选出来的anchor索引对应的网络预测结果的IOU,取log作为iou_loss。

然后计算gt和pred_cls的cls_loss，最后将cls_loss和iou_loss作为cost，计算dynamic_k。

cost = (pair_wise_cls_loss

       + 3.0 * pair_wise_ious_loss

       + 100000.0 * (~is_in_boxes_and_center))

3.2.3 dynamic_k_matching

（1）使用IOU确定dynamic_k，取与每个gt的最大的10个IOU。

n_candidate_k = min(10, ious_in_boxes_matrix.size(1))

      topk_ious, _ = torch.topk(ious_in_boxes_matrix, n_candidate_k, dim=1)

      dynamic_ks = torch.clamp(topk_ious.sum(1).int(), min=1)

然后将10个IOU相加，取整数，得到了每个gt对应的dynamic_k,如下如所示：

（2）为每个gt取cost排名最小的前dynamic_k个anchor作为正样本，其余为负样本。

3.2.4 构造target

    由前面3步，可以得到所有认为是正样本的anchor（实际是取对应到的gtbox的索引即可），假如8400个anchor里面有37个是最终得到的正样本，这长度为37的数组中，都是该anchor对应的当前图片中gtbox的类别下标，比如，第1322个anchor与gt[2]匹配，且gt[2]对应类别17，则这个anchor在这个长度为37的数组中为17。如下图所示(这里用了VOC数据集，所以是20类)：

Cls_target的构造：

        取上述正样本对应的类别数组，按照onehot展开成[37,20]的样子，然后再乘以对应的IOU，维度是[37,20]。

Obj_target的构造：

        取正负样本索引的mask(F,F,F,..T,T,F,....),转成float型。维度是[8400,1]。

Reg_target的构造：

        取上述正样本索引，与cls的构造类似，将gtbox的坐标分配给每个匹配的正样本，作为reg_target,维度是[37,4]。

        计算loss时，将每张图片的8400个预测结果按正样本索引mask取出，与上面的target做loss.

除了上述选出来的正样本，剩下的作为负样本，只会对iou_loss和cls_loss起作用，对obj_loss没有作用。

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号