birder 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

birder/net/detection/yolo_v4_tiny.py

@@ -15,18 +15,13 @@ import torch
 from torch import nn
 from torchvision.ops import Conv2dNormActivation
 
+from birder.model_registry import registry
 from birder.net.base import DetectorBackbone
+from birder.net.detection.yolo_anchors import resolve_anchor_groups
 from birder.net.detection.yolo_v3 import YOLOAnchorGenerator
 from birder.net.detection.yolo_v3 import YOLOHead
-from birder.net.detection.yolo_v3 import scale_anchors
 from birder.net.detection.yolo_v4 import YOLO_v4
 
-# Default anchors from YOLO v4 Tiny (COCO)
-DEFAULT_ANCHORS = [
-    [(10.0, 14.0), (23.0, 27.0), (37.0, 58.0)],  # Medium
-    [(81.0, 82.0), (135.0, 169.0), (344.0, 319.0)],  # Large
-]
-
 # Scale factors per detection scale to eliminate grid sensitivity
 DEFAULT_SCALE_XY = [1.05, 1.05]  # [medium, large]
 
@@ -92,7 +87,6 @@ class YOLOTinyNeck(nn.Module):
 # pylint: disable=invalid-name
 class YOLO_v4_Tiny(YOLO_v4):
     default_size = (416, 416)
-    auto_register = True
 
     def __init__(
         self,
@@ -104,22 +98,26 @@ class YOLO_v4_Tiny(YOLO_v4):
         export_mode: bool = False,
     ) -> None:
         super().__init__(num_classes, backbone, config=config, size=size, export_mode=export_mode)
-        assert self.config is None, "config not supported"
+        assert self.config is not None, "must set config"
 
         # self.num_classes = self.num_classes - 1 (Subtracted at parent)
 
         score_thresh = 0.05
         nms_thresh = 0.45
         detections_per_img = 300
-        self.ignore_thresh = 0.7
-
-        # Loss coefficients
-        self.noobj_coeff = 0.25
-        self.coord_coeff = 3.0
-        self.obj_coeff = 1.0
-        self.cls_coeff = 1.0
-
-        self.anchors = scale_anchors(DEFAULT_ANCHORS, self.default_size, self.size)
+        ignore_thresh = 0.7
+        noobj_coeff = 0.25
+        coord_coeff = 3.0
+        obj_coeff = 1.0
+        cls_coeff = 1.0
+        label_smoothing = 0.1
+        anchor_spec = self.config["anchors"]
+
+        self.ignore_thresh = ignore_thresh
+        self.noobj_coeff = noobj_coeff
+        self.coord_coeff = coord_coeff
+        self.obj_coeff = obj_coeff
+        self.cls_coeff = cls_coeff
         self.scale_xy = DEFAULT_SCALE_XY
         self.score_thresh = score_thresh
         self.nms_thresh = nms_thresh
@@ -128,12 +126,18 @@ class YOLO_v4_Tiny(YOLO_v4):
         self.backbone.return_channels = self.backbone.return_channels[-2:]
         self.backbone.return_stages = self.backbone.return_stages[-2:]
 
-        self.label_smoothing = 0.1
+        self.label_smoothing = label_smoothing
         self.smooth_positive = 1.0 - self.label_smoothing
         self.smooth_negative = self.label_smoothing / self.num_classes
 
         self.neck = YOLOTinyNeck(self.backbone.return_channels)
 
-        self.anchor_generator = YOLOAnchorGenerator(self.anchors)
+        anchors = resolve_anchor_groups(
+            anchor_spec, anchor_format="pixels", model_size=self.size, model_strides=(16, 32)
+        )
+        self.anchor_generator = YOLOAnchorGenerator(anchors)
         num_anchors = self.anchor_generator.num_anchors_per_location()
         self.head = YOLOHead(self.neck.out_channels, num_anchors, self.num_classes)
+
+
+registry.register_model_config("yolo_v4_tiny", YOLO_v4_Tiny, config={"anchors": "yolo_v4_tiny"})

birder/net/efficientformer_v1.py

@@ -357,16 +357,22 @@ class EfficientFormer_v1(BaseNet):
         resolution = (int(new_size[0] / (2**5)), int(new_size[1] / (2**5)))
         for m in self.body.modules():
             if isinstance(m, Attention):
