Upload 21 files

milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md

@@ -0,0 +1,284 @@
+# MILK10k EffB2 Metadata CLI Commands
+
+Entrypoint:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py
+```
+
+Base checkpoints:
+
+```bash
+--clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+--dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt
+```
+
+## 1. Check CLI
+
+```bash
+python train_milk10k_effb2_dual_metadata.py --help
+```
+
+## 2. Baseline
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --output-dir milk10k_effb2_baseline
+```
+
+## 3. Class Weight Only
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --class-weight \
+  --output-dir milk10k_effb2_class_weight
+```
+
+## 4. Weighted Sampler
+
+Start with mild sampling:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --weighted-sampler \
+  --sampler-power 0.5 \
+  --output-dir milk10k_effb2_sampler_p05
+```
+
+Stronger sampling:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --weighted-sampler \
+  --sampler-power 1.0 \
+  --output-dir milk10k_effb2_sampler_p10
+```
+
+## 5. Focal Loss
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --loss focal \
+  --focal-gamma 2.0 \
+  --output-dir milk10k_effb2_focal
+```
+
+Focal plus mild sampler:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --loss focal \
+  --focal-gamma 2.0 \
+  --weighted-sampler \
+  --sampler-power 0.5 \
+  --output-dir milk10k_effb2_focal_sampler_p05
+```
+
+## 6. MILK Long-Tail Loss
+
+Recommended first run:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --loss milk_lt \
+  --weighted-sampler \
+  --sampler-power 0.5 \
+  --output-dir milk10k_effb2_milk_lt_sampler_p05
+```
+
+Without sampler:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --loss milk_lt \
+  --output-dir milk10k_effb2_milk_lt
+```
+
+More conservative prior correction:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --loss milk_lt \
+  --lt-logit-tau 0.5 \
+  --lt-max-margin 0.3 \
+  --weighted-sampler \
+  --sampler-power 0.5 \
+  --output-dir milk10k_effb2_milk_lt_conservative
+```
+
+Note: do not add `--class-weight` with `--loss milk_lt`; `milk_lt` already uses effective-number alpha.
+
+## 7. K-Fold
+
+5-fold with recommended long-tail setup:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --loss milk_lt \
+  --weighted-sampler \
+  --sampler-power 0.5 \
+  --k-folds 5 \
+  --output-dir milk10k_effb2_milk_lt_kfold5
+```
+
+Outputs:
+
+```text
+milk10k_effb2_milk_lt_kfold5/
+  fold_00/
+  fold_01/
+  fold_02/
+  fold_03/
+  fold_04/
+  kfold_summary.csv
+  kfold_summary.json
+```
+
+## 8. Useful Training Flags
+
+```bash
+--batch-size 8
+--image-size 260
+--freeze-epochs 8
+--finetune-epochs 20
+--head-lr 1e-4
+--encoder-lr 1e-5
+--weight-decay 1e-4
+--patience 6
+--amp
+```
+
+Example with AMP:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --loss milk_lt \
+  --weighted-sampler \
+  --sampler-power 0.5 \
+  --amp \
+  --output-dir milk10k_effb2_milk_lt_amp
+```
+
+## 9. Smoke Checks
+
+Syntax check:
+
+```bash
+python -m py_compile train_milk10k_effb2_dual_metadata.py milk10k_effb2_metadata/*.py
+```
+
+Zero-epoch single split:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --freeze-epochs 0 \
+  --finetune-epochs 0 \
+  --loss milk_lt \
+  --output-dir /tmp/milk10k_effb2_smoke_single
+```
+
+Zero-epoch k-fold:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --freeze-epochs 0 \
+  --finetune-epochs 0 \
+  --loss milk_lt \
+  --k-folds 2 \
+  --output-dir /tmp/milk10k_effb2_smoke_kfold
+```
+
+## 10. Files To Compare After Training
+
+Per run:
+
+```text
+history.csv
+metrics.json
+per_class_metrics.csv
+confusion_matrix.csv
+val_predictions.csv
+run_config.json
+```
+
+For minority classes, inspect these rows in `per_class_metrics.csv`:
+
+```text
+BEN_OTH
+DF
+INF
+MAL_OTH
+VASC
+```
+
+## 11. Inference With best.pt
+
+Use the saved checkpoint directly. You do not need to pass the original branch checkpoints for inference because `best.pt` contains the full model state.
+
+```bash
+python predict_milk10k_effb2_dual_metadata.py \
+  --checkpoint milk10k_effb2_milk_lt_sampler_p05/best.pt \
+  --data-dir /marimo/milk10k \
+  --output milk10k_effb2_test_predictions.csv \
+  --batch-size 16 \
+  --image-size 384 \
+  --num-workers 4
+```
+
+By default, the output has no labels. If you explicitly pass `--groundtruth-csv`, the script also writes:
+
+```text
+milk10k_effb2_test_predictions.metrics.json
+```
+
+For an unlabeled test set, pass image root and metadata CSV explicitly:
+
+```bash
+python predict_milk10k_effb2_dual_metadata.py \
+  --checkpoint milk10k_effb2_milk_lt_sampler_p05/best.pt \
+  --input-dir /path/to/MILK10k_Test_Input \
+  --metadata-csv /path/to/MILK10k_Test_Metadata.csv \
+  --output milk10k_effb2_test_predictions.csv \
+  --batch-size 16 \
+  --image-size 384 \
+  --num-workers 4
+```
+
+Default output is submission-ready and includes only:
+
+```text
+lesion_id
+AKIEC ... VASC
+```
+
+For a local debug file with lesion IDs, file names, predicted label, and confidence, add:
+
+```bash
+--include-debug-columns
+```

