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

birder/scripts/train_kd.py

@@ -356,7 +356,7 @@ def train(args: argparse.Namespace) -> None:
 
     # Distillation
     if distillation_type == "soft":
-        distillation_criterion = torch.nn.KLDivLoss(reduction="batchmean", log_target=False)
+        distillation_criterion = torch.nn.KLDivLoss(reduction="batchmean", log_target=True)
     elif distillation_type == "hard":
         distillation_criterion = torch.nn.CrossEntropyLoss()
     elif distillation_type == "deit":
@@ -567,6 +567,11 @@ def train(args: argparse.Namespace) -> None:
     if virtual_epoch_mode is True:
         train_iter = iter(training_loader)
 
+    running_loss = training_utils.SmoothedValue(window_size=64)
+    running_val_loss = training_utils.SmoothedValue()
+    train_accuracy = training_utils.SmoothedValue(window_size=64)
+    val_accuracy = training_utils.SmoothedValue()
+
     logger.info(f"Starting training with learning rate of {last_lr}")
     for epoch in range(begin_epoch, args.stop_epoch):
         tic = time.time()
@@ -574,11 +579,6 @@ def train(args: argparse.Namespace) -> None:
         if embedding_projection is not None:
             embedding_projection.train()
 
-        running_loss = training_utils.SmoothedValue(window_size=64)
-        running_val_loss = training_utils.SmoothedValue()
-        train_accuracy = training_utils.SmoothedValue(window_size=64)
-        val_accuracy = training_utils.SmoothedValue()
-
         if args.distributed is True or virtual_epoch_mode is True:
             train_sampler.set_epoch(epoch)
 
@@ -625,7 +625,7 @@ def train(args: argparse.Namespace) -> None:
                     with torch.no_grad():
                         teacher_outputs = teacher(inputs)
                         if distillation_type == "soft":
-                            teacher_targets = F.softmax(teacher_outputs / args.temperature, dim=-1)
+                            teacher_targets = F.log_softmax(teacher_outputs / args.temperature, dim=-1)
                         else:
                             teacher_targets = teacher_outputs.argmax(dim=-1)
 
@@ -695,7 +695,7 @@ def train(args: argparse.Namespace) -> None:
             train_accuracy.update(training_utils.accuracy(targets, outputs.detach()))
 
             # Write statistics
-            if i % args.log_interval == 0 or i == last_batch_idx:
+            if (i % args.log_interval == 0 and i > 0) or i == last_batch_idx:
                 time_now = time.time()
                 time_cost = time_now - start_time
                 iters_processed_in_interval = i - last_idx
@@ -900,43 +900,44 @@ def get_args_parser() -> argparse.ArgumentParser:
             "A typical 'soft' distillation:\n"
             "torchrun --nproc_per_node=2 train_kd.py \\\n"
             "    --type soft \\\n"
-            "    --temperature 1 \\\n"
             "    --teacher vit_l16 \\\n"
             "    --student tiny_vit_5m \\\n"
+            "    --temperature 3.5 \\\n"
+            "    --batch-size 32 \\\n"
             "    --opt adamw \\\n"
+            "    --clip-grad-norm 5 \\\n"
             "    --lr 0.002 \\\n"
+            "    --wd 0.01 \\\n"
+            "    --norm-wd 0 \\\n"
             "    --lr-scheduler cosine \\\n"
             "    --lr-cosine-min 1e-7 \\\n"
-            "    --batch-size 64 \\\n"
             "    --warmup-epochs 5 \\\n"
-            "    --wd 0.01 \\\n"
-            "    --norm-wd 0 \\\n"
             "    --smoothing-alpha 0.1 \\\n"
-            "    --clip-grad-norm 5 \\\n"
-            "    --amp \\\n"
+            "    --amp --amp-dtype bfloat16 \\\n"
             "    --compile \\\n"
             "    --wds \\\n"
