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

birder/net/detection/deformable_detr.py

@@ -133,7 +133,7 @@ class MultiScaleDeformableAttention(nn.Module):
         self._reset_parameters()
 
     def _reset_parameters(self) -> None:
-        nn.init.constant_(self.sampling_offsets.weight.data, 0.0)
+        nn.init.constant_(self.sampling_offsets.weight, 0.0)
         thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads)
         grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)
         grid_init = (
@@ -147,12 +147,12 @@ class MultiScaleDeformableAttention(nn.Module):
         with torch.no_grad():
             self.sampling_offsets.bias = nn.Parameter(grid_init.view(-1))
 
-        nn.init.constant_(self.attention_weights.weight.data, 0.0)
-        nn.init.constant_(self.attention_weights.bias.data, 0.0)
-        nn.init.xavier_uniform_(self.value_proj.weight.data)
-        nn.init.constant_(self.value_proj.bias.data, 0.0)
-        nn.init.xavier_uniform_(self.output_proj.weight.data)
-        nn.init.constant_(self.output_proj.bias.data, 0.0)
+        nn.init.constant_(self.attention_weights.weight, 0.0)
+        nn.init.constant_(self.attention_weights.bias, 0.0)
+        nn.init.xavier_uniform_(self.value_proj.weight)
+        nn.init.constant_(self.value_proj.bias, 0.0)
+        nn.init.xavier_uniform_(self.output_proj.weight)
+        nn.init.constant_(self.output_proj.bias, 0.0)
 
     def forward(
         self,
@@ -280,8 +280,10 @@ class DeformableTransformerDecoderLayer(nn.Module):
         q = tgt + query_pos
         k = tgt + query_pos
 
-        tgt2 = self.self_attn(q.transpose(0, 1), k.transpose(0, 1), tgt.transpose(0, 1), attn_mask=self_attn_mask)
-        tgt2 = tgt2[0].transpose(0, 1)
+        (tgt2, _) = self.self_attn(
+            q.transpose(0, 1), k.transpose(0, 1), tgt.transpose(0, 1), need_weights=False, attn_mask=self_attn_mask
+        )
+        tgt2 = tgt2.transpose(0, 1)
         tgt = tgt + self.dropout(tgt2)
         tgt = self.norm1(tgt)
 
@@ -451,8 +453,8 @@ class DeformableTransformer(nn.Module):
             if isinstance(m, MultiScaleDeformableAttention):
                 m._reset_parameters()
 
-            nn.init.xavier_uniform_(self.reference_points.weight.data, gain=1.0)
-            nn.init.zeros_(self.reference_points.bias.data)
+            nn.init.xavier_uniform_(self.reference_points.weight, gain=1.0)
+            nn.init.zeros_(self.reference_points.bias)
 
         nn.init.normal_(self.level_embed)
 
@@ -613,7 +615,7 @@ class Deformable_DETR(DetectionBaseNet):
             nn.init.zeros_(bbox_embed[-2].weight)
             nn.init.zeros_(bbox_embed[-2].bias)
 
-        nn.init.constant_(self.bbox_embed[0][-2].bias.data[2:], -2.0)
+        nn.init.constant_(self.bbox_embed[0][-2].bias[2:], -2.0)
 
     def reset_classifier(self, num_classes: int) -> None:
         self.num_classes = num_classes

birder/net/detection/detr.py

@@ -108,7 +108,7 @@ class TransformerEncoderLayer(nn.Module):
         q = src + pos
         k = src + pos
 
-        (src2, _) = self.self_attn(q, k, value=src, key_padding_mask=src_key_padding_mask)
+        (src2, _) = self.self_attn(q, k, value=src, key_padding_mask=src_key_padding_mask, need_weights=False)
         src = src + self.dropout1(src2)
         src = self.norm1(src)
         src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
@@ -148,11 +148,15 @@ class TransformerDecoderLayer(nn.Module):
         q = tgt + query_pos
         k = tgt + query_pos
 
-        (tgt2, _) = self.self_attn(q, k, value=tgt)
+        (tgt2, _) = self.self_attn(q, k, value=tgt, need_weights=False)
         tgt = tgt + self.dropout1(tgt2)
         tgt = self.norm1(tgt)
         (tgt2, _) = self.multihead_attn(
-            query=tgt + query_pos, key=memory + pos, value=memory, key_padding_mask=memory_key_padding_mask
+            query=tgt + query_pos,
+            key=memory + pos,
+            value=memory,
+            key_padding_mask=memory_key_padding_mask,
+            need_weights=False,
         )
         tgt = tgt + self.dropout2(tgt2)
         tgt = self.norm2(tgt)

birder/net/detection/rt_detr_v1.py

@@ -234,7 +234,7 @@ class TransformerEncoderLayer(nn.Module):
         q = src + pos
         k = src + pos
 
-        (src2, _) = self.self_attn(q, k, value=src, key_padding_mask=key_padding_mask)
+        (src2, _) = self.self_attn(q, k, value=src, key_padding_mask=key_padding_mask, need_weights=False)
         src = src + self.dropout1(src2)
         src = self.norm1(src)
 
@@ -465,8 +465,8 @@ class RT_DETRDecoder(nn.Module):
             nn.init.constant_(class_embed.bias, bias_value)
 
         for bbox_embed in self.bbox_embed:
-            nn.init.zeros_(bbox_embed[-2].weight.data)
-            nn.init.zeros_(bbox_embed[-2].bias.data)
+            nn.init.zeros_(bbox_embed[-2].weight)
+            nn.init.zeros_(bbox_embed[-2].bias)
 
     def set_cache_enabled(self, enabled: bool) -> None:
         self.use_cache = enabled

birder/net/detection/yolo_v3.py

@@ -37,7 +37,7 @@ def scale_anchors(
     to_size: tuple[int, int],
 ) -> list[list[tuple[float, float]]]:
     if from_size == to_size:
-        # Avoid aliasing default anchors in case they are mutated later.
+        # Avoid aliasing default anchors in case they are mutated later
         return [list(scale) for scale in anchors]
 
     scale_h = to_size[0] / from_size[0]
@@ -368,14 +368,16 @@ class YOLO_v3(DetectionBaseNet):
         num_anchors = self.anchor_generator.num_anchors_per_location()
         self.head = YOLOHead(self.neck.out_channels, num_anchors, self.num_classes)
 
-    def adjust_size(self, new_size: tuple[int, int]) -> None:
+    def adjust_size(self, new_size: tuple[int, int], adjust_anchors: bool = False) -> None:
         if new_size == self.size:
             return
 
         old_size = self.size
         super().adjust_size(new_size)
-        self.anchors = scale_anchors(self.anchors, old_size, new_size)
-        self.anchor_generator.anchors = self.anchors
+
+        if adjust_anchors is True:
+            self.anchors = scale_anchors(self.anchors, old_size, new_size)
+            self.anchor_generator.anchors = self.anchors
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
@@ -705,13 +707,6 @@ class YOLO_v3(DetectionBaseNet):
         neck_features = self.neck(features)
         predictions = self.head(neck_features)
         (anchors, grids, strides) = self.anchor_generator(images, neck_features)
-        if self.dynamic_size is True:
-            image_size = (images.tensors.shape[-2], images.tensors.shape[-1])
-            if image_size[0] != self.size[0] or image_size[1] != self.size[1]:
-                scale_w = image_size[1] / self.size[1]
-                scale_h = image_size[0] / self.size[0]
-                scale_tensor = torch.tensor([scale_w, scale_h], device=anchors[0].device, dtype=anchors[0].dtype)
-                anchors = [anchor * scale_tensor for anchor in anchors]
 
         losses: dict[str, torch.Tensor] = {}
         detections: list[dict[str, torch.Tensor]] = []

birder/net/detection/yolo_v4.py

@@ -400,14 +400,8 @@ class YOLO_v4(DetectionBaseNet):
         self.ignore_thresh = 0.7
 
         # Loss coefficients
-        # Note: coord_coeff=0.07 matches darknet's iou_normalizer for CIoU loss.
-        # However, darknet uses squared deltas (loss = sum(delta^2) / batch) while we compute
-        # CIoU loss directly (loss = coeff * sum(ciou) / num_obj). This different formulation
-        # means darknet's obj_normalizer=1.0 overweights background loss relative to box
-        # regression in our implementation. We use a lower noobj_coeff (vs darknet's 1.0) to
-        # restore a better balance, similar to YOLOv3's noobj_coeff=0.2.
-        self.noobj_coeff = 0.3
-        self.coord_coeff = 0.07
+        self.noobj_coeff = 0.25
+        self.coord_coeff = 3.0
         self.obj_coeff = 1.0
         self.cls_coeff = 1.0
 
@@ -439,14 +433,16 @@ class YOLO_v4(DetectionBaseNet):
         num_anchors = self.anchor_generator.num_anchors_per_location()
         self.head = YOLOHead(self.neck.out_channels, num_anchors, self.num_classes)
 
-    def adjust_size(self, new_size: tuple[int, int]) -> None:
+    def adjust_size(self, new_size: tuple[int, int], adjust_anchors: bool = False) -> None:
         if new_size == self.size:
             return
 
         old_size = self.size
         super().adjust_size(new_size)
-        self.anchors = scale_anchors(self.anchors, old_size, new_size)
-        self.anchor_generator = YOLOAnchorGenerator(self.anchors)
+
+        if adjust_anchors is True:
+            self.anchors = scale_anchors(self.anchors, old_size, new_size)
+            self.anchor_generator = YOLOAnchorGenerator(self.anchors)
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
@@ -809,13 +805,6 @@ class YOLO_v4(DetectionBaseNet):
         neck_features = self.neck(features)
         predictions = self.head(neck_features)
         (anchors, grids, strides) = self.anchor_generator(images, neck_features)
-        if self.dynamic_size is True:
-            image_size = (images.tensors.shape[-2], images.tensors.shape[-1])
-            if image_size[0] != self.size[0] or image_size[1] != self.size[1]:
-                scale_w = image_size[1] / self.size[1]
-                scale_h = image_size[0] / self.size[0]
-                scale_tensor = torch.tensor([scale_w, scale_h], device=anchors[0].device, dtype=anchors[0].dtype)
-                anchors = [anchor * scale_tensor for anchor in anchors]
 
         losses: dict[str, torch.Tensor] = {}
         detections: list[dict[str, torch.Tensor]] = []

birder/net/detection/yolo_v4_tiny.py

@@ -113,9 +113,9 @@ class YOLO_v4_Tiny(YOLO_v4):
         detections_per_img = 300
         self.ignore_thresh = 0.7
 
-        # Loss coefficients - see YOLO v4 for detailed explanation
-        self.noobj_coeff = 0.3
-        self.coord_coeff = 0.07
+        # Loss coefficients
+        self.noobj_coeff = 0.25
+        self.coord_coeff = 3.0
         self.obj_coeff = 1.0
         self.cls_coeff = 1.0
 

birder/net/fastvit.py

@@ -818,10 +818,10 @@ class FastViT(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
         self.embedding_size = int(embed_dims[-1] * cls_ratio)
         self.classifier = self.create_classifier()
 
+        self.max_stride = 2 ** (len(layers) + 1)
         self.stem_stride = 4
         self.stem_width = embed_dims[0]
         self.encoding_size = int(embed_dims[-1] * cls_ratio)
-        self.max_stride = 2 ** (len(layers) + 1)
 
         # Weights initialization
         for m in self.modules():

birder/net/mim/mae_vit.py

@@ -2,13 +2,12 @@
 MAE ViT, adapted from
 https://github.com/lucidrains/vit-pytorch/blob/main/vit_pytorch/mae.py
 and
-https://github.com/facebookresearch/mae/blob/main/models_mae.py
+https://github.com/huggingface/transformers/blob/main/src/transformers/models/vit_mae/modeling_vit_mae.py
 
-Paper "Masked Autoencoders Are Scalable Vision Learners",
-https://arxiv.org/abs/2111.06377
+Paper "Masked Autoencoders Are Scalable Vision Learners", https://arxiv.org/abs/2111.06377
 """
 
-# Reference license: MIT and Attribution-NonCommercial 4.0 International
+# Reference license: MIT and Apache-2.0
 
 from typing import Any
 from typing import Optional
@@ -61,7 +60,7 @@ class MAE_ViT(MIMBaseNet):
             seq_len += self.encoder.num_special_tokens
             self.decoder_pos_embed = nn.Parameter(torch.empty(1, seq_len, decoder_embed_dim).normal_(std=0.02))
         else:
-            # Fixed sin-cos embedding
+            # Fixed sin-cos embeddings
             pos_embedding = pos_embedding_sin_cos_2d(
                 h=self.size[0] // self.patch_size,
                 w=self.size[1] // self.patch_size,
@@ -124,12 +123,12 @@ class MAE_ViT(MIMBaseNet):
         mask_tokens = self.mask_token.repeat(x.size(0), ids_restore.size(1) + special_token_len - x.size(1), 1)
         x_ = torch.concat([x[:, special_token_len:, :], mask_tokens], dim=1)  # No special tokens
         x_ = torch.gather(x_, dim=1, index=ids_restore.unsqueeze(-1).repeat(1, 1, x.size(2)))  # Un-shuffle
-        x = torch.concat([x[:, :special_token_len, :], x_], dim=1)  # Append special tokens
+        x = torch.concat([x[:, :special_token_len, :], x_], dim=1)  # Re-append special tokens
 
-        # Add pos embed
+        # Add positional embeddings
         x = x + self.decoder_pos_embed
 
-        # Apply transformer
+        # Apply decoder transformer
         x = self.decoder(x)
 
         # Remove special tokens

birder/net/pit.py

@@ -259,7 +259,7 @@ class PiT(DetectorBackbone):
         width = (new_size[1] - self.patch_size[1]) // self.patch_stride[1] + 1
 
         self.pos_embed = nn.Parameter(
-            F.interpolate(self.pos_embed.data, (height, width), mode="bicubic"), requires_grad=True
+            F.interpolate(self.pos_embed, (height, width), mode="bicubic"), requires_grad=True
         )
 
 

birder/net/resnet_v1.py

@@ -3,6 +3,9 @@ ResNet v1, adapted from
 https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py
 
 Paper "Deep Residual Learning for Image Recognition", https://arxiv.org/abs/1512.03385
+and
+Paper "Bag of Tricks for Image Classification with Convolutional Neural Networks",
+https://arxiv.org/abs/1812.01187
 """
 
 # Reference license: BSD 3-Clause
@@ -23,34 +26,25 @@ from birder.net.base import DetectorBackbone
 
 class ResidualBlock(nn.Module):
     def __init__(
-        self, in_channels: int, out_channels: int, stride: tuple[int, int], bottle_neck: bool, squeeze_excitation: bool
+        self,
+        in_channels: int,
+        out_channels: int,
+        stride: tuple[int, int],
+        bottle_neck: bool,
+        squeeze_excitation: bool,
+        avg_down: bool,
     ) -> None:
         super().__init__()
         if bottle_neck is True:
             self.block1 = nn.Sequential(
                 Conv2dNormActivation(
-                    in_channels,
-                    out_channels // 4,
-                    kernel_size=(1, 1),
-                    stride=(1, 1),
-                    padding=(0, 0),
-                    bias=False,
+                    in_channels, out_channels // 4, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=False
                 ),
                 Conv2dNormActivation(
-                    out_channels // 4,
-                    out_channels // 4,
-                    kernel_size=(3, 3),
-                    stride=stride,
-                    padding=(1, 1),
-                    bias=False,
+                    out_channels // 4, out_channels // 4, kernel_size=(3, 3), stride=stride, padding=(1, 1), bias=False
                 ),
                 nn.Conv2d(
-                    out_channels // 4,
-                    out_channels,
-                    kernel_size=(1, 1),
-                    stride=(1, 1),
-                    padding=(0, 0),
-                    bias=False,
+                    out_channels // 4, out_channels, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=False
                 ),
                 nn.BatchNorm2d(out_channels),
             )
@@ -67,10 +61,19 @@ class ResidualBlock(nn.Module):
         if in_channels == out_channels:
             self.block2 = nn.Identity()
         else:
-            self.block2 = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels, kernel_size=(1, 1), stride=stride, padding=(0, 0), bias=False),
-                nn.BatchNorm2d(out_channels),
-            )
+            if avg_down is True and stride != (1, 1):
+                # ResNet-D: Apply average pooling before 1x1 conv for downsampling
+                self.block2 = nn.Sequential(
+                    nn.AvgPool2d(kernel_size=2, stride=stride, ceil_mode=True, count_include_pad=False),
+                    nn.Conv2d(in_channels, out_channels, kernel_size=(1, 1), stride=(1, 1), padding=(0, 0), bias=False),
+                    nn.BatchNorm2d(out_channels),
+                )
+            else:
+                # Standard ResNet: Use strided 1x1 conv
+                self.block2 = nn.Sequential(
+                    nn.Conv2d(in_channels, out_channels, kernel_size=(1, 1), stride=stride, padding=(0, 0), bias=False),
+                    nn.BatchNorm2d(out_channels),
+                )
 
         self.relu = nn.ReLU(inplace=True)
         if squeeze_excitation is True:
@@ -107,21 +110,30 @@ class ResNet_v1(DetectorBackbone):
         filter_list: list[int] = self.config["filter_list"]
         units: list[int] = self.config["units"]
         pooling_param: Optional[float] = self.config.get("pooling_param", None)
+        deep_stem: bool = self.config.get("deep_stem", False)
+        avg_down: bool = self.config.get("avg_down", False)
 
         assert len(units) + 1 == len(filter_list)
         num_unit = len(units)
 
-        self.stem = nn.Sequential(
-            Conv2dNormActivation(
-                self.input_channels,
-                filter_list[0],
-                kernel_size=(7, 7),
-                stride=(2, 2),
-                padding=(3, 3),
-                bias=False,
-            ),
-            nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
-        )
+        if deep_stem is True:
+            # ResNet-D
+            self.stem = nn.Sequential(
+                Conv2dNormActivation(
+                    self.input_channels, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False
+                ),
+                Conv2dNormActivation(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False),
+                Conv2dNormActivation(32, filter_list[0], kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False),
+                nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
+            )
+        else:
+            # Standard ResNet stem: 7x7 conv
+            self.stem = nn.Sequential(
+                Conv2dNormActivation(
+                    self.input_channels, filter_list[0], kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False
+                ),
+                nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)),
+            )
 
         # Generate body layers
         stages: OrderedDict[str, nn.Module] = OrderedDict()
