Simplify to check+classification only, remove batch input and training UI

README.md

@@ -1,5 +1,5 @@
 ---
-title: Validasi Kehadiran Mahasiswa YOLOv8
+title: Klasifikasi Kehadiran Mahasiswa YOLOv8
 emoji: 🎓
 colorFrom: blue
 colorTo: green
@@ -8,108 +8,69 @@ python_version: "3.10"
 app_file: app.py
 ---
 
-# Implementasi Klasifikasi Kehadiran Mahasiswa Berbasis YOLOv8
+# Pengecekan dan Klasifikasi Kehadiran Mahasiswa Berbasis YOLOv8
 
-Proyek ini menyiapkan demo riset untuk validasi kehadiran mahasiswa di dalam ruang kelas menggunakan deteksi objek YOLOv8 dan OpenCV.
+Versi ini difokuskan untuk tahap awal:
+- pengecekan gambar kelas,
+- deteksi objek `person`,
+- klasifikasi sederhana keberadaan mahasiswa.
 
-## Tujuan Proyek
+## Tujuan Fitur Saat Ini
 
-Membangun aplikasi yang dapat:
-- menerima input gambar kelas (upload atau webcam),
-- mendeteksi objek kelas `person`,
-- menghitung jumlah mahasiswa terdeteksi,
-- membandingkan hasil deteksi dengan jumlah presensi,
-- menampilkan status validasi:
-  - `Sesuai` jika jumlah deteksi sama dengan presensi,
-  - `Tidak sesuai` jika berbeda.
-
-## Cara Kerja Validasi Presensi
-
-1. Model YOLOv8 dimuat dari `yolov8n.pt` (lokal default), atau dari Hugging Face Hub (opsional).
-2. Gambar diproses untuk deteksi objek.
-3. Sistem menghitung jumlah objek `person`.
-4. Jumlah deteksi dibandingkan dengan jumlah presensi dari pengguna.
-5. Aplikasi menampilkan:
+1. Upload gambar atau ambil dari kamera.
+2. Jalankan deteksi `person` dengan YOLOv8.
+3. Tampilkan hasil:
    - gambar teranotasi bounding box,
-   - ringkasan jumlah terdeteksi,
-   - jumlah presensi,
-   - status validasi.
-
-## Evaluasi Klasifikasi (Confusion Matrix Image)
+   - jumlah person terdeteksi,
+   - status klasifikasi:
+     - `Ada Mahasiswa` jika jumlah terdeteksi > 0
+     - `Tidak Ada Mahasiswa` jika jumlah terdeteksi = 0
+   - grafik hasil pengecekan.
 
-Aplikasi menyediakan evaluasi batch otomatis:
-- upload ZIP berisi gambar evaluasi,
-- upload CSV ground truth (filename, presensi, actual_label),
-- sistem menjalankan klasifikasi untuk semua sampel,
-- output confusion matrix ditampilkan sebagai **gambar heatmap**,
-- metrik Accuracy, Precision, Recall, dan F1-Score dihitung otomatis.
-
-## Struktur UI (Vertical Sections)
+## Struktur UI
 
 - **Section 1 - Input & Proses**
-  - upload/kamera gambar, input presensi, parameter confidence, tombol proses klasifikasi
-  - input evaluasi batch (ZIP gambar + CSV ground truth)
+  - input gambar (upload/webcam)
+  - confidence threshold
+  - tombol proses
 - **Section 2 - Hasil Processing**
-  - hasil klasifikasi
-  - grafik perbandingan (terdeteksi vs presensi)
-  - confusion matrix image
-  - metrik evaluasi batch
-- **Section 3 - Training**
-  - upload ZIP dataset YOLO
-  - set path `data.yaml`, epochs, image size
-  - jalankan training dan ambil `best.pt` jika tersedia
+  - hasil gambar deteksi
+  - ringkasan klasifikasi
+  - grafik jumlah person terdeteksi
+
+Catatan:
+- input evaluasi batch dihapus.
+- menu training dipisahkan dari halaman ini.
+- input jumlah presensi belum digunakan pada versi ini.
 
-## Struktur File yang Diharapkan
+## File Penting
 
-- `app.py` - aplikasi Gradio untuk Spaces
-- `requirements.txt` - dependensi Python
+- `app.py` - aplikasi Gradio
+- `requirements.txt` - dependensi
+- `yolov8n.pt` - model default
 - `.gitignore` - aturan ignore
-- `yolov8n.pt` - model YOLOv8 baseline untuk demo awal
-- `best.pt` - model hasil training lanjutan (opsional, bisa dipakai kemudian)
 
 Opsional environment variable:
-- `MODEL_PATH` : path model lokal custom
-- `HF_MODEL_REPO` : repo model Hugging Face Hub (misalnya `username/repo-model`)
-- `HF_MODEL_FILE` : nama file model di repo Hub (default `yolov8n.pt`)
+- `MODEL_PATH` - path model lokal custom
+- `HF_MODEL_REPO` - repo model Hugging Face Hub
+- `HF_MODEL_FILE` - nama file model di Hub (default `yolov8n.pt`)
 
-## Menjalankan Secara Lokal
+## Menjalankan Lokal
 
 ```bash
 python -m venv .venv
 # Windows
 .venv\Scripts\activate
-# Linux/macOS
-# source .venv/bin/activate
 
 pip install -r requirements.txt
 python app.py
 ```
 
-Buka URL lokal yang muncul di terminal (default Gradio).
-
 ## Deploy ke Hugging Face Spaces
 
-1. Buat Space baru dengan SDK **Gradio**.
-2. Upload file:
-   - `app.py`
-   - `requirements.txt`
-   - `README.md`
-   - `.gitignore`
-   - `yolov8n.pt` (atau gunakan env Hub fallback)
-3. Jika model dari Hub, atur Secrets/Variables:
-   - `HF_MODEL_REPO`
-   - `HF_MODEL_FILE` (opsional)
-4. Space akan build otomatis dan menjalankan `app.py`.
-
-## Format CSV Evaluasi
-
-Contoh kolom yang didukung:
-- `filename` (atau `file`/`image`)
-- `presensi` (atau `attendance`)
-- `actual_label` (atau `label`/`ground_truth`) berisi `Sesuai` atau `Tidak sesuai`
-
-## Catatan
-
-- Fitur utama saat ini fokus pada inferensi gambar.
-- Kerangka ekstensi video sudah disiapkan sebagai stub, tetapi pipeline video penuh belum diimplementasikan.
-- Jika nanti model training `best.pt` sudah siap, cukup set `MODEL_PATH=best.pt` atau `HF_MODEL_FILE=best.pt`.
+Upload:
+- `app.py`
+- `requirements.txt`
+- `README.md`
+- `.gitignore`
+- `yolov8n.pt` (atau gunakan env Hub fallback)

app.py

@@ -1,25 +1,16 @@
 import io
 import os
-import tempfile
-import zipfile
-from datetime import datetime
 from functools import lru_cache
-from typing import Any, Dict, List, Tuple
+from typing import Any, Tuple
 
 import cv2
 import gradio as gr
 import matplotlib.pyplot as plt
 import numpy as np
-import pandas as pd
-import seaborn as sns
 from huggingface_hub import hf_hub_download
-from sklearn.metrics import confusion_matrix
 from ultralytics import YOLO
 
 
-CLASS_NAMES = ["Sesuai", "Tidak sesuai"]
-
-
 def resolve_model_path() -> str:
     model_env = os.getenv("MODEL_PATH", "").strip()
     base_dir = os.path.dirname(__file__)
@@ -49,10 +40,6 @@ def load_model() -> YOLO:
     return YOLO(resolve_model_path())
 
 
-def _safe_div(num: float, den: float) -> float:
-    return 0.0 if den == 0 else num / den
-
-
 def _resolve_person_class_id(result: Any) -> int:
     names = getattr(result, "names", {})
     if isinstance(names, dict):
