birder 0.2.3__tar.gz → 0.3.1__tar.gz

{birder-0.2.3 → birder-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: birder
-Version: 0.2.3
+Version: 0.3.1
 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
@@ -66,6 +66,7 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: requests~=2.32.5; extra == "dev"
 Requires-Dist: safetensors~=0.7.0; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: torchao~=0.15.0; extra == "dev"
 Requires-Dist: torchprofile==0.0.4; extra == "dev"
 Requires-Dist: twine~=6.2.0; extra == "dev"
 Requires-Dist: types-requests~=2.32.4; extra == "dev"

{birder-0.2.3 → birder-0.3.1}/birder/common/fs_ops.py

@@ -627,7 +627,7 @@ def load_model(
         net.to(dtype)
     if inference is True:
         for param in net.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if pt2 is False:  # NOTE: Remove when GraphModule add support for 'eval'
             net.eval()
@@ -799,7 +799,7 @@ def load_detection_model(
         net.to(dtype)
     if inference is True:
         for param in net.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         net.eval()
 

{birder-0.2.3 → birder-0.3.1}/birder/common/training_cli.py

@@ -39,6 +39,7 @@ def add_optimization_args(parser: argparse.ArgumentParser, default_batch_size: i
     group = parser.add_argument_group("Optimization parameters")
     group.add_argument("--batch-size", type=int, default=default_batch_size, metavar="N", help="the batch size")
     group.add_argument("--opt", type=str, choices=list(get_args(OptimizerType)), default="sgd", help="optimizer to use")
+    group.add_argument("--opt-fused", default=False, action="store_true", help="use fused optimizer implementation")
     group.add_argument("--momentum", type=float, default=0.9, metavar="M", help="optimizer momentum")
     group.add_argument("--nesterov", default=False, action="store_true", help="use nesterov momentum")
     group.add_argument("--opt-eps", type=float, help="optimizer epsilon (None to use the optimizer default)")
@@ -211,6 +212,12 @@ def add_training_schedule_args(parser: argparse.ArgumentParser, default_epochs:
     group.add_argument(
         "--stop-epoch", type=int, metavar="N", help="epoch to stop the training at (multi stage training)"
     )
+    group.add_argument(
+        "--steps-per-epoch",
+        type=int,
+        metavar="N",
+        help="virtual epoch length in steps, leave unset to use the full dataset",
+    )
     group.add_argument("--warmup-epochs", type=int, metavar="N", help="number of warmup epochs")
     group.add_argument("--warmup-steps", type=int, metavar="N", help="number of warmup optimizer steps")
     group.add_argument("--cooldown-epochs", type=int, metavar="N", help="number of cooldown epochs (linear to zero)")
@@ -243,6 +250,7 @@ def add_data_aug_args(
     default_level: int = 4,
     default_min_scale: Optional[float] = None,
     default_re_prob: Optional[float] = None,
+    smoothing_alpha: bool = False,
     mixup_cutmix: bool = False,
 ) -> None:
     group = parser.add_argument_group("Data augmentation parameters")
@@ -279,6 +287,8 @@ def add_data_aug_args(
     group.add_argument(
         "--simple-crop", default=False, action="store_true", help="use simple random crop (SRC) instead of RRC"
     )
+    if smoothing_alpha is True:
+        group.add_argument("--smoothing-alpha", type=float, default=0.0, help="label smoothing alpha")
     if mixup_cutmix is True:
         group.add_argument("--mixup-alpha", type=float, help="mixup alpha")
         group.add_argument("--cutmix", default=False, action="store_true", help="enable cutmix")
@@ -559,9 +569,9 @@ def add_training_data_args(parser: argparse.ArgumentParser, unsupervised: bool =
     group.add_argument("--wds", default=False, action="store_true", help="use webdataset for training")
     group.add_argument("--wds-info", type=str, metavar="FILE", help="wds info file path")
     group.add_argument("--wds-cache-dir", type=str, metavar="DIR", help="webdataset cache directory")
-    group.add_argument("--wds-train-size", type=int, metavar="N", help="size of the wds training set")
     if unsupervised is False:
         group.add_argument("--wds-class-file", type=str, metavar="FILE", help="class list file")
+        group.add_argument("--wds-train-size", type=int, metavar="N", help="size of the wds training set")
         group.add_argument("--wds-val-size", type=int, metavar="N", help="size of the wds validation set")
         group.add_argument(
             "--wds-training-split", type=str, default="training", metavar="NAME", help="wds dataset train split"
@@ -570,6 +580,7 @@ def add_training_data_args(parser: argparse.ArgumentParser, unsupervised: bool =
             "--wds-val-split", type=str, default="validation", metavar="NAME", help="wds dataset validation split"
         )
     else:
+        group.add_argument("--wds-size", type=int, metavar="N", help="size of the wds")
         group.add_argument(
             "--wds-split", type=str, default="training", metavar="NAME", help="wds dataset split to load"
         )

{birder-0.2.3 → birder-0.3.1}/birder/common/training_utils.py

@@ -17,6 +17,7 @@ from typing import Any
 from typing import Literal
 from typing import Optional
 from typing import Sized
+from typing import overload
 
 import numpy as np
 import torch
@@ -70,13 +71,7 @@ class RASampler(torch.utils.data.Sampler):
     """
 
     def __init__(
-        self,
-        dataset: Sized,
-        num_replicas: int,
-        rank: int,
-        shuffle: bool,
-        seed: int = 0,
-        repetitions: int = 3,
+        self, dataset: Sized, num_replicas: int, rank: int, shuffle: bool, seed: int = 0, repetitions: int = 3
     ) -> None:
         super().__init__()
         self.dataset = dataset
@@ -85,12 +80,11 @@ class RASampler(torch.utils.data.Sampler):
         self.epoch = 0
         self.num_samples = int(math.ceil(len(self.dataset) * float(repetitions) / self.num_replicas))
         self.total_size = self.num_samples * self.num_replicas
-        self.num_selected_samples = int(math.floor(len(self.dataset) // 256 * 256 / self.num_replicas))
         self.shuffle = shuffle
         self.seed = seed
         self.repetitions = repetitions
 
-    def __iter__(self) -> Iterator[list[int]]:
+    def __iter__(self) -> Iterator[int]:
         if self.shuffle is True:
             # Deterministically shuffle based on epoch
             g = torch.Generator()
@@ -100,18 +94,148 @@ class RASampler(torch.utils.data.Sampler):
             indices = list(range(len(self.dataset)))
 
         # Add extra samples to make it evenly divisible
-        indices = [ele for ele in indices for i in range(self.repetitions)]
-        indices += indices[: (self.total_size - len(indices))]
-        assert len(indices) == self.total_size
+        indices = [ele for ele in indices for _ in range(self.repetitions)]
+        if len(indices) < self.total_size:
+            indices += indices[: (self.total_size - len(indices))]
+        else:
+            indices = indices[: self.total_size]
 
-        # Subsample
+        # Shard by rank
         indices = indices[self.rank : self.total_size : self.num_replicas]
         assert len(indices) == self.num_samples
 
-        return iter(indices[: self.num_selected_samples])
+        yield from indices
+
+    def __len__(self) -> int:
+        return self.num_samples
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = epoch
+
+
+class InfiniteSampler(torch.utils.data.Sampler):
+    """
+    Infinite sampler that loops indefinitely over the dataset
+    """
+
+    def __init__(self, dataset: Sized, shuffle: bool, seed: int = 0) -> None:
+        super().__init__()
+        self.dataset = dataset
+        self.shuffle = shuffle
+        self.seed = seed
+        self.epoch = 0
+
+    def __iter__(self) -> Iterator[int]:
+        g = torch.Generator()
+        while True:
+            if self.shuffle is True:
+                g.manual_seed(self.seed + self.epoch)
+                indices = torch.randperm(len(self.dataset), generator=g).tolist()
+            else:
+                indices = list(range(len(self.dataset)))
+
+            yield from indices
+
+            logger.debug(f"InfiniteSampler finished epoch {self.epoch}")
+            self.epoch += 1
+
+    def __len__(self) -> int:
+        return len(self.dataset)
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = epoch
+
+
+class InfiniteDistributedSampler(torch.utils.data.Sampler):
+    """
+    Infinite distributed sampler that keeps a continuous shuffled stream per rank
+    """
+
+    def __init__(self, dataset: Sized, num_replicas: int, rank: int, shuffle: bool, seed: int = 0) -> None:
+        super().__init__()
+        self.dataset = dataset
+        self.num_replicas = num_replicas
+        self.rank = rank
+        self.shuffle = shuffle
+        self.seed = seed
+        self.epoch = 0
+        self.num_samples = int(math.ceil(len(self.dataset) / self.num_replicas))
+        self.total_size = self.num_samples * self.num_replicas
+
+    def __iter__(self) -> Iterator[int]:
+        g = torch.Generator()
+        while True:
+            if self.shuffle is True:
+                g.manual_seed(self.seed + self.epoch)
+                indices = torch.randperm(len(self.dataset), generator=g).tolist()
+            else:
+                indices = list(range(len(self.dataset)))
+
+            if len(indices) < self.total_size:
+                indices += indices[: (self.total_size - len(indices))]
+            else:
+                indices = indices[: self.total_size]
+
+            indices = indices[self.rank : self.total_size : self.num_replicas]
+            assert len(indices) == self.num_samples
+
+            yield from indices
+
+            logger.debug(f"InfiniteDistributedSampler finished epoch {self.epoch}")
+            self.epoch += 1
 
     def __len__(self) -> int:
-        return self.num_selected_samples
+        return self.num_samples
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = epoch
+
+
+class InfiniteRASampler(torch.utils.data.Sampler):
+    """
+    Infinite version of the repeated augmentation sampler
+    """
+
+    def __init__(
+        self, dataset: Sized, num_replicas: int, rank: int, shuffle: bool, seed: int = 0, repetitions: int = 3
+    ) -> None:
+        super().__init__()
+        self.dataset = dataset
+        self.num_replicas = num_replicas
+        self.rank = rank
+        self.epoch = 0
+        self.num_samples = int(math.ceil(len(self.dataset) * float(repetitions) / self.num_replicas))
+        self.total_size = self.num_samples * self.num_replicas
+        self.shuffle = shuffle
+        self.seed = seed
+        self.repetitions = repetitions
+
+    def __iter__(self) -> Iterator[int]:
+        g = torch.Generator()
+        while True:
+            if self.shuffle is True:
+                g.manual_seed(self.seed + self.epoch)
+                indices = torch.randperm(len(self.dataset), generator=g).tolist()
+            else:
+                indices = list(range(len(self.dataset)))
+
+            indices = [ele for ele in indices for _ in range(self.repetitions)]
+            if len(indices) < self.total_size:
+                indices += indices[: (self.total_size - len(indices))]
+            else:
+                indices = indices[: self.total_size]
+
+            # Shard by rank
+            indices = indices[self.rank : self.total_size : self.num_replicas]
+            assert len(indices) == self.num_samples
+
+            yield from indices
+
+            logger.debug(f"InfiniteRASampler finished epoch {self.epoch}")
+            self.epoch += 1
+
+    def __len__(self) -> int:
+        return self.num_samples
 
     def set_epoch(self, epoch: int) -> None:
         self.epoch = epoch
@@ -469,12 +593,14 @@ def get_optimizer(parameters: list[dict[str, Any]], l_rate: float, args: argpars
         kwargs["betas"] = args.opt_betas
     if getattr(args, "opt_alpha", None) is not None:
         kwargs["alpha"] = args.opt_alpha
+    if getattr(args, "opt_fused", False) is True:
+        kwargs["fused"] = True
 
     # For optimizer compilation
     # lr = torch.tensor(l_rate) - Causes weird LR scheduling bugs
     lr = l_rate
-    if getattr(args, "compile_opt", False) is not False:
-        if opt not in ("lamb", "lambw", "lars"):
+    if getattr(args, "compile_opt", False) is True:
+        if opt not in ("sgd", "lamb", "lambw", "lars"):
             logger.debug("Setting optimizer capturable to True")
             kwargs["capturable"] = True
 
@@ -636,27 +762,87 @@ def get_amp_scaler(amp: bool, amp_dtype_str: str) -> tuple[Optional[torch.amp.Gr
     return (scaler, amp_dtype)
 
 
+@overload
 def get_samplers(
-    args: argparse.Namespace, training_dataset: torch.utils.data.Dataset, validation_dataset: torch.utils.data.Dataset
-) -> torch.utils.data.Sampler:
-    if args.distributed is True:
-        if args.ra_sampler is True:
-            train_sampler = RASampler(
-                training_dataset,
-                num_replicas=args.world_size,
-                rank=args.rank,
-                shuffle=True,
-                repetitions=args.ra_reps,
-            )
+    args: argparse.Namespace,
+    training_dataset: torch.utils.data.Dataset,
+    validation_dataset: torch.utils.data.Dataset,
+    infinite: bool = False,
+) -> tuple[torch.utils.data.Sampler, torch.utils.data.Sampler]: ...
 
-        else:
-            train_sampler = torch.utils.data.distributed.DistributedSampler(training_dataset, shuffle=True)
 
-        validation_sampler = torch.utils.data.distributed.DistributedSampler(validation_dataset, shuffle=False)
+@overload
+def get_samplers(
+    args: argparse.Namespace,
+    training_dataset: torch.utils.data.Dataset,
+    validation_dataset: None = None,
+    infinite: bool = False,
+) -> tuple[torch.utils.data.Sampler, None]: ...
+
+
+def get_samplers(
+    args: argparse.Namespace,
+    training_dataset: torch.utils.data.Dataset,
+    validation_dataset: Optional[torch.utils.data.Dataset] = None,
+    infinite: bool = False,
+) -> tuple[torch.utils.data.Sampler, Optional[torch.utils.data.Sampler]]:
+    if args.seed is None:
+        seed = int(torch.empty((), dtype=torch.int64).random_().item())
+        if is_dist_available_and_initialized() is True:
+            seed_tensor = torch.tensor(seed, dtype=torch.int64).cuda()
+            dist.broadcast(seed_tensor, src=0, async_op=False)
+            seed = int(seed_tensor.item())
+    else:
+        seed = args.seed
+
+    ra_sampler = getattr(args, "ra_sampler", False)
+    if args.distributed is True:
+        if infinite is True:
+            if ra_sampler is True:
+                train_sampler = InfiniteRASampler(
+                    training_dataset,
+                    num_replicas=args.world_size,
+                    rank=args.rank,
+                    shuffle=True,
+                    seed=seed,
+                    repetitions=args.ra_reps,
+                )
+            else:
+                train_sampler = InfiniteDistributedSampler(
+                    training_dataset, num_replicas=args.world_size, rank=args.rank, shuffle=True, seed=seed
+                )
+        else:
+            if ra_sampler is True:
+                train_sampler = RASampler(
+                    training_dataset,
+                    num_replicas=args.world_size,
+                    rank=args.rank,
+                    shuffle=True,
+                    seed=seed,
+                    repetitions=args.ra_reps,
+                )
+            else:
+                train_sampler = torch.utils.data.distributed.DistributedSampler(
+                    training_dataset, shuffle=True, seed=seed
+                )
+
+        if validation_dataset is None:
+            validation_sampler = None
+        else:
+            validation_sampler = torch.utils.data.distributed.DistributedSampler(validation_dataset, shuffle=False)
 
     else:
-        train_sampler = torch.utils.data.RandomSampler(training_dataset)
-        validation_sampler = torch.utils.data.SequentialSampler(validation_dataset)
+        if infinite is True:
+            train_sampler = InfiniteSampler(training_dataset, shuffle=True, seed=seed)
+        else:
+            generator = torch.Generator()
+            generator.manual_seed(seed)
+            train_sampler = torch.utils.data.RandomSampler(training_dataset, generator=generator)
+
+        if validation_dataset is None:
+            validation_sampler = None
+        else:
+            validation_sampler = torch.utils.data.SequentialSampler(validation_dataset)
 
     return (train_sampler, validation_sampler)
 

{birder-0.2.3 → birder-0.3.1}/birder/data/collators/detection.py

@@ -98,6 +98,7 @@ class BatchRandomResizeCollator(DetectionCollator):
                 if isinstance(boxes, tv_tensors.BoundingBoxes) is False:
                     if boxes.numel() == 0:
                         boxes = boxes.reshape(0, 4)
+
                     boxes = tv_tensors.BoundingBoxes(
                         boxes, format=tv_tensors.BoundingBoxFormat.XYXY, canvas_size=F.get_size(image)
                     )

{birder-0.2.3 → birder-0.3.1}/birder/data/dataloader/webdataset.py

@@ -22,9 +22,19 @@ def make_wds_loader(
     shuffle: bool = False,
     *,
     exact: bool = False,
+    infinite: bool = False,
 ) -> DataLoader:
+    assert exact is False or infinite is False
+
+    if infinite is True:
+        dataset_iterable = dataset.repeat()
+    elif exact is False:
+        dataset_iterable = dataset.repeat()
+    else:
+        dataset_iterable = dataset
+
     dataloader = wds.WebLoader(
-        dataset.repeat() if exact is False else dataset,
+        dataset_iterable,
         batch_size=batch_size,
         num_workers=num_workers,
         prefetch_factor=prefetch_factor,
@@ -43,7 +53,7 @@ def make_wds_loader(
         epoch_size = math.ceil(len(dataset) / (batch_size * world_size))
 
     dataloader = dataloader.with_length(epoch_size, silent=True)
-    if exact is False:
+    if exact is False and infinite is False:
         dataloader = dataloader.with_epoch(epoch_size)
 
     return dataloader

{birder-0.2.3 → birder-0.3.1}/birder/kernels/load_kernel.py

@@ -14,11 +14,24 @@ logger = logging.getLogger(__name__)
 
 
 _CACHED_KERNELS: dict[str, ModuleType] = {}
+_CUSTOM_KERNELS_ENABLED = True
+
+
+def set_custom_kernels_enabled(enabled: bool) -> None:
+    global _CUSTOM_KERNELS_ENABLED  # pylint: disable=global-statement
+    _CUSTOM_KERNELS_ENABLED = enabled
+
+
+def is_custom_kernels_enabled() -> bool:
+    if os.environ.get("DISABLE_CUSTOM_KERNELS", "0") == "1":
+        return False
+
+    return _CUSTOM_KERNELS_ENABLED
 
 
 def load_msda() -> Optional[ModuleType]:
     name = "msda"
-    if torch.cuda.is_available() is False or os.environ.get("DISABLE_CUSTOM_KERNELS", "0") == "1":
+    if torch.cuda.is_available() is False or is_custom_kernels_enabled() is False:
         return None
 
     if name in _CACHED_KERNELS:
@@ -60,7 +73,7 @@ def load_msda() -> Optional[ModuleType]:
 
 def load_swattention() -> Optional[ModuleType]:
     name = "swattention"
-    if torch.cuda.is_available() is False or os.environ.get("DISABLE_CUSTOM_KERNELS", "0") == "1":
+    if torch.cuda.is_available() is False or is_custom_kernels_enabled() is False:
         return None
 
     if name in _CACHED_KERNELS:
@@ -103,7 +116,7 @@ def load_swattention() -> Optional[ModuleType]:
 
 def load_soft_nms() -> Optional[ModuleType]:
     name = "soft_nms"
-    if os.environ.get("DISABLE_CUSTOM_KERNELS", "0") == "1":
+    if is_custom_kernels_enabled() is False:
         return None
 
     if name in _CACHED_KERNELS:
@@ -120,14 +133,6 @@ def load_soft_nms() -> Optional[ModuleType]:
         soft_nms: Optional[ModuleType] = load(
             "soft_nms",
             src_files,
-            with_cuda=True,
-            extra_cflags=["-DWITH_CUDA=1"],
-            extra_cuda_cflags=[
-                "-DCUDA_HAS_FP16=1",
-                "-D__CUDA_NO_HALF_OPERATORS__",
-                "-D__CUDA_NO_HALF_CONVERSIONS__",
-                "-D__CUDA_NO_HALF2_OPERATORS__",
-            ],
         )
 
     if soft_nms is not None:

{birder-0.2.3 → birder-0.3.1}/birder/kernels/soft_nms/soft_nms.cpp

@@ -61,24 +61,23 @@ void update_sorting_order(torch::Tensor& boxes, torch::Tensor& scores, torch::Te
     std::tie(max_score, t_max_idx) = torch::max(scores.index({Slice(idx + 1, None)}), 0);
 
     // max_idx is computed from sliced data, therefore need to convert it to "global" max idx
-    auto max_idx = t_max_idx.item<int>() + idx + 1;
-
-    if (scores.index({idx}).item<float>() < max_score.item<float>()) {
-        auto boxes_idx = boxes.index({idx}).clone();
-        auto boxes_max = boxes.index({max_idx}).clone();
-        boxes.index({idx}) = boxes_max;
-        boxes.index({max_idx}) = boxes_idx;
-
-        auto scores_idx = scores.index({idx}).clone();
-        auto scores_max = scores.index({max_idx}).clone();
-        scores.index({idx}) = scores_max;
-        scores.index({max_idx}) = scores_idx;
-
-        auto areas_idx = areas.index({idx}).clone();
-        auto areas_max = areas.index({max_idx}).clone();
-        areas.index({idx}) = areas_max;
-        areas.index({max_idx}) = areas_idx;
-    }
+    auto max_idx = t_max_idx + (idx + 1);
+    auto should_swap = scores.index({idx}) < max_score;
+
+    auto boxes_idx = boxes.index({idx}).clone();
+    auto boxes_max = boxes.index({max_idx}).clone();
+    boxes.index_put_({idx}, torch::where(should_swap, boxes_max, boxes_idx));
+    boxes.index_put_({max_idx}, torch::where(should_swap, boxes_idx, boxes_max));
+
+    auto scores_idx = scores.index({idx}).clone();
+    auto scores_max = scores.index({max_idx}).clone();
+    scores.index_put_({idx}, torch::where(should_swap, scores_max, scores_idx));
+    scores.index_put_({max_idx}, torch::where(should_swap, scores_idx, scores_max));
+
+    auto areas_idx = areas.index({idx}).clone();
+    auto areas_max = areas.index({max_idx}).clone();
+    areas.index_put_({idx}, torch::where(should_swap, areas_max, areas_idx));
+    areas.index_put_({max_idx}, torch::where(should_swap, areas_idx, areas_max));
 }
 
 std::tuple<torch::Tensor, torch::Tensor> soft_nms(

{birder-0.2.3 → birder-0.3.1}/birder/net/base.py

@@ -173,14 +173,14 @@ class BaseNet(nn.Module):
 
     def freeze(self, freeze_classifier: bool = True, unfreeze_features: bool = False) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.classifier.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
         if unfreeze_features is True and hasattr(self, "features") is True:
             for param in self.features.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         """

{birder-0.2.3 → birder-0.3.1}/birder/net/biformer.py

@@ -468,14 +468,14 @@ class BiFormer(DetectorBackbone):
 
     def freeze_stages(self, up_to_stage: int) -> None:
         for param in self.stem.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         for idx, module in enumerate(self.body.children()):
             if idx >= up_to_stage:
                 break
 
             for param in module.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         x = self.stem(x)

{birder-0.2.3 → birder-0.3.1}/birder/net/cait.py

@@ -268,14 +268,15 @@ class CaiT(BaseNet):
         super().adjust_size(new_size)
 
         # Add back class tokens
-        self.pos_embed = nn.Parameter(
-            adjust_position_embedding(
+        with torch.no_grad():
+            pos_embed = adjust_position_embedding(
                 self.pos_embed,
                 (old_size[0] // self.patch_size[0], old_size[1] // self.patch_size[1]),
                 (new_size[0] // self.patch_size[0], new_size[1] // self.patch_size[1]),
                 0,
             )
-        )
+
+        self.pos_embed = nn.Parameter(pos_embed)
 
 
 registry.register_model_config(

{birder-0.2.3 → birder-0.3.1}/birder/net/cas_vit.py

@@ -269,18 +269,18 @@ class CAS_ViT(DetectorBackbone):
 
     def freeze(self, freeze_classifier: bool = True, unfreeze_features: bool = False) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.classifier.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
             for param in self.dist_classifier.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
         if unfreeze_features is True:
             for param in self.features.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def transform_to_backbone(self) -> None:
         self.features = nn.Identity()
@@ -300,14 +300,14 @@ class CAS_ViT(DetectorBackbone):
 
     def freeze_stages(self, up_to_stage: int) -> None:
         for param in self.stem.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         for idx, module in enumerate(self.body.children()):
             if idx >= up_to_stage:
                 break
 
             for param in module.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         x = self.stem(x)