Upload milk10k code

milk10k_effb2_metadata/engine.py

@@ -9,7 +9,13 @@ from typing import Any
 import numpy as np
 import pandas as pd
 import torch
-from sklearn.metrics import balanced_accuracy_score, confusion_matrix, precision_recall_fscore_support
+from sklearn.metrics import (
+    average_precision_score,
+    balanced_accuracy_score,
+    confusion_matrix,
+    precision_recall_fscore_support,
+    roc_auc_score,
+)
 from torch import nn
 from torch.amp import GradScaler, autocast
 from torch.utils.data import DataLoader
@@ -47,6 +53,14 @@ def run_epoch(
     total = 0
     preds_all = []
     labels_all = []
+    aux_probs_all = []
+    aux_preds_all = []
+    aux_targets_all = []
+    aux_class_indices = None
+    aux_inf_idx = None
+    if class_names and all(name in class_names for name in ("INF", "BCC", "DF", "AKIEC")):
+        aux_inf_idx = class_names.index("INF")
+        aux_class_indices = [class_names.index(name) for name in ("INF", "BCC", "DF", "AKIEC")]
 
     for batch in tqdm(loader, leave=False):
         clinical, dermoscopic, metadata, labels = move_batch(batch, device)
@@ -58,6 +72,7 @@ def run_epoch(
                 output = model(clinical, dermoscopic, metadata)
                 loss = criterion(output, labels)
                 logits = main_logits(output)
+                aux_logits = output.get("inf_aux_logits") if isinstance(output, dict) else None
             if training:
                 if scaler is not None and use_amp:
                     scaler.scale(loss).backward()
@@ -80,6 +95,15 @@ def run_epoch(
         total += batch_size
         preds_all.append(logits.argmax(dim=1).detach().cpu().numpy())
         labels_all.append(labels.detach().cpu().numpy())
+        if aux_logits is not None and aux_class_indices is not None and aux_inf_idx is not None:
+            aux_mask = torch.isin(labels, torch.tensor(aux_class_indices, device=labels.device))
+            if bool(aux_mask.any()):
+                aux_targets = (labels[aux_mask] == aux_inf_idx).long()
+                aux_probs = torch.softmax(aux_logits[aux_mask], dim=1)[:, 1]
+                aux_preds = aux_logits[aux_mask].argmax(dim=1)
+                aux_targets_all.append(aux_targets.detach().cpu().numpy())
+                aux_probs_all.append(aux_probs.detach().cpu().numpy())
+                aux_preds_all.append(aux_preds.detach().cpu().numpy())
 
     y_pred = np.concatenate(preds_all) if preds_all else np.array([])
     y_true = np.concatenate(labels_all) if labels_all else np.array([])
@@ -128,6 +152,23 @@ def run_epoch(
             zero_division=0,
         )[1]
         stats["tail_recall_macro"] = float(np.mean(recalls)) if len(recalls) else 0.0
+    if aux_targets_all:
+        aux_true = np.concatenate(aux_targets_all)
+        aux_prob = np.concatenate(aux_probs_all)
+        aux_pred = np.concatenate(aux_preds_all)
+        aux_precision, aux_recall = precision_recall_fscore_support(
+            aux_true,
+            aux_pred,
+            labels=[1],
+            average=None,
+            zero_division=0,
+        )[:2]
+        stats["aux_INF_precision"] = float(aux_precision[0])
+        stats["aux_INF_recall"] = float(aux_recall[0])
+        stats["aux_INF_AP"] = float(average_precision_score(aux_true, aux_prob)) if aux_true.sum() else 0.0
+        stats["aux_INF_vs_confusers_AUC"] = float(roc_auc_score(aux_true, aux_prob)) if len(np.unique(aux_true)) == 2 else 0.0
+        stats["aux_INF_vs_confusers_support"] = float(len(aux_true))
+        stats["aux_INF_support"] = float(aux_true.sum())
     return stats
 
 
@@ -287,13 +328,21 @@ def train_phase(
         row["selected_variant"] = epoch_variant
         history.append(row)
         pd.DataFrame(history).to_csv(output_dir / "history.csv", index=False)
+        aux_text = ""
+        if "aux_INF_vs_confusers_AUC" in val_stats:
+            aux_text = (
+                f" val_aux_auc={val_stats['aux_INF_vs_confusers_AUC']:.4f}"
+                f" val_aux_ap={val_stats['aux_INF_AP']:.4f}"
+                f" val_aux_recall={val_stats['aux_INF_recall']:.4f}"
+                f" val_aux_precision={val_stats['aux_INF_precision']:.4f}"
+            )
         print(
             f"{phase} epoch {epoch:03d}: "
             f"train_loss={train_stats['loss']:.4f} val_loss={val_stats['loss']:.4f} "
             f"train_bal_acc={train_stats['balanced_accuracy']:.4f} train_f1={train_stats['f1_macro']:.4f} "
             f"val_acc={val_stats['accuracy']:.4f} val_bal_acc={val_stats['balanced_accuracy']:.4f} "
             f"val_f1={val_stats['f1_macro']:.4f} val_dice={val_stats.get('dice_macro', 0.0):.4f} "
-            f"val_top3={val_stats['top3_accuracy']:.4f} selected={epoch_variant}"
+            f"val_top3={val_stats['top3_accuracy']:.4f}{aux_text} selected={epoch_variant}"
         )
         for variant, stats, variant_model in candidates:
             if stats[selection_metric] <= variant_best.get(variant, float("-inf")):

milk10k_effb2_metadata/inference.py

@@ -25,7 +25,7 @@ from milk10k_effb2_metadata.data import (
     print_mask_audit_summary,
     resolve_monet_columns,
 )
-from milk10k_effb2_metadata.losses import main_logits
+from milk10k_effb2_metadata.losses import inf_aux_enabled, main_logits
 from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics
 from milk10k_effb2_metadata.model_setup import load_model_state_compat
 from milk10k_effb2_metadata.models import (
@@ -236,7 +236,7 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
         fusion_logit_weight=checkpoint_arg(checkpoint_args, "fusion_logit_weight", 0.6),
         clinical_logit_weight=checkpoint_arg(checkpoint_args, "clinical_logit_weight", 0.2),
         dermoscopic_logit_weight=checkpoint_arg(checkpoint_args, "dermoscopic_logit_weight", 0.2),
-        inf_aux=checkpoint_arg(checkpoint_args, "inf_aux", False),
+        inf_aux=inf_aux_enabled(checkpoint_args),
     ).to(device)
     load_model_state_compat(model, state)
     model.eval()

milk10k_effb2_metadata/losses.py

@@ -147,6 +147,11 @@ def main_logits(output: torch.Tensor | dict[str, torch.Tensor]) -> torch.Tensor:
     return output
 
 
+def inf_aux_enabled(args: argparse.Namespace | dict) -> bool:
+    getter = args.get if isinstance(args, dict) else lambda key, default=None: getattr(args, key, default)
+    return bool(getter("inf_aux", False) and float(getter("inf_aux_weight", 0.0)) > 0.0)
+
+
 class InfAuxLossWrapper(nn.Module):
     def __init__(
         self,
@@ -167,6 +172,10 @@ class InfAuxLossWrapper(nn.Module):
         self.main_loss.train(mode)
         return super().train(mode)
 
+    def set_epoch(self, epoch: int) -> None:
+        if hasattr(self.main_loss, "set_epoch"):
+            self.main_loss.set_epoch(epoch)
+
     def forward(self, output: torch.Tensor | dict[str, torch.Tensor], labels: torch.Tensor) -> torch.Tensor:
         logits = main_logits(output)
         loss = self.main_loss(logits, labels)
@@ -232,37 +241,37 @@ def f1_class_weight_tensor(label_to_idx: dict[str, int], args: argparse.Namespac
 def build_loss(train_df: pd.DataFrame, label_to_idx: dict[str, int], args: argparse.Namespace, device: torch.device) -> nn.Module:
     if args.loss == "ldam":
         counts = class_count_tensor(train_df, label_to_idx, device)
-        return LDAMLoss(
+        main_loss: nn.Module = LDAMLoss(
             class_counts=counts,
             beta=args.ldam_beta,
             max_margin=args.ldam_max_margin,
             deferred_start_epoch=args.ldam_drw_start_epoch,
             alpha_max=args.ldam_alpha_max,
         )
-
-    weight = None
-    if args.class_weight:
-        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:
-        if args.class_weight:
-            raise ValueError("--tau > 0 cannot be combined with --class-weight.")
-        counts = class_count_tensor(train_df, label_to_idx, device)
-        ce_loss: nn.Module = GeneralizedBalancedSoftmaxLoss(counts, tau=args.tau)
-    else:
-        ce_loss: nn.Module = nn.CrossEntropyLoss(weight=weight)
-    if args.loss == "focal":
-        main_loss: nn.Module = FocalLoss(weight=weight, gamma=args.focal_gamma)
-    elif args.loss == "ce_dice":
-        main_loss = CompositeClassificationLoss(ce_loss, SoftMacroDiceLoss(), args.dice_weight)
-    elif args.loss == "ce_f1":
-        main_loss = CompositeClassificationLoss(ce_loss, SoftMacroF1Loss(f1_class_weight_tensor(label_to_idx, args, device)), args.f1_weight)
     else:
-        main_loss = ce_loss
+        weight = None
+        if args.class_weight:
+            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:
+            if args.class_weight:
+                raise ValueError("--tau > 0 cannot be combined with --class-weight.")
+            counts = class_count_tensor(train_df, label_to_idx, device)
+            ce_loss: nn.Module = GeneralizedBalancedSoftmaxLoss(counts, tau=args.tau)
+        else:
+            ce_loss: nn.Module = nn.CrossEntropyLoss(weight=weight)
+        if args.loss == "focal":
+            main_loss = FocalLoss(weight=weight, gamma=args.focal_gamma)
+        elif args.loss == "ce_dice":
+            main_loss = CompositeClassificationLoss(ce_loss, SoftMacroDiceLoss(), args.dice_weight)
+        elif args.loss == "ce_f1":
+            main_loss = CompositeClassificationLoss(ce_loss, SoftMacroF1Loss(f1_class_weight_tensor(label_to_idx, args, device)), args.f1_weight)
+        else:
+            main_loss = ce_loss
 
-    if getattr(args, "inf_aux", False) and getattr(args, "inf_aux_weight", 0.0) > 0.0:
+    if inf_aux_enabled(args):
         if "INF" not in label_to_idx:
             raise ValueError("--inf-aux requires class INF.")
         confusers = [label_to_idx[resolve_label_name(label_to_idx, name)] for name in args.inf_aux_confusers]

milk10k_effb2_metadata/model_setup.py

@@ -12,6 +12,7 @@ from milk10k_effb2_metadata.checkpoints import (
     load_encoder_checkpoint,
     resolve_backbone_backends,
 )
+from milk10k_effb2_metadata.losses import inf_aux_enabled
 from milk10k_effb2_metadata.models import (
     DualEffB2MetadataClassifier,
     is_one_encoder_image_fusion,
@@ -200,7 +201,7 @@ def build_model(
         fusion_logit_weight=args.fusion_logit_weight,
         clinical_logit_weight=args.clinical_logit_weight,
         dermoscopic_logit_weight=args.dermoscopic_logit_weight,
-        inf_aux=getattr(args, "inf_aux", False),
+        inf_aux=inf_aux_enabled(args),
     ).to(device)
     if args.resume_checkpoint is None and not is_one_encoder_image_fusion(getattr(args, "image_fusion", "concat")):
         if args.clinical_checkpoint is not None:

milk10k_effb2_metadata/runner.py

@@ -24,7 +24,7 @@ from milk10k_effb2_metadata.data import (
     metadata_vector,
 )
 from milk10k_effb2_metadata.engine import train_phase
-from milk10k_effb2_metadata.losses import build_loss, main_logits
+from milk10k_effb2_metadata.losses import build_loss, inf_aux_enabled, main_logits
 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
@@ -371,7 +371,7 @@ def run_training_split(
     )
     if args.inf_aux:
         print(
-            f"INF aux: weight={args.inf_aux_weight}, confusers={args.inf_aux_confusers}, "
+            f"INF aux: active={inf_aux_enabled(args)}, weight={args.inf_aux_weight}, confusers={args.inf_aux_confusers}, "
             f"pos_weight={args.inf_aux_pos_weight}"
         )
     if args.balance_mode == "hybrid":

tests/test_fusion_and_f1_loss.py

@@ -19,9 +19,18 @@ if MISSING_DEPENDENCY is None:
         import numpy as np
         import pandas as pd
         from PIL import Image
+        from torch.utils.data import DataLoader, Dataset
         from milk10k_effb2_metadata.data import PairedMilk10kMetadataDataset
+        from milk10k_effb2_metadata.engine import run_epoch
         from milk10k_effb2_metadata.inference import build_model_from_checkpoint
-        from milk10k_effb2_metadata.losses import InfAuxLossWrapper, SoftMacroF1Loss, f1_class_weight_tensor, main_logits
+        from milk10k_effb2_metadata.losses import (
+            InfAuxLossWrapper,
+            SoftMacroF1Loss,
+            build_loss,
+            f1_class_weight_tensor,
+            inf_aux_enabled,
+            main_logits,
+        )
         from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier
     except ModuleNotFoundError as exc:  # pragma: no cover - local minimal env may omit ML deps.
         MISSING_DEPENDENCY = exc.name
@@ -54,6 +63,21 @@ if MISSING_DEPENDENCY is None:
         return FakeEncoder(feature_dim), feature_dim
 
 
+    class TinyAuxDataset(Dataset):
+        labels = [5, 1, 4, 0]
+
+        def __len__(self) -> int:
+            return len(self.labels)
+
+        def __getitem__(self, idx: int):
+            return {
+                "clinical": torch.randn(3, 8, 8),
+                "dermoscopic": torch.randn(3, 8, 8),
+                "metadata": torch.randn(5),
+                "label": torch.tensor(self.labels[idx]),
+            }
+
+
     class FusionSmokeTest(unittest.TestCase):
         def test_all_image_and_metadata_fusions_forward(self) -> None:
             modes = [
@@ -202,6 +226,42 @@ if MISSING_DEPENDENCY is None:
             self.assertEqual(tuple(output["inf_aux_logits"].shape), (2, 2))
             self.assertEqual(tuple(main_logits(output).shape), (2, 11))
 
+        def test_epoch_logs_inf_aux_metrics(self) -> None:
+            class_names = ["AKIEC", "BCC", "BEN_OTH", "BKL", "DF", "INF", "MAL_OTH", "MEL", "NV", "SCCKA", "VASC"]
+            with patch("milk10k_effb2_metadata.models.build_feature_encoder", side_effect=fake_build_feature_encoder):
+                model = DualEffB2MetadataClassifier(
+                    num_classes=11,
+                    metadata_input_dim=5,
+                    branch_dim=8,
+                    metadata_dim=6,
+                    classifier_hidden_dim=12,
+                    dropout=0.0,
+                    imagenet_pretrained=False,
+                    clinical_backbone_backend="torchvision",
+                    dermoscopic_backbone_backend="torchvision",
+                    backbone="efficientnet_b2",
+                    image_fusion="concat",
+                    inf_aux=True,
+                )
+            criterion = InfAuxLossWrapper(
+                torch.nn.CrossEntropyLoss(),
+                inf_idx=5,
+                confuser_indices=[0, 1, 4],
+                aux_weight=0.05,
+                aux_pos_weight=2.0,
+            )
+            stats = run_epoch(
+                model,
+                DataLoader(TinyAuxDataset(), batch_size=4),
+                criterion,
+                torch.device("cpu"),
+                class_names=class_names,
+            )
+            for key in ("aux_INF_vs_confusers_AUC", "aux_INF_recall", "aux_INF_precision", "aux_INF_AP"):
+                self.assertIn(key, stats)
+                self.assertTrue(np.isfinite(stats[key]))
+            self.assertEqual(stats["aux_INF_vs_confusers_support"], 4.0)
+
 
     class MetadataAugmentationTest(unittest.TestCase):
         def test_image_transform_does_not_change_metadata(self) -> None:
@@ -274,6 +334,33 @@ if MISSING_DEPENDENCY is None:
             with_aux.backward()
             self.assertIsNotNone(output["inf_aux_logits"].grad)
 
+        def test_inf_aux_disabled_when_weight_zero(self) -> None:
+            args = argparse.Namespace(inf_aux=True, inf_aux_weight=0.0)
+            self.assertFalse(inf_aux_enabled(args))
+
+        def test_ldam_can_be_wrapped_with_inf_aux(self) -> None:
+            label_to_idx = {"AKIEC": 0, "BCC": 1, "DF": 2, "INF": 3}
+            train_df = pd.DataFrame({"label": ["AKIEC", "BCC", "DF", "INF"]})
+            args = argparse.Namespace(
+                loss="ldam",
+                ldam_beta=0.9999,
+                ldam_max_margin=0.5,
+                ldam_drw_start_epoch=1,
+                ldam_alpha_max=10.0,
+                inf_aux=True,
+                inf_aux_weight=0.05,
+                inf_aux_confusers=["BCC", "DF", "AKIEC"],
+                inf_aux_pos_weight=2.0,
+            )
+            loss = build_loss(train_df, label_to_idx, args, torch.device("cpu"))
+            loss.set_epoch(2)
+            output = {
+                "logits": torch.randn(4, 4, requires_grad=True),
+                "inf_aux_logits": torch.randn(4, 2, requires_grad=True),
+            }
+            value = loss(output, torch.tensor([0, 1, 2, 3]))
+            self.assertTrue(torch.isfinite(value))
+
 
 if __name__ == "__main__":
     unittest.main()