-            "    --wds-class-file data/intermediate_packed/classes.txt \\\n"
-            "    --wds-info data/intermediate_packed/_info.json\n"
+            "    --wds-info data/intermediate_packed/_info.json \\\n"
+            "    --wds-class-file data/intermediate_packed/classes.txt\n"
             "\n"
-            "DeiT style distillation:\n"
+            "DeiT-style distillation:\n"
             "torchrun --nproc_per_node=2 train_kd.py \\\n"
             "    --type deit \\\n"
             "    --teacher regnet_y_8g \\\n"
             "    --student deit_s16 \\\n"
+            "    --batch-size 64 \\\n"
             "    --opt adamw \\\n"
+            "    --clip-grad-norm 1 \\\n"
             "    --lr 0.0005 \\\n"
-            "    --lr-scheduler cosine \\\n"
-            "    --warmup-epochs 5 \\\n"
-            "    --epochs 300 \\\n"
             "    --wd 0.05 \\\n"
             "    --norm-wd 0 \\\n"
+            "    --lr-scheduler cosine \\\n"
+            "    --epochs 300 \\\n"
+            "    --warmup-epochs 5 \\\n"
+            "    --aug-level 8 \\\n"
             "    --smoothing-alpha 0.1 \\\n"
             "    --mixup-alpha 0.8 \\\n"
-            "    --aug-level 8 \\\n"
             "    --model-ema \\\n"
             "    --ra-sampler --ra-reps 2 \\\n"
-            "    --clip-grad-norm 1 \\\n"
             "    --amp \\\n"
             "    --compile\n"
         ),
@@ -944,6 +945,7 @@ def get_args_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument("--type", type=str, choices=typing.get_args(DistType), help="type of distillation")
     parser.add_argument("--teacher", type=str, help="the teacher network")
+    parser.add_argument("--teacher-tag", type=str, help="teacher training log tag (loading only)")
     parser.add_argument(
         "--teacher-model-config",
         action=cli.FlexibleDictAction,
@@ -952,11 +954,11 @@ def get_args_parser() -> argparse.ArgumentParser:
             "('drop_path_rate=0.2' or '{\"units\": [3, 24, 36, 3], \"dropout\": 0.2}'"
         ),
     )
-    parser.add_argument("--teacher-tag", type=str, help="teacher training log tag (loading only)")
     parser.add_argument("--pts", default=False, action="store_true", help="load torchscript teacher")
     parser.add_argument("--pt2", default=False, action="store_true", help="load pt2 teacher")
     parser.add_argument("--teacher-epoch", type=int, help="load teacher weights from selected epoch")
     parser.add_argument("--student", type=str, help="the student network to train")
+    parser.add_argument("--student-tag", type=str, help="add student training logs tag")
     parser.add_argument(
         "--student-model-config",
         action=cli.FlexibleDictAction,
@@ -965,7 +967,6 @@ def get_args_parser() -> argparse.ArgumentParser:
             "('drop_path_rate=0.2' or '{\"units\": [3, 24, 36, 3], \"dropout\": 0.2}'"
         ),
     )
-    parser.add_argument("--student-tag", type=str, help="add student training logs tag")
     parser.add_argument(
         "--temperature",
         type=float,

birder/scripts/train_mim.py

@@ -368,11 +368,12 @@ def train(args: argparse.Namespace) -> None:
     if virtual_epoch_mode is True:
         train_iter = iter(training_loader)
 
+    running_loss = training_utils.SmoothedValue()
+
     logger.info(f"Starting training with learning rate of {last_lr}")
     for epoch in range(begin_epoch, args.stop_epoch):
         tic = time.time()
         net.train()
-        running_loss = training_utils.SmoothedValue()
 
         if args.distributed is True or virtual_epoch_mode is True:
             train_sampler.set_epoch(epoch)
@@ -436,7 +437,7 @@ def train(args: argparse.Namespace) -> None:
             running_loss.update(loss.detach())
 
             # Write statistics
-            if i % args.log_interval == 0 or i == last_batch_idx:
+            if (i % args.log_interval == 0 and i > 0) or i == last_batch_idx:
                 time_now = time.time()
                 time_cost = time_now - start_time
                 iters_processed_in_interval = i - last_idx
@@ -578,6 +579,7 @@ def get_args_parser() -> argparse.ArgumentParser:
         formatter_class=cli.ArgumentHelpFormatter,
     )
     parser.add_argument("-n", "--network", type=str, help="the neural network to use")
