Upload 114 files

milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md

@@ -20,16 +20,11 @@ Training code is split by responsibility:
 ```text
 training.py         Thin entry facade: normalize args, load dataframe, choose single run vs k-fold.
 runner.py           Full split runner: split CSVs, loaders, loss, train phases, final metrics/files.
-engine.py           Epoch/phase loop: run_epoch, train_phase, save best/last checkpoints.
+engine.py           Epoch/phase loop: run_epoch, train_phase, save best checkpoint.
 model_setup.py      Backend detection, model construction, resume checkpoint, optimizer param groups.
 training_utils.py   JSON-safe serialization, run_config.json, kfold_summary.csv/json.
 ```
 
-Training always writes both checkpoint types to the run directory:
-
-- `best.pt`: epoch with the best configured validation selection metric.
-- `last.pt`: most recently completed epoch, updated after every epoch and also available when early stopping triggers.
-
 Common places to edit:
 
 ```text
@@ -184,28 +179,6 @@ python train_milk10k_effb2_dual_metadata.py \
   --output-dir milk10k_effb2_sampler_p05
 ```
 
-## Hybrid epoch balancing
-
-Use hybrid balancing when the largest class dominates training but inverse-frequency
-loss weights make predictions too soft:
-
-```bash
-python train_milk10k_effb2_dual_metadata.py \
-  --data-dir /path/to/milk10k \
-  --balance-mode hybrid \
-  --balance-head-ratio 2.0 \
-  --balance-tail-floor 100 \
-  --balance-min-source-count 20 \
-  --loss ce \
-  --output-dir milk10k_effb2_hybrid_balance
-```
-
-The largest class is sampled without replacement up to twice the second-largest
-class. Eligible classes below 100 rows are sampled with replacement to 100 rows
-and receive the stronger train transform. Classes with fewer than 20 source rows
-are left unchanged. Sampling changes by epoch and is reproducible from `--seed`.
-Validation is never resampled. Do not combine this mode with `--weighted-sampler`.
-
 Stronger sampling:
 
 ```bash

milk10k_effb2_metadata/checkpoints.py

@@ -9,8 +9,8 @@ from typing import Any
 import torch
 from torch import nn
 
-CHECKPOINT_STATE_KEYS = ("encoder_state_dict", "model_state", "model_state_dict", "state_dict")
-PREFIXES_TO_STRIP = ("module.", "model.", "encoder.", "backbone.", "_orig_mod.")
+CHECKPOINT_STATE_KEYS = ("model_state", "model_state_dict", "state_dict")
+PREFIXES_TO_STRIP = ("module.", "model.", "_orig_mod.")
 
 
 def extract_state_dict(checkpoint: Any) -> dict[str, torch.Tensor]:
@@ -91,3 +91,4 @@ 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

@@ -9,18 +9,6 @@ from pathlib import Path
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="Train MILK10k dual-image backbones with metadata fusion.")
     parser.add_argument("--data-dir", type=Path, default=None)
-    parser.add_argument(
-        "--dermoscopic-mask-dir",
-        type=Path,
-        default=None,
-        help="Optional directory containing <lesion_id>_dermoscopic_mask.png files.",
-    )
-    parser.add_argument(
-        "--min-dermoscopic-mask-ratio",
-        type=float,
-        default=0.01,
-        help="Fallback to the original dermoscopic image when mask foreground ratio is below this value.",
-    )
     parser.add_argument(
         "--clinical-checkpoint",
         type=Path,
@@ -47,10 +35,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--backbone",
         default="efficientnet_b2",
-        help=(
-            "Backbone model architecture (efficientnet_b2, tf_efficientnetv2_b2, "
-            "efficientnet_b1, resnet50, convnext_base)."
-        ),
+        help="Backbone model architecture (efficientnet_b2, efficientnet_b1, resnet50, convnext_base).",
     )
     parser.add_argument(
         "--num-workers",
@@ -137,15 +122,6 @@ 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",
@@ -159,30 +135,6 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--class-weight", action="store_true")
     parser.add_argument("--weighted-sampler", action="store_true")
     parser.add_argument("--sampler-power", type=float, default=1.0)
-    parser.add_argument(
-        "--balance-mode",
-        choices=["none", "hybrid"],
-        default="none",
-        help="Train-only epoch balancing. hybrid caps the largest class and mildly oversamples eligible tail classes.",
-    )
-    parser.add_argument(
-        "--balance-head-ratio",
-        type=float,
-        default=2.0,
-        help="In hybrid mode, cap the largest class at this multiple of the second-largest class.",
-    )
-    parser.add_argument(
-        "--balance-tail-floor",
-        type=int,
-        default=100,
-        help="In hybrid mode, oversample eligible classes below this count up to this many rows per epoch.",
-    )
-    parser.add_argument(
-        "--balance-min-source-count",
-        type=int,
-        default=20,
-        help="Do not oversample a class with fewer real train rows than this value.",
-    )
     parser.add_argument("--loss", choices=["ce", "focal", "ldam", "ce_dice", "ce_f1"], default="ce")
     parser.add_argument("--focal-gamma", type=float, default=2.0)
     parser.add_argument("--dice-weight", type=float, default=0.3)
@@ -243,8 +195,4 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--calibration-step", type=float, default=0.25)
     parser.add_argument("--calibration-passes", type=int, default=3)
     parser.add_argument("--patience", type=int, default=6)
-    parser.add_argument("--tau", type=float, default=0.0, help="Logit adjustment parameter for Generalized Balanced Softmax")
-    parser.add_argument("--lws-epochs", type=int, default=0, help="Number of epochs to train Learnable Weight Scaling (LWS) post-training")
-    parser.add_argument("--ema", action="store_true", help="Enable Exponential Moving Average (EMA) for model weights")
-    parser.add_argument("--ema-decay", type=float, default=0.999, help="Decay rate for EMA")
     return parser.parse_args()

milk10k_effb2_metadata/data.py

@@ -11,7 +11,7 @@ import pandas as pd
 import torch
 from PIL import Image, ImageFile
 from sklearn.model_selection import StratifiedKFold, train_test_split
-from torch.utils.data import DataLoader, Dataset, Sampler, WeightedRandomSampler
+from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler
 from torchvision import transforms
 
 from datasets import LABEL_COLUMNS, normalize_image_type
@@ -19,110 +19,6 @@ from datasets import LABEL_COLUMNS, normalize_image_type
 ImageFile.LOAD_TRUNCATED_IMAGES = True
 
 METADATA_COLUMNS = ("age_approx", "sex", "skin_tone_class", "site")
-DERMOSCOPIC_MASK_PATH_COLUMN = "dermoscopic_mask_path"
-DERMOSCOPIC_MASK_RATIO_COLUMN = "dermoscopic_mask_ratio"
-DERMOSCOPIC_MASK_STATUS_COLUMN = "dermoscopic_mask_status"
-
-
-def apply_dermoscopic_mask(image: Image.Image, mask_path: str | Path | None) -> Image.Image:
-    """Return an RGB image with non-mask pixels black, or the original RGB image on read failure."""
-    image = image.convert("RGB")
-    if not isinstance(mask_path, (str, Path)) or not str(mask_path):
-        return image
-    try:
-        with Image.open(mask_path) as mask_image:
-            mask = mask_image.convert("L")
-            if mask.size != image.size:
-                return image
-            binary_mask = mask.point(lambda value: 255 if value else 0)
-            return Image.composite(image, Image.new("RGB", image.size), binary_mask)
-    except (OSError, ValueError):
-        return image
-
-
-def audit_dermoscopic_masks(
-    df: pd.DataFrame,
-    mask_dir: Path,
-    min_foreground_ratio: float = 0.01,
-    mask_id_column: str = "lesion_id",
-    mask_suffix: str = "_dermoscopic_mask.png",
-) -> tuple[pd.DataFrame, pd.DataFrame]:
-    """Attach valid mask paths and return one audit row per paired dermoscopic image."""
-    if not 0.0 <= min_foreground_ratio <= 1.0:
-        raise ValueError("--min-dermoscopic-mask-ratio must be between 0 and 1.")
-    mask_dir = mask_dir.expanduser().resolve()
-    if not mask_dir.is_dir():
-        raise FileNotFoundError(f"Dermoscopic mask directory does not exist: {mask_dir}")
-    if mask_id_column not in df.columns:
-        raise ValueError(f"Mask ID column is missing from dataframe: {mask_id_column}")
-
-    audited_df = df.copy()
-    mask_paths: list[str | None] = []
-    ratios: list[float | None] = []
-    statuses: list[str] = []
-    audit_rows: list[dict[str, Any]] = []
-
-    for _, row in audited_df.iterrows():
-        lesion_id = str(row["lesion_id"])
-        mask_id = str(row[mask_id_column])
-        image_path = Path(row["dermoscopic_path"])
-        mask_path = mask_dir / f"{mask_id}{mask_suffix}"
-        ratio: float | None = None
-        status = "valid"
-        image_size: tuple[int, int] | None = None
-        mask_size: tuple[int, int] | None = None
-
-        if not mask_path.is_file():
-            status = "missing"
-        else:
-            try:
-                with Image.open(image_path) as image:
-                    image_size = image.size
-                with Image.open(mask_path) as mask_image:
-                    mask = mask_image.convert("L")
-                    mask.load()
-                    mask_size = mask.size
-                    histogram = mask.histogram()
-                    total_pixels = mask.width * mask.height
-                    ratio = (total_pixels - histogram[0]) / total_pixels if total_pixels else 0.0
-                if mask_size != image_size:
-                    status = "size_mismatch"
-                elif ratio < min_foreground_ratio:
-                    status = "too_small"
-            except (OSError, ValueError):
-                status = "unreadable"
-
-        valid_path = str(mask_path) if status == "valid" else None
-        mask_paths.append(valid_path)
-        ratios.append(ratio)
-        statuses.append(status)
-        audit_rows.append(
-            {
-                "lesion_id": lesion_id,
-                "mask_id": mask_id,
-                "dermoscopic_path": str(image_path),
-                "mask_path": str(mask_path),
-                "foreground_ratio": ratio,
-                "status": status,
-                "image_size": None if image_size is None else f"{image_size[0]}x{image_size[1]}",
-                "mask_size": None if mask_size is None else f"{mask_size[0]}x{mask_size[1]}",
-            }
-        )
-
-    audited_df[DERMOSCOPIC_MASK_PATH_COLUMN] = mask_paths
-    audited_df[DERMOSCOPIC_MASK_RATIO_COLUMN] = ratios
-    audited_df[DERMOSCOPIC_MASK_STATUS_COLUMN] = statuses
-    return audited_df, pd.DataFrame(audit_rows)
-
-
-def print_mask_audit_summary(audit_df: pd.DataFrame, min_foreground_ratio: float) -> None:
-    counts = audit_df["status"].value_counts().sort_index().to_dict()
-    valid = int(counts.get("valid", 0))
-    print(
-        "Dermoscopic masks: "
-        f"total={len(audit_df)}, valid={valid}, fallback={len(audit_df) - valid}, "
-        f"min_foreground_ratio={min_foreground_ratio:.6f}, status_counts={counts}"
-    )
 
 
 class PairedMilk10kMetadataDataset(Dataset):
@@ -132,8 +28,6 @@ class PairedMilk10kMetadataDataset(Dataset):
         label_to_idx: dict[str, int],
         metadata_spec: dict[str, Any],
         transform=None,
-        strong_transform=None,
-        strong_augment_labels: set[int] | None = None,
     ) -> None:
         self.df = df.reset_index(drop=True)
         self.labels = [label_to_idx[label] for label in self.df["label"].tolist()]
@@ -142,87 +36,24 @@ class PairedMilk10kMetadataDataset(Dataset):
             ignore_mask = self.df["ignore_metadata"].fillna(False).astype(bool).to_numpy()
             self.metadata[ignore_mask] = 0.0
         self.transform = transform
-        self.strong_transform = strong_transform
-        self.strong_augment_labels = strong_augment_labels or set()
 
     def __len__(self) -> int:
         return len(self.df)
 
-    def _load_image(
-        self,
-        path: str,
-        mask_path: str | Path | None = None,
-        transform=None,
-    ) -> torch.Tensor:
+    def _load_image(self, path: str) -> torch.Tensor:
         with Image.open(path) as img:
-            image = apply_dermoscopic_mask(img, mask_path)
-        transform = self.transform if transform is None else transform
-        if transform is not None:
-            image = transform(image)
+            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]
-        label = self.labels[idx]
-        transform = self.strong_transform if label in self.strong_augment_labels else self.transform
         return {
-            "clinical": self._load_image(row["clinical_path"], transform=transform),
-            "dermoscopic": self._load_image(
-                row["dermoscopic_path"],
-                row.get(DERMOSCOPIC_MASK_PATH_COLUMN),
-                transform,
-            ),
+            "clinical": self._load_image(row["clinical_path"]),
+            "dermoscopic": self._load_image(row["dermoscopic_path"]),
             "metadata": torch.from_numpy(self.metadata[idx]),
-            "label": torch.tensor(label, dtype=torch.long),
-        }
-
-
-class HybridEpochSampler(Sampler[int]):
-    """Cap the largest class and oversample eligible tail classes per epoch."""
-
-    def __init__(
-        self,
-        labels: list[int],
-        target_counts: np.ndarray,
-        seed: int,
-        label_names: dict[int, str] | None = None,
-    ) -> None:
-        self.labels = np.asarray(labels, dtype=np.int64)
-        self.target_counts = np.asarray(target_counts, dtype=np.int64)
-        self.seed = int(seed)
-        self.epoch = 0
-        self.label_names = label_names or {}
-        self.class_indices = [np.flatnonzero(self.labels == idx) for idx in range(len(self.target_counts))]
-        self.original_counts = np.asarray([len(indices) for indices in self.class_indices], dtype=np.int64)
-
-    def __len__(self) -> int:
-        return int(self.target_counts.sum())
-
-    def set_epoch(self, epoch: int) -> None:
-        self.epoch = int(epoch)
-
-    def __iter__(self):
-        generator = torch.Generator().manual_seed(self.seed + self.epoch)
-        selected: list[torch.Tensor] = []
-        for indices, target in zip(self.class_indices, self.target_counts):
-            source = torch.as_tensor(indices, dtype=torch.long)
-            target = int(target)
-            if target <= len(source):
-                selected.append(source[torch.randperm(len(source), generator=generator)[:target]])
-                continue
-            full_repeats, remainder = divmod(target, len(source))
-            chunks = [source[torch.randperm(len(source), generator=generator)] for _ in range(full_repeats)]
-            if remainder:
-                chunks.append(source[torch.randperm(len(source), generator=generator)[:remainder]])
-            selected.append(torch.cat(chunks))
-        epoch_indices = torch.cat(selected)
-        order = torch.randperm(len(epoch_indices), generator=generator)
-        return iter(epoch_indices[order].tolist())
-
-    def exposure_summary(self) -> dict[str, int]:
-        return {
-            self.label_names.get(idx, str(idx)): int(count)
-            for idx, count in enumerate(self.target_counts)
+            "label": torch.tensor(self.labels[idx], dtype=torch.long),
         }
 
 
@@ -398,62 +229,6 @@ def make_transforms(image_size: int):
     return train_transform, eval_transform
 
 
-def make_strong_train_transform(image_size: int):
-    """A conservative stronger variant used only for oversampled tail classes."""
-    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-    return transforms.Compose(
-        [
-            transforms.RandomResizedCrop(image_size, scale=(0.65, 1.0), ratio=(1.15, 1.5)),
-            transforms.RandomHorizontalFlip(),
-            transforms.RandomVerticalFlip(),
-            transforms.RandomRotation(30),
-            transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.25),
-            transforms.RandomAffine(degrees=0, translate=(0.05, 0.05), scale=(0.95, 1.05)),
-            transforms.ToTensor(),
-            normalize,
-        ]
-    )
-
-
-def hybrid_target_counts(labels: list[int], args: argparse.Namespace) -> tuple[np.ndarray, set[int]]:
-    """Return per-class epoch targets and classes eligible for strong augmentation."""
-    counts = np.bincount(np.asarray(labels, dtype=np.int64))
-    if np.any(counts == 0):
-        raise ValueError("Cannot build hybrid sampler because at least one class has zero training samples.")
-    targets = counts.copy()
-
-    if len(counts) >= 2:
-        descending = np.argsort(-counts, kind="stable")
-        head_idx, second_idx = int(descending[0]), int(descending[1])
-        head_cap = max(1, int(np.floor(counts[second_idx] * args.balance_head_ratio)))
-        targets[head_idx] = min(int(counts[head_idx]), head_cap)
-
-    strong_labels: set[int] = set()
-    for idx, count in enumerate(counts):
-        if args.balance_min_source_count <= count < args.balance_tail_floor:
-            targets[idx] = args.balance_tail_floor
-            strong_labels.add(idx)
-    return targets, strong_labels
-
-
-def hybrid_balance_summary(
-    labels: list[int],
-    label_names: dict[int, str],
-    args: argparse.Namespace,
-) -> dict[str, Any]:
-    counts = np.bincount(np.asarray(labels, dtype=np.int64))
-    targets, strong_labels = hybrid_target_counts(labels, args)
-    return {
-        "mode": "hybrid",
-        "original_class_counts": {label_names[idx]: int(count) for idx, count in enumerate(counts)},
-        "effective_class_counts_per_epoch": {
-            label_names[idx]: int(count) for idx, count in enumerate(targets)
-        },
-        "strong_augmentation_classes": [label_names[idx] for idx in sorted(strong_labels)],
-        "effective_rows_per_epoch": int(targets.sum()),
-    }
-
-
 def make_loaders(
     train_df: pd.DataFrame,
     val_df: pd.DataFrame,
@@ -462,24 +237,7 @@ def make_loaders(
     args: argparse.Namespace,
 ) -> tuple[DataLoader, DataLoader]:
     train_transform, eval_transform = make_transforms(args.image_size)
-    label_names = {idx: label for label, idx in label_to_idx.items()}
-    train_labels = [label_to_idx[label] for label in train_df["label"].tolist()]
-    sampler = None
-    strong_transform = None
-    strong_labels: set[int] = set()
-    if args.balance_mode == "hybrid":
-        targets, strong_labels = hybrid_target_counts(train_labels, args)
-        sampler = HybridEpochSampler(train_labels, targets, args.seed, label_names)
-        strong_transform = make_strong_train_transform(args.image_size)
-
-    train_ds = PairedMilk10kMetadataDataset(
-        train_df,
-        label_to_idx,
-        metadata_spec,
-        train_transform,
-        strong_transform=strong_transform,
-        strong_augment_labels=strong_labels,
-    )
+    train_ds = PairedMilk10kMetadataDataset(train_df, label_to_idx, metadata_spec, train_transform)
     val_ds = PairedMilk10kMetadataDataset(val_df, label_to_idx, metadata_spec, eval_transform)
     common = dict(
         batch_size=args.batch_size,
@@ -487,8 +245,7 @@ def make_loaders(
         pin_memory=torch.cuda.is_available(),
         drop_last=False,
     )
-    if args.weighted_sampler:
-        sampler = build_weighted_sampler(train_ds, args)
+    sampler = build_weighted_sampler(train_ds, args) if args.weighted_sampler else None
     train_loader = DataLoader(train_ds, shuffle=sampler is None, sampler=sampler, **common)
     val_loader = DataLoader(val_ds, shuffle=False, **common)
     return train_loader, val_loader

milk10k_effb2_metadata/engine.py

@@ -35,7 +35,6 @@ def run_epoch(
     use_amp: bool = False,
     tail_class_indices: list[int] | None = None,
     class_names: list[str] | None = None,
-    ema_model: nn.Module | None = None,
 ) -> dict[str, float]:
     training = optimizer is not None
     model.train(training)
@@ -66,8 +65,6 @@ def run_epoch(
                     loss.backward()
                     torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
                     optimizer.step()
-                if ema_model is not None:
-                    ema_model.update_parameters(model)
 
         batch_size = labels.size(0)
         total_loss += float(loss.detach().item()) * batch_size
@@ -164,7 +161,6 @@ def save_checkpoint(
     metadata_spec: dict[str, Any],
     args: argparse.Namespace,
     extra: dict[str, Any] | None = None,
-    ema_model: nn.Module | None = None,
 ) -> None:
     payload = {
         "epoch": epoch,
@@ -180,8 +176,6 @@ def save_checkpoint(
         "metadata_spec": metadata_spec,
         "args": json_safe(vars(args)),
     }
-    if ema_model is not None:
-        payload["ema_model_state"] = ema_model.state_dict()
     if extra:
         payload.update(json_safe(extra))
     torch.save(payload, path)
@@ -208,7 +202,6 @@ def train_phase(
     tail_class_names: list[str] | None = None,
     train_class_counts: dict[str, int] | None = None,
     best_val_tail_recall: float = float("-inf"),
-    ema_model: nn.Module | None = None,
 ) -> tuple[int, float, float]:
     if num_epochs <= 0:
         return start_epoch, best_val_f1, best_val_tail_recall
@@ -229,11 +222,6 @@ def train_phase(
             continue
         if hasattr(criterion, "set_epoch"):
             criterion.set_epoch(epoch)
-        sampler = getattr(train_loader, "sampler", None)
-        if hasattr(sampler, "set_epoch"):
-            sampler.set_epoch(epoch)
-        if hasattr(sampler, "exposure_summary"):
-            print(f"Hybrid balance epoch {epoch:03d}: effective_class_counts={sampler.exposure_summary()}")
         train_stats = run_epoch(
             model,
             train_loader,
@@ -244,11 +232,9 @@ def train_phase(
             use_amp,
             tail_class_indices,
             class_names,
-            ema_model=ema_model,
         )
-        eval_model = ema_model if ema_model is not None else model
         val_stats = run_epoch(
-            eval_model,
+            model,
             val_loader,
             criterion,
             device,
@@ -297,7 +283,6 @@ def train_phase(
                 label_to_idx,
                 metadata_spec,
                 args,
-                ema_model=ema_model,
             )
             print(
                 f"Saved best checkpoint: phase={phase} epoch={epoch:03d} "
@@ -326,35 +311,12 @@ def train_phase(
                     "train_class_counts": train_class_counts or {},
                     "selection_metric": "val_tail_recall_macro",
                 },
-                ema_model=ema_model,
             )
             print(
                 f"Saved tail checkpoint: phase={phase} epoch={epoch:03d} "
                 f"best_val_tail_recall_macro={best_val_tail_recall:.4f} path={output_dir / 'tail_best.pt'}"
             )
 
-        save_checkpoint(
-            output_dir / "last.pt",
-            model,
-            optimizer,
-            epoch,
-            phase,
-            best_val_f1,
-            class_names,
-            label_to_idx,
-            metadata_spec,
-            args,
-            {
-                "last_selection_metric": float(val_stats[selection_metric]),
-                "last_val_stats": val_stats,
-            },
-            ema_model=ema_model,
-        )
-        print(
-            f"Saved last checkpoint: phase={phase} epoch={epoch:03d} "
-            f"{selection_metric}={val_stats[selection_metric]:.4f} path={output_dir / 'last.pt'}"
-        )
-
         if patience_count >= args.patience:
             print(f"Early stopping {phase} at epoch {epoch}")
             break

milk10k_effb2_metadata/inference.py

@@ -15,16 +15,7 @@ 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 (
-    DERMOSCOPIC_MASK_PATH_COLUMN,
-    METADATA_COLUMNS,
-    apply_dermoscopic_mask,
-    audit_dermoscopic_masks,
-    make_transforms,
-    metadata_vector,
-    print_mask_audit_summary,
-    resolve_monet_columns,
-)
+from milk10k_effb2_metadata.data import METADATA_COLUMNS, make_transforms, metadata_vector, resolve_monet_columns
 from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics
 from milk10k_effb2_metadata.models import (
     DualEffB2MetadataClassifier,
@@ -44,9 +35,9 @@ class InferencePairedDataset(Dataset):
     def __len__(self) -> int:
         return len(self.df)
 
-    def _load_image(self, path: str, mask_path: str | Path | None = None) -> torch.Tensor:
+    def _load_image(self, path: str) -> torch.Tensor:
         with Image.open(path) as img:
-            image = apply_dermoscopic_mask(img, mask_path)
+            image = img.convert("RGB")
         if self.transform is not None:
             image = self.transform(image)
         return image
@@ -55,10 +46,7 @@ class InferencePairedDataset(Dataset):
         row = self.df.iloc[idx]
         return {
             "clinical": self._load_image(row["clinical_path"]),
-            "dermoscopic": self._load_image(
-                row["dermoscopic_path"],
-                row.get(DERMOSCOPIC_MASK_PATH_COLUMN),
-            ),
+            "dermoscopic": self._load_image(row["dermoscopic_path"]),
             "metadata": torch.from_numpy(self.metadata[idx]),
         }
 
@@ -75,18 +63,6 @@ def parse_args() -> argparse.Namespace:
     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(
-        "--dermoscopic-mask-dir",
-        type=Path,
-        default=None,
-        help="Optional directory containing <lesion_id>_dermoscopic_mask.png files.",
-    )
-    parser.add_argument(
-        "--min-dermoscopic-mask-ratio",
-        type=float,
-        default=0.01,
-        help="Fallback to the original dermoscopic image when mask foreground ratio is below this value.",
-    )
     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)
@@ -222,7 +198,6 @@ 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),
@@ -319,21 +294,6 @@ def main() -> None:
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     input_dir, metadata_csv, groundtruth_csv = resolve_input_paths(args)
     df = load_inference_dataframe(input_dir, metadata_csv, groundtruth_csv)
-    if not 0.0 <= args.min_dermoscopic_mask_ratio <= 1.0:
-        raise ValueError("--min-dermoscopic-mask-ratio must be between 0 and 1.")
-    if args.dermoscopic_mask_dir is not None:
-        args.dermoscopic_mask_dir = args.dermoscopic_mask_dir.expanduser().resolve()
-        df, mask_audit = audit_dermoscopic_masks(
-            df,
-            args.dermoscopic_mask_dir,
-            args.min_dermoscopic_mask_ratio,
-            mask_id_column="dermoscopic_isic_id",
-            mask_suffix="_mask.png",
-        )
-        audit_output = args.output.with_name(f"{args.output.stem}.mask_audit.csv")
-        audit_output.parent.mkdir(parents=True, exist_ok=True)
-        mask_audit.to_csv(audit_output, index=False)
-        print_mask_audit_summary(mask_audit, args.min_dermoscopic_mask_ratio)
     checkpoint_paths = resolve_checkpoint_paths(args)
     ensemble_probs = []
     class_names: list[str] | None = None

milk10k_effb2_metadata/losses.py

@@ -27,28 +27,6 @@ class FocalLoss(nn.Module):
         return loss.mean()
 
 
-class GeneralizedBalancedSoftmaxLoss(nn.Module):
-    def __init__(
-        self,
-        class_counts: torch.Tensor,
-        tau: float = 1.0,
-        weight: torch.Tensor | None = None,
-    ) -> None:
-        super().__init__()
-        self.tau = tau
-        self.weight = weight
-        counts = class_counts.float().clamp_min(1.0)
-        self.register_buffer("log_counts", torch.log(counts))
-
-    def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
-        if self.training and self.tau > 0.0:
-            log_counts = self.log_counts.to(device=logits.device, dtype=logits.dtype)
-            adjusted_logits = logits + self.tau * log_counts
-        else:
-            adjusted_logits = logits
-        return F.cross_entropy(adjusted_logits, labels, weight=self.weight)
-
-
 class LDAMLoss(nn.Module):
     """LDAM with deferred effective-number reweighting."""
 
@@ -201,12 +179,7 @@ def build_loss(train_df: pd.DataFrame, label_to_idx: dict[str, int], args: argpa
         y = np.array([label_to_idx[label] for label in train_df["label"]])
         weights = compute_class_weight(class_weight="balanced", classes=np.arange(len(label_to_idx)), y=y)
         weight = torch.tensor(weights, dtype=torch.float32, device=device)
-        
-    if getattr(args, "tau", 0.0) > 0.0:
-        counts = class_count_tensor(train_df, label_to_idx, device)
-        ce_loss: nn.Module = GeneralizedBalancedSoftmaxLoss(counts, tau=args.tau, weight=weight)
-    else:
-        ce_loss: nn.Module = nn.CrossEntropyLoss(weight=weight)
+    ce_loss: nn.Module = nn.CrossEntropyLoss(weight=weight)
     if args.loss == "focal":
         return FocalLoss(weight=weight, gamma=args.focal_gamma)
     if args.loss == "ce_dice":

milk10k_effb2_metadata/model_setup.py

@@ -103,7 +103,6 @@ def load_resume_checkpoint(
     checkpoint_path: Path | None,
     model: DualEffB2MetadataClassifier,
     device: torch.device,
-    ema_model: torch.nn.Module | None = None,
 ) -> tuple[int, float, str | None]:
     if checkpoint_path is None:
         return 1, float("-inf"), None
@@ -112,8 +111,6 @@ def load_resume_checkpoint(
         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"])
-    if ema_model is not None and "ema_model_state" in checkpoint:
-        ema_model.load_state_dict(checkpoint["ema_model_state"])
     next_epoch = int(checkpoint.get("epoch", 0)) + 1
     best_val_f1 = float(
         checkpoint.get(
@@ -155,7 +152,6 @@ 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,7 +107,6 @@ 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,
@@ -129,8 +128,6 @@ 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)
@@ -138,7 +135,6 @@ 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
@@ -216,35 +212,16 @@ 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, classifier_style)
-        )
+        self.classifier = None if image_fusion == "moe" else self._classifier(fused_dim, classifier_hidden_dim, num_classes, dropout)
         if logit_fusion_mode == "fixed":
             self.clinical_classifier = BranchClassifier(branch_dim, num_classes, dropout)
             self.dermoscopic_classifier = BranchClassifier(branch_dim, num_classes, dropout)
         else:
             self.clinical_classifier = None
             self.dermoscopic_classifier = None
-            
-        self.class_scales = nn.Parameter(torch.ones(num_classes))
 
     @staticmethod
-    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),
-            )
+    def _classifier(in_dim: int, hidden_dim: int, num_classes: int, dropout: float) -> nn.Sequential:
         return nn.Sequential(
             nn.LayerNorm(in_dim),
             nn.Dropout(dropout),
@@ -310,14 +287,14 @@ class DualEffB2MetadataClassifier(nn.Module):
             fused = self._fused_features(clinical_features, dermoscopic_features, clinical_repr, dermoscopic_repr, metadata_repr)
             fusion_logits = self.classifier(fused)
         if self.logit_fusion_mode != "fixed":
-            return fusion_logits * self.class_scales
+            return fusion_logits
         clinical_logits = self.clinical_classifier(clinical_repr)
         dermoscopic_logits = self.dermoscopic_classifier(dermoscopic_repr)
         return (
             self.fusion_logit_weight * fusion_logits
             + self.clinical_logit_weight * clinical_logits
             + self.dermoscopic_logit_weight * dermoscopic_logits
-        ) * self.class_scales
+        )
 
     def _append_metadata(self, features: torch.Tensor, metadata_repr: torch.Tensor | None) -> torch.Tensor:
         if metadata_repr is None:
@@ -424,8 +401,6 @@ 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"):
@@ -450,8 +425,6 @@ 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":
@@ -505,8 +478,6 @@ 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

milk10k_effb2_metadata/reporting.py

@@ -95,11 +95,6 @@ def class_distribution(df: pd.DataFrame, class_names: list[str]) -> dict[str, An
         if len(df)
         else {name: 0 for name in class_names}
     )
-    mask_status_counts = (
-        df["dermoscopic_mask_status"].fillna("not_audited").value_counts().sort_index().astype(int).to_dict()
-        if "dermoscopic_mask_status" in df.columns
-        else {}
-    )
     return {
         "rows": int(len(df)),
         "class_counts": counts,
@@ -107,7 +102,6 @@ def class_distribution(df: pd.DataFrame, class_names: list[str]) -> dict[str, An
         "synthetic_rows": int(is_augmented.sum()),
         "synthetic_class_counts": augmented_counts,
         "ignore_metadata_rows": int(ignore_metadata.sum()),
-        "dermoscopic_mask_status_counts": mask_status_counts,
     }
 
 
@@ -359,21 +353,6 @@ def render_split_summary(data_summary: dict[str, Any]) -> str:
             lines.append(f"| {class_name} | {count} | {summary['synthetic_class_counts'].get(class_name, 0)} |")
         lines.append("")
     lines.append(f"- synthetic_train_only: {data_summary['synthetic_train_only']}")
-    balance = data_summary.get("balance")
-    if balance:
-        lines.extend(
-            [
-                f"- balance_mode: {balance['mode']}",
-                f"- effective_rows_per_epoch: {balance['effective_rows_per_epoch']}",
-                f"- strong_augmentation_classes: {balance['strong_augmentation_classes']}",
-                "",
-                "| class | original train | effective per epoch |",
-                "|---|---:|---:|",
-            ]
-        )
-        for class_name, count in balance["original_class_counts"].items():
-            effective = balance["effective_class_counts_per_epoch"][class_name]
-            lines.append(f"| {class_name} | {count} | {effective} |")
     lines.append("")
     return "\n".join(lines)
 
@@ -401,13 +380,7 @@ def render_run_report(
             f"- loss: {getattr(args, 'loss', None)}",
             f"- class_weight: {getattr(args, 'class_weight', None)}",
             f"- weighted_sampler: {getattr(args, 'weighted_sampler', None)}",
-            f"- balance_mode: {getattr(args, 'balance_mode', None)}",
-            f"- balance_head_ratio: {getattr(args, 'balance_head_ratio', None)}",
-            f"- balance_tail_floor: {getattr(args, 'balance_tail_floor', None)}",
-            f"- balance_min_source_count: {getattr(args, 'balance_min_source_count', None)}",
             f"- augmented_data_dir: {getattr(args, 'augmented_data_dir', None)}",
-            f"- dermoscopic_mask_dir: {getattr(args, 'dermoscopic_mask_dir', None)}",
-            f"- min_dermoscopic_mask_ratio: {getattr(args, 'min_dermoscopic_mask_ratio', None)}",
             f"- augmented_classes: {getattr(args, 'augmented_classes', None)}",
             f"- augmented_max_per_class: {getattr(args, 'augmented_max_per_class', None)}",
             f"- freeze_metadata_head: {getattr(args, 'freeze_metadata_head', None)}",

milk10k_effb2_metadata/runner.py

@@ -12,7 +12,6 @@ import torch
 
 from milk10k_effb2_metadata.data import (
     fit_metadata_spec,
-    hybrid_balance_summary,
     kfold_splits,
     lesion_split,
     load_paired_dataframe,
@@ -25,89 +24,6 @@ from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics, op
 from milk10k_effb2_metadata.model_setup import build_model, load_resume_checkpoint
 from milk10k_effb2_metadata.reporting import build_data_summary, save_data_summary, save_kfold_report, save_run_diagnostics
 from milk10k_effb2_metadata.training_utils import json_safe, save_kfold_summary, save_run_config
-import torch.nn.functional as F
-
-def train_lws_post_training(
-    model: DualEffB2MetadataClassifier,
-    train_loader: DataLoader,
-    criterion: nn.Module,
-    device: torch.device,
-    args: argparse.Namespace,
-    ema_model: nn.Module | None = None,
-) -> None:
-    if args.lws_epochs <= 0:
-        return
-        
-    print(f"\nStarting LWS Post-Training for {args.lws_epochs} epochs...")
-    model.requires_grad_(False)
-    model.class_scales.requires_grad_(True)
-    
-    optimizer = torch.optim.Adam([model.class_scales], lr=args.head_lr)
-    
-    from milk10k_effb2_metadata.data import build_weighted_sampler
-    dataset = train_loader.dataset
-    # Force weighted sampler for LWS
-    lws_sampler = build_weighted_sampler(dataset, args)
-    lws_loader = DataLoader(
-        dataset, 
-        batch_size=args.batch_size, 
-        num_workers=args.num_workers, 
-        pin_memory=torch.cuda.is_available(),
-        sampler=lws_sampler,
-    )
-    
-    model.train()
-    from milk10k_effb2_metadata.metrics import move_batch
-    for epoch in range(1, args.lws_epochs + 1):
-        total_loss = 0.0
-        for batch in lws_loader:
-            clinical, dermoscopic, metadata, labels = move_batch(batch, device)
-            optimizer.zero_grad()
-            logits = model(clinical, dermoscopic, metadata)
-            loss = criterion(logits, labels)
-            loss.backward()
-            optimizer.step()
-            
-            model.class_scales.data.clamp_(0.75, 1.5)
-            
-            if ema_model is not None:
-                ema_model.update_parameters(model)
-                
-            total_loss += loss.item()
-            
-        scales_str = np.array2string(model.class_scales.detach().cpu().numpy(), precision=3, separator=',')
-        print(f"LWS Epoch {epoch}/{args.lws_epochs} - Loss: {total_loss / len(lws_loader):.4f} - Scales: {scales_str}")
-
-def fit_global_temperature(
-    model: nn.Module,
-    val_loader: DataLoader,
-    device: torch.device,
-) -> float:
-    model.eval()
-    all_logits = []
-    all_labels = []
-    from milk10k_effb2_metadata.metrics import move_batch
-    with torch.no_grad():
-        for batch in val_loader:
-            clinical, dermoscopic, metadata, labels = move_batch(batch, device)
-            logits = model(clinical, dermoscopic, metadata)
-            all_logits.append(logits)
-            all_labels.append(labels)
-            
-    all_logits = torch.cat(all_logits)
-    all_labels = torch.cat(all_labels)
-    
-    temperature = torch.nn.Parameter(torch.ones(1, device=device))
-    optimizer = torch.optim.LBFGS([temperature], lr=0.01, max_iter=50)
-    
-    def eval_fn():
-        optimizer.zero_grad()
-        loss = F.cross_entropy(all_logits / temperature, all_labels)
-        loss.backward()
-        return loss
-        
-    optimizer.step(eval_fn)
-    return float(temperature.item())
 
 
 def build_tail_tracking_config(
@@ -139,11 +55,6 @@ def resolve_label_name(class_names: list[str], name: str) -> str:
     return normalized[key]
 
 
-def source_lesion_id(value: Any) -> str:
-    """Return the original lesion ID for a generated paired lesion ID."""
-    return str(value).split("__sdpair_", 1)[0]
-
-
 def load_augmented_subset(
     base_df: pd.DataFrame,
     class_names: list[str],
@@ -163,6 +74,14 @@ def load_augmented_subset(
     augmented_max_per_class = getattr(args, "augmented_max_per_class", 0)
     if augmented_max_per_class < 0:
         raise ValueError("--augmented-max-per-class must be >= 0.")
+    if augmented_max_per_class > 0 and not augmented_df.empty:
+        augmented_df = (
+            augmented_df.sample(frac=1.0, random_state=args.seed)
+            .groupby("label", group_keys=False)
+            .head(augmented_max_per_class)
+            .sort_values(["label", "lesion_id"])
+            .reset_index(drop=True)
+        )
     augmented_df["is_augmented"] = True
     augmented_df["ignore_metadata"] = bool(getattr(args, "zero_augmented_metadata", False))
     return augmented_df
@@ -171,7 +90,6 @@ def load_augmented_subset(
 def append_augmented_train_rows(
     base_df: pd.DataFrame,
     train_df: pd.DataFrame,
-    val_df: pd.DataFrame,
     class_names: list[str],
     args: argparse.Namespace,
 ) -> pd.DataFrame:
@@ -180,39 +98,10 @@ def append_augmented_train_rows(
         if getattr(args, "augmented_data_dir", None) is not None:
             print("Augmented data: no extra rows selected.")
         return train_df
-    train_source_ids = set(train_df["lesion_id"].astype(str).map(source_lesion_id))
-    val_source_ids = set(val_df["lesion_id"].astype(str).map(source_lesion_id))
-    augmented_df["source_lesion_id"] = augmented_df["lesion_id"].astype(str).map(source_lesion_id)
-    source_overlap = train_source_ids & val_source_ids
-    if source_overlap:
-        raise RuntimeError(
-            f"Source leakage already exists between train and validation: {len(source_overlap)} lesion IDs."
-        )
-    selected = augmented_df["source_lesion_id"].isin(train_source_ids)
-    excluded_validation = augmented_df["source_lesion_id"].isin(val_source_ids)
-    unknown = ~(selected | excluded_validation)
-    if unknown.any():
-        examples = augmented_df.loc[unknown, "lesion_id"].astype(str).head(5).tolist()
-        raise ValueError(
-            "Augmented lesions cannot be mapped to an original train/validation source. "
-            f"Examples: {examples}"
-        )
-    excluded_count = int(excluded_validation.sum())
-    augmented_df = augmented_df.loc[selected].copy()
-    augmented_max_per_class = getattr(args, "augmented_max_per_class", 0)
-    if augmented_max_per_class > 0 and not augmented_df.empty:
-        augmented_df = (
-            augmented_df.sample(frac=1.0, random_state=args.seed)
-            .groupby("label", group_keys=False)
-            .head(augmented_max_per_class)
-            .sort_values(["label", "lesion_id"])
-            .reset_index(drop=True)
-        )
     counts = augmented_df["label"].value_counts().sort_index().to_dict()
     print(
-        "Source-safe augmented train append: "
+        "Augmented train append: "
         f"rows={len(augmented_df)}, counts={counts}, "
-        f"excluded_validation_sources={excluded_count}, "
         f"zero_metadata={getattr(args, 'zero_augmented_metadata', False)}, "
         f"source={getattr(args, 'augmented_data_dir', None)}"
     )
@@ -238,12 +127,6 @@ def run_training_split(
     train_df.to_csv(split_dir / "train.csv", index=False)
     val_df.to_csv(split_dir / "val.csv", index=False)
     data_summary = build_data_summary(df, train_df, val_df, class_names)
-    if args.balance_mode == "hybrid":
-        data_summary["balance"] = hybrid_balance_summary(
-            [label_to_idx[label] for label in train_df["label"].tolist()],
-            {idx: label for label, idx in label_to_idx.items()},
-            args,
-        )
     save_data_summary(output_dir, data_summary)
 
     metadata_spec = fit_metadata_spec(train_df)
@@ -269,13 +152,7 @@ def run_training_split(
         clinical_backbone_backend,
         dermoscopic_backbone_backend,
     )
-    
-    ema_model = None
-    if getattr(args, "ema", False):
-        from torch.optim.swa_utils import AveragedModel, get_ema_multi_avg_fn
-        ema_model = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(args.ema_decay))
-        
-    resume_epoch, resume_best_val_f1, resume_phase = load_resume_checkpoint(args.resume_checkpoint, model, device, ema_model=ema_model)
+    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)
     tail_config = build_tail_tracking_config(train_df, class_names, label_to_idx, args)
@@ -292,12 +169,7 @@ def run_training_split(
         f"metadata_fusion={args.metadata_fusion}, image_fusion={getattr(args, 'image_fusion', 'concat')}, "
         f"gate_hidden_dim={args.metadata_gate_hidden_dim}"
     )
-    print(
-        f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}, "
-        f"balance_mode={args.balance_mode}"
-    )
-    if args.balance_mode == "hybrid":
-        print(f"Hybrid balance plan: {data_summary['balance']}")
+    print(f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}")
     if getattr(args, "image_fusion", "concat") == "moe" and args.logit_fusion_mode == "fixed":
         print("Note: --image-fusion moe already mixes expert logits; --logit-fusion-mode fixed adds extra branch logits.")
     if args.loss == "ce_f1":
@@ -341,7 +213,6 @@ def run_training_split(
         skip_freeze_until,
         **(tail_config or {}),
         best_val_tail_recall=best_tail_start,
-        ema_model=ema_model,
     )
     epoch, best_val_f1, best_val_tail_recall = train_phase(
         "finetune",
@@ -362,36 +233,18 @@ def run_training_split(
         skip_finetune_until,
         **(tail_config or {}),
         best_val_tail_recall=best_val_tail_recall,
-        ema_model=ema_model,
     )
 
     best_path = output_dir / "best.pt"
     if best_path.exists():
         checkpoint = torch.load(best_path, map_location=device, weights_only=False)
         model.load_state_dict(checkpoint["model_state"])
-        if ema_model is not None and "ema_model_state" in checkpoint:
-            ema_model.load_state_dict(checkpoint["ema_model_state"])
-            
-    eval_model = ema_model if ema_model is not None else model
-    
-    if args.lws_epochs > 0:
-        train_lws_post_training(model, train_loader, criterion, device, args, ema_model=ema_model)
-        # Re-save best checkpoint to include LWS scales
-        checkpoint["model_state"] = model.state_dict()
-        if ema_model is not None:
-            checkpoint["ema_model_state"] = ema_model.state_dict()
-        torch.save(checkpoint, best_path)
-        
-    opt_temp = fit_global_temperature(eval_model, val_loader, device)
-    print(f"Optimal Global Temperature (T) = {opt_temp:.4f}")
-    
-    y_true, y_prob = predict(eval_model, val_loader, device)
+    y_true, y_prob = predict(model, val_loader, device)
     metrics, per_class_df, cm = compute_metrics(y_true, y_prob, class_names)
     metrics = {
         "best_selection_metric": float(best_val_f1),
         "selection_metric_name": args.selection_metric,
         "best_val_f1_macro": float(best_val_f1) if args.selection_metric == "f1_macro" else None,
-        "global_temperature": opt_temp,
         **metrics,
     }
     if tail_config is not None:
@@ -465,24 +318,14 @@ def train_single_run(
         real_df = df[~synthetic_mask].copy()
         synthetic_df = df[synthetic_mask].copy()
         train_df, val_df = lesion_split(real_df, args.val_size, args.seed)
-        train_sources = set(train_df["lesion_id"].astype(str))
-        val_sources = set(val_df["lesion_id"].astype(str))
-        synthetic_df["source_lesion_id"] = synthetic_df["lesion_id"].astype(str).map(source_lesion_id)
-        unknown_sources = ~synthetic_df["source_lesion_id"].isin(train_sources | val_sources)
-        if unknown_sources.any():
-            examples = synthetic_df.loc[unknown_sources, "lesion_id"].astype(str).head(5).tolist()
-            raise ValueError(f"Synthetic lesions have unknown source IDs. Examples: {examples}")
-        safe_synthetic_df = synthetic_df[synthetic_df["source_lesion_id"].isin(train_sources)].copy()
-        excluded_count = int(synthetic_df["source_lesion_id"].isin(val_sources).sum())
-        train_df = pd.concat([train_df, safe_synthetic_df], ignore_index=True, sort=False)
+        train_df = pd.concat([train_df, synthetic_df], ignore_index=True, sort=False)
         print(
-            f"Source-safe synthetic train-only split: real_train={len(train_df) - len(safe_synthetic_df)}, "
-            f"synthetic_train={len(safe_synthetic_df)}, excluded_validation_sources={excluded_count}, "
-            f"val_real={len(val_df)}"
+            f"Synthetic train-only split: real_train={len(train_df) - len(synthetic_df)}, "
+            f"synthetic_train={len(synthetic_df)}, val_real={len(val_df)}"
         )
     else:
         train_df, val_df = lesion_split(df, args.val_size, args.seed)
-    train_df = append_augmented_train_rows(df, train_df, val_df, class_names, args)
+    train_df = append_augmented_train_rows(df, train_df, class_names, args)
     return run_training_split(
         df,
         train_df,
@@ -512,7 +355,7 @@ def train_kfold(
     fold_metrics = []
     for fold_idx, (train_df, val_df) in enumerate(kfold_splits(df, args.k_folds, args.seed)):
         print(f"\nK-fold {fold_idx + 1}/{args.k_folds}")
-        train_df = append_augmented_train_rows(df, train_df, val_df, class_names, args)
+        train_df = append_augmented_train_rows(df, train_df, class_names, args)
         metrics = run_training_split(
             df,
             train_df,

milk10k_effb2_metadata/training.py

@@ -7,33 +7,17 @@ import argparse
 from milk10k_effb2_metadata.training_utils import json_safe
 
 
-def validate_balance_args(args: argparse.Namespace) -> None:
-    if args.balance_mode == "hybrid" and args.weighted_sampler:
-        raise ValueError("--balance-mode hybrid cannot be combined with --weighted-sampler.")
-    if args.balance_head_ratio <= 0:
-        raise ValueError("--balance-head-ratio must be greater than 0.")
-    if args.balance_tail_floor < 0:
-        raise ValueError("--balance-tail-floor must be >= 0.")
-    if args.balance_min_source_count < 1:
-        raise ValueError("--balance-min-source-count must be at least 1.")
-
-
 def run(args: argparse.Namespace) -> None:
     import torch
 
     from datasets import resolve_data_dir, set_seed
-    from milk10k_effb2_metadata.data import (
-        audit_dermoscopic_masks,
-        load_paired_dataframe,
-        print_mask_audit_summary,
-    )
+    from milk10k_effb2_metadata.data import load_paired_dataframe
     from milk10k_effb2_metadata.model_setup import resolve_training_backbone_backends
     from milk10k_effb2_metadata.models import normalize_backbone_name, resolve_image_size
     from milk10k_effb2_metadata.runner import train_kfold, train_single_run
 
     if args.k_folds < 1:
         raise ValueError("--k-folds must be at least 1.")
-    validate_balance_args(args)
 
     set_seed(args.seed)
     data_dir = resolve_data_dir(args.data_dir)
@@ -47,17 +31,6 @@ def run(args: argparse.Namespace) -> None:
     args.image_size = resolve_image_size(args.backbone, args.image_size)
 
     df = load_paired_dataframe(data_dir)
-    if not 0.0 <= args.min_dermoscopic_mask_ratio <= 1.0:
-        raise ValueError("--min-dermoscopic-mask-ratio must be between 0 and 1.")
-    if args.dermoscopic_mask_dir is not None:
-        args.dermoscopic_mask_dir = args.dermoscopic_mask_dir.expanduser().resolve()
-        df, mask_audit = audit_dermoscopic_masks(
-            df,
-            args.dermoscopic_mask_dir,
-            args.min_dermoscopic_mask_ratio,
-        )
-        mask_audit.to_csv(args.output_dir / "dermoscopic_mask_audit.csv", index=False)
-        print_mask_audit_summary(mask_audit, args.min_dermoscopic_mask_ratio)
     class_names = sorted(df["label"].unique())
     label_to_idx = {label: idx for idx, label in enumerate(class_names)}
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

milk10k_effb2_metadata/training_utils.py

@@ -46,7 +46,6 @@ def save_run_config(
         "paths": {
             "output_dir": str(output_dir),
             "data_dir": str(getattr(args, "data_dir", "")),
-            "dermoscopic_mask_dir": str(getattr(args, "dermoscopic_mask_dir", "")),
             "clinical_checkpoint": str(getattr(args, "clinical_checkpoint", "")),
             "dermoscopic_checkpoint": str(getattr(args, "dermoscopic_checkpoint", "")),
             "resume_checkpoint": str(getattr(args, "resume_checkpoint", "")),