create log experiment

.gitignore

@@ -16,25 +16,14 @@ test.py
 
 .env
 outputs/interim/
-outputs-publik/interim/
-
 outputs/logs/
-outputs-publik/logs/
-
 outputs/figures/
-outputs-publik/figures/
-
+outputs-v1/interim/
+outputs-v1/logs/
 outputs/visualized_segments/
-outputs-publik/visualized_segments/
 
-archives/
 
-outputs-publik
 
-
-outputs-denoise/
-outputs-bima/
-data/data-publik/
 data/dataset_root/
 data/01_raw/*
 data/02_processed/*
@@ -52,7 +41,8 @@ pertahankan folder dengan file kosong .gitkeep
 
 
 
+<<<<<<< HEAD
 /results
 
-archives-1/
-
+=======
+>>>>>>> bdb5b47fc05627063c1ade15705b9dca12b5f889

README.md

@@ -13,420 +13,46 @@ tags:
 - beef-grading
 ---
 
-# Pipeline Beef Research BIMA: Deteksi Mutu Kesegaran Daging Sapi Multidomain
-
-## Daftar Isi
-
-1. [Latar Belakang](#1-latar-belakang)
-2. [Tujuan Penelitian](#2-tujuan-penelitian)
-3. [Dataset](#3-dataset)
-4. [Metodologi](#4-metodologi)
-5. [Arsitektur Pipeline](#5-arsitektur-pipeline)
-6. [Tahapan Pipeline (Detail Teknis)](#6-tahapan-pipeline-detail-teknis)
-7. [Hasil dan Evaluasi](#7-hasil-dan-evaluasi)
-8. [Struktur Output](#8-struktur-output)
-9. [Setup dan Instalasi](#9-setup-dan-instalasi)
-10. [Cara Menjalankan Pipeline](#10-cara-menjalankan-pipeline)
-11. [Struktur Proyek](#11-struktur-proyek)
-
----
-
-## 1. Latar Belakang
-
-Penilaian mutu dan kesegaran daging sapi secara konvensional masih mengandalkan inspeksi visual oleh tenaga ahli—sebuah proses yang tidak skalabel, subjektif, dan rentan terhadap inkonsistensi antar penilai. Di sisi lain, pendekatan *machine learning* supervised (SVM, KNN, CNN) membutuhkan dataset berlabel dalam jumlah besar yang mahal dan memakan waktu untuk dikumpulkan, terutama di konteks penelitian lapangan (RPH dan UMKM).
-
-Proyek ini menawarkan pendekatan alternatif: pipeline **sepenuhnya unsupervised** berbasis computer vision yang mampu memisahkan citra daging sapi ke dalam dua klaster mutu (Segar / Tidak Segar) **tanpa memerlukan label training satu pun**. Sistem ini dirancang untuk berjalan lintas domain (multi-domain), yaitu dapat menangani dataset dari kondisi pengambilan gambar yang berbeda (latar belakang hitam dari RPH Day-1 dan karton biru dari UMKM Day-2) tanpa memerlukan penyesuaian aturan warna yang berbeda per domain.
-
----
-
-## 2. Tujuan Penelitian
-
-- Membangun pipeline deteksi mutu kesegaran daging sapi berbasis unsupervised learning yang tidak memerlukan proses labeling supervised.
-- Membandingkan kinerja dua algoritma ekstraksi fitur lokal: **SIFT** (*Scale-Invariant Feature Transform*) dan **SURF** (*Speeded-Up Robust Features*).
-- Mengembangkan representasi citra berbasis **Bags of Visual Words (BoVW)** yang diperkaya dengan momen warna HSV (fusi fitur tekstur + warna).
-- Mengevaluasi kualitas pemisahan klaster menggunakan metrik validasi internal (tanpa label) dan eksternal (opsional, bila label tersedia).
-- Menghasilkan model produksi yang dapat digunakan untuk klasifikasi otomatis gambar daging baru.
-
----
-
-## 3. Dataset
-
-Dataset terdiri dari citra daging sapi yang dikumpulkan dari dua domain berbeda:
-
-| Domain | Kondisi Pengambilan | Latar Belakang | Label Temporal |
-|--------|---------------------|----------------|----------------|
-| **DAY-1** | RPH (Rumah Potong Hewan), hari pertama pasca penyembelihan | Kain hitam | Segar |
-| **DAY-2** | UMKM/pasar, hari berikutnya | Karton biru muda | Mendekati tidak segar |
-
-### Konvensi Penamaan File
-
-```
-[HARI]_[DOMAIN]_[KODE]_[NOMOR].JPG
-Contoh: DAY-1_RPH_SIR_001.JPG
-```
-
-- `HARI`: `DAY-1` atau `DAY-2`
-- `DOMAIN`: kode lokasi pengambilan gambar
-- `KODE`: jenis potongan daging (misal `SIR` untuk sirloin)
-- `NOMOR`: nomor urut citra
-
-### Label Ground Truth (Opsional)
-
-File `data/labels.csv` dengan kolom `filename,label` (nilai: `segar` / `tidak_segar`) bersifat **opsional** dan **tidak digunakan untuk training**. Label ini hanya dipakai untuk validasi eksternal pasca-hoc (menghitung ARI, NMI, dan Purity) guna mengukur seberapa baik klaster otomatis bersesuaian dengan penilaian pakar.
-
----
-
-## 4. Metodologi
-
-### Prinsip Dasar: Unsupervised Sepenuhnya
-
-Pipeline ini **tidak menggunakan label apapun dalam proses pelatihan**. Seluruh pemisahan mutu dilakukan secara otonom berdasarkan struktur visual inheren dari citra daging. Pendekatan ini dipilih karena:
-
-1. **Data berlabel sulit dikumpulkan** di lapangan (membutuhkan ahli peternakan).
-2. **Validitas lintas domain** — fitur tekstur dan warna permukaan daging yang terurai seharusnya universal, tidak bergantung pada latar belakang foto.
-3. **Skalabilitas** — sistem dapat langsung diterapkan pada dataset baru tanpa proses re-labeling.
-
-### Alur Metodologi
-
-```
-Citra Mentah
-    │
-    ▼
-Preprocessing & Segmentasi ROI
-(Resize → Denoising → HSV Thresholding → Morfologi → Bounding Box Crop)
-    │
-    ▼
-Ekstraksi Fitur Lokal
-(SIFT / SURF, dibatasi pada area mask daging)
-    │
-    ├── Descriptor lokal (128-dim SIFT / 64-dim SURF)
-    └── Momen HSV (Mean, Std, Skewness per channel H/S/V → 9-dim)
-    │
-    ▼
-Bags of Visual Words (BoVW)
-(MiniBatchKMeans codebook → Histogram Hellinger → Fusi HSV)
-    │
-    ▼
-Reduksi Dimensi (PCA)
-    │
-    ▼
-Clustering Unsupervised
-(K-Means / GMM, k=2)
-    │
-    ▼
-Evaluasi & Komparasi
-(Metrik internal + eksternal opsional + visualisasi PCA/t-SNE)
-```
-
-### Keputusan Desain Kunci
-
-#### Segmentasi ROI Agnostik Domain
-
-Segmentasi menggunakan **Strict HSV Thresholding** pada rentang pigmen mioglobin (H: 0–30 dan 160–180, S > 30, V > 25), diikuti **Margin Annihilation** (menghapus 12% tepi citra untuk mengeliminasi sisa label/stiker), lalu morfologi ellips (close + open) untuk menutup porositas tanpa mendistorsi batas. Pendekatan ini bekerja untuk kedua domain (hitam dan biru) tanpa aturan warna yang berbeda per domain.
-
-#### Root-BoVW (Transformasi Hellinger)
-
-Histogram BoVW dinormalisasi menggunakan **transformasi Hellinger** (√(histogram/total)) bukan L2 biasa. Ini menghasilkan vektor dengan norma L2 = 1 dan mengurangi sensitivitas terhadap frekuensi kata visual yang sangat dominan—ekuivalen dengan menggunakan kernel Hellinger pada SVM, namun bekerja langsung di ruang Euclidean sehingga K-Means dan GMM dapat diterapkan secara efektif.
-
-#### Fusi Warna HSV yang Terkalibrasi
-
-Momen warna HSV (mean, std, skewness untuk channel H, S, dan V = 9 dimensi) difusikan ke histogram BoVW setelah dua tahap normalisasi:
-1. **MinMaxScaler** (fit di seluruh dataset, bukan per citra)
-2. **L2-normalize per baris** agar norma-L2 = 1, setara dengan blok tekstur Hellinger
-
-Dengan demikian, parameter `HSV_FUSION_WEIGHT` benar-benar merepresentasikan "bobot proporsi" yang terkendali: nilai 3.0 berarti kontribusi warna diberi bobot 3× lipat kontribusi tekstur.
-
-#### Perbandingan Algoritma yang Adil (Ruang Fitur Seragam)
-
-Semua algoritma clustering (K-Means dan GMM) dijalankan **di ruang fitur yang sama setelah PCA** (bukan K-Means di data mentah sementara GMM di PCA). Ini memastikan perbandingan murni pada level algoritma, bukan perbandingan ruang fitur yang tercampur.
-
-#### Uji Stabilitas Klaster
-
-Untuk menghindari *metric-chasing* (melaporkan Silhouette dari satu kali fit yang berpotensi terlalu optimis), pipeline menjalankan **10 kali subsample 80% data** dan melaporkan Silhouette mean ± std serta ARI vs klaster data penuh. ARI mendekati 1 berarti klaster stabil terhadap perturbasi subsampling.
-
----
-
-## 5. Arsitektur Pipeline
-
-Pipeline terdiri dari 8 tahap yang dapat dijalankan secara terpisah (dengan cache pickle antar tahap) atau sekaligus:
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    run_pipeline.py                          │
-│                                                             │
-│  step_preprocess  →  step_extract  →  step_bovw             │
-│       │                  │               │                  │
-│  manifest.pkl      descriptors_*.pkl  histograms_*.pkl      │
-│  masks/*.npz       timing_*.pkl       codebooks_*.pkl       │
-│  processed/*.npz   hsv_*.pkl                                │
-│                                                             │
-│  step_cluster  →  step_evaluate  →  step_export             │
-│       │                │               │                    │
-│  cluster_labels.pkl  figures/       Laporan_Prediksi.csv    │
-│  cluster_metrics.csv tables/                                │
-│                                                             │
-│  step_tune  →  step_build_production_model                  │
-│       │                │                                    │
-│  tuning_results.csv  meat_grading_model.joblib              │
-│                                                             │
-│  step_batch_experiment                                      │
-│       │                                                     │
-│  archives/  (14 skenario + Master_Log.csv)                  │
-└─────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 6. Tahapan Pipeline (Detail Teknis)
-
-### Tahap 1 — Preprocessing & Segmentasi ROI (`src/preprocessing.py`, `src/segmentation.py`)
-
-**Alur per citra:**
-1. **Resize** mempertahankan aspek rasio, sisi terpanjang menjadi 800px (`RESIZE_MAX_SIDE`).
-2. **Denoising** menggunakan `fastNlMeansDenoisingColored` (opsional, diaktifkan jika `DENOISE_H` bukan `None`).
-3. **Segmentasi ROI** — Strict HSV Thresholding pada rentang mioglobin + Margin Annihilation 12% + morfologi ellips 11×11 + pemilihan kontur terbaik berdasarkan skor `area / (dist_dari_pusat + 1)`.
-4. **QA Visual** — menyimpan gambar berdampingan (asli + kontur merah | daging tersegmentasi di atas latar putih) ke `outputs/visualized_segments/`.
-5. **Bounding Box Crop** — memotong citra ke bounding box foreground dengan padding 1% agar detektor tepi SURF tidak terpotong.
-6. **Konversi** ke grayscale (untuk SIFT/SURF) dan HSV (untuk momen warna).
-
-**Output:** `outputs/interim/processed/*.npz` (gray, hsv, mask per citra), `manifest.pkl`.
-
-### Tahap 2 — Ekstraksi Fitur Lokal (`src/feature_extraction.py`)
-
-- **SIFT**: `cv2.xfeatures2d.SIFT_create`, descriptor 128-dimensi.
-- **SURF**: `cv2.xfeatures2d.SURF_create`, Hessian threshold = 500 (hasil tuning), descriptor 64-dimensi.
-- Keypoint dibatasi **hanya pada area mask** menggunakan parameter `mask` di `detectAndCompute`.
-- Descriptor di-cap maksimum 800 per citra (subsample acak) untuk menjaga efisiensi codebook.
-- **Momen HSV**: Mean, Std, dan Skewness untuk channel H, S, dan V → vektor 9-dimensi per citra.
-- Waktu ekstraksi per citra direkam untuk perbandingan efisiensi komputasi.
-
-**Output:** `descriptors_sift.pkl`, `descriptors_surf.pkl`, `hsv_sift.pkl`, `hsv_surf.pkl`, `timing_*.pkl`.
-
-### Tahap 3 — Bags of Visual Words (`src/bovw.py`)
-
-- **Sampling descriptor**: Maksimum 200.000 descriptor dari seluruh dataset digabung untuk melatih codebook (menghindari memory error untuk dataset besar).
-- **Pembangunan codebook**: `MiniBatchKMeans` dengan batch size 2000, `n_init=10`, `max_iter=200`, untuk ukuran k ∈ {50, 100, 200}.
-- **Komputasi histogram**: Setiap citra dikuantisasi ke dalam histogram k-bin menggunakan `codebook.predict(descriptors)`, lalu dinormalisasi dengan transformasi Hellinger.
-- **Fusi warna HSV**: Jika `USE_COLOR_FUSION=True`, vektor HSV dinormalisasi (MinMax → L2-norm) lalu dikali `HSV_FUSION_WEIGHT` dan di-concatenate ke histogram BoVW.
-
-**Output:** `codebooks_*.pkl` (dict k → MiniBatchKMeans), `histograms_*.pkl` (dict k → matrix N×(k+9)).
-
-### Tahap 4 — Clustering Unsupervised (`src/clustering.py`)
-
-**4a. Sensitivitas Ukuran Codebook** (ruang fitur mentah, K-Means saja):
-- Menguji pengaruh granularitas codebook (k=50, 100, 200) terhadap kualitas klaster.
-- Ditandai `feature_space="raw"` agar tidak tercampur dengan analisis perbandingan algoritma.
-
-**4b. Perbandingan Algoritma Clustering** (ruang fitur PCA, codebook k=200):
-- PCA diaplikasikan ke data default codebook, mempertahankan hingga 30 komponen utama.
-- K-Means (`n_init=20`) dan GMM (`covariance_type="full"`, `n_init=10`) dibandingkan di ruang PCA yang sama.
-- Label hasil clustering disimpan untuk visualisasi dan ekspor.
-
-**4c. Uji Stabilitas Klaster**:
-- 10 iterasi subsample 80%, masing-masing dijalankan K-Means independen.
-- Melaporkan Silhouette mean ± std dan ARI vs klaster data penuh.
 
-**Output:** `cluster_labels.pkl`, `cluster_metrics_all.csv`, `cluster_stability.csv`.
-
-### Tahap 5 — Evaluasi & Visualisasi (`src/evaluation.py`, `src/visualization.py`)
-
-**Metrik Validasi Internal** (tanpa label):
-| Metrik | Interpretasi | Arah Optimal |
-|--------|-------------|--------------|
-| **Silhouette Score** | Kerapatan intra-klaster vs. separasi antar-klaster, rentang [-1, 1] | ↑ Lebih tinggi lebih baik |
-| **Davies-Bouldin Index** | Rata-rata similaritas tiap klaster dengan klaster paling mirip | ↓ Lebih rendah lebih baik |
-| **Calinski-Harabasz Index** | Rasio dispersi antar-klaster / intra-klaster | ↑ Lebih tinggi lebih baik |
-
-**Metrik Validasi Eksternal** (bila `labels.csv` tersedia):
-| Metrik | Interpretasi |
-|--------|-------------|
-| **ARI** (Adjusted Rand Index) | Kesesuaian klaster dengan ground truth, dikoreksi untuk chance, rentang [-1, 1] |
-| **NMI** (Normalized Mutual Info) | Informasi mutual antara klaster dan ground truth, rentang [0, 1] |
-| **Purity** | Proporsi anggota klaster yang berasal dari kelas mayoritas |
-
-**Visualisasi yang dihasilkan:**
-- Proyeksi PCA 2D dan t-SNE 2D dari klaster terbaik.
-- Bar chart Silhouette, Davies-Bouldin, dan Calinski-Harabasz per kombinasi (fitur × algoritma).
-- Ablation Study: dampak PCA terhadap Silhouette Score (raw vs. PCA space).
-- Boxplot efisiensi komputasi (waktu ekstraksi dan jumlah keypoint).
-- Radar Chart multidimensional SIFT vs. SURF (performa + efisiensi).
-- Visual proof keypoint SIFT vs. SURF pada citra sampel.
-- Stacked bar chart distribusi klaster per hari (temporal degradation).
-
-### Tahap 6 — Hyperparameter Tuning (`step_tune`)
-
-Grid search terhadap:
-- **HSV Fusion Weight**: [2.5, 2.8, 3.0, 3.2, 3.5]
-- **PCA Components**: [15, 20, 25, 30, 35]
-- **GMM Covariance Type**: ['full', 'tied', 'diag']
-
-Total 75 kombinasi diuji, diurutkan berdasarkan Silhouette Score tertinggi lalu Davies-Bouldin terendah. Konfigurasi terbaik kemudian diuji stabilitasnya (10× subsample) dan hasilnya **dilaporkan sebagai mean ± std**, bukan nilai mentah dari pencarian, untuk menghindari bias optimistis.
-
-> **Peringatan metodologis**: Silhouette Score hasil grid search tidak boleh dilaporkan langsung sebagai bukti separabilitas karena merupakan target optimisasi itu sendiri. Selalu gunakan angka stabilitas (mean ± std dari subsample berulang).
-
-### Tahap 7 — Ekspor Prediksi (`step_export`)
-
-Menghasilkan tabel prediksi per citra dari model terbaik (SIFT + K-Means) dalam format CSV yang siap dibuka di Excel, mencakup: nama file, domain asal, hari ke-, jenis potongan, ID klaster, dan asumsi kondisi (Klaster A / Klaster B).
-
-### Tahap 8 — Pembuatan Model Produksi (`step_build_production_model`)
-
-Merakit dan menyimpan seluruh komponen pipeline ke dalam satu file `.joblib`:
-
-```python
-model_package = {
-    "codebook":   MiniBatchKMeans,   # Kamus visual BoVW
-    "scaler":     MinMaxScaler,      # Normalisasi HSV
-    "pca":        PCA,               # Reduksi dimensi
-    "gmm":        GaussianMixture,   # Classifier akhir
-    "hsv_weight": float,             # Bobot fusi warna
-    "metadata":   dict               # Konfigurasi eksperimen
-}
-```
-
-Model ini dapat dimuat dan digunakan untuk klasifikasi citra daging baru tanpa menjalankan ulang seluruh pipeline.
-
----
-
-## 7. Hasil dan Evaluasi
-
-### Komparasi SIFT vs. SURF
-
-| Aspek | SIFT | SURF |
-|-------|------|------|
-| **Dimensi Descriptor** | 128-dim | 64-dim |
-| **Kecepatan Ekstraksi** | Lebih lambat | ~2–3× lebih cepat |
-| **Jumlah Keypoint** | Lebih banyak (threshold berbasis DoG) | Bergantung Hessian threshold (500 optimal) |
-| **Separabilitas Klaster** | Silhouette umumnya lebih tinggi di ruang PCA | Silhouette kompetitif setelah fusi HSV |
-| **Keunggulan** | Akurasi separasi tekstur | Efisiensi komputasi |
-
-### Dampak Komponen Pipeline (Ablation Study)
-
-| Komponen | Dampak pada Silhouette |
-|----------|----------------------|
-| Raw BoVW tanpa PCA | Baseline (rendah akibat *curse of dimensionality*) |
-| + PCA (30 komponen) | Peningkatan signifikan |
-| + Fusi HSV (weight=3.0) | Peningkatan tambahan — warna permukaan merupakan indikator kesegaran yang kuat |
-| + Normalisasi L2 HSV | Memastikan bobot HSV terkendali dan dapat diinterpretasi |
-
-### Uji Stabilitas (Laporan yang Jujur)
-
-Kualitas klaster dilaporkan sebagai:
-- **Silhouette mean ± std** dari 10× subsample 80%
-- **ARI vs klaster data penuh** — nilai mendekati 1 menunjukkan struktur klaster yang stabil, bukan artefak dari satu kali fitting
-
-### Sensitivitas Ukuran Codebook
-
-Ukuran codebook k ∈ {50, 100, 200} diuji. Secara umum, k=200 memberikan representasi yang lebih granular dan Silhouette Score yang lebih baik. Perbedaan antara k=100 dan k=200 biasanya tidak dramatis, menunjukkan saturasi representasi.
-
----
-
-## 8. Struktur Output
-
-```
-outputs/
-├── interim/                       # Cache pickle antar tahap (dapat dihapus & diulang)
-│   ├── manifest.pkl               # Metadata seluruh citra (hari/domain/kode/label)
-│   ├── processed/                 # *.npz per citra (gray, hsv, mask)
-│   ├── masks/                     # Mask ROI terpisah (*.npz)
-│   ├── descriptors_sift.pkl
-│   ├── descriptors_surf.pkl
-│   ├── hsv_sift.pkl
-│   ├── hsv_surf.pkl
-│   ├── codebooks_sift.pkl
-│   ├── codebooks_surf.pkl
-│   ├── histograms_sift.pkl
-│   ├── histograms_surf.pkl
-│   ├── timing_sift.pkl
-│   ├── timing_surf.pkl
-│   └── cluster_labels.pkl
-├── figures/                       # Seluruh grafik (PCA, t-SNE, radar, boxplot, dsb.)
-├── tables/                        # Seluruh tabel hasil (CSV)
-│   ├── manifest_summary.csv
-│   ├── efficiency_raw.csv
-│   ├── efficiency_summary.csv
-│   ├── cluster_metrics_all.csv
-│   ├── cluster_stability.csv
-│   ├── tuning_results_deep_search.csv
-│   ├── Laporan_Prediksi_SIFT_KMEANS.csv
-│   └── final_summary.json
-├── visualized_segments/           # Hasil QA segmentasi (asli | tersegmentasi)
-├── meat_grading_model.joblib      # Model produksi siap pakai
-└── logs/
-    └── pipeline.log
-```
-
-```
-archives/
-└── DATA-BIMA_EXP-YYYYMMDD-XX/    # Satu folder per skenario eksperimen batch
-    ├── code_snapshot/             # Snapshot kode saat eksperimen berjalan
-    └── results/
-        └── evaluation_metrics.json
-Master_Log_DATA-BIMA_YYYYMMDD_HHMMSS.csv  # Rekapitulasi 14 skenario
-```
-
----
-
-## 9. Setup dan Instalasi
-
-### Prasyarat
+# Pipeline Beef Research BIMA: Deteksi Mutu Kesegaran Daging Sapi Multidomain
 
-- Python 3.7 (wajib — OpenCV 3.4.2.16 dengan SIFT/SURF tersedia hanya di Python 3.7)
-- [uv](https://github.com/astral-sh/uv) (package manager)
+Pipeline **unsupervised** (SIFT/SURF -> Bags of Visual Words -> Clustering) untuk
+dataset citra daging sapi multidomain (RPH & UMKM), seluruh proses klasifikasi mutu dilakukan tanpa pelatihan supervised
+(tanpa SVM/KNN), murni berbasis unsupervised learning.
 
-### Instalasi
+## 1. Setup Environment (uv, Python 3.7, OpenCV 3.4.2.16)
 
 ```bash
-# Install Python 3.7 lewat uv (jika belum ada di mesin)
+# Install python 3.7 lewat uv (jika belum ada di mesin)
 uv python install 3.7
 
 # Buat & sync environment sesuai pyproject.toml
 uv sync
 
-# Verifikasi SIFT & SURF tersedia (harus mencetak True True)
+# (opsional) verifikasi SIFT & SURF tersedia (harus tercetak True True)
 uv run python -c "import cv2; s=cv2.xfeatures2d.SIFT_create(); f=cv2.xfeatures2d.SURF_create(); print(True, True)"
 ```
 
-> **Catatan:** Jika `uv python install 3.7` gagal karena python-build-standalone tidak lagi menyediakan build 3.7 di platform Anda, gunakan pyenv/conda untuk menyediakan interpreter 3.7, lalu arahkan uv ke sana:
-> ```bash
-> uv venv --python /path/to/python3.7
-> uv sync
-> ```
-
-### Dependensi Utama
-
-| Paket | Versi | Fungsi |
-|-------|-------|--------|
-| `opencv-contrib-python` | 3.4.2.16 | SIFT, SURF (`xfeatures2d`) |
-| `scikit-learn` | ≥1.0.2 | KMeans, GMM, PCA, metrik |
-| `numpy` | ≥1.21.6 | Operasi matriks |
-| `pandas` | ≥1.1.5 | Tabel hasil |
-| `matplotlib` | ≥3.5.3 | Visualisasi |
-| `seaborn` | ≥0.12.2 | Visualisasi statistik |
-
----
-
-## 10. Cara Menjalankan Pipeline
-
-### Persiapan Data
+> Catatan: jika `uv python install 3.7` gagal karena python-build-standalone tidak
+> lagi menyediakan build 3.7 di platform Anda, gunakan pyenv/conda untuk
+> menyediakan interpreter 3.7, lalu arahkan uv ke sana dengan
+> `uv venv --python /path/to/python3.7` sebelum `uv sync`.
 
-1. Susun dataset sesuai konvensi penamaan (`DAY-1_[DOMAIN]_[KODE]_[NOMOR].JPG`).
-2. Letakkan di `data/dataset_root/` atau ubah `RAW_DATA_DIR` di `config.py`.
-3. (Opsional) Siapkan `data/labels.csv` dengan kolom `filename,label` untuk validasi eksternal.
+## 2. Siapkan Data
 
-### Konfigurasi
+Susun dataset mentah sesuai struktur pada README dataset (folder `DAY-1/`, `DAY-2/`,
+penamaan `[HARI]_[DOMAIN]_[KODE]_[NOMOR].JPG`). Atur path pada `config.py`
+(`RAW_DATA_DIR`).
 
-Edit `config.py` sesuai kebutuhan:
+Jika Anda sudah punya sebagian label ground truth (dari pelabelan awal tim
+peneliti / Peternakan), siapkan file CSV opsional `labels.csv` dengan kolom
+`filename,label` (label: `segar` / `tidak_segar`) — dipakai HANYA untuk
+validasi eksternal klaster (ARI/NMI/Purity), bukan untuk training.
 
-```python
-DATASET_DOMAIN = "DATA-BIMA"       # Nama domain untuk penamaan arsip
-RAW_DATA_DIR   = "data/dataset_root"
-USE_COLOR_FUSION      = True        # Aktifkan fusi momen HSV
-HSV_FUSION_WEIGHT     = 3.0        # Bobot kontribusi warna vs. tekstur
-DEFAULT_CODEBOOK_SIZE = 200        # Ukuran codebook utama
-SURF_HESSIAN_THRESHOLD = 500       # Threshold detektor SURF
-```
+## 3. Menjalankan Pipeline
 
-### Menjalankan Tahap per Tahap
+Pipeline terbagi menjadi 5 tahap, masing-masing bisa dijalankan terpisah
+(hasil antara di-cache di `outputs/interim/`) atau sekaligus dengan `all`.
 
 ```bash
 uv run python run_pipeline.py --step preprocess
@@ -434,49 +60,54 @@ uv run python run_pipeline.py --step extract
 uv run python run_pipeline.py --step bovw
 uv run python run_pipeline.py --step cluster
 uv run python run_pipeline.py --step evaluate
-uv run python run_pipeline.py --step export
-uv run python run_pipeline.py --step build_model
-```
-
-### Menjalankan Semua Tahap Sekaligus
 
-```bash
+# atau jalankan semua tahap sekaligus
 uv run python run_pipeline.py --step all
 ```
 
-> Perintah `--step all` menjalankan semua tahap kecuali `tune` (untuk menghindari grid search yang lama secara tidak sengaja).
+## 4. Struktur Output
 
-### Tahap Opsional
+```
+outputs/
+├── interim/                     # cache pickle antar tahap (boleh dihapus & rerun)
+│   ├── manifest.pkl             # metadata semua citra (hari/domain/kode/label)
+│   ├── masks/                   # mask ROI hasil segmentasi (npz per citra)
+│   ├── descriptors_sift.pkl
+│   ├── descriptors_surf.pkl
+│   ├── codebook_sift.pkl
+│   ├── codebook_surf.pkl
+│   ├── histograms_sift.npy
+│   └── histograms_surf.npy
+├── figures/                     # semua grafik (PCA/TSNE, perbandingan metrik, dsb.)
+├── tables/                      # semua tabel hasil (CSV) siap ditempel ke laporan
+└── logs/
+    └── pipeline.log
+```
 
-```bash
-# Grid search hyperparameter (lama, ~75 kombinasi × step_bovw)
-uv run python run_pipeline.py --step tune
+## 5. Tahapan Pipeline (ringkas)
 
-# 14 skenario eksperimen batch dengan arsip otomatis
-uv run python run_pipeline.py --step batch_log
-```
+1. **Preprocessing & Segmentasi ROI** (`src/preprocessing.py`, `src/segmentation.py`)
+   Resize, denoising, konversi HSV, dan **segmentasi latar belakang berbasis
+   flood-fill dari tepi citra** (bekerja untuk backdrop hitam Day-1 maupun
+   karton biru muda Day-2 tanpa perlu aturan warna berbeda per hari) sehingga
+   fitur yang diekstraksi terfokus pada permukaan daging, bukan latar
+   belakang yang kebetulan berkorelasi dengan hari/tahap kesegaran.
 
----
+2. **Ekstraksi Fitur Lokal** (`src/feature_extraction.py`)
+   SIFT dan SURF dijalankan terpisah, keypoint dibatasi hanya pada area mask
+   ROI daging (parameter `mask` di `detectAndCompute`).
 
-## 11. Struktur Proyek
+3. **Bags of Visual Words** (`src/bovw.py`)
+   Codebook dibangun dengan `MiniBatchKMeans` (beberapa ukuran cluster diuji:
+   50/100/150/200 sesuai indikator capaian proposal), setiap citra direpresentasikan
+   sebagai histogram fitur ternormalisasi.
 
-```
-beefresearch-bima/
-├── config.py                  # Konfigurasi sentral pipeline
-├── run_pipeline.py            # Orkestrator utama (semua step ada di sini)
-├── pyproject.toml             # Dependensi & metadata proyek
-├── data/
-│   ├── dataset_root/          # Dataset mentah (diatur di config.py)
-│   └── labels.csv             # Ground truth opsional
-├── src/
-│   ├── preprocessing.py       # Resize, denoising, konversi, crop
-│   ├── segmentation.py        # HSV thresholding & morfologi ROI
-│   ├── feature_extraction.py  # SIFT/SURF + momen HSV
-│   ├── bovw.py                # Codebook & histogram Hellinger
-│   ├── clustering.py          # K-Means, GMM, metrik validasi
-│   ├── evaluation.py          # Tabel efisiensi & komparasi fitur
-│   ├── visualization.py       # Semua fungsi plot
-│   └── utils.py               # Logger, I/O pickle/JSON, utils umum
-├── outputs/                   # Semua hasil pipeline (di-generate otomatis)
-└── archives/                  # Arsip eksperimen batch
-```
+4. **Clustering Unsupervised** (`src/clustering.py`)
+   K-Means (k=2) dan Gaussian Mixture dibandingkan
+   untuk membagi citra ke 2 klaster akhir (Segar/Tidak Segar).
+
+5. **Evaluasi & Komparasi SIFT vs SURF** (`src/evaluation.py`, `src/visualization.py`)
+   Validasi internal (Silhouette, Davies-Bouldin, Calinski-Harabasz), validasi
+   eksternal opsional (ARI/NMI/Purity bila ada `labels.csv`), efisiensi
+   komputasi (waktu ekstraksi & jumlah keypoint rata-rata), serta visualisasi
+   PCA/t-SNE dari histogram BoVW.

config.py

@@ -1,14 +1,15 @@
 """
-Konfigurasi pipeline utama.
+Konfigurasi terpusat pipeline computer vision deteksi mutu kesegaran daging sapi.
+Ubah nilai di sini sesuai kebutuhan; jangan ubah logika di dalam modul src/.
 """
 import os
 
+# ---------------------------------------------------------------------------
 # PATH DIREKTORI
+# ---------------------------------------------------------------------------
 PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
 
-DATASET_DOMAIN = "DATA-BIMA"  # Ubah sesuai domain dataset yang digunakan
-
-RAW_DATA_DIR = os.path.join(PROJECT_ROOT, "data", "dataset_root") #Atur juga data sumber nya
+RAW_DATA_DIR = os.path.join(PROJECT_ROOT, "data", "dataset_root")
 LABELS_CSV = os.path.join(PROJECT_ROOT, "data", "labels.csv")
 
 OUTPUT_DIR = os.path.join(PROJECT_ROOT, "outputs")
@@ -25,7 +26,9 @@ SEGMENTED_VIEW_DIR = os.path.join(OUTPUT_DIR, "visualized_segments")
 IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".JPG", ".JPEG")
 FILENAME_REGEX = r"^(DAY-\d+)_([A-Za-z]+)_([A-Za-z]+)_(\d+)\.\w+$"
 
+# ---------------------------------------------------------------------------
 # PREPROCESSING
+# ---------------------------------------------------------------------------
 RESIZE_MAX_SIDE = 800
 
 DENOISE_H = None      
@@ -37,7 +40,9 @@ FLOODFILL_TOLERANCE = 12
 FLOODFILL_MORPH_KERNEL = 7   
 MIN_FOREGROUND_AREA_RATIO = 0.05  
 
+# ---------------------------------------------------------------------------
 # EKSTRAKSI FITUR & FUSI
+# ---------------------------------------------------------------------------
 SIFT_N_FEATURES = 0          
 SURF_HESSIAN_THRESHOLD = 500  # Nilai default optimal dari hasil tuning
 MAX_DESCRIPTORS_PER_IMAGE = 800
@@ -46,20 +51,29 @@ MAX_DESCRIPTORS_PER_IMAGE = 800
 USE_COLOR_FUSION = True
 HSV_FUSION_WEIGHT = 3.0       # Nilai default optimal dari hasil tuning
 
+# ---------------------------------------------------------------------------
 # BAGS OF VISUAL WORDS
-CODEBOOK_SIZES = [50, 100, 200]
+# ---------------------------------------------------------------------------
+CODEBOOK_SIZES = [200]
 DEFAULT_CODEBOOK_SIZE = 200   # Nilai default optimal dari hasil tuning
 MAX_DESCRIPTORS_FOR_CODEBOOK = 200_000
 MINIBATCH_KMEANS_BATCH_SIZE = 2000
 
+# ---------------------------------------------------------------------------
 # CLUSTERING (K-Means / PCA)
+# ---------------------------------------------------------------------------
 N_CLUSTERS_FINAL = 2  
 RANDOM_STATE = 42
 
+# ---------------------------------------------------------------------------
 # LOGGING
+# ---------------------------------------------------------------------------
 LOG_LEVEL = "INFO"
 
-# HYPERPARAMETER TUNING OTOMATIS (NATIVE) diuji secara otomatis saat menjalankan --step tune
+# ---------------------------------------------------------------------------
+# HYPERPARAMETER TUNING OTOMATIS (NATIVE)
+# ---------------------------------------------------------------------------
+# Rentang angka yang akan diuji secara otomatis saat menjalankan --step tune
 TUNING_HESSIAN_THRESHOLDS = [400, 500, 600]
 TUNING_HSV_WEIGHTS = [2.0, 2.5, 3.0]
 TUNING_CODEBOOK_SIZES = [50, 100, 200]

outputs/tables/Laporan_Prediksi_SIFT_KMEANS.csv

@@ -1037,7 +1037,7 @@ DAY-1_UMKM_SKL_093.JPG,UMKM,DAY-1,SKL,0,Klaster A
 DAY-1_UMKM_SKL_094.JPG,UMKM,DAY-1,SKL,0,Klaster A
 DAY-1_UMKM_SKL_095.JPG,UMKM,DAY-1,SKL,0,Klaster A
 DAY-1_UMKM_SKL_096.JPG,UMKM,DAY-1,SKL,0,Klaster A
-DAY-1_UMKM_SKL_097.JPG,UMKM,DAY-1,SKL,0,Klaster A
+DAY-1_UMKM_SKL_097.JPG,UMKM,DAY-1,SKL,1,Klaster B
 DAY-1_UMKM_SKL_098.JPG,UMKM,DAY-1,SKL,0,Klaster A
 DAY-1_UMKM_SKL_099.JPG,UMKM,DAY-1,SKL,0,Klaster A
 DAY-1_UMKM_SKL_100.JPG,UMKM,DAY-1,SKL,0,Klaster A
@@ -1821,7 +1821,7 @@ DAY-2_UMKM_PDS_060.JPG,UMKM,DAY-2,PDS,0,Klaster A
 DAY-2_UMKM_PDS_061.JPG,UMKM,DAY-2,PDS,1,Klaster B
 DAY-2_UMKM_PDS_062.JPG,UMKM,DAY-2,PDS,0,Klaster A
 DAY-2_UMKM_PDS_063.JPG,UMKM,DAY-2,PDS,1,Klaster B
-DAY-2_UMKM_PDS_064.JPG,UMKM,DAY-2,PDS,0,Klaster A
+DAY-2_UMKM_PDS_064.JPG,UMKM,DAY-2,PDS,1,Klaster B
 DAY-2_UMKM_PDS_065.JPG,UMKM,DAY-2,PDS,1,Klaster B
 DAY-2_UMKM_PDS_066.JPG,UMKM,DAY-2,PDS,0,Klaster A
 DAY-2_UMKM_PDS_067.JPG,UMKM,DAY-2,PDS,1,Klaster B
@@ -2017,7 +2017,7 @@ DAY-2_UMKM_PNT_116.JPG,UMKM,DAY-2,PNT,1,Klaster B
 DAY-2_UMKM_PNT_117.JPG,UMKM,DAY-2,PNT,1,Klaster B
 DAY-2_UMKM_PNT_118.JPG,UMKM,DAY-2,PNT,0,Klaster A
 DAY-2_UMKM_PNT_119.JPG,UMKM,DAY-2,PNT,1,Klaster B
-DAY-2_UMKM_PNT_120.JPG,UMKM,DAY-2,PNT,1,Klaster B
+DAY-2_UMKM_PNT_120.JPG,UMKM,DAY-2,PNT,0,Klaster A
 DAY-2_UMKM_PNT_121.JPG,UMKM,DAY-2,PNT,1,Klaster B
 DAY-2_UMKM_PNT_122.JPG,UMKM,DAY-2,PNT,0,Klaster A
 DAY-2_UMKM_PNT_123.JPG,UMKM,DAY-2,PNT,1,Klaster B
@@ -2247,7 +2247,7 @@ DAY-2_UMKM_SKL_066.JPG,UMKM,DAY-2,SKL,1,Klaster B
 DAY-2_UMKM_SKL_067.JPG,UMKM,DAY-2,SKL,1,Klaster B
 DAY-2_UMKM_SKL_068.JPG,UMKM,DAY-2,SKL,1,Klaster B
 DAY-2_UMKM_SKL_069.JPG,UMKM,DAY-2,SKL,1,Klaster B
-DAY-2_UMKM_SKL_070.JPG,UMKM,DAY-2,SKL,1,Klaster B
+DAY-2_UMKM_SKL_070.JPG,UMKM,DAY-2,SKL,0,Klaster A
 DAY-2_UMKM_SKL_071.JPG,UMKM,DAY-2,SKL,1,Klaster B
 DAY-2_UMKM_SKL_072.JPG,UMKM,DAY-2,SKL,0,Klaster A
 DAY-2_UMKM_SKL_073.JPG,UMKM,DAY-2,SKL,1,Klaster B
@@ -2452,6 +2452,6 @@ DAY-2_UMKM_SMC_134.JPG,UMKM,DAY-2,SMC,1,Klaster B
 DAY-2_UMKM_SMC_135.JPG,UMKM,DAY-2,SMC,1,Klaster B
 DAY-2_UMKM_SMC_136.JPG,UMKM,DAY-2,SMC,1,Klaster B
 DAY-2_UMKM_SMC_137.JPG,UMKM,DAY-2,SMC,1,Klaster B
-DAY-2_UMKM_SMC_138.JPG,UMKM,DAY-2,SMC,0,Klaster A
+DAY-2_UMKM_SMC_138.JPG,UMKM,DAY-2,SMC,1,Klaster B
 DAY-2_UMKM_SMC_139.JPG,UMKM,DAY-2,SMC,1,Klaster B
 DAY-2_UMKM_SMC_140.JPG,UMKM,DAY-2,SMC,1,Klaster B

outputs/tables/cluster_metrics_all.csv

@@ -1,11 +1,7 @@
 silhouette_score,davies_bouldin_score,calinski_harabasz_score,feature,method,codebook_size,feature_space
-0.3273361027240753,1.3393923655280175,1275.8714948781799,SIFT,kmeans,50,raw
-0.30371972918510437,1.4179403992073865,1155.3381185938072,SIFT,kmeans,100,raw
-0.2761237323284149,1.519173743772955,1020.7523554216446,SIFT,kmeans,200,raw
-0.3402327299118042,1.2915196253700496,1361.5232738374064,SIFT,kmeans,200,pca
-0.3259091377258301,1.3138622678954146,1269.7095677771042,SIFT,gmm,200,pca
-0.29011809825897217,1.4702439943859047,1079.6358132925886,SURF,kmeans,50,raw
-0.266449511051178,1.5571960138509717,972.1834943598637,SURF,kmeans,100,raw
-0.24493154883384705,1.646778363458069,872.3269812624878,SURF,kmeans,200,raw
-0.3165423274040222,1.37358422721392,1211.4946023395398,SURF,kmeans,200,pca
-0.2951558530330658,1.4791946371612006,1047.482893527336,SURF,gmm,200,pca
+0.2769351303577423,1.5145757851244719,1026.650511427009,SIFT,kmeans,200,raw
+0.3407447636127472,1.2889466499830886,1367.2222491156222,SIFT,kmeans,200,pca
+0.3261227607727051,1.312133462623333,1273.1930209170655,SIFT,gmm,200,pca
+0.2449309080839157,1.6467811072725456,872.3243306465555,SURF,kmeans,200,raw
+0.316542387008667,1.373584476226374,1211.4935094315822,SURF,kmeans,200,pca
+0.29515576362609863,1.4791957406926373,1047.4810568345908,SURF,gmm,200,pca

outputs/tables/cluster_stability.csv

@@ -1,3 +1,3 @@
 feature,silhouette_mean,silhouette_std,ari_vs_full_mean,ari_vs_full_std,n_trials
-SIFT,0.3397314935922623,0.0024768677542831774,0.99006899750333,0.010907261921736588,10
-SURF,0.31878958344459535,0.006372579916181219,0.9385743852568675,0.15141701917397363,10
+SIFT,0.3403042733669281,0.002450848583654707,0.9896803679035703,0.013573475599350439,10
+SURF,0.3187896698713303,0.006372772695515273,0.9385743852568675,0.15141701917397363,10

outputs/tables/efficiency_summary.csv

@@ -1,3 +1,3 @@
 method,mean_elapsed_sec,median_elapsed_sec,std_elapsed_sec,mean_n_keypoints,median_n_keypoints,std_n_keypoints,n_images
-SIFT,0.0036894152202715568,0.0035862605000147596,0.0016130202402580723,128.5969055374593,90.0,122.42829721038306,2456
-SURF,0.00276825313436675,0.0025465785001870245,0.0013585822474636924,56.10260586319218,37.0,60.453230961928284,2456
+SIFT,0.0044723340390882705,0.003919449999983726,0.0023356877672534916,128.60138436482086,90.0,122.43336731418978,2456
+SURF,0.0022748484934848137,0.002071800000010171,0.004352626171909472,56.10260586319218,37.0,60.453230961928284,2456

outputs/tables/final_summary.json

@@ -2,12 +2,12 @@
   "best_combination_by_silhouette": {
     "feature": "SIFT",
     "clustering_method": "kmeans",
-    "silhouette_score": 0.3402327299118042
+    "silhouette_score": 0.3407447636127472
   },
   "best_feature_overall_avg_silhouette": "SIFT",
   "avg_silhouette_per_feature": {
-    "SIFT": 0.33307093381881714,
-    "SURF": 0.305849090218544
+    "SIFT": 0.33343376219272614,
+    "SURF": 0.3058490753173828
   },
   "codebook_size_used_for_main_comparison": 200
 }

run_pipeline.py

@@ -3,7 +3,7 @@
 Orkestrator pipeline unsupervised computer vision untuk deteksi mutu
 kesegaran daging sapi multidomain (SIFT/SURF -> BoVW -> Clustering).
 
-Code pemakaian:
+Contoh pemakaian:
     uv run python run_pipeline.py --step preprocess
     uv run python run_pipeline.py --step extract
     uv run python run_pipeline.py --step bovw
@@ -14,10 +14,8 @@ Code pemakaian:
 """
 import argparse
 import os
-import shutil
 import time
 import json
-import datetime
 
 import numpy as np
 import pandas as pd
@@ -25,7 +23,6 @@ from tqdm import tqdm
 from sklearn.preprocessing import MinMaxScaler
 from sklearn.decomposition import PCA
 from sklearn.mixture import GaussianMixture
-from typing import Dict, Any
 import joblib
 
 import config
@@ -34,9 +31,11 @@ from src import bovw, clustering, evaluation, feature_extraction, preprocessing,
 logger = utils.get_logger("run_pipeline")
 
 
+# ---------------------------------------------------------------------------
 # TAHAP 1: PREPROCESSING & SEGMENTASI ROI
+# ---------------------------------------------------------------------------
 def step_preprocess():
-    logger.info("TAHAP 1 - PREPROCESSING & SEGMENTASI ROI")
+    logger.info("=== TAHAP 1: PREPROCESSING & SEGMENTASI ROI ===")
     utils.ensure_dirs()
 
     image_paths = utils.list_images(config.RAW_DATA_DIR, config.IMAGE_EXTENSIONS)
@@ -82,9 +81,11 @@ def step_preprocess():
     logger.info("Selesai preprocessing: %d sukses.", len(manifest))
 
 
+# ---------------------------------------------------------------------------
 # TAHAP 2: EKSTRAKSI FITUR LOKAL (SIFT & SURF)
+# ---------------------------------------------------------------------------
 def step_extract():
-    logger.info("TAHAP 2 - EKSTRAKSI FITUR LOKAL (SIFT & SURF)")
+    logger.info("=== TAHAP 2: EKSTRAKSI FITUR LOKAL (SIFT & SURF) ===")
     manifest = utils.load_pickle(os.path.join(config.INTERIM_DIR, "manifest.pkl"))
 
     for method in ("sift", "surf"):
@@ -118,9 +119,11 @@ def step_extract():
     evaluation.save_table(evaluation.summarize_efficiency(df_eff), "efficiency_summary.csv")
 
 
+# ---------------------------------------------------------------------------
 # TAHAP 3: BAGS OF VISUAL WORDS & EARLY FUSION
+# ---------------------------------------------------------------------------
 def step_bovw():
-    logger.info("TAHAP 3 - BAGS OF VISUAL WORDS & EARLY FUSION")
+    logger.info("=== TAHAP 3: BAGS OF VISUAL WORDS & EARLY FUSION ===")
     manifest = utils.load_pickle(os.path.join(config.INTERIM_DIR, "manifest.pkl"))
     filenames = [e["filename"] for e in manifest]
 
@@ -144,7 +147,7 @@ def step_bovw():
                     hsv_dict[f_name] = scaler.transform(hsv_dict[f_name].reshape(1, -1))[0]
 
                 # ----------------------------------------------------------
-                # MinMaxScaler saja TIDAK cukup menyamakan skala
+                # PERBAIKAN: MinMaxScaler saja TIDAK cukup menyamakan skala
                 # dengan blok tekstur. bovw_hist (Hellinger) punya norma-L2 = 1
                 # per baris (properti transformasi sqrt(L1-normalized)),
                 # sedangkan vektor HSV hasil MinMax bisa punya norma-L2
@@ -155,7 +158,7 @@ def step_bovw():
                 # yang dijalankan setelahnya (fitur bervarians besar otomatis
                 # mendominasi komponen utama).
                 #
-                # normalisasi setiap vektor HSV ke norma-L2 = 1 SETELAH
+                # Solusi: normalisasi setiap vektor HSV ke norma-L2 = 1 SETELAH
                 # MinMax, baru dikalikan HSV_FUSION_WEIGHT. Sekarang
                 # HSV_FUSION_WEIGHT=1.0 berarti "kontribusi warna setara
                 # dengan tekstur", weight=3.0 berarti "warna diberi bobot 3x
@@ -204,9 +207,11 @@ def step_bovw():
         utils.save_pickle(histograms, os.path.join(config.INTERIM_DIR, f"histograms_{method}.pkl"))
 
 
+# ---------------------------------------------------------------------------
 # TAHAP 4: CLUSTERING UNSUPERVISED DENGAN PCA
+# ---------------------------------------------------------------------------
 def step_cluster():
-    logger.info("TAHAP 4 - CLUSTERING UNSUPERVISED")
+    logger.info("=== TAHAP 4: CLUSTERING UNSUPERVISED ===")
     manifest = utils.load_pickle(os.path.join(config.INTERIM_DIR, "manifest.pkl"))
     true_labels = [e.get("label") for e in manifest]
     has_ground_truth = all(l is not None for l in true_labels) and len(true_labels) > 0
@@ -318,9 +323,12 @@ def step_cluster():
     evaluation.save_table(pd.DataFrame(stability_rows), "cluster_stability.csv")
 
 
+# ---------------------------------------------------------------------------
 # TAHAP 5: EVALUASI & KOMPARASI SIFT vs SURF
+# ---------------------------------------------------------------------------
 def step_evaluate():
-    logger.info("TAHAP 5 - EVALUASI & KOMPARASI SIFT vs SURF")
+    logger.info("=== TAHAP 5: EVALUASI & KOMPARASI SIFT vs SURF ===")
+    logger.info("Menghasilkan bukti visual deteksi Keypoint untuk manuskrip...")
     manifest_path = os.path.join(config.INTERIM_DIR, "manifest.pkl")
     if os.path.exists(manifest_path):
         manifest = utils.load_pickle(manifest_path)
@@ -339,13 +347,14 @@ def step_evaluate():
     df_results = pd.read_csv(os.path.join(config.TABLES_DIR, "cluster_metrics_all.csv"))
     df_eff = pd.read_csv(os.path.join(config.TABLES_DIR, "efficiency_raw.csv"))
 
+    # --- [INJEKSI KODE BARU: GRAFIK ABLATION PCA] ---
     logger.info("Menghasilkan visualisasi Ablation Study (PCA Impact)...")
     visualization.plot_pca_ablation_impact(
         df_results, 
         save_name="pca_impact_ablation.png"
     )
-
-    logger.info("Menghasilkan Radar Chart untuk Komparasi Keseluruhan")
+    #baru buat keseluruhan
+    logger.info("Menghasilkan Radar Chart Komparasi Keseluruhan...")
     visualization.plot_overall_radar_comparison(df_results, df_eff)
 
     df_default = df_results[
@@ -406,14 +415,17 @@ def step_evaluate():
     logger.info("Ringkasan akhir disimpan ke outputs/tables/final_summary.json")
 
 
+# ---------------------------------------------------------------------------
 # TAHAP 6: HYPERPARAMETER TUNING NATIVE (DEEP SEARCH)
+# ---------------------------------------------------------------------------
 def step_tune():
-    logger.info("TAHAP 6 - HYPERPARAMETER TUNING (DEEP SEARCH)")
+    logger.info("=== TAHAP 6: HYPERPARAMETER TUNING (DEEP SEARCH) ===")
     
-    # Tuning parameter baru untuk memaksimalkan Silhouette > 0.5
+    # Kumpulan parameter baru untuk memaksimalkan Silhouette > 0.5
     tuning_pca_components = [15, 20, 25, 30, 35]
     tuning_gmm_covariances = ['full', 'tied', 'diag']
     
+    # Kita fokuskan Hessian di angka optimal sebelumnya untuk menghemat waktu
     config.SURF_HESSIAN_THRESHOLD = 500
     config.CODEBOOK_SIZES = [200]
     config.DEFAULT_CODEBOOK_SIZE = 200
@@ -485,7 +497,15 @@ def step_tune():
     print(df_results.head(1).to_string(index=False))
     print("="*60)
 
-
+    # ------------------------------------------------------------------
+    # PERINGATAN METODOLOGIS + UJI STABILITAS KONFIGURASI TERBAIK
+    # ------------------------------------------------------------------
+    # Silhouette tertinggi dari grid search di atas TIDAK BOLEH langsung
+    # dilaporkan sebagai bukti separabilitas klaster - angka itu dipilih
+    # KARENA memaksimalkan metrik yang sama, jadi pasti bias optimis
+    # (circular: mencari lalu melaporkan metrik yang sama). Untuk laporan,
+    # gunakan silhouette_mean +/- std dari uji stabilitas di bawah, BUKAN
+    # SILHOUETTE_SCORE mentah dari baris teratas tabel deep search.
     logger.warning(
         "PERINGATAN METODOLOGIS: SILHOUETTE_SCORE pada tabel deep search "
         "adalah hasil PENCARIAN yang memaksimalkan metrik itu sendiri -> bias "
@@ -538,7 +558,7 @@ def step_tune():
 
 
 def step_export():
-    logger.info("TAHAP 7 - EKSPOR TABEL PREDIKSI")
+    logger.info("=== TAHAP 7: EKSPOR TABEL PREDIKSI ===")
     
     # 1. Memuat metadata gambar dan hasil klasterisasi
     manifest_path = os.path.join(config.INTERIM_DIR, "manifest.pkl")
@@ -584,171 +604,24 @@ def step_export():
     print(df_report.head(10).to_string(index=False))
     print("="*70)
 
-    if df_report['Hari Ke-'].isnull().all():
-        logger.warning(
-            "Dataset eksternal (publik) terdeteksi. Metadata temporal ('Hari Ke-') tidak "
-            "tersedia. Pembuatan grafik Distribusi Temporal secara otomatis dilewati."
-        )
-    else:
-        logger.info("Menghasilkan visualisasi Distribusi Temporal (DAY-1 vs DAY-2)...")
-        visualization.plot_temporal_distribution(
-            df_report, 
-            save_name=f"temporal_cluster_{config.DATASET_DOMAIN}.png"
-        )
-        logger.info("Grafik distribusi klaster otonom tersimpan di direktori figures.")
-
-
-def _execute_single_scenario(sc: Dict[str, Any], dict_sift: dict, dict_surf: dict, 
-                             code_dir: str, results_dir: str) -> dict:
-    """
-    Helper function (Private Method): 
-    Mengeksekusi satu iterasi eksperimen otonom (ekstraksi matriks laten, 
-    reduksi dimensi, dan klastering) serta mengembalikan matriks evaluasinya.
-    """
-    # 1. Penentuan target dictionary berdasarkan skenario
-    target_dict = dict_sift if sc["feat"] == "SIFT" else dict_surf
-    X_current = target_dict[sc["k"]].copy()
-    
-    # 2. Operasi Ablasi Fusi Warna (HSV)
-    if not sc["use_hsv"]:
-        X_current = X_current[:, :-9]
-        
-    # 3. Operasi Reduksi Dimensi (PCA)
-    if sc["space"] == "pca":
-        # Mencegah komponen PCA melampaui dimensi sampel
-        n_comp = min(sc["pca_comp"], X_current.shape[1] - 1)
-        pca = PCA(n_components=n_comp, random_state=config.RANDOM_STATE)
-        X_current = pca.fit_transform(X_current)
-        
-    # 4. Pemanggilan Algoritma Klastering Otonom
-    if sc["algo"] == "kmeans":
-        labels, _ = clustering.run_kmeans(X_current)
-    else:
-        labels, _ = clustering.run_gmm(X_current)
-        
-    # 5. Kalkulasi Metrik Separabilitas Spasial
-    metrics = clustering.internal_validation(X_current, labels)
-    
-    return metrics
-
+    # --- [INJEKSI KODE BARU: GRAFIK DISTRIBUSI TEMPORAL] ---
+    logger.info("Menghasilkan visualisasi Distribusi Temporal (DAY-1 vs DAY-2)...")
+    visualization.plot_temporal_distribution(
+        df_report, 
+        save_name="temporal_cluster_distribution.png"
+    )
+    logger.info("Grafik distribusi klaster otonom tersimpan di direktori figures.")
+    # --- [AKHIR INJEKSI KODE BARU] ---
 
-#EKSPERIMEN SENSITIVITAS ANALISIS
-def step_batch_experiment() -> None:
-    logger.info("=== TAHAP EKSPERIMEN BATCH & SENSITIVITY ANALYSIS ===")
-    
-    sift_path = os.path.join(config.INTERIM_DIR, "histograms_sift.pkl")
-    surf_path = os.path.join(config.INTERIM_DIR, "histograms_surf.pkl")
-    efficiency_path = os.path.join(config.TABLES_DIR, "efficiency_summary.csv")
-    
-    if not os.path.exists(sift_path) or not os.path.exists(efficiency_path):
-        logger.warning("Fitur dasar atau data efisiensi belum ada. Harap jalankan ekstraksi terlebih dahulu.")
-        return
-        
-    dict_sift = utils.load_pickle(sift_path)
-    dict_surf = utils.load_pickle(surf_path)
-    
-    # 1. Pemuatan dan Pemetaan Data Efisiensi
-    df_eff = pd.read_csv(efficiency_path)
-    df_eff['method'] = df_eff['method'].str.upper()
-    
-    eff_lookup = {}
-    for _, row in df_eff.iterrows():
-        eff_lookup[row['method']] = {
-            'elapsed_sec': round(row['mean_elapsed_sec'], 4),
-            'std_sec': round(row['std_elapsed_sec'], 4),
-            'n_keypoints': int(round(row['mean_n_keypoints'], 0))
-        }
-    
-    # 2. Definisi 14 Skenario Eksperimen (SINTA 1/2 Standard)
-    scenarios = [
-        {"id": "EXP-001", "feat": "SIFT", "k": 200, "use_hsv": True, "space": "raw", "algo": "kmeans", "pca_comp": None},
-        {"id": "EXP-002", "feat": "SURF", "k": 200, "use_hsv": True, "space": "raw", "algo": "kmeans", "pca_comp": None},
-        {"id": "EXP-003", "feat": "SIFT", "k": 200, "use_hsv": True, "space": "pca", "algo": "kmeans", "pca_comp": 30},
-        {"id": "EXP-004", "feat": "SURF", "k": 200, "use_hsv": True, "space": "pca", "algo": "kmeans", "pca_comp": 30},
-        {"id": "EXP-005", "feat": "SIFT", "k": 200, "use_hsv": True, "space": "pca", "algo": "gmm", "pca_comp": 30},
-        {"id": "EXP-006", "feat": "SURF", "k": 200, "use_hsv": True, "space": "pca", "algo": "gmm", "pca_comp": 30},
-        {"id": "EXP-007", "feat": "SIFT", "k": 50,  "use_hsv": True, "space": "pca", "algo": "kmeans", "pca_comp": 30},
-        {"id": "EXP-008", "feat": "SIFT", "k": 100, "use_hsv": True, "space": "pca", "algo": "kmeans", "pca_comp": 30},
-        {"id": "EXP-009", "feat": "SURF", "k": 50,  "use_hsv": True, "space": "pca", "algo": "kmeans", "pca_comp": 30},
-        {"id": "EXP-010", "feat": "SURF", "k": 100, "use_hsv": True, "space": "pca", "algo": "kmeans", "pca_comp": 30},
-        {"id": "EXP-011", "feat": "SIFT", "k": 200, "use_hsv": False, "space": "pca", "algo": "kmeans", "pca_comp": 30},
-        {"id": "EXP-012", "feat": "SURF", "k": 200, "use_hsv": False, "space": "pca", "algo": "kmeans", "pca_comp": 30},
-        {"id": "EXP-013", "feat": "SIFT", "k": 200, "use_hsv": False, "space": "raw", "algo": "kmeans", "pca_comp": None},
-        {"id": "EXP-014", "feat": "SURF", "k": 200, "use_hsv": False, "space": "raw", "algo": "kmeans", "pca_comp": None},
-    ]
-    
-    experiment_logs = []
-    base_archive_path = os.path.join(os.getcwd(), "archives")
-    os.makedirs(base_archive_path, exist_ok=True)
-    
-    # Menghasilkan format tanggal (YYYYMMDD) untuk penomoran ID
-    date_str = datetime.datetime.now().strftime("%Y%m%d")
-    # Mempertahankan timestamp detik untuk nama file Master Log
-    timestamp_full = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-    # Menggunakan enumerate untuk menghasilkan sekuens otomatis (01, 02, dst.)
-    for idx, sc in enumerate(scenarios, start=1):
-        # Membentuk ID Eksperimen: EXP-YYYYMMDD-XX
-        seq_str = f"{idx:02d}"
-        exp_id = f"EXP-{date_str}-{seq_str}"
-        
-        # Menimpa 'id' lama agar ID baru terekam di Master Log
-        sc["id"] = exp_id 
-        
-        extractor = sc["feat"]
-        logger.info(f"Mengeksekusi {exp_id}: {extractor} k={sc['k']} HSV={sc['use_hsv']} {sc['space'].upper()} {sc['algo'].upper()}")
-        
-        # A. Pembuatan Direktori Arsip otomatis
-        folder_name = f"{config.DATASET_DOMAIN}_{exp_id}"
-        exp_dir = os.path.join(base_archive_path, folder_name)
-        code_dir, results_dir = os.path.join(exp_dir, "code_snapshot"), os.path.join(exp_dir, "results")
-        os.makedirs(code_dir, exist_ok=True)
-        os.makedirs(results_dir, exist_ok=True)
-        
-        # B. Snapshot Source Code
-        for file in os.listdir("."):
-            if file.endswith(".py") or file.endswith(".json"):
-                shutil.copy(file, code_dir)
-        if os.path.exists("src"):
-            shutil.copytree("src", os.path.join(code_dir, "src"))
-            
-        # C. Eksekusi Skenario Komputasi
-        metrics = _execute_single_scenario(sc, dict_sift, dict_surf, code_dir, results_dir)
-        
-        # D. Integrasi Metrik Efisiensi ke dalam Log
-        eff_data = eff_lookup.get(extractor, {'elapsed_sec': 0, 'std_sec': 0, 'n_keypoints': 0})
-        metrics["efficiency"] = eff_data
-        
-        # Memperbarui JSON di dalam folder arsip
-        with open(os.path.join(results_dir, "evaluation_metrics.json"), "w") as f:
-            json.dump(metrics, f, indent=4)
-            
-        # E. Pencatatan ke Master Log Tabular
-        experiment_logs.append({
-            "ID Eksperimen": exp_id,
-            "Ekstraktor": extractor,
-            "Konfigurasi": f"{extractor} k={sc['k']} HSV={sc['use_hsv']}",
-            "Ruang & Algo": f"{sc['space'].upper()} + {sc['algo'].upper()}",
-            "Silhouette (↑)": round(metrics.get("silhouette_score", 0), 4),
-            "Davies-Bouldin (↓)": round(metrics.get("davies_bouldin_score", 0), 4),
-            "Calinski-Harabasz (↑)": round(metrics.get("calinski_harabasz_score", 0), 2),
-            "Waktu Ekstraksi (det/citra) (↓)": eff_data["elapsed_sec"],
-            "Std Dev Waktu (±)": eff_data["std_sec"],
-            "Rata-rata Keypoint": eff_data["n_keypoints"],
-            "Folder Arsip": folder_name
-        })
-        
-    # 3. Ekspor Tabel Rekapitulasi
-    df_log = pd.DataFrame(experiment_logs)
-    main_log_path = os.path.join(base_archive_path, f"Master_Log_{config.DATASET_DOMAIN}_{timestamp_full}.csv")
-    df_log.to_csv(main_log_path, index=False)
-    logger.info(f"Eksperimen komprehensif terintegrasi selesai. Log tersimpan di: {main_log_path}")
 
-# TAHAP 8: PEMBUATAN MODEL PRODUKSI 
+# ---------------------------------------------------------------------------
+# TAHAP 8: PEMBUATAN MODEL PRODUKSI (DEPLOYMENT)
+# ---------------------------------------------------------------------------
 def step_build_production_model():
-    logger.info("TAHAP 8 - MERAKIT MODEL PRODUKSI")
+    logger.info("=== TAHAP 8: MERAKIT MODEL PRODUKSI ===")
     
-    # 1. Tentukan parameter terbaik dari hasil eksperimen
+    # 1. Tentukan parameter terbaik dari hasil eksperimenmu
+    # 1. Membaca parameter terbaik dari hasil Deep Search secara otomatis
     logger.info("Mengambil konfigurasi terbaik dari file CSV...")
     tuning_csv_path = os.path.join(config.TABLES_DIR, "tuning_results_deep_search.csv")
     
@@ -778,10 +651,9 @@ def step_build_production_model():
     codebook = codebooks[best_codebook_size]
     filenames = list(descriptors_dict.keys())
     
-    """ 2. Buat ulang scaler warna HSV (MinMax lalu L2-normalize per baris -
-    HARUS sama persis dengan step_bovw, atau model produksi tidak konsisten
-    dengan hasil eksperimen yang dilaporkan """
-    
+    # 2. Buat ulang scaler warna HSV (MinMax lalu L2-normalize per baris -
+    # HARUS sama persis dengan step_bovw, atau model produksi tidak konsisten
+    # dengan hasil eksperimen yang dilaporkan)
     logger.info("Melatih ulang MinMaxScaler...")
     raw_hsv_values = list(hsv_dict.values())
     scaler = MinMaxScaler()
@@ -813,7 +685,7 @@ def step_build_production_model():
     logger.info("Melatih GMM Classifier...")
     gmm = GaussianMixture(n_components=2, covariance_type=best_gmm_covariance, 
                           random_state=config.RANDOM_STATE, n_init=10)
-    gmm.fit(X_pca) 
+    gmm.fit(X_pca) # Kita memanggil .fit() untuk menyimpan statenya
     
     # 6. BUNGKUS MENJADI SATU FILE MODEL
     model_package = {
@@ -835,7 +707,9 @@ def step_build_production_model():
     logger.info("Model Produksi berhasil disimpan di: %s", model_path)
     logger.info("Model ini siap dimuat (di-load) untuk aplikasi klasifikasi otomatis tahun depan!")
 
+# ---------------------------------------------------------------------------
 # ENTRY POINT
+# ---------------------------------------------------------------------------
 STEPS = {
     "preprocess": step_preprocess,
     "extract": step_extract,
@@ -845,7 +719,6 @@ STEPS = {
     "tune": step_tune,
     "export": step_export,
     "build_model": step_build_production_model,
-    "batch_log": step_batch_experiment,
 }
 
 def main():

src/bovw.py

@@ -1,4 +1,4 @@
-"""Bags of Visual Words - pembentukan codebook (MiniBatchKMeans) & histogram fitur."""
+"""Bags of Visual Words: pembentukan codebook (MiniBatchKMeans) & histogram fitur."""
 import numpy as np
 from sklearn.cluster import MiniBatchKMeans
 
@@ -8,7 +8,8 @@ import config
 def sample_descriptors_for_codebook(all_descriptors_list, max_total, random_state):
     """
     Menggabungkan descriptor dari seluruh citra lalu men-subsample hingga
-    maksimum `max_total` baris agar pelatihan codebook tetap efisien.
+    maksimum `max_total` baris agar pelatihan codebook tetap efisien memori
+    untuk dataset beribu-ribu citra.
     """
     stacked = np.vstack(
         [d for d in all_descriptors_list if d is not None and len(d) > 0]
@@ -58,7 +59,7 @@ def compute_histogram(descriptors, codebook, normalize="hellinger"):
         if total > 0:
             histogram = histogram / total
     elif normalize == "hellinger":
-        # Transformasi Root-BoVW
+        # Transformasi Root-BoVW (Sangat superior untuk deteksi tekstur)
         total = histogram.sum()
         if total > 0:
             histogram = histogram / total

src/clustering.py

@@ -28,7 +28,8 @@ def run_gmm(X, k=None, random_state=None):
     labels = model.fit_predict(X)
     return labels, model
 
-#algoritma yang dipake
+# Pipeline utama akan membaca dictionary ini secara dinamis
+# Sekarang hanya terdaftar dua algoritma
 CLUSTERING_METHODS = {
     "kmeans": run_kmeans,
     "gmm": run_gmm,

src/evaluation.py

@@ -1,6 +1,8 @@
 """Komparasi SIFT vs SURF: efisiensi komputasi & kualitas separabilitas klaster."""
 import os
+
 import pandas as pd
+
 import config
 
 
@@ -38,7 +40,7 @@ def summarize_efficiency(df_efficiency):
 def build_cluster_metrics_table(results):
     """
     results: list of dict, masing-masing hasil satu kombinasi
-        {feature: "SIFT"/"SURF", method: "kmeans"/"gmm",
+        {feature: "SIFT"/"SURF", method: "kmeans"/"gmm"/"agglomerative",
          codebook_size: int, **internal_metrics, **external_metrics(optional)}
     """
     return pd.DataFrame(results)

src/feature_extraction.py

@@ -1,5 +1,9 @@
 """
-Ekstraksi fitur SIFT & SURF, serta momen HSV, dibatasi pada area ROI daging (mask).
+Ekstraksi fitur lokal SIFT & SURF, serta momen HSV, dibatasi pada area ROI daging (mask).
+
+Membutuhkan opencv-contrib-python versi yang dikompilasi dengan
+OPENCV_ENABLE_NONFREE=ON (mis. 3.4.2.16) agar cv2.xfeatures2d.SIFT_create()
+dan cv2.xfeatures2d.SURF_create() tersedia.
 """
 import time
 import cv2

src/preprocessing.py

@@ -1,4 +1,4 @@
-"""Preprocessing: resize, denoising, segmentasi ROI, QA visual, dan Bounding Box Crop."""
+"""Preprocessing citra: resize, denoising, segmentasi ROI, QA visual, dan Bounding Box Crop."""
 import os
 import cv2
 import numpy as np
@@ -32,19 +32,20 @@ def crop_to_bounding_box(image, mask, pad_ratio=0.01):
     Mengeliminasi redundansi dimensi latar belakang untuk menjaga kemurnian
     ekstraksi fitur spasial (SURF) dan momen statistik warna (HSV).
     """
-    #1.Ekstraksi koordinat absolut dari piksel foreground murni
+    # 1. Ekstraksi koordinat absolut dari piksel foreground murni
     coords = cv2.findNonZero(mask)
     
     # Fallback jika mask secara anomali kosong
     if coords is None:
         return image, mask
         
-    #2.Kalkulasi bounding box yang presisi mengelilingi piksel aktif
+    # 2. Kalkulasi bounding box yang presisi mengelilingi piksel aktif
     x, y, w, h_rect = cv2.boundingRect(coords)
     
     H, W = image.shape[:2]
     
-    #3.Margin ketat (1% dari dimensi objek) untuk menyisakan sedikit ruang agar detektor tepi SURF tidak terpotong
+    # 3. Margin sangat ketat (1% dari dimensi objek) 
+    # untuk menyisakan sedikit ruang agar detektor tepi SURF tidak terpotong
     pad_x, pad_y = int(w * pad_ratio), int(h_rect * pad_ratio)
     
     x1, y1 = max(0, x - pad_x), max(0, y - pad_y)

src/segmentation.py

@@ -13,11 +13,11 @@ def segment_meat_roi(image_bgr, min_area_ratio=0.015):
     h, w = image_bgr.shape[:2]
     total_area = float(h * w)
 
-    # 1.Konversi ke HSV dengan reduksi blur untuk menjaga ketegasan batas tepi
+    # 1. Konversi ke HSV dengan reduksi blur untuk menjaga ketegasan batas tepi
     blurred = cv2.GaussianBlur(image_bgr, (7, 7), 0)
     hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
 
-    # 2.Strict Spectrum Isolation
+    # 2. Strict Spectrum Isolation
     # S > 50 dan V > 40 membuang warna netral (hitam/abu-abu latar & putih stiker)
     # H: 0-20 & 160-180 murni mengunci pigmen mioglobin (merah/pink/cokelat)
     mask1 = cv2.inRange(hsv, np.array([0, 30, 25]), np.array([30, 255, 255]))

src/utils.py

@@ -15,7 +15,7 @@ def get_logger(name="pipeline"):
     os.makedirs(config.LOGS_DIR, exist_ok=True)
     logger = logging.getLogger(name)
     if logger.handlers:
-        return logger 
+        return logger  # sudah dikonfigurasi sebelumnya, hindari duplikasi handler
 
     logger.setLevel(getattr(logging, config.LOG_LEVEL, logging.INFO))
     fmt = logging.Formatter(

src/visualization.py

@@ -1,9 +1,11 @@
 """
 Visualisasi hasil: reduksi dimensi, evaluasi metrik, dan analisis distribusi.
+Standar output disesuaikan untuk publikasi akademik (SINTA/Scopus) dengan 
+resolusi 300 DPI dan gaya minimalis-kontras tinggi.
 """
 import os
 import matplotlib
-matplotlib.use("Agg")  
+matplotlib.use("Agg")  # Headless mode
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
@@ -17,7 +19,7 @@ from sklearn.preprocessing import MinMaxScaler
 import config
 
 def set_academic_style():
-    """Mengatur parameter global Matplotlib"""
+    """Mengatur parameter global Matplotlib untuk standar jurnal akademik."""
     plt.rcParams.update({
         "font.family": "serif",
         "font.serif": ["Times New Roman", "DejaVu Serif"],
@@ -37,18 +39,19 @@ def set_academic_style():
         "axes.spines.right": False
     })
 
-# Panggil styling
+# Panggil styling di awal
 set_academic_style()
 
 
 def plot_embedding_2d(X, labels, method_name, save_name, title=None):
-    """Plot reduksi dimensi PCA"""
+    """Plot reduksi dimensi PCA dengan standar visual akademik."""
     os.makedirs(config.FIGURES_DIR, exist_ok=True)
     pca = PCA(n_components=2, random_state=config.RANDOM_STATE)
     embedding = pca.fit_transform(X)
 
     fig, ax = plt.subplots(figsize=(7, 6))
     
+    # Menggunakan colormap yang ramah buta warna dan elegan
     scatter = ax.scatter(
         embedding[:, 0], embedding[:, 1], c=labels, cmap="Set1",
         s=25, alpha=0.8, edgecolors="white", linewidth=0.5
@@ -325,7 +328,7 @@ def plot_overall_radar_comparison(df_metrics, df_efficiency, save_name="overall_
     ]
     
     # 4. Normalisasi Min-Max (0-1) agar bisa di-plot di sumbu yang sama
-    # Untuk DB dan Time, balik (invers) sebelum dinormalisasi agar nilai tertinggi = terbaik
+    # Untuk DB dan Time, kita balik (invers) sebelum dinormalisasi agar nilai tertinggi = terbaik
     raw_data = np.array([sift_raw, surf_raw])
     
     # Inversi kolom DB (indeks 3) dan Time (indeks 4)