milk10k_effb2_metadata/cli.py

@@ -11,6 +11,12 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--data-dir", type=Path, default=None)
     parser.add_argument("--clinical-checkpoint", type=Path, required=True)
     parser.add_argument("--dermoscopic-checkpoint", type=Path, required=True)
+    parser.add_argument(
+        "--resume-checkpoint",
+        type=Path,
+        default=None,
+        help="Resume model weights/best score from an EffB2 metadata checkpoint, usually output-dir/best.pt.",
+    )
     parser.add_argument("--output-dir", type=Path, default=Path("milk10k_dual_effb2_metadata_runs"))
     parser.add_argument("--freeze-epochs", type=int, default=8)
     parser.add_argument("--finetune-epochs", type=int, default=20)
@@ -29,6 +35,22 @@ def parse_args() -> argparse.Namespace:
     )
     parser.add_argument("--head-lr", type=float, default=1e-4)
     parser.add_argument("--encoder-lr", type=float, default=1e-5)
+    parser.add_argument(
+        "--metadata-lr",
+        type=float,
+        default=None,
+        help="Optional LR for metadata_head. Defaults to --head-lr.",
+    )
+    parser.add_argument(
+        "--disable-metadata",
+        action="store_true",
+        help="Ignore metadata values by feeding a zero metadata representation and freezing metadata_head.",
+    )
+    parser.add_argument(
+        "--freeze-metadata-head",
+        action="store_true",
+        help="Freeze metadata_head parameters while still using its current output.",
+    )
     parser.add_argument("--weight-decay", type=float, default=1e-4)
     parser.add_argument("--val-size", type=float, default=0.20)
     parser.add_argument("--seed", type=int, default=42)

milk10k_effb2_metadata/inference.py

@@ -150,6 +150,7 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
         clinical_backbone_backend=clinical_backend,
         dermoscopic_backbone_backend=dermoscopic_backend,
         backbone=checkpoint_arg(checkpoint_args, "backbone", "efficientnet_b2"),
+        disable_metadata=checkpoint_arg(checkpoint_args, "disable_metadata", False),
     ).to(device)
     model.load_state_dict(state)
     model.eval()

milk10k_effb2_metadata/models.py

@@ -54,11 +54,14 @@ class DualEffB2MetadataClassifier(nn.Module):
         clinical_backbone_backend: str,
         dermoscopic_backbone_backend: str,
         backbone: str = "efficientnet_b2",
+        disable_metadata: bool = False,
     ) -> None:
         super().__init__()
         self.clinical_backbone_backend = clinical_backbone_backend
         self.dermoscopic_backbone_backend = dermoscopic_backbone_backend
         self.backbone = backbone
