Upload 19 files

milk10k_effb2_metadata/inference.py

@@ -0,0 +1,220 @@
+"""Inference CLI for EffB2 dual metadata checkpoints."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image
+from torch.utils.data import DataLoader, Dataset
+from tqdm.auto import tqdm
+
+from datasets import LABEL_COLUMNS, normalize_image_type
+from milk10k_effb2_metadata.data import METADATA_COLUMNS, make_transforms, metadata_vector, resolve_monet_columns
+from milk10k_effb2_metadata.metrics import compute_metrics
+from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier
+from milk10k_effb2_metadata.training import json_safe
+
+
+class InferencePairedDataset(Dataset):
+    def __init__(self, df: pd.DataFrame, metadata_spec: dict[str, Any], transform=None) -> None:
+        self.df = df.reset_index(drop=True)
+        self.metadata = np.stack([metadata_vector(row, metadata_spec) for _, row in self.df.iterrows()])
+        self.transform = transform
+
+    def __len__(self) -> int:
+        return len(self.df)
+
+    def _load_image(self, path: str) -> torch.Tensor:
+        with Image.open(path) as img:
+            image = img.convert("RGB")
+        if self.transform is not None:
+            image = self.transform(image)
+        return image
+
+    def __getitem__(self, idx: int) -> dict[str, torch.Tensor]:
+        row = self.df.iloc[idx]
+        return {
+            "clinical": self._load_image(row["clinical_path"]),
+            "dermoscopic": self._load_image(row["dermoscopic_path"]),
+            "metadata": torch.from_numpy(self.metadata[idx]),
+        }
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run inference with a MILK10k dual EffB2 metadata checkpoint.")
+    parser.add_argument("--checkpoint", type=Path, required=True, help="Path to best.pt from training.")
+    parser.add_argument("--data-dir", type=Path, default=None, help="Directory containing MILK10k input/metadata files.")
+    parser.add_argument("--input-dir", type=Path, default=None, help="Image root. Overrides --data-dir/MILK10k_Training_Input.")
+    parser.add_argument("--metadata-csv", type=Path, default=None, help="Metadata CSV. Overrides --data-dir/MILK10k_Training_Metadata.csv.")
+    parser.add_argument("--groundtruth-csv", type=Path, default=None, help="Optional ground-truth CSV for metrics.")
+    parser.add_argument("--output", type=Path, default=Path("test_predictions.csv"))
+    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)
+    return parser.parse_args()
+
+
+def load_inference_dataframe(
+    input_dir: Path,
+    metadata_csv: Path,
+    groundtruth_csv: Path | None,
+) -> pd.DataFrame:
+    meta = pd.read_csv(metadata_csv)
+    monet_columns = resolve_monet_columns(meta)
+    meta["image_type_norm"] = meta["image_type"].map(normalize_image_type)
+    meta["path"] = meta.apply(lambda r: input_dir / r["lesion_id"] / f"{r['isic_id']}.jpg", axis=1)
+    meta = meta[meta["path"].map(lambda p: p.exists())].copy()
+    meta["path"] = meta["path"].map(str)
+
+    keep = ["lesion_id", "isic_id", "path", *METADATA_COLUMNS, *monet_columns]
+    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 = (
+        clinical.add_prefix("clinical_")
+        .merge(dermoscopic.add_prefix("dermoscopic_"), left_on="clinical_lesion_id", right_on="dermoscopic_lesion_id")
+        .rename(columns={"clinical_lesion_id": "lesion_id"})
+        .drop(columns=["dermoscopic_lesion_id"])
+    )
+
+    if groundtruth_csv is not None and groundtruth_csv.exists():
+        gt = pd.read_csv(groundtruth_csv)
+        gt["label"] = gt[LABEL_COLUMNS].idxmax(axis=1)
+        paired = paired.merge(gt[["lesion_id", "label"]], on="lesion_id", how="left")
+
+    if paired.empty:
+        raise ValueError(f"No paired clinical/dermoscopic lesions found under {input_dir}")
+    return paired
+
+
+def resolve_input_paths(args: argparse.Namespace) -> tuple[Path, Path, Path | None]:
+    if args.data_dir is None and (args.input_dir is None or args.metadata_csv is None):
+        raise ValueError("Pass --data-dir, or pass both --input-dir and --metadata-csv.")
+
+    data_dir = args.data_dir.expanduser().resolve() if args.data_dir is not None else None
+    input_dir = args.input_dir or data_dir / "MILK10k_Training_Input"
+    metadata_csv = args.metadata_csv or data_dir / "MILK10k_Training_Metadata.csv"
+    groundtruth_csv = args.groundtruth_csv
+    return input_dir.expanduser().resolve(), metadata_csv.expanduser().resolve(), groundtruth_csv
+
+
+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)
+    if timm_hits > torchvision_hits:
+        return "timm"
+    if torchvision_hits > timm_hits:
+        return "torchvision"
+    raise RuntimeError(f"Cannot infer backend for checkpoint branch prefix {branch_prefix!r}.")
+
+
+def checkpoint_arg(checkpoint_args: dict[str, Any], key: str, default: Any) -> Any:
+    value = checkpoint_args.get(key, default)
+    if isinstance(default, bool):
+        return bool(value)
+    if isinstance(default, int):
+        return int(value)
+    if isinstance(default, float):
+        return float(value)
+    return value
+
+
+def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, device: torch.device) -> DualEffB2MetadataClassifier:
+    state = checkpoint["model_state"]
+    checkpoint_args = checkpoint.get("args", {})
+    class_names = checkpoint["class_names"]
+    clinical_backend = infer_backend_from_model_state(state, "clinical_encoder.")
+    dermoscopic_backend = infer_backend_from_model_state(state, "dermoscopic_encoder.")
+    model = DualEffB2MetadataClassifier(
+        num_classes=len(class_names),
+        metadata_input_dim=metadata_dim,
+        branch_dim=checkpoint_arg(checkpoint_args, "branch_dim", 512),
+        metadata_dim=checkpoint_arg(checkpoint_args, "metadata_dim", 64),
+        classifier_hidden_dim=checkpoint_arg(checkpoint_args, "classifier_hidden_dim", 512),
+        dropout=checkpoint_arg(checkpoint_args, "dropout", 0.3),
+        imagenet_pretrained=False,
+        clinical_backbone_backend=clinical_backend,
+        dermoscopic_backbone_backend=dermoscopic_backend,
+    ).to(device)
+    model.load_state_dict(state)
+    model.eval()
+    return model
+
+
+@torch.no_grad()
+def predict_dataframe(model: DualEffB2MetadataClassifier, loader: DataLoader, device: torch.device) -> np.ndarray:
+    probs_all = []
+    for batch in tqdm(loader, leave=False):
+        clinical = batch["clinical"].to(device, non_blocking=True)
+        dermoscopic = batch["dermoscopic"].to(device, non_blocking=True)
+        metadata = batch["metadata"].to(device, non_blocking=True)
+        logits = model(clinical, dermoscopic, metadata)
+        probs_all.append(torch.softmax(logits, dim=1).cpu().numpy())
+    return np.concatenate(probs_all)
+
+
+def save_inference_outputs(df: pd.DataFrame, y_prob: np.ndarray, class_names: list[str], output: Path) -> None:
+    y_pred = y_prob.argmax(axis=1)
+    prediction_df = pd.DataFrame(
+        {
+            "lesion_id": df["lesion_id"].tolist(),
+            "clinical_file": [Path(path).name for path in df["clinical_path"].tolist()],
+            "dermoscopic_file": [Path(path).name for path in df["dermoscopic_path"].tolist()],
+            "clinical_isic_id": df.get("clinical_isic_id", pd.Series([""] * len(df))).tolist(),
+            "dermoscopic_isic_id": df.get("dermoscopic_isic_id", pd.Series([""] * len(df))).tolist(),
+            "y_pred": y_pred,
+            "label_pred": [class_names[idx] for idx in y_pred],
+            "confidence": y_prob.max(axis=1),
+        }
+    )
+    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)
+
+
+def main() -> None:
+    args = parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    checkpoint = torch.load(args.checkpoint, map_location=device, weights_only=False)
+    metadata_spec = checkpoint["metadata_spec"]
+    class_names = checkpoint["class_names"]
+    checkpoint_args = checkpoint.get("args", {})
+    image_size = args.image_size or int(checkpoint_args.get("image_size", 260))
+
+    input_dir, metadata_csv, groundtruth_csv = resolve_input_paths(args)
+    df = load_inference_dataframe(input_dir, metadata_csv, groundtruth_csv)
+    _, eval_transform = make_transforms(image_size)
+    dataset = InferencePairedDataset(df, metadata_spec, eval_transform)
+    loader = DataLoader(
+        dataset,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        pin_memory=torch.cuda.is_available(),
+        shuffle=False,
+    )
+    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)
+
+    print(f"Saved predictions: {args.output}")
+    if "label" in df.columns and df["label"].notna().all():
+        label_to_idx = {label: idx for idx, label in enumerate(class_names)}
+        y_true = np.array([label_to_idx[label] for label in df["label"]])
+        metrics, _, _ = compute_metrics(y_true, y_prob, class_names)
+        metrics_path = args.output.with_suffix(".metrics.json")
+        with open(metrics_path, "w", encoding="utf-8") as f:
+            import json
+
+            json.dump(json_safe(metrics), f, indent=2)
+        print(f"Saved metrics: {metrics_path}")
+
+
+if __name__ == "__main__":
+    main()

milk10k_effb2_metadata/training.py

@@ -203,6 +203,10 @@ def train_phase(
                 metadata_spec,
                 args,
             )
+            print(
+                f"Saved best checkpoint: phase={phase} epoch={epoch:03d} "
+                f"best_val_f1_macro={best_val_f1:.4f} path={output_dir / 'best.pt'}"
+            )
         else:
             patience_count += 1
             if patience_count >= args.patience:

predict_milk10k_effb2_dual_metadata.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+"""Run inference with a MILK10k dual EfficientNet-B2 metadata checkpoint."""
+
+from milk10k_effb2_metadata.inference import main
+
+
+if __name__ == "__main__":
+    main()