pytorch mmcv Resnet3D网络源码解读

最新推荐文章于 2024-09-15 07:55:11 发布
最新推荐文章于 2024-09-15 07:55:11 发布
阅读量1.9k 收藏 16
点赞数 2
分类专栏： Pytorch源码学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bairw_Bella/article/details/109319813
版权

Resnet3D网络

使用mmcv 构建残差块

1，模型初始化中构建残差块的基础模块，适用于浅层ResNet18,ResNet34

1，根据是否使用膨胀的3D卷积，确定卷积核的尺寸，padding和步长

 if self.inflate:
            conv1_kernel_size = (3, 3, 3)
            conv1_padding = (1, dilation, dilation)
            conv2_kernel_size = (3, 3, 3)
            conv2_padding = (1, 1, 1)
        else: #else实际上不对时序进行卷积运算
            conv1_kernel_size = (1, 3, 3)
            conv1_padding = (0, dilation, dilation)
            conv2_kernel_size = (1, 3, 3)
            conv2_padding = (0, 1, 1)

2 ，如果是膨胀3D卷积，构建卷积核为3×3×3两个卷积层

 self.conv1 = ConvModule(
            inplanes, #输入特征图维度
            planes,   #输出特征图维度
            conv1_kernel_size,#核尺寸
            stride=(self.conv1_stride_t, self.conv1_stride_s,
                    self.conv1_stride_s),
            padding=conv1_padding,
            dilation=(1, dilation, dilation),
            bias=False,
            conv_cfg=self.conv_cfg,
            norm_cfg=self.norm_cfg,
            act_cfg=self.act_cfg)
self.conv2 = ConvModule(
            planes,
            planes * self.expansion,
            conv2_kernel_size,
            stride=(self.conv2_stride_t, self.conv2_stride_s,
                    self.conv2_stride_s),
            padding=conv2_padding,
            bias=False,
            conv_cfg=self.conv_cfg,
            norm_cfg=self.norm_cfg,
            act_cfg=None)

2，构建瓶颈式的残差模块

  • 对不同的膨胀模式设定不同的卷积方式
   if self.inflate:
            if inflate_style == '3x1x1':
                conv1_kernel_size = (3, 1, 1)
                conv1_padding = (1, 0, 0)
                conv2_kernel_size = (1, 3, 3)
                conv2_padding = (0, dilation, dilation)
            else:
                conv1_kernel_size = (1, 1, 1)
                conv1_padding = (0, 0, 0)
                conv2_kernel_size = (3, 3, 3)
                conv2_padding = (1, dilation, dilation)
        else:
            conv1_kernel_size = (1, 1, 1)
            conv1_padding = (0, 0, 0)
            conv2_kernel_size = (1, 3, 3)
            conv2_padding = (0, dilation, dilation)

  •  3个卷积层的构建
 self.conv1 = ConvModule(
            inplanes,
            planes,
            conv1_kernel_size,
            stride=(self.conv1_stride_t, self.conv1_stride_s,
                    self.conv1_stride_s),
            padding=conv1_padding,
            bias=False,
            conv_cfg=self.conv_cfg,
            norm_cfg=self.norm_cfg,
            act_cfg=self.act_cfg)

 

 self.conv2 = ConvModule(
            planes,
            planes,
            conv2_kernel_size,
            stride=(self.conv2_stride_t, self.conv2_stride_s,
                    self.conv2_stride_s),
            padding=conv2_padding,
            dilation=(1, dilation, dilation),
            bias=False,
            conv_cfg=self.conv_cfg,
            norm_cfg=self.norm_cfg,
            act_cfg=self.act_cfg)

 

self.conv3 = ConvModule(
            planes,
            planes * self.expansion,
#残差块中最后一个卷积层的输出通道应该是第一个卷积层的expansion倍，self.expansion=4
            1,
            bias=False,
            conv_cfg=self.conv_cfg,
            norm_cfg=self.norm_cfg,
            # No activation in the third ConvModule for bottleneck
            act_cfg=None)
  • 3D残差瓶颈块的构建

    def forward(self, x):
        """Defines the computation performed at every call."""

        def _inner_forward(x):
            """Forward wrapper for utilizing checkpoint."""
            identity = x

            out = self.conv1(x)
            out = self.conv2(out)
            out = self.conv3(out)

            if self.downsample is not None:
                identity = self.downsample(x)

            out = out + identity
            return out

