pytorch mmcv Resnet3D网络源码解读

最新推荐文章于 2024-06-03 09:32:29 发布
最新推荐文章于 2024-06-03 09:32:29 发布
阅读量1.8k 收藏 15
点赞数 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
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
3D-ResNets-PyTorch-master.zip
09-02
这是关于论文Can Spatiotemporal 3D CNNs Retrace the History of 2D CNNs and ImageNet?的相关代码
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数
ResNet网络论文阅读笔记和3D ResNet的pytorch代码
qq_36421001的博客
03-27 1434
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
探索3D卷积神经网络：PyTorch实现的I3D与3D-ResNets
最新发布
gitblog_00004的博客
06-03 426
探索3D卷积神经网络：PyTorch实现的I3D与3D-ResNets 项目地址:https://gitcode.com/tomrunia/PyTorchConv3D 在这个数字化的世界中，视频数据正以指数级增长，而深度学习在动作识别和时空信息理解方面的能力也在不断提升。今天，我们将向您推介一个强大的开源项目——PyTorchConv3D，这是一个基于PyTorch的3D卷积神经网络库，其中包括了...
[pytorch] 2D + 3D ResNet代码实现, 改写
qq_38736504的博客
10-19 3855
pytorch 2D 3D ResNet 代码实现
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
基于pytorch+Resnet50网络对皮肤病图片进行二分类源码++数据集+全部数据资料.zip
03-12
基于pytorch+Resnet50网络对皮肤病图片进行二分类源码+全部数据资料.zip数据集说明 数据集存放目录为： used_dataset , 共200张图片，标签为：benign(良性）、malignant(患病)。 基于pytorch+Resnet50网络对皮肤病...
人工智能-深度学习-ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别-Pytorch
03-16
ResNet（残差神经网络）是深度学习领域的一个重要模型，由Kaiming He等人在2015年提出，解决了深度神经网络训练时的梯度消失问题。这里我们关注的是ResNet50，它是ResNet系列中的一个变体，具有50个卷积层，具有很高...
Python实现基于PyTorch+Resnet构建花朵图像分类模型项目源码（高分项目）.zip
05-09
Python实现基于PyTorch+Resnet构建花朵图像分类模型项目源码（高分项目）.zip该项目是个人毕设项目源码，评审分达到97分，都经过严格调试，确保可以运行！放心下载使用。该项目资源主要针对计算机相关专业的学生或...
Pytorch框架Resnet-VGG两种网络实现人脸表情识别源码+训练好的模型+项目详细说明+PPT报告.zip
12-21
Pytorch框架Resnet_VGG两种网络实现人脸表情识别源码+训练好的模型+项目详细说明+PPT报告.zip 包含的网络有resnet网络，vgg网络，以及对应训练好的模型文件， 包含项目详细说明文档，可参考文档操作学习。 包含制作...
Python-伪三维残差网络P3D的pytorch版本支持预训练模型
08-11
伪三维残差网络（P-3D）的pytorch版本，支持预训练模型
预先训练的3D ResNet-18：用于3D ResNet-18网络的预先训练的神经网络工具箱模型-matlab开发
05-28
为了将可学习的参数从预先训练的2D ResNet-18（ImageNet）传递到3D，我们通过三维复制了2D滤镜（重复复制它们）。 这是可能的，因为视频或3D图像可以转换为图像切片序列。 在训练过程中，我们希望3D ResNet-18学习每个帧中的模式。 该模型具有3400万个可学习的参数。 只需调用“ resnet18TL3Dfunction（）”函数。
卷积神经网络-基于Pytorch+ResNet实现的动物10分类算法.zip
05-03
在本项目中，我们将探讨如何利用PyTorch这一强大的深度学习框架，结合ResNet（残差网络）结构来实现一个动物10分类算法。PyTorch是一个开源的Python库，它为研究人员提供了构建和训练深度学习模型的灵活性和易用性。...
3D-resnet50 医学图像分类，训练及验证代码python
dr_yingli的博客
12-04 3210
3D-resnet50 医学图像分类，训练及验证代码python 可以选用resnet[10, 18 34, 50, 101, 152, 200]
MMDv2 配置ResNet-SetNet-SSD
GiantYum的博客
10-27 571
修改配置文件并训练 天天学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 5362
以下仅为个人理解，若有不正之处还请指出，欢迎交流！ 本文解读的源码为mmdet/models/backbones中的resnet.py 首先附上ResNet原文地址Deep Residual Learning for Image Recognition 其中，ResNet整体网络结构图如下： 一、ResNet网络中的两种基本残差块 由网络结构图可以看出，ResNet-18和ResNet-3...
【视频理解】六、3D-ResNet
traveller的博客
11-06 886
3D-ResNet
骨骼识别-复现PoseC3D
m0_63642362的博客
05-26 7224
转自AI Studio，原文链接：​​​​​​骨骼点动作识别-基于Paddle复现PoseC3D - 飞桨AI Studio Revisiting Skeleton-based Action Recognition（PoseC3D 基于Paddle复现） 1.简介 人体骨架作为人类行为的一种简洁的表现形式，近年来受到越来越多的关注。许多基于骨架的动作识别方法都采用了图卷积网络（GCN）来提取人体骨架上的特征。尽管在以前的工作中取得了积极的成果，但基于GCN的方法在健壮性、互操作性和可扩展性方面受到限制
pytorch 用resnet18作为骨干网络
10-14
PyTorch使用resnet18作为骨干网络有着很多优点。 首先，resnet18是一个非常经典且广泛应用的卷积神经网络结构。它的主要特点是具有残差连接，使得网络能够更深，同时减轻了梯度消失问题。这对于处理复杂的图像数据集特别有用，可以提高模型的准确性和效果。 其次，PyTorch是一个深度学习框架，具有很强的灵活性和易用性。通过使用PyTorch的接口和函数，我们可以很方便地构建和训练基于resnet18的模型。这使得我们能够迅速构建出一个强大的图像分类模型，并进行进一步的优化和调试。 另外，resnet18相对较小的模型规模使得其适用于一些资源受限的场景，比如在计算资源较少的设备上进行推理和部署。同时，相比于更深层次的resnet模型，resnet18的训练速度也更快，有利于提高模型的训练效率和迭代速度。 总之，通过将resnet18作为骨干网络，PyTorch能够充分利用其优势，提供了一个强大的图像分类框架。这可以帮助研究人员和开发者更好地进行图像分类任务的研究和应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值