Upload train_milk10k_effb2_dual_metadata.py

train_milk10k_effb2_dual_metadata.py

@@ -16,6 +16,7 @@ from typing import Any
 
 import numpy as np
 import pandas as pd
+import timm
 import torch
 from PIL import Image, ImageFile
 from sklearn.metrics import (
@@ -122,15 +123,23 @@ class DualEffB2MetadataClassifier(nn.Module):
         classifier_hidden_dim: int,
         dropout: float,
         imagenet_pretrained: bool,
+        clinical_backbone_backend: str,
+        dermoscopic_backbone_backend: str,
     ) -> None:
         super().__init__()
-        self.clinical_encoder, feature_dim = build_effb2_feature_encoder(imagenet_pretrained)
-        self.dermoscopic_encoder, derm_feature_dim = build_effb2_feature_encoder(imagenet_pretrained)
-        if feature_dim != derm_feature_dim:
-            raise RuntimeError(f"EfficientNet-B2 feature dims differ: {feature_dim} vs {derm_feature_dim}")
+        self.clinical_backbone_backend = clinical_backbone_backend
+        self.dermoscopic_backbone_backend = dermoscopic_backbone_backend
+        self.clinical_encoder, clinical_feature_dim = build_effb2_feature_encoder(
+            clinical_backbone_backend,
+            imagenet_pretrained,
+        )
+        self.dermoscopic_encoder, dermoscopic_feature_dim = build_effb2_feature_encoder(
+            dermoscopic_backbone_backend,
+            imagenet_pretrained,
+        )
 
-        self.clinical_head = ProjectionHead(feature_dim, branch_dim, dropout)
-        self.dermoscopic_head = ProjectionHead(feature_dim, branch_dim, dropout)
+        self.clinical_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout)
+        self.dermoscopic_head = ProjectionHead(dermoscopic_feature_dim, branch_dim, dropout)
         self.metadata_head = MetadataHead(metadata_input_dim, metadata_dim, dropout)
         fused_dim = branch_dim * 2 + metadata_dim
         self.classifier = nn.Sequential(
@@ -167,7 +176,12 @@ def parse_args() -> argparse.Namespace:
     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("--num-workers", type=int, default=4)
+    parser.add_argument(
+        "--num-workers",
+        type=int,
+        default=0,
+        help="DataLoader workers. Keep 0 in small Docker/Marimo containers to avoid /dev/shm exhaustion.",
+    )
     parser.add_argument("--head-lr", type=float, default=1e-4)
     parser.add_argument("--encoder-lr", type=float, default=1e-5)
     parser.add_argument("--weight-decay", type=float, default=1e-4)
@@ -179,6 +193,12 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--dropout", type=float, default=0.3)
     parser.add_argument("--class-weight", action="store_true")
     parser.add_argument("--amp", action="store_true")
+    parser.add_argument(
+        "--backbone-backend",
+        choices=["auto", "timm", "torchvision"],
+        default="auto",
+        help="Backbone implementation used by checkpoints. auto detects timm vs torchvision from checkpoint keys.",
+    )
     parser.add_argument(
         "--imagenet-pretrained",
         action="store_true",
@@ -188,12 +208,24 @@ def parse_args() -> argparse.Namespace:
     return parser.parse_args()
 
 
-def build_effb2_feature_encoder(imagenet_pretrained: bool) -> tuple[nn.Module, int]:
-    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
+def build_effb2_feature_encoder(backbone_backend: str, imagenet_pretrained: bool) -> tuple[nn.Module, int]:
+    if backbone_backend == "timm":
+        model = timm.create_model(
+            "efficientnet_b2",
+            pretrained=imagenet_pretrained,
+            num_classes=0,
+            global_pool="avg",
+        )
+        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
+
+    raise ValueError(f"Unsupported backbone backend: {backbone_backend}")
 
 
 def load_paired_dataframe(data_dir: Path) -> pd.DataFrame:
@@ -335,6 +367,15 @@ def extract_state_dict(checkpoint: Any) -> dict[str, torch.Tensor]:
     raise ValueError("Checkpoint does not contain a supported state dict.")
 
 
+def load_raw_checkpoint(path: Path, device: torch.device, branch_name: str) -> Any:
+    if not path.exists():
+        raise FileNotFoundError(f"{branch_name} checkpoint not found: {path}")
+    try:
+        return torch.load(path, map_location=device, weights_only=False)
+    except TypeError:
+        return torch.load(path, map_location=device)
+
+
 def normalize_key(key: str) -> str:
     changed = True
     while changed:
@@ -346,14 +387,36 @@ def normalize_key(key: str) -> str:
     return key
 
 
-def load_encoder_checkpoint(path: Path, encoder: nn.Module, branch_name: str, device: torch.device) -> None:
-    if not path.exists():
-        raise FileNotFoundError(f"{branch_name} checkpoint not found: {path}")
-    try:
-        checkpoint = torch.load(path, map_location=device, weights_only=False)
-    except TypeError:
-        checkpoint = torch.load(path, map_location=device)
+def infer_checkpoint_backend(path: Path, device: torch.device, branch_name: str) -> 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.")
+    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"
+    raise RuntimeError(
+        f"{branch_name}: cannot infer checkpoint backend from {path}. "
+        "Pass --backbone-backend timm or --backbone-backend torchvision explicitly."
+    )
+
+
+def resolve_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]:
+    if args.backbone_backend != "auto":
+        return args.backbone_backend, args.backbone_backend
+
+    clinical_backend = infer_checkpoint_backend(args.clinical_checkpoint, device, "clinical")
+    dermoscopic_backend = infer_checkpoint_backend(args.dermoscopic_checkpoint, device, "dermoscopic")
+    print(f"Auto-detected backbone backends: clinical={clinical_backend}, dermoscopic={dermoscopic_backend}")
+    return clinical_backend, dermoscopic_backend
+
 
+def load_encoder_checkpoint(path: Path, encoder: nn.Module, branch_name: str, device: torch.device) -> None:
+    checkpoint = load_raw_checkpoint(path, device, branch_name)
     raw_state = extract_state_dict(checkpoint)
     source_state = {normalize_key(key): value for key, value in raw_state.items()}
     target_state = encoder.state_dict()
@@ -679,6 +742,8 @@ def save_run_config(
     metadata_spec: dict[str, Any],
     train_df: pd.DataFrame,
     val_df: pd.DataFrame,
+    clinical_backbone_backend: str,
+    dermoscopic_backbone_backend: str,
 ) -> None:
     payload = {
         "args": {key: str(value) if isinstance(value, Path) else value for key, value in vars(args).items()},
@@ -687,7 +752,8 @@ def save_run_config(
         "train_size": len(train_df),
         "val_size": len(val_df),
         "fusion": "concat(clinical_head, dermoscopic_head, metadata_head)",
-        "backbone": "torchvision efficientnet_b2",
+        "clinical_backbone": f"{clinical_backbone_backend} efficientnet_b2",
+        "dermoscopic_backbone": f"{dermoscopic_backbone_backend} efficientnet_b2",
     }
     with open(output_dir / "run_config.json", "w", encoding="utf-8") as f:
         json.dump(payload, f, indent=2)
@@ -705,14 +771,24 @@ def main() -> None:
     train_df, val_df = lesion_split(df, args.val_size, args.seed)
     metadata_spec = fit_metadata_spec(train_df)
     metadata_dim = len(metadata_vector(train_df.iloc[0], metadata_spec))
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    clinical_backbone_backend, dermoscopic_backbone_backend = resolve_backbone_backends(args, device)
 
     split_dir = args.output_dir / "splits"
     split_dir.mkdir(exist_ok=True)
     train_df.to_csv(split_dir / "train.csv", index=False)
     val_df.to_csv(split_dir / "val.csv", index=False)
-    save_run_config(args.output_dir, args, class_names, metadata_spec, train_df, val_df)
+    save_run_config(
+        args.output_dir,
+        args,
+        class_names,
+        metadata_spec,
+        train_df,
+        val_df,
+        clinical_backbone_backend,
+        dermoscopic_backbone_backend,
+    )
 
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model = DualEffB2MetadataClassifier(
         num_classes=len(class_names),
         metadata_input_dim=metadata_dim,
@@ -721,6 +797,8 @@ def main() -> None:
         classifier_hidden_dim=args.classifier_hidden_dim,
         dropout=args.dropout,
         imagenet_pretrained=args.imagenet_pretrained,
+        clinical_backbone_backend=clinical_backbone_backend,
+        dermoscopic_backbone_backend=dermoscopic_backbone_backend,
     ).to(device)
     load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
     load_encoder_checkpoint(args.dermoscopic_checkpoint, model.dermoscopic_encoder, "dermoscopic", device)