3，def make_res_layer ()添加许多Block块至Sequential

make_res_layer，该函数是添加许多Block块至Sequential

在该函数中定义：如果stride不等于1或者维度不匹配的时候的downsample，

conv3 = ConvModule(planes, planes * self.expansion，...)用一个1×1×1的操作升维的，因此需要对inplanes和planes不一致的情况进行一次downsample ，即将带downsample的block添加至layers。这样保证了x和out的维度一致，接下来通过一个循环添加了指定个数的Block，由于x已经维度一致了，这样添加的其他的Block就可以不用降维了，所以循环添加不含Downsample的Block。

if spatial_stride != 1 or inplanes != planes * block.expansion:
            downsample = ConvModule(
                inplanes,
                planes * block.expansion,
                kernel_size=1,
                stride=(temporal_stride, spatial_stride, spatial_stride),
                bias=False,
                conv_cfg=conv_cfg,
                norm_cfg=norm_cfg,
                act_cfg=None)
  layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for _ in range(1, blocks):
            layers.append(block(self.inplanes, planes))

50层的3dResNet 

第一部分

conv kernel_size=(5, 7, 7)，bn+act

maxpooling +加pool2(时序维度的池化)

('conv1', ConvModule(
  (conv): Conv3d(3, 64, kernel_size=(5, 7, 7), stride=(2, 2, 2), padding=(2, 3, 3), bias=False)
  (bn): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (activate): ReLU(inplace=True)
))
('maxpool', MaxPool3d(kernel_size=(1, 3, 3), stride=(2, 2, 2), padding=(0, 1, 1), dilation=1, ceil_mode=False))
('pool2', MaxPool3d(kernel_size=(2, 1, 1), stride=(2, 1, 1), padding=0, dilation=1, ceil_mode=False)) 

#‘pooling2’层影响layer1后的时序维度

''''

pooling2=False时

torch.Size([1, 64, 4, 80, 64])
layer layer1 : output_size torch.Size([1, 256, 4, 80, 64])
layer layer2 : output_size torch.Size([1, 512, 4, 40, 32])
layer layer3 : output_size torch.Size([1, 1024, 4, 20, 16])
layer layer4 : output_size torch.Size([1, 2048, 4, 10, 8])

''''