@@ -79,19 +66,25 @@ def infer_image(image: np.ndarray, conf_threshold: float) -> Tuple[np.ndarray, i
     return annotated, detected_count
 
 
-def classify_status(detected_count: int, attendance_count: int) -> str:
-    return "Sesuai" if detected_count == attendance_count else "Tidak sesuai"
+def classify_presence(detected_count: int) -> str:
+    return "Ada Mahasiswa" if detected_count > 0 else "Tidak Ada Mahasiswa"
 
 
-def draw_single_comparison_chart(detected: int, attendance: int) -> np.ndarray:
+def draw_detection_chart(detected: int) -> np.ndarray:
     fig, ax = plt.subplots(figsize=(5.0, 3.2))
-    labels = ["Terdeteksi", "Presensi"]
-    values = [detected, attendance]
-    bars = ax.bar(labels, values, color=["#2b6cb0", "#2f855a"])
-    ax.set_title("Grafik Perbandingan")
+    labels = ["Jumlah Person Terdeteksi"]
+    values = [detected]
+    bars = ax.bar(labels, values, color=["#2b6cb0"])
+    ax.set_title("Grafik Hasil Pengecekan")
     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")
+        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()
@@ -103,24 +96,18 @@ def draw_single_comparison_chart(detected: int, attendance: int) -> np.ndarray:
     return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
 
 
-def run_single_validation(
-    image: np.ndarray, attendance_count: float, conf_threshold: float
+def run_check_and_classify(
+    image: np.ndarray, conf_threshold: float
 ) -> Tuple[np.ndarray, str, np.ndarray]:
-    try:
-        attendance = int(attendance_count)
-    except (TypeError, ValueError):
-        attendance = 0
-
     try:
         annotated, detected = infer_image(image, conf_threshold)
-        status = classify_status(detected, attendance)
+        status = classify_presence(detected)
         summary = (
             "### Hasil Klasifikasi\n"
-            f"- Jumlah terdeteksi: **{detected}**\n"
-            f"- Jumlah presensi: **{attendance}**\n"
+            f"- Jumlah person terdeteksi: **{detected}**\n"
             f"- Status klasifikasi: **{status}**"
         )
-        chart = draw_single_comparison_chart(detected, attendance)
+        chart = draw_detection_chart(detected)
         return annotated, summary, chart
     except Exception as err:
         summary = (
@@ -129,181 +116,16 @@ def run_single_validation(
             "Tips: pastikan model tersedia (`yolov8n.pt` atau MODEL_PATH)."
         )
         blank = np.full((320, 500, 3), 245, dtype=np.uint8)
-        cv2.putText(blank, "Grafik belum tersedia", (120, 165), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (80, 80, 80), 2)
-        return image, summary, blank
-
-
-def draw_confusion_matrix_image(cm: np.ndarray) -> np.ndarray:
-    sns.set_style("white")
-    fig, ax = plt.subplots(figsize=(6.2, 4.8))
-    sns.heatmap(
-        cm,
-        annot=True,
-        fmt="d",
-        cmap="Blues",
-        cbar=True,
-        xticklabels=CLASS_NAMES,
-        yticklabels=CLASS_NAMES,
-        linewidths=0.5,
-        linecolor="white",
-        ax=ax,
-    )
-    ax.set_title("Confusion Matrix", fontsize=12, pad=10)
-    ax.set_xlabel("Predicted label")
-    ax.set_ylabel("True label")
-    plt.xticks(rotation=30, ha="right")
-    plt.yticks(rotation=0)
-    plt.tight_layout()
-
-    buf = io.BytesIO()
-    fig.savefig(buf, format="png", dpi=150)
-    plt.close(fig)
-    buf.seek(0)
-    data = np.frombuffer(buf.read(), dtype=np.uint8)
-    img_bgr = cv2.imdecode(data, cv2.IMREAD_COLOR)
-    return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
-
-
-def _normalize_actual_label(value: str) -> str:
-    v = str(value).strip().lower()
-    if v in ("sesuai", "match", "1", "true"):
-        return "Sesuai"
-    return "Tidak sesuai"
-
-
-def _get_col(df: pd.DataFrame, options: List[str]) -> str:
-    lower_map = {c.lower(): c for c in df.columns}
-    for opt in options:
-        if opt.lower() in lower_map:
-            return lower_map[opt.lower()]
-    raise ValueError(f"Kolom tidak ditemukan. Butuh salah satu dari: {options}")
-
-
-def evaluate_classification_batch(
-    image_zip_path: str, csv_path: str, conf_threshold: float
-) -> Tuple[np.ndarray, str]:
-    if not image_zip_path or not csv_path:
-        raise ValueError("Upload ZIP gambar dan CSV evaluasi terlebih dahulu.")
-
-    df = pd.read_csv(csv_path)
-    fname_col = _get_col(df, ["filename", "file", "image", "image_name"])
-    pres_col = _get_col(df, ["presensi", "attendance", "attendance_count"])
-    actual_col = _get_col(df, ["actual_label", "label", "ground_truth", "aktual"])
-
-    y_true: List[str] = []
-    y_pred: List[str] = []
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        with zipfile.ZipFile(image_zip_path, "r") as zf:
-            zf.extractall(tmpdir)
-
-        for _, row in df.iterrows():
-            fname = str(row[fname_col]).strip()
-            attendance = int(row[pres_col])
-            actual = _normalize_actual_label(row[actual_col])
-            img_path = os.path.join(tmpdir, fname)
-            img = cv2.imread(img_path)
-            if img is None:
-                continue
-            rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            _, detected = infer_image(rgb, conf_threshold)
-            pred = classify_status(detected, attendance)
-            y_true.append(actual)
-            y_pred.append(pred)
-
-    if len(y_true) == 0:
-        raise ValueError("Tidak ada sampel valid yang berhasil diproses.")
-
-    cm = confusion_matrix(y_true, y_pred, labels=CLASS_NAMES)
-    cm_img = draw_confusion_matrix_image(cm)
-    tn, fp, fn, tp = cm.ravel() if cm.size == 4 else (0, 0, 0, 0)
-    acc = _safe_div(tp + tn, tp + tn + fp + fn)
-    prec = _safe_div(tp, tp + fp)
-    rec = _safe_div(tp, tp + fn)
-    f1 = _safe_div(2 * prec * rec, prec + rec)
-    metrics = (
-        "### Hasil Evaluasi Batch\n"
-        f"- Jumlah sampel: **{len(y_true)}**\n"
-        f"- Accuracy: **{acc:.4f}**\n"
-        f"- Precision (Sesuai): **{prec:.4f}**\n"
-        f"- Recall (Sesuai): **{rec:.4f}**\n"
-        f"- F1-Score (Sesuai): **{f1:.4f}**"
-    )
-    return cm_img, metrics
-
-
-def run_batch_ui(image_zip: Any, csv_file: Any, conf_threshold: float) -> Tuple[np.ndarray, str]:
-    try:
-        zip_path = image_zip.name if image_zip is not None else ""
-        csv_path = csv_file.name if csv_file is not None else ""
-        return evaluate_classification_batch(zip_path, csv_path, conf_threshold)
-    except Exception as err:
-        msg = f"### Hasil Evaluasi Batch\nEvaluasi batch gagal: {err}"
-        blank = np.full((420, 620, 3), 245, dtype=np.uint8)
-        cv2.putText(blank, "Confusion Matrix belum tersedia", (95, 210), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (80, 80, 80), 2)
-        return blank, msg
-
-
-def _find_yaml(root_dir: str, yaml_name_or_path: str) -> str:
-    candidate = os.path.join(root_dir, yaml_name_or_path)
-    if os.path.exists(candidate):
-        return candidate
-
-    target_name = os.path.basename(yaml_name_or_path)
-    for base, _, files in os.walk(root_dir):
-        for f in files:
-            if f == target_name:
-                return os.path.join(base, f)
-    raise FileNotFoundError(f"File YAML dataset tidak ditemukan: {yaml_name_or_path}")
-
-
-def run_training_ui(
-    dataset_zip: Any, data_yaml: str, epochs: float, imgsz: float
-) -> Tuple[str, str]:
-    if dataset_zip is None:
-        return "Training gagal: upload ZIP dataset terlebih dahulu.", None
-
-    try:
-        dataset_path = dataset_zip.name
-        base_dir = os.path.dirname(__file__)
-        train_workspace = os.path.join(base_dir, "training_data", datetime.now().strftime("%Y%m%d_%H%M%S"))
-        os.makedirs(train_workspace, exist_ok=True)
-
-        with zipfile.ZipFile(dataset_path, "r") as zf:
-            zf.extractall(train_workspace)
-
-        yaml_path = _find_yaml(train_workspace, data_yaml.strip() or "data.yaml")
-        base_model = os.path.join(base_dir, "yolov8n.pt")
-        if not os.path.exists(base_model):
-            base_model = resolve_model_path()
-
-        train_model = YOLO(base_model)
-        results = train_model.train(
-            data=yaml_path,
-            epochs=int(epochs),
-            imgsz=int(imgsz),
-            project=os.path.join(base_dir, "runs_train"),
-            name="space_train",
-            exist_ok=True,
-            device="cpu",
-            verbose=False,
-        )
-
-        save_dir = str(results.save_dir)
-        best_path = os.path.join(save_dir, "weights", "best.pt")
-        if not os.path.exists(best_path):
-            best_path = None
-
-        msg = (
-            "Training selesai.\n"
-            f"- Dataset workspace: `{train_workspace}`\n"
-            f"- data.yaml: `{yaml_path}`\n"
-            f"- Output run: `{save_dir}`\n"
-            f"- best.pt: `{best_path}`"
+        cv2.putText(
+            blank,
+            "Grafik belum tersedia",
+            (120, 165),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.8,
+            (80, 80, 80),
+            2,
         )
-        return msg, best_path
-    except Exception as err:
-        return f"Training gagal: {err}", None
+        return image, summary, blank
 
 
 CUSTOM_CSS = """
@@ -312,12 +134,12 @@ CUSTOM_CSS = """
 """
 
 
-with gr.Blocks(css=CUSTOM_CSS, title="Klasifikasi Kehadiran Mahasiswa - YOLOv8") as demo:
+with gr.Blocks(css=CUSTOM_CSS, title="Pengecekan dan Klasifikasi Mahasiswa - YOLOv8") as demo:
     gr.HTML(
         """
-        <h1 style="text-align:center;margin-bottom:4px;">Klasifikasi Kehadiran Mahasiswa Berbasis YOLOv8</h1>
+        <h1 style="text-align:center;margin-bottom:4px;">Pengecekan dan Klasifikasi Kehadiran Berbasis YOLOv8</h1>
         <p style="text-align:center;color:#4a5568;margin-top:0;">
-            Status <b>Sesuai</b> jika jumlah terdeteksi = jumlah presensi, selain itu <b>Tidak sesuai</b>.
+            Mode saat ini: deteksi person pada gambar kelas + klasifikasi keberadaan mahasiswa.
         </p>
         """
     )
@@ -331,54 +153,20 @@ with gr.Blocks(css=CUSTOM_CSS, title="Klasifikasi Kehadiran Mahasiswa - YOLOv8")
                 sources=["upload", "webcam"],
             )
             output_image = gr.Image(label="Hasil Proses (Dekat Upload)", type="numpy")
-        attendance_input = gr.Number(label="Jumlah Presensi", value=0, precision=0, minimum=0)
         conf_input = gr.Slider(0.1, 1.0, value=0.25, step=0.05, label="Confidence Threshold")
-        run_btn = gr.Button("Proses Klasifikasi", variant="primary")
-        gr.Markdown("### Input Evaluasi Batch")
-        image_zip = gr.File(label="ZIP Gambar Evaluasi", file_types=[".zip"])
-        csv_file = gr.File(label="CSV Ground Truth", file_types=[".csv"])
-        eval_btn = gr.Button("Jalankan Evaluasi Batch", variant="secondary")
+        run_btn = gr.Button("Proses Pengecekan", variant="primary")
 
     with gr.Column(elem_classes=["section-box"]):
         gr.Markdown("## Section 2 - Hasil Processing")
         class_result_md = gr.Markdown("Hasil klasifikasi akan tampil di sini.")
         comparison_chart = gr.Image(label="Grafik Klasifikasi", type="numpy")
-        cm_image = gr.Image(label="Confusion Matrix", type="numpy")
-        eval_metrics = gr.Markdown("Metrik evaluasi batch akan tampil di sini.")
-
-    with gr.Column(elem_classes=["section-box"]):
-        gr.Markdown("## Section 3 - Training")
-        gr.Markdown(
-            "Upload ZIP dataset YOLO lalu jalankan training. "
-            "Isi `data.yaml` sesuai nama/path file YAML di dalam ZIP."
-        )
-        train_zip = gr.File(label="ZIP Dataset Training", file_types=[".zip"])
-        train_yaml = gr.Textbox(label="Path data.yaml di dalam ZIP", value="data.yaml")
-        with gr.Row():
-            train_epochs = gr.Number(label="Epochs", value=20, precision=0, minimum=1)
-            train_imgsz = gr.Number(label="Image Size", value=640, precision=0, minimum=64)
-        train_btn = gr.Button("Mulai Training", variant="primary")
-        train_log = gr.Textbox(label="Log Training", lines=7, interactive=False)
-        train_best = gr.File(label="Download best.pt (jika tersedia)")
 
     run_btn.click(
-        fn=run_single_validation,
-        inputs=[image_input, attendance_input, conf_input],
+        fn=run_check_and_classify,
+        inputs=[image_input, conf_input],
         outputs=[output_image, class_result_md, comparison_chart],
     )
 
-    eval_btn.click(
-        fn=run_batch_ui,
-        inputs=[image_zip, csv_file, conf_input],
-        outputs=[cm_image, eval_metrics],
-    )
-
-    train_btn.click(
-        fn=run_training_ui,
-        inputs=[train_zip, train_yaml, train_epochs, train_imgsz],
-        outputs=[train_log, train_best],
-    )
-
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -3,7 +3,4 @@ ultralytics>=8.2.0
 opencv-python-headless>=4.10.0.84
 huggingface_hub>=0.23.0
 numpy>=1.26.0
-pandas>=2.2.0
-scikit-learn>=1.5.0
 matplotlib>=3.8.0
-seaborn>=0.13.0