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

birder/net/iformer.py

@@ -113,12 +113,12 @@ class LowMixer(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.pool(x)
-        (B, _, H, W) = x.size()
+        B, _, H, W = x.size()
         x = x.permute(0, 2, 3, 1).view(B, -1, self.dim)
 
-        (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)
         x = F.scaled_dot_product_attention(  # pylint: disable=not-callable
             q, k, v, dropout_p=self.attn_drop if self.training else 0.0, scale=self.scale
         )
@@ -301,7 +301,7 @@ class InceptionTransformerStage(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.downsample(x)
-        (H, W) = x.shape[1:3]
+        H, W = x.shape[1:3]
 
         x = x + self._get_pos_embed(H, W)
         x = self.blocks(x)

birder/net/inception_next.py

@@ -33,7 +33,6 @@ class InceptionDWConv2d(nn.Module):
             stride=(1, 1),
             padding=square_kernel_size // 2,
             groups=branch_channels,
-            bias=True,
         )
         self.dwconv_w = nn.Conv2d(
             branch_channels,
@@ -42,7 +41,6 @@ class InceptionDWConv2d(nn.Module):
             stride=(1, 1),
             padding=(0, band_kernel_size // 2),
             groups=branch_channels,
-            bias=True,
         )
         self.dwconv_h = nn.Conv2d(
             branch_channels,
@@ -51,7 +49,6 @@ class InceptionDWConv2d(nn.Module):
             stride=(1, 1),
             padding=(band_kernel_size // 2, 0),
             groups=branch_channels,
-            bias=True,
         )
         self.split_indexes = (
             in_channels - (3 * branch_channels),
@@ -61,7 +58,7 @@ class InceptionDWConv2d(nn.Module):
         )
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (x_id, x_hw, x_w, x_h) = torch.split(x, self.split_indexes, dim=1)
+        x_id, x_hw, x_w, x_h = torch.split(x, self.split_indexes, dim=1)
         x_hw = self.dwconv_hw(x_hw)
         x_w = self.dwconv_w(x_w)
         x_h = self.dwconv_h(x_h)
@@ -78,11 +75,9 @@ class ConvMLP(nn.Module):
         act_layer: Callable[..., nn.Module] = nn.GELU,
     ) -> None:
         super().__init__()
-        self.fc1 = nn.Conv2d(in_features, hidden_features, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=True)
+        self.fc1 = nn.Conv2d(in_features, hidden_features, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0))
         self.act = act_layer()
-        self.fc2 = nn.Conv2d(
-            hidden_features, out_features, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=True
-        )
+        self.fc2 = nn.Conv2d(hidden_features, out_features, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0))
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.fc1(x)
@@ -139,12 +134,7 @@ class InceptionNeXtStage(nn.Module):
             self.downsample = nn.Sequential(
                 nn.BatchNorm2d(in_channels),
                 nn.Conv2d(
-                    in_channels,
-                    out_channels,
-                    kernel_size=(stride, stride),
-                    stride=(stride, stride),
-                    padding=(0, 0),
-                    bias=True,
+                    in_channels, out_channels, kernel_size=(stride, stride), stride=(stride, stride), padding=(0, 0)
                 ),
             )
 

birder/net/levit.py

@@ -45,7 +45,7 @@ class Subsample(nn.Module):
         self.resolution = resolution
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, _, C) = x.shape
+        B, _, C = x.shape
         x = x.view(B, self.resolution[0], self.resolution[1], C)
         x = x[:, :: self.stride, :: self.stride]
         return x.reshape(B, -1, C)
@@ -84,7 +84,7 @@ class Attention(nn.Module):
         self.attention_bias_idxs = nn.Buffer(rel_pos, persistent=False)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, N, _) = x.shape
+        B, N, _ = x.shape
         q, k, v = self.qkv(x).view(B, N, self.num_heads, -1).split([self.key_dim, self.key_dim, self.val_dim], dim=3)
         q = q.permute(0, 2, 1, 3)
         k = k.permute(0, 2, 3, 1)
