• YOLOv9独家改进|动态蛇形卷积Dynamic Snake Convolution与RepNCSPELAN4融合

    专栏介绍：YOLOv9改进系列 | 包含深度学习最新创新，主力高效涨点！！！

    一、改进点介绍

            Dynamic Snake Convolution是一种针对细长微弱的局部结构特征与复杂多变的全局形态特征设计的卷积模块。

            RepNCSPELAN4是YOLOv9中的特征提取模块，类似YOLOv5和v8中的C2f与C3模块。

    二、RepNCSPELAN4Dynamic模块详解

     2.1 模块简介

           RepNCSPELAN4Dynamic的主要思想：  使用Dynamic Snake Convolution与RepNCSPELAN4中融合。

    三、 RepNCSPELAN4Dynamic模块使用教程

    3.1 RepNCSPELAN4Dynamic模块的代码

    1. class RepNBottleneck_DySnakeConv(RepNBottleneck):
    2.     # Standard bottleneck
    3.     def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):  # ch_in, ch_out, shortcut, kernels, groups, expand
    4.         super().__init__(c1, c2, shortcut, g, k, e)
    5.         c_ = int(c2 * e)  # hidden channels
    6.         self.cv1 = RepConvN(c1, c_, k[0], 1)
    7.         self.cv2 = Conv(c_, c2, k[1], s=1, g=g)
    8.         self.add = shortcut and c1 == c2
    9.  
    10.  
    11. class RepNCSP_DySnakeConv(RepNCSP):
    12.     # CSP Bottleneck with 3 convolutions
    13.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
    14.         super().__init__(c1, c2, n, shortcut, g, e)
    15.         c_ = int(c2 * e)  # hidden channels
    16.         self.cv1 = DySnakeConv(c1, c_)
    17.         self.cv2 = DySnakeConv(c1, c_)
    18.         self.cv3 = DySnakeConv(2 * c_, c2)  # optional act=FReLU(c2)
    19.         self.m = nn.Sequential(*(RepNBottleneck_DySnakeConv(c_, c_, shortcut, g, e=1.0) for _ in range(n)))
    20.  
    21. class RepNCSPELAN4DySnakeConv(RepNCSPELAN4):
    22.     # csp-elan
    23.     def __init__(self, c1, c2, c3, c4, c5=1):  # ch_in, ch_out, number, shortcut, groups, expansion
    24.         super().__init__(c1, c2, c3, c4, c5)
    25.         self.cv1 = Conv(c1, c3, k=1, s=1)
    26.         self.cv2 = nn.Sequential(RepNCSP_DySnakeConv(c3 // 2, c4, c5), DySnakeConv(c4, c4, 3))
    27.         self.cv3 = nn.Sequential(RepNCSP_DySnakeConv(c4, c4, c5), DySnakeConv(c4, c4, 3))
    28.         self.cv4 = Conv(c3 + (2 * c4), c2, 1, 1)
    29.  
    30. class DySnakeConv(nn.Module):
    31.     def __init__(self, inc, ouc, k=3) -> None:
    32.         super().__init__()
    33.  
    34.         self.conv_0 = Conv(inc, ouc, k)
    35.         self.conv_x = DSConv(inc, ouc, 0, k)
    36.         self.conv_y = DSConv(inc, ouc, 1, k)
    37.  
    38.     def forward(self, x):
    39.         return torch.cat([self.conv_0(x), self.conv_x(x), self.conv_y(x)], dim=1)
    40.  
    41.  
    42. class DSConv(nn.Module):
    43.     def __init__(self, in_ch, out_ch, morph, kernel_size=3, if_offset=True, extend_scope=1):
    44.         """
    45.         The Dynamic Snake Convolution
    46.         :param in_ch: input channel
    47.         :param out_ch: output channel
    48.         :param kernel_size: the size of kernel
    49.         :param extend_scope: the range to expand (default 1 for this method)
    50.         :param morph: the morphology of the convolution kernel is mainly divided into two types
    51.                         along the x-axis (0) and the y-axis (1) (see the paper for details)
    52.         :param if_offset: whether deformation is required, if it is False, it is the standard convolution kernel
    53.         """
    54.         super(DSConv, self).__init__()
    55.         # use the  to learn the deformable offset
    56.         self.offset_conv = nn.Conv2d(in_ch, 2 * kernel_size, 3, padding=1)
    57.         self.bn = nn.BatchNorm2d(2 * kernel_size)
    58.         self.kernel_size = kernel_size
    59.  
    60.         # two types of the DSConv (along x-axis and y-axis)
    61.         self.dsc_conv_x = nn.Conv2d(
    62.             in_ch,
    63.             out_ch,
    64.             kernel_size=(kernel_size, 1),
    65.             stride=(kernel_size, 1),
    66.             padding=0,
    67.         )
    68.         self.dsc_conv_y = nn.Conv2d(
    69.             in_ch,
    70.             out_ch,
    71.             kernel_size=(1, kernel_size),
    72.             stride=(1, kernel_size),
    73.             padding=0,
    74.         )
    75.  
    76.         self.gn = nn.GroupNorm(out_ch // 4, out_ch)
    77.         self.act = Conv.default_act
    78.  
    79.         self.extend_scope = extend_scope
    80.         self.morph = morph
    81.         self.if_offset = if_offset
    82.  
    83.     def forward(self, f):
    84.         offset = self.offset_conv(f)
    85.         offset = self.bn(offset)
    86.         # We need a range of deformation between -1 and 1 to mimic the snake's swing
    87.         offset = torch.tanh(offset)
    88.         input_shape = f.shape
    89.         dsc = DSC(input_shape, self.kernel_size, self.extend_scope, self.morph)
    90.         deformed_feature = dsc.deform_conv(f, offset, self.if_offset)
    91.         if self.morph == 0:
    92.             x = self.dsc_conv_x(deformed_feature.type(f.dtype))
    93.             x = self.gn(x)
    94.             x = self.act(x)
    95.             return x
    96.         else:
    97.             x = self.dsc_conv_y(deformed_feature.type(f.dtype))
    98.             x = self.gn(x)
    99.             x = self.act(x)
    100.             return x
    101.  
    102.  
    103. # Core code, for ease of understanding, we mark the dimensions of input and output next to the code
    104. class DSC(object):
    105.     def __init__(self, input_shape, kernel_size, extend_scope, morph):
    106.         self.num_points = kernel_size
    107.         self.width = input_shape[2]
    108.         self.height = input_shape[3]
    109.         self.morph = morph
    110.         self.extend_scope = extend_scope  # offset (-1 ~ 1) * extend_scope
    111.  
    112.         # define feature map shape
    113.         """
    114.         B: Batch size  C: Channel  W: Width  H: Height
    115.         """
    116.         self.num_batch = input_shape[0]
    117.         self.num_channels = input_shape[1]
    118.  
    119.     """
    120.     input: offset [B,2*K,W,H]  K: Kernel size (2*K: 2D image, deformation contains  and )
    121.     output_x: [B,1,W,K*H]   coordinate map
    122.     output_y: [B,1,K*W,H]   coordinate map
    123.     """
    124.  
    125.     def _coordinate_map_3D(self, offset, if_offset):
    126.         device = offset.device
    127.         # offset
    128.         y_offset, x_offset = torch.split(offset, self.num_points, dim=1)
    129.  
    130.         y_center = torch.arange(0, self.width).repeat([self.height])
    131.         y_center = y_center.reshape(self.height, self.width)
    132.         y_center = y_center.permute(1, 0)
    133.         y_center = y_center.reshape([-1, self.width, self.height])
    134.         y_center = y_center.repeat([self.num_points, 1, 1]).float()
    135.         y_center = y_center.unsqueeze(0)
    136.  
    137.         x_center = torch.arange(0, self.height).repeat([self.width])
    138.         x_center = x_center.reshape(self.width, self.height)
    139.         x_center = x_center.permute(0, 1)
    140.         x_center = x_center.reshape([-1, self.width, self.height])
    141.         x_center = x_center.repeat([self.num_points, 1, 1]).float()
    142.         x_center = x_center.unsqueeze(0)
    143.  
    144.         if self.morph == 0:
    145.             """
    146.             Initialize the kernel and flatten the kernel
    147.                 y: only need 0
    148.                 x: -num_points//2 ~ num_points//2 (Determined by the kernel size)
    149.                 !!! The related PPT will be submitted later, and the PPT will contain the whole changes of each step
    150.             """
    151.             y = torch.linspace(0, 0, 1)
    152.             x = torch.linspace(
    153.                 -int(self.num_points // 2),
    154.                 int(self.num_points // 2),
    155.                 int(self.num_points),
    156.             )
    157.  
    158.             y, x = torch.meshgrid(y, x)
    159.             y_spread = y.reshape(-1, 1)
    160.             x_spread = x.reshape(-1, 1)
    161.  
    162.             y_grid = y_spread.repeat([1, self.width * self.height])
    163.             y_grid = y_grid.reshape([self.num_points, self.width, self.height])
    164.             y_grid = y_grid.unsqueeze(0)  # [B*K*K, W,H]
    165.  
    166.             x_grid = x_spread.repeat([1, self.width * self.height])
    167.             x_grid = x_grid.reshape([self.num_points, self.width, self.height])
    168.             x_grid = x_grid.unsqueeze(0)  # [B*K*K, W,H]
    169.  
    170.             y_new = y_center + y_grid
    171.             x_new = x_center + x_grid
    172.  
    173.             y_new = y_new.repeat(self.num_batch, 1, 1, 1).to(device)
    174.             x_new = x_new.repeat(self.num_batch, 1, 1, 1).to(device)
    175.  
    176.             y_offset_new = y_offset.detach().clone()
    177.  
    178.             if if_offset:
    179.                 y_offset = y_offset.permute(1, 0, 2, 3)
    180.                 y_offset_new = y_offset_new.permute(1, 0, 2, 3)
    181.                 center = int(self.num_points // 2)
    182.  
    183.                 # The center position remains unchanged and the rest of the positions begin to swing
    184.                 # This part is quite simple. The main idea is that "offset is an iterative process"
    185.                 y_offset_new[center] = 0
    186.                 for index in range(1, center):
    187.                     y_offset_new[center + index] = (y_offset_new[center + index - 1] + y_offset[center + index])
    188.                     y_offset_new[center - index] = (y_offset_new[center - index + 1] + y_offset[center - index])
    189.                 y_offset_new = y_offset_new.permute(1, 0, 2, 3).to(device)
    190.                 y_new = y_new.add(y_offset_new.mul(self.extend_scope))
    191.  
    192.             y_new = y_new.reshape(
    193.                 [self.num_batch, self.num_points, 1, self.width, self.height])
    194.             y_new = y_new.permute(0, 3, 1, 4, 2)
    195.             y_new = y_new.reshape([
    196.                 self.num_batch, self.num_points * self.width, 1 * self.height
    197.             ])
    198.             x_new = x_new.reshape(
    199.                 [self.num_batch, self.num_points, 1, self.width, self.height])
    200.             x_new = x_new.permute(0, 3, 1, 4, 2)
    201.             x_new = x_new.reshape([
    202.                 self.num_batch, self.num_points * self.width, 1 * self.height
    203.             ])
    204.             return y_new, x_new
    205.  
    206.         else:
    207.             """
    208.             Initialize the kernel and flatten the kernel
    209.                 y: -num_points//2 ~ num_points//2 (Determined by the kernel size)
    210.                 x: only need 0
    211.             """
    212.             y = torch.linspace(
    213.                 -int(self.num_points // 2),
    214.                 int(self.num_points // 2),
    215.                 int(self.num_points),
    216.             )
    217.             x = torch.linspace(0, 0, 1)
    218.  
    219.             y, x = torch.meshgrid(y, x)
    220.             y_spread = y.reshape(-1, 1)
    221.             x_spread = x.reshape(-1, 1)
    222.  
    223.             y_grid = y_spread.repeat([1, self.width * self.height])
    224.             y_grid = y_grid.reshape([self.num_points, self.width, self.height])
    225.             y_grid = y_grid.unsqueeze(0)
    226.  
    227.             x_grid = x_spread.repeat([1, self.width * self.height])
    228.             x_grid = x_grid.reshape([self.num_points, self.width, self.height])
    229.             x_grid = x_grid.unsqueeze(0)
    230.  
    231.             y_new = y_center + y_grid
    232.             x_new = x_center + x_grid
    233.  
    234.             y_new = y_new.repeat(self.num_batch, 1, 1, 1)
    235.             x_new = x_new.repeat(self.num_batch, 1, 1, 1)
    236.  
    237.             y_new = y_new.to(device)
    238.             x_new = x_new.to(device)
    239.             x_offset_new = x_offset.detach().clone()
    240.  
    241.             if if_offset:
    242.                 x_offset = x_offset.permute(1, 0, 2, 3)
    243.                 x_offset_new = x_offset_new.permute(1, 0, 2, 3)
    244.                 center = int(self.num_points // 2)
    245.                 x_offset_new[center] = 0
    246.                 for index in range(1, center):
    247.                     x_offset_new[center + index] = (x_offset_new[center + index - 1] + x_offset[center + index])
    248.                     x_offset_new[center - index] = (x_offset_new[center - index + 1] + x_offset[center - index])
    249.                 x_offset_new = x_offset_new.permute(1, 0, 2, 3).to(device)
    250.                 x_new = x_new.add(x_offset_new.mul(self.extend_scope))
    251.  
    252.             y_new = y_new.reshape(
    253.                 [self.num_batch, 1, self.num_points, self.width, self.height])
    254.             y_new = y_new.permute(0, 3, 1, 4, 2)
    255.             y_new = y_new.reshape([
    256.                 self.num_batch, 1 * self.width, self.num_points * self.height
    257.             ])
    258.             x_new = x_new.reshape(
    259.                 [self.num_batch, 1, self.num_points, self.width, self.height])
    260.             x_new = x_new.permute(0, 3, 1, 4, 2)
    261.             x_new = x_new.reshape([
    262.                 self.num_batch, 1 * self.width, self.num_points * self.height
    263.             ])
    264.             return y_new, x_new
    265.  
    266.     """
    267.     input: input feature map [N,C,D,W,H]；coordinate map [N,K*D,K*W,K*H] 
    268.     output: [N,1,K*D,K*W,K*H]  deformed feature map
    269.     """
    270.  
    271.     def _bilinear_interpolate_3D(self, input_feature, y, x):
    272.         device = input_feature.device
    273.         y = y.reshape([-1]).float()
    274.         x = x.reshape([-1]).float()
    275.  
    276.         zero = torch.zeros([]).int()
    277.         max_y = self.width - 1
    278.         max_x = self.height - 1
    279.  
    280.         # find 8 grid locations
    281.         y0 = torch.floor(y).int()
    282.         y1 = y0 + 1
    283.         x0 = torch.floor(x).int()
    284.         x1 = x0 + 1
    285.  
    286.         # clip out coordinates exceeding feature map volume
    287.         y0 = torch.clamp(y0, zero, max_y)
    288.         y1 = torch.clamp(y1, zero, max_y)
    289.         x0 = torch.clamp(x0, zero, max_x)
    290.         x1 = torch.clamp(x1, zero, max_x)
    291.  
    292.         input_feature_flat = input_feature.flatten()
    293.         input_feature_flat = input_feature_flat.reshape(
    294.             self.num_batch, self.num_channels, self.width, self.height)
    295.         input_feature_flat = input_feature_flat.permute(0, 2, 3, 1)
    296.         input_feature_flat = input_feature_flat.reshape(-1, self.num_channels)
    297.         dimension = self.height * self.width
    298.  
    299.         base = torch.arange(self.num_batch) * dimension
    300.         base = base.reshape([-1, 1]).float()
    301.  
    302.         repeat = torch.ones([self.num_points * self.width * self.height
    303.                              ]).unsqueeze(0)
    304.         repeat = repeat.float()
    305.  
    306.         base = torch.matmul(base, repeat)
    307.         base = base.reshape([-1])
    308.  
    309.         base = base.to(device)
    310.  
    311.         base_y0 = base + y0 * self.height
    312.         base_y1 = base + y1 * self.height
    313.  
    314.         # top rectangle of the neighbourhood volume
    315.         index_a0 = base_y0 - base + x0
    316.         index_c0 = base_y0 - base + x1
    317.  
    318.         # bottom rectangle of the neighbourhood volume
    319.         index_a1 = base_y1 - base + x0
    320.         index_c1 = base_y1 - base + x1
    321.  
    322.         # get 8 grid values
    323.         value_a0 = input_feature_flat[index_a0.type(torch.int64)].to(device)
    324.         value_c0 = input_feature_flat[index_c0.type(torch.int64)].to(device)
    325.         value_a1 = input_feature_flat[index_a1.type(torch.int64)].to(device)
    326.         value_c1 = input_feature_flat[index_c1.type(torch.int64)].to(device)
    327.  
    328.         # find 8 grid locations
    329.         y0 = torch.floor(y).int()
    330.         y1 = y0 + 1
    331.         x0 = torch.floor(x).int()
    332.         x1 = x0 + 1
    333.  
    334.         # clip out coordinates exceeding feature map volume
    335.         y0 = torch.clamp(y0, zero, max_y + 1)
    336.         y1 = torch.clamp(y1, zero, max_y + 1)
    337.         x0 = torch.clamp(x0, zero, max_x + 1)
    338.         x1 = torch.clamp(x1, zero, max_x + 1)
    339.  
    340.         x0_float = x0.float()
    341.         x1_float = x1.float()
    342.         y0_float = y0.float()
    343.         y1_float = y1.float()
    344.  
    345.         vol_a0 = ((y1_float - y) * (x1_float - x)).unsqueeze(-1).to(device)
    346.         vol_c0 = ((y1_float - y) * (x - x0_float)).unsqueeze(-1).to(device)
    347.         vol_a1 = ((y - y0_float) * (x1_float - x)).unsqueeze(-1).to(device)
    348.         vol_c1 = ((y - y0_float) * (x - x0_float)).unsqueeze(-1).to(device)
    349.  
    350.         outputs = (value_a0 * vol_a0 + value_c0 * vol_c0 + value_a1 * vol_a1 +
    351.                    value_c1 * vol_c1)
    352.  
    353.         if self.morph == 0:
    354.             outputs = outputs.reshape([
    355.                 self.num_batch,
    356.                 self.num_points * self.width,
    357.                 1 * self.height,
    358.                 self.num_channels,
    359.             ])
    360.             outputs = outputs.permute(0, 3, 1, 2)
    361.         else:
    362.             outputs = outputs.reshape([
    363.                 self.num_batch,
    364.                 1 * self.width,
    365.                 self.num_points * self.height,
    366.                 self.num_channels,
    367.             ])
    368.             outputs = outputs.permute(0, 3, 1, 2)
    369.         return outputs
    370.  
    371.     def deform_conv(self, input, offset, if_offset):
    372.         y, x = self._coordinate_map_3D(offset, if_offset)
    373.         deformed_feature = self._bilinear_interpolate_3D(input, y, x)
    374.         return deformed_feature

    3.2 在YOlO v9中的添加教程

    阅读YOLOv9添加模块教程或使用下文操作

            1. 将YOLOv9工程中models下common.py文件中的最下行（否则可能因类继承报错）增加模块的代码。

    ​

             2. 将YOLOv9工程中models下yolo.py文件中的第681行（可能因版本变化而变化）增加以下代码。

                RepNCSPELAN4, SPPELAN, RepNCSPELAN4DySnakeConv}:

    3.3 运行配置文件

    1. # YOLOv9
    2. # Powered bu https://blog.csdn.net/StopAndGoyyy
    3.  
    4. # parameters
    5. nc: 80  # number of classes
    6. #depth_multiple: 0.33  # model depth multiple
    7. depth_multiple: 1  # model depth multiple
    8. #width_multiple: 0.25  # layer channel multiple
    9. width_multiple: 1  # layer channel multiple
    10. #activation: nn.LeakyReLU(0.1)
    11. #activation: nn.ReLU()
    12.  
    13. # anchors
    14. anchors: 3
    15.  
    16. # YOLOv9 backbone
    17. backbone:
    18.   [
    19.    [-1, 1, Silence, []],  
    20.    
    21.    # conv down
    22.    [-1, 1, Conv, [64, 3, 2]],  # 1-P1/2
    23.  
    24.    # conv down
    25.    [-1, 1, Conv, [128, 3, 2]],  # 2-P2/4
    26.  
    27.    # elan-1 block
    28.    [-1, 1, RepNCSPELAN4DySnakeConv, [256, 128, 64, 1]],  # 3
    29.  
    30.    # avg-conv down
    31.    [-1, 1, ADown, [256]],  # 4-P3/8
    32.  
    33.    # elan-2 block
    34.    [-1, 1, RepNCSPELAN4, [512, 256, 128, 1]],  # 5
    35.  
    36.    # avg-conv down
    37.    [-1, 1, ADown, [512]],  # 6-P4/16
    38.  
    39.    # elan-2 block
    40.    [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 7
    41.  
    42.    # avg-conv down
    43.    [-1, 1, ADown, [512]],  # 8-P5/32
    44.  
    45.    # elan-2 block
    46.    [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 9
    47.   ]
    48.  
    49. # YOLOv9 head
    50. head:
    51.   [
    52.    # elan-spp block
    53.    [-1, 1, SPPELAN, [512, 256]],  # 10
    54.  
    55.    # up-concat merge
    56.    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
    57.    [[-1, 7], 1, Concat, [1]],  # cat backbone P4
    58.  
    59.    # elan-2 block
    60.    [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 13
    61.  
    62.    # up-concat merge
    63.    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
    64.    [[-1, 5], 1, Concat, [1]],  # cat backbone P3
    65.  
    66.    # elan-2 block
    67.    [-1, 1, RepNCSPELAN4, [256, 256, 128, 1]],  # 16 (P3/8-small)
    68.  
    69.    # avg-conv-down merge
    70.    [-1, 1, ADown, [256]],
    71.    [[-1, 13], 1, Concat, [1]],  # cat head P4
    72.  
    73.    # elan-2 block
    74.    [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 19 (P4/16-medium)
    75.  
    76.    # avg-conv-down merge
    77.    [-1, 1, ADown, [512]],
    78.    [[-1, 10], 1, Concat, [1]],  # cat head P5
    79.  
    80.    # elan-2 block
    81.    [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 22 (P5/32-large)
    82.    
    83.    
    84.    # multi-level reversible auxiliary branch
    85.    
    86.    # routing
    87.    [5, 1, CBLinear, [[256]]], # 23
    88.    [7, 1, CBLinear, [[256, 512]]], # 24
    89.    [9, 1, CBLinear, [[256, 512, 512]]], # 25
    90.    
    91.    # conv down
    92.    [0, 1, Conv, [64, 3, 2]],  # 26-P1/2
    93.  
    94.    # conv down
    95.    [-1, 1, Conv, [128, 3, 2]],  # 27-P2/4
    96.  
    97.    # elan-1 block
    98.    [-1, 1, RepNCSPELAN4, [256, 128, 64, 1]],  # 28
    99.  
    100.    # avg-conv down fuse
    101.    [-1, 1, ADown, [256]],  # 29-P3/8
    102.    [[23, 24, 25, -1], 1, CBFuse, [[0, 0, 0]]], # 30  
    103.  
    104.    # elan-2 block
    105.    [-1, 1, RepNCSPELAN4, [512, 256, 128, 1]],  # 31
    106.  
    107.    # avg-conv down fuse
    108.    [-1, 1, ADown, [512]],  # 32-P4/16
    109.    [[24, 25, -1], 1, CBFuse, [[1, 1]]], # 33 
    110.  
    111.    # elan-2 block
    112.    [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 34
    113.  
    114.    # avg-conv down fuse
    115.    [-1, 1, ADown, [512]],  # 35-P5/32
    116.    [[25, -1], 1, CBFuse, [[2]]], # 36
    117.  
    118.    # elan-2 block
    119.    [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 37
    120.    
    121.    
    122.    
    123.    # detection head
    124.  
    125.    # detect
    126.    [[31, 34, 37, 16, 19, 22], 1, DualDDetect, [nc]],  # DualDDetect(A3, A4, A5, P3, P4, P5)
    127.   ]

    3.4 训练过程

    ​

    欢迎关注!

  • 相关阅读:
    Python中取2023, 9, 1——2023, 10, 31的全部时间
    Stable Diffusion webui 常用启动参数
    微信小程序签名
    前端模糊搜索
    什么是hive的静态分区和动态分区，它们又有什么区别呢？hive动态分区详解
    [100天算法】-面试题 17.17.多次搜索（day 43）
    【轻量化网络】MobileNet系列
    【web开发】6、Django(1)
    万字长文：从计算机本源深入探寻volatile和Java内存模型
    3GPP R17连接态省电特性
  • 原文地址：https://blog.csdn.net/StopAndGoyyy/article/details/136426572