Upload 18 files

milk10k_effb2_metadata/checkpoints.py

@@ -48,7 +48,7 @@ def infer_checkpoint_backend(path: Path, device: torch.device, branch_name: str)
     checkpoint = load_raw_checkpoint(path, device, branch_name)
     state = extract_state_dict(checkpoint)
     keys = {normalize_key(key) for key in state}
-    timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.")
+    timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.", "stages.", "stem.")
     torchvision_prefixes = ("features.", "avgpool.", "classifier.")
     timm_hits = sum(key.startswith(timm_prefixes) for key in keys)
     torchvision_hits = sum(key.startswith(torchvision_prefixes) for key in keys)
@@ -56,6 +56,8 @@ def infer_checkpoint_backend(path: Path, device: torch.device, branch_name: str)
         return "timm"
     if torchvision_hits > timm_hits:
         return "torchvision"
+    if any(key.startswith("layer") for key in keys):
+        return "timm"
     raise RuntimeError(
         f"{branch_name}: cannot infer checkpoint backend from {path}. "
         "Pass --backbone-backend timm or --backbone-backend torchvision explicitly."

milk10k_effb2_metadata/cli.py

@@ -15,7 +15,12 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--freeze-epochs", type=int, default=8)
     parser.add_argument("--finetune-epochs", type=int, default=20)
     parser.add_argument("--batch-size", type=int, default=8)
-    parser.add_argument("--image-size", type=int, default=260)
+    parser.add_argument("--image-size", type=int, default=None, help="Input image size. Defaults to backbone-specific optimal size if None.")
+    parser.add_argument(
+        "--backbone",
+        default="efficientnet_b2",
+        help="Backbone model architecture (efficientnet_b2, efficientnet_b1, resnet50, convnext_base).",
+    )
     parser.add_argument(
         "--num-workers",
         type=int,

milk10k_effb2_metadata/inference.py

@@ -56,6 +56,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--batch-size", type=int, default=16)
     parser.add_argument("--image-size", type=int, default=None, help="Defaults to checkpoint args image_size.")
     parser.add_argument("--num-workers", type=int, default=0)
+    parser.add_argument("--include-debug-columns", action="store_true", help="Include lesion/file IDs and predicted labels before class probabilities.")
     return parser.parse_args()
 
 
@@ -72,6 +73,8 @@ def load_inference_dataframe(
     meta["path"] = meta["path"].map(str)
 
     keep = ["lesion_id", "isic_id", "path", *METADATA_COLUMNS, *monet_columns]
+    if "id" in meta.columns:
+        keep.insert(0, "id")
     clinical = meta[meta["image_type_norm"] == "clinical_close_up"][keep].drop_duplicates("lesion_id")
     dermoscopic = meta[meta["image_type_norm"] == "dermoscopic"][keep].drop_duplicates("lesion_id")
     paired = (
@@ -80,6 +83,8 @@ def load_inference_dataframe(
         .rename(columns={"clinical_lesion_id": "lesion_id"})
         .drop(columns=["dermoscopic_lesion_id"])
     )
+    if "clinical_id" in paired.columns:
+        paired["id"] = paired["clinical_id"]
 
     if groundtruth_csv is not None and groundtruth_csv.exists():
         gt = pd.read_csv(groundtruth_csv)
@@ -104,12 +109,16 @@ def resolve_input_paths(args: argparse.Namespace) -> tuple[Path, Path, Path | No
 
 def infer_backend_from_model_state(state: dict[str, torch.Tensor], branch_prefix: str) -> str:
     keys = [key.removeprefix(branch_prefix) for key in state if key.startswith(branch_prefix)]
-    timm_hits = sum(key.startswith(("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.")) for key in keys)
-    torchvision_hits = sum(key.startswith(("features.", "avgpool.", "classifier.")) for key in keys)
+    timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.", "stages.", "stem.")
+    torchvision_prefixes = ("features.", "avgpool.", "classifier.")
+    timm_hits = sum(key.startswith(timm_prefixes) for key in keys)
+    torchvision_hits = sum(key.startswith(torchvision_prefixes) for key in keys)
     if timm_hits > torchvision_hits:
         return "timm"
     if torchvision_hits > timm_hits:
         return "torchvision"
+    if any(key.startswith("layer") for key in keys):
+        return "timm"
     raise RuntimeError(f"Cannot infer backend for checkpoint branch prefix {branch_prefix!r}.")
 
 
@@ -140,6 +149,7 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
         imagenet_pretrained=False,
         clinical_backbone_backend=clinical_backend,
         dermoscopic_backbone_backend=dermoscopic_backend,
+        backbone=checkpoint_arg(checkpoint_args, "backbone", "efficientnet_b2"),
     ).to(device)
     model.load_state_dict(state)
     model.eval()
@@ -158,7 +168,20 @@ def predict_dataframe(model: DualEffB2MetadataClassifier, loader: DataLoader, de
     return np.concatenate(probs_all)
 
 
-def save_inference_outputs(df: pd.DataFrame, y_prob: np.ndarray, class_names: list[str], output: Path) -> None:
+def save_inference_outputs(
+    df: pd.DataFrame,
+    y_prob: np.ndarray,
+    class_names: list[str],
+    output: Path,
+    include_debug_columns: bool = False,
+) -> None:
+    probability_df = pd.DataFrame(y_prob, columns=class_names)
+    probability_df.insert(0, "lesion_id", df["lesion_id"].tolist())
+    output.parent.mkdir(parents=True, exist_ok=True)
+    if not include_debug_columns:
+        probability_df.to_csv(output, index=False)
+        return
+
     y_pred = y_prob.argmax(axis=1)
     prediction_df = pd.DataFrame(
         {
@@ -174,8 +197,6 @@ def save_inference_outputs(df: pd.DataFrame, y_prob: np.ndarray, class_names: li
     )
     if "label" in df.columns:
         prediction_df["label_true"] = df["label"].tolist()
-    probability_df = pd.DataFrame(y_prob, columns=[f"prob_{name}" for name in class_names])
-    output.parent.mkdir(parents=True, exist_ok=True)
     pd.concat([prediction_df, probability_df], axis=1).to_csv(output, index=False)
 
 
@@ -201,7 +222,7 @@ def main() -> None:
     )
     model = build_model_from_checkpoint(checkpoint, dataset.metadata.shape[1], device)
     y_prob = predict_dataframe(model, loader, device)
-    save_inference_outputs(df, y_prob, class_names, args.output)
+    save_inference_outputs(df, y_prob, class_names, args.output, args.include_debug_columns)
 
     print(f"Saved predictions: {args.output}")
     if "label" in df.columns and df["label"].notna().all():

milk10k_effb2_metadata/models.py

@@ -53,15 +53,19 @@ class DualEffB2MetadataClassifier(nn.Module):
         imagenet_pretrained: bool,
         clinical_backbone_backend: str,
         dermoscopic_backbone_backend: str,
+        backbone: str = "efficientnet_b2",
     ) -> None:
         super().__init__()
         self.clinical_backbone_backend = clinical_backbone_backend
         self.dermoscopic_backbone_backend = dermoscopic_backbone_backend
-        self.clinical_encoder, clinical_feature_dim = build_effb2_feature_encoder(
+        self.backbone = backbone
+        self.clinical_encoder, clinical_feature_dim = build_feature_encoder(
+            backbone,
             clinical_backbone_backend,
             imagenet_pretrained,
         )
-        self.dermoscopic_encoder, dermoscopic_feature_dim = build_effb2_feature_encoder(
+        self.dermoscopic_encoder, dermoscopic_feature_dim = build_feature_encoder(
+            backbone,
             dermoscopic_backbone_backend,
             imagenet_pretrained,
         )
@@ -94,10 +98,24 @@ class DualEffB2MetadataClassifier(nn.Module):
         return self.classifier(fused)
 
 
-def build_effb2_feature_encoder(backbone_backend: str, imagenet_pretrained: bool) -> tuple[nn.Module, int]:
+def normalize_backbone_name(name: str) -> str:
+    name = name.lower().replace(" ", "").replace("_", "").replace("-", "")
+    if name in ("efficientnetb2", "effnetb2", "effb2"):
+        return "efficientnet_b2"
+    if name in ("efficientnetb1", "effnetb1", "effb1"):
+        return "efficientnet_b1"
+    if name in ("resnet50", "resnet_50"):
+        return "resnet50"
+    if name in ("convnextbase", "convxbase"):
+        return "convnext_base"
+    raise ValueError(f"Unknown backbone: {name}")
+
+
+def build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrained: bool) -> tuple[nn.Module, int]:
+    backbone = normalize_backbone_name(backbone)
     if backbone_backend == "timm":
         model = timm.create_model(
-            "efficientnet_b2",
+            backbone,
             pretrained=imagenet_pretrained,
             num_classes=0,
             global_pool="avg",
@@ -105,11 +123,36 @@ def build_effb2_feature_encoder(backbone_backend: str, imagenet_pretrained: bool
         return model, int(model.num_features)
 
     if backbone_backend == "torchvision":
-        weights = EfficientNet_B2_Weights.IMAGENET1K_V1 if imagenet_pretrained else None
-        model = efficientnet_b2(weights=weights)
-        feature_dim = int(model.classifier[1].in_features)
-        model.classifier = nn.Identity()
-        return model, feature_dim
+        if backbone == "efficientnet_b2":
+            from torchvision.models import efficientnet_b2, EfficientNet_B2_Weights
+            weights = EfficientNet_B2_Weights.IMAGENET1K_V1 if imagenet_pretrained else None
+            model = efficientnet_b2(weights=weights)
+            feature_dim = int(model.classifier[1].in_features)
+            model.classifier = nn.Identity()
+            return model, feature_dim
+        elif backbone == "efficientnet_b1":
+            from torchvision.models import efficientnet_b1, EfficientNet_B1_Weights
+            weights = EfficientNet_B1_Weights.IMAGENET1K_V1 if imagenet_pretrained else None
+            model = efficientnet_b1(weights=weights)
+            feature_dim = int(model.classifier[1].in_features)
+            model.classifier = nn.Identity()
+            return model, feature_dim
+        elif backbone == "resnet50":
+            from torchvision.models import resnet50, ResNet50_Weights
+            weights = ResNet50_Weights.IMAGENET1K_V1 if imagenet_pretrained else None
+            model = resnet50(weights=weights)
+            feature_dim = int(model.fc.in_features)
+            model.fc = nn.Identity()
+            return model, feature_dim
+        elif backbone == "convnext_base":
+            from torchvision.models import convnext_base, ConvNeXt_Base_Weights
+            weights = ConvNeXt_Base_Weights.IMAGENET1K_V1 if imagenet_pretrained else None
+            model = convnext_base(weights=weights)
+            feature_dim = int(model.classifier[2].in_features)
+            model.classifier = nn.Identity()
+            return model, feature_dim
+        else:
+            raise ValueError(f"Unsupported torchvision backbone: {backbone}")
 
     raise ValueError(f"Unsupported backbone backend: {backbone_backend}")
 

milk10k_effb2_metadata/training.py

@@ -234,6 +234,7 @@ def build_model(
         imagenet_pretrained=args.imagenet_pretrained,
         clinical_backbone_backend=clinical_backbone_backend,
         dermoscopic_backbone_backend=dermoscopic_backbone_backend,
+        backbone=args.backbone,
     ).to(device)
     load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
     load_encoder_checkpoint(args.dermoscopic_checkpoint, model.dermoscopic_encoder, "dermoscopic", device)
@@ -259,8 +260,8 @@ def save_run_config(
         "val_size": len(val_df),
         "fold": fold,
         "fusion": "concat(clinical_head, dermoscopic_head, metadata_head)",
-        "clinical_backbone": f"{clinical_backbone_backend} efficientnet_b2",
-        "dermoscopic_backbone": f"{dermoscopic_backbone_backend} efficientnet_b2",
+        "clinical_backbone": f"{clinical_backbone_backend} {args.backbone}",
+        "dermoscopic_backbone": f"{dermoscopic_backbone_backend} {args.backbone}",
     }
     with open(output_dir / "run_config.json", "w", encoding="utf-8") as f:
         json.dump(payload, f, indent=2)
@@ -477,6 +478,16 @@ def run(args: argparse.Namespace) -> None:
     data_dir = resolve_data_dir(args.data_dir)
     args.output_dir.mkdir(parents=True, exist_ok=True)
 
+    from milk10k_effb2_metadata.models import normalize_backbone_name
+    args.backbone = normalize_backbone_name(args.backbone)
+    if args.image_size is None:
+        if args.backbone == "efficientnet_b2":
+            args.image_size = 260
+        elif args.backbone == "efficientnet_b1":
+            args.image_size = 240
+        else:  # resnet50, convnext_base
+            args.image_size = 224
+
     df = load_paired_dataframe(data_dir)
     class_names = sorted(df["label"].unique())
     label_to_idx = {label: idx for idx, label in enumerate(class_names)}