def __init__(self, mult=1.0, feature_levels=(3, 4, 5), pretrained=True, include_final=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels net = ptcv_get_model(self.mult2name[mult], pretrained=pretrained) del net.output net = net.features self.layer1 = net.init_block.conv self.layer2 = net.init_block.pool self.layer3 = net.stage1 self.layer4 = net.stage2 if include_final: self.layer5 = nn.Sequential( net.stage3, net.final_block, ) else: self.layer5 = net.stage3 out_channels = [ get_out_channels(self.layer1), get_out_channels(self.layer1), calc_out_channels(self.layer3), calc_out_channels(self.layer4), calc_out_channels(self.layer5), ] self.out_channels = [out_channels[i - 1] for i in feature_levels]
def __init__(self, version=27, feature_levels=(3, 4, 5), pretrained=False, no_down=0, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels assert not pretrained, "Pretrained models are not avaliable now." if no_down != 0: assert feature_levels == (3, 4) and no_down == -1 backbone = get_vovnet(version) del backbone.output f = backbone.features self.layer1 = f.init_block self.layer2 = f.stage1 self.layer3 = f.stage2 if no_down == 0: self.layer4 = f.stage3 self.layer5 = nn.Sequential(f.stage4, f.post_activ) else: conv_to_atrous(f.stage4, rate=2) del f.stage4.pool self.layer4 = nn.Sequential(f.stage3, f.stage4, f.post_activ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, version=27, feature_levels=(3, 4, 5), pretrained=True, no_down=0, atrous=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels if no_down != 0: assert feature_levels == (3, 4) and no_down == -1 backbone = self.version2name[version](pretrained=pretrained) del backbone.classifier self.layer1 = backbone.stem[:6] self.layer2 = nn.Sequential( backbone.stem[6:], backbone.stage2, ) self.layer3 = backbone.stage3 if no_down: del backbone.stage5.Pooling if atrous: conv_to_atrous(backbone.stage5, rate=2) self.layer4 = nn.Sequential( backbone.stage4, backbone.stage5 ) else: self.layer4 = backbone.stage4 self.layer5 = backbone.stage5 self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, name, feature_levels=(3, 4, 5), pretrained=True): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels net = torch.hub.load('zhanghang1989/ResNeSt', name, pretrained=pretrained) del net.fc self.layer1 = nn.Sequential( net.conv1, net.bn1, net.relu, ) self.layer2 = nn.Sequential( net.maxpool, net.layer1, ) self.layer3 = net.layer2 self.layer4 = net.layer3 self.layer5 = net.layer4 self.out_channels = np.array([ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ])
def __init__(self, feature_levels=(3, 4, 5), pretrained=True, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels backbone = mobilenetv3_large(pretrained=pretrained) del backbone.classifier features = backbone.features self.layer1 = features[:2] self.layer2 = nn.Sequential( features[2:4], features[4].conv[:3], ) self.layer3 = nn.Sequential( features[4].conv[3:], *features[5:7], features[7].conv[:3], ) self.layer4 = nn.Sequential( features[7].conv[3:], *features[8:13], features[13].conv[:3], ) self.layer5 = nn.Sequential(features[13].conv[3:], *features[14:], backbone.conv) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, width_mult=1.0, depth_coef=1.0, feature_levels=(3, 4, 5), pretrained=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.out_levels = feature_levels if pretrained: raise NotImplementedError( "Pretrained models for EfficientNet are not provided.") else: net = BEfficientNet(width_mult=width_mult, depth_coef=depth_coef, drop_connect=0, num_classes=1, **kwargs) del net.classifier net = net.features self.layer1 = nn.Sequential( net.init_block, net.stage1, net.stage2.unit1.expand, ) self.layer2 = nn.Sequential( net.stage2.unit1.dwconv, net.stage2.unit1.se, net.stage2.unit1.project, net.stage2.unit2, net.stage3.unit1.expand, ) self.layer3 = nn.Sequential( net.stage3.unit1.dwconv, net.stage3.unit1.se, net.stage3.unit1.project, *net.stage3[1:], net.stage4.unit1.expand, ) self.layer4 = nn.Sequential( net.stage4.unit1.dwconv, net.stage4.unit1.se, net.stage4.unit1.project, *net.stage4[1:], net.stage5.unit1.expand, ) self.layer5 = nn.Sequential( net.stage5.unit1.dwconv, net.stage5.unit1.se, net.stage5.unit1.project, *net.stage5[1:], net.final_block, ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, version='b0', feature_levels=(3, 4, 5), pretrained=True, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels name = 'efficientnet_%sc' % version backbone = ptcv_get_model(name, pretrained=pretrained) del backbone.output features = backbone.features self._kernel_sizes = [3] self._strides = [2] self.layer1 = nn.Sequential( features.init_block.conv, features.stage1, features.stage2.unit1.conv1, ) self._kernel_sizes.append(features.stage2.unit1.kernel_size) self._strides.append(features.stage2.unit1.stride) self.layer2 = nn.Sequential( features.stage2.unit1.conv2, features.stage2.unit1.se, features.stage2.unit1.conv3, features.stage2[1:], features.stage3.unit1.conv1, ) self._kernel_sizes.append(features.stage3.unit1.kernel_size) self._strides.append(features.stage3.unit1.stride) self.layer3 = nn.Sequential( features.stage3.unit1.conv2, features.stage3.unit1.se, features.stage3.unit1.conv3, features.stage3[1:], features.stage4.unit1.conv1, ) self._kernel_sizes.append(features.stage4.unit1.kernel_size) self._strides.append(features.stage4.unit1.stride) self.layer4 = nn.Sequential( features.stage4.unit1.conv2, features.stage4.unit1.se, features.stage4.unit1.conv3, features.stage4[1:], features.stage5.unit1.conv1, ) self._kernel_sizes.append(features.stage5.unit1.kernel_size) self._strides.append(features.stage5.unit1.stride) self.layer5 = nn.Sequential(features.stage5.unit1.conv2, features.stage5.unit1.se, features.stage5.unit1.conv3, features.stage5[1:], features.final_block) self.out_channels = np.array([ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ])
def __init__(self, mult=1.0, feature_levels=(3, 4, 5), pretrained=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.out_levels = feature_levels if pretrained: net = ptcv_get_model(self.mult2name[mult], pretrained=True) del net.output net = net.features self.layer1 = net.init_block.conv self.layer2 = net.init_block.pool self.layer3 = net.stage1 self.layer4 = net.stage2 self.layer5 = nn.Sequential( net.stage3, net.final_block, ) out_channels = [ get_out_channels(self.layer1), get_out_channels(self.layer1), calc_out_channels(self.layer3), calc_out_channels(self.layer4), calc_out_channels(self.layer5), ] else: from horch.models.re.shufflenet import shufflenet_v2 as BShuffleNetV2 net = BShuffleNetV2(mult=mult, **kwargs) channels = net.out_channels del net.fc self.layer1 = net.conv1 self.layer2 = net.maxpool self.layer3 = net.stage2 self.layer4 = net.stage3 self.layer5 = nn.Sequential( net.stage4, net.conv5, ) out_channels = [channels[0]] + channels[:3] + [channels[-1]] self.out_channels = [out_channels[i - 1] for i in feature_levels]
def __init__(self, version='b0', feature_levels=(3, 4, 5), pretrained=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels assert not pretrained, "Pretrained models are not avaliable now." net = efficientnet(version, num_classes=1, drop_connect=0, **kwargs) del net.classifier net = net.features self.layer1 = nn.Sequential( net.init_block, net.stage1, net.stage2.unit1.expand, ) self.layer2 = nn.Sequential( net.stage2.unit1.dwconv, net.stage2.unit1.se, net.stage2.unit1.project, net.stage2.unit2, net.stage3.unit1.expand, ) self.layer3 = nn.Sequential( net.stage3.unit1.dwconv, net.stage3.unit1.se, net.stage3.unit1.project, *net.stage3[1:], net.stage4.unit1.expand, ) self.layer4 = nn.Sequential( net.stage4.unit1.dwconv, net.stage4.unit1.se, net.stage4.unit1.project, *net.stage4[1:], net.stage5.unit1.expand, ) self.layer5 = nn.Sequential( net.stage5.unit1.dwconv, net.stage5.unit1.se, net.stage5.unit1.project, *net.stage5[1:], net.final_block, ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, feature_levels=(3, 4, 5), pretrained=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.out_levels = feature_levels if pretrained: net = ptcv_get_model("darknet53", pretrained=True) del net.output net = net.features self.layer1 = nn.Sequential( net.init_block, net.stage1, ) self.layer2 = net.stage2 self.layer3 = net.stage3 self.layer4 = net.stage4 self.layer5 = net.stage5 else: backbone = BDarknet(num_classes=1, **kwargs) del backbone.fc self.layer1 = nn.Sequential( backbone.conv0, backbone.down1, backbone.layer1, ) self.layer2 = nn.Sequential( backbone.down2, backbone.layer2, ) self.layer3 = nn.Sequential( backbone.down3, backbone.layer3, ) self.layer4 = nn.Sequential( backbone.down4, backbone.layer4, ) self.layer5 = nn.Sequential( backbone.down5, backbone.layer5, ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, mult=1.0, feature_levels=(3, 4, 5), pretrained=True, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels net = ptcv_get_model(self.mult2name[float(mult)], pretrained=pretrained) del net.output net = net.features self.layer1 = nn.Sequential( net.init_block, net.stage1, net.stage2.unit1.conv1, ) self.layer2 = nn.Sequential( net.stage2.unit1.conv2, net.stage2.unit1.conv3, net.stage2.unit2, net.stage3.unit1.conv1, ) self.layer3 = nn.Sequential( net.stage3.unit1.conv2, net.stage3.unit1.conv3, *net.stage3[1:], net.stage4.unit1.conv1, ) self.layer4 = nn.Sequential( net.stage4.unit1.conv2, net.stage4.unit1.conv3, *net.stage4[1:], net.stage5.unit1.conv1, ) self.layer5 = nn.Sequential( net.stage5.unit1.conv2, net.stage5.unit1.conv3, *net.stage5[1:], net.final_block, ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, feature_levels=(3, 4), pretrained=True): super().__init__() assert pretrained, "Only pretrained VGG16 is provided." self.feature_levels = feature_levels from torchvision.models import vgg16_bn backbone = vgg16_bn(pretrained=True) f = backbone.features f[6].ceil_mode = True f[13].ceil_mode = True f[23].ceil_mode = True f[33].ceil_mode = True f[43].kernel_size = (3, 3) f[43].stride = (1, 1) f[43].padding = (1, 1) conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6) fc6 = backbone.classifier[0] fc6_weight = fc6.weight.data.view(4096, 512, 7, 7) fc6_bias = fc6.bias.data conv6.weight.data = decimate(fc6_weight, m=[4, None, 3, 3]) conv6.bias.data = decimate(fc6_bias, m=[4]) conv7 = nn.Conv2d(1024, 1024, kernel_size=1) fc7 = backbone.classifier[3] fc7_weight = fc7.weight.data.view(4096, 4096, 1, 1) fc7_bias = fc7.bias.data conv7.weight.data = decimate(fc7_weight, m=[4, 4, None, None]) conv7.bias.data = decimate(fc7_bias, m=[4]) self.stage0 = f[:6] self.stage1 = f[6:13] self.stage2 = f[13:23] self.stage3 = f[23:33] self.stage4 = nn.Sequential( *f[33:], conv6, nn.BatchNorm2d(1024), nn.ReLU(inplace=True), conv7, nn.BatchNorm2d(1024), nn.ReLU(inplace=True), ) self.out_channels = [ get_out_channels(getattr(self, ("stage%d" % i))) for i in feature_levels ]
def __init__(self, version='mobile', feature_levels=(3, 4, 5), pretrained=True, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels name = 'proxylessnas_%s' % version backbone = ptcv_get_model(name, pretrained=pretrained) del backbone.output features = backbone.features self.layer1 = nn.Sequential( features.init_block, features.stage1, features.stage2.unit1.body.bc_conv, ) self.layer2 = nn.Sequential( features.stage2.unit1.body.dw_conv, features.stage2.unit1.body.pw_conv, features.stage2[1:], features.stage3.unit1.body.bc_conv, ) self.layer3 = nn.Sequential( features.stage3.unit1.body.dw_conv, features.stage3.unit1.body.pw_conv, features.stage3[1:], features.stage4.unit1.body.bc_conv, ) self.layer4 = nn.Sequential( features.stage4.unit1.body.dw_conv, features.stage4.unit1.body.pw_conv, features.stage4[1:], features.stage5.unit1.body.bc_conv, ) self.layer5 = nn.Sequential(features.stage5.unit1.body.dw_conv, features.stage5.unit1.body.pw_conv, features.stage5[1:], features.final_block) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, mult=1.0, feature_levels=(3, 4, 5), pretrained=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels assert not pretrained, "Pretrained models are not avaliable now." backbone = mobilenetv3(mult=mult, num_classes=1, **kwargs) del backbone.classifier features = backbone.features self.layer1 = features[:2] self.layer2 = nn.Sequential( features[2:4], features[4].expand, ) self.layer3 = nn.Sequential( features[4].dwconv, features[4].se, features[4].project, *features[5:7], features[7].expand, ) self.layer4 = nn.Sequential( features[7].dwconv, features[7].project, *features[8:13], features[13].expand, ) self.layer5 = nn.Sequential( features[13].dwconv, features[13].se, features[13].project, *features[14:], ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, feature_levels=(3, 4, 5), pretrained=True, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels net = ptcv_get_model("darknet53", pretrained=pretrained) del net.output net = net.features self.layer1 = nn.Sequential( net.init_block, net.stage1, ) self.layer2 = net.stage2 self.layer3 = net.stage3 self.layer4 = net.stage4 self.layer5 = net.stage5 self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, feature_levels=(3, 4, 5), pretrained=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels assert not pretrained, "Pretrained models are in horch.models.pretrained.backbone." backbone = BDarknet(num_classes=1, **kwargs) del backbone.fc self.layer1 = nn.Sequential( backbone.conv0, backbone.down1, backbone.layer1, ) self.layer2 = nn.Sequential( backbone.down2, backbone.layer2, ) self.layer3 = nn.Sequential( backbone.down3, backbone.layer3, ) self.layer4 = nn.Sequential( backbone.down4, backbone.layer4, ) self.layer5 = nn.Sequential( backbone.down5, backbone.layer5, ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def __init__(self, mult=1.0, feature_levels=(3, 4, 5), pretrained=True, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.out_levels = feature_levels if pretrained: net = ptcv_get_model(self.mult2name[mult], pretrained=True) del net.output net = net.features self.layer1 = nn.Sequential( net.init_block, net.stage1, net.stage2.unit1.conv1, ) self.layer2 = nn.Sequential( net.stage2.unit1.conv2, net.stage2.unit1.conv3, net.stage2.unit2, net.stage3.unit1.conv1, ) self.layer3 = nn.Sequential( net.stage3.unit1.conv2, net.stage3.unit1.conv3, *net.stage3[1:], net.stage4.unit1.conv1, ) self.layer4 = nn.Sequential( net.stage4.unit1.conv2, net.stage4.unit1.conv3, *net.stage4[1:], net.stage5.unit1.conv1, ) self.layer5 = nn.Sequential( net.stage5.unit1.conv2, net.stage5.unit1.conv3, *net.stage5[1:], net.final_block, ) else: backbone = mobilenetv2(mult=mult, pretrained=pretrained) del backbone.classifier features = backbone.features self.layer1 = features[:2] self.layer2 = features[2:4] self.layer3 = nn.Sequential( *features[4:7], features[7].conv[:3], ) self.layer4 = nn.Sequential( features[7].conv[3:], *features[8:14], features[14].conv[:3], ) self.layer5 = nn.Sequential( features[14].conv[3:], *features[15:], backbone.conv, ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]