+    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     parser.add_argument(
         "--model-config",
         action=cli.FlexibleDictAction,
@@ -586,7 +588,6 @@ def get_args_parser() -> argparse.ArgumentParser:
             "('drop_path_rate=0.2' or '{\"units\": [3, 24, 36, 3], \"dropout\": 0.2}'"
         ),
     )
-    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     parser.add_argument("--encoder", type=str, help="the neural network to used as encoder (network being pre-trained)")
     parser.add_argument(
         "--encoder-model-config",

birder/scripts/train_mmcr.py

@@ -370,11 +370,12 @@ def train(args: argparse.Namespace) -> None:
     if virtual_epoch_mode is True:
         train_iter = iter(training_loader)
 
+    running_loss = training_utils.SmoothedValue()
+
     logger.info(f"Starting training with learning rate of {last_lr}")
     for epoch in range(begin_epoch, args.stop_epoch):
         tic = time.time()
         net.train()
-        running_loss = training_utils.SmoothedValue()
 
         if args.distributed is True or virtual_epoch_mode is True:
             train_sampler.set_epoch(epoch)
@@ -447,7 +448,7 @@ def train(args: argparse.Namespace) -> None:
             running_loss.update(loss.detach())
 
             # Write statistics
-            if i % args.log_interval == 0 or i == last_batch_idx:
+            if (i % args.log_interval == 0 and i > 0) or i == last_batch_idx:
                 time_now = time.time()
                 time_cost = time_now - start_time
                 iters_processed_in_interval = i - last_idx
@@ -587,6 +588,7 @@ def get_args_parser() -> argparse.ArgumentParser:
         formatter_class=cli.ArgumentHelpFormatter,
     )
     parser.add_argument("-n", "--network", type=str, help="the neural network to train")
+    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     parser.add_argument(
         "--model-config",
         action=cli.FlexibleDictAction,
@@ -606,7 +608,6 @@ def get_args_parser() -> argparse.ArgumentParser:
     parser.add_argument("--lambda-coeff", type=float, default=0.0, help="weight of local nuc")
     parser.add_argument("--n-aug", type=int, default=2, help="number of views")
     parser.add_argument("--momentum-tau", type=float, default=0.99, help="base EMA parameter for momentum update")
-    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     training_cli.add_optimization_args(parser)
     training_cli.add_lr_wd_args(parser)
     training_cli.add_lr_scheduler_args(parser)

birder/scripts/train_rotnet.py

@@ -381,12 +381,13 @@ def train(args: argparse.Namespace) -> None:
     if virtual_epoch_mode is True:
         train_iter = iter(training_loader)
 
+    running_loss = training_utils.SmoothedValue(window_size=64)
+    train_accuracy = training_utils.SmoothedValue(window_size=64)
+
     logger.info(f"Starting training with learning rate of {last_lr}")
     for epoch in range(begin_epoch, args.stop_epoch):
         tic = time.time()
         net.train()
-        running_loss = training_utils.SmoothedValue(window_size=64)
-        train_accuracy = training_utils.SmoothedValue(window_size=64)
 
         if args.distributed is True or virtual_epoch_mode is True:
             train_sampler.set_epoch(epoch)
@@ -455,7 +456,7 @@ def train(args: argparse.Namespace) -> None:
             train_accuracy.update(training_utils.accuracy(targets, outputs.detach()))
 
             # Write statistics
-            if i % args.log_interval == 0 or i == last_batch_idx:
+            if (i % args.log_interval == 0 and i > 0) or i == last_batch_idx:
                 time_now = time.time()
                 time_cost = time_now - start_time
                 iters_processed_in_interval = i - last_idx
@@ -580,6 +581,7 @@ def get_args_parser() -> argparse.ArgumentParser:
         formatter_class=cli.ArgumentHelpFormatter,
     )
     parser.add_argument("-n", "--network", type=str, help="the neural network to train")