+        self.disable_metadata = disable_metadata
+        self.metadata_dim = metadata_dim
         self.clinical_encoder, clinical_feature_dim = build_feature_encoder(
             backbone,
             clinical_backbone_backend,
@@ -95,7 +98,10 @@ class DualEffB2MetadataClassifier(nn.Module):
         dermoscopic_features = torch.flatten(dermoscopic_features, 1)
         clinical_repr = self.clinical_head(clinical_features)
         dermoscopic_repr = self.dermoscopic_head(dermoscopic_features)
-        metadata_repr = self.metadata_head(metadata)
+        if self.disable_metadata:
+            metadata_repr = clinical_repr.new_zeros((clinical_repr.size(0), self.metadata_dim))
+        else:
+            metadata_repr = self.metadata_head(metadata)
         fused = torch.cat([clinical_repr, dermoscopic_repr, metadata_repr], dim=1)
         return self.classifier(fused)
 
@@ -164,4 +170,3 @@ def set_encoder_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -
         param.requires_grad = trainable
     for param in model.dermoscopic_encoder.parameters():
         param.requires_grad = trainable
-

milk10k_effb2_metadata/train_milk10k_effb2_dual_metadata.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Train a MILK10k dual EfficientNet-B2 classifier with metadata fusion."""
+
+from milk10k_effb2_metadata.cli import parse_args
+
+
+def main() -> None:
+    args = parse_args()
+    from milk10k_effb2_metadata.training import run
+
+    run(args)
+
+
+if __name__ == "__main__":
+    main()

milk10k_effb2_metadata/training.py

@@ -34,20 +34,30 @@ from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier, set_encod
 def build_optimizer(model: DualEffB2MetadataClassifier, args: argparse.Namespace, encoders_trainable: bool) -> torch.optim.Optimizer:
     head_params = []
     encoder_params = []
+    metadata_params = []
     for name, param in model.named_parameters():
         if not param.requires_grad:
             continue
         if name.startswith(("clinical_encoder.", "dermoscopic_encoder.")):
             encoder_params.append(param)
+        elif name.startswith("metadata_head."):
+            metadata_params.append(param)
         else:
             head_params.append(param)
 
     groups = [{"params": head_params, "lr": args.head_lr}]
+    if metadata_params:
+        groups.append({"params": metadata_params, "lr": args.metadata_lr if args.metadata_lr is not None else args.head_lr})
     if encoders_trainable and encoder_params:
         groups.append({"params": encoder_params, "lr": args.encoder_lr})
     return torch.optim.AdamW(groups, weight_decay=args.weight_decay)
 
 
+def set_metadata_head_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None:
+    for param in model.metadata_head.parameters():
+        param.requires_grad = trainable
+
+
 def run_epoch(
     model: DualEffB2MetadataClassifier,
     loader: DataLoader,
@@ -152,6 +162,7 @@ def train_phase(
     output_dir: Path,
     history: list[dict[str, Any]],
     best_val_f1: float,
+    skip_until_epoch: int = 1,
 ) -> tuple[int, float]:
     if num_epochs <= 0:
         return start_epoch, best_val_f1
@@ -167,6 +178,9 @@ def train_phase(
     print(f"\nPhase: {phase}, epochs={num_epochs}, encoders_trainable={encoders_trainable}")
     for local_epoch in range(1, num_epochs + 1):
         epoch = start_epoch + local_epoch - 1
+        if epoch < skip_until_epoch:
+            print(f"Skipping already completed {phase} epoch {epoch:03d}")
+            continue
         if hasattr(criterion, "set_epoch"):
             criterion.set_epoch(epoch)
         train_stats = run_epoch(model, train_loader, criterion, device, optimizer, scaler, use_amp)
@@ -216,6 +230,29 @@ def train_phase(
     return epoch + 1, best_val_f1
 
 
+def load_resume_checkpoint(
+    checkpoint_path: Path | None,
+    model: DualEffB2MetadataClassifier,
+    device: torch.device,
+) -> tuple[int, float, str | None]:
+    if checkpoint_path is None:
+        return 1, float("-inf"), None
+    checkpoint_path = checkpoint_path.expanduser().resolve()
+    if not checkpoint_path.exists():
+        raise FileNotFoundError(f"Resume checkpoint not found: {checkpoint_path}")
+    checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False)
+    model.load_state_dict(checkpoint["model_state"])
+    next_epoch = int(checkpoint.get("epoch", 0)) + 1
+    best_val_f1 = float(checkpoint.get("best_val_f1_macro", float("-inf")))
+    phase = checkpoint.get("phase")
+    print(
+        f"Resumed checkpoint: {checkpoint_path}, phase={phase}, "
+        f"last_epoch={next_epoch - 1}, best_val_f1_macro={best_val_f1:.4f}"
+    )
+    print("Optimizer is re-created from current CLI LR settings.")
+    return next_epoch, best_val_f1, str(phase) if phase is not None else None
+
+
 def build_model(
     class_names: list[str],
     metadata_dim: int,
@@ -235,9 +272,12 @@ def build_model(
         clinical_backbone_backend=clinical_backbone_backend,
         dermoscopic_backbone_backend=dermoscopic_backbone_backend,
         backbone=args.backbone,
+        disable_metadata=args.disable_metadata,
     ).to(device)
     load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
     load_encoder_checkpoint(args.dermoscopic_checkpoint, model.dermoscopic_encoder, "dermoscopic", device)
+    if args.disable_metadata or args.freeze_metadata_head:
+        set_metadata_head_trainable(model, False)
     return model
 
 
@@ -259,7 +299,9 @@ def save_run_config(
         "train_size": len(train_df),
         "val_size": len(val_df),
         "fold": fold,
-        "fusion": "concat(clinical_head, dermoscopic_head, metadata_head)",
+        "fusion": "concat(clinical_head, dermoscopic_head, metadata_head)"
+        if not args.disable_metadata
+        else "concat(clinical_head, dermoscopic_head, zero_metadata_repr)",
         "clinical_backbone": f"{clinical_backbone_backend} {args.backbone}",
         "dermoscopic_backbone": f"{dermoscopic_backbone_backend} {args.backbone}",
     }
@@ -308,6 +350,7 @@ def run_training_split(
         clinical_backbone_backend,
         dermoscopic_backbone_backend,
     )
+    resume_epoch, resume_best_val_f1, resume_phase = load_resume_checkpoint(args.resume_checkpoint, model, device)
     train_loader, val_loader = make_loaders(train_df, val_df, label_to_idx, metadata_spec, args)
     criterion = build_loss(train_df, label_to_idx, args, device)
 
@@ -317,11 +360,23 @@ def run_training_split(
     print(f"Paired lesions: train={len(train_df)}, val={len(val_df)}, total={len(df)}")
     print(f"Metadata input dim: {metadata_dim}")
     print(f"MONET columns: {len(metadata_spec.get('monet_columns', []))}")
+    print(
+        f"Metadata mode: disable_metadata={args.disable_metadata}, "
+        f"freeze_metadata_head={args.freeze_metadata_head}, metadata_lr={args.metadata_lr}"
+    )
     print(f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}")
     if args.loss == "milk_lt" and args.class_weight:
         print("Note: --class-weight is ignored for --loss milk_lt because milk_lt uses effective-number alpha.")
 
     history: list[dict[str, Any]] = []
+    history_path = output_dir / "history.csv"
+    if args.resume_checkpoint is not None and history_path.exists():
+        history = pd.read_csv(history_path).to_dict("records")
+    best_start = resume_best_val_f1 if args.resume_checkpoint is not None else float("-inf")
+    skip_freeze_until = resume_epoch if resume_phase == "freeze" else 1
+    if resume_phase == "finetune":
+        skip_freeze_until = args.freeze_epochs + 1
+    skip_finetune_until = resume_epoch if resume_phase == "finetune" else 1
     epoch, best_val_f1 = train_phase(
         "freeze",
         args.freeze_epochs,
@@ -337,7 +392,8 @@ def run_training_split(
         metadata_spec,
         output_dir,
         history,
-        float("-inf"),
+        best_start,
+        skip_freeze_until,
     )
     epoch, best_val_f1 = train_phase(
         "finetune",
@@ -355,6 +411,7 @@ def run_training_split(
         output_dir,
         history,
         best_val_f1,
+        skip_finetune_until,
     )
 
     best_path = output_dir / "best.pt"