Add feature support to legacy senets, add 32x32 resnext models to exclude list for feature testing.

tests/test_models.py

@@ -110,8 +110,10 @@ def test_model_forward_torchscript(model_name, batch_size):
 
 EXCLUDE_FEAT_FILTERS = [
     'hrnet*',  '*pruned*',  # hopefully fix at some point
-    'legacy*',  # not going to bother
 ]
+if 'GITHUB_ACTIONS' in os.environ and 'Linux' in platform.system():
+    # GitHub Linux runner is slower and hits memory limits sooner than MacOS, exclude bigger models
+    EXCLUDE_FEAT_FILTERS += ['*resnext101_32x32d']
 
 @pytest.mark.timeout(120)
 @pytest.mark.parametrize('model_name', list_models(exclude_filters=EXCLUDE_FILTERS + EXCLUDE_FEAT_FILTERS))

timm/models/senet.py

@@ -18,7 +18,7 @@ import torch.nn as nn
 import torch.nn.functional as F
 
 from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
-from .helpers import load_pretrained
+from .helpers import build_model_with_cfg
 from .layers import SelectAdaptivePool2d
 from .registry import register_model
 
@@ -229,8 +229,8 @@ class SEResNetBlock(nn.Module):
 class SENet(nn.Module):
 
     def __init__(self, block, layers, groups, reduction, drop_rate=0.2,
-                 in_chans=3, inplanes=128, input_3x3=True, downsample_kernel_size=3,
+                 in_chans=3, inplanes=64, input_3x3=False, downsample_kernel_size=1,
-                 downsample_padding=1, num_classes=1000, global_pool='avg'):
+                 downsample_padding=0, num_classes=1000, global_pool='avg'):
         """
         Parameters
         ----------
@@ -297,10 +297,10 @@ class SENet(nn.Module):
                 ('bn1', nn.BatchNorm2d(inplanes)),
                 ('relu1', nn.ReLU(inplace=True)),
             ]
-        # To preserve compatibility with Caffe weights `ceil_mode=True`
-        # is used instead of `padding=1`.
-        layer0_modules.append(('pool', nn.MaxPool2d(3, stride=2, ceil_mode=True)))
         self.layer0 = nn.Sequential(OrderedDict(layer0_modules))
+        # To preserve compatibility with Caffe weights `ceil_mode=True` is used instead of `padding=1`.
+        self.pool0 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
+        self.feature_info = [dict(num_chs=inplanes, reduction=2, module='layer0')]
         self.layer1 = self._make_layer(
             block,
             planes=64,
@@ -310,6 +310,7 @@ class SENet(nn.Module):
             downsample_kernel_size=1,
             downsample_padding=0
         )
+        self.feature_info += [dict(num_chs=64 * block.expansion, reduction=4, module='layer1')]
         self.layer2 = self._make_layer(
             block,
             planes=128,
@@ -320,6 +321,7 @@ class SENet(nn.Module):
             downsample_kernel_size=downsample_kernel_size,
             downsample_padding=downsample_padding
         )
+        self.feature_info += [dict(num_chs=128 * block.expansion, reduction=8, module='layer2')]
         self.layer3 = self._make_layer(
             block,
             planes=256,
@@ -330,6 +332,7 @@ class SENet(nn.Module):
             downsample_kernel_size=downsample_kernel_size,
             downsample_padding=downsample_padding
         )
+        self.feature_info += [dict(num_chs=256 * block.expansion, reduction=16, module='layer3')]
         self.layer4 = self._make_layer(
             block,
             planes=512,
@@ -340,8 +343,9 @@ class SENet(nn.Module):
             downsample_kernel_size=downsample_kernel_size,
             downsample_padding=downsample_padding
         )
-        self.avg_pool = SelectAdaptivePool2d(pool_type=global_pool)
+        self.feature_info += [dict(num_chs=512 * block.expansion, reduction=32, module='layer4')]
         self.num_features = 512 * block.expansion
+        self.global_pool = SelectAdaptivePool2d(pool_type=global_pool)
         self.last_linear = nn.Linear(self.num_features, num_classes)
 
         for m in self.modules():
@@ -352,14 +356,13 @@ class SENet(nn.Module):
         downsample = None
         if stride != 1 or self.inplanes != planes * block.expansion:
             downsample = nn.Sequential(
-                nn.Conv2d(self.inplanes, planes * block.expansion,
+                nn.Conv2d(
-                          kernel_size=downsample_kernel_size, stride=stride,
+                    self.inplanes, planes * block.expansion, kernel_size=downsample_kernel_size,
-                          padding=downsample_padding, bias=False),
+                    stride=stride, padding=downsample_padding, bias=False),
                 nn.BatchNorm2d(planes * block.expansion),
             )
 
-        layers = [block(
+        layers = [block(self.inplanes, planes, groups, reduction, stride, downsample)]
-            self.inplanes, planes, groups, reduction, stride, downsample)]
         self.inplanes = planes * block.expansion
         for i in range(1, blocks):
             layers.append(block(self.inplanes, planes, groups, reduction))
@@ -371,15 +374,16 @@ class SENet(nn.Module):
 
     def reset_classifier(self, num_classes, global_pool='avg'):
         self.num_classes = num_classes
-        self.avg_pool = SelectAdaptivePool2d(pool_type=global_pool)
+        self.global_pool = SelectAdaptivePool2d(pool_type=global_pool)
         if num_classes:
-            num_features = self.num_features * self.avg_pool.feat_mult()
+            num_features = self.num_features * self.global_pool.feat_mult()
             self.last_linear = nn.Linear(num_features, num_classes)
         else:
             self.last_linear = nn.Identity()
 
     def forward_features(self, x):
         x = self.layer0(x)
+        x = self.pool0(x)
         x = self.layer1(x)
         x = self.layer2(x)
         x = self.layer3(x)
@@ -387,7 +391,7 @@ class SENet(nn.Module):
         return x
 
     def logits(self, x):
-        x = self.avg_pool(x).flatten(1)
+        x = self.global_pool(x).flatten(1)
         if self.drop_rate > 0.:
             x = F.dropout(x, p=self.drop_rate, training=self.training)
         x = self.last_linear(x)
@@ -399,116 +403,70 @@ class SENet(nn.Module):
         return x
 
 
+def _create_senet(variant, pretrained=False, **kwargs):
+    return build_model_with_cfg(
+        SENet, variant, default_cfg=default_cfgs[variant], pretrained=pretrained, **kwargs)
+
+
 @register_model
-def legacy_seresnet18(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
+def legacy_seresnet18(pretrained=False, **kwargs):
-    default_cfg = default_cfgs['seresnet18']
+    model_args = dict(
-    model = SENet(SEResNetBlock, [2, 2, 2, 2], groups=1, reduction=16,
+        block=SEResNetBlock, layers=[2, 2, 2, 2], groups=1, reduction=16, **kwargs)
-                  inplanes=64, input_3x3=False,
+    return _create_senet('seresnet18', pretrained, **model_args)
-                  downsample_kernel_size=1, downsample_padding=0,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
-    model.default_cfg = default_cfg
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model
 
 
 @register_model
-def legacy_seresnet34(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
+def legacy_seresnet34(pretrained=False, **kwargs):
-    default_cfg = default_cfgs['seresnet34']
+    model_args = dict(
-    model = SENet(SEResNetBlock, [3, 4, 6, 3], groups=1, reduction=16,
+        block=SEResNetBlock, layers=[3, 4, 6, 3], groups=1, reduction=16, **kwargs)
-                  inplanes=64, input_3x3=False,
+    return _create_senet('seresnet34', pretrained, **model_args)
-                  downsample_kernel_size=1, downsample_padding=0,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
-    model.default_cfg = default_cfg
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model
 
 
 @register_model
 def legacy_seresnet50(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
-    default_cfg = default_cfgs['seresnet50']
+    model_args = dict(
-    model = SENet(SEResNetBottleneck, [3, 4, 6, 3], groups=1, reduction=16,
+        block=SEResNetBottleneck, layers=[3, 4, 6, 3], groups=1, reduction=16, **kwargs)
-                  inplanes=64, input_3x3=False,
+    return _create_senet('seresnet50', pretrained, **model_args)
-                  downsample_kernel_size=1, downsample_padding=0,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
-    model.default_cfg = default_cfg
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model
 
 
 @register_model
 def legacy_seresnet101(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
-    default_cfg = default_cfgs['seresnet101']
+    model_args = dict(
-    model = SENet(SEResNetBottleneck, [3, 4, 23, 3], groups=1, reduction=16,
+        block=SEResNetBottleneck, layers=[3, 4, 23, 3], groups=1, reduction=16, **kwargs)
-                  inplanes=64, input_3x3=False,
+    return _create_senet('seresnet101', pretrained, **model_args)
-                  downsample_kernel_size=1, downsample_padding=0,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
-    model.default_cfg = default_cfg
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model
 
 
 @register_model
-def legacy_seresnet152(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
+def legacy_seresnet152(pretrained=False, **kwargs):
-    default_cfg = default_cfgs['seresnet152']
+    model_args = dict(
-    model = SENet(SEResNetBottleneck, [3, 8, 36, 3], groups=1, reduction=16,
+        block=SEResNetBottleneck, layers=[3, 8, 36, 3], groups=1, reduction=16, **kwargs)
-                  inplanes=64, input_3x3=False,
+    return _create_senet('seresnet152', pretrained, **model_args)
-                  downsample_kernel_size=1, downsample_padding=0,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
-    model.default_cfg = default_cfg
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model
 
 
 @register_model
-def legacy_senet154(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
+def legacy_senet154(pretrained=False, **kwargs):
-    default_cfg = default_cfgs['senet154']
+    model_args = dict(
-    model = SENet(SEBottleneck, [3, 8, 36, 3], groups=64, reduction=16,
+        block=SEBottleneck, layers=[3, 8, 36, 3], groups=64, reduction=16,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
+        downsample_kernel_size=3, downsample_padding=1,  inplanes=128, input_3x3=True, **kwargs)
-    model.default_cfg = default_cfg
+    return _create_senet('senet154', pretrained, **model_args)
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model
 
 
 @register_model
-def legacy_seresnext26_32x4d(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
+def legacy_seresnext26_32x4d(pretrained=False, **kwargs):
-    default_cfg = default_cfgs['seresnext26_32x4d']
+    model_args = dict(
-    model = SENet(SEResNeXtBottleneck, [2, 2, 2, 2], groups=32, reduction=16,
+        block=SEResNeXtBottleneck, layers=[2, 2, 2, 2], groups=32, reduction=16, **kwargs)
-                  inplanes=64, input_3x3=False,
+    return _create_senet('seresnext26_32x4d', pretrained, **model_args)
-                  downsample_kernel_size=1, downsample_padding=0,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
-    model.default_cfg = default_cfg
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model
 
 
 @register_model
-def legacy_seresnext50_32x4d(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
+def legacy_seresnext50_32x4d(pretrained=False, **kwargs):
-    default_cfg = default_cfgs['seresnext50_32x4d']
+    model_args = dict(
-    model = SENet(SEResNeXtBottleneck, [3, 4, 6, 3], groups=32, reduction=16,
+        block=SEResNeXtBottleneck, layers=[3, 4, 6, 3], groups=32, reduction=16, **kwargs)
-                  inplanes=64, input_3x3=False,
+    return _create_senet('seresnext50_32x4d', pretrained, **model_args)
-                  downsample_kernel_size=1, downsample_padding=0,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
-    model.default_cfg = default_cfg
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model
 
 
 @register_model
-def legacy_seresnext101_32x4d(pretrained=False, num_classes=1000, in_chans=3, **kwargs):
+def legacy_seresnext101_32x4d(pretrained=False, **kwargs):
-    default_cfg = default_cfgs['seresnext101_32x4d']
+    model_args = dict(
-    model = SENet(SEResNeXtBottleneck, [3, 4, 23, 3], groups=32, reduction=16,
+        block=SEResNeXtBottleneck, layers=[3, 4, 23, 3], groups=32, reduction=16, **kwargs)
-                  inplanes=64, input_3x3=False,
+    return _create_senet('seresnext101_32x4d', pretrained, **model_args)
-                  downsample_kernel_size=1, downsample_padding=0,
-                  num_classes=num_classes, in_chans=in_chans, **kwargs)
-    model.default_cfg = default_cfg
-    if pretrained:
-        load_pretrained(model, default_cfg, num_classes, in_chans)
-    return model

timm/models/xception_aligned.py

@@ -1,6 +1,7 @@
-"""Pytorch impl of Aligned Xception
+"""Pytorch impl of Aligned Xception 41, 65, 71
 
-This is a correct impl of Aligned Xception (Deeplab) models compatible with TF definition.
+This is a correct, from scratch impl of Aligned Xception (Deeplab) models compatible with TF weights at
+https://github.com/tensorflow/models/blob/master/research/deeplab/g3doc/model_zoo.md
 
 Hacked together by Ross Wightman
 """