"""Single-split and k-fold training runners.""" from __future__ import annotations import argparse import json from pathlib import Path from typing import Any import numpy as np import pandas as pd import torch import torch.nn.functional as F from torch import nn from torch.utils.data import DataLoader, WeightedRandomSampler from milk10k_effb2_metadata.data import ( fit_metadata_spec, hybrid_balance_summary, kfold_splits, lesion_split, load_paired_dataframe, make_loaders, metadata_vector, ) from milk10k_effb2_metadata.engine import train_phase from milk10k_effb2_metadata.losses import build_loss from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics, optimize_class_bias, predict, save_predictions from milk10k_effb2_metadata.model_setup import build_model, load_model_state_compat, load_resume_checkpoint from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier 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 def train_lws_post_training( model: DualEffB2MetadataClassifier, train_loader: DataLoader, val_loader: DataLoader, device: torch.device, args: argparse.Namespace, source_checkpoint: dict[str, Any], output_path: Path, ) -> dict[str, Any] | None: if args.lws_epochs <= 0: return None print(f"\nStarting LWS Post-Training for {args.lws_epochs} epochs...") model.requires_grad_(False) model.class_scales.data.fill_(1.0) model.class_scales.requires_grad_(True) optimizer = torch.optim.Adam([model.class_scales], lr=args.lws_lr) criterion = nn.CrossEntropyLoss() dataset = train_loader.dataset labels = np.asarray(dataset.labels, dtype=np.int64) counts = np.bincount(labels) class_weights = 1.0 / np.power(counts.astype(np.float64), args.lws_sampler_power) generator = torch.Generator().manual_seed(args.seed) lws_sampler = WeightedRandomSampler( torch.as_tensor(class_weights[labels], dtype=torch.double), num_samples=len(dataset), replacement=True, generator=generator, ) lws_loader = DataLoader( dataset, batch_size=args.batch_size, num_workers=args.num_workers, pin_memory=torch.cuda.is_available(), sampler=lws_sampler, ) # Keep dropout and batch normalization disabled. Gradients still flow to # class_scales while every representation/classifier parameter is frozen. model.eval() from milk10k_effb2_metadata.metrics import move_batch best_score = float("-inf") best_metrics: dict[str, Any] | None = None 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_(args.lws_min_scale, args.lws_max_scale) total_loss += loss.item() y_true, y_prob = predict(model, val_loader, device) metrics, _, _ = compute_metrics(y_true, y_prob, source_checkpoint["class_names"]) scales_str = np.array2string(model.class_scales.detach().cpu().numpy(), precision=3, separator=',') print( f"LWS Epoch {epoch}/{args.lws_epochs} - Loss: {total_loss / max(len(lws_loader), 1):.4f} " f"- F1: {metrics['f1_macro']:.4f} - Scales: {scales_str}" ) if metrics[args.selection_metric] > best_score: best_score = float(metrics[args.selection_metric]) best_metrics = metrics payload = dict(source_checkpoint) payload["model_state"] = { name: value.detach().cpu().clone() for name, value in model.state_dict().items() } payload["checkpoint_variant"] = "lws" payload["best_selection_metric"] = best_score payload["best_val_f1_macro"] = float(metrics["f1_macro"]) payload["lws_epoch"] = epoch payload["lws_scales"] = model.class_scales.detach().cpu().tolist() payload["variant_val_metrics"] = json_safe(metrics) torch.save(payload, output_path) model.class_scales.requires_grad_(False) return best_metrics 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) log_temperature = torch.nn.Parameter(torch.zeros(1, device=device)) optimizer = torch.optim.LBFGS([log_temperature], lr=0.05, max_iter=50) def eval_fn(): optimizer.zero_grad() temperature = log_temperature.exp().clamp(0.05, 20.0) loss = F.cross_entropy(all_logits / temperature, all_labels) loss.backward() return loss optimizer.step(eval_fn) return float(log_temperature.detach().exp().clamp(0.05, 20.0).item()) @torch.no_grad() def predict_temperature( model: nn.Module, loader: DataLoader, device: torch.device, temperature: float, ) -> tuple[np.ndarray, np.ndarray]: from milk10k_effb2_metadata.metrics import move_batch model.eval() labels_all: list[np.ndarray] = [] probs_all: list[np.ndarray] = [] for batch in loader: clinical, dermoscopic, metadata, labels = move_batch(batch, device) logits = model(clinical, dermoscopic, metadata) / temperature labels_all.append(labels.cpu().numpy()) probs_all.append(torch.softmax(logits, dim=1).cpu().numpy()) return np.concatenate(labels_all), np.concatenate(probs_all) def add_head_confidence_metrics( metrics: dict[str, Any], y_true: np.ndarray, y_prob: np.ndarray, class_names: list[str], train_df: pd.DataFrame, min_support: int = 100, ) -> None: train_counts = train_df["label"].value_counts() head_indices = [idx for idx, name in enumerate(class_names) if int(train_counts.get(name, 0)) >= min_support] y_pred = y_prob.argmax(axis=1) mask = np.isin(y_true, head_indices) & (y_pred == y_true) metrics["head_class_names"] = [class_names[idx] for idx in head_indices] metrics["mean_correct_confidence_head"] = ( float(y_prob[mask, y_true[mask]].mean()) if np.any(mask) else None ) def build_tail_tracking_config( train_df: pd.DataFrame, class_names: list[str], label_to_idx: dict[str, int], args: argparse.Namespace, ) -> dict[str, Any] | None: if args.loss != "ldam" or args.tail_num_classes <= 0: return None counts_series = train_df["label"].value_counts().reindex(class_names, fill_value=0) train_class_counts = {label: int(counts_series[label]) for label in class_names} tail_class_names = sorted(class_names, key=lambda label: (train_class_counts[label], label))[ : min(args.tail_num_classes, len(class_names)) ] return { "tail_class_names": tail_class_names, "tail_class_indices": [label_to_idx[label] for label in tail_class_names], "train_class_counts": train_class_counts, } def resolve_label_name(class_names: list[str], name: str) -> str: normalized = {label.upper(): label for label in class_names} key = name.strip().upper() if key not in normalized: raise ValueError(f"Unknown augmented class name: {name!r}. Choices: {class_names}") 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], args: argparse.Namespace, ) -> pd.DataFrame: augmented_data_dir = getattr(args, "augmented_data_dir", None) if augmented_data_dir is None: return pd.DataFrame(columns=base_df.columns) augmented_dir = augmented_data_dir.expanduser().resolve() augmented_df = load_paired_dataframe(augmented_dir) base_lesion_ids = set(base_df["lesion_id"].astype(str)) augmented_df = augmented_df[~augmented_df["lesion_id"].astype(str).isin(base_lesion_ids)].copy() augmented_classes = getattr(args, "augmented_classes", []) if augmented_classes: allowed = {resolve_label_name(class_names, name) for name in augmented_classes} augmented_df = augmented_df[augmented_df["label"].isin(allowed)].copy() 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.") augmented_df["is_augmented"] = True augmented_df["ignore_metadata"] = bool(getattr(args, "zero_augmented_metadata", False)) return augmented_df 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: augmented_df = load_augmented_subset(base_df, class_names, args) if augmented_df.empty: 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: " 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)}" ) return pd.concat([train_df, augmented_df], ignore_index=True, sort=False) def run_training_split( df: pd.DataFrame, train_df: pd.DataFrame, val_df: pd.DataFrame, class_names: list[str], label_to_idx: dict[str, int], args: argparse.Namespace, device: torch.device, clinical_backbone_backend: str, dermoscopic_backbone_backend: str, output_dir: Path, fold: int | None = None, ) -> dict[str, Any]: output_dir.mkdir(parents=True, exist_ok=True) split_dir = 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) 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) metadata_dim = len(metadata_vector(train_df.iloc[0], metadata_spec)) save_run_config( output_dir, args, class_names, label_to_idx, metadata_spec, train_df, val_df, clinical_backbone_backend, dermoscopic_backbone_backend, fold, ) model = build_model( class_names, metadata_dim, args, device, 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) 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) print(f"Output dir: {output_dir}") print(f"Device: {device}") print(f"Classes: {class_names}") 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}, " 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']}") 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": print(f"Soft-F1 class controls: ignore={args.f1_ignore_classes}, weights={args.f1_class_weight}") if args.loss == "ldam" and args.class_weight: print("Note: --class-weight is ignored for --loss ldam because LDAM+DRW uses effective-number alpha.") if tail_config is not None: tail_counts = {label: tail_config["train_class_counts"][label] for label in tail_config["tail_class_names"]} print(f"LDAM tail tracking: tail_num_classes={args.tail_num_classes}, tail_counts={tail_counts}") 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") best_tail_start = float("-inf") tail_best_path = output_dir / "tail_best.pt" if args.resume_checkpoint is not None and tail_best_path.exists(): tail_checkpoint = torch.load(tail_best_path, map_location=device, weights_only=False) best_tail_start = float(tail_checkpoint.get("best_val_tail_recall_macro", 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 variant_best = {"raw": float("-inf"), "ema": float("-inf")} epoch, best_val_f1, best_val_tail_recall, variant_best = train_phase( "freeze", args.freeze_epochs, 1, model, train_loader, val_loader, criterion, device, args, class_names, label_to_idx, metadata_spec, output_dir, history, best_start, skip_freeze_until, **(tail_config or {}), best_val_tail_recall=best_tail_start, ema_model=ema_model, variant_best=variant_best, ) epoch, best_val_f1, best_val_tail_recall, variant_best = train_phase( "finetune", args.finetune_epochs, epoch, model, train_loader, val_loader, criterion, device, args, class_names, label_to_idx, metadata_spec, output_dir, history, best_val_f1, skip_finetune_until, **(tail_config or {}), best_val_tail_recall=best_val_tail_recall, ema_model=ema_model, variant_best=variant_best, ) raw_path = output_dir / "best_raw.pt" ema_path = output_dir / "best_ema.pt" if not raw_path.exists(): raise RuntimeError(f"Training did not produce {raw_path}") source_path = ema_path if ema_path.exists() else raw_path source_checkpoint = torch.load(source_path, map_location=device, weights_only=False) load_model_state_compat(model, source_checkpoint["model_state"]) lws_path = output_dir / "best_lws.pt" if args.lws_epochs > 0: train_lws_post_training( model, train_loader, val_loader, device, args, source_checkpoint, lws_path, ) variant_paths = [raw_path] if ema_path.exists(): variant_paths.append(ema_path) if lws_path.exists(): variant_paths.append(lws_path) variant_results: dict[str, dict[str, Any]] = {} deployment: tuple[float, Path, dict[str, Any], np.ndarray] | None = None y_true: np.ndarray | None = None for variant_path in variant_paths: checkpoint = torch.load(variant_path, map_location=device, weights_only=False) load_model_state_compat(model, checkpoint["model_state"]) variant = str(checkpoint.get("checkpoint_variant", variant_path.stem.removeprefix("best_"))) uncalibrated_y_true, uncalibrated_prob = predict_temperature(model, val_loader, device, 1.0) uncalibrated_metrics, _, _ = compute_metrics(uncalibrated_y_true, uncalibrated_prob, class_names) add_head_confidence_metrics( uncalibrated_metrics, uncalibrated_y_true, uncalibrated_prob, class_names, train_df, ) temperature = fit_global_temperature(model, val_loader, device) if args.fit_temperature else 1.0 current_y_true, current_prob = predict_temperature(model, val_loader, device, temperature) current_metrics, current_per_class, current_cm = compute_metrics(current_y_true, current_prob, class_names) add_head_confidence_metrics(current_metrics, current_y_true, current_prob, class_names, train_df) checkpoint["temperature"] = temperature checkpoint["uncalibrated_metrics"] = json_safe(uncalibrated_metrics) checkpoint["temperature_metrics"] = json_safe(current_metrics) checkpoint["checkpoint_variant"] = variant torch.save(checkpoint, variant_path) current_per_class.to_csv(output_dir / f"per_class_metrics_{variant}.csv", index=False) pd.DataFrame(current_cm, index=class_names, columns=class_names).to_csv( output_dir / f"confusion_matrix_{variant}.csv" ) variant_output = output_dir / variant variant_output.mkdir(exist_ok=True) save_predictions(val_df, current_y_true, current_prob, class_names, variant_output) variant_results[variant] = { "checkpoint": str(variant_path), "temperature": temperature, "uncalibrated_metrics": uncalibrated_metrics, "metrics": current_metrics, } score = float(current_metrics[args.selection_metric]) if deployment is None or score > deployment[0]: deployment = (score, variant_path, checkpoint, current_prob) y_true = current_y_true if deployment is None or y_true is None: raise RuntimeError("No deployable raw/EMA/LWS checkpoint was produced.") _, deployment_path, deployment_checkpoint, y_prob = deployment torch.save(deployment_checkpoint, output_dir / "best.pt") print( f"Selected deployment variant={deployment_checkpoint['checkpoint_variant']} " f"from {deployment_path.name}, temperature={deployment_checkpoint['temperature']:.4f}" ) metrics, per_class_df, cm = compute_metrics(y_true, y_prob, class_names) add_head_confidence_metrics(metrics, y_true, y_prob, class_names, train_df) metrics = { "best_selection_metric": float(metrics[args.selection_metric]), "selection_metric_name": args.selection_metric, "best_val_f1_macro": float(metrics["f1_macro"]), "checkpoint_variant": deployment_checkpoint["checkpoint_variant"], "temperature": deployment_checkpoint["temperature"], "variants": variant_results, **metrics, } if tail_config is not None: metrics["best_val_tail_recall_macro"] = float(best_val_tail_recall) metrics["tail_class_names"] = tail_config["tail_class_names"] if args.calibrate_bias: class_bias, calibrated_score = optimize_class_bias( y_true, y_prob, class_names, metric_name=args.calibration_metric, max_bias=args.calibration_max_bias, step=args.calibration_step, passes=args.calibration_passes, ) calibrated_prob = apply_class_bias(y_prob, class_bias) calibrated_metrics, calibrated_per_class_df, calibrated_cm = compute_metrics(y_true, calibrated_prob, class_names) calibration_payload = { "metric": args.calibration_metric, "optimized_score": float(calibrated_score), "class_names": class_names, "class_bias": [float(item) for item in class_bias.tolist()], "metrics": calibrated_metrics, } with open(output_dir / "calibration.json", "w", encoding="utf-8") as f: json.dump(json_safe(calibration_payload), f, indent=2) calibrated_per_class_df.to_csv(output_dir / "per_class_metrics_calibrated.csv", index=False) pd.DataFrame(calibrated_cm, index=class_names, columns=class_names).to_csv( output_dir / "confusion_matrix_calibrated.csv" ) metrics["calibrated"] = calibrated_metrics with open(output_dir / "metrics.json", "w", encoding="utf-8") as f: json.dump(json_safe(metrics), f, indent=2) pd.DataFrame(cm, index=class_names, columns=class_names).to_csv(output_dir / "confusion_matrix.csv") per_class_df.to_csv(output_dir / "per_class_metrics.csv", index=False) save_predictions(val_df, y_true, y_prob, class_names, output_dir) save_run_diagnostics( output_dir, args, data_summary, metrics, per_class_df, cm, y_prob, class_names, fold, ) print( f"Done: best_val_f1_macro={metrics['f1_macro']:.4f}, " f"val_acc={metrics['accuracy']:.4f}, balanced_acc={metrics['balanced_accuracy']:.4f}, " f"f1_macro={metrics['f1_macro']:.4f}, top3={metrics['top3_accuracy']:.4f}, " f"auc_macro={metrics['roc_auc_macro_ovr']}" ) return metrics def train_single_run( df: pd.DataFrame, class_names: list[str], label_to_idx: dict[str, int], args: argparse.Namespace, device: torch.device, clinical_backbone_backend: str, dermoscopic_backbone_backend: str, ) -> dict[str, Any]: df = df.copy() df["is_augmented"] = False df["ignore_metadata"] = False if args.synthetic_train_only: synthetic_mask = df["lesion_id"].astype(str).str.contains("__sdpair_", regex=False) 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) 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)}" ) 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) return run_training_split( df, train_df, val_df, class_names, label_to_idx, args, device, clinical_backbone_backend, dermoscopic_backbone_backend, args.output_dir, ) def train_kfold( df: pd.DataFrame, class_names: list[str], label_to_idx: dict[str, int], args: argparse.Namespace, device: torch.device, clinical_backbone_backend: str, dermoscopic_backbone_backend: str, ) -> list[dict[str, Any]]: df = df.copy() df["is_augmented"] = False df["ignore_metadata"] = False 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) metrics = run_training_split( df, train_df, val_df, class_names, label_to_idx, args, device, clinical_backbone_backend, dermoscopic_backbone_backend, args.output_dir / f"fold_{fold_idx:02d}", fold_idx, ) fold_metrics.append({"fold": fold_idx, **metrics}) save_kfold_summary(fold_metrics, args.output_dir) save_kfold_report(fold_metrics, args.output_dir) return fold_metrics