birder 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

birder/net/mobilevit_v2.py

@@ -159,12 +159,7 @@ class MobileVitBlock(nn.Module):
         self.norm = nn.GroupNorm(num_groups=1, num_channels=transformer_dim)
 
         self.conv_proj = Conv2dNormActivation(
-            transformer_dim,
-            channels,
-            kernel_size=(1, 1),
-            stride=(1, 1),
-            padding=(0, 0),
-            activation_layer=nn.SiLU,
+            transformer_dim, channels, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), activation_layer=None
         )
 
         self.patch_size = patch_size
@@ -236,7 +231,6 @@ class MobileViT_v2(DetectorBackbone):
             stride=(2, 2),
             padding=(1, 1),
             activation_layer=nn.SiLU,
-            bias=True,
         )
 
         stages: OrderedDict[str, nn.Module] = OrderedDict()
@@ -340,15 +334,6 @@ class MobileViT_v2(DetectorBackbone):
         x = self.forward_features(x)
         return self.features(x)
 
-    def create_classifier(self, embed_dim: Optional[int] = None) -> nn.Module:
-        if self.num_classes == 0:
-            return nn.Identity()
-
-        if embed_dim is None:
-            embed_dim = self.embedding_size
-
-        return nn.Linear(embed_dim, self.num_classes, bias=False)
-
 
 registry.register_model_config("mobilevit_v2_0_25", MobileViT_v2, config={"width_factor": 0.25})
 registry.register_model_config("mobilevit_v2_0_5", MobileViT_v2, config={"width_factor": 0.5})
