def __init__(self, inplanes, planes, stride=1, dilation=1, kernel=3, norm='bn', use_se=False, activation=nn.ReLU): super(BasicBlock, self).__init__() padding = (dilation * kernel - dilation) // 2 self.inplanes, self.planes = int(inplanes), int(planes) self.conv1 = nn.Conv2d(inplanes, inplanes, kernel_size=kernel, padding=padding, stride=stride, dilation=dilation, groups=inplanes, bias=False) self.bn1 = make_norm(inplanes, norm=norm) self.conv2 = nn.Conv2d(inplanes, planes, kernel_size=1, stride=1, padding=0, bias=False) self.bn2 = make_norm(planes, norm=norm) self.se = ops.Se2d(planes, reduction=4) if use_se else None try: self.activation = activation(inplace=True) except: self.activation = activation()
def __init__(self, inplanes, outplanes, stride=1, dilation=1, kernel=3, groups=(1, 1), t=6, norm='bn', bn_eps=1e-5, se_ratio=0, activation=nn.ReLU6, se_reduce_mid=False, se_divisible=False, force_residual=False, sync_se_act=True): super(LinearBottleneck, self).__init__() padding = (dilation * kernel - dilation) // 2 self.stride = stride self.inplanes, self.outplanes, innerplanes = int(inplanes), int(outplanes), make_divisible(inplanes * t, 8) self.t = t self.force_residual = force_residual if self.t != 1: self.conv1 = nn.Conv2d(self.inplanes, innerplanes, kernel_size=1, padding=0, stride=1, groups=groups[0], bias=False) self.bn1 = make_norm(innerplanes, norm=norm, eps=bn_eps) self.conv2 = nn.Conv2d(innerplanes, innerplanes, kernel_size=kernel, padding=padding, stride=stride, dilation=dilation, groups=innerplanes, bias=False) self.bn2 = make_norm(innerplanes, norm=norm, eps=bn_eps) se_base_chs = innerplanes if se_reduce_mid else self.inplanes se_innerplanse = make_divisible(se_base_chs * se_ratio, 8) if se_divisible else int(se_base_chs * se_ratio) self.se = SeConv2d(innerplanes, se_innerplanse, activation if sync_se_act else nn.ReLU) if se_ratio else None self.conv3 = nn.Conv2d(innerplanes, self.outplanes, kernel_size=1, padding=0, stride=1, groups=groups[1], bias=False) self.bn3 = make_norm(self.outplanes, norm=norm, eps=bn_eps) try: self.activation = activation(inplace=True) except: self.activation = activation()
def _make_head(self, block, pre_stage_channels, outplanes=2048, conv='normal'): # Increasing the #channels on each resolution, from C, 2C, 4C, 8C to 128, 256, 512, 1024 incre_modules = [] for i, channels in enumerate(pre_stage_channels): self.inplanes = channels incre_module = self._make_layer(block, self.head_dim[i], 1, stride=1, dilation=1, conv=conv) incre_modules.append(incre_module) incre_modules = nn.ModuleList(incre_modules) # downsampling modules downsamp_modules = [] for i in range(len(pre_stage_channels) - 1): in_channels = self.head_dim[i] * block.expansion out_channels = self.head_dim[i + 1] * block.expansion downsamp_module = nn.Sequential( nn.Conv2d(in_channels, out_channels, 3, 2, 1), # official implementation forgets bias=False make_norm(out_channels, norm=self.norm), nn.ReLU(inplace=True) ) downsamp_modules.append(downsamp_module) downsamp_modules = nn.ModuleList(downsamp_modules) final_layer = nn.Sequential( nn.Conv2d(self.head_dim[3] * block.expansion, outplanes, 1, 1, 0), make_norm(outplanes, norm=self.norm), nn.ReLU(inplace=True) ) return incre_modules, downsamp_modules, final_layer
def __init__(self, inplanes, planes, stride=1, dilation=1, norm='bn', conv='normal', use_se=False, stride_3x3=False, downsample=None): super(AlignedBasicBlock, self).__init__() if conv == 'normal': conv_op = nn.Conv2d elif conv == 'deform': conv_op = ops.DeformConvPack elif conv == 'deformv2': conv_op = ops.ModulatedDeformConvPack else: raise ValueError('{} type conv operation is not supported.'.format(conv)) self.conv1_1 = conv_op(inplanes, planes, kernel_size=3, stride=stride, dilation=dilation, padding=dilation, bias=False) self.conv2_1 = conv_op(inplanes, planes // 2, kernel_size=3, stride=stride, dilation=dilation, padding=dilation, bias=False) self.bn2_1 = make_norm(planes // 2, norm=norm) self.conv2_2 = conv_op(planes // 2, planes // 2, kernel_size=3, stride=1, dilation=dilation, padding=dilation, bias=False) self.bn_concat = make_norm(planes + (planes // 2), norm=norm) self.conv = nn.Conv2d(planes + (planes // 2), planes, kernel_size=3, stride=1, dilation=dilation, padding=dilation, bias=False) self.bn = make_norm(planes, norm=norm) self.se = ops.Se2d(planes, reduction=16) if use_se else None self.relu = nn.ReLU(inplace=True) self.downsample = downsample
def __init__(self, inplanes, planes, base_width=64, stride=1, dilation=1, norm='bn', conv='normal', context='none', ctx_ratio=0.0625, radix=1, stride_3x3=False, downsample=None): super(BasicBlock, self).__init__() if conv == 'normal': conv_op = nn.Conv2d elif conv == 'deform': conv_op = ops.DeformConvPack elif conv == 'deformv2': conv_op = ops.ModulatedDeformConvPack else: raise ValueError( '{} type conv operation is not supported.'.format(conv)) assert context in ['none', 'se', 'gcb'] width = int(planes * (base_width / 64.)) self.conv1 = conv_op(inplanes, width, kernel_size=3, stride=stride, dilation=dilation, padding=dilation, bias=False) self.bn1 = make_norm(width, norm=norm, an_k=10 if planes < 256 else 20) self.conv2 = conv_op(width, width, kernel_size=3, stride=1, dilation=dilation, padding=dilation, bias=False) self.bn2 = make_norm(width, norm=norm, an_k=10 if planes < 256 else 20) if context == 'none': self.ctx = None elif context == 'se': self.ctx = ops.SeConv2d(width, int(width * ctx_ratio)) elif context == 'gcb': self.ctx = ops.GlobalContextBlock(width, int(width * ctx_ratio)) else: raise ValueError( '{} type context operation is not supported.'.format(context)) self.relu = nn.ReLU(inplace=True) self.downsample = downsample
def __init__(self, block, planes, norm='bn', conv='normal', use_se=False, use_global=False, stage=2, output_branches=2): super(StageModule, self).__init__() self.use_global = use_global self.branches = nn.ModuleList() for i in range(stage): w = planes * (2 ** i) branch = nn.Sequential( block(w, w, 1, 1, norm, conv, use_se, True), block(w, w, 1, 1, norm, conv, use_se, True), block(w, w, 1, 1, norm, conv, use_se, True), block(w, w, 1, 1, norm, conv, use_se, True), ) self.branches.append(branch) self.fuse_layers = nn.ModuleList() if self.use_global: self.global_layers = nn.ModuleList() # for each output_branches (i.e. each branch in all cases but the very last one) for i in range(output_branches): self.fuse_layers.append(nn.ModuleList()) for j in range(stage): # for each branch if i == j: self.fuse_layers[-1].append(nn.Sequential()) # Used in place of "None" because it is callable elif i < j: self.fuse_layers[-1].append(nn.Sequential( nn.Conv2d(planes * (2 ** j), planes * (2 ** i), 1, 1, 0, bias=False), make_norm(planes * (2 ** i), norm=norm), nn.Upsample(scale_factor=(2.0 ** (j - i)), mode='nearest'), )) elif i > j: ops = [] for k in range(i - j - 1): ops.append(nn.Sequential( nn.Conv2d(planes * (2 ** j), planes * (2 ** j), 3, 2, 1, bias=False), make_norm(planes * (2 ** j), norm=norm), nn.ReLU(inplace=True), )) ops.append(nn.Sequential( nn.Conv2d(planes * (2 ** j), planes * (2 ** i), 3, 2, 1, bias=False), make_norm(planes * (2 ** i), norm=norm), )) self.fuse_layers[-1].append(nn.Sequential(*ops)) if self.use_global: sum_planes = sum([planes * (2 ** k) for k in range(stage)]) self.global_layers.append( nn.Sequential( nn.Conv2d(sum_planes, planes * (2 ** i), 1, 1, 0, bias=False), make_norm(planes * (2 ** i), norm=norm), nn.Sigmoid() ) ) self.relu = nn.ReLU(inplace=True)
def __init__(self, setting='large', widen_factor=1.0, norm='bn', activation=H_Swish, drop_rate=0.0, num_classes=1000): """ Constructor Args: widen_factor: config of widen_factor num_classes: number of classes """ super(MobileNetV3, self).__init__() block = LinearBottleneck self.widen_factor = widen_factor self.norm = norm self.se_reduce_mid = True self.se_divisible = False self.head_use_bias = False self.force_residual = False self.sync_se_act = True self.bn_eps = 1e-5 self.drop_rate = drop_rate self.activation_type = activation layers_cfg = MV3_CFG[setting] num_of_channels = [lc[-1][1] for lc in layers_cfg[1:-1]] self.channels = [make_divisible(ch * self.widen_factor, 8) for ch in num_of_channels] self.activation = activation() if layers_cfg[0][0][3] else nn.ReLU(inplace=True) self.inplanes = make_divisible(layers_cfg[0][0][1] * self.widen_factor, 8) self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=layers_cfg[0][0][0], stride=layers_cfg[0][0][4], padding=layers_cfg[0][0][0] // 2, bias=False) self.bn1 = make_norm(self.inplanes, norm=self.norm, eps=self.bn_eps) self.layer0 = self._make_layer(block, layers_cfg[1], dilation=1) if layers_cfg[1][0][0] else None self.layer1 = self._make_layer(block, layers_cfg[2], dilation=1) self.layer2 = self._make_layer(block, layers_cfg[3], dilation=1) self.layer3 = self._make_layer(block, layers_cfg[4], dilation=1) self.layer4 = self._make_layer(block, layers_cfg[5], dilation=1) last_ch = make_divisible(layers_cfg[-1][0][1] * self.widen_factor, 8) self.last_stage = nn.Sequential( nn.Conv2d(self.inplanes, last_ch, kernel_size=layers_cfg[-1][0][0], stride=layers_cfg[-1][0][4], padding=layers_cfg[-1][0][0] // 2, bias=False), make_norm(last_ch, norm=self.norm, eps=self.bn_eps), activation() if layers_cfg[-1][0][3] else nn.ReLU(inplace=True), SeConv2d(last_ch, int(last_ch * layers_cfg[-1][0][2]), activation) if layers_cfg[-1][0][2] else nn.Identity() ) self.avgpool = nn.AdaptiveAvgPool2d(1) self.conv_out = nn.Sequential( nn.Conv2d(last_ch, layers_cfg[-1][1][1], kernel_size=layers_cfg[-1][1][0], stride=layers_cfg[-1][1][4], padding=layers_cfg[-1][1][0] // 2, bias=self.head_use_bias), activation() if layers_cfg[-1][1][3] else nn.ReLU(inplace=True) ) self.fc = nn.Linear(layers_cfg[-1][1][1], num_classes) self._init_weights()
def _make_layer(self, block, planes, blocks, stride=1, dilation=1, conv='normal', context='none'): """ Stack n bottleneck modules where n is inferred from the depth of the network. Args: block: block type used to construct ResNet planes: number of output channels (need to multiply by block.expansion) blocks: number of blocks to be built stride: factor to reduce the spatial dimensionality in the first bottleneck of the block. Returns: a Module consisting of n sequential bottlenecks. """ downsample = None if stride != 1 or self.inplanes != planes * block.expansion: if self.avg_down: downsample = nn.Sequential( nn.AvgPool2d(kernel_size=stride, stride=stride), nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=1, bias=False), make_norm(planes * block.expansion, norm=self.norm.split('_')[-1]), ) else: downsample = nn.Sequential( nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False), make_norm(planes * block.expansion, norm=self.norm.split('_')[-1]), ) layers = [] layers.append( block(self.inplanes, planes, self.base_width, stride, dilation, self.norm, conv, context, self.ctx_ratio, self.radix, self.stride_3x3, downsample)) self.inplanes = planes * block.expansion for i in range(1, blocks): layers.append( block(self.inplanes, planes, self.base_width, 1, dilation, self.norm, conv, context, self.ctx_ratio, self.radix, self.stride_3x3)) return nn.Sequential(*layers)
def __init__(self, aligned=False, use_se=False, use_global=False, avg_down=False, base_width=32, norm='bn', stage_with_conv=('normal', 'normal', 'normal', 'normal'), num_classes=1000): """ Constructor Args: layers: config of layers, e.g., (3, 4, 23, 3) num_classes: number of classes """ super(HRNet, self).__init__() block_1 = AlignedBottleneck if aligned else Bottleneck block_2 = AlignedBasicBlock if aligned else BasicBlock self.use_se = use_se self.avg_down = avg_down self.base_width = base_width self.norm = norm self.head_dim = (32, 64, 128, 256) self.inplanes = 64 # default 64 self.conv1 = nn.Conv2d(3, 64, 3, 2, 1, bias=False) self.bn1 = make_norm(64, norm=self.norm) self.conv2 = nn.Conv2d(64, 64, 3, 2, 1, bias=False) self.bn2 = make_norm(64, norm=self.norm) self.relu = nn.ReLU(inplace=True) self.layer1 = self._make_layer(block_1, 64, 4, 1, conv=stage_with_conv[0]) # 4 blocks without down sample self.transition1 = self._make_transition(index=1, stride=2) # Fusion layer 1: create full and 1/2 resolution self.stage2 = nn.Sequential( StageModule(block_2, base_width, norm, stage_with_conv[1], use_se, False, stage=2, output_branches=2), ) # Stage 2 with 1 group of block modules, which has 2 branches self.transition2 = self._make_transition(index=2, stride=2) # Fusion layer 2: create 1/4 resolution self.stage3 = nn.Sequential( StageModule(block_2, base_width, norm, stage_with_conv[2], use_se, use_global, stage=3, output_branches=3), StageModule(block_2, base_width, norm, stage_with_conv[2], use_se, use_global, stage=3, output_branches=3), StageModule(block_2, base_width, norm, stage_with_conv[2], use_se, use_global, stage=3, output_branches=3), StageModule(block_2, base_width, norm, stage_with_conv[2], use_se, use_global, stage=3, output_branches=3), ) # Stage 3 with 4 groups of block modules, which has 3 branches self.transition3 = self._make_transition(index=3, stride=2) # Fusion layer 3: create 1/8 resolution self.stage4 = nn.Sequential( StageModule(block_2, base_width, norm, stage_with_conv[3], use_se, use_global, stage=4, output_branches=4), StageModule(block_2, base_width, norm, stage_with_conv[3], use_se, use_global, stage=4, output_branches=4), StageModule(block_2, base_width, norm, stage_with_conv[3], use_se, use_global, stage=4, output_branches=4), ) # Stage 4 with 3 groups of block modules, which has 4 branches pre_stage_channels = [base_width, base_width * 2, base_width * 4, base_width * 8] self.incre_modules, self.downsamp_modules, self.final_layer = \ self._make_head(block_1, pre_stage_channels, outplanes=2048, conv=stage_with_conv[3]) self.avgpool = nn.AdaptiveAvgPool2d(1) self.classifier = nn.Linear(2048, num_classes) self._init_weights()
def __init__(self, use_se=False, widen_factor=1.0, norm='bn', activation=nn.ReLU6, drop_rate=0.0, num_classes=1000): """ Constructor Args: widen_factor: config of widen_factor num_classes: number of classes """ super(MobileNetV2, self).__init__() block = LinearBottleneck self.use_se = use_se self.widen_factor = widen_factor self.norm = norm self.drop_rate = drop_rate self.activation_type = activation try: self.activation = activation(inplace=True) except: self.activation = activation() layers_cfg = model_se(MV2_CFG['A']) if self.use_se else MV2_CFG['A'] num_of_channels = [lc[-1][1] for lc in layers_cfg[1:-1]] self.channels = [make_divisible(ch * self.widen_factor, 8) for ch in num_of_channels] self.inplanes = make_divisible(layers_cfg[0][0][1] * self.widen_factor, 8) self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=layers_cfg[0][0][0], stride=layers_cfg[0][0][4], padding=layers_cfg[0][0][0] // 2, bias=False) self.bn1 = make_norm(self.inplanes, norm=self.norm) self.layer0 = self._make_layer(block, layers_cfg[1], dilation=1) self.layer1 = self._make_layer(block, layers_cfg[2], dilation=1) self.layer2 = self._make_layer(block, layers_cfg[3], dilation=1) self.layer3 = self._make_layer(block, layers_cfg[4], dilation=1) self.layer4 = self._make_layer(block, layers_cfg[5], dilation=1) out_ch = layers_cfg[-1][-1][1] self.conv_out = nn.Conv2d(self.inplanes, out_ch, kernel_size=layers_cfg[-1][-1][0], stride=layers_cfg[-1][-1][4], padding=layers_cfg[-1][-1][0] // 2, bias=False) self.bn_out = make_norm(out_ch, norm=self.norm) self.avgpool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(out_ch, num_classes) self._init_weights()
def _make_transition(self, index=1, stride=1): transition = nn.ModuleList() if index == 1: transition.append(nn.Sequential( nn.Conv2d(self.inplanes, self.base_width, kernel_size=3, stride=1, padding=1, bias=False), make_norm(self.base_width, norm=self.norm), nn.ReLU(inplace=True), )) else: transition.extend([nn.Sequential() for _ in range(index)]) transition.append(nn.Sequential( nn.Sequential( # Double Sequential to fit with official pre-trained weights nn.Conv2d(self.inplanes if index == 1 else self.base_width * (2 ** (index - 1)), self.base_width * (2 ** index), kernel_size=3, stride=stride, padding=1, bias=False), make_norm(self.base_width * (2 ** index), norm=self.norm), nn.ReLU(inplace=True), ) )) return transition
def __init__(self, inplanes, planes, outplanes, num_conv=5, dilation=1, norm='bn', conv='normal', identity=False): super(OSABlock, self).__init__() if conv == 'normal': conv_op = nn.Conv2d elif conv == 'deform': conv_op = ops.DeformConvPack elif conv == 'deformv2': conv_op = ops.ModulatedDeformConvPack else: raise ValueError( '{} type conv operation is not supported.'.format(conv)) self.identity = identity self.layers = nn.ModuleList() dim_in = inplanes for i in range(num_conv): self.layers.append( nn.Sequential( conv_op(dim_in, planes, kernel_size=3, stride=1, dilation=dilation, padding=dilation, bias=False), make_norm(planes, norm=norm), nn.ReLU(inplace=True))) dim_in = planes # feature aggregation dim_in = inplanes + num_conv * planes self.concat = nn.Sequential( conv_op(dim_in, outplanes, kernel_size=1, stride=1, bias=False), make_norm(outplanes, norm=norm), nn.ReLU(inplace=True))
def __init__(self, inplanes, outplanes, stride=1, dilation=1, kernel=3, groups=(1, 1), t=6, norm='bn', se_ratio=0, activation=nn.ReLU6): super(LinearBottleneck, self).__init__() padding = (dilation * kernel - dilation) // 2 self.stride = stride self.inplanes, self.outplanes, innerplanes = int(inplanes), int(outplanes), int(inplanes * abs(t)) self.t = t if self.t != 1: self.conv1 = nn.Conv2d(self.inplanes, innerplanes, kernel_size=1, padding=0, stride=1, groups=groups[0], bias=False) self.bn1 = make_norm(innerplanes, norm=norm) self.conv2 = nn.Conv2d(innerplanes, innerplanes, kernel_size=kernel, padding=padding, stride=stride, dilation=dilation, groups=innerplanes, bias=False) self.bn2 = make_norm(innerplanes, norm=norm) self.se = ops.SeConv2d(innerplanes, int(self.inplanes * se_ratio), activation) if se_ratio else None self.conv3 = nn.Conv2d(innerplanes, self.outplanes, kernel_size=1, padding=0, stride=1, groups=groups[1], bias=False) self.bn3 = make_norm(self.outplanes, norm=norm) try: self.activation = activation(inplace=True) except: self.activation = activation()
def _make_layer(self, block, planes, blocks, stride=1, dilation=1, conv='normal'): downsample = None if stride != 1 or self.inplanes != planes * block.expansion: if self.avg_down: downsample = nn.Sequential( nn.AvgPool2d(kernel_size=stride, stride=stride), nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=1, bias=False), make_norm(planes * block.expansion, norm=self.norm), ) else: downsample = nn.Sequential( nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False), make_norm(planes * block.expansion, norm=self.norm), ) layers = [] layers.append(block(self.inplanes, planes, stride, dilation, self.norm, conv, self.use_se, True, downsample)) self.inplanes = planes * block.expansion for i in range(1, blocks): layers.append(block(self.inplanes, planes, 1, dilation, self.norm, conv, self.use_se, True)) return nn.Sequential(*layers)
def __init__(self, inplanes, planes, stride=1, dilation=1, norm='bn', conv='normal', use_se=False, stride_3x3=False, downsample=None): super(Bottleneck, self).__init__() if conv == 'normal': conv_op = nn.Conv2d elif conv == 'deform': conv_op = ops.DeformConvPack elif conv == 'deformv2': conv_op = ops.ModulatedDeformConvPack else: raise ValueError('{} type conv operation is not supported.'.format(conv)) (str1x1, str3x3) = (1, stride) if stride_3x3 else (stride, 1) self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, stride=str1x1, bias=False) self.bn1 = make_norm(planes, norm=norm) self.conv2 = conv_op(planes, planes, kernel_size=3, stride=str3x3, dilation=dilation, padding=dilation, bias=False) self.bn2 = make_norm(planes, norm=norm) self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False) self.bn3 = make_norm(planes * 4, norm=norm) self.se = ops.Se2d(planes * 4, reduction=16) if use_se else None self.relu = nn.ReLU(inplace=True) self.downsample = downsample
def __init__(self, norm='bn', activation=nn.ReLU6, stride=32): """ Constructor """ super(MobileNetV2, self).__init__() block = mv2.LinearBottleneck self.use_se = cfg.BACKBONE.MV2.USE_SE self.widen_factor = cfg.BACKBONE.MV2.WIDEN_FACTOR self.norm = norm self.activation_type = activation try: self.activation = activation(inplace=True) except: self.activation = activation() self.stride = stride layers_cfg = mv2.model_se( mv2.MV2_CFG['A']) if self.use_se else mv2.MV2_CFG['A'] num_of_channels = [lc[-1][1] for lc in layers_cfg[1:-1]] self.channels = [ make_divisible(ch * self.widen_factor, 8) for ch in num_of_channels ] self.layers = [len(lc) for lc in layers_cfg[2:-1]] self.inplanes = make_divisible(layers_cfg[0][0][1] * self.widen_factor, 8) self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=layers_cfg[0][0][0], stride=layers_cfg[0][0][4], padding=layers_cfg[0][0][0] // 2, bias=False) self.bn1 = make_norm(self.inplanes, norm=self.norm) self.layer0 = self._make_layer(block, layers_cfg[1], dilation=1) self.layer1 = self._make_layer(block, layers_cfg[2], dilation=1) self.layer2 = self._make_layer(block, layers_cfg[3], dilation=1) self.layer3 = self._make_layer(block, layers_cfg[4], dilation=1) self.layer4 = self._make_layer(block, layers_cfg[5], dilation=1) self.spatial_scale = [1 / 4., 1 / 8., 1 / 16., 1 / 32.] self.dim_out = self.stage_out_dim[1:int(math.log(self.stride, 2))] del self.conv_out del self.bn_out del self.avgpool del self.fc self._init_weights() self._init_modules()
def __init__(self, norm='bn', activation=mv3.H_Swish, stride=32): """ Constructor """ super(MobileNetV3, self).__init__() block = mv3.LinearBottleneck self.widen_factor = cfg.BACKBONE.MV3.WIDEN_FACTOR self.norm = norm self.se_reduce_mid = cfg.BACKBONE.MV3.SE_REDUCE_MID self.se_divisible = cfg.BACKBONE.MV3.SE_DIVISIBLE self.head_use_bias = cfg.BACKBONE.MV3.HEAD_USE_BIAS self.force_residual = cfg.BACKBONE.MV3.FORCE_RESIDUAL self.sync_se_act = cfg.BACKBONE.MV3.SYNC_SE_ACT self.bn_eps = cfg.BACKBONE.BN_EPS self.activation_type = activation self.stride = stride setting = cfg.BACKBONE.MV3.SETTING layers_cfg = mv3.MV3_CFG[setting] num_of_channels = [lc[-1][1] for lc in layers_cfg[1:-1]] self.channels = [make_divisible(ch * self.widen_factor, 8) for ch in num_of_channels] self.activation = activation() if layers_cfg[0][0][3] else nn.ReLU(inplace=True) self.layers = [len(lc) for lc in layers_cfg[2:-1]] self.inplanes = make_divisible(layers_cfg[0][0][1] * self.widen_factor, 8) self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=layers_cfg[0][0][0], stride=layers_cfg[0][0][4], padding=layers_cfg[0][0][0] // 2, bias=False) self.bn1 = make_norm(self.inplanes, norm=self.norm, eps=self.bn_eps) self.layer0 = self._make_layer(block, layers_cfg[1], dilation=1) if layers_cfg[1][0][0] else None self.layer1 = self._make_layer(block, layers_cfg[2], dilation=1) self.layer2 = self._make_layer(block, layers_cfg[3], dilation=1) self.layer3 = self._make_layer(block, layers_cfg[4], dilation=1) self.layer4 = self._make_layer(block, layers_cfg[5], dilation=1) self.spatial_scale = [1 / 4., 1 / 8., 1 / 16., 1 / 32.] self.dim_out = self.stage_out_dim[1:int(math.log(self.stride, 2))] del self.last_stage del self.avgpool del self.conv_out del self.fc self._init_weights() self._init_modules()
def __init__(self, norm='bn', stride=32): """ Constructor """ super(HRNet, self).__init__() block_1 = hr.AlignedBottleneck if cfg.BACKBONE.HRNET.USE_ALIGN else hr.Bottleneck block_2 = hr.AlignedBasicBlock if cfg.BACKBONE.HRNET.USE_ALIGN else hr.BasicBlock use_se = cfg.BACKBONE.HRNET.USE_SE self.use_se = use_se self.use_global = cfg.BACKBONE.HRNET.USE_GLOBAL self.avg_down = cfg.BACKBONE.HRNET.AVG_DOWN base_width = cfg.BACKBONE.HRNET.WIDTH self.base_width = base_width self.norm = norm self.stride = stride stage_with_conv = cfg.BACKBONE.HRNET.STAGE_WITH_CONV self.inplanes = 64 # default 64 self.conv1 = nn.Conv2d(3, 64, 3, 2, 1, bias=False) self.bn1 = make_norm(64, norm=self.norm) self.conv2 = nn.Conv2d(64, 64, 3, 2, 1, bias=False) self.bn2 = make_norm(64, norm=self.norm) self.relu = nn.ReLU(inplace=True) self.layer1 = self._make_layer( block_1, 64, 4, 1, conv=stage_with_conv[0]) # 4 blocks without down sample self.transition1 = self._make_transition( index=1, stride=2) # Fusion layer 1: create full and 1/2 resolution self.stage2 = nn.Sequential( hr.StageModule(block_2, base_width, norm, stage_with_conv[1], use_se, False, 2, 2), ) # Stage 2 with 1 group of block modules, which has 2 branches self.transition2 = self._make_transition( index=2, stride=2) # Fusion layer 2: create 1/4 resolution self.stage3 = nn.Sequential( hr.StageModule(block_2, base_width, norm, stage_with_conv[2], use_se, self.use_global, 3, 3), hr.StageModule(block_2, base_width, norm, stage_with_conv[2], use_se, self.use_global, 3, 3), hr.StageModule(block_2, base_width, norm, stage_with_conv[2], use_se, self.use_global, 3, 3), hr.StageModule(block_2, base_width, norm, stage_with_conv[2], use_se, self.use_global, 3, 3), ) # Stage 3 with 4 groups of block modules, which has 3 branches self.transition3 = self._make_transition( index=3, stride=2) # Fusion layer 3: create 1/8 resolution self.stage4 = nn.Sequential( hr.StageModule(block_2, base_width, norm, stage_with_conv[3], use_se, self.use_global, 4, 4), hr.StageModule(block_2, base_width, norm, stage_with_conv[3], use_se, self.use_global, 4, 4), hr.StageModule(block_2, base_width, norm, stage_with_conv[3], use_se, self.use_global, 4, 4), # multi out ) # Stage 4 with 3 groups of block modules, which has 4 branches self.spatial_scale = [1 / 4., 1 / 8., 1 / 16., 1 / 32.] self.dim_out = self.stage_out_dim[1:int(math.log(self.stride, 2))] del self.incre_modules del self.downsamp_modules del self.final_layer del self.avgpool del self.classifier self._init_weights() self._init_modules()
def __init__(self, inplanes, planes, base_width=64, stride=1, dilation=1, norm='bn', conv='normal', context='none', ctx_ratio=0.0625, radix=1, stride_3x3=False, downsample=None): super(Bottleneck, self).__init__() if conv == 'normal': conv_op = nn.Conv2d elif conv == 'deform': conv_op = ops.DeformConvPack elif conv == 'deformv2': conv_op = ops.ModulatedDeformConvPack else: raise ValueError( '{} type conv operation is not supported.'.format(conv)) (str1x1, str3x3) = (1, stride) if stride_3x3 else (stride, 1) width = int(planes * (base_width / 64.)) self.radix = radix self.conv1 = nn.Conv2d(inplanes, width, kernel_size=1, stride=str1x1, bias=False) self.bn1 = make_norm(width, norm=norm.split('_')[-1]) if radix > 1 and (str3x3 > 1 or dilation > 1): self.avd_layer = nn.AvgPool2d(3, str3x3, padding=1) str3x3 = 1 else: self.avd_layer = None if radix > 1: self.conv2 = ops.SplAtConv2d(width, width, kernel_size=3, stride=str3x3, padding=dilation, dilation=dilation, bias=False, radix=radix) else: self.conv2 = conv_op(width, width, kernel_size=3, stride=str3x3, dilation=dilation, padding=dilation, bias=False) self.bn2 = make_norm(width, norm=norm, an_k=10 if planes < 256 else 20) self.conv3 = nn.Conv2d(width, planes * self.expansion, kernel_size=1, bias=False) self.bn3 = make_norm(planes * self.expansion, norm=norm.split('_')[-1]) if context == 'none': self.ctx = None elif context == 'se': self.ctx = ops.SeConv2d(planes * self.expansion, int(planes * self.expansion * ctx_ratio)) elif context == 'gcb': self.ctx = ops.GlobalContextBlock( planes * self.expansion, int(planes * self.expansion * ctx_ratio)) elif context == 'nonlocal': self.ctx = ops.NonLocal2d(planes * self.expansion, int(planes * self.expansion * ctx_ratio), planes * self.expansion, use_gn=True) elif context == 'msa': self.ctx = ops.MS_NonLocal2d(planes * self.expansion, int(planes * self.expansion * ctx_ratio), planes * self.expansion, use_gn=True) else: raise ValueError( '{} type context operation is not supported.'.format(context)) self.relu = nn.ReLU(inplace=True) self.downsample = downsample
def __init__(self, base_width=64, stage_dims=(128, 160, 192, 224), concat_dims=(256, 512, 768, 1024), layers=(1, 1, 2, 2), num_conv=5, norm='bn', stage_with_conv=('normal', 'normal', 'normal', 'normal'), num_classes=1000): """ Constructor Args: layers: config of layers, e.g., (1, 1, 2, 2) num_classes: number of classes """ super(VoVNet, self).__init__() block = OSABlock self.num_conv = num_conv self.norm = norm self.channels = [base_width] + list(concat_dims) self.inplanes = base_width self.conv1 = nn.Conv2d(3, self.inplanes, 3, 2, 1, bias=False) self.bn1 = make_norm(self.inplanes, norm=self.norm) self.conv2 = nn.Conv2d(self.inplanes, self.inplanes, 3, 1, 1, bias=False) self.bn2 = make_norm(self.inplanes, norm=self.norm) self.conv3 = nn.Conv2d(self.inplanes, self.inplanes * 2, 3, 2, 1, bias=False) self.bn3 = make_norm(self.inplanes * 2, norm=self.norm) self.relu = nn.ReLU(inplace=True) self.inplanes = self.inplanes * 2 self.layer1 = self._make_layer(block, stage_dims[0], concat_dims[0], layers[0], 1, conv=stage_with_conv[0]) self.layer2 = self._make_layer(block, stage_dims[1], concat_dims[1], layers[1], 2, conv=stage_with_conv[1]) self.layer3 = self._make_layer(block, stage_dims[2], concat_dims[2], layers[2], 2, conv=stage_with_conv[2]) self.layer4 = self._make_layer(block, stage_dims[3], concat_dims[3], layers[3], 2, conv=stage_with_conv[3]) self.avgpool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(self.inplanes, num_classes) self._init_weights()
def __init__(self, bottleneck=True, aligned=False, use_3x3x3stem=False, stride_3x3=False, avg_down=False, stem_width=64, base_width=64, layers=(3, 4, 6, 3), norm='bn', stage_with_conv=('normal', 'normal', 'normal', 'normal'), stage_with_context=('none', 'none', 'none', 'none'), ctx_ratio=16, radix=1, num_classes=1000): """ Constructor Args: layers: config of layers, e.g., (3, 4, 23, 3) num_classes: number of classes """ super(ResNet, self).__init__() if aligned: block = AlignedBottleneck else: if bottleneck: block = Bottleneck else: block = BasicBlock self.expansion = block.expansion self.stride_3x3 = stride_3x3 self.avg_down = avg_down self.base_width = base_width self.norm = norm self.ctx_ratio = ctx_ratio self.radix = radix self.inplanes = stem_width self.use_3x3x3stem = use_3x3x3stem if not self.use_3x3x3stem: self.conv1 = nn.Conv2d(3, self.inplanes, 7, 2, 3, bias=False) self.bn1 = make_norm(self.inplanes, norm=self.norm.split('_')[-1]) else: self.conv1 = nn.Conv2d(3, self.inplanes // 2, 3, 2, 1, bias=False) self.bn1 = make_norm(self.inplanes // 2, norm=self.norm.split('_')[-1]) self.conv2 = nn.Conv2d(self.inplanes // 2, self.inplanes // 2, 3, 1, 1, bias=False) self.bn2 = make_norm(self.inplanes // 2, norm=self.norm.split('_')[-1]) self.conv3 = nn.Conv2d(self.inplanes // 2, self.inplanes, 3, 1, 1, bias=False) self.bn3 = make_norm(self.inplanes, norm=self.norm.split('_')[-1]) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0], 1, conv=stage_with_conv[0], context=stage_with_context[0]) self.layer2 = self._make_layer(block, 128, layers[1], 2, conv=stage_with_conv[1], context=stage_with_context[1]) self.layer3 = self._make_layer(block, 256, layers[2], 2, conv=stage_with_conv[2], context=stage_with_context[2]) self.layer4 = self._make_layer(block, 512, layers[3], 2, conv=stage_with_conv[3], context=stage_with_context[3]) self.avgpool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(512 * self.expansion, num_classes) self._init_weights()
def __init__(self, norm='bn', activation=nn.ReLU, stride=32): """ Constructor """ super(MobileNetV1, self).__init__() block = mv1.BasicBlock self.use_se = cfg.BACKBONE.MV1.USE_SE self.norm = norm self.activation_type = activation try: self.activation = activation(inplace=True) except: self.activation = activation() self.stride = stride layers = cfg.BACKBONE.MV1.LAYERS[:int(math.log(stride, 2)) - 1] self.layers = layers kernel = cfg.BACKBONE.MV1.KERNEL c5_dilation = cfg.BACKBONE.MV1.C5_DILATION num_of_channels = cfg.BACKBONE.MV1.NUM_CHANNELS channels = [ make_divisible(ch * cfg.BACKBONE.MV1.WIDEN_FACTOR, 8) for ch in num_of_channels ] self.channels = channels self.conv1 = nn.Conv2d(3, channels[0], kernel_size=3, stride=2, padding=1, bias=False) self.bn1 = make_norm(channels[0], norm=self.norm) self.conv2 = nn.Conv2d(channels[0], channels[0], kernel_size=kernel, stride=1, padding=kernel // 2, groups=channels[0], bias=False) self.bn2 = make_norm(channels[0], norm=self.norm) self.conv3 = nn.Conv2d(channels[0], channels[1], kernel_size=1, stride=1, padding=0, bias=False) self.bn3 = make_norm(channels[1], norm=self.norm) self.inplanes = channels[1] self.layer1 = self._make_layer(block, channels[2], layers[0], stride=2, dilation=1, kernel=kernel) self.layer2 = self._make_layer(block, channels[3], layers[1], stride=2, dilation=1, kernel=kernel) self.layer3 = self._make_layer(block, channels[4], layers[2], stride=2, dilation=1, kernel=kernel) self.layer4 = self._make_layer(block, channels[5], layers[3], stride=1 if c5_dilation != 1 else 2, dilation=c5_dilation, kernel=kernel) self.spatial_scale = [1 / 4., 1 / 8., 1 / 16., 1 / 32. * c5_dilation] self.dim_out = self.stage_out_dim[1:int(math.log(self.stride, 2))] self.dropblock = ops.DropBlock2D( keep_prob=0.9, block_size=7) if cfg.BACKBONE.MV1.USE_DP else None del self.avgpool del self.fc self._init_weights() self._init_modules()
def __init__(self, inplanes, planes, base_width=64, stride=1, dilation=1, norm='bn', conv='normal', context='none', ctx_ratio=0.0625, stride_3x3=False, downsample=None): super(AlignedBottleneck, self).__init__() if conv == 'normal': conv_op = nn.Conv2d elif conv == 'deform': conv_op = ops.DeformConvPack elif conv == 'deformv2': conv_op = ops.ModulatedDeformConvPack else: raise ValueError( '{} type conv operation is not supported.'.format(conv)) width = int(planes * (base_width / 64.)) self.conv1_1 = nn.Conv2d(inplanes, width, kernel_size=1, stride=1, padding=0, bias=False) self.bn1_1 = make_norm(width, norm=norm.split('_')[-1]) self.conv1_2 = conv_op(width, width, kernel_size=3, stride=stride, dilation=dilation, padding=dilation, bias=False) self.conv2_1 = nn.Conv2d(inplanes, width // 2, kernel_size=1, stride=1, padding=0, bias=False) self.bn2_1 = make_norm(width // 2, norm=norm.split('_')[-1]) self.conv2_2 = conv_op(width // 2, width // 2, kernel_size=3, stride=stride, dilation=dilation, padding=dilation, bias=False) self.bn2_2 = make_norm(width // 2, norm=norm, an_k=10 if planes < 256 else 20) self.conv2_3 = conv_op(width // 2, width // 2, kernel_size=3, stride=1, dilation=dilation, padding=dilation, bias=False) self.bn_concat = make_norm(width + (width // 2), norm=norm, an_k=10 if planes < 256 else 20) self.conv = nn.Conv2d(width + (width // 2), planes * self.expansion, kernel_size=1, stride=1, padding=0, bias=False) self.bn = make_norm(planes * self.expansion, norm=norm.split('_')[-1]) if context == 'none': self.ctx = None elif context == 'se': self.ctx = ops.SeConv2d(planes * self.expansion, int(planes * self.expansion * ctx_ratio)) elif context == 'gcb': self.ctx = ops.GlobalContextBlock( planes * self.expansion, int(planes * self.expansion * ctx_ratio)) else: raise ValueError( '{} type context operation is not supported.'.format(context)) self.relu = nn.ReLU(inplace=True) self.downsample = downsample
def __init__(self, inplanes, planes, base_width, cardinality, stride=1, dilation=1, norm='bn', conv='normal', context='none', ctx_ratio=0.0625, downsample=None): """ Constructor Args: inplanes: input channel dimensionality planes: output channel dimensionality base_width: base width. cardinality: num of convolution groups. stride: conv stride. Replaces pooling layer. """ super(Bottleneck, self).__init__() D = int(math.floor(planes * (base_width / 64.0))) C = cardinality if conv == 'normal': conv_op = nn.Conv2d elif conv == 'deform': conv_op = ops.DeformConvPack elif conv == 'deformv2': conv_op = ops.ModulatedDeformConvPack else: raise ValueError( '{} type conv operation is not supported.'.format(conv)) self.conv1 = nn.Conv2d(inplanes, D * C, kernel_size=1, stride=1, padding=0, bias=False) self.bn1 = make_norm(D * C, norm=norm) self.conv2 = conv_op(D * C, D * C, kernel_size=3, stride=stride, dilation=dilation, padding=dilation, groups=C, bias=False) self.bn2 = make_norm(D * C, norm=norm) self.conv3 = nn.Conv2d(D * C, planes * 4, kernel_size=1, stride=1, padding=0, bias=False) self.bn3 = make_norm(planes * 4, norm=norm) if context == 'none': self.ctx = None elif context == 'se': self.ctx = ops.SeConv2d(planes * 4, int(planes * 4 * ctx_ratio)) elif context == 'gcb': self.ctx = ops.GlobalContextBlock(planes * 4, int(planes * 4 * ctx_ratio)) else: raise ValueError( '{} type context operation is not supported.'.format(context)) self.relu = nn.ReLU(inplace=True) self.downsample = downsample
def __init__(self, use_se=False, widen_factor=1.0, kernel=3, layers=(2, 2, 6, 2), norm='bn', activation=nn.ReLU, drop_rate=0.0, num_classes=1000): """ Constructor Args: widen_factor: config of widen_factor num_classes: number of classes """ super(MobileNetV1, self).__init__() block = BasicBlock self.use_se = use_se self.norm = norm self.drop_rate = drop_rate self.activation_type = activation try: self.activation = activation(inplace=True) except: self.activation = activation() num_of_channels = [32, 64, 128, 256, 512, 1024] channels = [ make_divisible(ch * widen_factor, 8) for ch in num_of_channels ] self.channels = channels self.conv1 = nn.Conv2d(3, channels[0], kernel_size=3, stride=2, padding=1, bias=False) self.bn1 = make_norm(channels[0], norm=self.norm) self.conv2 = nn.Conv2d(channels[0], channels[0], kernel_size=kernel, stride=1, padding=kernel // 2, groups=channels[0], bias=False) self.bn2 = make_norm(channels[0], norm=self.norm) self.conv3 = nn.Conv2d(channels[0], channels[1], kernel_size=1, stride=1, padding=0, bias=False) self.bn3 = make_norm(channels[1], norm=self.norm) self.inplanes = channels[1] self.layer1 = self._make_layer(block, channels[2], layers[0], stride=2, dilation=1, kernel=kernel) self.layer2 = self._make_layer(block, channels[3], layers[1], stride=2, dilation=1, kernel=kernel) self.layer3 = self._make_layer(block, channels[4], layers[2], stride=2, dilation=1, kernel=kernel) self.layer4 = self._make_layer(block, channels[5], layers[3], stride=2, dilation=1, kernel=kernel) self.avgpool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(channels[5], num_classes) self._init_weights()
def __init__(self, norm='bn', stride=32): """ Constructor """ super(ResNet, self).__init__() if cfg.BACKBONE.RESNET.USE_ALIGN: block = res.AlignedBottleneck else: if cfg.BACKBONE.RESNET.BOTTLENECK: block = res.Bottleneck # not use the original Bottleneck module else: block = res.BasicBlock self.expansion = block.expansion self.stride_3x3 = cfg.BACKBONE.RESNET.STRIDE_3X3 self.avg_down = cfg.BACKBONE.RESNET.AVG_DOWN self.norm = norm self.stride = stride layers = cfg.BACKBONE.RESNET.LAYERS[:int(math.log(stride, 2)) - 1] self.layers = layers self.base_width = cfg.BACKBONE.RESNET.WIDTH stage_with_context = cfg.BACKBONE.RESNET.STAGE_WITH_CONTEXT self.ctx_ratio = cfg.BACKBONE.RESNET.CTX_RATIO stage_with_conv = cfg.BACKBONE.RESNET.STAGE_WITH_CONV c5_dilation = cfg.BACKBONE.RESNET.C5_DILATION self.inplanes = 64 self.use_3x3x3stem = cfg.BACKBONE.RESNET.USE_3x3x3HEAD if not self.use_3x3x3stem: self.conv1 = nn.Conv2d(3, self.inplanes, 7, 2, 3, bias=False) self.bn1 = make_norm(self.inplanes, norm=self.norm.split('_')[-1]) else: self.conv1 = nn.Conv2d(3, self.inplanes // 2, 3, 2, 1, bias=False) self.bn1 = make_norm(self.inplanes // 2, norm=self.norm.split('_')[-1]) self.conv2 = nn.Conv2d(self.inplanes // 2, self.inplanes // 2, 3, 1, 1, bias=False) self.bn2 = make_norm(self.inplanes // 2, norm=self.norm.split('_')[-1]) self.conv3 = nn.Conv2d(self.inplanes // 2, self.inplanes, 3, 1, 1, bias=False) self.bn3 = make_norm(self.inplanes, norm=self.norm.split('_')[-1]) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0], 1, conv=stage_with_conv[0], context=stage_with_context[0]) self.layer2 = self._make_layer(block, 128, layers[1], 2, conv=stage_with_conv[1], context=stage_with_context[1]) self.layer3 = self._make_layer(block, 256, layers[2], 2, conv=stage_with_conv[2], context=stage_with_context[2]) if len(layers) == 4: if c5_dilation != 1: c5_stride = 1 else: c5_stride = 2 self.layer4 = self._make_layer(block, 512, layers[3], c5_stride, dilation=c5_dilation, conv=stage_with_conv[3], context=stage_with_context[3]) self.spatial_scale = [ 1 / 4., 1 / 8., 1 / 16., 1 / 32. * c5_dilation ] else: del self.layer4 self.spatial_scale = [1 / 4., 1 / 8., 1 / 16.] self.dim_out = self.stage_out_dim[1:int(math.log(self.stride, 2))] del self.avgpool del self.fc self._init_weights() self._init_modules()
def __init__(self, norm='bn', stride=32): """ Constructor """ super(VoVNet, self).__init__() block = vov.OSABlock self.num_conv = cfg.BACKBONE.VOV.NUM_CONV # 5 self.norm = norm self.stride = stride base_width = cfg.BACKBONE.VOV.WIDTH # 64 stage_dims = cfg.BACKBONE.VOV.STAGE_DIMS concat_dims = cfg.BACKBONE.VOV.CONCAT_DIMS layers = cfg.BACKBONE.VOV.LAYERS self.layers = layers stage_with_conv = cfg.BACKBONE.VOV.STAGE_WITH_CONV self.channels = [base_width] + list(concat_dims) self.inplanes = base_width self.conv1 = nn.Conv2d(3, self.inplanes, 3, 2, 1, bias=False) self.bn1 = make_norm(self.inplanes, norm=self.norm) self.conv2 = nn.Conv2d(self.inplanes, self.inplanes, 3, 1, 1, bias=False) self.bn2 = make_norm(self.inplanes, norm=self.norm) self.conv3 = nn.Conv2d(self.inplanes, self.inplanes * 2, 3, 2, 1, bias=False) self.bn3 = make_norm(self.inplanes * 2, norm=self.norm) self.relu = nn.ReLU(inplace=True) self.inplanes = self.inplanes * 2 self.layer1 = self._make_layer(block, stage_dims[0], concat_dims[0], layers[0], 1, conv=stage_with_conv[0]) self.layer2 = self._make_layer(block, stage_dims[1], concat_dims[1], layers[1], 2, conv=stage_with_conv[1]) self.layer3 = self._make_layer(block, stage_dims[2], concat_dims[2], layers[2], 2, conv=stage_with_conv[2]) self.layer4 = self._make_layer(block, stage_dims[3], concat_dims[3], layers[3], 2, conv=stage_with_conv[3]) self.spatial_scale = [1 / 4., 1 / 8., 1 / 16., 1 / 32.] self.dim_out = self.stage_out_dim[1:int(math.log(self.stride, 2))] del self.avgpool del self.fc self._init_weights() self._init_modules()