首先看config文件中，以Faster-RCNN为例，backbone的主要参数为：

    1. backbone=dict(
    2.         type='ResNet',  #backbone名称
    3.         depth=50,　    　　#网络的深度５０　－－> ResNet50
    4.         num_stages=4,    #4个残差块
    5.         out_indices=(0, 1, 2, 3),　#指输出哪几层卷积后的特征作为输出，0-C2，1-C3，2-C4，3-C5
    6.         frozen_stages=1,   # 第一层冻结，参数不参与训练
    7.         style='pytorch')　　
    8. '''
    9. style 源码中的解释：
    10.         If style is "pytorch", the stride-two layer is the 3x3 conv layer,
    11.         if it is "caffe", the stride-two layer is the first 1x1 conv layer.
    12. '''

    然后转到/mmdet/models/backbone/resnet.py中查看构建backbone:

    1. class Bottleneck(nn.Module):
    2.     expansion = 4       #　表示输出的channel的膨胀系数为４　64-->256
    4.     def __init__(self,
    5.                  inplanes,
    6.                  planes,
    7.                  stride=1,
    8.                  dilation=1,　　# 空洞卷积：正常卷积核的空洞率为dilation=1
    9.                  downsample=None,
    10.                  style='pytorch',
    11.                  with_cp=False,
    12.                  conv_cfg=None,
    13.                  norm_cfg=dict(type='BN'),
    14.                  dcn=None, # 添加可变形卷积   
    15.                  gcb=None, # 
    16.                  gen_attention=None): # 添加注意力机制模块
    17.         """Bottleneck block for ResNet.
    18.         If style is "pytorch", the stride-two layer is the 3x3 conv layer,
    19.         if it is "caffe", the stride-two layer is the first 1x1 conv layer.
    20.         """
    21.         super(Bottleneck, self).__init__()
    22.         assert style in ['pytorch', 'caffe']
    23.         assert dcn is None or isinstance(dcn, dict)
    24.         assert gcb is None or isinstance(gcb, dict)
    25.         assert gen_attention is None or isinstance(gen_attention, dict)
    27.         self.inplanes = inplanes　#　input
    28.         self.planes = planes      # output
    29.         self.stride = stride
    30.         self.dilation = dilation
    31.         self.style = style
    32.         self.with_cp = with_cp
    33.         self.conv_cfg = conv_cfg  # 设定卷积核的一些参数
    34.         self.norm_cfg = norm_cfg　# 设定normlize层的参数：BN or GN
    35.         self.dcn = dcn 
    36.         self.with_dcn = dcn is not None
    37.         self.gcb = gcb
    38.         self.with_gcb = gcb is not None
    39.         self.gen_attention = gen_attention
    40.         self.with_gen_attention = gen_attention is not None

    首先是一些基础参数；

    1.           """
    2.         Bottleneck block for ResNet.
    3.         If style is "pytorch", the stride-two layer is the 3x3 conv layer,
    4.         if it is "caffe", the stride-two layer is the first 1x1 conv layer.
    5.         """
    7.         if self.style == 'pytorch':
    8.             self.conv1_stride = 1
    9.             self.conv2_stride = stride
    10.         else:
    11.             self.conv1_stride = stride
    12.             self.conv2_stride = 1
    14.         self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)
    15.         self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)
    16.         self.norm3_name, norm3 = build_norm_layer(
    17.             norm_cfg, planes * self.expansion, postfix=3)
    18.         # 添加normlize层，一个残差块共三个conv层和三个norm层
    19.         # build_norm_layer返回的是该norm层的名字’str‘与其 'nn.model'的对象
    21.         self.conv1 = build_conv_layer(
    22.             conv_cfg, # conv_cfg = None  build常规卷积核
    23.             inplanes,
    24.             planes,
    25.             kernel_size=1,
    26.             stride=self.conv1_stride,
    27.             bias=False)
    28.         self.add_module(self.norm1_name, norm1)　# 将norm对象赋值给self.norm1_name
    29.         fallback_on_stride = False
    30.         if self.with_dcn:　　# 是否添加可变形卷积
    31.             fallback_on_stride = dcn.pop('fallback_on_stride', False)
    32.         if not self.with_dcn or fallback_on_stride:
    33.             self.conv2 = build_conv_layer(
    34.                 conv_cfg,
    35.                 planes,
    36.                 planes,
    37.                 kernel_size=3,
    38.                 stride=self.conv2_stride,
    39.                 padding=dilation,
    40.                 dilation=dilation,
    41.                 bias=False)
    42.         else:　# 添加常规卷积核
    43.             assert self.conv_cfg is None, 'conv_cfg cannot be None for DCN'
    44.             self.conv2 = build_conv_layer(
    45.                 dcn,
    46.                 planes,
    47.                 planes,
    48.                 kernel_size=3,
    49.                 stride=self.conv2_stride,
    50.                 padding=dilation,
    51.                 dilation=dilation,
    52.                 bias=False)
    54.         self.add_module(self.norm2_name, norm2)
    55.         self.conv3 = build_conv_layer(
    56.             conv_cfg,
    57.             planes,
    58.             planes * self.expansion,
    59.             kernel_size=1,
    60.             bias=False)
    61.         self.add_module(self.norm3_name, norm3)
    63.         self.relu = nn.ReLU(inplace=True)
    64.         self.downsample = downsample
    66.         if self.with_gcb:
    67.             gcb_inplanes = planes * self.expansion
    68.             self.context_block = ContextBlock(inplanes=gcb_inplanes, **gcb)
    70.         # gen_attention
    71.         if self.with_gen_attention:
    72.             self.gen_attention_block = GeneralizedAttention(
    73.                 planes, **gen_attention)

    将残差块搭建完成；

    1.     @property
    2.     def norm1(self):
    3.         return getattr(self, self.norm1_name)
    5.     @property
    6.     def norm2(self):
    7.         return getattr(self, self.norm2_name)
    9.     @property
    10.     def norm3(self):
    11.         return getattr(self, self.norm3_name)

    @property装饰器就是负责把一个方法变成属性调用的;**getattr()** 函数用于返回一个对象属性值。

    1. # 每一个残差块的forward前向传播
    2.     def forward(self, x):
    4.         def _inner_forward(x):
    5.             identity = x
    7.             out = self.conv1(x)
    8.             out = self.norm1(out)
    9.             out = self.relu(out)
    11.             out = self.conv2(out)
    12.             out = self.norm2(out)
    13.             out = self.relu(out)
    15.             if self.with_gen_attention:
    16.                 out = self.gen_attention_block(out)
    18.             out = self.conv3(out)
    19.             out = self.norm3(out)
    21.             if self.with_gcb:
    22.                 out = self.context_block(out)
    24.             if self.downsample is not None:
    25.                 identity = self.downsample(x)
    27.             out += identity
    29.             return out
    31.         if self.with_cp and x.requires_grad:
    32.             out = cp.checkpoint(_inner_forward, x)
    33.         else:
    34.             out = _inner_forward(x)
    36.         out = self.relu(out)
    38.         return out
    1. def make_res_layer(block,
    2.                    inplanes,
    3.                    planes,
    4.                    blocks,
    5.                    stride=1,
    6.                    dilation=1,
    7.                    style='pytorch',
    8.                    with_cp=False,
    9.                    conv_cfg=None,
    10.                    norm_cfg=dict(type='BN'),
    11.                    dcn=None,
    12.                    gcb=None,
    13.                    gen_attention=None,
    14.                    gen_attention_blocks=[]):
    15.     downsample = None
    16.     if stride != 1 or inplanes != planes * block.expansion:
    17.         downsample = nn.Sequential(
    18.             build_conv_layer(
    19.                 conv_cfg,
    20.                 inplanes,
    21.                 planes * block.expansion,
    22.                 kernel_size=1,
    23.                 stride=stride,
    24.                 bias=False),
    25.             build_norm_layer(norm_cfg, planes * block.expansion)[1],
    26.         )
    28.     layers = []
    29.     layers.append(
    30.         block(
    31.             inplanes=inplanes,
    32.             planes=planes,
    33.             stride=stride,
    34.             dilation=dilation,
    35.             downsample=downsample,
    36.             style=style,
    37.             with_cp=with_cp,
    38.             conv_cfg=conv_cfg,
    39.             norm_cfg=norm_cfg,
    40.             dcn=dcn,
    41.             gcb=gcb,
    42.             gen_attention=gen_attention if
    43.             (0 in gen_attention_blocks) else None))
    44.     inplanes = planes * block.expansion
    45.     for i in range(1, blocks):
    46.         layers.append(
    47.             block(
    48.                 inplanes=inplanes,
    49.                 planes=planes,
    50.                 stride=1,
    51.                 dilation=dilation,
    52.                 style=style,
    53.                 with_cp=with_cp,
    54.                 conv_cfg=conv_cfg,
    55.                 norm_cfg=norm_cfg,
    56.                 dcn=dcn,
    57.                 gcb=gcb,
    58.                 gen_attention=gen_attention if
    59.                 (i in gen_attention_blocks) else None))
    61.     return nn.Sequential(*layers)

    下面是最主要的构建ResNet网络的代码块：

    1. @BACKBONES.register_module
    2. class ResNet(nn.Module):
    3.     """ResNet backbone.
    5.     Args:
    6.         depth (int): Depth of resnet, from {18, 34, 50, 101, 152}.
    7.         in_channels (int): Number of input image channels. Normally 3.
    8.         num_stages (int): Resnet stages, normally 4.
    9.         strides (Sequence[int]): Strides of the first block of each stage.
    10.         dilations (Sequence[int]): Dilation of each stage.
    11.         out_indices (Sequence[int]): Output from which stages.
    12.         style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
    13.             layer is the 3x3 conv layer, otherwise the stride-two layer is
    14.             the first 1x1 conv layer.
    15.         frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
    16.             -1 means not freezing any parameters.
    17.         norm_cfg (dict): dictionary to construct and config norm layer.
    18.         norm_eval (bool): Whether to set norm layers to eval mode, namely,
    19.             freeze running stats (mean and var). Note: Effect on Batch Norm
    20.             and its variants only.
    21.         with_cp (bool): Use checkpoint or not. Using checkpoint will save some
    22.             memory while slowing down the training speed.
    23.         zero_init_residual (bool): whether to use zero init for last norm layer
    24.             in resblocks to let them behave as identity.
    26.     Example:
    27.         >>> from mmdet.models import ResNet
    28.         >>> import torch
    29.         >>> self = ResNet(depth=18)
    30.         >>> self.eval()
    31.         >>> inputs = torch.rand(1, 3, 32, 32)
    32.         >>> level_outputs = self.forward(inputs)
    33.         >>> for level_out in level_outputs:
    34.         ...     print(tuple(level_out.shape))
    35.         (1, 64, 8, 8)
    36.         (1, 128, 4, 4)
    37.         (1, 256, 2, 2)
    38.         (1, 512, 1, 1)
    39.     """
    41.     arch_settings = {
    42.         18: (BasicBlock, (2, 2, 2, 2)),
    43.         34: (BasicBlock, (3, 4, 6, 3)),
    44.         50: (Bottleneck, (3, 4, 6, 3)),
    45.         101: (Bottleneck, (3, 4, 23, 3)),
    46.         152: (Bottleneck, (3, 8, 36, 3))
    47.     }
    49.     def __init__(self,
    50.                  depth,
    51.                  in_channels=3,
    52.                  num_stages=4,
    53.                  strides=(1, 2, 2, 2),
    54.                  dilations=(1, 1, 1, 1),
    55.                  out_indices=(0, 1, 2, 3),
    56.                  style='pytorch',
    57.                  frozen_stages=-1,
    58.                  conv_cfg=None,
    59.                  norm_cfg=dict(type='BN', requires_grad=True),
    60.                  norm_eval=True,
    61.                  dcn=None,
    62.                  stage_with_dcn=(False, False, False, False),
    63.                  gcb=None,
    64.                  stage_with_gcb=(False, False, False, False),
    65.                  gen_attention=None,
    66.                  stage_with_gen_attention=((), (), (), ()),
    67.                  with_cp=False,
    68.                  zero_init_residual=True):
    69.         super(ResNet, self).__init__()
    70.         if depth not in self.arch_settings:
    71.             raise KeyError('invalid depth {} for resnet'.format(depth))
    72.         self.depth = depth
    73.         self.num_stages = num_stages
    74.         assert num_stages >= 1 and num_stages <= 4
    75.         self.strides = strides
    76.         self.dilations = dilations
    77.         assert len(strides) == len(dilations) == num_stages
    78.         self.out_indices = out_indices
    79.         assert max(out_indices) < num_stages
    80.         self.style = style
    81.         self.frozen_stages = frozen_stages
    82.         self.conv_cfg = conv_cfg
    83.         self.norm_cfg = norm_cfg
    84.         self.with_cp = with_cp
    85.         self.norm_eval = norm_eval
    86.         self.dcn = dcn
    87.         self.stage_with_dcn = stage_with_dcn
    88.         if dcn is not None:
    89.             assert len(stage_with_dcn) == num_stages
    90.         self.gen_attention = gen_attention
    91.         self.gcb = gcb
    92.         self.stage_with_gcb = stage_with_gcb
    93.         if gcb is not None:
    94.             assert len(stage_with_gcb) == num_stages
    95.         self.zero_init_residual = zero_init_residual
    96.         self.block, stage_blocks = self.arch_settings[depth]
    97.         self.stage_blocks = stage_blocks[:num_stages]
    98.         self.inplanes = 64
    100.         self._make_stem_layer(in_channels)  # channel:3 --> 64
    101.         # stem_layer,进入残差块之前需要对图片进行一次卷及操作
    103.         self.res_layers = []
    104.         for i, num_blocks in enumerate(self.stage_blocks):
    105.             stride = strides[i]
    106.             dilation = dilations[i]
    107.             dcn = self.dcn if self.stage_with_dcn[i] else None
    108.             gcb = self.gcb if self.stage_with_gcb[i] else None
    109.             planes = 64 * 2**i
    110.             res_layer = make_res_layer(
    111.                 self.block,
    112.                 self.inplanes,
    113.                 planes,
    114.                 num_blocks,
    115.                 stride=stride,
    116.                 dilation=dilation,
    117.                 style=self.style,
    118.                 with_cp=with_cp,
    119.                 conv_cfg=conv_cfg,
    120.                 norm_cfg=norm_cfg,
    121.                 dcn=dcn,
    122.                 gcb=gcb,
    123.                 gen_attention=gen_attention,
    124.                 gen_attention_blocks=stage_with_gen_attention[i])
    125.             self.inplanes = planes * self.block.expansion
    126.             layer_name = 'layer{}'.format(i + 1)
    127.             self.add_module(layer_name, res_layer)
    128.             self.res_layers.append(layer_name) 
    129.             # 将４stage的残差块添加到res_layer的list中
    131.         self._freeze_stages()
    133.         self.feat_dim = self.block.expansion * 64 * 2**(
    134.             len(self.stage_blocks) - 1)
    136.     @property
    137.     def norm1(self):
    138.         return getattr(self, self.norm1_name)
    140.     def _make_stem_layer(self, in_channels):
    141.         self.conv1 = build_conv_layer(
    142.             self.conv_cfg,
    143.             in_channels,
    144.             64,
    145.             kernel_size=7,
    146.             stride=2,
    147.             padding=3,
    148.             bias=False)
    149.         self.norm1_name, norm1 = build_norm_layer(self.norm_cfg, 64, postfix=1)
    150.         self.add_module(self.norm1_name, norm1)
    151.         self.relu = nn.ReLU(inplace=True)
    152.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
    153.     # frezze某些层的参数不参与训练
    154.     def _freeze_stages(self):
    155.         if self.frozen_stages >= 0:
    156.             self.norm1.eval()
    157.             for m in [self.conv1, self.norm1]:
    158.                 for param in m.parameters():
    159.                     param.requires_grad = False
    161.         for i in range(1, self.frozen_stages + 1):
    162.             m = getattr(self, 'layer{}'.format(i))
    163.             m.eval()
    164.             for param in m.parameters():
    165.                 param.requires_grad = False
    167.     def init_weights(self, pretrained=None):
    168.         if isinstance(pretrained, str):
    169.             logger = get_root_logger()
    170.             load_checkpoint(self, pretrained, strict=False, logger=logger)
    171.         elif pretrained is None:
    172.             for m in self.modules():
    173.                 if isinstance(m, nn.Conv2d):
    174.                     kaiming_init(m)
    175.                 elif isinstance(m, (_BatchNorm, nn.GroupNorm)):
    176.                     constant_init(m, 1)
    178.             if self.dcn is not None:
    179.                 for m in self.modules():
    180.                     if isinstance(m, Bottleneck) and hasattr(
    181.                             m, 'conv2_offset'):
    182.                         constant_init(m.conv2_offset, 0)
    184.             if self.zero_init_residual:
    185.                 for m in self.modules():
    186.                     if isinstance(m, Bottleneck):
    187.                         constant_init(m.norm3, 0)
    188.                     elif isinstance(m, BasicBlock):
    189.                         constant_init(m.norm2, 0)
    190.         else:
    191.             raise TypeError('pretrained must be a str or None')
    193.     def forward(self, x):
    194.         x = self.conv1(x)
    195.         x = self.norm1(x)
    196.         x = self.relu(x)
    197.         x = self.maxpool(x)
    198.         outs = []
    199.         for i, layer_name in enumerate(self.res_layers):
    200.             res_layer = getattr(self, layer_name)
    201.             x = res_layer(x)
    202.             if i in self.out_indices:
    203.                 outs.append(x)
    204.         return tuple(outs)
    206.     def train(self, mode=True):
    207.         super(ResNet, self).train(mode)
    208.         self._freeze_stages()
    209.         if mode and self.norm_eval:
    210.             for m in self.modules():
    211.                 # trick: eval have effect on BatchNorm only
    212.                 if isinstance(m, _BatchNorm):
    213.                     m.eval()