+    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     parser.add_argument(
         "--model-config",
         action=cli.FlexibleDictAction,
@@ -594,7 +596,6 @@ def get_args_parser() -> argparse.ArgumentParser:
         default=0.75,
         help="probability of applying a non-zero rotation (90, 180, or 270 degrees)",
     )
-    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     parser.add_argument(
         "--freeze-body",
         default=False,

birder/scripts/train_simclr.py

@@ -363,11 +363,12 @@ def train(args: argparse.Namespace) -> None:
     if virtual_epoch_mode is True:
         train_iter = iter(training_loader)
 
+    running_loss = training_utils.SmoothedValue()
+
     logger.info(f"Starting training with learning rate of {last_lr}")
     for epoch in range(begin_epoch, args.stop_epoch):
         tic = time.time()
         net.train()
-        running_loss = training_utils.SmoothedValue()
 
         if args.distributed is True or virtual_epoch_mode is True:
             train_sampler.set_epoch(epoch)
@@ -431,7 +432,7 @@ def train(args: argparse.Namespace) -> None:
             running_loss.update(loss.detach())
 
             # Write statistics
-            if i % args.log_interval == 0 or i == last_batch_idx:
+            if (i % args.log_interval == 0 and i > 0) or i == last_batch_idx:
                 time_now = time.time()
                 time_cost = time_now - start_time
                 iters_processed_in_interval = i - last_idx
@@ -572,6 +573,7 @@ def get_args_parser() -> argparse.ArgumentParser:
         formatter_class=cli.ArgumentHelpFormatter,
     )
     parser.add_argument("-n", "--network", type=str, help="the neural network to train")
+    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     parser.add_argument(
         "--model-config",
         action=cli.FlexibleDictAction,
@@ -582,7 +584,6 @@ def get_args_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument("--projection-dim", type=int, default=128, metavar="DIM", help="projection dim")
     parser.add_argument("--temperature", type=float, default=0.1, help="loss temperature")
-    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     training_cli.add_optimization_args(parser)
     training_cli.add_lr_wd_args(parser)
     training_cli.add_lr_scheduler_args(parser)

birder/scripts/train_vicreg.py

@@ -369,11 +369,12 @@ def train(args: argparse.Namespace) -> None:
     if virtual_epoch_mode is True:
         train_iter = iter(training_loader)
 
+    running_loss = training_utils.SmoothedValue()
+
     logger.info(f"Starting training with learning rate of {last_lr}")
     for epoch in range(begin_epoch, args.stop_epoch):
         tic = time.time()
         net.train()
-        running_loss = training_utils.SmoothedValue()
 
         if args.distributed is True or virtual_epoch_mode is True:
             train_sampler.set_epoch(epoch)
@@ -437,7 +438,7 @@ def train(args: argparse.Namespace) -> None:
             running_loss.update(loss.detach())
 
             # Write statistics
-            if i % args.log_interval == 0 or i == last_batch_idx:
+            if (i % args.log_interval == 0 and i > 0) or i == last_batch_idx:
                 time_now = time.time()
                 time_cost = time_now - start_time
                 iters_processed_in_interval = i - last_idx
@@ -577,6 +578,7 @@ def get_args_parser() -> argparse.ArgumentParser:
         formatter_class=cli.ArgumentHelpFormatter,
     )
     parser.add_argument("-n", "--network", type=str, help="the neural network to train")