-                m.attention_biases = nn.Parameter(
-                    interpolate_attention_bias(m.attention_biases, old_resolution, resolution)
-                )
+                with torch.no_grad():
+                    m.attention_biases = nn.Parameter(
+                        interpolate_attention_bias(m.attention_biases, old_resolution, resolution)
+                    )
 
-                pos = torch.stack(
-                    torch.meshgrid(torch.arange(resolution[0]), torch.arange(resolution[1]), indexing="ij")
-                ).flatten(1)
-                rel_pos = (pos[..., :, None] - pos[..., None, :]).abs()
-                rel_pos = (rel_pos[0] * resolution[1]) + rel_pos[1]
-                m.attention_bias_idxs = nn.Buffer(rel_pos)
+                    device = m.attention_biases.device
+                    pos = torch.stack(
+                        torch.meshgrid(
+                            torch.arange(resolution[0], device=device),
+                            torch.arange(resolution[1], device=device),
+                            indexing="ij",
+                        )
+                    ).flatten(1)
+                    rel_pos = (pos[..., :, None] - pos[..., None, :]).abs()
+                    rel_pos = (rel_pos[0] * resolution[1]) + rel_pos[1]
+                    m.attention_bias_idxs = nn.Buffer(rel_pos)
 
 
 registry.register_model_config(

birder/net/efficientformer_v2.py

@@ -554,26 +554,30 @@ class EfficientFormer_v2(DetectorBackbone):
                         attn.N = attn.resolution[0] * attn.resolution[1]
                         attn.N2 = attn.resolution2[0] * attn.resolution2[1]
 
-                        # Interpolate attention_biases
-                        attn.attention_biases = nn.Parameter(
-                            interpolate_attention_bias(attn.attention_biases, old_base, new_base)
-                        )
-
-                        k_pos = torch.stack(
-                            torch.meshgrid(
-                                torch.arange(attn.resolution[0]), torch.arange(attn.resolution[1]), indexing="ij"
+                        with torch.no_grad():
+                            # Interpolate attention_biases
+                            attn.attention_biases = nn.Parameter(
+                                interpolate_attention_bias(attn.attention_biases, old_base, new_base)
                             )
-                        ).flatten(1)
-                        q_pos = torch.stack(
-                            torch.meshgrid(
-                                torch.arange(0, attn.resolution[0], step=2),
-                                torch.arange(0, attn.resolution[1], step=2),
-                                indexing="ij",
-                            )
-                        ).flatten(1)
-                        rel_pos = (q_pos[..., :, None] - k_pos[..., None, :]).abs()
-                        rel_pos = (rel_pos[0] * attn.resolution[1]) + rel_pos[1]
-                        attn.attention_bias_idxs = nn.Buffer(torch.LongTensor(rel_pos), persistent=False)
+
+                            device = attn.attention_biases.device
+                            k_pos = torch.stack(
+                                torch.meshgrid(
+                                    torch.arange(attn.resolution[0], device=device),
+                                    torch.arange(attn.resolution[1], device=device),
+                                    indexing="ij",
+                                )
+                            ).flatten(1)
+                            q_pos = torch.stack(
+                                torch.meshgrid(
+                                    torch.arange(0, attn.resolution[0], step=2, device=device),
+                                    torch.arange(0, attn.resolution[1], step=2, device=device),
+                                    indexing="ij",
+                                )
+                            ).flatten(1)
+                            rel_pos = (q_pos[..., :, None] - k_pos[..., None, :]).abs()
+                            rel_pos = (rel_pos[0] * attn.resolution[1]) + rel_pos[1]
+                            attn.attention_bias_idxs = nn.Buffer(rel_pos.to(torch.long), persistent=False)
 
                     old_base = (old_base[0] // 2, old_base[1] // 2)
                     new_base = (new_base[0] // 2, new_base[1] // 2)
@@ -590,16 +594,22 @@ class EfficientFormer_v2(DetectorBackbone):
                             m.token_mixer.resolution = c_new_base
                             m.token_mixer.N = m.token_mixer.resolution[0] * m.token_mixer.resolution[1]
 
-                            m.token_mixer.attention_biases = nn.Parameter(
-                                interpolate_attention_bias(m.token_mixer.attention_biases, c_old_base, c_new_base)
-                            )
-
-                            pos = torch.stack(
-                                torch.meshgrid(torch.arange(c_new_base[0]), torch.arange(c_new_base[1]), indexing="ij")
-                            ).flatten(1)
-                            rel_pos = (pos[..., :, None] - pos[..., None, :]).abs()
-                            rel_pos = (rel_pos[0] * c_new_base[1]) + rel_pos[1]
-                            m.token_mixer.attention_bias_idxs = nn.Buffer(torch.LongTensor(rel_pos), persistent=False)
+                            with torch.no_grad():
+                                m.token_mixer.attention_biases = nn.Parameter(
+                                    interpolate_attention_bias(m.token_mixer.attention_biases, c_old_base, c_new_base)
+                                )
+
+                                device = m.token_mixer.attention_biases.device
+                                pos = torch.stack(
+                                    torch.meshgrid(
+                                        torch.arange(c_new_base[0], device=device),
+                                        torch.arange(c_new_base[1], device=device),
+                                        indexing="ij",
+                                    )
+                                ).flatten(1)
+                                rel_pos = (pos[..., :, None] - pos[..., None, :]).abs()
+                                rel_pos = (rel_pos[0] * c_new_base[1]) + rel_pos[1]
+                                m.token_mixer.attention_bias_idxs = nn.Buffer(rel_pos.to(torch.long), persistent=False)
 
 
 registry.register_model_config(

birder/net/efficientvit_msft.py

@@ -497,14 +497,16 @@ class EfficientViT_MSFT(DetectorBackbone):
 
                                 idxs.append(attention_offsets[offset])
 
-                        m.mixer.m.attn.attention_biases = nn.Parameter(
-                            interpolate_attention_bias(
-                                m.mixer.m.attn.attention_biases, old_window_resolution, window_resolution
+                        with torch.no_grad():
+                            m.mixer.m.attn.attention_biases = nn.Parameter(
+                                interpolate_attention_bias(
+                                    m.mixer.m.attn.attention_biases, old_window_resolution, window_resolution
+                                )
+                            )
+                            device = m.mixer.m.attn.attention_biases.device
+                            m.mixer.m.attn.attention_bias_idxs = nn.Buffer(
+                                torch.tensor(idxs, device=device, dtype=torch.long).view(N, N), persistent=False
                             )
-                        )
-                        m.mixer.m.attn.attention_bias_idxs = nn.Buffer(
-                            torch.LongTensor(idxs).view(N, N), persistent=False
-                        )
 
 
 registry.register_model_config(

birder/net/fasternet.py

@@ -6,7 +6,7 @@ Paper "Run, Don't Walk: Chasing Higher FLOPS for Faster Neural Networks",
 https://arxiv.org/abs/2303.03667
 
 Changes from original:
-* No extra norm's for detection
+* No extra norms for detection
 """
 
 # Reference license: MIT

birder/net/fastvit.py

@@ -879,6 +879,7 @@ class FastViT(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
         x = self.forward_features(x)
         return self.features(x)
 
+    @torch.no_grad()  # type: ignore[untyped-decorator]
     def reparameterize_model(self) -> None:
         for module in self.modules():
             if hasattr(module, "reparameterize") is True:

birder/net/flexivit.py

@@ -519,15 +519,16 @@ class FlexiViT(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, Mask
         else:
             num_prefix_tokens = 0
 
-        self.pos_embedding = nn.Parameter(
-            # On rounding error see: https://github.com/facebookresearch/dino/issues/8
-            adjust_position_embedding(
+        with torch.no_grad():
+            pos_embedding = adjust_position_embedding(
+                # On rounding error see: https://github.com/facebookresearch/dino/issues/8
                 self.pos_embedding,
                 (old_size[0] // self.patch_size, old_size[1] // self.patch_size),
                 (new_size[0] // self.patch_size, new_size[1] // self.patch_size),
                 num_prefix_tokens,
             )
-        )
+
+        self.pos_embedding = nn.Parameter(pos_embedding)
 
     def adjust_patch_size(self, patch_size: int) -> None:
         if self.patch_size == patch_size: