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

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/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)")
@@ -249,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")
@@ -285,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")
@@ -565,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"
@@ -576,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/common/training_utils.py

@@ -593,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
 

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/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/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)

birder/net/coat.py

@@ -563,24 +563,24 @@ class CoaT(DetectorBackbone):
     def freeze_stages(self, up_to_stage: int) -> None:
         if up_to_stage >= 1:
             for param in self.patch_embed1.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
             for param in self.serial_blocks1.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
         if up_to_stage >= 2:
             for param in self.patch_embed2.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
             for param in self.serial_blocks2.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
         if up_to_stage >= 3:
             for param in self.patch_embed3.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
             for param in self.serial_blocks3.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
         if up_to_stage >= 4:
             for param in self.patch_embed4.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
             for param in self.serial_blocks4.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         features = self._features(x)

birder/net/conv2former.py

@@ -218,14 +218,14 @@ class Conv2Former(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
 
     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 masked_encoding_retention(
         self,

birder/net/convnext_v1.py

@@ -158,14 +158,14 @@ class ConvNeXt_v1(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
 
     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 masked_encoding_retention(
         self,

birder/net/convnext_v2.py

@@ -180,14 +180,14 @@ class ConvNeXt_v2(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
 
     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 masked_encoding_retention(
         self,

birder/net/crossformer.py

@@ -404,14 +404,14 @@ class CrossFormer(DetectorBackbone):
 
     def freeze_stages(self, up_to_stage: int) -> None:
         for param in self.patch_embed.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.patch_embed(x)

birder/net/cspnet.py

@@ -342,14 +342,14 @@ class CSPNet(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/net/cswin_transformer.py

@@ -359,14 +359,14 @@ class CSWin_Transformer(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/net/darknet.py

@@ -115,14 +115,14 @@ class Darknet(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/net/davit.py

@@ -391,14 +391,14 @@ class DaViT(DetectorBackbone, PreTrainEncoder, MaskedTokenRetentionMixin):
 
     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 masked_encoding_retention(
         self,

birder/net/deit.py

@@ -117,14 +117,14 @@ class DeiT(BaseNet):
 
     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)
 
     def set_causal_attention(self, is_causal: bool = True) -> None:
         self.encoder.set_causal_attention(is_causal)

birder/net/deit3.py

@@ -182,16 +182,16 @@ class DeiT3(DetectorBackbone, PreTrainEncoder, MaskedTokenOmissionMixin, MaskedT
 
     def freeze_stages(self, up_to_stage: int) -> None:
         for param in self.conv_proj.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
-        self.pos_embedding.requires_grad = False
+        self.pos_embedding.requires_grad_(False)
 
         for idx, module in enumerate(self.encoder.children()):
             if idx >= up_to_stage:
                 break
 
             for param in module.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
 
     def set_causal_attention(self, is_causal: bool = True) -> None:
         self.encoder.set_causal_attention(is_causal)

birder/net/densenet.py

@@ -140,14 +140,14 @@ class DenseNet(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/net/detection/deformable_detr.py

@@ -633,11 +633,11 @@ class Deformable_DETR(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.class_embed.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def _get_src_permutation_idx(self, indices: list[torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         batch_idx = torch.concat([torch.full_like(src, i) for i, (src, _) in enumerate(indices)])

birder/net/detection/detr.py

@@ -356,11 +356,11 @@ class DETR(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.class_embed.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def _get_src_permutation_idx(self, indices: list[torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         batch_idx = torch.concat([torch.full_like(src, i) for i, (src, _) in enumerate(indices)])

birder/net/detection/efficientdet.py

@@ -601,11 +601,11 @@ class EfficientDet(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.class_net.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def compute_loss(
         self,

birder/net/detection/faster_rcnn.py

@@ -851,11 +851,11 @@ class Faster_RCNN(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.roi_heads.box_predictor.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def forward(
         self,

birder/net/detection/fcos.py

@@ -338,11 +338,11 @@ class FCOS(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.head.classification_head.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def compute_loss(
         self,

birder/net/detection/retinanet.py

@@ -332,11 +332,11 @@ class RetinaNet(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.head.classification_head.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     @torch.jit.unused  # type: ignore[untyped-decorator]
     @torch.compiler.disable()  # type: ignore[untyped-decorator]

birder/net/detection/rt_detr_v1.py

@@ -742,16 +742,16 @@ class RT_DETR_v1(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.decoder.class_embed.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
             for param in self.decoder.enc_score_head.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
             if self.num_denoising > 0:
                 for param in self.denoising_class_embed.parameters():
-                    param.requires_grad = True
+                    param.requires_grad_(True)
 
     def _get_src_permutation_idx(self, indices: list[torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         batch_idx = torch.concat([torch.full_like(src, i) for i, (src, _) in enumerate(indices)])

birder/net/detection/ssd.py

@@ -341,11 +341,11 @@ class SSD(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.head.classification_head.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     # pylint: disable=too-many-locals
     def compute_loss(

birder/net/detection/ssdlite.py

@@ -197,8 +197,8 @@ class SSDLite(SSD):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.head.classification_head.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)

birder/net/detection/yolo_v2.py

@@ -270,11 +270,11 @@ class YOLO_v2(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.head.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def _compute_anchor_iou(self, box_wh: torch.Tensor, anchor_wh: torch.Tensor) -> torch.Tensor:
         """

birder/net/detection/yolo_v3.py

@@ -376,11 +376,11 @@ class YOLO_v3(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.head.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def _compute_anchor_iou(self, box_wh: torch.Tensor, anchor_wh: torch.Tensor) -> torch.Tensor:
         """

birder/net/detection/yolo_v4.py

@@ -444,11 +444,11 @@ class YOLO_v4(DetectionBaseNet):
 
     def freeze(self, freeze_classifier: bool = True) -> None:
         for param in self.parameters():
-            param.requires_grad = False
+            param.requires_grad_(False)
 
         if freeze_classifier is False:
             for param in self.head.parameters():
-                param.requires_grad = True
+                param.requires_grad_(True)
 
     def _compute_anchor_iou(self, box_wh: torch.Tensor, anchor_wh: torch.Tensor) -> torch.Tensor:
         """

birder/net/edgenext.py

@@ -336,14 +336,14 @@ class EdgeNeXt(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/net/edgevit.py

@@ -354,7 +354,7 @@ class EdgeViT(DetectorBackbone):
                 break
 
             for param in module.parameters():
-                param.requires_grad = False
+                param.requires_grad_(False)
 
     def forward_features(self, x: torch.Tensor) -> torch.Tensor:
         return self.body(x)

birder/net/efficientformer_v1.py

@@ -307,18 +307,18 @@ class EfficientFormer_v1(BaseNet):
 
     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 forward_features(self, x: torch.Tensor) -> torch.Tensor:
         x = self.stem(x)