code’github link: https://github.com/clovaai/wsolevaluation

    该博客是ADL的backbone结构的学习笔记：

    ResNet50残差块定义：

    1. class Bottleneck(nn.Module):
    2.     expansion = 4
    3.     # 表示输出的channel的膨胀系数为４　64-->256
    5.     def __init__(self, inplanes, planes, stride=1, downsample=None,
    6.                  base_width=64):
    7.         super(Bottleneck, self).__init__()
    8.         '''
    9.         下面分别是三个Conv层
    10.         1x1, 3x3, 1x1,其中最后一层1x1完成planes*4的out_channel定型
    11.         如果有下采样需求，在第一层的stride=stride中完成
    12.         '''
    13.         width = int(planes * (base_width / 64.))
    14.         self.conv1 = nn.Conv2d(inplanes, width, 1, bias=False)
    15.         self.bn1 = nn.BatchNorm2d(width)
    16.         self.conv2 = nn.Conv2d(width, width, 3,
    17.                                stride=stride, padding=1, bias=False)
    18.         self.bn2 = nn.BatchNorm2d(width)
    19.         self.conv3 = nn.Conv2d(width, planes * self.expansion, 1, bias=False)
    20.         # 在最后一层1x1卷积核完成通道的增加（4倍）
    21.         self.bn3 = nn.BatchNorm2d(planes * self.expansion)
    22.         self.relu = nn.ReLU(inplace=True)
    23.         self.downsample = downsample
    24.         self.stride = stride
    26.     def forward(self, x):
    27.         identity = x
    29.         out = self.conv1(x)
    30.         out = self.bn1(out)
    31.         out = self.relu(out)
    33.         out = self.conv2(out)
    34.         out = self.bn2(out)
    35.         out = self.relu(out)
    37.         out = self.conv3(out)
    38.         out = self.bn3(out)
    40.   　    #如果说残差块输入的channel和输出的channel不一致
    41.         #如果有下采样需求(stride>1，比如说为2)，跑出来的结果就是残差块里的残差
    42.         # downsample的具体操作在 get_downsampling_layer 函数中体现    
    43.         if self.downsample is not None:
    44.             identity = self.downsample(x)
    46.         out += identity
    47.         out = self.relu(out)
    49.         return out

    具体的ResNetADL的网络模型构建：

    1. _ADL_POSITION = [[], [], [], [0], [0, 2]]
    2. '''
    3. 在第几层添加ADL模块，论文中有实验数据表明，
    4. 由于层数越深，特征图像素点的感受野越大，
    5. drop_mask所drop的区域面积也就越大
    6. '''
    8. class ResNetAdl(nn.Module):
    9.     def __init__(self, block, layers, num_classes=1000,
    10.                  large_feature_map=False, **kwargs):
    11.         super(ResNetAdl, self).__init__()
    13.         self.stride_l3 = 1 if large_feature_map else 2
    14.         '''
    15.         large_feature_map=Ture self.stride_l3=1
    16.         large_feature_map=False self.stride_l3=2
    17.         特征图会大一些，在原ResNet中作者就这个问题给出了一点说明：
    18.         'it is slightly better whereas slower to set stride = 1'
    19.         '''
    20.         self.inplanes = 64
    21.         #ADL模块的两个参数
    22.         self.adl_drop_rate = kwargs['adl_drop_rate']
    23.         self.adl_threshold = kwargs['adl_drop_threshold']
    25.         self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2,
    26.                                padding=3, bias=False)
    27.         # 这里可以把7x7的卷积核改为3个3x3的卷积核防止信息的丢失
    28.         self.bn1 = nn.BatchNorm2d(self.inplanes)
    29.         self.relu = nn.ReLU(inplace=True)
    30.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
    32.         self.layer1 = self._make_layer(block, 64, layers[0],
    33.                                        stride=1,
    34.                                        split=_ADL_POSITION[1])
    35.         self.layer2 = self._make_layer(block, 128, layers[1],
    36.                                        stride=2,
    37.                                        split=_ADL_POSITION[2])
    38.         self.layer3 = self._make_layer(block, 256, layers[2],
    39.                                        stride=self.stride_l3,
    40.                                        split=_ADL_POSITION[3])
    41.         # it is slightly better whereas slower to set stride = 1
    42.         self.layer4 = self._make_layer(block, 512, layers[3],
    43.                                        stride=1,
    44.                                        split=_ADL_POSITION[4])
    46.         self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
    47.         self.fc = nn.Linear(512 * block.expansion, num_classes)
    49.         initialize_weights(self.modules(), init_mode='xavier')
    51.     def forward(self, x, labels=None, return_cam=False):
    52.         x = self.conv1(x)
    53.         x = self.bn1(x)
    54.         x = self.relu(x)
    55.         x = self.maxpool(x)
    57.         x = self.layer1(x)
    58.         x = self.layer2(x)
    59.         x = self.layer3(x)
    60.         x = self.layer4(x)
    62.         pre_logit = self.avgpool(x)
    63.         pre_logit = pre_logit.reshape(pre_logit.size(0), -1)
    64.         logits = self.fc(pre_logit)
    66.         if return_cam:
    67.             feature_map = x.detach().clone()
    68.             '''
    69.             返回一个新的tensor，从当前计算图中分离下来的，
    70.             但是仍指向原变量的存放位置,不同之处只是requires_grad为false
    71.             这里把第4个残差模块的feature map给clone下来保存
    72.             '''
    73.             cam_weights = self.fc.weight[labels]
    74.             # 再获得相应label对应feature map的权重
    75.             cams = (cam_weights.view(*feature_map.shape[:2], 1, 1) *
    76.                     feature_map).mean(1, keepdim=False)
    77.             return cams
    79.         return {'logits': logits}
    81.     def _make_layer(self, block, planes, blocks, stride, split=None):
    82.         layers = self._layer(block, planes, blocks, stride)
    83.         # layer type:list 用于储存网络的模块
    84.         for pos in reversed(split):
    85.             # 将ADL模块添加到layers里，分别添加到stage 4 的第一层后面和第三层后面
    86.             layers.insert(pos + 1, ADL(self.adl_drop_rate, self.adl_threshold))
    87.         return nn.Sequential(*layers)
    89.     def _layer(self, block, planes, blocks, stride):
    90.         downsample = get_downsampling_layer(self.inplanes, block, planes,
    91.                                             stride)
    93.         layers = [block(self.inplanes, planes, stride, downsample)]
    94.         self.inplanes = planes * block.expansion
    95.         for _ in range(1, blocks):
    96.             layers.append(block(self.inplanes, planes))
    97.         return layers
    100. def get_downsampling_layer(inplanes, block, planes, stride):
    101.     outplanes = planes * block.expansion
    102.     if stride == 1 and inplanes == outplanes:
    103.         return
    104.     else:
    105.         return nn.Sequential(
    106.             nn.Conv2d(inplanes, outplanes, 1, stride, bias=False),
    107.             nn.BatchNorm2d(outplanes),
    108.         )

    总体结构就是在ResNet上稍微做了做修改，应该很好理解。