@@ -358,32 +343,3 @@ registry.register_model_config("mobilevit_v2_1_25", MobileViT_v2, config={"width
 registry.register_model_config("mobilevit_v2_1_5", MobileViT_v2, config={"width_factor": 1.5})
 registry.register_model_config("mobilevit_v2_1_75", MobileViT_v2, config={"width_factor": 1.75})
 registry.register_model_config("mobilevit_v2_2_0", MobileViT_v2, config={"width_factor": 2.0})
-
-registry.register_weights(
-    "mobilevit_v2_1_0_il-common",
-    {
-        "description": "MobileViT v2 with width multiplier of 1.0 trained on the il-common dataset",
-        "resolution": (256, 256),
-        "formats": {
-            "pt": {
-                "file_size": 17.6,
-                "sha256": "2b45b7f2ffe3dd129d9a7e9690d2dfd0f93ac60f24d118b920a51bcb950fd95e",
-            }
-        },
-        "net": {"network": "mobilevit_v2_1_0", "tag": "il-common"},
-    },
-)
-registry.register_weights(
-    "mobilevit_v2_1_5_il-common",
-    {
-        "description": "MobileViT v2 with width multiplier of 1.5 trained on the il-common dataset",
-        "resolution": (256, 256),
-        "formats": {
-            "pt": {
-                "file_size": 38.8,
-                "sha256": "acd28c3ee653b62c69ad765c1d99827cea5051deb6dbdd7b9c8d7612782c86a3",
-            }
-        },
-        "net": {"network": "mobilevit_v2_1_5", "tag": "il-common"},
-    },
-)

birder/net/moganet.py

@@ -4,6 +4,9 @@ https://github.com/Westlake-AI/MogaNet/blob/main/models/moganet.py
 
 Paper "MogaNet: Multi-order Gated Aggregation Network",
 https://arxiv.org/abs/2211.03295
+
+Changes from original:
+* Removed biases before norms
 """
 
 # Reference license: Apache-2.0
@@ -30,7 +33,7 @@ from birder.net.base import TokenRetentionResultType
 class ElementScale(nn.Module):
     def __init__(self, embed_dims: int, init_value: float) -> None:
         super().__init__()
-        self.scale = nn.Parameter(init_value * torch.ones((1, embed_dims, 1, 1)), requires_grad=True)
+        self.scale = nn.Parameter(init_value * torch.ones((1, embed_dims, 1, 1)))
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         return x * self.scale
@@ -179,14 +182,14 @@ class MogaBlock(nn.Module):
         super().__init__()
 
         # Spatial attention
-        self.norm1 = nn.BatchNorm2d(embed_dims, eps=1e-5)
+        self.norm1 = nn.BatchNorm2d(embed_dims)
         self.attn = MultiOrderGatedAggregation(
             embed_dims, attn_dw_dilation=attn_dw_dilation, attn_channel_split=attn_channel_split
         )
-        self.layer_scale_1 = nn.Parameter(init_value * torch.ones((1, embed_dims, 1, 1)), requires_grad=True)
+        self.layer_scale_1 = nn.Parameter(init_value * torch.ones((1, embed_dims, 1, 1)))
 
         # Channel MLP
-        self.norm2 = nn.BatchNorm2d(embed_dims, eps=1e-5)
+        self.norm2 = nn.BatchNorm2d(embed_dims)
         mlp_hidden_dim = int(embed_dims * ffn_ratio)
         self.mlp = ChannelAggregationFFN(
             embed_dims=embed_dims,
@@ -194,7 +197,7 @@ class MogaBlock(nn.Module):
             kernel_size=3,
             ffn_drop=drop_rate,
         )
-        self.layer_scale_2 = nn.Parameter(init_value * torch.ones((1, embed_dims, 1, 1)), requires_grad=True)
+        self.layer_scale_2 = nn.Parameter(init_value * torch.ones((1, embed_dims, 1, 1)))
 
         self.drop_path = StochasticDepth(drop_path_rate, mode="row")
 

birder/net/mvit_v2.py

@@ -178,7 +178,7 @@ class MultiScaleAttention(nn.Module):
                 groups=dim_conv,
                 bias=False,
             )
-            self.norm_q = nn.LayerNorm(dim_conv)
+            self.norm_q = nn.LayerNorm(dim_conv, eps=1e-6)
         else:
             self.pool_q = None
             self.norm_q = None
@@ -193,7 +193,7 @@ class MultiScaleAttention(nn.Module):
                 groups=dim_conv,
                 bias=False,
             )
-            self.norm_k = nn.LayerNorm(dim_conv)
+            self.norm_k = nn.LayerNorm(dim_conv, eps=1e-6)
 
             self.pool_v = nn.Conv2d(
                 dim_conv,
@@ -204,7 +204,7 @@ class MultiScaleAttention(nn.Module):
                 groups=dim_conv,
                 bias=False,
             )
-            self.norm_v = nn.LayerNorm(dim_conv)
+            self.norm_v = nn.LayerNorm(dim_conv, eps=1e-6)
         else:
             self.pool_k = None
             self.norm_k = None
@@ -291,7 +291,7 @@ class MultiScaleBlock(nn.Module):
         self.dim = dim
         self.dim_out = dim_out
         self.num_heads = num_heads
-        self.norm1 = nn.LayerNorm(dim)
+        self.norm1 = nn.LayerNorm(dim, eps=1e-6)
         self.has_cls_token = has_cls_token
         self.dim_mul_in_att = dim_mul_in_att
 
@@ -309,7 +309,7 @@ class MultiScaleBlock(nn.Module):
             has_cls_token=has_cls_token,
         )
         self.drop_path = StochasticDepth(drop_path, mode="row")
-        self.norm2 = nn.LayerNorm(att_dim)
+        self.norm2 = nn.LayerNorm(att_dim, eps=1e-6)
         self.mlp = MLP(att_dim, [int(att_dim * mlp_ratio), dim_out], activation_layer=nn.GELU, inplace=None)
 
         if self.dim_mul_in_att is True and self.dim != self.dim_out:
@@ -506,7 +506,7 @@ class MViT_v2(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
             input_size = (input_size[0] // stride_q[i][0], input_size[1] // stride_q[i][1])
 
         self.body = SequentialWithShape(stages)
-        self.norm = nn.LayerNorm(embed_dim)
+        self.norm = nn.LayerNorm(embed_dim, eps=1e-6)
         self.return_channels = return_channels
         self.embedding_size = embed_dim
         self.classifier = self.create_classifier()

birder/net/nfnet.py

@@ -3,6 +3,9 @@ Normalizer-Free Networks, adapted from
 https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/nfnet.py
 
 Paper "High-Performance Large-Scale Image Recognition Without Normalization", https://arxiv.org/abs/2102.06171
+
+Changes from original:
+* Removed dynamic padding
 """
 
 # Reference license: Apache-2.0
@@ -262,6 +265,7 @@ class NFNet(DetectorBackbone):
         self.body = nn.Sequential(stages)
         self.features = nn.Sequential(
             ScaledStdConv2d(prev_channels, prev_channels * 2, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0)),
+            act_layer(),
             nn.AdaptiveAvgPool2d(output_size=(1, 1)),
             nn.Flatten(1),
         )

birder/net/pit.py

@@ -321,7 +321,7 @@ registry.register_weights(
         "formats": {
             "pt": {
                 "file_size": 18.4,
-                "sha256": "8a1d98a2b7388e1efa14bbee89fc182b588a35d239544de521769c2d850ee5fe",
+                "sha256": "5f6bd74b09c1ee541ee2ddae4844ce501b4b3218201ea6381fce0b8fc30257f2",
             }
         },
         "net": {"network": "pit_t", "tag": "il-common"},

birder/net/pvt_v1.py

@@ -50,7 +50,7 @@ class Attention(nn.Module):
 
         if sr_ratio > 1:
             self.sr = nn.Conv2d(dim, dim, kernel_size=(sr_ratio, sr_ratio), stride=(sr_ratio, sr_ratio), padding=(0, 0))
-            self.norm = nn.LayerNorm(dim)
+            self.norm = nn.LayerNorm(dim, eps=1e-6)
         else:
             self.sr = None
             self.norm = None
@@ -90,7 +90,7 @@ class PyramidVisionTransformerBlock(nn.Module):
         drop_path: float,
     ) -> None:
         super().__init__()
-        self.norm1 = nn.LayerNorm(dim)
+        self.norm1 = nn.LayerNorm(dim, eps=1e-6)
         self.attn = Attention(
             dim,
             num_heads=num_heads,
@@ -100,7 +100,7 @@ class PyramidVisionTransformerBlock(nn.Module):
             proj_drop=proj_drop,
         )
 
-        self.norm2 = nn.LayerNorm(dim)
+        self.norm2 = nn.LayerNorm(dim, eps=1e-6)
         self.mlp = MLP(dim, [int(dim * mlp_ratio), dim], activation_layer=nn.GELU, dropout=proj_drop)
         self.drop_path = StochasticDepth(drop_path, mode="row")
 
@@ -115,7 +115,7 @@ class PatchEmbed(nn.Module):
     def __init__(self, patch_size: tuple[int, int], in_channels: int, embed_dim: int) -> None:
         super().__init__()
         self.proj = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size, padding=(0, 0))
