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

birder/net/convnext_v2.py

@@ -56,15 +56,7 @@ class ConvNeXtBlock(nn.Module):
     ) -> None:
         super().__init__()
         self.block = nn.Sequential(
-            nn.Conv2d(
-                channels,
-                channels,
-                kernel_size=(7, 7),
-                stride=(1, 1),
-                padding=(3, 3),
-                groups=channels,
-                bias=True,
-            ),
+            nn.Conv2d(channels, channels, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=channels),
             Permute([0, 2, 3, 1]),
             nn.LayerNorm(channels, eps=1e-6),
             nn.Linear(channels, 4 * channels),  # Same as 1x1 conv
@@ -137,7 +129,7 @@ class ConvNeXt_v2(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
                 layers.append(
                     nn.Sequential(
                         LayerNorm2d(i, eps=1e-6),
-                        nn.Conv2d(i, out, kernel_size=(2, 2), stride=(2, 2), padding=(0, 0), bias=True),
+                        nn.Conv2d(i, out, kernel_size=(2, 2), stride=(2, 2), padding=(0, 0)),
                     )
                 )
 

birder/net/crossformer.py

@@ -120,9 +120,9 @@ class Attention(nn.Module):
         self.relative_position_index = nn.Buffer(relative_position_index)
 
     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)
 
         q = q * self.scale
         attn = q @ k.transpose(-2, -1)
@@ -188,15 +188,15 @@ class CrossFormerBlock(nn.Module):
         self.drop_path = StochasticDepth(drop_path, mode="row")
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (H, W) = self.input_resolution
-        (B, _, C) = x.size()
+        H, W = self.input_resolution
+        B, _, C = x.size()
 
         shortcut = x
         x = self.norm1(x)
         x = x.view(B, H, W, C)
 
         # Group embeddings
-        (GH, GW) = self.group_size  # pylint: disable=invalid-name
+        GH, GW = self.group_size  # pylint: disable=invalid-name
         if self.use_lda is False:
             x = x.reshape(B, H // GH, GH, W // GW, GW, C).permute(0, 1, 3, 2, 4, 5)
         else:
@@ -244,8 +244,8 @@ class PatchMerging(nn.Module):
             )
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (H, W) = self.input_resolution
-        (B, _, C) = x.shape
+        H, W = self.input_resolution
+        B, _, C = x.shape
 
         x = self.norm(x)
         x = x.view(B, H, W, C).permute(0, 3, 1, 2)
@@ -396,8 +396,8 @@ class CrossFormer(DetectorBackbone):
         for name, module in self.body.named_children():
             x = module(x)
             if name in self.return_stages:
-                (H, W) = module.resolution
-                (B, _, C) = x.size()
+                H, W = module.resolution
+                B, _, C = x.size()
                 out[name] = x.view(B, H, W, C).permute(0, 3, 1, 2).contiguous()
 
         return out

birder/net/crossvit.py

@@ -74,7 +74,7 @@ class CrossAttention(nn.Module):
         self.proj_drop = nn.Dropout(proj_drop)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, N, C) = x.shape
