Revise layout evaluation and training artifact sync update 32

app.py

@@ -21,10 +21,10 @@ import seaborn as sns
 from huggingface_hub import CommitOperationAdd, CommitOperationDelete, HfApi, hf_hub_download
 from ultralytics import YOLO
 
-CM_INIT = {"tp": 0, "fp": 0, "fn": 0, "tn": 0}
+CM_INIT = {"tp": 0, "fp": 0, "fn": 0, "tn": 0, "person": 0, "not_person": 0}
 EVAL_CLASSES = ["Person", "Not Person/Background"]
 APP_VERSION = os.getenv("APP_VERSION", "v0.9.0")
-APP_MINOR_UPDATE = os.getenv("APP_MINOR_UPDATE", "31")
+APP_MINOR_UPDATE = os.getenv("APP_MINOR_UPDATE", "32")
 
 
 # Gradio/Spaces can trigger noisy asyncio cleanup traces ("Invalid file descriptor: -1")
@@ -374,13 +374,13 @@ def save_detection_artifacts(
     return str(image_path), str(csv_path), hf_sync_msg
 
 
-def draw_detection_chart(detected: int) -> np.ndarray:
-    fig, ax = plt.subplots(figsize=(5.0, 3.2))
-    labels = ["Jumlah Person Terdeteksi"]
-    values = [detected]
-    bars = ax.bar(labels, values, color=["#2b6cb0"])
+def draw_detection_chart(person_count: int, non_person_count: int) -> np.ndarray:
+    fig, ax = plt.subplots(figsize=(6.2, 3.6))
+    labels = ["Person", "Not Person"]
+    values = [person_count, non_person_count]
+    bars = ax.bar(labels, values, color=["#2563eb", "#64748b"])
     ax.set_title("Grafik Hasil Pengecekan")
-    ax.set_ylabel("Jumlah")
+    ax.set_ylabel("Jumlah Objek")
     for b in bars:
         ax.text(
             b.get_x() + b.get_width() / 2,
@@ -400,21 +400,33 @@ def draw_detection_chart(detected: int) -> np.ndarray:
     return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
 
 
-def draw_compare_chart(detected_before: int, detected_after: int) -> np.ndarray:
-    fig, ax = plt.subplots(figsize=(6.2, 3.4))
-    labels = ["YOLOv8n", "Best.pt"]
-    values = [detected_before, detected_after]
-    bars = ax.bar(labels, values, color=["#2b6cb0", "#805ad5"])
-    ax.set_title("Perbandingan Sebelum vs Sesudah Training")
-    ax.set_ylabel("Jumlah")
-    for b in bars:
-        ax.text(
-            b.get_x() + b.get_width() / 2,
-            b.get_height() + 0.05,
-            str(int(b.get_height())),
-            ha="center",
-            va="bottom",
-        )
+def draw_compare_chart(
+    yolo_person: int,
+    yolo_non_person: int,
+    best_person: int,
+    best_non_person: int,
+) -> np.ndarray:
+    fig, ax = plt.subplots(figsize=(7.4, 3.8))
+    x = np.arange(2)
+    width = 0.36
+    person_values = [yolo_person, best_person]
+    non_person_values = [yolo_non_person, best_non_person]
+    bars_person = ax.bar(x - width / 2, person_values, width, label="Person", color="#2563eb")
+    bars_non_person = ax.bar(x + width / 2, non_person_values, width, label="Not Person", color="#64748b")
+    ax.set_title("Perbandingan Count Objek per Model")
+    ax.set_ylabel("Jumlah Objek")
+    ax.set_xticks(x)
+    ax.set_xticklabels(["YOLOv8n", "Best.pt"])
+    ax.legend(loc="best")
+    for bars in (bars_person, bars_non_person):
+        for b in bars:
+            ax.text(
+                b.get_x() + b.get_width() / 2,
+                b.get_height() + 0.05,
+                str(int(b.get_height())),
+                ha="center",
+                va="bottom",
+            )
     plt.tight_layout()
     buf = io.BytesIO()
     fig.savefig(buf, format="png", dpi=140)
@@ -437,6 +449,43 @@ def _merge_annotated_images(left: np.ndarray, right: np.ndarray) -> np.ndarray:
     return combined
 
 
+def build_eval_payload(
+    predicted_label: str,
+    actual_label: str,
+    predicted_person_count: int,
+    predicted_non_person_count: int,
+    actual_person_count: int,
+    actual_non_person_count: int,
+) -> Dict[str, Any]:
+    return {
+        "predicted_label": predicted_label,
+        "actual_label": actual_label,
+        "predicted_person_count": int(predicted_person_count),
+        "predicted_non_person_count": int(predicted_non_person_count),
+        "actual_person_count": int(actual_person_count),
+        "actual_non_person_count": int(actual_non_person_count),
+    }
+
+
+def object_confusion_delta(eval_payload: Dict[str, Any]) -> Dict[str, int]:
+    actual_person = int(eval_payload.get("actual_person_count", 0) or 0)
+    actual_non_person = int(eval_payload.get("actual_non_person_count", 0) or 0)
+    predicted_person = int(eval_payload.get("predicted_person_count", 0) or 0)
+
+    tp = min(actual_person, predicted_person)
+    fn = max(actual_person - predicted_person, 0)
+    fp = max(predicted_person - actual_person, 0)
+    tn = max(actual_non_person - fp, 0)
+    return {
+        "tp": tp,
+        "fp": fp,
+        "fn": fn,
+        "tn": tn,
+        "person": actual_person,
+        "not_person": actual_non_person,
+    }
+
+
 def run_check_and_classify(
     image: np.ndarray,
     conf_threshold: float,
@@ -450,6 +499,7 @@ def run_check_and_classify(
     np.ndarray,
     str,
     str,
+    Dict[str, Any],
     str,
     str | None,
     str | None,
@@ -466,7 +516,7 @@ def run_check_and_classify(
             )
             pred_before = classify_person_vs_background(det_before)
             pred_after = classify_person_vs_background(det_after)
-            chart = draw_compare_chart(det_before, det_after)
+            chart = draw_compare_chart(det_before, non_person_before, det_after, non_person_after)
             yolo_image_path, saved_csv_path, hf_sync_msg_yolo = save_detection_artifacts(
                 ann_before,
                 model_choice="YOLOv8n",
@@ -486,6 +536,14 @@ def run_check_and_classify(
                 non_person_count=non_person_after,
             )
             actual_label = classify_scene_label(det_before, non_person_before)
+            eval_payload = build_eval_payload(
+                predicted_label=pred_after,
+                actual_label=actual_label,
+                predicted_person_count=det_after,
+                predicted_non_person_count=non_person_after,
+                actual_person_count=det_before,
+                actual_non_person_count=non_person_before,
+            )
             summary = (
                 "### Ringkasan Perbandingan Model\n"
                 f"- Confidence threshold: **{conf_threshold:.2f}**\n"
@@ -504,6 +562,7 @@ def run_check_and_classify(
                 chart,
                 pred_after,
                 actual_label,
+                eval_payload,
                 pred_md,
                 best_image_path,
                 saved_csv_path,
@@ -516,6 +575,8 @@ def run_check_and_classify(
         status_presence = classify_presence(detected)
         predicted_label = classify_person_vs_background(detected)
         actual_label = classify_scene_label(detected, non_person_count)
+        actual_person_count = detected
+        actual_non_person_count = non_person_count
         yolo_panel_output: str | np.ndarray | None = None
         best_panel_output: str | np.ndarray | None = None
 
@@ -524,6 +585,8 @@ def run_check_and_classify(
                 image, conf_threshold, "YOLOv8n", annotation_style
             )
             actual_label = classify_scene_label(ref_person_count, ref_non_person_count)
+            actual_person_count = ref_person_count
+            actual_non_person_count = ref_non_person_count
 
         saved_image_path, saved_csv_path, hf_sync_msg = save_detection_artifacts(
             annotated,
@@ -553,7 +616,15 @@ def run_check_and_classify(
             f"- Arsip evaluasi lokal: **{saved_csv_path or '-'}**\n"
             f"- Auto-save ke Space: **{hf_sync_msg}**"
         )
-        chart = draw_detection_chart(detected)
+        chart = draw_detection_chart(detected, non_person_count)
+        eval_payload = build_eval_payload(
+            predicted_label=predicted_label,
+            actual_label=actual_label,
+            predicted_person_count=detected,
+            predicted_non_person_count=non_person_count,
+            actual_person_count=actual_person_count,
+            actual_non_person_count=actual_non_person_count,
+        )
         pred_md = f"Label prediksi evaluasi: **{predicted_label}**"
         return (
             yolo_panel_output,
@@ -562,6 +633,7 @@ def run_check_and_classify(
             chart,
             predicted_label,
             actual_label,
+            eval_payload,
             pred_md,
             saved_image_path,
             saved_csv_path,
@@ -582,7 +654,7 @@ def run_check_and_classify(
             (80, 80, 80),
             2,
         )
-        return None, None, summary, blank, "", "", "Label prediksi evaluasi: **-**", None, None
+        return None, None, summary, blank, "", "", {}, "Label prediksi evaluasi: **-**", None, None
 
 
 def toggle_model_selector(mode: str):
@@ -601,26 +673,39 @@ def draw_confusion_matrix_from_state(cm_state: Dict[str, int]) -> np.ndarray:
     tn = int(cm_state.get("tn", 0))
     cm = np.array([[tp, fn], [fp, tn]], dtype=int)
 
+    person_total = int(cm_state.get("person", tp + fn))
+    not_person_total = int(cm_state.get("not_person", fp + tn))
+
     sns.set_style("white")
-    fig, ax = plt.subplots(figsize=(6.0, 4.6))
+    fig, ax = plt.subplots(figsize=(7.4, 5.8))
     sns.heatmap(
         cm,
         annot=True,
         fmt="d",
         cmap="Blues",
         cbar=True,
-        xticklabels=EVAL_CLASSES,
-        yticklabels=EVAL_CLASSES,
+        xticklabels=["Prediksi Person", "Prediksi Not Person"],
+        yticklabels=["Aktual Person", "Aktual Not Person"],
         linewidths=0.5,
         linecolor="white",
+        annot_kws={"size": 14, "weight": "bold"},
         ax=ax,
     )
-    ax.set_title("Confusion Matrix")
+    ax.set_title("Confusion Matrix Count Objek")
     ax.set_xlabel("Prediksi")
     ax.set_ylabel("Aktual")
-    plt.xticks(rotation=25, ha="right")
+    ax.text(
+        0.5,
+        -0.22,
+        f"Total aktual: Person={person_total} | Not Person/Background={not_person_total}",
+        transform=ax.transAxes,
+        ha="center",
+        va="top",
+        fontsize=10,
+    )
+    plt.xticks(rotation=12, ha="right")
     plt.yticks(rotation=0)
-    plt.tight_layout()
+    plt.tight_layout(rect=[0, 0.07, 1, 1])
 
     buf = io.BytesIO()
     fig.savefig(buf, format="png", dpi=150)
@@ -640,21 +725,25 @@ def render_metric_markdown(cm_state: Dict[str, int]) -> str:
     prec = _safe_div(tp, tp + fp)
     rec = _safe_div(tp, tp + fn)
     f1 = _safe_div(2 * prec * rec, prec + rec)
+    person_total = int(cm_state.get("person", tp + fn))
+    not_person_total = int(cm_state.get("not_person", fp + tn))
+    total = tp + fp + fn + tn
     return (
-        "### Evaluasi dan Rumus\n"
-        "- Kelas positif evaluasi: **Person**\n"
-        f"- Accuracy = (TP+TN)/(TP+FP+FN+TN) = ({tp}+{tn})/({tp+fp+fn+tn}) = **{acc:.4f}**\n"
-        f"- Precision = TP/(TP+FP) = {tp}/({tp+fp}) = **{prec:.4f}**\n"
-        f"- Recall = TP/(TP+FN) = {tp}/({tp+fn}) = **{rec:.4f}**\n"
-        f"- F1-Score = 2PR/(P+R) = **{f1:.4f}**"
+        "### Rumus Evaluasi Berbasis Count\n"
+        f"**Count objek aktual:** Person = `{person_total}`, Not Person/Background = `{not_person_total}`  \n"
+        f"**TP:** `{tp}` | **FP:** `{fp}` | **FN:** `{fn}` | **TN:** `{tn}` | **Total:** `{total}`\n\n"
+        "| Metrik | Rumus | Substitusi | Hasil |\n"
+        "|---|---:|---:|---:|\n"
+        f"| Accuracy | `(TP+TN)/(TP+FP+FN+TN)` | `({tp}+{tn})/({total})` | **{acc:.4f}** |\n"
+        f"| Precision | `TP/(TP+FP)` | `{tp}/({tp+fp})` | **{prec:.4f}** |\n"
+        f"| Recall | `TP/(TP+FN)` | `{tp}/({tp+fn})` | **{rec:.4f}** |\n"
+        f"| F1-Score | `2*(Precision*Recall)/(Precision+Recall)` | `2*({prec:.4f}*{rec:.4f})/({prec+rec:.4f})` | **{f1:.4f}** |"
     )
 
 
-def update_evaluation(
-    cm_state: Dict[str, int], predicted_label: str, actual_label: str
-) -> Tuple[Dict[str, int], np.ndarray, str, str]:
+def update_evaluation(cm_state: Dict[str, int], eval_payload: Dict[str, Any]) -> Tuple[Dict[str, int], np.ndarray, str, str]:
     state = dict(cm_state or CM_INIT)
-    if predicted_label not in EVAL_CLASSES:
+    if not eval_payload:
         return (
             state,
             draw_confusion_matrix_from_state(state),
@@ -662,27 +751,25 @@ def update_evaluation(
             "Jalankan deteksi terlebih dahulu agar label prediksi tersedia.",
         )
 
-    if actual_label == "Person" and predicted_label == "Person":
-        state["tp"] += 1
-    elif actual_label == "Person" and predicted_label == "Not Person/Background":
-        state["fn"] += 1
-    elif actual_label == "Not Person/Background" and predicted_label == "Person":
-        state["fp"] += 1
-    else:
-        state["tn"] += 1
+    delta = object_confusion_delta(eval_payload)
+    for key in ("tp", "fp", "fn", "tn", "person", "not_person"):
+        state[key] = int(state.get(key, 0)) + int(delta.get(key, 0))
 
     return (
         state,
         draw_confusion_matrix_from_state(state),
         render_metric_markdown(state),
-        "Confusion matrix berhasil diperbarui.",
+        (
+            "Confusion matrix count objek diperbarui: "
+            f"Person={delta['person']}, Not Person/Background={delta['not_person']}."
+        ),
     )
 
 
 def update_evaluation_auto(
-    cm_state: Dict[str, int], predicted_label: str, actual_label: str
+    cm_state: Dict[str, int], eval_payload: Dict[str, Any]
 ) -> Tuple[Dict[str, int], np.ndarray, str, str]:
-    if predicted_label not in EVAL_CLASSES:
+    if not eval_payload:
         state = dict(cm_state or CM_INIT)
         return (
             state,
@@ -690,9 +777,7 @@ def update_evaluation_auto(
             render_metric_markdown(state),
             "Jalankan deteksi terlebih dahulu agar evaluasi otomatis dapat diperbarui.",
         )
-    if actual_label not in EVAL_CLASSES:
-        actual_label = predicted_label
-    return update_evaluation(cm_state, predicted_label, actual_label)
+    return update_evaluation(cm_state, eval_payload)
 
 
 def reset_evaluation() -> Tuple[Dict[str, int], np.ndarray, str, str]:
@@ -959,6 +1044,15 @@ def save_training_curve_image(chart_rgb: np.ndarray, output_path: Path) -> str |
     return str(output_path)
 
 
+def load_rgb_image(image_path: Path) -> np.ndarray | None:
+    if not image_path.exists() or not image_path.is_file():
+        return None
+    bgr = cv2.imread(str(image_path))
+    if bgr is None:
+        return None
+    return cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+
+
 def save_training_summary(paths: Dict[str, Path], state: Dict[str, Any], rows_count: int) -> str:
     payload = {
         "saved_at": datetime.now().isoformat(),
@@ -975,6 +1069,49 @@ def save_training_summary(paths: Dict[str, Path], state: Dict[str, Any], rows_co
     return str(paths["summary"])
 
 
+def sync_training_artifacts_to_hf(
+    run_name: str,
+    results_csv: Path | None,
+    log_file: Path | None,
+    chart_file: Path | None,
+    summary_file: Path | None,
+) -> str:
+    hf_repo = os.getenv("HF_MODEL_REPO", "").strip()
+    hf_repo_type = os.getenv("HF_MODEL_REPO_TYPE", "space").strip() or "space"
+    hf_token = os.getenv("HF_TOKEN", "").strip() or None
+    repo_dir = os.getenv("HF_TRAINING_DIR", "space_training_archive").strip().strip("/")
+    run_name = run_name or datetime.now().strftime("training_%Y%m%d_%H%M%S")
+
+    if not hf_repo:
+        return "HF training artifact sync dilewati: set HF_MODEL_REPO."
+
+    upload_items: list[tuple[Path | None, str]] = [
+        (results_csv, f"{repo_dir}/{run_name}/results.csv"),
+        (log_file, f"{repo_dir}/{run_name}/training.log"),
+        (chart_file, f"{repo_dir}/{run_name}/training_curve.png"),
+        (summary_file, f"{repo_dir}/{run_name}/training_summary.json"),
+        (chart_file, "training_outputs/training_curve_latest.png"),
+        (summary_file, "training_outputs/training_summary_latest.json"),
+    ]
+    try:
+        api = HfApi(token=hf_token)
+        uploaded = 0
+        for local_path, repo_path in upload_items:
+            if local_path is None or (not local_path.exists()) or (not local_path.is_file()):
+                continue
+            api.upload_file(
+                path_or_fileobj=str(local_path),
+                path_in_repo=repo_path,
+                repo_id=hf_repo,
+                repo_type=hf_repo_type,
+                commit_message=f"Save training artifact {run_name}",
+            )
+            uploaded += 1
+        return f"HF training artifact sync sukses: {uploaded} file -> {repo_dir}/{run_name}"
+    except Exception as err:
+        return f"HF training artifact sync gagal: {err}"
+
+
 def _env_true(var_name: str, default: bool = False) -> bool:
     val = os.getenv(var_name)
     if val is None:
@@ -1284,10 +1421,14 @@ def _training_status_md(state: Dict[str, Any], rows_count: int) -> str:
             f"Tahap: **{stage}**  \nEpoch tercatat: **{rows_count}**"
         )
     if status == "done":
-        return f"Status training: **Selesai**  \nRun: `{run_name}`"
+        sync_msg = state.get("artifacts_sync_msg")
+        suffix = f"  \nArtefak: `{sync_msg}`" if sync_msg else ""
+        return f"Status training: **Selesai**  \nRun: `{run_name}`{suffix}"
     if status == "failed":
         err = state.get("error", "-")
-        return f"Status training: **Gagal**  \nRun: `{run_name}`  \nError: `{err}`"
+        sync_msg = state.get("artifacts_sync_msg")
+        suffix = f"  \nArtefak: `{sync_msg}`" if sync_msg else ""
+        return f"Status training: **Gagal**  \nRun: `{run_name}`  \nError: `{err}`{suffix}"
     return f"Status training: **{status}**  \nRun: `{run_name}`"
 
 
@@ -1300,10 +1441,17 @@ def poll_training_status() -> Tuple[str, Any, Any, Any, Any, np.ndarray, str]:
 
         results_csv = _safe_results_csv_path(state)
         rows = _read_results_rows(results_csv) if results_csv is not None else []
-        chart = plot_training_curves(results_csv) if results_csv is not None else _make_info_image(
-            "Grafik training belum tersedia."
+        saved_chart = load_rgb_image(paths["chart"])
+        chart = (
+            plot_training_curves(results_csv)
+            if results_csv is not None
+            else saved_chart
+            if saved_chart is not None
+            else _make_info_image("Grafik training belum tersedia.")
+        )
+        chart_file = save_training_curve_image(chart, paths["chart"]) if results_csv is not None else (
+            str(paths["chart"]) if paths["chart"].exists() else None
         )
-        chart_file = save_training_curve_image(chart, paths["chart"]) if results_csv is not None else None
 
         if state.get("status") == "running":
             pid = int(state.get("pid", 0) or 0)
@@ -1318,6 +1466,17 @@ def poll_training_status() -> Tuple[str, Any, Any, Any, Any, np.ndarray, str]:
         metrics_file = str(results_csv) if results_csv is not None else None
         log_file = str(paths["log"]) if paths["log"].exists() else None
         summary_file = save_training_summary(paths, state, len(rows))
+        if state.get("status") in {"done", "failed"} and not state.get("artifacts_sync_attempted"):
+            sync_msg = sync_training_artifacts_to_hf(
+                run_name=str(state.get("run_name", "training_run")),
+                results_csv=results_csv,
+                log_file=Path(log_file) if log_file else None,
+                chart_file=Path(chart_file) if chart_file else None,
+                summary_file=Path(summary_file) if summary_file else None,
+            )
+            state["artifacts_sync_attempted"] = True
+            state["artifacts_sync_msg"] = sync_msg
+            _write_status(paths["status"], state)
         return (
             log_text,
             best_file,
@@ -1340,6 +1499,7 @@ def poll_training_status() -> Tuple[str, Any, Any, Any, Any, np.ndarray, str]:
 
 
 def run_training(
+    train_model_choice: str,
     epochs: float,
     imgsz: float,
     batch: float,
@@ -1377,7 +1537,10 @@ def run_training(
             log_file=paths["log"],
         )
 
-        model_path = str(base_dir / "yolov8n.pt") if (base_dir / "yolov8n.pt").exists() else resolve_model_path("YOLOv8n")
+        if train_model_choice == "Best.pt":
+            model_path = resolve_model_path("Best.pt")
+        else:
+            model_path = str(base_dir / "yolov8n.pt") if (base_dir / "yolov8n.pt").exists() else resolve_model_path("YOLOv8n")
         run_name = f"classroom_train_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
         project_dir = base_dir / "runs_train"
         save_dir = project_dir / run_name
@@ -1385,6 +1548,7 @@ def run_training(
 
         with paths["log"].open("a", encoding="utf-8") as lf:
             lf.write(f"\n[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Start training {run_name}\n")
+            lf.write(f"Model awal training: {train_model_choice} ({model_path})\n")
             lf.write(f"{prep_info}\n")
 
         train_code = r"""
@@ -1532,6 +1696,9 @@ CUSTOM_CSS = """
 }
 .version-foot {font-size:12px; color:#64748b; text-align:center; margin-top:8px;}
 .advanced-box {margin-top: 8px; padding: 8px; border: 1px dashed #cbd5e1; border-radius: 8px;}
+.section-box table {width: 100%; border-collapse: collapse; font-size: 14px;}
+.section-box th, .section-box td {padding: 8px 10px; border-bottom: 1px solid #e2e8f0; vertical-align: top;}
+.section-box th {background: #f8fafc; font-weight: 700;}
 
 @media (prefers-color-scheme: dark) {
   body, .gradio-container {background: #0f172a !important; color: #e2e8f0 !important;}
@@ -1541,6 +1708,8 @@ CUSTOM_CSS = """
   .version-chip {background: #111827 !important; border-color: #475569 !important; color: #cbd5e1 !important;}
   .version-foot {color: #94a3b8 !important;}
   .advanced-box {border-color: #475569 !important;}
+  .section-box th {background: #1f2937 !important;}
+  .section-box th, .section-box td {border-color: #334155 !important;}
 }
 """
 
@@ -1574,7 +1743,7 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
         )
 
     with gr.Column(elem_classes=["section-box"]):
-        gr.Markdown("## Tahap 1 - Akuisisi Data", elem_classes=["section-title"])
+        gr.Markdown("## Tahap 1 - Pilih Model", elem_classes=["section-title"])
         inference_mode = gr.Dropdown(
             choices=["Single Model", "Bandingkan (YOLOv8n vs Best.pt)"],
             value="Single Model",
@@ -1585,11 +1754,6 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
             value="YOLOv8n",
             label="Pilih Model",
         )
-        image_input = gr.Image(
-            label="Input Gambar Kelas (Upload/Kamera)",
-            type="numpy",
-            sources=["upload", "webcam"],
-        )
         conf_input = gr.Slider(0.1, 1.0, value=0.25, step=0.05, label="Parameter Confidence (Deteksi)")
         with gr.Accordion("Advanced Options", open=False, elem_classes=["advanced-box"]):
             annotation_style = gr.Radio(
@@ -1598,53 +1762,35 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
                 label="Gaya anotasi objek",
                 info="Pilih tampilan bbox atau label-only untuk label objek yang terdeteksi.",
             )
-        run_btn = gr.Button("Jalankan Deteksi dan Klasifikasi", variant="primary")
 
     with gr.Column(elem_classes=["section-box"]):
-        gr.Markdown("## Tahap 2 - Hasil Deteksi dan Klasifikasi", elem_classes=["section-title"])
-        output_image_yolo = gr.Image(
-            label="Output Deteksi YOLOv8n",
-            type="filepath",
-        )
-        output_image_best = gr.Image(
-            label="Output Deteksi Best.pt",
-            type="filepath",
+        gr.Markdown("## Tahap 2 - Input Gambar", elem_classes=["section-title"])
+        image_input = gr.Image(
+            label="Input Gambar Kelas (Upload/Kamera)",
+            type="numpy",
+            sources=["upload", "webcam"],
         )
-        class_result_md = gr.Markdown("Ringkasan hasil deteksi akan tampil di sini.")
-        comparison_chart = gr.Image(label="Visualisasi Jumlah Person Terdeteksi", type="numpy")
-        predicted_label_md = gr.Markdown("Label prediksi evaluasi: **-**")
-        saved_detection_file = gr.File(label="File Gambar Hasil Evaluasi")
-        evaluation_csv_file = gr.File(label="Log CSV Evaluasi Lokal")
+        run_btn = gr.Button("Jalankan Deteksi dan Klasifikasi", variant="primary")
 
     with gr.Column(elem_classes=["section-box"]):
-        gr.Markdown("## Tahap 3 - Evaluasi (Confusion Matrix + Rumus)", elem_classes=["section-title"])
-        cm_state = gr.State(dict(CM_INIT))
-        predicted_state = gr.State("")
-        actual_state = gr.State("")
-        gr.Markdown(
-            "Evaluasi diperbarui otomatis setelah inferensi. "
-            "Untuk mode `Best.pt` dan mode perbandingan, label aktual/proxy diambil dari referensi scene YOLOv8n "
-            "agar kasus objek non-person ikut masuk sebagai `Not Person/Background`."
+        gr.Markdown("## Tahap 3 - Grafik dan Training", elem_classes=["section-title"])
+        comparison_chart = gr.Image(
+            label="Grafik Count Person dan Not Person",
+            type="numpy",
+            value=_make_info_image("Grafik hasil deteksi akan tampil setelah proses inferensi."),
         )
-        with gr.Row():
-            reset_eval_btn = gr.Button("Reset Evaluasi")
-        eval_status = gr.Markdown("Belum ada update evaluasi otomatis.")
-        with gr.Row():
-            cm_image = gr.Image(
-                label="Confusion Matrix",
-                value=draw_confusion_matrix_from_state(CM_INIT),
-                type="numpy",
-                interactive=False,
-            )
-            metric_md = gr.Markdown(render_metric_markdown(CM_INIT))
-
-    with gr.Column(elem_classes=["section-box"]):
-        with gr.Accordion("Tahap 4 - Pengembangan Model (Training)", open=False):
+        with gr.Accordion("Menu Training Model", open=False):
             gr.Markdown(
                 "Training akan membaca dataset dari `dataset/train` dan `dataset/test`.\n"
                 "Jika label `.txt` belum ada, aktifkan pseudo-label agar proses tetap jalan.\n"
                 "Saat training berjalan, terminal progres dan grafik epoch akan update otomatis."
             )
+            train_model_choice = gr.Dropdown(
+                choices=["YOLOv8n", "Best.pt"],
+                value="YOLOv8n",
+                label="Model awal training",
+                info="Pilih YOLOv8n untuk training awal, atau Best.pt untuk melanjutkan fine-tuning dari bobot terakhir.",
+            )
             with gr.Row():
                 train_epochs = gr.Number(label="Epochs", value=10, precision=0, minimum=1)
                 train_imgsz = gr.Number(label="Image Size", value=640, precision=0, minimum=64)
@@ -1674,6 +1820,42 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
             training_log_file = gr.File(label="training.log / Log Training Lokal")
             training_chart_file = gr.File(label="training_curve_latest.png / Grafik Training Lokal")
 
+    with gr.Column(elem_classes=["section-box"]):
+        gr.Markdown("## Tahap 4 - Evaluasi (Confusion Matrix + Rumus)", elem_classes=["section-title"])
+        cm_state = gr.State(dict(CM_INIT))
+        predicted_state = gr.State("")
+        actual_state = gr.State("")
+        eval_payload_state = gr.State({})
+        gr.Markdown(
+            "Evaluasi otomatis memakai count objek. `Person` dihitung sebagai objek positif, "
+            "sedangkan objek selain person dihitung sebagai `Not Person/Background`."
+        )
+        reset_eval_btn = gr.Button("Reset Evaluasi")
+        eval_status = gr.Markdown("Belum ada update evaluasi otomatis.")
+        with gr.Row():
+            cm_image = gr.Image(
+                label="Confusion Matrix Count Objek",
+                value=draw_confusion_matrix_from_state(CM_INIT),
+                type="numpy",
+                interactive=False,
+            )
+            metric_md = gr.Markdown(render_metric_markdown(CM_INIT))
+
+    with gr.Column(elem_classes=["section-box"]):
+        gr.Markdown("## Tahap 5 - Hasil Gambar", elem_classes=["section-title"])
+        output_image_yolo = gr.Image(
+            label="Output Deteksi YOLOv8n",
+            type="filepath",
+        )
+        output_image_best = gr.Image(
+            label="Output Deteksi Best.pt",
+            type="filepath",
+        )
+        class_result_md = gr.Markdown("Ringkasan hasil deteksi akan tampil di sini.")
+        predicted_label_md = gr.Markdown("Label prediksi evaluasi: **-**")
+        saved_detection_file = gr.File(label="File Gambar Hasil Evaluasi")
+        evaluation_csv_file = gr.File(label="Log CSV Evaluasi Lokal")
+
     run_btn_evt = run_btn.click(
         fn=run_check_and_classify,
         inputs=[image_input, conf_input, model_choice, inference_mode, annotation_style],
@@ -1684,6 +1866,7 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
             comparison_chart,
             predicted_state,
             actual_state,
+            eval_payload_state,
             predicted_label_md,
             saved_detection_file,
             evaluation_csv_file,
@@ -1691,7 +1874,7 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
     )
     run_btn_evt.then(
         fn=update_evaluation_auto,
-        inputs=[cm_state, predicted_state, actual_state],
+        inputs=[cm_state, eval_payload_state],
         outputs=[cm_state, cm_image, metric_md, eval_status],
     )
     inference_mode.change(
@@ -1708,7 +1891,7 @@ with gr.Blocks(title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
 
     train_btn.click(
         fn=run_training,
-        inputs=[train_epochs, train_imgsz, train_batch, use_pseudo, pseudo_conf],
+        inputs=[train_model_choice, train_epochs, train_imgsz, train_batch, use_pseudo, pseudo_conf],
         outputs=[
             train_log,
             best_model_file,