-        self.norm = nn.LayerNorm(embed_dim)
+        self.norm = nn.LayerNorm(embed_dim, eps=1e-6)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.proj(x)
@@ -169,7 +169,7 @@ class PyramidVisionTransformerStage(nn.Module):
             ]
         )
 
-        self.norm = nn.LayerNorm(dim_out)
+        self.norm = nn.LayerNorm(dim_out, eps=1e-6)
         if cls_token is True:
             self.cls_token = nn.Parameter(torch.zeros(1, 1, dim_out))
         else:

birder/net/pvt_v2.py

@@ -85,7 +85,7 @@ class Attention(nn.Module):
                 self.sr = nn.Conv2d(
                     dim, dim, kernel_size=(sr_ratio, sr_ratio), stride=(sr_ratio, sr_ratio), padding=(0, 0)
                 )
-                self.norm = nn.LayerNorm(dim)
+                self.norm = nn.LayerNorm(dim, eps=1e-6)
             else:
                 self.sr = None
                 self.norm = None
@@ -93,7 +93,7 @@ class Attention(nn.Module):
             self.pool = nn.AdaptiveAvgPool2d(7)
             self.act = nn.GELU()
             self.sr = nn.Conv2d(dim, dim, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0))
-            self.norm = nn.LayerNorm(dim)
+            self.norm = nn.LayerNorm(dim, eps=1e-6)
 
         assert (self.pool is None and self.act is None) or (self.pool is not None and self.act is not None)
 
@@ -140,7 +140,7 @@ class PyramidVisionTransformerBlock(nn.Module):
         drop_path: float,
     ) -> None:
         super().__init__()
-        self.norm1 = nn.LayerNorm(dim)
+        self.norm1 = nn.LayerNorm(dim, eps=1e-6)
         self.attn = Attention(
             dim,
             num_heads=num_heads,
@@ -151,7 +151,7 @@ class PyramidVisionTransformerBlock(nn.Module):
             proj_drop=proj_drop,
         )
 
-        self.norm2 = nn.LayerNorm(dim)
+        self.norm2 = nn.LayerNorm(dim, eps=1e-6)
         self.mlp = MLP(
             in_features=dim,
             hidden_features=int(dim * mlp_ratio),
@@ -179,7 +179,7 @@ class OverlapPatchEmbed(nn.Module):
             stride=stride,
             padding=(patch_size[0] // 2, patch_size[1] // 2),
         )
-        self.norm = nn.LayerNorm(embed_dim)
+        self.norm = nn.LayerNorm(embed_dim, eps=1e-6)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.proj(x)

birder/net/repghost.py

@@ -169,7 +169,7 @@ class RepGhostBottleneck(nn.Module):
         # Squeeze-and-excitation
         if se_ratio > 0:
             self.se = SqueezeExcitation(
-                mid_channels, make_divisible(int(mid_channels * se_ratio), 4), activation=nn.Hardsigmoid
+                mid_channels, make_divisible(int(mid_channels * se_ratio), 4), scale_activation=nn.Hardsigmoid
             )
         else:
             self.se = nn.Identity()
@@ -351,32 +351,3 @@ registry.register_model_config("repghost_0_5", RepGhost, config={"width": 0.5})
 registry.register_model_config("repghost_1_0", RepGhost, config={"width": 1.0})
 registry.register_model_config("repghost_1_3", RepGhost, config={"width": 1.3})
 registry.register_model_config("repghost_1_5", RepGhost, config={"width": 1.5})
-
-registry.register_weights(
-    "repghost_1_0_il-common",
-    {
-        "description": "RepGhost 1.0x model trained on the il-common dataset",
-        "resolution": (256, 256),
-        "formats": {
-            "pt": {
-                "file_size": 12.8,
-                "sha256": "37e211ec65c752ad79bbbaacea277f7d683d0b0f69d954a7ca7af46b9a1260e6",
-            }
-        },
-        "net": {"network": "repghost_1_0", "tag": "il-common"},
-    },
-)
-registry.register_weights(
-    "repghost_1_0_il-common_reparameterized",
-    {
-        "description": "RepGhost 1.0x (reparameterized) model trained on the il-common dataset",
-        "resolution": (256, 256),
-        "formats": {
-            "pt": {
-                "file_size": 12.6,
-                "sha256": "e003e0498d63428305c10f879a0e2b999604795d417f07ea0da35ea925f794f5",
-            }
-        },
-        "net": {"network": "repghost_1_0", "tag": "il-common_reparameterized", "reparameterized": True},
-    },
-)

birder/net/resmlp.py

@@ -40,8 +40,8 @@ class LayerScaleMLP(nn.Module):
         self.drop_path = StochasticDepth(drop_path, mode="row")
         self.norm2 = Affine(dim)
         self.mlp = MLP(dim, [int(dim * 4.0), dim], activation_layer=nn.GELU, dropout=drop)
-        self.gamma_1 = nn.Parameter(init_value * torch.ones((dim)), requires_grad=True)
-        self.gamma_2 = nn.Parameter(init_value * torch.ones((dim)), requires_grad=True)
+        self.gamma_1 = nn.Parameter(init_value * torch.ones((dim)))
+        self.gamma_2 = nn.Parameter(init_value * torch.ones((dim)))
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x).transpose(1, 2)).transpose(1, 2))

birder/net/resnest.py

@@ -3,6 +3,9 @@ ResNeSt, adapted from
 https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/resnest.py
 
 Paper "ResNeSt: Split-Attention Networks", https://arxiv.org/abs/2004.08955
+
+Changes from original:
+* Removed bias from fc1 (SplitAttn)
 """
 
 # Reference license: Apache-2.0

birder/net/resnet_v1.py

@@ -4,6 +4,8 @@ https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py
 
 Paper "Deep Residual Learning for Image Recognition", https://arxiv.org/abs/1512.03385
 and
+Paper "Squeeze-and-Excitation Networks", https://arxiv.org/abs/1709.01507
+and
 Paper "Bag of Tricks for Image Classification with Convolutional Neural Networks",
 https://arxiv.org/abs/1812.01187
 """
@@ -101,7 +103,6 @@ class ResNet_v1(DetectorBackbone):
         *,
         config: Optional[dict[str, Any]] = None,
         size: Optional[tuple[int, int]] = None,
-        squeeze_excitation: bool = False,
     ) -> None:
         super().__init__(input_channels, num_classes, config=config, size=size)
         assert self.config is not None, "must set config"
@@ -110,6 +111,7 @@ class ResNet_v1(DetectorBackbone):
         filter_list: list[int] = self.config["filter_list"]
         units: list[int] = self.config["units"]
         pooling_param: Optional[float] = self.config.get("pooling_param", None)
+        squeeze_excitation: bool = self.config.get("squeeze_excitation", False)
         deep_stem: bool = self.config.get("deep_stem", False)
         avg_down: bool = self.config.get("avg_down", False)
 
@@ -302,6 +304,128 @@ registry.register_model_config(
     },
 )
 