+        B, N, C = x.shape
         # B1C -> B1H(C/H) -> BH1(C/H)
         q = self.wq(x[:, 0:1, ...]).reshape(B, 1, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
         # BNC -> BNH(C/H) -> BHN(C/H)

birder/net/cspnet.py

@@ -226,7 +226,7 @@ class CrossStage(nn.Module):
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         x = self.conv_down(x)
         x = self.conv_exp(x)
-        (xs, xb) = x.split(self.expand_channels // 2, dim=1)
+        xs, xb = x.split(self.expand_channels // 2, dim=1)
         xb = self.blocks(xb)
         xb = self.conv_transition_b(xb).contiguous()
         out = self.conv_transition(torch.concat([xs, xb], dim=1))

birder/net/cswin_transformer.py

@@ -29,7 +29,7 @@ from birder.net.vit import PatchEmbed
 
 
 def img2windows(img: torch.Tensor, h_sp: int, w_sp: int) -> torch.Tensor:
-    (B, C, H, W) = img.size()
+    B, C, H, W = img.size()
     img_reshape = img.view(B, C, H // h_sp, h_sp, W // w_sp, w_sp)
     img_perm = img_reshape.permute(0, 2, 4, 3, 5, 1).contiguous().reshape(-1, h_sp * w_sp, C)
 
@@ -81,7 +81,7 @@ class LePEAttention(nn.Module):
             raise ValueError("unsupported idx")
 
     def im2cswin(self, x: torch.Tensor) -> torch.Tensor:
-        (B, _, C) = x.size()
+        B, _, C = x.size()
         x = x.transpose(-2, -1).contiguous().view(B, C, self.resolution[0], self.resolution[1])
         x = img2windows(x, self.h_sp, self.w_sp)
         x = x.reshape(-1, self.h_sp * self.w_sp, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3).contiguous()
@@ -89,7 +89,7 @@ class LePEAttention(nn.Module):
         return x
 
     def get_lepe(self, x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        (B, _, C) = x.size()
+        B, _, C = x.size()
         H = self.resolution[0]
         W = self.resolution[1]
         x = x.transpose(-2, -1).contiguous().view(B, C, H, W)
@@ -107,13 +107,13 @@ class LePEAttention(nn.Module):
         return (x, lepe)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (q, k, v) = x.unbind(0)
+        q, k, v = x.unbind(0)
 
-        (B, _, C) = q.shape
+        B, _, C = q.shape
 
         q = self.im2cswin(q)
         k = self.im2cswin(k)
-        (v, lepe) = self.get_lepe(v)
+        v, lepe = self.get_lepe(v)
 
         q = q * self.scale
         attn = q @ k.transpose(-2, -1)  # B head N C @ B head C N --> B head N N
@@ -136,12 +136,12 @@ class MergeBlock(nn.Module):
         self.resolution = resolution
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, _, C) = x.size()
+        B, _, C = x.size()
         H = self.resolution[0]
         W = self.resolution[1]
         x = x.transpose(-2, -1).contiguous().view(B, C, H, W)
         x = self.conv(x)
-        (B, C) = x.shape[:2]
+        B, C = x.shape[:2]
         x = x.view(B, C, -1).transpose(-2, -1).contiguous()
         x = self.norm(x)
 
@@ -206,7 +206,7 @@ class CSWinBlock(nn.Module):
         self.drop_path = StochasticDepth(drop_path, mode="row")
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, _, C) = x.shape
+        B, _, C = x.shape
 
         qkv = self.qkv(self.norm1(x)).reshape(B, -1, 3, C).permute(2, 0, 1, 3)
         if self.branch_num == 2:
@@ -350,7 +350,7 @@ class CSWin_Transformer(DetectorBackbone):
         for name, module in self.body.named_children():
             x = module(x)
             if name in self.return_stages:
-                (B, L, C) = x.size()
+                B, L, C = x.size()
                 H = int(math.sqrt(L))
                 W = H
                 out[name] = x.transpose(-2, -1).contiguous().view(B, C, H, W)

birder/net/davit.py

@@ -31,7 +31,7 @@ from birder.net.base import TokenRetentionResultType
 
 
 def window_partition(x: torch.Tensor, window_size: tuple[int, int]) -> torch.Tensor:
-    (B, H, W, C) = x.shape
+    B, H, W, C = x.shape
     x = x.view(B, H // window_size[0], window_size[0], W // window_size[1], window_size[1], C)
     windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size[0], window_size[1], C)
 
@@ -92,10 +92,10 @@ class Downsample(nn.Module):
         )
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (_, _, H, W) = x.shape
+        _, _, H, W = x.shape
         x = self.norm(x)
         if self.even_k is True:
-            (k_h, k_w) = self.conv.kernel_size
+            k_h, k_w = self.conv.kernel_size
             pad_r = (k_w - W % k_w) % k_w
             pad_b = (k_h - H % k_h) % k_h
             x = F.pad(x, (0, pad_r, 0, pad_b))
@@ -115,10 +115,10 @@ class ChannelAttention(nn.Module):
         self.proj = nn.Linear(dim, dim)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, N, C) = x.shape
+        B, N, C = x.shape
 
         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)
 
         k = k * self.scale
         attn = k.transpose(-1, -2) @ v
