birder 0.4.0__tar.gz → 0.4.2__tar.gz

{birder-0.4.0 → birder-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: birder
-Version: 0.4.0
+Version: 0.4.2
 Summary: An open-source computer vision framework for wildlife image analysis, featuring state-of-the-art models for species classification and detection.
 Author: Ofer Hasson
 License-Expression: Apache-2.0
@@ -26,7 +26,7 @@ License-File: LICENSE
 Requires-Dist: matplotlib>=3.9.0
 Requires-Dist: numpy>=2.2.0
 Requires-Dist: onnx>=1.18.0
-Requires-Dist: onnxscript~=0.5.7
+Requires-Dist: onnxscript~=0.6.0
 Requires-Dist: Pillow>=12.0.0
 Requires-Dist: polars>=1.31.0
 Requires-Dist: pyarrow>=20.0.0
@@ -43,12 +43,12 @@ Requires-Dist: torch>=2.7.0
 Requires-Dist: torchvision
 Provides-Extra: dev
 Requires-Dist: altair~=5.5.0; extra == "dev"
-Requires-Dist: bandit~=1.9.2; extra == "dev"
-Requires-Dist: black~=25.12.0; extra == "dev"
+Requires-Dist: bandit~=1.9.3; extra == "dev"
+Requires-Dist: black~=26.1.0; extra == "dev"
 Requires-Dist: build~=1.4.0; extra == "dev"
 Requires-Dist: bumpver~=2025.1131; extra == "dev"
 Requires-Dist: captum~=0.7.0; extra == "dev"
-Requires-Dist: coverage~=7.13.1; extra == "dev"
+Requires-Dist: coverage~=7.13.2; extra == "dev"
 Requires-Dist: debugpy; extra == "dev"
 Requires-Dist: flake8-pep585~=0.1.7; extra == "dev"
 Requires-Dist: flake8~=7.3.0; extra == "dev"

{birder-0.4.0 → birder-0.4.2}/birder/adversarial/base.py

@@ -56,7 +56,7 @@ def pixel_eps_to_normalized(
 
 
 def clamp_normalized(inputs: torch.Tensor, rgb_stats: RGBType) -> torch.Tensor:
-    (min_val, max_val) = normalized_bounds(rgb_stats, device=inputs.device, dtype=inputs.dtype)
+    min_val, max_val = normalized_bounds(rgb_stats, device=inputs.device, dtype=inputs.dtype)
     return torch.clamp(inputs, min=min_val, max=max_val)
 
 

{birder-0.4.0 → birder-0.4.2}/birder/adversarial/simba.py

@@ -87,7 +87,7 @@ class SimBA:
         if self._is_successful(current_logits, label, target_label):
             return adv_inputs.detach(), num_queries
 
-        (_, channels, height, width) = adv_inputs.shape
+        _, channels, height, width = adv_inputs.shape
         num_dims = channels * height * width
         step = pixel_eps_to_normalized(self.step_size, self.rgb_stats, device=adv_inputs.device, dtype=adv_inputs.dtype)
         step_vals = step.view(-1)  # Per-channel steps
@@ -98,11 +98,11 @@ class SimBA:
 
         # Coordinate-wise search in random order
         for flat_idx in perm[:num_steps]:
-            (c, rem) = divmod(int(flat_idx.item()), stride)
-            (h, w) = divmod(rem, width)
+            c, rem = divmod(int(flat_idx.item()), stride)
+            h, w = divmod(rem, width)
             step_val = step_vals[c]
 
-            (candidate_inputs, candidate_logits, candidate_objective) = self._best_candidate(
+            candidate_inputs, candidate_logits, candidate_objective = self._best_candidate(
                 adv_inputs, c, h, w, step_val, label, target_label
             )
             num_queries += 2

{birder-0.4.0 → birder-0.4.2}/birder/common/cli.py

@@ -49,7 +49,7 @@ class FlexibleDictAction(argparse.Action):
             new_dict = {}
             for pair in pairs:
                 # Split each pair into key and value
-                (key, value) = pair.split("=", 1)
+                key, value = pair.split("=", 1)
                 key = key.strip()
 
                 # Try to safely evaluate the value (handles ints and strings mostly)

{birder-0.4.0 → birder-0.4.2}/birder/common/fs_ops.py

@@ -384,7 +384,7 @@ def load_checkpoint(
     )
 
     # Initialize network and restore checkpoint state
-    net = registry.net_factory(network, input_channels, num_classes, config=config, size=size)
+    net = registry.net_factory(network, num_classes, input_channels, config=config, size=size)
 
     # When a checkpoint was trained with EMA:
     #   The primary weights in the checkpoint file are the EMA weights
@@ -437,7 +437,7 @@ def load_mim_checkpoint(
     size = lib.get_size_from_signature(signature)
 
     # Initialize network and restore checkpoint state
-    net_encoder = registry.net_factory(encoder, input_channels, num_classes, config=encoder_config, size=size)
+    net_encoder = registry.net_factory(encoder, num_classes, input_channels, config=encoder_config, size=size)
     net = registry.mim_net_factory(
         network, net_encoder, config=config, size=size, mask_ratio=mask_ratio, min_mask_size=min_mask_size
     )
@@ -488,7 +488,7 @@ def load_detection_checkpoint(
     size = lib.get_size_from_signature(signature)
 
     # Initialize network and restore checkpoint state
-    net_backbone = registry.net_factory(backbone, input_channels, num_classes, config=backbone_config, size=size)
+    net_backbone = registry.net_factory(backbone, num_classes, input_channels, config=backbone_config, size=size)
     net = registry.detection_net_factory(network, num_classes, net_backbone, config=config, size=size)
 
     # When a checkpoint was trained with EMA:
@@ -584,7 +584,7 @@ def load_model(
             merged_config = None  # type: ignore[assignment]
 
         model_state: dict[str, Any] = safetensors.torch.load_file(path, device=device.type)
-        net = registry.net_factory(network, input_channels, num_classes, config=merged_config, size=size)
+        net = registry.net_factory(network, num_classes, input_channels, config=merged_config, size=size)
         if reparameterized is True:
             net.reparameterize_model()
 
@@ -611,7 +611,7 @@ def load_model(
         if len(merged_config) == 0:
             merged_config = None
 
-        net = registry.net_factory(network, input_channels, num_classes, config=merged_config, size=size)
+        net = registry.net_factory(network, num_classes, input_channels, config=merged_config, size=size)
         if reparameterized is True:
             net.reparameterize_model()
 
@@ -733,7 +733,7 @@ def load_detection_model(
 
         model_state: dict[str, Any] = safetensors.torch.load_file(path, device=device.type)
         net_backbone = registry.net_factory(
-            backbone, input_channels, num_classes, config=backbone_merged_config, size=size
+            backbone, num_classes, input_channels, config=backbone_merged_config, size=size
         )
         if backbone_reparameterized is True:
             net_backbone.reparameterize_model()
@@ -776,7 +776,7 @@ def load_detection_model(
             merged_config = None
 
         net_backbone = registry.net_factory(
-            backbone, input_channels, num_classes, config=backbone_merged_config, size=size
+            backbone, num_classes, input_channels, config=backbone_merged_config, size=size
         )
         if backbone_reparameterized is True:
             net_backbone.reparameterize_model()
@@ -959,7 +959,7 @@ def load_model_with_cfg(
             encoder_name = cfg["encoder"]
 
         encoder_config = cfg.get("encoder_config", None)
-        encoder = registry.net_factory(encoder_name, input_channels, num_classes=0, config=encoder_config, size=size)
+        encoder = registry.net_factory(encoder_name, 0, input_channels, config=encoder_config, size=size)
         net = registry.mim_net_factory(name, encoder, config=model_config, size=size)
 
     elif cfg["task"] == Task.OBJECT_DETECTION:
@@ -969,14 +969,14 @@ def load_model_with_cfg(
             backbone_name = cfg["backbone"]
 
         backbone_config = cfg.get("backbone_config", None)
-        backbone = registry.net_factory(backbone_name, input_channels, num_classes, config=backbone_config, size=size)
+        backbone = registry.net_factory(backbone_name, num_classes, input_channels, config=backbone_config, size=size)
         if cfg.get("backbone_reparameterized", False) is True:
             backbone.reparameterize_model()
 
         net = registry.detection_net_factory(name, num_classes, backbone, config=model_config, size=size)
 
     elif cfg["task"] == Task.IMAGE_CLASSIFICATION:
-        net = registry.net_factory(name, input_channels, num_classes, config=model_config, size=size)
+        net = registry.net_factory(name, num_classes, input_channels, config=model_config, size=size)
 
     else:
         raise ValueError(f"Configuration not supported: {cfg['task']}")
@@ -1019,7 +1019,7 @@ def download_model_by_weights(
             f"Requested format '{file_format}' not available for {weights}, available formats are: {available_formats}"
         )
 
-    (model_file, url) = get_pretrained_model_url(weights, file_format)
+    model_file, url = get_pretrained_model_url(weights, file_format)
     if dst is None:
         dst = settings.MODELS_DIR.joinpath(model_file)
 

{birder-0.4.0 → birder-0.4.2}/birder/common/lib.py

@@ -157,6 +157,6 @@ def get_pretrained_model_url(weights: str, file_format: str) -> tuple[str, str]:
 
 def format_duration(seconds: float) -> str:
     s = int(seconds)
-    (mm, ss) = divmod(s, 60)
-    (hh, mm) = divmod(mm, 60)
+    mm, ss = divmod(s, 60)
+    hh, mm = divmod(mm, 60)
     return f"{hh:d}:{mm:02d}:{ss:02d}"

{birder-0.4.0 → birder-0.4.2}/birder/common/masking.py

@@ -16,7 +16,7 @@ def _mask_token_omission(
     Parameters
     ----------
     x
-        Tensor of shape (N, L, D), where N is the batch size, L is the sequence length, and D is the feature dimension.
+        Tensor of shape (N, L, D), where N is the batch size, L is the sequence length and D is the feature dimension.
     mask_ratio
         The ratio of the sequence length to be masked. This value should be between 0 and 1.
     kept_mask_ratio
@@ -48,7 +48,7 @@ def _mask_token_omission(
     # Masking: length -> length * mask_ratio
     # Perform per-sample random masking by per-sample shuffling.
     # Per-sample shuffling is done by argsort random noise.
-    (N, L, D) = x.size()  # batch, length, dim
+    N, L, D = x.size()  # batch, length, dim
     len_keep = int(L * (1 - mask_ratio))
     len_masked = int(L * (mask_ratio - kept_mask_ratio))
 
@@ -82,7 +82,7 @@ def mask_tensor(
     if channels_last is False:
         x = x.permute(0, 2, 3, 1)
 
-    (B, H, W, _) = x.size()
+    B, H, W, _ = x.size()
 
     shaped_mask = mask.reshape(B, H // patch_factor, W // patch_factor)
     shaped_mask = shaped_mask.repeat_interleave(patch_factor, dim=1).repeat_interleave(patch_factor, dim=2)

{birder-0.4.0 → birder-0.4.2}/birder/common/training_cli.py

@@ -13,6 +13,7 @@ from birder.conf import settings
 from birder.data.datasets.coco import MosaicType
 from birder.data.transforms.classification import AugType
 from birder.data.transforms.classification import RGBMode
+from birder.data.transforms.detection import MULTISCALE_STEP
 from birder.data.transforms.detection import AugType as DetAugType
 
 logger = logging.getLogger(__name__)
@@ -55,7 +56,9 @@ def add_optimization_args(parser: argparse.ArgumentParser, default_batch_size: i
     )
 
 
-def add_lr_wd_args(parser: argparse.ArgumentParser, backbone_lr: bool = False, wd_end: bool = False) -> None:
+def add_lr_wd_args(
+    parser: argparse.ArgumentParser, backbone_lr: bool = False, wd_end: bool = False, backbone_layer_decay: bool = False
+) -> None:
     group = parser.add_argument_group("Learning rate and regularization parameters")
     group.add_argument("--lr", type=float, default=0.1, metavar="LR", help="base learning rate")
     group.add_argument("--bias-lr", type=float, metavar="LR", help="learning rate of biases")
@@ -91,6 +94,9 @@ def add_lr_wd_args(parser: argparse.ArgumentParser, backbone_lr: bool = False, w
         help="custom weight decay for specific layers by name (e.g., offset_conv=0.0)",
     )
     group.add_argument("--layer-decay", type=float, help="layer-wise learning rate decay (LLRD)")
+    if backbone_layer_decay is True:
+        group.add_argument("--backbone-layer-decay", type=float, help="backbone layer-wise learning rate decay (LLRD)")
+
     group.add_argument("--layer-decay-min-scale", type=float, help="minimum layer scale factor clamp value")
     group.add_argument(
         "--layer-decay-no-opt-scale", type=float, help="layer scale threshold below which parameters are frozen"
@@ -199,10 +205,16 @@ def add_detection_input_args(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="enable random square resize once per batch (capped by max(--size))",
     )
+    group.add_argument(
+        "--multiscale-step",
+        type=int,
+        default=MULTISCALE_STEP,
+        help="step size for multiscale size lists and collator padding divisibility (size_divisible)",
+    )
     group.add_argument(
         "--multiscale-min-size",
         type=int,
-        help="minimum short-edge size for multiscale lists (rounded up to nearest multiple of 32)",
+        help="minimum short-edge size for multiscale lists (rounded up to nearest multiple of --multiscale-step)",
     )
 
 
@@ -515,7 +527,10 @@ def add_distributed_args(parser: argparse.ArgumentParser) -> None:
 
 
 def add_logging_and_debug_args(
-    parser: argparse.ArgumentParser, default_log_interval: int = 50, fake_data: bool = True
+    parser: argparse.ArgumentParser,
+    default_log_interval: int = 50,
+    fake_data: bool = True,
+    classification: bool = False,
 ) -> None:
     group = parser.add_argument_group("Logging and debugging parameters")
     group.add_argument(
@@ -525,6 +540,11 @@ def add_logging_and_debug_args(
         metavar="NAME",
         help="experiment name for logging (creates dedicated directory for the run)",
     )
+    if classification is True:
+        group.add_argument(
+            "--top-k", type=int, metavar="K", help="additional top-k accuracy value to track (top-1 is always tracked)"
+        )
+
     group.add_argument(
         "--log-interval",
         type=int,
@@ -746,3 +766,10 @@ def common_args_validation(args: argparse.Namespace) -> None:
     # Precision_args, shared by all scripts
     if args.amp is True and args.model_dtype != "float32":
         raise ValidationError("--amp can only be used with --model-dtype float32")
+
+    if hasattr(args, "top_k") is True and args.top_k is not None:
+        if args.top_k == 1:
+            raise ValidationError("Top-1 accuracy is tracked by default, please remove 1 from --top-k argument")
+
+        if args.top_k <= 0:
+            raise ValidationError("--top-k value must be a positive integer")

{birder-0.4.0 → birder-0.4.2}/birder/common/training_utils.py

@@ -11,6 +11,7 @@ from collections import deque
 from collections.abc import Callable
 from collections.abc import Generator
 from collections.abc import Iterator
+from collections.abc import Sequence
 from datetime import datetime
 from pathlib import Path
 from typing import Any
@@ -342,7 +343,7 @@ def count_layers(model: torch.nn.Module) -> int:
     return num_layers
 
 
-# pylint: disable=protected-access,too-many-locals,too-many-branches
+# pylint: disable=protected-access,too-many-locals,too-many-branches,too-many-statements
 def optimizer_parameter_groups(
     model: torch.nn.Module,
     weight_decay: float,
@@ -351,6 +352,7 @@ def optimizer_parameter_groups(
     custom_keys_weight_decay: Optional[list[tuple[str, float]]] = None,
     custom_layer_weight_decay: Optional[dict[str, float]] = None,
     layer_decay: Optional[float] = None,
+    backbone_layer_decay: Optional[float] = None,
     layer_decay_min_scale: Optional[float] = None,
     layer_decay_no_opt_scale: Optional[float] = None,
     bias_lr: Optional[float] = None,
@@ -361,7 +363,7 @@ def optimizer_parameter_groups(
     Return parameter groups for optimizers with per-parameter group weight decay.
 
     This function creates parameter groups with customizable weight decay, layer-wise
-    learning rate scaling, and special handling for different parameter types. It supports
+    learning rate scaling and special handling for different parameter types. It supports
     advanced optimization techniques like layer decay and custom weight decay rules.
 
     Referenced from https://github.com/pytorch/vision/blob/main/references/classification/utils.py and from
@@ -387,6 +389,8 @@ def optimizer_parameter_groups(
         Applied to parameters whose names contain the specified keys.
     layer_decay
         Layer-wise learning rate decay factor.
+    backbone_layer_decay
+        Layer-wise learning rate decay factor for backbone parameters only.
     layer_decay_min_scale
         Minimum learning rate scale factor when using layer decay. Prevents layers from having too small learning rates.
     layer_decay_no_opt_scale
@@ -433,6 +437,27 @@ def optimizer_parameter_groups(
         if layer_decay is not None:
             logger.warning("Assigning lr scaling (layer decay) without a block group map")
 
+    backbone_group_map: dict[str, int] = {}
+    backbone_num_layers = 0
+    if backbone_layer_decay is not None:
+        backbone_module = getattr(model, "backbone", None)
+        if backbone_module is None:
+            logger.warning("Backbone layer decay requested but model has no backbone")
+            backbone_layer_decay = None
+        else:
+            backbone_block_group_regex = getattr(backbone_module, "block_group_regex", None)
+            if backbone_block_group_regex is not None:
+                names = [n for n, _ in backbone_module.named_parameters()]
+                groups = group_by_regex(names, backbone_block_group_regex)
+                backbone_group_map = {
+                    f"backbone.{item}": index for index, sublist in enumerate(groups) for item in sublist
+                }
+                backbone_num_layers = len(groups)
+            else:
+                backbone_group_map = {}
+                backbone_num_layers = count_layers(backbone_module)
+                logger.warning("Assigning lr scaling (backbone layer decay) without a block group map")
+
     # Build layer scale
     if layer_decay_min_scale is None:
         layer_decay_min_scale = 0.0
@@ -443,14 +468,28 @@ def optimizer_parameter_groups(
         layer_scales = [max(layer_decay_min_scale, layer_decay ** (layer_max - i)) for i in range(num_layers)]
         logger.info(f"Layer scaling ranges from {min(layer_scales)} to {max(layer_scales)} across {num_layers} layers")
 
+    backbone_layer_scales = []
+    if backbone_layer_decay is not None:
+        backbone_layer_max = backbone_num_layers - 1
+        backbone_layer_scales = [
+            max(layer_decay_min_scale, backbone_layer_decay ** (backbone_layer_max - i))
+            for i in range(backbone_num_layers)
+        ]
+        logger.info(
+            "Backbone layer scaling ranges from "
+            f"{min(backbone_layer_scales)} to {max(backbone_layer_scales)} across {backbone_num_layers} layers"
+        )
+
     # Set weight decay and layer decay
     idx = 0
+    backbone_idx = 0
     params = []
     module_stack_with_prefix = [(model, "")]
     visited_modules = []
     while len(module_stack_with_prefix) > 0:  # pylint: disable=too-many-nested-blocks
         skip_module = False
-        (module, prefix) = module_stack_with_prefix.pop()
+        module, prefix = module_stack_with_prefix.pop()
+        is_backbone_module = prefix == "backbone" or prefix.startswith("backbone.")
         if id(module) in visited_modules:
             skip_module = True
 
@@ -459,23 +498,35 @@ def optimizer_parameter_groups(
         for name, p in module.named_parameters(recurse=False):
             target_name = f"{prefix}.{name}" if prefix != "" else name
             idx = group_map.get(target_name, idx)
+            is_backbone_param = target_name.startswith("backbone.")
+            if backbone_layer_decay is not None and is_backbone_param is True:
+                backbone_idx = backbone_group_map.get(target_name, backbone_idx)
             if skip_module is True:
                 break
 
             parameters_found = True
             if p.requires_grad is False:
                 continue
-            if layer_decay is not None and layer_decay_no_opt_scale is not None:
-                if layer_scales[idx] < layer_decay_no_opt_scale:
-                    p.requires_grad_(False)
+            if layer_decay_no_opt_scale is not None:
+                if backbone_layer_decay is not None and is_backbone_param is True:
+                    if backbone_layer_scales and backbone_layer_scales[backbone_idx] < layer_decay_no_opt_scale:
+                        p.requires_grad_(False)
+                elif layer_decay is not None:
+                    if layer_scales[idx] < layer_decay_no_opt_scale:
+                        p.requires_grad_(False)
 
             is_custom_key = False
             if custom_keys_weight_decay is not None:
                 for key, custom_wd in custom_keys_weight_decay:
                     target_name_for_custom_key = f"{prefix}.{name}" if prefix != "" and "." in key else name
                     if key == target_name_for_custom_key:
-                        # Calculate lr_scale (from layer_decay or custom_layer_lr_scale)
-                        lr_scale = 1.0 if layer_decay is None else layer_scales[idx]
+                        # Calculate lr_scale (from layer_decay/backbone_layer_decay or custom_layer_lr_scale)
+                        if layer_decay is not None and (backbone_layer_decay is None or is_backbone_param is False):
+                            lr_scale = layer_scales[idx]
+                        elif backbone_layer_decay is not None and is_backbone_param is True:
+                            lr_scale = backbone_layer_scales[backbone_idx]
+                        else:
+                            lr_scale = 1.0
                         if custom_layer_lr_scale is not None:
                             for layer_name_key, custom_scale in custom_layer_lr_scale.items():
                                 if layer_name_key in target_name:
@@ -499,8 +550,8 @@ def optimizer_parameter_groups(
                         # Apply learning rate based on priority: bias_lr > backbone_lr > lr_scale
                         if bias_lr is not None and target_name.endswith(".bias") is True:
                             d["lr"] = bias_lr
-                        elif backbone_lr is not None and target_name.startswith("backbone.") is True:
-                            d["lr"] = backbone_lr
+                        elif backbone_lr is not None and is_backbone_param is True:
+                            d["lr"] = backbone_lr * lr_scale if backbone_layer_decay is not None else backbone_lr
                         elif lr_scale != 1.0:
                             d["lr"] = base_lr * lr_scale
 
@@ -521,8 +572,13 @@ def optimizer_parameter_groups(
                             wd = custom_wd_value
                             break
 
-                # Calculate lr_scale (from layer_decay or custom_layer_lr_scale)
-                lr_scale = 1.0 if layer_decay is None else layer_scales[idx]
+                # Calculate lr_scale (from layer_decay/backbone_layer_decay or custom_layer_lr_scale)
+                if layer_decay is not None and (backbone_layer_decay is None or is_backbone_param is False):
+                    lr_scale = layer_scales[idx]
+                elif backbone_layer_decay is not None and is_backbone_param is True:
+                    lr_scale = backbone_layer_scales[backbone_idx]
+                else:
+                    lr_scale = 1.0
                 if custom_layer_lr_scale is not None:
                     for layer_name_key, custom_scale in custom_layer_lr_scale.items():
                         if layer_name_key in target_name:
@@ -538,8 +594,8 @@ def optimizer_parameter_groups(
                 # Apply learning rate based on priority: bias_lr > backbone_lr > lr_scale
                 if bias_lr is not None and target_name.endswith(".bias") is True:
                     d["lr"] = bias_lr
-                elif backbone_lr is not None and target_name.startswith("backbone.") is True:
-                    d["lr"] = backbone_lr
+                elif backbone_lr is not None and is_backbone_param is True:
+                    d["lr"] = backbone_lr * lr_scale if backbone_layer_decay is not None else backbone_lr
                 elif lr_scale != 1.0:
                     d["lr"] = base_lr * lr_scale
 
@@ -547,6 +603,8 @@ def optimizer_parameter_groups(
 
         if parameters_found is True:
             idx += 1
+            if is_backbone_module is True:
+                backbone_idx += 1
 
         for child_name, child_module in reversed(list(module.named_children())):
             child_prefix = f"{prefix}.{child_name}" if prefix != "" else child_name
@@ -884,6 +942,11 @@ class SmoothedValue:
         self.total: torch.Tensor | float = 0.0
         self.count: int = 0
 
+    def clear(self) -> None:
+        self.deque.clear()
+        self.total = 0.0
+        self.count = 0
+
     def update(self, value: torch.Tensor | float, n: int = 1) -> None:
         self.deque.append(value)
         self.count += n
@@ -927,14 +990,32 @@ class SmoothedValue:
         return to_tensor(v, torch.device("cpu")).item()  # type: ignore[no-any-return]
 
 
-def accuracy(y_true: torch.Tensor, y_pred: torch.Tensor) -> float:
+@torch.no_grad()  # type: ignore[untyped-decorator]
+def accuracy(y_true: torch.Tensor, y_pred: torch.Tensor) -> torch.Tensor:
     if y_pred.dim() > 1 and y_pred.size(1) > 1:
         y_pred = y_pred.argmax(dim=1)
 
     y_true = y_true.flatten()
     y_pred = y_pred.flatten()
 
-    return (y_true == y_pred).float().mean().item()  # type: ignore[no-any-return]
+    return (y_true == y_pred).sum() / y_true.numel()
+
+
+@torch.no_grad()  # type: ignore[untyped-decorator]
+def topk_accuracy(y_true: torch.Tensor, y_pred: torch.Tensor, topk: Sequence[int]) -> list[torch.Tensor]:
+    maxk = min(max(topk), y_pred.size(1))
+    batch_size = y_true.size(0)
+
+    _, pred = y_pred.topk(maxk, dim=1, largest=True, sorted=True)
+    correct = pred.eq(y_true.unsqueeze(1))
+
+    res: list[torch.Tensor] = []
+    for k in topk:
+        k = min(k, maxk)
+        correct_k = correct[:, :k].any(dim=1).sum(dtype=torch.float32)
+        res.append((correct_k / batch_size))
+
+    return res
 
 
 ###############################################################################

{birder-0.4.0 → birder-0.4.2}/birder/data/collators/detection.py

@@ -70,13 +70,21 @@ class BatchRandomResizeCollator(DetectionCollator):
         size: tuple[int, int],
         size_divisible: int = 32,
         multiscale_min_size: Optional[int] = None,
+        multiscale_step: Optional[int] = None,
     ) -> None:
         super().__init__(input_offset, size_divisible=size_divisible)
         if size is None:
             raise ValueError("size must be provided for batch multiscale")
 
         max_side = max(size)
-        sizes = [side for side in build_multiscale_sizes(multiscale_min_size) if side <= max_side]
+        if multiscale_step is None:
+            multiscale_step = size_divisible
+
+        sizes = []
+        for side in build_multiscale_sizes(multiscale_min_size, multiscale_step=multiscale_step):
+            if side <= max_side:
+                sizes.append(side)
+
         if len(sizes) == 0:
             sizes = [max_side]
 

{birder-0.4.0 → birder-0.4.2}/birder/data/transforms/detection.py

@@ -17,17 +17,20 @@ DEFAULT_MULTISCALE_MAX_SIZE = 800
 
 
 def build_multiscale_sizes(
-    min_size: Optional[int] = None, max_size: int = DEFAULT_MULTISCALE_MAX_SIZE
+    min_size: Optional[int] = None, max_size: int = DEFAULT_MULTISCALE_MAX_SIZE, multiscale_step: int = MULTISCALE_STEP
 ) -> tuple[int, ...]:
+    if multiscale_step <= 0:
+        raise ValueError("multiscale_step must be positive")
+
     if min_size is None:
         min_size = DEFAULT_MULTISCALE_MIN_SIZE
 
-    start = int(math.ceil(min_size / MULTISCALE_STEP) * MULTISCALE_STEP)
-    end = int(math.floor(max_size / MULTISCALE_STEP) * MULTISCALE_STEP)
+    start = int(math.ceil(min_size / multiscale_step) * multiscale_step)
+    end = int(math.floor(max_size / multiscale_step) * multiscale_step)
     if end < start:
         return (start,)
 
-    return tuple(range(start, end + 1, MULTISCALE_STEP))
+    return tuple(range(start, end + 1, multiscale_step))
 
 
 class ResizeWithRandomInterpolation(nn.Module):
@@ -59,6 +62,7 @@ def get_birder_augment(
     multiscale: bool,
     max_size: Optional[int],
     multiscale_min_size: Optional[int],
+    multiscale_step: int = MULTISCALE_STEP,
     post_mosaic: bool = False,
 ) -> Callable[..., torch.Tensor]:
     if dynamic_size is True:
@@ -98,7 +102,10 @@ def get_birder_augment(
     # Resize
     if multiscale is True:
         transformations.append(
-            v2.RandomShortestSize(min_size=build_multiscale_sizes(multiscale_min_size), max_size=max_size or 1333),
+            v2.RandomShortestSize(
+                min_size=build_multiscale_sizes(multiscale_min_size, multiscale_step=multiscale_step),
+                max_size=max_size or 1333,
+            ),
         )
     else:
         transformations.append(
@@ -160,6 +167,7 @@ def training_preset(
     multiscale: bool = False,
     max_size: Optional[int] = None,
     multiscale_min_size: Optional[int] = None,
+    multiscale_step: int = MULTISCALE_STEP,
     post_mosaic: bool = False,
 ) -> Callable[..., torch.Tensor]:
     mean = rgv_values["mean"]
@@ -180,7 +188,15 @@ def training_preset(
             [
                 v2.ToImage(),
                 get_birder_augment(
-                    size, level, fill_value, dynamic_size, multiscale, max_size, multiscale_min_size, post_mosaic
+                    size,
+                    level,
+                    fill_value,
+                    dynamic_size,
+                    multiscale,
+                    max_size,
+                    multiscale_min_size,
+                    multiscale_step,
+                    post_mosaic,
                 ),
                 v2.ToDtype(torch.float32, scale=True),
                 v2.Normalize(mean=mean, std=std),
@@ -212,7 +228,10 @@ def training_preset(
         return v2.Compose(  # type: ignore
             [
                 v2.ToImage(),
-                v2.RandomShortestSize(min_size=build_multiscale_sizes(multiscale_min_size), max_size=max_size or 1333),
+                v2.RandomShortestSize(
+                    min_size=build_multiscale_sizes(multiscale_min_size, multiscale_step=multiscale_step),
+                    max_size=max_size or 1333,
+                ),
                 v2.RandomHorizontalFlip(0.5),
                 v2.SanitizeBoundingBoxes(),
                 v2.ToDtype(torch.float32, scale=True),
@@ -284,7 +303,7 @@ def training_preset(
         )
 
     if aug_type == "detr":
-        multiscale_sizes = build_multiscale_sizes(multiscale_min_size)
+        multiscale_sizes = build_multiscale_sizes(multiscale_min_size, multiscale_step=multiscale_step)
         return v2.Compose(  # type: ignore
             [
                 v2.ToImage(),

{birder-0.4.0 → birder-0.4.2}/birder/data/transforms/mosaic.py

@@ -19,7 +19,7 @@ def mosaic_random_center(
     Create a mosaic augmentation by combining 4 images into a single image.
 
     This augmentation places 4 images on a canvas, meeting at a randomly selected
-    center point. Each image is scaled to fit, cropped as needed, and their bounding
+    center point. Each image is scaled to fit, cropped as needed and their bounding
     boxes are transformed accordingly.
 
     Parameters