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

birder/net/mobilenet_v2.py

@@ -37,36 +37,44 @@ class InvertedResidual(nn.Module):
         num_expfilter = int(round(in_channels * expansion_factor))
 
         self.shortcut = shortcut
-        self.block = nn.Sequential(
-            Conv2dNormActivation(
-                in_channels,
-                num_expfilter,
-                kernel_size=(1, 1),
-                stride=(1, 1),
-                padding=(0, 0),
-                bias=False,
-                activation_layer=activation_layer,
-            ),
-            Conv2dNormActivation(
-                num_expfilter,
-                num_expfilter,
-                kernel_size=kernel_size,
-                stride=stride,
-                padding=padding,
-                groups=num_expfilter,
-                bias=False,
-                activation_layer=activation_layer,
-            ),
-            Conv2dNormActivation(
-                num_expfilter,
-                out_channels,
-                kernel_size=(1, 1),
-                stride=(1, 1),
-                padding=(0, 0),
-                bias=False,
-                activation_layer=None,
-            ),
+        layers = []
+        if expansion_factor != 1.0:
+            layers.append(
+                Conv2dNormActivation(
+                    in_channels,
+                    num_expfilter,
+                    kernel_size=(1, 1),
+                    stride=(1, 1),
+                    padding=(0, 0),
+                    bias=False,
+                    activation_layer=activation_layer,
+                )
+            )
+
+        layers.extend(
+            [
+                Conv2dNormActivation(
+                    num_expfilter,
+                    num_expfilter,
+                    kernel_size=kernel_size,
+                    stride=stride,
+                    padding=padding,
+                    groups=num_expfilter,
+                    bias=False,
+                    activation_layer=activation_layer,
+                ),
+                Conv2dNormActivation(
+                    num_expfilter,
+                    out_channels,
+                    kernel_size=(1, 1),
+                    stride=(1, 1),
+                    padding=(0, 0),
+                    bias=False,
+                    activation_layer=None,
+                ),
+            ]
         )
+        self.block = nn.Sequential(*layers)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         if self.shortcut is True:
@@ -171,6 +179,7 @@ class MobileNet_v2(DetectorBackbone):
             ),
             nn.AdaptiveAvgPool2d(output_size=(1, 1)),
             nn.Flatten(1),
+            nn.Dropout(0.2),
         )
         self.return_channels = return_channels[1:5]
         self.embedding_size = last_channels