@@ -144,7 +144,7 @@ class AttentionSubsample(nn.Module):
         self.attention_bias_idxs = nn.Buffer(rel_pos, persistent=False)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, N, _) = x.shape
+        B, N, _ = x.shape
         k, v = self.kv(x).view(B, N, self.num_heads, -1).split([self.key_dim, self.val_dim], dim=3)
         k = k.permute(0, 2, 3, 1)  # BHCN
         v = v.permute(0, 2, 1, 3)  # BHNC

birder/net/lit_v1.py

@@ -43,7 +43,7 @@ def interpolate_rel_pos_bias_table(
     if new_resolution == base_resolution:
         return rel_pos_bias_table
 
-    (base_h, base_w) = base_resolution
+    base_h, base_w = base_resolution
     num_heads = rel_pos_bias_table.size(1)
     orig_dtype = rel_pos_bias_table.dtype
     bias_table = rel_pos_bias_table.float()
@@ -104,7 +104,7 @@ class RelPosAttention(nn.Module):
         relative_position_index = build_relative_position_index(input_resolution, device=bias_table.device)
         self.relative_position_index = nn.Buffer(relative_position_index)
 
-        self.qkv = nn.Linear(dim, dim * 3, bias=True)
+        self.qkv = nn.Linear(dim, dim * 3)
         self.proj = nn.Linear(dim, dim)
 
         # Weight initialization
@@ -130,9 +130,9 @@ class RelPosAttention(nn.Module):
         return relative_position_bias.unsqueeze(0)
 
     def forward(self, x: torch.Tensor, resolution: tuple[int, int]) -> 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 * self.scale) @ k.transpose(-2, -1)
         attn = attn + self._get_rel_pos_bias(resolution)
@@ -177,7 +177,6 @@ class DeformablePatchMerging(nn.Module):
             kernel_size=(kernel_size, kernel_size),
             stride=(kernel_size, kernel_size),
             padding=(0, 0),
-            bias=True,
         )
         self.deform_conv = DeformConv2d(
             in_dim,
@@ -195,8 +194,8 @@ class DeformablePatchMerging(nn.Module):
         nn.init.zeros_(self.offset_conv.bias)
 
     def forward(self, x: torch.Tensor, resolution: tuple[int, int]) -> tuple[torch.Tensor, int, int]:
-        (H, W) = resolution
-        (B, _, C) = x.size()
+        H, W = resolution
+        B, _, C = x.size()
 
         x = x.reshape(B, H, W, C).permute(0, 3, 1, 2).contiguous()
 
@@ -206,7 +205,7 @@ class DeformablePatchMerging(nn.Module):
         x = self.norm(x)
         x = self.act(x)
 
-        (B, C, H, W) = x.size()
+        B, C, H, W = x.size()
         x = x.permute(0, 2, 3, 1).reshape(B, H * W, C)
 
         return (x, H, W)
@@ -252,7 +251,7 @@ class LITStage(nn.Module):
                 block.set_dynamic_size(dynamic_size)
 
     def forward(self, x: torch.Tensor, input_resolution: tuple[int, int]) -> tuple[torch.Tensor, int, int]:
-        (x, H, W) = self.downsample(x, input_resolution)
+        x, H, W = self.downsample(x, input_resolution)
         for block in self.blocks:
             x = block(x, (H, W))
 
@@ -291,7 +290,6 @@ class LIT_v1(DetectorBackbone):
                 kernel_size=(patch_size, patch_size),
                 stride=(patch_size, patch_size),
                 padding=(0, 0),
-                bias=True,
             ),
             Permute([0, 2, 3, 1]),
             nn.LayerNorm(embed_dim),
