Upload 32 files

milk10k_effb2_metadata/engine.py

@@ -9,7 +9,7 @@ from typing import Any
 import numpy as np
 import pandas as pd
 import torch
-from sklearn.metrics import balanced_accuracy_score, precision_recall_fscore_support
+from sklearn.metrics import balanced_accuracy_score, confusion_matrix, precision_recall_fscore_support
 from torch import nn
 from torch.amp import GradScaler, autocast
 from torch.utils.data import DataLoader
@@ -21,6 +21,10 @@ from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier, set_encod
 from milk10k_effb2_metadata.training_utils import json_safe
 
 
+def metric_name(label: str) -> str:
+    return "".join(char if char.isalnum() else "_" for char in label).strip("_")
+
+
 def run_epoch(
     model: DualEffB2MetadataClassifier,
     loader: DataLoader,
@@ -30,6 +34,7 @@ def run_epoch(
     scaler: GradScaler | None = None,
     use_amp: bool = False,
     tail_class_indices: list[int] | None = None,
+    class_names: list[str] | None = None,
 ) -> dict[str, float]:
     training = optimizer is not None
     model.train(training)
@@ -80,6 +85,33 @@ def run_epoch(
         "f1_macro": float(precision_recall_fscore_support(y_true, y_pred, average="macro", zero_division=0)[2]) if total else 0.0,
         "top3_accuracy": top3_correct / max(total, 1),
     }
+    if total and class_names:
+        labels = list(range(len(class_names)))
+        precision, recall, f1, support = precision_recall_fscore_support(
+            y_true,
+            y_pred,
+            labels=labels,
+            average=None,
+            zero_division=0,
+        )
+        cm = confusion_matrix(y_true, y_pred, labels=labels)
+        for idx, class_name in enumerate(class_names):
+            name = metric_name(class_name)
+            row_total = int(cm[idx, :].sum())
+            stats[f"support_{name}"] = float(support[idx])
+            stats[f"precision_{name}"] = float(precision[idx])
+            stats[f"recall_{name}"] = float(recall[idx])
+            stats[f"f1_{name}"] = float(f1[idx])
+            stats[f"correct_{name}"] = float(cm[idx, idx])
+            for pred_idx, pred_name in enumerate(class_names):
+                if pred_idx == idx:
+                    continue
+                count = int(cm[idx, pred_idx])
+                if count <= 0:
+                    continue
+                pred_metric = metric_name(pred_name)
+                stats[f"conf_{name}_to_{pred_metric}_count"] = float(count)
+                stats[f"conf_{name}_to_{pred_metric}_rate"] = count / row_total if row_total else 0.0
     if tail_class_indices:
         recalls = precision_recall_fscore_support(
             y_true,
@@ -92,6 +124,30 @@ def run_epoch(
     return stats
 
 
+def format_class_diagnostics(stats: dict[str, float], class_name: str, class_names: list[str]) -> str:
+    name = metric_name(class_name)
+    support = int(stats.get(f"support_{name}", 0.0))
+    correct = int(stats.get(f"correct_{name}", 0.0))
+    recall = stats.get(f"recall_{name}", 0.0)
+    precision = stats.get(f"precision_{name}", 0.0)
+    f1 = stats.get(f"f1_{name}", 0.0)
+    wrongs = []
+    for pred_name in class_names:
+        if pred_name == class_name:
+            continue
+        pred_metric = metric_name(pred_name)
+        count = int(stats.get(f"conf_{name}_to_{pred_metric}_count", 0.0))
+        if count > 0:
+            rate = stats.get(f"conf_{name}_to_{pred_metric}_rate", 0.0)
+            wrongs.append((count, pred_name, rate))
+    wrongs.sort(reverse=True)
+    wrong_text = ", ".join(f"{pred}={count} ({rate:.0%})" for count, pred, rate in wrongs[:3]) or "none"
+    return (
+        f"{class_name}: n={support} correct={correct} recall={recall:.3f} "
+        f"precision={precision:.3f} f1={f1:.3f} wrong_to=[{wrong_text}]"
+    )
+
+
 def save_checkpoint(
     path: Path,
     model: DualEffB2MetadataClassifier,
@@ -162,8 +218,25 @@ def train_phase(
             continue
         if hasattr(criterion, "set_epoch"):
             criterion.set_epoch(epoch)
-        train_stats = run_epoch(model, train_loader, criterion, device, optimizer, scaler, use_amp, tail_class_indices)
-        val_stats = run_epoch(model, val_loader, criterion, device, tail_class_indices=tail_class_indices)
+        train_stats = run_epoch(
+            model,
+            train_loader,
+            criterion,
+            device,
+            optimizer,
+            scaler,
+            use_amp,
+            tail_class_indices,
+            class_names,
+        )
+        val_stats = run_epoch(
+            model,
+            val_loader,
+            criterion,
+            device,
+            tail_class_indices=tail_class_indices,
+            class_names=class_names,
+        )
         scheduler.step(val_stats["f1_macro"])
         row = {
             "phase": phase,
@@ -186,6 +259,9 @@ def train_phase(
                 f"train_tail_recall={train_stats['tail_recall_macro']:.4f} "
                 f"val_tail_recall={val_stats['tail_recall_macro']:.4f}"
             )
+            for class_name in tail_class_names or []:
+                print(f"  train {format_class_diagnostics(train_stats, class_name, class_names)}")
+                print(f"  val   {format_class_diagnostics(val_stats, class_name, class_names)}")
 
         if val_stats["f1_macro"] > best_val_f1:
             best_val_f1 = val_stats["f1_macro"]