@@ -140,6 +152,7 @@ class ResNet_v1(DetectorBackbone):
                     stride=stride,
                     bottle_neck=bottle_neck,
                     squeeze_excitation=squeeze_excitation,
+                    avg_down=avg_down,
                 )
             )
             for _ in range(1, units[i]):
@@ -150,6 +163,7 @@ class ResNet_v1(DetectorBackbone):
                         stride=(1, 1),
                         bottle_neck=bottle_neck,
                         squeeze_excitation=squeeze_excitation,
+                        avg_down=avg_down,
                     )
                 )
 
@@ -242,6 +256,52 @@ registry.register_model_config(
     config={"bottle_neck": True, "filter_list": [64, 256, 512, 1024, 2048], "units": [3, 30, 48, 8]},
 )
 
+# ResNet-D variants (From: Bag of Tricks for Image Classification with Convolutional Neural Networks)
+registry.register_model_config(
+    "resnet_d_50",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 4, 6, 3],
+        "deep_stem": True,
+        "avg_down": True,
+    },
+)
+registry.register_model_config(
+    "resnet_d_101",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 4, 23, 3],
+        "deep_stem": True,
+        "avg_down": True,
+    },
+)
+registry.register_model_config(
+    "resnet_d_152",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 8, 36, 3],
+        "deep_stem": True,
+        "avg_down": True,
+    },
+)
+registry.register_model_config(
+    "resnet_d_200",
+    ResNet_v1,
+    config={
+        "bottle_neck": True,
+        "filter_list": [64, 256, 512, 1024, 2048],
+        "units": [3, 24, 36, 3],
+        "deep_stem": True,
+        "avg_down": True,
+    },
+)
+
 registry.register_weights(
     "resnet_v1_50_arabian-peninsula",
     {

birder/net/ssl/data2vec.py

@@ -78,7 +78,7 @@ class Data2Vec(SSLBaseNet):
         if self.normalize_targets is True:
             y = F.layer_norm(y.float(), y.shape[-1:])
 
-        mask = ~mask.bool()
+        mask = mask.bool()
         x = x[mask]
         y = y[mask]
 

birder/net/ssl/data2vec2.py

@@ -7,7 +7,6 @@ https://arxiv.org/abs/2212.07525
 
 Changes from original:
 * Target CLS is taken just from the last layer
-* Replaced instance norm (1st of the IN -> AVG -> LM) with layer norm
 """
 
 # Reference license: MIT
@@ -140,7 +139,10 @@ class Data2Vec2(SSLBaseNet):
         y = y[..., -self.average_top_k_layers :]  # Take the last k layers
         y = y.permute(3, 0, 1, 2)
 
-        y = [F.layer_norm(t.float(), t.shape[-1:]) for t in y[:-1]] + [y[-1]]
+        # Note: the backbone already LN-normalizes the final layer (per-token),
+        # but data2vec2 uses per-layer instance norm across tokens (per-channel)
+        # before averaging (IN -> AVG -> LN), so we keep IN for all K layers.
+        y = [F.instance_norm(t.float().transpose(1, 2)).transpose(1, 2) for t in y]
         y = sum(y) / len(y)
         y = F.layer_norm(y.float(), y.shape[-1:])
 

birder/results/gui.py

@@ -31,6 +31,7 @@ def show_detections(
     detection: dict[str, torch.Tensor],
     class_to_idx: dict[str, int],
     score_threshold: float = 0.5,
+    class_min_scores: Optional[dict[str, float]] = None,
     color_list: Optional[list[tuple[int, ...]]] = None,
     show: bool = True,
 ) -> tuple[matplotlib.figure.Figure, matplotlib.axes.Axes]:
@@ -38,10 +39,22 @@ def show_detections(
     idx_to_class = dict(zip(class_to_idx.values(), class_to_idx.keys()))
 
     scores = detection["scores"]
-    idxs = torch.where(scores > score_threshold)
+    labels_all = detection["labels"]
+
+    # Apply per-class minimum scores if provided, otherwise use global threshold
+    if class_min_scores is not None and len(class_min_scores) > 0:
+        mask = torch.zeros(len(scores), dtype=torch.bool)
+        for i, (score, label) in enumerate(zip(scores, labels_all)):
+            class_name = idx_to_class[label.item()]
+            min_score = class_min_scores.get(class_name, score_threshold)
+            mask[i] = score > min_score
+        idxs = torch.where(mask)[0]
+    else:
+        idxs = torch.where(scores > score_threshold)
+
     scores = scores[idxs]
     boxes = detection["boxes"][idxs]
-    labels = detection["labels"][idxs]
+    labels = labels_all[idxs]
     label_names = [f"{idx_to_class[i.item()]}: {s:.4f}" for i, s in zip(labels, scores)]
     if color_list is not None:
         colors = [color_list[label] for label in labels]

birder/scripts/predict_detection.py

@@ -101,6 +101,17 @@ def predict(args: argparse.Namespace) -> None:
 
     score_threshold = args.min_score
 
+    # Process per-class minimum scores
+    class_min_scores: dict[str, float] = {}
+    if args.class_min_score is not None:
+        for class_name, score_str in args.class_min_score:
+            score = float(score_str)
+            if class_name not in class_to_idx:
+                logger.warning(f"Class '{class_name}' from --class-min-score not found in model classes")
+            else:
+                class_min_scores[class_name] = score
+                logger.info(f"Using minimum score {score} for class '{class_name}'")
+
     # Set label colors
     cmap = plt.get_cmap("jet")
     color_list = []
@@ -157,6 +168,7 @@ def predict(args: argparse.Namespace) -> None:
                     detection,
                     class_to_idx=class_to_idx,
                     score_threshold=score_threshold,
+                    class_min_scores=class_min_scores,
                     color_list=color_list,
                 )
 
@@ -224,7 +236,10 @@ def get_args_parser() -> argparse.ArgumentParser:
             "-e 0 --min-score 0.25 --gpu --show --shuffle data/detection_data/validation\n"
             "python predict_detection.py --network faster_rcnn -t coco --backbone csp_resnet_50 "
             "--backbone-tag imagenet1k -e 0 --batch-size 1 --gpu --gpu-id 1 "
-            "--coco-json-path data/detection_data/validation_annotations_coco.json data/detection_data"
+            "--coco-json-path data/detection_data/validation_annotations_coco.json data/detection_data\n"
+            "python predict_detection.py -n yolo_v4 --backbone csp_resnet_50 --backbone-tag imagenet1k -t coco "
+            " --min-score 0.4 --class-min-score person 0.75 --class-min-score car 0.3 --batch-size 1 --show "
+            "--shuffle ~/Datasets/cocodataset/val2017\n"
         ),
         formatter_class=cli.ArgumentHelpFormatter,
     )
@@ -284,6 +299,13 @@ def get_args_parser() -> argparse.ArgumentParser:
         "--fast-matmul", default=False, action="store_true", help="use fast matrix multiplication (affects precision)"
     )
     parser.add_argument("--min-score", type=float, default=0.5, help="prediction score threshold")
+    parser.add_argument(
+        "--class-min-score",
+        action="append",
+        nargs=2,
+        metavar=("CLASS", "SCORE"),
+        help="set custom minimum score for specific class (can be used multiple times)",
+    )
     parser.add_argument(
         "--size",
         type=int,
@@ -342,6 +364,16 @@ def validate_args(args: argparse.Namespace) -> None:
         )
     if args.min_score >= 1 or args.min_score <= 0.0:
         raise cli.ValidationError(f"--min-score must be in range of (0, 1.0), got {args.min_score}")
+    if args.class_min_score is not None:
+        for class_name, score_str in args.class_min_score:
+            try:
+                score = float(score_str)
+                if score >= 1.0 or score <= 0.0:
+                    raise cli.ValidationError(
+                        f"--class-min-score for '{class_name}' must be in range of (0, 1.0), got {score}"
+                    )
+            except ValueError as e:
+                raise cli.ValidationError(f"--class-min-score value must be a valid float, got '{score_str}'") from e
     if args.parallel is True and args.gpu is False:
         raise cli.ValidationError("--parallel requires --gpu to be set")
     if args.parallel is True and args.compile is True: