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

birder/net/mim/simmim.py

@@ -80,7 +80,6 @@ class SimMIM(MIMBaseNet):
             kernel_size=(1, 1),
             stride=(1, 1),
             padding=(0, 0),
-            bias=True,
         )
 
         self.mask_token = nn.Parameter(torch.zeros(1, 1, 1, self.encoder.stem_width))
@@ -112,7 +111,7 @@ class SimMIM(MIMBaseNet):
         """
 
         if x.ndim == 4:
-            (n, c, _, _) = x.shape
+            n, c, _, _ = x.shape
             x = x.reshape(n, c, -1)
             x = torch.einsum("ncl->nlc", x)
 
@@ -135,7 +134,7 @@ class SimMIM(MIMBaseNet):
         mask: 0 is keep, 1 is remove
         """
 
-        (N, C, _, _) = pred.shape
+        N, C, _, _ = pred.shape
         pred = pred.reshape(N, C, -1)
         pred = torch.einsum("ncl->nlc", pred)
 

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

@@ -101,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

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")
 
@@ -166,8 +162,8 @@ class MobileVitBlock(nn.Module):
         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

birder/net/mvit_v2.py

@@ -36,7 +36,7 @@ from birder.net.base import TokenRetentionResultType
 def pre_pool(
     x: torch.Tensor, hw_shape: tuple[int, int], has_cls_token: bool
 ) -> tuple[torch.Tensor, Optional[torch.Tensor]]:
-    (H, W) = hw_shape
+    H, W = hw_shape
     if has_cls_token is True:
         cls_tok = x[:, :, :1, :]
         x = x[:, :, 1:, :]
@@ -68,8 +68,8 @@ def cal_rel_pos_spatial(
     rel_pos_w: torch.Tensor,
 ) -> torch.Tensor:
     sp_idx = 1 if has_cls_token is True else 0
-    (q_h, q_w) = q_shape
-    (k_h, k_w) = k_shape
+    q_h, q_w = q_shape
+    k_h, k_w = k_shape
 
     # Scale up rel pos if shapes for q and k are different.
     q_h_ratio = max(k_h / q_h, 1.0)
@@ -90,7 +90,7 @@ def cal_rel_pos_spatial(
     rel_h = rel_pos_h[dist_h.long()]
     rel_w = rel_pos_w[dist_w.long()]
 
-    (B, n_head, _, dim) = q.shape
+    B, n_head, _, dim = q.shape
 
     r_q = q[:, :, sp_idx:].reshape(B, n_head, q_h, q_w, dim)
     rel_h = torch.einsum("byhwc,hkc->byhwk", r_q, rel_h)
@@ -108,7 +108,7 @@ class SequentialWithShape(nn.Sequential):
         self, x: torch.Tensor, hw_shape: tuple[int, int]
     ) -> tuple[torch.Tensor, tuple[int, int]]:
         for module in self:
-            (x, hw_shape) = module(x, hw_shape)
+            x, hw_shape = module(x, hw_shape)
 
         return (x, hw_shape)
 
@@ -129,7 +129,7 @@ class PatchEmbed(nn.Module):
 
     def forward(self, x: torch.Tensor) -> tuple[torch.Tensor, tuple[int, int]]:
         x = self.proj(x)
-        (H, W) = x.shape[2:4]
+        H, W = x.shape[2:4]
 
         x = x.flatten(2).transpose(1, 2)
 
@@ -227,31 +227,31 @@ class MultiScaleAttention(nn.Module):
         nn.init.trunc_normal_(self.rel_pos_w, std=0.02)
 
     def forward(self, x: torch.Tensor, hw_shape: tuple[int, int]) -> tuple[torch.Tensor, tuple[int, int]]:
-        (B, N, _) = x.size()
+        B, N, _ = x.size()
 
         qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4)
-        (q, k, v) = qkv.unbind(dim=0)
+        q, k, v = qkv.unbind(dim=0)
 
         if self.pool_q is not None:
-            (q, q_tok) = pre_pool(q, hw_shape, self.has_cls_token)
+            q, q_tok = pre_pool(q, hw_shape, self.has_cls_token)
             q = self.pool_q(q)
-            (q, q_shape) = post_pool(q, self.num_heads, q_tok)
+            q, q_shape = post_pool(q, self.num_heads, q_tok)
             q = self.norm_q(q)
         else:
             q_shape = hw_shape
 
         if self.pool_k is not None:
-            (k, k_tok) = pre_pool(k, hw_shape, self.has_cls_token)
+            k, k_tok = pre_pool(k, hw_shape, self.has_cls_token)
             k = self.pool_k(k)
-            (k, k_shape) = post_pool(k, self.num_heads, k_tok)
+            k, k_shape = post_pool(k, self.num_heads, k_tok)
             k = self.norm_k(k)
         else:
             k_shape = hw_shape
 
         if self.pool_v is not None:
-            (v, v_tok) = pre_pool(v, hw_shape, self.has_cls_token)
+            v, v_tok = pre_pool(v, hw_shape, self.has_cls_token)
             v = self.pool_v(v)
-            (v, _) = post_pool(v, self.num_heads, v_tok)
+            v, _ = post_pool(v, self.num_heads, v_tok)
             v = self.norm_v(v)
 
         attn = (q * self.scale) @ k.transpose(-2, -1)
@@ -337,8 +337,8 @@ class MultiScaleBlock(nn.Module):
         else:
             cls_tok = None
 
-        (B, _, C) = x.size()
-        (H, W) = hw_shape
+        B, _, C = x.size()
+        H, W = hw_shape
         x = x.reshape(B, H, W, C).permute(0, 3, 1, 2).contiguous()
         x = self.pool_skip(x)
         x = x.reshape(B, C, -1).transpose(1, 2)
@@ -349,7 +349,7 @@ class MultiScaleBlock(nn.Module):
 
     def forward(self, x: torch.Tensor, hw_shape: tuple[int, int]) -> tuple[torch.Tensor, tuple[int, int]]:
         x_norm = self.norm1(x)
-        (x_block, hw_shape_new) = self.attn(x_norm, hw_shape)
+        x_block, hw_shape_new = self.attn(x_norm, hw_shape)
 
         if self.proj_attn is not None:
             x = self.proj_attn(x_norm)
@@ -421,7 +421,7 @@ class MultiScaleVitStage(nn.Module):
 
     def forward(self, x: torch.Tensor, hw_shape: tuple[int, int]) -> tuple[torch.Tensor, tuple[int, int]]:
         for blk in self.blocks:
-            (x, hw_shape) = blk(x, hw_shape)
+            x, hw_shape = blk(x, hw_shape)
 
         return (x, hw_shape)
 