@@ -151,7 +151,7 @@ class ChannelBlock(nn.Module):
         self.drop_path = StochasticDepth(drop_path, mode="row")
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, C, H, W) = x.shape
+        B, C, H, W = x.shape
         x = self.cpe1(x).flatten(2).transpose(1, 2)
 
         cur = self.norm1(x)
@@ -177,10 +177,10 @@ class WindowAttention(nn.Module):
         self.proj = nn.Linear(dim, dim)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, N, C) = x.shape
+        B, N, C = x.shape
 
         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(q, k, v, scale=self.scale)  # pylint: disable=not-callable
         x = x.transpose(1, 2).reshape(B, N, C)
@@ -215,7 +215,7 @@ class SpatialBlock(nn.Module):
 
     # pylint: disable=invalid-name
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        (B, C, H, W) = x.shape
+        B, C, H, W = x.shape
 
         shortcut = self.cpe1(x).flatten(2).transpose(1, 2)
 
@@ -226,7 +226,7 @@ class SpatialBlock(nn.Module):
         pad_r = (self.window_size[1] - W % self.window_size[1]) % self.window_size[1]
         pad_b = (self.window_size[0] - H % self.window_size[0]) % self.window_size[0]
         x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
-        (_, Hp, Wp, _) = x.shape
+        _, Hp, Wp, _ = x.shape
 
         x_windows = window_partition(x, self.window_size)
         x_windows = x_windows.view(-1, self.window_size[0] * self.window_size[1], C)

birder/net/deit.py

@@ -19,13 +19,15 @@ from birder.model_registry import registry
 from birder.net._vit_configs import BASE
 from birder.net._vit_configs import SMALL
 from birder.net._vit_configs import TINY
-from birder.net.base import BaseNet
+from birder.net.base import DetectorBackbone
+from birder.net.base import normalize_out_indices
 from birder.net.vit import Encoder
 from birder.net.vit import PatchEmbed
 from birder.net.vit import adjust_position_embedding
 
 
-class DeiT(BaseNet):
+# pylint: disable=too-many-instance-attributes
+class DeiT(DetectorBackbone):
     block_group_regex = r"encoder\.block\.(\d+)"
 
     def __init__(
@@ -47,6 +49,7 @@ class DeiT(BaseNet):
         num_heads: int = self.config["num_heads"]
         hidden_dim: int = self.config["hidden_dim"]
         mlp_dim: int = self.config["mlp_dim"]
+        out_indices: Optional[list[int]] = self.config.get("out_indices", None)
         drop_path_rate: float = self.config["drop_path_rate"]
 
         torch._assert(image_size[0] % patch_size == 0, "Input shape indivisible by patch size!")
@@ -56,6 +59,7 @@ class DeiT(BaseNet):
         self.num_layers = num_layers
         self.hidden_dim = hidden_dim
         self.num_special_tokens = 2
+        self.out_indices = normalize_out_indices(out_indices, num_layers)
         dpr = [x.item() for x in torch.linspace(0, drop_path_rate, num_layers)]  # Stochastic depth decay rule
 
         self.conv_proj = nn.Conv2d(
@@ -64,7 +68,6 @@ class DeiT(BaseNet):
             kernel_size=(patch_size, patch_size),
             stride=(patch_size, patch_size),
             padding=(0, 0),
-            bias=True,
         )
         self.patch_embed = PatchEmbed()
 
@@ -92,6 +95,9 @@ class DeiT(BaseNet):
         )
         self.norm = nn.LayerNorm(hidden_dim, eps=1e-6)
 
+        num_return_stages = len(self.out_indices) if self.out_indices is not None else 1
+        self.return_stages = [f"stage{stage_idx + 1}" for stage_idx in range(num_return_stages)]
+        self.return_channels = [hidden_dim] * num_return_stages
         self.embedding_size = hidden_dim
         self.dist_classifier = self.create_classifier()
         self.classifier = self.create_classifier()
@@ -136,6 +142,53 @@ class DeiT(BaseNet):
     def set_causal_attention(self, is_causal: bool = True) -> None:
         self.encoder.set_causal_attention(is_causal)
 