@@ -230,18 +239,3 @@ registry.register_model_config("mobilenet_v2_1_25", MobileNet_v2, config={"alpha
 registry.register_model_config("mobilenet_v2_1_5", MobileNet_v2, config={"alpha": 1.5})
 registry.register_model_config("mobilenet_v2_1_75", MobileNet_v2, config={"alpha": 1.75})
 registry.register_model_config("mobilenet_v2_2_0", MobileNet_v2, config={"alpha": 2.0})
-
-registry.register_weights(
-    "mobilenet_v2_1_0_il-common",
-    {
-        "description": "MobileNet v2 (1.0 multiplier) model trained on the il-common dataset",
-        "resolution": (256, 256),
-        "formats": {
-            "pt": {
-                "file_size": 10.6,
-                "sha256": "d6182293e98c102026f7cdc0d446aaf0e511232173c4b98c1a882c9f147be6e7",
-            }
-        },
-        "net": {"network": "mobilenet_v2_1_0", "tag": "il-common"},
-    },
-)

birder/net/{mobilenet_v3_large.py → mobilenet_v3.py}

@@ -3,6 +3,9 @@ MobileNet v3, adapted from
 https://github.com/pytorch/vision/blob/main/torchvision/models/mobilenetv3.py
 
 Paper "Searching for MobileNetV3", https://arxiv.org/abs/1905.02244
+
+Changes from original:
+* Using nn.BatchNorm2d with eps 1e-5 instead of 1e-3
 """
 
 # Reference license: BSD 3-Clause
@@ -113,7 +116,7 @@ class InvertedResidual(nn.Module):
 
 
 # pylint: disable=invalid-name
-class MobileNet_v3_Large(DetectorBackbone):
+class MobileNet_v3(DetectorBackbone):
     def __init__(
         self,
         input_channels: int,
@@ -121,12 +124,12 @@ class MobileNet_v3_Large(DetectorBackbone):
         *,
         config: Optional[dict[str, Any]] = None,
         size: Optional[tuple[int, int]] = None,
-        large: bool = True,
     ) -> None:
         super().__init__(input_channels, num_classes, config=config, size=size)
         assert self.config is not None, "must set config"
 
         alpha: float = self.config["alpha"]
+        large: bool = self.config["large"]
 
         if large is True:
             last_channels = int(round(1280 * max(1.0, alpha)))
@@ -268,15 +271,39 @@ class MobileNet_v3_Large(DetectorBackbone):
         )
 
 
-registry.register_model_config("mobilenet_v3_large_0_25", MobileNet_v3_Large, config={"alpha": 0.25})
-registry.register_model_config("mobilenet_v3_large_0_5", MobileNet_v3_Large, config={"alpha": 0.5})
-registry.register_model_config("mobilenet_v3_large_0_75", MobileNet_v3_Large, config={"alpha": 0.75})
-registry.register_model_config("mobilenet_v3_large_1_0", MobileNet_v3_Large, config={"alpha": 1.0})
-registry.register_model_config("mobilenet_v3_large_1_25", MobileNet_v3_Large, config={"alpha": 1.25})
-registry.register_model_config("mobilenet_v3_large_1_5", MobileNet_v3_Large, config={"alpha": 1.5})
-registry.register_model_config("mobilenet_v3_large_1_75", MobileNet_v3_Large, config={"alpha": 1.75})
-registry.register_model_config("mobilenet_v3_large_2_0", MobileNet_v3_Large, config={"alpha": 2.0})
+registry.register_model_config("mobilenet_v3_small_0_25", MobileNet_v3, config={"alpha": 0.25, "large": False})
+registry.register_model_config("mobilenet_v3_small_0_5", MobileNet_v3, config={"alpha": 0.5, "large": False})
+registry.register_model_config("mobilenet_v3_small_0_75", MobileNet_v3, config={"alpha": 0.75, "large": False})
+registry.register_model_config("mobilenet_v3_small_1_0", MobileNet_v3, config={"alpha": 1.0, "large": False})
+registry.register_model_config("mobilenet_v3_small_1_25", MobileNet_v3, config={"alpha": 1.25, "large": False})
+registry.register_model_config("mobilenet_v3_small_1_5", MobileNet_v3, config={"alpha": 1.5, "large": False})
+registry.register_model_config("mobilenet_v3_small_1_75", MobileNet_v3, config={"alpha": 1.75, "large": False})
+registry.register_model_config("mobilenet_v3_small_2_0", MobileNet_v3, config={"alpha": 2.0, "large": False})
+
+registry.register_model_config("mobilenet_v3_large_0_25", MobileNet_v3, config={"alpha": 0.25, "large": True})
+registry.register_model_config("mobilenet_v3_large_0_5", MobileNet_v3, config={"alpha": 0.5, "large": True})
+registry.register_model_config("mobilenet_v3_large_0_75", MobileNet_v3, config={"alpha": 0.75, "large": True})
+registry.register_model_config("mobilenet_v3_large_1_0", MobileNet_v3, config={"alpha": 1.0, "large": True})
+registry.register_model_config("mobilenet_v3_large_1_25", MobileNet_v3, config={"alpha": 1.25, "large": True})
+registry.register_model_config("mobilenet_v3_large_1_5", MobileNet_v3, config={"alpha": 1.5, "large": True})
+registry.register_model_config("mobilenet_v3_large_1_75", MobileNet_v3, config={"alpha": 1.75, "large": True})
+registry.register_model_config("mobilenet_v3_large_2_0", MobileNet_v3, config={"alpha": 2.0, "large": True})
+
 
+registry.register_weights(
+    "mobilenet_v3_small_1_0_il-common",
+    {
+        "description": "MobileNet v3 small (1.0 multiplier) model trained on the il-common dataset",
+        "resolution": (256, 256),
+        "formats": {
+            "pt": {
+                "file_size": 7.4,
+                "sha256": "ac53227f7513fd0c0b5204ee57403de2ab6c74c4e4d1061b9168596c6b5cea48",
+            }
+        },
+        "net": {"network": "mobilenet_v3_small_1_0", "tag": "il-common"},
+    },
+)
 registry.register_weights(
     "mobilenet_v3_large_0_75_il-common",
     {

birder/net/mobilenet_v4_hybrid.py

@@ -142,24 +142,24 @@ class MultiQueryAttention(nn.Module):
         self.output = nn.Sequential(*output_layers)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, C, H, W) = x.size()
+        B, C, H, W = x.size()
         q = self.query(x)
         q = q.reshape(B, self.num_heads, self.key_dim, -1)
         q = q.transpose(-1, -2).contiguous()
 
         k = self.key(x)
-        (B, C, _, _) = k.size()
+        B, C, _, _ = k.size()
         k = k.reshape(B, C, -1).transpose(1, 2)
         k = k.unsqueeze(1).contiguous()
 
         v = self.value(x)
-        (B, C, _, _) = v.size()
+        B, C, _, _ = v.size()
         v = v.reshape(B, C, -1).transpose(1, 2)
         v = v.unsqueeze(1).contiguous()
 
         # Calculate attention score
         attn_score = F.scaled_dot_product_attention(q, k, v, dropout_p=0.0)  # pylint: disable=not-callable
-        (B, _, _, C) = attn_score.size()
+        B, _, _, C = attn_score.size()
         feat_dim = C * self.num_heads
         attn_score = attn_score.transpose(1, 2)
         attn_score = (

birder/net/mobileone.py

@@ -61,13 +61,7 @@ class MobileOneBlock(nn.Module):
 
         if reparameterized is True:
             self.reparam_conv = nn.Conv2d(
-                in_channels,
-                out_channels,
-                kernel_size=kernel_size,
-                stride=stride,
-                padding=padding,
-                groups=groups,
-                bias=True,
+                in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=groups
             )
         else:
             self.reparam_conv = None
@@ -144,7 +138,7 @@ class MobileOneBlock(nn.Module):
         if self.reparameterized is True:
             return
 
-        (kernel, bias) = self._get_kernel_bias()
+        kernel, bias = self._get_kernel_bias()
         self.reparam_conv = nn.Conv2d(
             in_channels=self.in_channels,
             out_channels=self.out_channels,
@@ -152,7 +146,6 @@ class MobileOneBlock(nn.Module):
             stride=self.stride,
             padding=self.padding,
             groups=self.groups,
-            bias=True,
         )
         self.reparam_conv.weight.data = kernel
         self.reparam_conv.bias.data = bias
@@ -178,7 +171,7 @@ class MobileOneBlock(nn.Module):
         kernel_scale = 0
         bias_scale = 0
         if self.rbr_scale is not None:
-            (kernel_scale, bias_scale) = self._fuse_bn_tensor(self.rbr_scale)
+            kernel_scale, bias_scale = self._fuse_bn_tensor(self.rbr_scale)
             pad = self.kernel_size // 2
             kernel_scale = F.pad(kernel_scale, [pad, pad, pad, pad])
 
@@ -186,13 +179,13 @@ class MobileOneBlock(nn.Module):
         kernel_identity = 0
         bias_identity = 0
         if self.rbr_skip is not None:
-            (kernel_identity, bias_identity) = self._fuse_bn_tensor(self.rbr_skip)
+            kernel_identity, bias_identity = self._fuse_bn_tensor(self.rbr_skip)
 
         # Get weights and bias of conv branches
         kernel_conv = 0
         bias_conv = 0
         for ix in range(self.num_conv_branches):
-            (_kernel, _bias) = self._fuse_bn_tensor(self.rbr_conv[ix])
+            _kernel, _bias = self._fuse_bn_tensor(self.rbr_conv[ix])
             kernel_conv += _kernel
             bias_conv += _bias
 

birder/net/mobilevit_v1.py

@@ -1,11 +1,14 @@
 """
-MobileViT, adapted from
+MobileViT v1, adapted from
 https://github.com/huggingface/pytorch-image-models/blob/main/timm/models/mobilevit.py
 and
 https://github.com/lucidrains/vit-pytorch/blob/main/vit_pytorch/mobile_vit.py
 
 Paper "MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer",
 https://arxiv.org/abs/2110.02178
+
+Changes from original:
+* Removed classifier bias
 """
 
 # Reference license: Apache-2.0 and MIT
@@ -63,6 +66,7 @@ class MobileVitBlock(nn.Module):
                     attention_dropout=attn_drop,
                     drop_path=drop_path_rate,
                     activation_layer=nn.SiLU,
+                    norm_layer_eps=1e-5,
                 )
                 for _ in range(transformer_depth)
             ]
@@ -97,8 +101,8 @@ class MobileVitBlock(nn.Module):
         x = self.conv_1x1(x)
 
         # Unfold (feature map -> patches)
-        (patch_h, patch_w) = self.patch_size
-        (B, C, H, W) = x.shape
+        patch_h, patch_w = self.patch_size
+        B, C, H, W = x.shape
         new_h, new_w = math.ceil(H / patch_h) * patch_h, math.ceil(W / patch_w) * patch_w
         num_patch_h = new_h // patch_h  # n_h, n_w
         num_patch_w = new_w // patch_w
@@ -166,7 +170,6 @@ class MobileViT_v1(BaseNet):
             stride=(2, 2),
             padding=(1, 1),
             activation_layer=nn.SiLU,
-            bias=True,
         )
 
         layers = []
@@ -231,7 +234,6 @@ class MobileViT_v1(BaseNet):
                 stride=(1, 1),
                 padding=(0, 0),
                 activation_layer=nn.SiLU,
-                bias=True,
             ),
             nn.AdaptiveAvgPool2d(output_size=(1, 1)),
             nn.Flatten(1),
@@ -290,32 +292,3 @@ registry.register_model_config(
         "expansion": 4,
     },
 )
-
-registry.register_weights(
-    "mobilevit_v1_xxs_il-common",
-    {
-        "description": "MobileViT v1 XXS model trained on the il-common dataset",
-        "resolution": (256, 256),
-        "formats": {
-            "pt": {
-                "file_size": 4.2,
-                "sha256": "2b565a768ca21fd72d5ef5090ff0f8b725f3e1165cd8e56749815041e5254d26",
-            }
-        },
-        "net": {"network": "mobilevit_v1_xxs", "tag": "il-common"},
-    },
-)
-registry.register_weights(
-    "mobilevit_v1_xs_il-common",
-    {
-        "description": "MobileViT v1 XS model trained on the il-common dataset",
-        "resolution": (256, 256),
-        "formats": {
-            "pt": {
-                "file_size": 8.1,
-                "sha256": "193bcede7f0b9f4574673e95c23c6ca3b8eeb30254a32a85e93342f1d67db31b",
-            }
-        },
-        "net": {"network": "mobilevit_v1_xs", "tag": "il-common"},
-    },
-)

birder/net/mobilevit_v2.py

@@ -63,7 +63,7 @@ class LinearSelfAttention(nn.Module):
         # Project x into query, key and value
         # Query --> [B, 1, P, N]
         # value, key --> [B, d, P, N]
-        (query, key, value) = qkv.split([1, self.embed_dim, self.embed_dim], dim=1)
+        query, key, value = qkv.split([1, self.embed_dim, self.embed_dim], dim=1)
 
         # apply softmax along N dimension
         context_scores = F.softmax(query, dim=-1)
@@ -98,14 +98,10 @@ class LinearTransformerBlock(nn.Module):
 
         self.norm2 = nn.GroupNorm(num_groups=1, num_channels=embed_dim)
         self.mlp = nn.Sequential(
-            nn.Conv2d(
-                embed_dim, int(embed_dim * mlp_ratio), kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=True
-            ),
+            nn.Conv2d(embed_dim, int(embed_dim * mlp_ratio), kernel_size=(1, 1), stride=(1, 1), padding=(0, 0)),
             nn.SiLU(),
             nn.Dropout(drop),
-            nn.Conv2d(
-                int(embed_dim * mlp_ratio), embed_dim, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=True
-            ),
+            nn.Conv2d(int(embed_dim * mlp_ratio), embed_dim, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0)),
         )
         self.drop_path2 = StochasticDepth(drop_path, mode="row")
 
@@ -159,20 +155,15 @@ 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
         self.patch_area = self.patch_size[0] * self.patch_size[1]
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, C, H, W) = x.shape
-        (patch_h, patch_w) = self.patch_size
+        B, C, H, W = x.shape
+        patch_h, patch_w = self.patch_size
         new_h = math.ceil(H / patch_h) * patch_h
         new_w = math.ceil(W / patch_w) * patch_w
         num_patch_h, num_patch_w = new_h // patch_h, new_w // patch_w  # n_h, n_w
@@ -236,7 +227,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 +330,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 +339,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")