+# Squeeze-and-Excitation Networks
+registry.register_model_config(
+    "se_resnet_v1_18",
+    ResNet_v1,
+    config={
+        "bottle_neck": False,
+        "filter_list": [64, 64, 128, 256, 512],
+        "units": [2, 2, 2, 2],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v1_34",
+    ResNet_v1,
+    config={
+        "bottle_neck": False,
+        "filter_list": [64, 64, 128, 256, 512],
+        "units": [3, 4, 6, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v1_50",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 4, 6, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v1_101",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 4, 23, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v1_152",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 8, 36, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v1_200",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 24, 36, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v1_269",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 30, 48, 8],
+        "squeeze_excitation": True,
+    },
+)
+
+# SE-ResNet-D variants with SE
+registry.register_model_config(
+    "se_resnet_d_50",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 4, 6, 3],
+        "squeeze_excitation": True,
+        "deep_stem": True,
+        "avg_down": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_d_101",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 4, 23, 3],
+        "squeeze_excitation": True,
+        "deep_stem": True,
+        "avg_down": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_d_152",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 8, 36, 3],
+        "squeeze_excitation": True,
+        "deep_stem": True,
+        "avg_down": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_d_200",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 24, 36, 3],
+        "squeeze_excitation": True,
+        "deep_stem": True,
+        "avg_down": True,
+    },
+)
+
 registry.register_weights(
     "resnet_v1_50_arabian-peninsula",
     {

birder/net/resnet_v2.py

@@ -3,6 +3,8 @@ ResNet v2, adapted from
 https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/resnetv2.py
 
 Paper "Identity Mappings in Deep Residual Networks", https://arxiv.org/abs/1603.05027
+and
+Paper "Squeeze-and-Excitation Networks", https://arxiv.org/abs/1709.01507
 """
 
 # Reference license: Apache-2.0
@@ -98,7 +100,6 @@ class ResNet_v2(DetectorBackbone):
         *,
         config: Optional[dict[str, Any]] = None,
         size: Optional[tuple[int, int]] = None,
-        squeeze_excitation: bool = False,
     ) -> None:
         super().__init__(input_channels, num_classes, config=config, size=size)
         assert self.config is not None, "must set config"
@@ -106,6 +107,7 @@ class ResNet_v2(DetectorBackbone):
         bottle_neck: bool = self.config["bottle_neck"]
         filter_list: list[int] = self.config["filter_list"]
         units: list[int] = self.config["units"]
+        squeeze_excitation: bool = self.config.get("squeeze_excitation", False)
 
         assert len(units) + 1 == len(filter_list)
         num_unit = len(units)
@@ -231,3 +233,75 @@ registry.register_model_config(
     ResNet_v2,
     config={"bottle_neck": True, "filter_list": [64, 256, 512, 1024, 2048], "units": [3, 30, 48, 8]},
 )
+
+# Squeeze-and-Excitation Networks
+registry.register_model_config(
+    "se_resnet_v2_18",
+    ResNet_v2,
+    config={
+        "bottle_neck": False,
+        "filter_list": [64, 64, 128, 256, 512],
+        "units": [2, 2, 2, 2],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v2_34",
+    ResNet_v2,
+    config={
+        "bottle_neck": False,
+        "filter_list": [64, 64, 128, 256, 512],
+        "units": [3, 4, 6, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v2_50",
+    ResNet_v2,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 4, 6, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v2_101",
+    ResNet_v2,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 4, 23, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v2_152",
+    ResNet_v2,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 8, 36, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v2_200",
+    ResNet_v2,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 24, 36, 3],
+        "squeeze_excitation": True,
+    },
+)
+registry.register_model_config(
+    "se_resnet_v2_269",
+    ResNet_v2,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 30, 48, 8],
+        "squeeze_excitation": True,
+    },
+)

birder/net/resnext.py

@@ -3,6 +3,11 @@ ResNeXt, adapted from
 https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py
 
 Paper "Aggregated Residual Transformations for Deep Neural Networks", https://arxiv.org/abs/1611.05431
+and
+Paper "Squeeze-and-Excitation Networks", https://arxiv.org/abs/1709.01507
+and
+Paper "Bag of Tricks for Image Classification with Convolutional Neural Networks",
+https://arxiv.org/abs/1812.01187
 """
 
 # Reference license: BSD 3-Clause
@@ -117,7 +122,6 @@ class ResNeXt(DetectorBackbone):
         *,
         config: Optional[dict[str, Any]] = None,
         size: Optional[tuple[int, int]] = None,
-        squeeze_excitation: bool = False,
     ) -> None:
         super().__init__(input_channels, num_classes, config=config, size=size)
         assert self.config is not None, "must set config"
@@ -127,6 +131,7 @@ class ResNeXt(DetectorBackbone):
         base_width: int = self.config.get("base_width", 4)
         filter_list = [64, 128, 256, 512]
         units: list[int] = self.config["units"]
+        squeeze_excitation: bool = self.config.get("squeeze_excitation", False)
         deep_stem: bool = self.config.get("deep_stem", False)
         avg_down: bool = self.config.get("avg_down", False)
 
@@ -251,3 +256,32 @@ registry.register_model_config(
 registry.register_model_config(
     "resnext_d_152", ResNeXt, config={"units": [3, 8, 36, 3], "deep_stem": True, "avg_down": True}
 )
+
+# Squeeze-and-Excitation Networks
+registry.register_model_config("se_resnext_50", ResNeXt, config={"units": [3, 4, 6, 3], "squeeze_excitation": True})
+registry.register_model_config("se_resnext_101", ResNeXt, config={"units": [3, 4, 23, 3], "squeeze_excitation": True})
+registry.register_model_config("se_resnext_152", ResNeXt, config={"units": [3, 8, 36, 3], "squeeze_excitation": True})
+
+registry.register_model_config(
+    "se_resnext_101_32x8", ResNeXt, config={"units": [3, 4, 23, 3], "base_width": 8, "squeeze_excitation": True}
+)
+registry.register_model_config(
+    "se_resnext_101_64x4", ResNeXt, config={"units": [3, 4, 23, 3], "groups": 64, "squeeze_excitation": True}
+)
+
+# SE-ResNeXt-D variants with SE
+registry.register_model_config(
+    "se_resnext_d_50",
+    ResNeXt,
+    config={"units": [3, 4, 6, 3], "squeeze_excitation": True, "deep_stem": True, "avg_down": True},
+)
+registry.register_model_config(
+    "se_resnext_d_101",
+    ResNeXt,
+    config={"units": [3, 4, 23, 3], "squeeze_excitation": True, "deep_stem": True, "avg_down": True},
+)
+registry.register_model_config(
+    "se_resnext_d_152",
+    ResNeXt,
+    config={"units": [3, 8, 36, 3], "squeeze_excitation": True, "deep_stem": True, "avg_down": True},
+)