@@ -361,12 +359,12 @@ class LIT_v1(DetectorBackbone):
 
     def detection_features(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
         x = self.stem(x)
-        (B, H, W, C) = x.size()
+        B, H, W, C = x.size()
         x = x.reshape(B, H * W, C)
 
         out = {}
         for name, stage in self.body.items():
-            (x, H, W) = stage(x, (H, W))
+            x, H, W = stage(x, (H, W))
             if name in self.return_stages:
                 features = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
                 out[name] = features
@@ -386,10 +384,10 @@ class LIT_v1(DetectorBackbone):
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         x = self.stem(x)
-        (B, H, W, C) = x.size()
+        B, H, W, C = x.size()
         x = x.reshape(B, H * W, C)
         for stage in self.body.values():
-            (x, H, W) = stage(x, (H, W))
+            x, H, W = stage(x, (H, W))
 
         return x
 
@@ -410,7 +408,7 @@ class LIT_v1(DetectorBackbone):
 
         new_patches_resolution = (new_size[0] // self.patch_size, new_size[1] // self.patch_size)
 
-        (h, w) = new_patches_resolution
+        h, w = new_patches_resolution
         for stage in self.body.values():
             if not isinstance(stage.downsample, IdentityDownsample):
                 h = h // 2

birder/net/lit_v1_tiny.py

@@ -44,13 +44,13 @@ class Attention(nn.Module):
         super().__init__()
         self.num_heads = num_heads
         self.scale = (dim // num_heads) ** -0.5
-        self.qkv = nn.Linear(dim, dim * 3, bias=True)
+        self.qkv = nn.Linear(dim, dim * 3)
         self.proj = nn.Linear(dim, dim)
 
     def forward(self, x: torch.Tensor) -> 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
         attn = F.softmax(attn, dim=-1)
@@ -139,7 +139,7 @@ class LITStage(nn.Module):
         )
 
     def forward(self, x: torch.Tensor, input_resolution: tuple[int, int]) -> tuple[torch.Tensor, int, int]:
-        (x, H, W) = self.downsample(x, input_resolution)
+        x, H, W = self.downsample(x, input_resolution)
 
         if self.cls_token is not None:
             cls_tokens = self.cls_token.expand(x.size(0), -1, -1)
@@ -247,12 +247,12 @@ class LIT_v1_Tiny(DetectorBackbone):
 
     def detection_features(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
         x = self.stem(x)
-        (B, H, W, C) = x.size()
+        B, H, W, C = x.size()
         x = x.reshape(B, H * W, C)
 
         out = {}
         for name, stage in self.body.items():
-            (x, H, W) = stage(x, (H, W))
+            x, H, W = stage(x, (H, W))
             if name in self.return_stages:
                 if stage.cls_token is not None:
                     spatial_x = x[:, 1:]
@@ -276,10 +276,10 @@ class LIT_v1_Tiny(DetectorBackbone):
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         x = self.stem(x)
-        (B, H, W, C) = x.size()
+        B, H, W, C = x.size()
         x = x.reshape(B, H * W, C)
         for stage in self.body.values():
-            (x, H, W) = stage(x, (H, W))
+            x, H, W = stage(x, (H, W))
 
         return x
 
@@ -301,7 +301,7 @@ class LIT_v1_Tiny(DetectorBackbone):
 
         new_patches_resolution = (new_size[0] // self.patch_size, new_size[1] // self.patch_size)
 
-        (h, w) = new_patches_resolution
+        h, w = new_patches_resolution
         for stage in self.body.values():
             if not isinstance(stage.downsample, IdentityDownsample):
                 h = h // 2

birder/net/lit_v2.py

@@ -39,7 +39,7 @@ class DepthwiseMLP(nn.Module):
     def forward(self, x: torch.Tensor, H: int, W: int) -> torch.Tensor:
         x = self.fc1(x)
 
-        (B, N, C) = x.size()
+        B, N, C = x.size()
         x = x.reshape(B, H, W, C).permute(0, 3, 1, 2).contiguous()
         x = self.dwconv(x)
         x = x.permute(0, 2, 3, 1).reshape(B, N, C)
@@ -57,7 +57,7 @@ class DepthwiseMLPBlock(nn.Module):
         self.drop_path = StochasticDepth(drop_path, mode="row")
 
     def forward(self, x: torch.Tensor, resolution: tuple[int, int]) -> torch.Tensor:
-        (H, W) = resolution
+        H, W = resolution
         return x + self.drop_path(self.mlp(self.norm(x), H, W))
 
 
@@ -121,7 +121,7 @@ class HiLoAttention(nn.Module):
             self.h_proj = nn.Identity()
 
     def _lofi(self, x: torch.Tensor) -> torch.Tensor:
-        (B, H, W, C) = x.size()
+        B, H, W, C = x.size()
 
         q = self.l_q(x).reshape(B, H * W, self.l_heads, self.head_dim).permute(0, 2, 1, 3)
 
@@ -133,7 +133,7 @@ class HiLoAttention(nn.Module):
         else:
             kv = self.l_kv(x).reshape(B, -1, 2, self.l_heads, self.head_dim).permute(2, 0, 3, 1, 4)
 
-        (k, v) = kv.unbind(0)
+        k, v = kv.unbind(0)
 
         attn = (q @ k.transpose(-2, -1)) * self.scale
         attn = F.softmax(attn, dim=-1)
@@ -144,7 +144,7 @@ class HiLoAttention(nn.Module):
         return x
 
     def _hifi(self, x: torch.Tensor) -> torch.Tensor:
-        (B, H, W, _) = x.size()
+        B, H, W, _ = x.size()
         ws = self.window_size
 
         # Pad if needed
@@ -153,7 +153,7 @@ class HiLoAttention(nn.Module):
         if pad_h > 0 or pad_w > 0:
             x = F.pad(x, (0, 0, 0, pad_w, 0, pad_h))
 
-        (_, h_pad, w_pad, _) = x.size()
+        _, h_pad, w_pad, _ = x.size()
         h_groups = h_pad // ws
         w_groups = w_pad // ws
         total_groups = h_groups * w_groups
@@ -161,7 +161,7 @@ class HiLoAttention(nn.Module):
         x = x.reshape(B, h_groups, ws, w_groups, ws, -1).transpose(2, 3)
 
         qkv = self.h_qkv(x).reshape(B, total_groups, -1, 3, self.h_heads, self.head_dim).permute(3, 0, 1, 4, 2, 5)
-        (q, k, v) = qkv.unbind(0)
+        q, k, v = qkv.unbind(0)
 
         attn = (q @ k.transpose(-2, -1)) * self.scale
         attn = F.softmax(attn, dim=-1)
@@ -177,7 +177,7 @@ class HiLoAttention(nn.Module):
         return x
 
     def forward(self, x: torch.Tensor, H: int, W: int) -> torch.Tensor:
-        (B, N, C) = x.size()
+        B, N, C = x.size()
         x = x.reshape(B, H, W, C)
 
         if self.h_heads == 0:
@@ -215,7 +215,7 @@ class HiLoBlock(nn.Module):
         self.drop_path2 = StochasticDepth(drop_path, mode="row")
 
     def forward(self, x: torch.Tensor, resolution: tuple[int, int]) -> torch.Tensor:
-        (H, W) = resolution
+        H, W = resolution
         x = x + self.drop_path1(self.attn(self.norm1(x), H, W))
         x = x + self.drop_path2(self.mlp(self.norm2(x), H, W))
         return x
@@ -252,7 +252,7 @@ class LITStage(nn.Module):
         self.blocks = nn.ModuleList(blocks)
 
     def forward(self, x: torch.Tensor, input_resolution: tuple[int, int]) -> tuple[torch.Tensor, int, int]:
-        (x, H, W) = self.downsample(x, input_resolution)
+        x, H, W = self.downsample(x, input_resolution)
         for block in self.blocks:
             x = block(x, (H, W))
 
@@ -292,7 +292,6 @@ class LIT_v2(DetectorBackbone):
                 kernel_size=(patch_size, patch_size),
                 stride=(patch_size, patch_size),
                 padding=(0, 0),
-                bias=True,
             ),
             Permute([0, 2, 3, 1]),
             nn.LayerNorm(embed_dim),
@@ -361,12 +360,12 @@ class LIT_v2(DetectorBackbone):
 
     def detection_features(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
         x = self.stem(x)
-        (B, H, W, C) = x.size()
+        B, H, W, C = x.size()
         x = x.reshape(B, H * W, C)
 
         out = {}
         for name, stage in self.body.items():
-            (x, H, W) = stage(x, (H, W))
+            x, H, W = stage(x, (H, W))
             if name in self.return_stages:
                 features = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
                 out[name] = features
@@ -386,10 +385,10 @@ class LIT_v2(DetectorBackbone):
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         x = self.stem(x)
-        (B, H, W, C) = x.size()
+        B, H, W, C = x.size()
         x = x.reshape(B, H * W, C)
         for stage in self.body.values():
-            (x, H, W) = stage(x, (H, W))
+            x, H, W = stage(x, (H, W))
 
         return x
 

birder/net/maxvit.py

@@ -83,7 +83,7 @@ class MBConv(nn.Module):
         if stride[0] != 1 or stride[1] != 1 or in_channels != out_channels:
             self.proj = nn.Sequential(
                 nn.AvgPool2d(kernel_size=(3, 3), stride=stride, padding=(1, 1)),
-                nn.Conv2d(in_channels, out_channels, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=True),
+                nn.Conv2d(in_channels, out_channels, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0)),
             )
         else:
             self.proj = nn.Identity()
@@ -119,12 +119,7 @@ class MBConv(nn.Module):
             ),
             SqueezeExcitation(mid_channels, sqz_channels, activation=nn.SiLU),
             nn.Conv2d(
-                in_channels=mid_channels,
-                out_channels=out_channels,
-                kernel_size=(1, 1),
-                stride=(1, 1),
-                padding=(0, 0),
-                bias=True,
+                in_channels=mid_channels, out_channels=out_channels, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0)
             ),
         )
 
