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
]
