Upload 32 files

milk10k_effb2_metadata/cli.py

@@ -94,6 +94,12 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--ldam-max-margin", type=float, default=0.5)
     parser.add_argument("--ldam-drw-start-epoch", type=int, default=0)
     parser.add_argument("--ldam-alpha-max", type=float, default=10.0)
+    parser.add_argument(
+        "--tail-num-classes",
+        type=int,
+        default=4,
+        help="Number of lowest-support train classes to track for LDAM tail_best.pt.",
+    )
     parser.add_argument("--k-folds", type=int, default=1)
     parser.add_argument("--amp", action="store_true")
     parser.add_argument(

milk10k_effb2_metadata/engine.py

@@ -29,6 +29,7 @@ def run_epoch(
     optimizer: torch.optim.Optimizer | None = None,
     scaler: GradScaler | None = None,
     use_amp: bool = False,
+    tail_class_indices: list[int] | None = None,
 ) -> dict[str, float]:
     training = optimizer is not None
     model.train(training)
@@ -72,13 +73,23 @@ def run_epoch(
     y_pred = np.concatenate(preds_all) if preds_all else np.array([])
     y_true = np.concatenate(labels_all) if labels_all else np.array([])
 
-    return {
+    stats = {
         "loss": total_loss / max(total, 1),
         "accuracy": correct / max(total, 1),
         "balanced_accuracy": float(balanced_accuracy_score(y_true, y_pred)) if total else 0.0,
         "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 tail_class_indices:
+        recalls = precision_recall_fscore_support(
+            y_true,
+            y_pred,
+            labels=tail_class_indices,
+            average=None,
+            zero_division=0,
+        )[1]
+        stats["tail_recall_macro"] = float(np.mean(recalls)) if len(recalls) else 0.0
+    return stats
 
 
 def save_checkpoint(
@@ -92,21 +103,22 @@ def save_checkpoint(
     label_to_idx: dict[str, int],
     metadata_spec: dict[str, Any],
     args: argparse.Namespace,
+    extra: dict[str, Any] | None = None,
 ) -> None:
-    torch.save(
-        {
-            "epoch": epoch,
-            "phase": phase,
-            "model_state": model.state_dict(),
-            "optimizer_state": optimizer.state_dict(),
-            "best_val_f1_macro": best_val_f1,
-            "class_names": class_names,
-            "label_to_idx": label_to_idx,
-            "metadata_spec": metadata_spec,
-            "args": json_safe(vars(args)),
-        },
-        path,
-    )
+    payload = {
+        "epoch": epoch,
+        "phase": phase,
+        "model_state": model.state_dict(),
+        "optimizer_state": optimizer.state_dict(),
+        "best_val_f1_macro": best_val_f1,
+        "class_names": class_names,
+        "label_to_idx": label_to_idx,
+        "metadata_spec": metadata_spec,
+        "args": json_safe(vars(args)),
+    }
+    if extra:
+        payload.update(json_safe(extra))
+    torch.save(payload, path)
 
 
 def train_phase(
@@ -126,9 +138,13 @@ def train_phase(
     history: list[dict[str, Any]],
     best_val_f1: float,
     skip_until_epoch: int = 1,
-) -> tuple[int, float]:
+    tail_class_indices: list[int] | None = None,
+    tail_class_names: list[str] | None = None,
+    train_class_counts: dict[str, int] | None = None,
+    best_val_tail_recall: float = float("-inf"),
+) -> tuple[int, float, float]:
     if num_epochs <= 0:
-        return start_epoch, best_val_f1
+        return start_epoch, best_val_f1, best_val_tail_recall
 
     encoders_trainable = phase == "finetune"
     set_encoder_trainable(model, encoders_trainable)
@@ -146,8 +162,8 @@ 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)
-        val_stats = run_epoch(model, val_loader, criterion, device)
+        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)
         scheduler.step(val_stats["f1_macro"])
         row = {
             "phase": phase,
@@ -164,6 +180,12 @@ def train_phase(
             f"val_acc={val_stats['accuracy']:.4f} val_bal_acc={val_stats['balanced_accuracy']:.4f} "
             f"val_f1={val_stats['f1_macro']:.4f} val_top3={val_stats['top3_accuracy']:.4f}"
         )
+        if tail_class_indices:
+            print(
+                f"LDAM tail: classes={tail_class_names} "
+                f"train_tail_recall={train_stats['tail_recall_macro']:.4f} "
+                f"val_tail_recall={val_stats['tail_recall_macro']:.4f}"
+            )
 
         if val_stats["f1_macro"] > best_val_f1:
             best_val_f1 = val_stats["f1_macro"]
@@ -186,8 +208,35 @@ def train_phase(
             )
         else:
             patience_count += 1
-            if patience_count >= args.patience:
-                print(f"Early stopping {phase} at epoch {epoch}")
-                break
 
-    return epoch + 1, best_val_f1
+        if tail_class_indices and val_stats["tail_recall_macro"] > best_val_tail_recall:
+            best_val_tail_recall = val_stats["tail_recall_macro"]
+            save_checkpoint(
+                output_dir / "tail_best.pt",
+                model,
+                optimizer,
+                epoch,
+                phase,
+                best_val_f1,
+                class_names,
+                label_to_idx,
+                metadata_spec,
+                args,
+                {
+                    "best_val_tail_recall_macro": best_val_tail_recall,
+                    "tail_class_names": tail_class_names or [],
+                    "tail_class_indices": tail_class_indices,
+                    "train_class_counts": train_class_counts or {},
+                    "selection_metric": "val_tail_recall_macro",
+                },
+            )
+            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'}"
+            )
+
+        if patience_count >= args.patience:
+            print(f"Early stopping {phase} at epoch {epoch}")
+            break
+
+    return epoch + 1, best_val_f1, best_val_tail_recall

milk10k_effb2_metadata/runner.py

@@ -24,6 +24,27 @@ from milk10k_effb2_metadata.model_setup import build_model, load_resume_checkpoi
 from milk10k_effb2_metadata.training_utils import json_safe, save_kfold_summary, save_run_config
 
 
+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 run_training_split(
     df: pd.DataFrame,
     train_df: pd.DataFrame,
@@ -68,6 +89,7 @@ def run_training_split(
     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)
 
     print(f"Output dir: {output_dir}")
     print(f"Device: {device}")
@@ -83,17 +105,25 @@ def run_training_split(
     print(f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}")
     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
-    epoch, best_val_f1 = train_phase(
+    epoch, best_val_f1, best_val_tail_recall = train_phase(
         "freeze",
         args.freeze_epochs,
         1,
@@ -110,8 +140,10 @@ def run_training_split(
         history,
         best_start,
         skip_freeze_until,
+        **(tail_config or {}),
+        best_val_tail_recall=best_tail_start,
     )
-    epoch, best_val_f1 = train_phase(
+    epoch, best_val_f1, best_val_tail_recall = train_phase(
         "finetune",
         args.finetune_epochs,
         epoch,
@@ -128,6 +160,8 @@ def run_training_split(
         history,
         best_val_f1,
         skip_finetune_until,
+        **(tail_config or {}),
+        best_val_tail_recall=best_val_tail_recall,
     )
 
     best_path = output_dir / "best.pt"
@@ -137,6 +171,9 @@ def run_training_split(
     y_true, y_prob = predict(model, val_loader, device)
     metrics, per_class_df, cm = compute_metrics(y_true, y_prob, class_names)
     metrics = {"best_val_f1_macro": float(best_val_f1), **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"]
     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")

milk10k_effb2_metadata/training_utils.py

@@ -46,6 +46,7 @@ def save_kfold_summary(fold_metrics: list[dict[str, Any]], output_dir: Path) ->
 
     summary_keys = [
         "best_val_f1_macro",
+        "best_val_tail_recall_macro",
         "accuracy",
         "balanced_accuracy",
         "f1_macro",