Upload 147 files

milk10k_effb2_metadata/checkpoints.py

@@ -9,8 +9,8 @@ from typing import Any
 import torch
 from torch import nn
 
-CHECKPOINT_STATE_KEYS = ("model_state", "model_state_dict", "state_dict")
-PREFIXES_TO_STRIP = ("module.", "model.", "_orig_mod.")
+CHECKPOINT_STATE_KEYS = ("encoder_state_dict", "model_state", "model_state_dict", "state_dict")
+PREFIXES_TO_STRIP = ("module.", "model.", "encoder.", "backbone.", "_orig_mod.")
 
 
 def extract_state_dict(checkpoint: Any) -> dict[str, torch.Tensor]:
@@ -91,4 +91,3 @@ def load_encoder_checkpoint(path: Path, encoder: nn.Module, branch_name: str, de
     target_state.update(matched)
     encoder.load_state_dict(target_state)
     print(f"{branch_name}: loaded {len(matched)} keys from {path}; skipped {skipped} keys")
-

milk10k_effb2_metadata/cli.py

@@ -35,7 +35,10 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--backbone",
         default="efficientnet_b2",
-        help="Backbone model architecture (efficientnet_b2, efficientnet_b1, resnet50, convnext_base).",
+        help=(
+            "Backbone model architecture (efficientnet_b2, tf_efficientnetv2_b2, "
+            "efficientnet_b1, resnet50, convnext_base)."
+        ),
     )
     parser.add_argument(
         "--num-workers",
@@ -122,6 +125,15 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--branch-dim", type=int, default=512)
     parser.add_argument("--metadata-dim", type=int, default=64)
     parser.add_argument("--classifier-hidden-dim", type=int, default=512)
+    parser.add_argument(
+        "--classifier-style",
+        choices=["legacy", "simple"],
+        default="legacy",
+        help=(
+            "Final fused classifier architecture. legacy keeps the existing LayerNorm/GELU head; "
+            "simple uses Linear-ReLU-Dropout-Linear."
+        ),
+    )
     parser.add_argument("--dropout", type=float, default=0.3)
     parser.add_argument(
         "--logit-fusion-mode",

milk10k_effb2_metadata/inference.py

@@ -198,6 +198,7 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
         metadata_fusion=checkpoint_arg(checkpoint_args, "metadata_fusion", "concat"),
         image_fusion=checkpoint_arg(checkpoint_args, "image_fusion", "concat"),
         metadata_gate_hidden_dim=checkpoint_args.get("metadata_gate_hidden_dim"),
+        classifier_style=checkpoint_arg(checkpoint_args, "classifier_style", "legacy"),
         logit_fusion_mode=checkpoint_arg(checkpoint_args, "logit_fusion_mode", "single"),
         fusion_logit_weight=checkpoint_arg(checkpoint_args, "fusion_logit_weight", 0.6),
         clinical_logit_weight=checkpoint_arg(checkpoint_args, "clinical_logit_weight", 0.2),

milk10k_effb2_metadata/model_setup.py

@@ -152,6 +152,7 @@ def build_model(
         metadata_fusion=args.metadata_fusion,
         image_fusion=getattr(args, "image_fusion", "concat"),
         metadata_gate_hidden_dim=args.metadata_gate_hidden_dim,
+        classifier_style=getattr(args, "classifier_style", "legacy"),
         logit_fusion_mode=args.logit_fusion_mode,
         fusion_logit_weight=args.fusion_logit_weight,
         clinical_logit_weight=args.clinical_logit_weight,

milk10k_effb2_metadata/models.py

@@ -107,6 +107,7 @@ class DualEffB2MetadataClassifier(nn.Module):
         metadata_fusion: str = "concat",
         image_fusion: str = "concat",
         metadata_gate_hidden_dim: int | None = None,
+        classifier_style: str = "legacy",
         logit_fusion_mode: str = "single",
         fusion_logit_weight: float = 0.6,
         clinical_logit_weight: float = 0.2,
@@ -128,6 +129,8 @@ class DualEffB2MetadataClassifier(nn.Module):
             raise ValueError(f"Unsupported image_fusion: {image_fusion}")
         if logit_fusion_mode not in ("single", "fixed"):
             raise ValueError(f"Unsupported logit_fusion_mode: {logit_fusion_mode}")
+        if classifier_style not in ("legacy", "simple"):
+            raise ValueError(f"Unsupported classifier_style: {classifier_style}")
         self.clinical_backbone_backend = clinical_backbone_backend
         self.dermoscopic_backbone_backend = dermoscopic_backbone_backend
         self.backbone = normalize_backbone_name(backbone)
@@ -135,6 +138,7 @@ class DualEffB2MetadataClassifier(nn.Module):
         self.metadata_dim = metadata_dim
         self.metadata_fusion = metadata_fusion
         self.image_fusion = image_fusion
+        self.classifier_style = classifier_style
         self.logit_fusion_mode = logit_fusion_mode
         self.fusion_logit_weight = fusion_logit_weight
         self.clinical_logit_weight = clinical_logit_weight
@@ -212,7 +216,11 @@ class DualEffB2MetadataClassifier(nn.Module):
             if clinical_feature_dim != dermoscopic_feature_dim:
                 raise ValueError("shared_private image fusion requires matching branch feature dimensions.")
             self.shared_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout)
-        self.classifier = None if image_fusion == "moe" else self._classifier(fused_dim, classifier_hidden_dim, num_classes, dropout)
+        self.classifier = (
+            None
+            if image_fusion == "moe"
+            else self._classifier(fused_dim, classifier_hidden_dim, num_classes, dropout, classifier_style)
+        )
         if logit_fusion_mode == "fixed":
             self.clinical_classifier = BranchClassifier(branch_dim, num_classes, dropout)
             self.dermoscopic_classifier = BranchClassifier(branch_dim, num_classes, dropout)
@@ -221,7 +229,20 @@ class DualEffB2MetadataClassifier(nn.Module):
             self.dermoscopic_classifier = None
 
     @staticmethod
-    def _classifier(in_dim: int, hidden_dim: int, num_classes: int, dropout: float) -> nn.Sequential:
+    def _classifier(
+        in_dim: int,
+        hidden_dim: int,
+        num_classes: int,
+        dropout: float,
+        classifier_style: str,
+    ) -> nn.Sequential:
+        if classifier_style == "simple":
+            return nn.Sequential(
+                nn.Linear(in_dim, hidden_dim),
+                nn.ReLU(),
+                nn.Dropout(dropout),
+                nn.Linear(hidden_dim, num_classes),
+            )
         return nn.Sequential(
             nn.LayerNorm(in_dim),
             nn.Dropout(dropout),
@@ -401,6 +422,8 @@ class DualConvNeXtMetadataClassifier(DualEffB2MetadataClassifier):
 
 def normalize_backbone_name(name: str) -> str:
     name = name.lower().replace(" ", "").replace("_", "").replace("-", "")
+    if name in ("tfefficientnetv2b2", "efficientnetv2b2", "effnetv2b2", "effv2b2"):
+        return "tf_efficientnetv2_b2"
     if name in ("efficientnetb2", "effnetb2", "effb2"):
         return "efficientnet_b2"
     if name in ("efficientnetb1", "effnetb1", "effb1"):
@@ -425,6 +448,8 @@ def default_image_size(backbone: str) -> int:
     backbone = normalize_backbone_name(backbone)
     if backbone == "efficientnet_b2":
         return 260
+    if backbone == "tf_efficientnetv2_b2":
+        return 384
     if backbone == "efficientnet_b1":
         return 240
     if backbone == "convnext_base":
@@ -478,6 +503,8 @@ def build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrai
         return model, int(model.num_features)
 
     if backbone_backend == "torchvision":
+        if backbone == "tf_efficientnetv2_b2":
+            raise ValueError("tf_efficientnetv2_b2 is only available with --backbone-backend timm.")
         if backbone == "efficientnet_b2":
             from torchvision.models import efficientnet_b2, EfficientNet_B2_Weights
             weights = EfficientNet_B2_Weights.IMAGENET1K_V1 if imagenet_pretrained else None