+    def transform_to_backbone(self) -> None:
+        super().transform_to_backbone()
+        self.norm = nn.Identity()
+        self.dist_classifier = nn.Identity()
+
+    def detection_features(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
+        H, W = x.shape[-2:]
+
+        # Reshape and permute the input tensor
+        x = self.conv_proj(x)
+        x = self.patch_embed(x)
+
+        # Expand the class token to the full batch
+        batch_class_token = self.class_token.expand(x.shape[0], -1, -1)
+        batch_dist_token = self.dist_token.expand(x.shape[0], -1, -1)
+
+        x = torch.concat([batch_class_token, batch_dist_token, x], dim=1)
+        x = x + self.pos_embedding
+
+        if self.out_indices is None:
+            xs = [self.encoder(x)]
+        else:
+            xs = self.encoder.forward_features(x, out_indices=self.out_indices)
+
+        out: dict[str, torch.Tensor] = {}
+        for stage_name, stage_x in zip(self.return_stages, xs):
+            stage_x = stage_x[:, self.num_special_tokens :]
+            stage_x = stage_x.permute(0, 2, 1)
+            B, C, _ = stage_x.size()
+            stage_x = stage_x.reshape(B, C, H // self.patch_size, W // self.patch_size)
+            out[stage_name] = stage_x
+
+        return out
+
+    def freeze_stages(self, up_to_stage: int) -> None:
+        for param in self.conv_proj.parameters():
+            param.requires_grad_(False)
+
+        self.pos_embedding.requires_grad_(False)
+
+        for idx, module in enumerate(self.encoder.children()):
+            if idx >= up_to_stage:
+                break
+
+            for param in module.parameters():
+                param.requires_grad_(False)
+
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         # Reshape and permute the input tensor
         x = self.conv_proj(x)

birder/net/deit3.py

@@ -27,6 +27,7 @@ from birder.net.base import MaskedTokenRetentionMixin
 from birder.net.base import PreTrainEncoder
 from birder.net.base import TokenOmissionResultType
 from birder.net.base import TokenRetentionResultType
+from birder.net.base import normalize_out_indices
 from birder.net.vit import Encoder
 from birder.net.vit import EncoderBlock
 from birder.net.vit import PatchEmbed
@@ -59,6 +60,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         mlp_dim: int = self.config["mlp_dim"]
         layer_scale_init_value: Optional[float] = self.config.get("layer_scale_init_value", 1e-5)
         num_reg_tokens: int = self.config.get("num_reg_tokens", 0)
+        out_indices: Optional[list[int]] = self.config.get("out_indices", None)
         drop_path_rate: float = self.config["drop_path_rate"]
 
         torch._assert(image_size[0] % patch_size == 0, "Input shape indivisible by patch size!")
@@ -70,6 +72,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         self.num_reg_tokens = num_reg_tokens
         self.num_special_tokens = 1 + self.num_reg_tokens
         self.pos_embed_special_tokens = pos_embed_special_tokens
+        self.out_indices = normalize_out_indices(out_indices, num_layers)
         dpr = [x.item() for x in torch.linspace(0, drop_path_rate, num_layers)]  # Stochastic depth decay rule
 
         self.conv_proj = nn.Conv2d(
@@ -78,7 +81,6 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
             kernel_size=(patch_size, patch_size),
             stride=(patch_size, patch_size),
             padding=(0, 0),
-            bias=True,
         )
         self.patch_embed = PatchEmbed()
 
@@ -112,8 +114,9 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         )
         self.norm = nn.LayerNorm(hidden_dim, eps=1e-6)
 
-        self.return_stages = ["neck"]  # Actually meaningless, just for completeness
-        self.return_channels = [hidden_dim]
+        num_return_stages = len(self.out_indices) if self.out_indices is not None else 1
+        self.return_stages = [f"stage{stage_idx + 1}" for stage_idx in range(num_return_stages)]
+        self.return_channels = [hidden_dim] * num_return_stages
         self.embedding_size = hidden_dim
         self.classifier = self.create_classifier()
 
@@ -159,7 +162,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         )
 
     def detection_features(self, x: torch.Tensor) -> dict[str, torch.Tensor]:
-        (H, W) = x.shape[-2:]
+        H, W = x.shape[-2:]
 
         x = self.conv_proj(x)
         x = self.patch_embed(x)