''''

pooling2=True时

torch.Size([1, 64, 4, 80, 64])
layer layer1 : output_size torch.Size([1, 256, 4, 80, 64])
layer layer2 : output_size torch.Size([1, 512, 2, 40, 32])
layer layer3 : output_size torch.Size([1, 1024, 2, 20, 16])
layer layer4 : output_size torch.Size([1, 2048, 2, 10, 8])

第二部分 layer1，layer2，layer3,layer4

layer1:3个 Bottleneck3d

layer2：4个 Bottleneck3d

layer3：6个

layer4：3个


('layer1', Sequential(
  (0): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(64, 64, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(64, 64, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(64, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (downsample): ConvModule(
      (conv): Conv3d(64, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (1): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(256, 64, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(64, 64, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(64, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (2): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(256, 64, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(64, 64, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(64, 256, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
))
('layer2', Sequential(
  (0): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(256, 128, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(128, 128, kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(128, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (downsample): ConvModule(
      (conv): Conv3d(256, 512, kernel_size=(1, 1, 1), stride=(1, 2, 2), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (1): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(512, 128, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(128, 128, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(128, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (2): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(512, 128, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(128, 128, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(128, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (3): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(512, 128, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(128, 128, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(128, 512, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
))
('layer3', Sequential(
  (0): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(512, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(256, 256, kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (downsample): ConvModule(
      (conv): Conv3d(512, 1024, kernel_size=(1, 1, 1), stride=(1, 2, 2), bias=False)
      (bn): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (1): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(256, 256, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (2): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(256, 256, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (3): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(256, 256, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (4): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(256, 256, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (5): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(1024, 256, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(256, 256, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(256, 1024, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
))
('layer4', Sequential(
  (0): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(1024, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(512, 512, kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(512, 2048, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (downsample): ConvModule(
      (conv): Conv3d(1024, 2048, kernel_size=(1, 1, 1), stride=(1, 2, 2), bias=False)
      (bn): BatchNorm3d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (1): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(2048, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(512, 512, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(512, 2048, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
  (2): Bottleneck3d(
    (conv1): ConvModule(
      (conv): Conv3d(2048, 512, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv2): ConvModule(
      (conv): Conv3d(512, 512, kernel_size=(1, 3, 3), stride=(1, 1, 1), padding=(0, 1, 1), bias=False)
      (bn): BatchNorm3d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (activate): ReLU(inplace=True)
    )
    (conv3): ConvModule(
      (conv): Conv3d(512, 2048, kernel_size=(1, 1, 1), stride=(1, 1, 1), bias=False)
      (bn): BatchNorm3d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (relu): ReLU(inplace=True)
  )
)) 

 

 

 

 

 

Bella_wanna_Better
关注
专栏目录
基于MMdetection的RT-DETR目标检测器的源码解析（上）
m0_51951660的博客
09-14 1681
基于MMdetection的RT-DETR目标检测器的源码解析
DBNET文字检测与文字识别源码详解
qq_52053775的博客
04-28 152
配置mmorc: pip install -U openmim mim install mmengine mim install mmcv mim install mmdet git clone https://github.com/open-mmlab/mmocr.git cd mmocr pip install -v -e . 数据集：Tasks - Incidental Scene Text - Robust Reading Competition数据集下载后放到data目录下：
3D-ResNets-PyTorch-master.zip
09-02
这是关于论文Can Spatiotemporal 3D CNNs Retrace the History of 2D CNNs and ImageNet?的相关代码
ResNet网络论文阅读笔记和3D ResNet的pytorch代码
qq_36421001的博客
03-27 1550
Deep Residual Learning for Image Recognition Kaiming He Xiangyu Zhang Shaoqing Ren Jian Sun 参考文献和链接： Deep Residual LearnDeep Residual Learning for Image Recognition, He-Kaiming, 2015 https://www.jianshu.com/p/93990a641066 https://blog.csd
keras-resnet3d 项目使用教程
最新发布
gitblog_00041的博客
09-15 881
keras-resnet3d 项目使用教程 项目地址:https://gitcode.com/gh_mirrors/ke/keras-resnet3d 1. 项目介绍 keras-resnet3d 是一个基于 Keras 框架的 3D ResNet 实现，专门用于处理三维体积数据（volumetric data）。该项目提供了对 ResNet 架构的 3D 扩展，适用于医学影像分析、视频处理等需要...
[pytorch] 2D + 3D ResNet代码实现, 改写
qq_38736504的博客
10-19 4333
pytorch 2D 3D ResNet 代码实现
3D-ResNets-PyTorch：用于动作识别的3D ResNets（CVPR 2018）
02-05
用于动作识别的3D ResNet 更新（2020/4/13） 我们在arXiv上发表了一篇论文。 我们上载了本文所述的预训练模型，包括在结合了Kinetics-700和Moments in Time的数据集中预训练的ResNet-50。 更新（2020/4/10） 我们极大地更新了脚本。 如果要使用旧版本来复制我们的CVPR2018论文，则应使用CVPR2018分支中的脚本。 此更新包括： 重构整个项目 支持更新的PyTorch版本 支持分布式培训 支持对“时刻”数据集的培训和测试。 添加R（2 + 1）D模型 上载经过Kinetics-700，时刻矩和STAIR-Actions数
3D-ResNets-PyTorch: 基于PyTorch的三维残差网络用于动作识别
gitblog_00217的博客
08-08 634
3D-ResNets-PyTorch: 基于PyTorch的三维残差网络用于动作识别 项目地址:https://gitcode.com/gh_mirrors/3d/3D-ResNets-PyTorch 项目介绍 3D-ResNets-PyTorch 是一个实现三维残差网络(3D ResNets)的开源项目，专为视频中的动作识别设计。该库由论文 Can Spatiotemporal 3D CNNs ...
探索3D卷积神经网络：PyTorch实现的I3D与3D-ResNets
gitblog_00004的博客
06-03 585
探索3D卷积神经网络：PyTorch实现的I3D与3D-ResNets PyTorchConv3DI3D and 3D-ResNets in PyTorch项目地址:https://gitcode.com/gh_mirrors/py/PyTorchConv3D 在这个数字化的世界中，视频数据正以指数级增长，而深度学习在动作识别和时空信息理解方面的能力也在不断提升。今天，我们将向您推介一个强大的开...
3D ResNet：用于动作识别的3D ResNet
02-03
用于动作识别的3D ResNet 这是以下论文的PyTorch代码： 该代码仅包括对ActivityNet和Kinetics数据集的培训和测试。 如果您想使用我们的预训练模型对视频进行分类，请使用。 提供了此代码的PyTorch（python）版本。 PyTorch版本包含其他模型，例如预激活ResNet，Wide ResNet，ResNeXt和DenseNet。 引文 如果您使用此代码或预先训练的模型，请引用以下内容： @article{hara3dcnns, author={Kensho Hara and Hirokatsu Kataoka and Yutaka
RetinaNet源码阅读 [MMDetection]（1）
宝林的赛博小屋
01-26 1088
0.背景 1）什么是MMdetection？MMdetection是商汤科技推出的基于pytorch开源目标检测框架，包含了一些经典的目标检测方法。用户可以根据自己的需求，对模型参数进行修改，也可以使用其中的模块（如损失函数、Backbone等）搭建自己的网络。 用户最直接接触的就是config文件，在config文件中，用户主要设置model（模型结构）、datasete（数据集信息）、schedule（训练策略）、default_runtime。同时，各个config文件可以互相直接继承，继承以后再稍加
Python-伪三维残差网络P3D的pytorch版本支持预训练模型
08-11
伪三维残差网络（P-3D）的pytorch版本，支持预训练模型
PSPNet原理与代码实例讲解
AI大模型应用之禅
09-11 176
PSPNet原理与代码实例讲解 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍 1.1 问题的由来 深度学习在计算机视觉领域取得了显著的成果，特别是在
MMLAB系列：mmdetection的使用
qq_52053775的博客
08-29 1580
mmdetection支持coco和voc数据格式，建议使用coco数据格式。
3D-resnet50 医学图像分类，训练及验证代码python
dr_yingli的博客
12-04 3670
3D-resnet50 医学图像分类，训练及验证代码python 可以选用resnet[10, 18 34, 50, 101, 152, 200]
[pytorch] Resnet3D预训练网络 + MedMNIST 3D医学数据分类
热门推荐
qq_38736504的博客
03-23 1万+
[pytorch] MedMNIST 3D医学数据分类MedMNIST数据集
MMDv2 配置ResNet-SetNet-SSD
GiantYum的博客
10-27 616
修改配置文件并训练 天天学Java,好久没跑过实验了，记录下，防止日后踩坑 将mmdet.models.utils.se_layer.SELayer注册为plugin 注意修改下参数channels为in_channels，否则会出现unexpected args channels的参数解析错误，不太明白源码怎么解析的 # Copyright (c) OpenMMLab. All rights reserved. import mmcv import torch.nn as nn from mmcv.c
【mmdetection源码解读(一)】骨干网络--ResNet
cc__cc__的博客
04-12 5514
以下仅为个人理解，若有不正之处还请指出，欢迎交流！ 本文解读的源码为mmdet/models/backbones中的resnet.py 首先附上ResNet原文地址Deep Residual Learning for Image Recognition 其中，ResNet整体网络结构图如下： 一、ResNet网络中的两种基本残差块 由网络结构图可以看出，ResNet-18和ResNet-3...
【视频理解】六、3D-ResNet
traveller的博客
11-06 1173
3D-ResNet
基于PyTorch和ResNet的花朵图像分类模型源码
资源摘要信息:"Python实现基于PyTorch+Resnet构建花朵图像分类模型项目源码（高分项目）.zip" 该项目是一个完整的计算机视觉学习项目，使用Python语言开发，采用了深度学习框架PyTorch以及预训练的ResNet模型来构建...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值