+    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     parser.add_argument(
         "--model-config",
         action=cli.FlexibleDictAction,
@@ -589,7 +591,6 @@ def get_args_parser() -> argparse.ArgumentParser:
     parser.add_argument("--sim-coeff", type=float, default=25.0, help="invariance regularization loss coefficient")
     parser.add_argument("--std-coeff", type=float, default=25.0, help="variance regularization loss coefficient")
     parser.add_argument("--cov-coeff", type=float, default=1.0, help="covariance regularization loss coefficient")
-    parser.add_argument("-t", "--tag", type=str, help="add model tag")
     training_cli.add_optimization_args(parser)
     training_cli.add_lr_wd_args(parser)
     training_cli.add_lr_scheduler_args(parser)

birder/tools/avg_model.py

@@ -15,12 +15,15 @@ from birder.net.base import SignatureType
 logger = logging.getLogger(__name__)
 
 
-def avg_models(network: str, tag: Optional[str], reparameterized: bool, epochs: list[int], force: bool) -> None:
+# pylint: disable=too-many-locals
+def avg_models(
+    network: str, tag: Optional[str], reparameterized: bool, epochs: list[int], accum_dtype: torch.dtype, force: bool
+) -> None:
     device = torch.device("cpu")
+    network_name = get_network_name(network, tag)
     state_list = []
     aux_data = {}
     for idx, epoch in enumerate(epochs):
-        network_name = get_network_name(network, tag)
         path = fs_ops.model_path(network_name, epoch=epoch)
         logger.info(f"Loading model from {path}...")
 
@@ -51,12 +54,18 @@ def avg_models(network: str, tag: Optional[str], reparameterized: bool, epochs:
     logger.info("Calculating averages...")
     avg_state = {}
     for state_name in state_list[0]:
-        params = torch.empty((len(state_list),) + state_list[0][state_name].size())
+        t0 = state_list[0][state_name]
+        if torch.is_floating_point(t0) is True:
+            params = torch.empty((len(state_list),) + t0.size(), dtype=accum_dtype)
 
-        for idx, state in enumerate(state_list):
-            params[idx] = state[state_name]
+            for idx, state in enumerate(state_list):
+                params[idx] = state[state_name].to(accum_dtype)
 
-        avg_state[state_name] = params.mean(axis=0)
+            avg_state[state_name] = params.mean(dim=0).to(dtype=t0.dtype)
+        else:
+            # For int/bool buffers (e.g. num_batches_tracked / relative_position_index), averaging is not meaningful
+            logger.info(f"Not averaging non-floating state entry: {state_name} (dtype={t0.dtype})")
+            avg_state[state_name] = t0
 
     net.load_state_dict(avg_state)
 
@@ -86,7 +95,7 @@ def set_parser(subparsers: Any) -> None:
         epilog=(
             "Usage examples:\n"
             "python -m birder.tools avg-model --network efficientnet_v2_m --epochs 290 295 300\n"
-            "python -m birder.tools avg-model --network shufflenet_v2_2_0 --epochs 95 100 100\n"
+            "python -m birder.tools avg-model --network shufflenet_v2_2_0 --epochs 95 100 100 --accum-dtype float64\n"
         ),
         formatter_class=cli.ArgumentHelpFormatter,
     )
@@ -98,9 +107,16 @@ def set_parser(subparsers: Any) -> None:
     subparser.add_argument(
         "-r", "--reparameterized", default=False, action="store_true", help="load reparameterized model"
     )
+    subparser.add_argument(
+        "--accum-dtype",
+        choices=["float32", "float64"],
+        default="float32",
+        help="dtype used for averaging floating tensors",
+    )
     subparser.add_argument("--force", action="store_true", help="override existing model")
     subparser.set_defaults(func=main)
 
 
 def main(args: argparse.Namespace) -> None:
-    avg_models(args.network, args.tag, args.reparameterized, args.epochs, args.force)
+    accum_dtype: torch.dtype = getattr(torch, args.accum_dtype)
+    avg_models(args.network, args.tag, args.reparameterized, args.epochs, accum_dtype, args.force)

birder/tools/introspection.py

@@ -10,6 +10,7 @@ from birder.common import fs_ops
 from birder.common import lib
 from birder.data.transforms.classification import inference_preset
 from birder.introspection import AttentionRollout
+from birder.introspection import FeaturePCA
 from birder.introspection import GradCAM
 from birder.introspection import GuidedBackprop
 from birder.introspection import TransformerAttribution
@@ -23,10 +24,7 @@ def _nhwc_reshape_transform(tensor: torch.Tensor) -> torch.Tensor:
 
 
 def _show_attn_rollout(
-    args: argparse.Namespace,
-    net: BaseNet,
-    transform: Callable[..., torch.Tensor],
-    device: torch.device,
+    args: argparse.Namespace, net: BaseNet, transform: Callable[..., torch.Tensor], device: torch.device
 ) -> None:
     ar = AttentionRollout(net, device, transform, args.attn_layer_name, args.discard_ratio, args.head_fusion)
     result = ar(args.image_path)
@@ -92,6 +90,16 @@ def _show_grad_cam(
     result.show()
 
 
+def _show_feature_pca(
+    args: argparse.Namespace, net: BaseNet, transform: Callable[..., torch.Tensor], device: torch.device
+) -> None:
+    feature_pca = FeaturePCA(
+        net, device, transform, args.normalize_features, channels_last=args.channels_last, stage=args.stage
+    )
+    result = feature_pca(args.image_path)
+    result.show()
+
+
 def set_parser(subparsers: Any) -> None:
     subparser = subparsers.add_parser(
         "introspection",
@@ -102,6 +110,8 @@ def set_parser(subparsers: Any) -> None:
             "Usage examples:\n"
             "python -m birder.tools introspection --network efficientnet_v2_m -e 200 --method gradcam "
             "'data/training/European goldfinch/000300.jpeg'\n"
+            "python -m birder.tools introspection -n convnext_v2_tiny -t vicreg --method feature-pca "
+            "--normalize-features --stage stage2 data/validation/Mallard/000015.jpeg\n"
             "python -m birder.tools introspection -n resnest_50 --epoch 300 --method gradcam "
             "data/index5.jpeg --target 'Grey heron'\n"
             "python -m birder.tools introspection -n efficientnet_v2_s --method guided-backprop "
@@ -126,7 +136,7 @@ def set_parser(subparsers: Any) -> None:
     subparser.add_argument(
         "--method",
         type=str,
-        choices=["gradcam", "guided-backprop", "attn-rollout", "transformer-attribution"],
+        choices=["attn-rollout", "feature-pca", "gradcam", "guided-backprop", "transformer-attribution"],
         help="introspection method",
     )
     subparser.add_argument(
@@ -142,7 +152,21 @@ def set_parser(subparsers: Any) -> None:
         "--layer-num", type=int, default=-1, help="target layer, index for target block (gradcam only)"
     )
     subparser.add_argument(
-        "--channels-last", default=False, action="store_true", help="channels last model, like swin (gradcam only)"
+        "--channels-last",
+        default=False,
+        action="store_true",
+        help="channels last model, like swin (gradcam and feature-pca)",
+    )
+    subparser.add_argument(
+        "--normalize-features",
+        default=False,
+        action="store_true",
+        help="normalize feature vectors before PCA (feature-pca only)",
+    )
+    subparser.add_argument(
+        "--stage",
+        type=str,
+        help="stage to visualize, e.g., 'stage1', 'neck', etc. (feature-pca only, defaults to last stage)",
     )
     subparser.add_argument(
         "--attn-layer-name",
@@ -193,11 +217,13 @@ def main(args: argparse.Namespace) -> None:
 
     transform = inference_preset(args.size, model_info.rgb_stats, 1.0)
 
-    if args.method == "gradcam":
+    if args.method == "attn-rollout":
+        _show_attn_rollout(args, net, transform, device)
+    elif args.method == "feature-pca":
+        _show_feature_pca(args, net, transform, device)
+    elif args.method == "gradcam":
         _show_grad_cam(args, net, model_info.class_to_idx, transform, device)
     elif args.method == "guided-backprop":
         _show_guided_backprop(args, net, model_info.class_to_idx, transform, device)
-    elif args.method == "attn-rollout":
-        _show_attn_rollout(args, net, transform, device)
     elif args.method == "transformer-attribution":
         _show_transformer_attribution(args, net, model_info.class_to_idx, transform, device)

birder/tools/show_iterator.py

@@ -140,10 +140,16 @@ def show_iterator(args: argparse.Namespace) -> None:
         mask_size = (args.size[0] // args.patch_size, args.size[1] // args.patch_size)
         mask_generator: Optional[masking.Masking]
         if args.masking == "uniform":
-            mask_generator = masking.UniformMasking(mask_size, args.mask_ratio)
+            mask_generator = masking.UniformMasking(mask_size, args.mask_ratio, min_mask_size=args.min_mask_size)
         elif args.masking == "block":
             max_patches = int(args.mask_ratio * mask_size[0] * mask_size[1])
             mask_generator = masking.BlockMasking(mask_size, 4, max_patches, 0.33, 3.33)
+        elif args.masking == "roll-block":
+            num_masking_patches = int(args.mask_ratio * mask_size[0] * mask_size[1])
+            mask_generator = masking.RollBlockMasking(mask_size, num_masking_patches=num_masking_patches)
+        elif args.masking == "inverse-roll":
+            num_masking_patches = int(args.mask_ratio * mask_size[0] * mask_size[1])
+            mask_generator = masking.InverseRollBlockMasking(mask_size, num_masking_patches=num_masking_patches)
         else:
             mask_generator = None
 
@@ -187,7 +193,7 @@ def set_parser(subparsers: Any) -> None:
             "python -m birder.tools show-iterator --mode training --size 224 --batch --wds "
             "--wds-class-file ~/Datasets/imagenet-1k-wds/classes.txt --wds-size 50000 "
             "--data-path ~/Datasets/imagenet-1k-wds/validation\n"
-            "python -m birder.tools show-iterator --mode training --batch --size 224 --aug-level 6 --masking uniform\n"
+            "python -m birder.tools show-iterator --mode training --batch --size 224 --aug-level 1 --masking uniform\n"
             "python -m birder.tools show-iterator --mode training --size 224 --batch --wds "
             "--data-path data/training_packed\n"
             "python -m birder.tools show-iterator --mode training --batch --mixup-alpha 0.8 --cutmix "
@@ -206,8 +212,16 @@ def set_parser(subparsers: Any) -> None:
     )
     subparser.add_argument("--mixup-alpha", type=float, help="mixup alpha")
     subparser.add_argument("--cutmix", default=False, action="store_true", help="enable cutmix")
-    subparser.add_argument("--masking", type=str, choices=["uniform", "block"], help="enable masking")
+    subparser.add_argument(
+        "--masking",
+        type=str,
+        choices=["uniform", "block", "roll-block", "inverse-roll"],
+        help="masking strategy to apply",
+    )
     subparser.add_argument("--mask-ratio", type=float, default=0.5, help="mask ratio")
+    subparser.add_argument(
+        "--min-mask-size", type=int, default=1, help="minimum mask unit size in patches (uniform only)"
+    )
     subparser.add_argument("--patch-size", type=int, default=16, help="mask base patch size")
     subparser.add_argument(
         "--data-path", type=str, default=str(settings.TRAINING_DATA_PATH), help="image directory path"

birder/version.py

@@ -1 +1 @@
-__version__ = "v0.3.1"
+__version__ = "v0.3.3"

{birder-0.3.1.dist-info → birder-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: birder
-Version: 0.3.1
+Version: 0.3.3
 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