@@ -523,14 +523,14 @@ class MViT_v2(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
                     nn.init.zeros_(m.bias)
 
     def detection_features(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
-        (x, hw_shape) = self.patch_embed(x)
+        x, hw_shape = self.patch_embed(x)
         if self.cls_token is not None:
             cls_tokens = self.cls_token.expand(x.size(0), -1, -1)
             x = torch.concat((cls_tokens, x), dim=1)
 
         out = {}
         for name, module in self.body.named_children():
-            (x, hw_shape) = module(x, hw_shape)
+            x, hw_shape = module(x, hw_shape)
             if name in self.return_stages:
                 x_inter = x
                 if self.cls_token is not None:
@@ -561,7 +561,7 @@ class MViT_v2(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
     ) -> TokenRetentionResultType:
         B = x.size(0)
 
-        (x, hw_shape) = self.patch_embed(x)
+        x, hw_shape = self.patch_embed(x)
         x = mask_tensor(
             x.permute(0, 2, 1).reshape(B, -1, hw_shape[0], hw_shape[1]),
             mask,
@@ -574,7 +574,7 @@ class MViT_v2(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
             cls_tokens = self.cls_token.expand(B, -1, -1)
             x = torch.concat((cls_tokens, x), dim=1)
 
-        (x, _) = self.body(x, hw_shape)
+        x, _ = self.body(x, hw_shape)
         x = self.norm(x)
 
         result: TokenRetentionResultType = {}
@@ -596,12 +596,12 @@ class MViT_v2(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
         return result
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
-        (x, hw_shape) = self.patch_embed(x)
+        x, hw_shape = self.patch_embed(x)
         if self.cls_token is not None:
             cls_tokens = self.cls_token.expand(x.size(0), -1, -1)
             x = torch.concat((cls_tokens, x), dim=1)
 
-        (x, _) = self.body(x, hw_shape)
+        x, _ = self.body(x, hw_shape)
         x = self.norm(x)
 
         return x

birder/net/nextvit.py

@@ -165,7 +165,7 @@ class E_MHSA(nn.Module):
             self.norm = nn.Identity()
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, N, C) = x.size()
+        B, N, C = x.size()
         q = self.q(x)
         q = q.reshape(B, N, self.num_heads, int(C // self.num_heads)).permute(0, 2, 1, 3)
 
@@ -226,7 +226,7 @@ class NTB(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.patch_embed(x)
-        (B, C, H, W) = x.size()
+        B, C, H, W = x.size()
         out = self.norm1(x)
 
         out = out.reshape(B, C, H * W).permute(0, 2, 1)

birder/net/pit.py

@@ -29,12 +29,12 @@ class SequentialTuple(nn.Sequential):
         self, x: tuple[torch.Tensor, torch.Tensor]
     ) -> tuple[torch.Tensor, torch.Tensor]:
         for module in self:
-            x = module(x)
+            x = module(*x)
 
         return x
 
 
-class Transformer(nn.Module):
+class PiTStage(nn.Module):
     def __init__(
         self,
         base_dim: int,
@@ -59,13 +59,12 @@ class Transformer(nn.Module):
             dpr=drop_path_prob,
         )
 
-    def forward(self, xt: tuple[torch.Tensor, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
-        (x, cls_tokens) = xt
+    def forward(self, x: torch.Tensor, cls_tokens: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         token_length = cls_tokens.shape[1]
         if self.pool is not None:
-            (x, cls_tokens) = self.pool(x, cls_tokens)
+            x, cls_tokens = self.pool(x, cls_tokens)
 
-        (B, C, H, W) = x.size()
+        B, C, H, W = x.size()
         x = x.flatten(2).transpose(1, 2)
         x = torch.concat((cls_tokens, x), dim=1)
         x = self.encoder(x)
@@ -142,7 +141,7 @@ class PiT(DetectorBackbone):
             if i > 0:
                 pool = Pooling(prev_dim, embed_dim)
 
-            stages[f"stage{i+1}"] = Transformer(
+            stages[f"stage{i+1}"] = PiTStage(
                 base_dims[i],
                 depth,
                 heads=heads[i],
@@ -158,7 +157,7 @@ class PiT(DetectorBackbone):
         self.body = SequentialTuple(stages)
         self.norm = nn.LayerNorm(embed_dim, eps=1e-6)
 
-        self.return_stages = self.return_stages[: len(depths)]
+        self.return_stages = [f"stage{idx + 1}" for idx in range(len(depths))]
         self.return_channels = return_channels
         self.embedding_size = embed_dim
         self.dist_classifier = self.create_classifier()
@@ -197,7 +196,7 @@ class PiT(DetectorBackbone):
 
         out = {}
         for name, module in self.body.named_children():
-            (x, cls_tokens) = module((x, cls_tokens))
+            x, cls_tokens = module(x, cls_tokens)
             if name in self.return_stages:
                 out[name] = x
 
@@ -218,12 +217,13 @@ class PiT(DetectorBackbone):
         x = self.stem(x)
         x = x + self.pos_embed
         cls_tokens = self.cls_token.expand(x.shape[0], -1, -1)
-        (x, cls_tokens) = self.body((x, cls_tokens))
+        for stage in self.body.children():
+            x, cls_tokens = stage(x, cls_tokens)
 
         return (x, cls_tokens)
 
     def embedding(self, x: torch.Tensor) -> torch.Tensor:
-        (_, cls_tokens) = self.forward_features(x)
+        _, cls_tokens = self.forward_features(x)
         cls_tokens = self.norm(cls_tokens)
 
         return cls_tokens
@@ -312,18 +312,3 @@ registry.register_model_config(
         "drop_path_rate": 0.1,
     },
 )
-
-registry.register_weights(
-    "pit_t_il-common",
-    {
-        "description": "PiT tiny model trained on the il-common dataset",
-        "resolution": (256, 256),
-        "formats": {
-            "pt": {
-                "file_size": 18.4,
-                "sha256": "5f6bd74b09c1ee541ee2ddae4844ce501b4b3218201ea6381fce0b8fc30257f2",
-            }
-        },
-        "net": {"network": "pit_t", "tag": "il-common"},
-    },
-)

birder/net/pvt_v1.py

@@ -56,7 +56,7 @@ class Attention(nn.Module):
             self.norm = None
 
     def forward(self, x: torch.Tensor, H: int, W: int) -> torch.Tensor:
-        (B, N, C) = x.shape
+        B, N, C = x.shape
         q = self.q(x).reshape(B, N, self.num_heads, -1).permute(0, 2, 1, 3)
 
         if self.sr is not None:
@@ -65,7 +65,7 @@ class Attention(nn.Module):
             x = self.norm(x)
 
         kv = self.kv(x).reshape(B, -1, 2, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
-        (k, v) = kv.unbind(0)
+        k, v = kv.unbind(0)
 
         x = F.scaled_dot_product_attention(  # pylint: disable=not-callable
             q, k, v, dropout_p=self.attn_drop.p if self.training else 0.0, scale=self.scale
@@ -177,7 +177,7 @@ class PyramidVisionTransformerStage(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.downsample(x)  # B, C, H, W -> B, H, W, C
-        (B, H, W, C) = x.size()
+        B, H, W, C = x.size()
         x = x.reshape(B, -1, C)
         x = x + self.pos_embed
         if self.cls_token is not None:
@@ -264,7 +264,7 @@ class PVT_v1(DetectorBackbone):
 
         out = {}
         for name, module in self.body.named_children():
-            (B, _, H, W) = x.size()
+            B, _, H, W = x.size()
             x = module(x)
             if name in self.return_stages:
                 if name == "stage4":

birder/net/pvt_v2.py

@@ -29,13 +29,7 @@ class MLP(nn.Module):
         self.fc1 = nn.Linear(in_features, hidden_features)
         self.relu = nn.ReLU() if extra_relu else nn.Identity()
         self.dwconv = nn.Conv2d(
-            hidden_features,
-            hidden_features,
-            kernel_size=(3, 3),
-            stride=(1, 1),
-            padding=(1, 1),
-            groups=hidden_features,
-            bias=True,
+            hidden_features, hidden_features, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=hidden_features
         )
         self.act = nn.GELU()
         self.fc2 = nn.Linear(hidden_features, in_features)
@@ -44,7 +38,7 @@ class MLP(nn.Module):
     def forward(self, x: torch.Tensor, H: int, W: int) -> torch.Tensor:
         x = self.fc1(x)
         x = self.relu(x)
-        (B, _, C) = x.shape
+        B, _, C = x.shape
         x = x.transpose(1, 2).view(B, C, H, W)
         x = self.dwconv(x)
         x = x.flatten(2).transpose(1, 2)
@@ -98,7 +92,7 @@ class Attention(nn.Module):
         assert (self.pool is None and self.act is None) or (self.pool is not None and self.act is not None)
 
     def forward(self, x: torch.Tensor, H: int, W: int) -> torch.Tensor:
-        (B, N, C) = x.shape
+        B, N, C = x.shape
         q = self.q(x).reshape(B, N, self.num_heads, -1).permute(0, 2, 1, 3)
 
         if self.pool is not None and self.act is not None:
@@ -114,7 +108,7 @@ class Attention(nn.Module):
                 x = self.norm(x)
 
         kv = self.kv(x).reshape(B, -1, 2, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
-        (k, v) = kv.unbind(0)
+        k, v = kv.unbind(0)
 
         x = F.scaled_dot_product_attention(  # pylint: disable=not-callable
             q, k, v, dropout_p=self.attn_drop.p if self.training else 0.0, scale=self.scale
@@ -238,7 +232,7 @@ class PyramidVisionTransformerStage(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.downsample(x)  # B, C, H, W -> B, H, W, C
-        (B, H, W, C) = x.shape
+        B, H, W, C = x.shape
         x = x.reshape(B, -1, C)
         for blk in self.blocks:
             x = blk(x, H, W)

birder/net/regionvit.py

@@ -30,8 +30,8 @@ def convert_to_flatten_layout(
     cls_tokens: torch.Tensor, patch_tokens: torch.Tensor, ws: int
 ) -> tuple[torch.Tensor, Optional[torch.Tensor], int, int, int, int, int, int]:
     # Padding if added will be at the bottom right
-    (B, C, H, W) = patch_tokens.size()
-    (_, _, h_ks, w_ks) = cls_tokens.size()
+    B, C, H, W = patch_tokens.size()
+    _, _, h_ks, w_ks = cls_tokens.size()
     need_mask = False
     p_l = 0
     p_r = 0
@@ -43,13 +43,13 @@ def convert_to_flatten_layout(
         patch_tokens = F.pad(patch_tokens, (p_l, p_r, p_t, p_b))
         need_mask = True
 
-    (B, C, H, W) = patch_tokens.size()
+    B, C, H, W = patch_tokens.size()
     kernel_size = (H // h_ks, W // w_ks)
     tmp = F.unfold(patch_tokens, kernel_size=kernel_size, dilation=(1, 1), padding=(0, 0), stride=kernel_size)
     patch_tokens = tmp.transpose(1, 2).reshape(-1, C, kernel_size[0] * kernel_size[1]).transpose(-2, -1)
 
     if need_mask is True:
-        (bh_sk_s, ksks, C) = patch_tokens.size()
+        bh_sk_s, ksks, C = patch_tokens.size()
         h_s = H // ws
         w_s = W // ws
         mask = torch.ones(bh_sk_s // B, 1 + ksks, 1 + ksks, device=patch_tokens.device, dtype=torch.float)
@@ -116,7 +116,7 @@ class SequentialWithTwo(nn.Sequential):
         self, cls_tokens: torch.Tensor, patch_tokens: torch.Tensor
     ) -> tuple[torch.Tensor, torch.Tensor]:
         for module in self:
-            (cls_tokens, patch_tokens) = module(cls_tokens, patch_tokens)
+            cls_tokens, patch_tokens = module(cls_tokens, patch_tokens)
 
         return (cls_tokens, patch_tokens)
 
@@ -178,9 +178,9 @@ class AttentionWithRelPos(nn.Module):
         nn.init.trunc_normal_(self.rel_pos, std=0.02)
 
     def forward(self, x: torch.Tensor, patch_attn: bool = False, mask: Optional[torch.Tensor] = None) -> torch.Tensor:
-        (B, N, C) = x.size()
+        B, N, C = x.size()
         qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        (q, k, v) = qkv.unbind(0)
+        q, k, v = qkv.unbind(0)
 
         attn = (q @ k.transpose(-2, -1)) * self.scale
 
@@ -242,7 +242,7 @@ class PatchEmbed(nn.Module):
             raise ValueError("Unknown patch_conv_type")
 
     def forward(self, x: torch.Tensor, extra_padding: bool = False) -> torch.Tensor:
-        (_, _, H, W) = x.size()
+        _, _, H, W = x.size()
         if extra_padding and (H % self.patch_size[0] != 0 or W % self.patch_size[1] != 0):
             p_l = (self.patch_size[1] - W % self.patch_size[1]) // 2
             p_r = (self.patch_size[1] - W % self.patch_size[1]) - p_l
@@ -384,12 +384,12 @@ class ConvAttStage(nn.Module):
         self.ws = window_size
 
     def forward(self, cls_tokens: torch.Tensor, patch_tokens: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        (cls_tokens, patch_tokens) = self.proj(cls_tokens, patch_tokens)
-        (out, mask, p_r, p_b, B, C, H, W) = convert_to_flatten_layout(cls_tokens, patch_tokens, self.ws[0])
+        cls_tokens, patch_tokens = self.proj(cls_tokens, patch_tokens)
+        out, mask, p_r, p_b, B, C, H, W = convert_to_flatten_layout(cls_tokens, patch_tokens, self.ws[0])
         for blk in self.blocks:
             out = blk(out, mask, B)
 
-        (cls_tokens, patch_tokens) = convert_to_spatial_layout(out, B, C, H, W, self.ws, mask, p_r, p_b)
+        cls_tokens, patch_tokens = convert_to_spatial_layout(out, B, C, H, W, self.ws, mask, p_r, p_b)
 
         return (cls_tokens, patch_tokens)
 
@@ -480,7 +480,7 @@ class RegionViT(DetectorBackbone):
 
         out = {}
         for name, module in self.body.named_children():
-            (cls_tokens, x) = module(cls_tokens, x)
+            cls_tokens, x = module(cls_tokens, x)
             if name in self.return_stages:
                 out[name] = x
 
@@ -503,14 +503,14 @@ class RegionViT(DetectorBackbone):
         o_x = x
         x = self.patch_embed(x)
         cls_tokens = self.cls_token(o_x, extra_padding=True)
-        (cls_tokens, x) = self.body(cls_tokens, x)
+        cls_tokens, x = self.body(cls_tokens, x)
 
         return (cls_tokens, x)
 
     def embedding(self, x: torch.Tensor) -> torch.Tensor:
-        (cls_tokens, _) = self.forward_features(x)
+        cls_tokens, _ = self.forward_features(x)
 
-        (N, C, _, _) = cls_tokens.size()
+        N, C, _, _ = cls_tokens.size()
         cls_tokens = cls_tokens.reshape(N, C, -1).transpose(1, 2)
         cls_tokens = self.norm(cls_tokens)
         out = torch.mean(cls_tokens, dim=1)

birder/net/regnet.py

@@ -100,7 +100,7 @@ class BlockParams:
         group_widths = [group_width] * num_stages
 
         # Adjust the compatibility of stage widths and group widths
-        (stage_widths, group_widths) = cls._adjust_widths_groups_compatibility(
+        stage_widths, group_widths = cls._adjust_widths_groups_compatibility(
             stage_widths, bottleneck_multipliers, group_widths
         )
 

birder/net/repghost.py

@@ -79,7 +79,7 @@ class RepGhostModule(nn.Module):
         if self.reparameterized is True:
             return
 
-        (kernel, bias) = self._get_kernel_bias()
+        kernel, bias = self._get_kernel_bias()
         self.cheap_operation = nn.Conv2d(
             in_channels=self.cheap_operation[0].in_channels,
             out_channels=self.cheap_operation[0].out_channels,
@@ -87,7 +87,6 @@ class RepGhostModule(nn.Module):
             padding=self.cheap_operation[0].padding,
             dilation=self.cheap_operation[0].dilation,
             groups=self.cheap_operation[0].groups,
-            bias=True,
         )
 
         self.cheap_operation.weight.data = kernel
@@ -98,9 +97,9 @@ class RepGhostModule(nn.Module):
         self.reparameterized = True
 
     def _get_kernel_bias(self) -> tuple[torch.Tensor, torch.Tensor]:
-        (kernel, bias) = self._fuse_bn_tensor(self.cheap_operation[0], self.cheap_operation[1])
+        kernel, bias = self._fuse_bn_tensor(self.cheap_operation[0], self.cheap_operation[1])
         if self.fusion_bn is not None:
-            (kernel1x1, bias_bn) = self._fuse_bn_tensor(nn.Identity(), self.fusion_bn, kernel.shape[0])
+            kernel1x1, bias_bn = self._fuse_bn_tensor(nn.Identity(), self.fusion_bn, kernel.shape[0])
             kernel += F.pad(kernel1x1, [1, 1, 1, 1])
             bias += bias_bn
 
@@ -299,7 +298,7 @@ class RepGhost(DetectorBackbone):
         out_channels = 1280
         self.features = nn.Sequential(
             nn.AdaptiveAvgPool2d(output_size=(1, 1)),
-            nn.Conv2d(prev_channels, out_channels, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=True),
+            nn.Conv2d(prev_channels, out_channels, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0)),
             nn.ReLU(inplace=True),
             nn.Flatten(1),
             nn.Dropout(p=0.2),