@@ -169,12 +164,12 @@ class RelativePositionalMultiHeadAttention(nn.Module):
 
     # pylint: disable=invalid-name
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, G, P, D) = x.size()
+        B, G, P, D = x.size()
         H = self.n_heads
         DH = self.head_dim
 
         qkv = self.to_qkv(x)
-        (q, k, v) = torch.chunk(qkv, 3, dim=-1)
+        q, k, v = torch.chunk(qkv, 3, dim=-1)
 
         q = q.reshape(B, G, P, H, DH).permute(0, 1, 3, 2, 4)
         k = k.reshape(B, G, P, H, DH).permute(0, 1, 3, 2, 4)
@@ -206,8 +201,8 @@ class SwapAxes(nn.Module):
 
 class WindowPartition(nn.Module):
     def forward(self, x: torch.Tensor, p: tuple[int, int]) -> torch.Tensor:
-        (B, C, H, W) = x.size()
-        (PH, PW) = p  # pylint: disable=invalid-name
+        B, C, H, W = x.size()
+        PH, PW = p  # pylint: disable=invalid-name
 
         # Chunk up H and W dimensions
         x = x.reshape(B, C, H // PH, PH, W // PW, PW)
@@ -222,8 +217,8 @@ class WindowPartition(nn.Module):
 class WindowDepartition(nn.Module):
     # pylint: disable=invalid-name
     def forward(self, x: torch.Tensor, p: tuple[int, int], h_partitions: int, w_partitions: int) -> torch.Tensor:
-        (B, _G, _PP, C) = x.size()
-        (PH, PW) = p  # pylint: disable=invalid-name
+        B, _G, _PP, C = x.size()
+        PH, PW = p  # pylint: disable=invalid-name
         HP = h_partitions
         WP = w_partitions
 
@@ -500,14 +495,7 @@ class MaxViT(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
                 activation_layer=nn.GELU,
                 inplace=None,
             ),
-            nn.Conv2d(
-                stem_channels,
-                stem_channels,
-                kernel_size=(3, 3),
-                stride=(1, 1),
-                padding=(1, 1),
-                bias=True,
-            ),
+            nn.Conv2d(stem_channels, stem_channels, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
         )
 
         # Account for stem stride
@@ -706,7 +694,7 @@ class MaxViT(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
                             src_size = (2 * old_attn_size[0] - 1, 2 * old_attn_size[1] - 1)
 
                             def _calc(src: int, dst: int) -> list[float]:
-                                (left, right) = 1.01, 1.5
+                                left, right = 1.01, 1.5
                                 while right - left > 1e-6:
                                     q = (left + right) / 2.0
                                     gp = (1.0 - q ** (src // 2)) / (1.0 - q)  # Geometric progression

birder/net/metaformer.py

@@ -127,10 +127,10 @@ class Attention(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = x.permute(0, 2, 3, 1)  # (N, C, H, W) -> (N, H, W, C)
-        (B, H, W, _) = x.shape
+        B, H, W, _ = x.shape
         N = H * W
         qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
-        (q, k, v) = qkv.unbind(0)
+        q, k, v = qkv.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

birder/net/mim/crossmae.py

@@ -46,11 +46,11 @@ class CrossAttention(nn.Module):
         self.proj = nn.Linear(decoder_dim, decoder_dim)
 
     def forward(self, tgt: torch.Tensor, memory: torch.Tensor) -> torch.Tensor:
-        (B, N, C) = tgt.size()
+        B, N, C = tgt.size()
         n_kv = memory.size(1)
         q = self.q(tgt).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
         kv = self.kv(memory).reshape(B, n_kv, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        (k, v) = kv.unbind(0)
+        k, v = kv.unbind(0)
 
         attn = F.scaled_dot_product_attention(q, k, v, dropout_p=0.0)  # pylint: disable=not-callable
         x = attn.transpose(1, 2).reshape(B, N, C)
@@ -120,7 +120,7 @@ class CrossMAE(MIMBaseNet):
             self.decoder_layers.append(CrossAttentionBlock(encoder_dim, decoder_embed_dim, num_heads=16, mlp_ratio=4.0))
 
         self.decoder_norm = nn.LayerNorm(decoder_embed_dim, eps=1e-6)
-        self.pred = nn.Linear(decoder_embed_dim, self.patch_size**2 * self.input_channels, bias=True)
+        self.pred = nn.Linear(decoder_embed_dim, self.patch_size**2 * self.input_channels)
 
         # Weight initialization
         for m in self.modules():
@@ -170,7 +170,7 @@ class CrossMAE(MIMBaseNet):
         return imgs
 
     def fill_pred(self, mask: torch.Tensor, pred: torch.Tensor) -> torch.Tensor:
-        (N, L) = mask.shape[0:2]
+        N, L = mask.shape[0:2]
         combined = torch.zeros(N, L, pred.shape[2], device=pred.device, dtype=pred.dtype)
         combined[mask.bool()] = pred.view(-1, pred.shape[2])
 
@@ -213,7 +213,7 @@ class CrossMAE(MIMBaseNet):
     def forward(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
         h = self.size[0] // self.encoder.stem_stride
         w = self.size[1] // self.encoder.stem_stride
-        (mask, ids_keep, _) = uniform_mask(
+        mask, ids_keep, _ = uniform_mask(
             x.size(0), h, w, self.mask_ratio, self.kept_mask_ratio, min_mask_size=self.min_mask_size, device=x.device
         )
 

birder/net/mim/fcmae.py

@@ -48,7 +48,6 @@ class FCMAE(MIMBaseNet):
             kernel_size=(1, 1),
             stride=(1, 1),
             padding=(0, 0),
-            bias=True,
         )
 
         self.mask_token = nn.Parameter(torch.zeros(1, self.decoder_embed_dim, 1, 1))
@@ -65,7 +64,6 @@ class FCMAE(MIMBaseNet):
             kernel_size=(1, 1),
             stride=(1, 1),
             padding=(0, 0),
-            bias=True,
         )
 
         # Weights initialization
@@ -106,7 +104,7 @@ class FCMAE(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)
 
@@ -125,7 +123,7 @@ class FCMAE(MIMBaseNet):
         x = self.proj(x)
 
         # Append mask token
-        (B, _, H, W) = x.shape
+        B, _, H, W = x.shape
         mask = mask.reshape(-1, H, W).unsqueeze(1).type_as(x)
         mask_token = self.mask_token.repeat(B, 1, H, W)
         x = x * (1.0 - mask) + (mask_token * mask)
@@ -141,7 +139,7 @@ class FCMAE(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/mim/mae_hiera.py

@@ -26,7 +26,7 @@ def apply_fusion_head(head: nn.Module, x: torch.Tensor) -> torch.Tensor:
     if isinstance(head, nn.Identity):
         return x
 
-    (B, num_mask_units) = x.shape[0:2]
+    B, num_mask_units = x.shape[0:2]
 
     # Apply head, e.g [B, #MUs, My, Mx, C] -> head([B * #MUs, C, My, Mx])
     permute = [0] + [len(x.shape) - 2] + list(range(1, len(x.shape) - 2))
@@ -169,7 +169,7 @@ class MAE_Hiera(MIMBaseNet):
 
     def forward_encoder(self, x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         # Tokens selected for masking at mask unit level
-        (mask, _, _) = uniform_mask(
+        mask, _, _ = uniform_mask(
             x.size(0),
             self.encoder.mask_spatial_shape[0],
             self.encoder.mask_spatial_shape[1],
@@ -179,7 +179,7 @@ class MAE_Hiera(MIMBaseNet):
         )
 
         # Get multi-scale representations from encoder
-        (intermediates, mask) = self.encoder.masked_encoding(x, mask)
+        intermediates, mask = self.encoder.masked_encoding(x, mask)
 
         # Resolution unchanged after q_pool stages, so skip those features
         intermediates = intermediates[: self.encoder.q_pool] + intermediates[-1:]
@@ -206,12 +206,12 @@ class MAE_Hiera(MIMBaseNet):
         # Get back spatial order
         x = undo_windowing(
             x_dec,
-            self.tokens_spatial_shape_final,  # type:ignore[arg-type]
+            self.tokens_spatial_shape_final,  # type: ignore[arg-type]
             self.mask_unit_spatial_shape_final,
         )
         mask = undo_windowing(
             mask[..., 0:1],
-            self.tokens_spatial_shape_final,  # type:ignore[arg-type]
+            self.tokens_spatial_shape_final,  # type: ignore[arg-type]
             self.mask_unit_spatial_shape_final,
         )
 
@@ -240,8 +240,8 @@ class MAE_Hiera(MIMBaseNet):
         return loss.mean()
 
     def forward(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
-        (latent, mask) = self.forward_encoder(x)
-        (pred, pred_mask) = self.forward_decoder(latent, mask)
+        latent, mask = self.forward_encoder(x)
+        pred, pred_mask = self.forward_decoder(latent, mask)
         loss = self.forward_loss(x, pred, ~pred_mask)
 
         return {"loss": loss, "pred": pred, "mask": mask}

birder/net/mim/mae_vit.py

@@ -52,7 +52,7 @@ class MAE_ViT(MIMBaseNet):
 
         self.norm_pix_loss = norm_pix_loss
 
-        self.decoder_embed = nn.Linear(encoder_dim, decoder_embed_dim, bias=True)
+        self.decoder_embed = nn.Linear(encoder_dim, decoder_embed_dim)
         self.mask_token = nn.Parameter(torch.zeros(1, 1, decoder_embed_dim))
 
         if learnable_pos_embed is True:
@@ -74,9 +74,7 @@ class MAE_ViT(MIMBaseNet):
             layers.append(self.encoder.decoder_block(decoder_embed_dim))
 
         layers.append(nn.LayerNorm(decoder_embed_dim, eps=1e-6))
-        layers.append(
-            nn.Linear(decoder_embed_dim, self.patch_size**2 * self.input_channels, bias=True)
-        )  # Decoder to patch
+        layers.append(nn.Linear(decoder_embed_dim, self.patch_size**2 * self.input_channels))  # Decoder to patch
         self.decoder = nn.Sequential(*layers)
 
     def patchify(self, imgs: torch.Tensor) -> torch.Tensor:
@@ -153,7 +151,7 @@ class MAE_ViT(MIMBaseNet):
     def forward(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
         h = self.size[0] // self.encoder.max_stride
         w = self.size[1] // self.encoder.max_stride
-        (mask, ids_keep, ids_restore) = uniform_mask(
+        mask, ids_keep, ids_restore = uniform_mask(
             x.size(0), h, w, self.mask_ratio, min_mask_size=self.min_mask_size, device=x.device
         )