Upload 16 files

milk10k_effb2_metadata/training.py

@@ -114,7 +114,7 @@ def save_checkpoint(
     optimizer: torch.optim.Optimizer,
     epoch: int,
     phase: str,
-    best_val_loss: float,
+    best_val_f1: float,
     class_names: list[str],
     label_to_idx: dict[str, int],
     metadata_spec: dict[str, Any],
@@ -126,7 +126,7 @@ def save_checkpoint(
             "phase": phase,
             "model_state": model.state_dict(),
             "optimizer_state": optimizer.state_dict(),
-            "best_val_loss": best_val_loss,
+            "best_val_f1_macro": best_val_f1,
             "class_names": class_names,
             "label_to_idx": label_to_idx,
             "metadata_spec": metadata_spec,
@@ -151,15 +151,15 @@ def train_phase(
     metadata_spec: dict[str, Any],
     output_dir: Path,
     history: list[dict[str, Any]],
-    best_val_loss: float,
+    best_val_f1: float,
 ) -> tuple[int, float]:
     if num_epochs <= 0:
-        return start_epoch, best_val_loss
+        return start_epoch, best_val_f1
 
     encoders_trainable = phase == "finetune"
     set_encoder_trainable(model, encoders_trainable)
     optimizer = build_optimizer(model, args, encoders_trainable)
-    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="min", factor=0.2, patience=2)
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="max", factor=0.2, patience=2)
     scaler = GradScaler("cuda", enabled=args.amp and device.type == "cuda")
     use_amp = args.amp and device.type == "cuda"
     patience_count = 0
@@ -171,7 +171,7 @@ def train_phase(
             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)
-        scheduler.step(val_stats["loss"])
+        scheduler.step(val_stats["f1_macro"])
         row = {
             "phase": phase,
             "epoch": epoch,
@@ -188,8 +188,8 @@ def train_phase(
             f"val_f1={val_stats['f1_macro']:.4f} val_top3={val_stats['top3_accuracy']:.4f}"
         )
 
-        if val_stats["loss"] < best_val_loss:
-            best_val_loss = val_stats["loss"]
+        if val_stats["f1_macro"] > best_val_f1:
+            best_val_f1 = val_stats["f1_macro"]
             patience_count = 0
             save_checkpoint(
                 output_dir / "best.pt",
@@ -197,7 +197,7 @@ def train_phase(
                 optimizer,
                 epoch,
                 phase,
-                best_val_loss,
+                best_val_f1,
                 class_names,
                 label_to_idx,
                 metadata_spec,
@@ -209,7 +209,7 @@ def train_phase(
                 print(f"Early stopping {phase} at epoch {epoch}")
                 break
 
-    return start_epoch + num_epochs, best_val_loss
+    return epoch + 1, best_val_f1
 
 
 def build_model(
@@ -317,7 +317,7 @@ def run_training_split(
         print("Note: --class-weight is ignored for --loss milk_lt because milk_lt uses effective-number alpha.")
 
     history: list[dict[str, Any]] = []
-    epoch, best_val_loss = train_phase(
+    epoch, best_val_f1 = train_phase(
         "freeze",
         args.freeze_epochs,
         1,
@@ -332,9 +332,9 @@ def run_training_split(
         metadata_spec,
         output_dir,
         history,
-        float("inf"),
+        float("-inf"),
     )
-    epoch, best_val_loss = train_phase(
+    epoch, best_val_f1 = train_phase(
         "finetune",
         args.finetune_epochs,
         epoch,
@@ -349,7 +349,7 @@ def run_training_split(
         metadata_spec,
         output_dir,
         history,
-        best_val_loss,
+        best_val_f1,
     )
 
     best_path = output_dir / "best.pt"
@@ -358,14 +358,14 @@ def run_training_split(
         model.load_state_dict(checkpoint["model_state"])
     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_loss": float(best_val_loss), **metrics}
+    metrics = {"best_val_f1_macro": float(best_val_f1), **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)
     print(
-        f"Done: best_val_loss={best_val_loss:.4f}, "
+        f"Done: best_val_f1_macro={best_val_f1:.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']}"
@@ -429,7 +429,7 @@ def train_kfold(
 
 def save_kfold_summary(fold_metrics: list[dict[str, Any]], output_dir: Path) -> None:
     summary_keys = [
-        "best_val_loss",
+        "best_val_f1_macro",
         "accuracy",
         "balanced_accuracy",
         "f1_macro",