@@ -176,15 +179,20 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
             x = x + self._get_pos_embed(H, W)
             x = torch.concat([batch_special_tokens, x], dim=1)
 
-        x = self.encoder(x)
-        x = self.norm(x)
+        if self.out_indices is None:
+            xs = [self.encoder(x)]
+        else:
+            xs = self.encoder.forward_features(x, out_indices=self.out_indices)
 
-        x = x[:, self.num_special_tokens :]
-        x = x.permute(0, 2, 1)
-        (B, C, _) = x.size()
-        x = x.reshape(B, C, H // self.patch_size, W // self.patch_size)
+        out: dict[str, torch.Tensor] = {}
+        for stage_name, stage_x in zip(self.return_stages, xs):
+            stage_x = stage_x[:, self.num_special_tokens :]
+            stage_x = stage_x.permute(0, 2, 1)
+            B, C, _ = stage_x.size()
+            stage_x = stage_x.reshape(B, C, H // self.patch_size, W // self.patch_size)
+            out[stage_name] = stage_x
 
-        return {self.return_stages[0]: x}
+        return out
 
     def freeze_stages(self, up_to_stage: int) -> None:
         for param in self.conv_proj.parameters():
@@ -199,6 +207,10 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
             for param in module.parameters():
                 param.requires_grad_(False)
 
+    def transform_to_backbone(self) -> None:
+        super().transform_to_backbone()
+        self.norm = nn.Identity()
+
     def set_causal_attention(self, is_causal: bool = True) -> None:
         self.encoder.set_causal_attention(is_causal)
 
@@ -209,7 +221,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         return_all_features: bool = False,
         return_keys: Literal["all", "tokens", "embedding"] = "tokens",
     ) -> TokenOmissionResultType:
-        (H, W) = x.shape[-2:]
+        H, W = x.shape[-2:]
 
         # Reshape and permute the input tensor
         x = self.conv_proj(x)
@@ -272,7 +284,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         mask_token: Optional[torch.Tensor] = None,
         return_keys: Literal["all", "features", "embedding"] = "features",
     ) -> TokenRetentionResultType:
-        (H, W) = x.shape[-2:]
+        H, W = x.shape[-2:]
 
         x = self.conv_proj(x)
         x = mask_tensor(x, mask, mask_token=mask_token, patch_factor=self.max_stride // self.stem_stride)
@@ -302,7 +314,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         if return_keys in ("all", "features"):
             features = x[:, self.num_special_tokens :]
             features = features.permute(0, 2, 1)
-            (B, C, _) = features.size()
+            B, C, _ = features.size()
             features = features.reshape(B, C, H // self.patch_size, W // self.patch_size)
             result["features"] = features
 
@@ -312,7 +324,7 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
         return result
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
-        (H, W) = x.shape[-2:]
+        H, W = x.shape[-2:]
 
         # Reshape and permute the input tensor
         x = self.conv_proj(x)

birder/net/detection/__init__.py

@@ -3,8 +3,10 @@ from birder.net.detection.detr import DETR
 from birder.net.detection.efficientdet import EfficientDet
 from birder.net.detection.faster_rcnn import Faster_RCNN
 from birder.net.detection.fcos import FCOS
+from birder.net.detection.plain_detr import Plain_DETR
 from birder.net.detection.retinanet import RetinaNet
 from birder.net.detection.rt_detr_v1 import RT_DETR_v1
+from birder.net.detection.rt_detr_v2 import RT_DETR_v2
 from birder.net.detection.ssd import SSD
 from birder.net.detection.ssdlite import SSDLite
 from birder.net.detection.vitdet import ViTDet
@@ -19,8 +21,10 @@ __all__ = [
     "EfficientDet",
     "Faster_RCNN",
     "FCOS",
+    "Plain_DETR",
     "RetinaNet",
     "RT_DETR_v1",
+    "RT_DETR_v2",
     "SSD",
     "SSDLite",
     "ViTDet",

birder/net/detection/{yolo_anchors.py → _yolo_anchors.py}

@@ -71,7 +71,7 @@ def scale_anchors(anchors: AnchorGroups, from_size: tuple[int, int], to_size: tu
 
 
 def scale_anchors(anchors: AnchorLike, from_size: tuple[int, int], to_size: tuple[int, int]) -> AnchorLike:
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
 
     if from_size == to_size:
         # Avoid aliasing default anchors in case they are mutated later
@@ -100,7 +100,7 @@ def pixels_to_grid(anchors: AnchorGroups, strides: Sequence[int]) -> AnchorGroup
 
 
 def pixels_to_grid(anchors: AnchorLike, strides: Sequence[int]) -> AnchorLike:
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
     if len(anchor_groups) != len(strides):
         raise ValueError("strides must provide one value per anchor scale")
 
@@ -123,7 +123,7 @@ def grid_to_pixels(anchors: AnchorGroups, strides: Sequence[int]) -> AnchorGroup
 
 
 def grid_to_pixels(anchors: AnchorLike, strides: Sequence[int]) -> AnchorLike:
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
     if len(anchor_groups) != len(strides):
         raise ValueError("strides must provide one value per anchor scale")
 
@@ -187,7 +187,7 @@ def resolve_anchor_group(
     preset: str, *, anchor_format: str, model_size: tuple[int, int], model_strides: Sequence[int]
 ) -> AnchorGroup:
     anchors = _resolve_anchors(preset, anchor_format=anchor_format, model_size=model_size, model_strides=model_strides)
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
     if single is False:
         raise ValueError("Expected a single anchor group for this model")
 
@@ -198,7 +198,7 @@ def resolve_anchor_groups(
     preset: str, *, anchor_format: str, model_size: tuple[int, int], model_strides: Sequence[int]
 ) -> AnchorGroups:
     anchors = _resolve_anchors(preset, anchor_format=anchor_format, model_size=model_size, model_strides=model_strides)
-    (anchor_groups, single) = _normalize_anchor_groups(anchors)
+    anchor_groups, single = _normalize_anchor_groups(anchors)
     if single is True:
         raise ValueError("Expected multiple anchor groups for this model")
 

birder/net/detection/base.py

@@ -41,6 +41,7 @@ def get_detection_signature(input_shape: tuple[int, ...], num_outputs: int, dyna
 
 class DetectionBaseNet(nn.Module):
     default_size: tuple[int, int]
+    block_group_regex: Optional[str]
     auto_register = False
     scriptable = True
     task = str(Task.OBJECT_DETECTION)
@@ -308,7 +309,7 @@ class SimpleFeaturePyramidNetwork(nn.Module):
             names.append(f"stage{idx+1}")
 
         if self.extra_blocks is not None:
-            (results, names) = self.extra_blocks(results, [x], names)
+            results, names = self.extra_blocks(results, [x], names)
 
         out = OrderedDict(list(zip(names, results)))
 
@@ -432,7 +433,7 @@ class BoxCoder:
         ctr_x = boxes[:, 0] + 0.5 * widths
         ctr_y = boxes[:, 1] + 0.5 * heights
 
-        (wx, wy, ww, wh) = self.weights
+        wx, wy, ww, wh = self.weights
         dx = rel_codes[:, 0::4] / wx
         dy = rel_codes[:, 1::4] / wy
         dw = rel_codes[:, 2::4] / ww
@@ -510,8 +511,8 @@ class AnchorGenerator(nn.Module):
         )
 
         for size, stride, base_anchors in zip(grid_sizes, strides, cell_anchors):
-            (grid_height, grid_width) = size
-            (stride_height, stride_width) = stride
+            grid_height, grid_width = size
+            stride_height, stride_width = stride
             device = base_anchors.device
 
             # For output anchor, compute [x_center, y_center, x_center, y_center]
@@ -656,7 +657,7 @@ class Matcher(nn.Module):
         #  tensor([39796, 32055, 32070, 39190, 40255, 40390, 41455, 45470, 45325, 46390]))
         # Each element in the first tensor is a gt index,
         # and each element in second tensor is a prediction index
-        # Note how gt items 1, 2, 3, and 5 each have two ties
+        # Note how gt items 1, 2, 3 and 5 each have two ties
 
         pred_idx_to_update = gt_pred_pairs_of_highest_quality[1]
         matches[pred_idx_to_update] = all_matches[pred_idx_to_update]