Upload project with bundled WavLM model

.gitignore

@@ -0,0 +1,37 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+.venv/
+env/
+.env
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS / Temp
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,335 @@
+# Metode Penilaian Kemiripan Bacaan Al-Qur'an pada Pembelajaran DIROSA Menggunakan Representasi Audio WavLM dan Dynamic Time Warping
+
+Repositori ini berisi implementasi dari penelitian skripsi berjudul **"Metode Penilaian Kemiripan Bacaan Al-Qur'an pada Pembelajaran DIROSA Menggunakan Representasi Audio WavLM dan Dynamic Time Warping"**.
+
+Metode yang diajukan mengukur seberapa mirip bacaan Al-Qur'an seorang peserta DIROSA terhadap bacaan referensi, melalui pendekatan berbasis *deep audio representation learning*. Fitur audio diekstraksi menggunakan model pretrained **WavLM**, kemudian dibandingkan secara sekuensial menggunakan **Dynamic Time Warping (DTW)** untuk menghasilkan skor kemiripan.
+
+---
+
+## Daftar Isi
+
+- [Gambaran Umum](#gambaran-umum)
+- [Arsitektur Pipeline](#arsitektur-pipeline)
+- [Struktur Direktori](#struktur-direktori)
+- [Prasyarat](#prasyarat)
+- [Instalasi](#instalasi)
+- [Penggunaan](#penggunaan)
+  - [Antarmuka Web (Streamlit)](#antarmuka-web-streamlit)
+  - [Command Line Interface](#command-line-interface)
+- [Dataset Audio](#dataset-audio)
+- [Penjelasan Modul](#penjelasan-modul)
+- [Konfigurasi dan Parameter](#konfigurasi-dan-parameter)
+- [Analisis Korelasi](#analisis-korelasi)
+- [Lisensi](#lisensi)
+
+---
+
+## Gambaran Umum
+
+Metode ini membandingkan dua rekaman audio bacaan Al-Qur'an dan menghasilkan skor kemiripan pada skala 0--100. Pipeline pemrosesan meliputi empat tahap utama:
+
+1. **Pemuatan dan pra-pemrosesan audio** -- resampling ke 16 kHz, konversi mono, VAD endpoint trimming, dan normalisasi amplitudo.
+2. **Ekstraksi fitur** -- menggunakan model pretrained WavLM Base Plus (tersimpan lokal di folder `wavlm-base-plus/`) untuk menghasilkan representasi frame-level dari 12 layer transformer.
+3. **Pencocokan sekuens** -- Dynamic Time Warping dengan jarak cosine dan batasan Sakoe-Chiba band.
+4. **Penilaian** -- konversi jarak DTW ternormalisasi ke skor 0--100 melalui pemetaan logistik (sigmoid) yang telah dikalibrasi.
+
+---
+
+## Arsitektur Pipeline
+
+```
+Audio WAV (Peserta)  ──┐
+                       ├──> AudioLoader ──> WavLMEncoder ──> DTWSimilarity ──> SimilarityScorer
+Audio WAV (Referensi) ─┘    (16 kHz,       (frame-level     (cosine DTW,     (sigmoid score
+                             mono, VAD,      features,        Sakoe-Chiba)      0-100)
+                             normalisasi)    layer 1-12)
+```
+
+---
+
+## Struktur Direktori
+
+```
+kode_inti_yudisium/
+|
+|-- app.py                    # Antarmuka web Streamlit (single, batch, korelasi)
+|-- run_similarity.py         # CLI untuk single/batch processing
+|-- scoring.py                # Orchestrator pipeline end-to-end
+|-- wavlm_encoder.py          # Ekstraksi fitur WavLM (frozen, multi-layer)
+|-- dtw_similarity.py          # DTW dengan Sakoe-Chiba band dan konversi skor
+|-- audio_loader.py           # Pemuatan audio, VAD trimming, normalisasi
+|-- correlation_analysis.py   # Analisis korelasi Spearman/Pearson dan visualisasi
+|-- create_dataset.py         # Skrip pembuatan dataset final (merge skor + rating)
+|-- dataset_final.csv         # Dataset gabungan skor sistem dan rating Ustadz
+|-- requirements.txt          # Daftar dependensi Python
+|
+|-- audio referensi/          # 20 file WAV bacaan referensi (Pertemuan 1-20)
+|-- audio peserta/            # Rekaman peserta, terorganisir per subfolder
+|   |-- peserta 1/
+|   |-- peserta 2/
+|   |-- peserta 3/
+|   |-- peserta 4/
+|   |-- peserta 5/
+|
+|-- README.md
+```
+
+---
+
+## Prasyarat
+
+- **Python** 3.9 atau lebih baru
+- **PyTorch** dengan dukungan CUDA (opsional, untuk akselerasi GPU)
+- Koneksi internet diperlukan saat pertama kali menjalankan program untuk mengunduh model WavLM dari HuggingFace Hub
+
+> Model WavLM secara otomatis berjalan di GPU jika PyTorch CUDA tersedia.
+> Jika tidak, sistem akan fallback ke CPU secara transparan.
+
+---
+
+## Instalasi
+
+1. Clone atau unduh repositori ini.
+
+2. Buat virtual environment (direkomendasikan):
+
+   ```bash
+   python -m venv venv
+   # Windows
+   venv\Scripts\activate
+   # Linux / macOS
+   source venv/bin/activate
+   ```
+
+3. Install dependensi:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+   Dependensi utama:
+
+   | Paket              | Versi    | Fungsi                                      |
+   |--------------------|----------|---------------------------------------------|
+   | `torch`            | 2.12.0   | Backend deep learning, komputasi tensor     |
+   | `torchaudio`       | 2.11.0   | Pemuatan dan resampling audio               |
+   | `transformers`     | 4.57.3   | Model WavLM dari HuggingFace               |
+   | `numpy`            | 2.3.5    | Operasi numerik dan array                   |
+   | `scipy`            | 1.16.3   | Uji statistik (Spearman, Pearson)           |
+   | `pandas`           | 2.3.3    | Manipulasi data tabular                     |
+   | `soundfile`        | 0.13.1   | Pembacaan file audio WAV (fallback loader)  |
+   | `webrtcvad-wheels` | 2.0.14   | Voice Activity Detection (endpoint trimming)|
+   | `streamlit`        | 1.52.2   | Antarmuka web interaktif                    |
+   | `matplotlib`       | 3.10.8   | Visualisasi grafik dan plot                 |
+
+---
+
+## Penggunaan
+
+### Antarmuka Web (Streamlit)
+
+Jalankan aplikasi web interaktif:
+
+```bash
+streamlit run app.py
+```
+
+Aplikasi menyediakan tiga tab utama:
+
+| Tab                              | Fungsi                                                                                 |
+|----------------------------------|----------------------------------------------------------------------------------------|
+| **Single Processing**            | Upload dua file audio (referensi dan peserta), pilih layer, lihat skor dan visualisasi |
+| **Batch Processing (Folder)**    | Proses seluruh folder `audio peserta/` terhadap `audio referensi/`, ekspor CSV         |
+| **Analisis Korelasi (Overview)** | Visualisasi hubungan skor sistem vs rating Ustadz (Spearman, Pearson, heatmap)         |
+
+Fitur antarmuka:
+
+- Preview waveform sebelum dan sesudah pra-pemrosesan (VAD + normalisasi)
+- Pemilihan layer WavLM (1--12) secara individual atau seluruhnya
+- Visualisasi alignment path DTW dan cost matrix heatmap
+- Diagnostik internal DTW (opsional)
+- Interpretasi skor otomatis (Sangat Mirip, Mirip, Cukup Mirip, Kurang Mirip)
+
+### Command Line Interface
+
+**Mode Single** -- bandingkan dua file audio:
+
+```bash
+python run_similarity.py audio_peserta.wav audio_referensi.wav
+```
+
+Opsi tambahan:
+
+```bash
+python run_similarity.py audio1.wav audio2.wav --detailed --json
+```
+
+**Mode Batch** -- proses seluruh folder:
+
+```bash
+python run_similarity.py \
+    --participant-dir "audio peserta" \
+    --reference-dir "audio referensi" \
+    --recursive \
+    --output hasil_batch.csv
+```
+
+Parameter CLI yang tersedia:
+
+| Parameter            | Default                       | Keterangan                                       |
+|----------------------|-------------------------------|--------------------------------------------------|
+| `--model`            | `./wavlm-base-plus`          | Model WavLM (path lokal, sudah tersedia di repo)     |
+| `--device`           | auto-detect                   | Device komputasi (`cuda` / `cpu`)                |
+| `--distance`         | `cosine`                      | Metrik jarak DTW (`cosine` / `euclidean`)        |
+| `--no-normalize`     | _disabled_                    | Nonaktifkan normalisasi jarak DTW                |
+| `--detailed`         | _disabled_                    | Tampilkan metrik detail (single mode)            |
+| `--json`             | _disabled_                    | Output dalam format JSON                         |
+| `--recursive`        | _disabled_                    | Cari file WAV secara rekursif (batch mode)       |
+| `--output`           | `similarity_results.csv`      | Path output batch (`.csv` / `.xlsx`)             |
+
+---
+
+## Dataset Audio
+
+Dataset audio yang digunakan dalam penelitian ini terdiri dari 20 frasa bacaan DIROSA (Pertemuan 1--20) yang dibacakan oleh 5 peserta, masing-masing dibandingkan terhadap satu audio referensi per frasa.
+
+**Unduh dataset audio:**
+
+[https://drive.google.com/drive/folders/1wO7WvfKn4bnWfLxaVSHSOqn0psosf8oB?usp=sharing](https://drive.google.com/drive/folders/1wO7WvfKn4bnWfLxaVSHSOqn0psosf8oB?usp=sharing)
+
+Setelah diunduh, letakkan isi folder sesuai struktur berikut:
+
+```
+kode_inti_yudisium/
+|-- audio referensi/
+|   |-- Dirosa Pertemuan 1.wav
+|   |-- Dirosa Pertemuan 2.wav
+|   |-- ...
+|   |-- Dirosa Pertemuan 20.wav
+|
+|-- audio peserta/
+|   |-- peserta 1/
+|   |   |-- Dirosa Pertemuan 1.wav
+|   |   |-- Dirosa Pertemuan 2.wav
+|   |   |-- ...
+|   |-- peserta 2/
+|   |-- ...
+```
+
+Format audio: **WAV, mono, 16-bit PCM**. Audio akan di-resample ke 16 kHz secara otomatis jika diperlukan.
+
+---
+
+## Penjelasan Modul
+
+### `audio_loader.py` -- AudioLoader
+
+Bertanggung jawab atas seluruh tahap pra-pemrosesan audio:
+
+- **Pemuatan audio**: menggunakan `soundfile` sebagai loader utama (tanpa dependensi FFmpeg), dengan fallback ke `torchaudio`.
+- **Resampling**: konversi otomatis ke 16 kHz (target sample rate WavLM).
+- **Konversi mono**: audio stereo dirata-ratakan menjadi satu kanal.
+- **VAD Endpoint Trimming**: menggunakan WebRTC VAD dengan mekanisme hysteresis (onset/offset) untuk menghapus segmen hening di awal dan akhir tanpa memotong jeda internal.
+- **Energy Refinement**: pemangkasan berbasis RMS envelope untuk menghilangkan sisa noise atau napas yang lolos dari VAD.
+- **Normalisasi amplitudo**: penskalaan waveform ke rentang [-1, 1].
+
+### `wavlm_encoder.py` -- WavLMEncoder
+
+Mengekstraksi fitur frame-level menggunakan model pretrained WavLM (frozen, tanpa fine-tuning):
+
+- Mendukung ekstraksi dari satu layer tertentu atau beberapa layer sekaligus.
+- Model berjalan di GPU secara otomatis jika CUDA tersedia.
+- Pipeline PyTorch-only (TensorFlow/Flax dinonaktifkan secara eksplisit).
+
+### `dtw_similarity.py` -- DTWSimilarity
+
+Modul inti pencocokan sekuens:
+
+- **Cost matrix**: jarak cosine atau Euclidean (vectorised).
+- **DTW dengan Sakoe-Chiba band**: membatasi jalur warping untuk efisiensi dan menghindari alignment yang tidak realistis.
+- **Backtracking**: rekonstruksi optimal warping path.
+- **Konversi skor**: pemetaan logistik (sigmoid) dari jarak ternormalisasi ke skala 0--100.
+
+Kalibrasi default (midpoint=0.3, steepness=10.0):
+
+| Jarak (d)    | Skor     | Interpretasi        |
+|--------------|----------|---------------------|
+| ~ 0.05       | ~ 92     | Sangat mirip        |
+| ~ 0.15       | ~ 82     | Mirip               |
+| ~ 0.30       | = 50     | Borderline          |
+| ~ 0.35       | ~ 38     | Kurang mirip        |
+| > 0.50       | < 12     | Sangat berbeda      |
+
+### `scoring.py` -- SimilarityScorer
+
+Orchestrator yang menghubungkan seluruh komponen pipeline:
+
+- `compute_similarity()` -- mengembalikan jarak DTW mentah.
+- `compute_similarity_score_normalized()` -- mengembalikan skor 0--100.
+- `compute_detailed_similarity()` -- mengembalikan hasil lengkap per layer termasuk warping path, cost matrix, diagnostik, dan waveform.
+
+### `correlation_analysis.py`
+
+Modul analisis statistik untuk validasi metode:
+
+- Korelasi **Spearman** (monotonic) dan **Pearson** (linear) antara skor sistem dan rating Ustadz.
+- Visualisasi: bar chart, scatter plot, heatmap, dan diagram pasangan frasa.
+
+### `create_dataset.py`
+
+Skrip utilitas untuk menggabungkan hasil batch processing (skor per layer) dengan rating manual Ustadz menjadi satu dataset (`dataset_final.csv`).
+
+### `run_similarity.py`
+
+CLI entry point yang mendukung mode single (dua file) dan batch (dua folder), dengan output CSV/XLSX.
+
+### `app.py`
+
+Antarmuka web berbasis Streamlit yang menyatukan seluruh fungsionalitas pipeline dalam tampilan interaktif.
+
+---
+
+## Konfigurasi dan Parameter
+
+Parameter utama pipeline dikonfigurasi melalui `SimilarityScorer`:
+
+| Parameter            | Default                       | Keterangan                                                |
+|----------------------|-------------------------------|-----------------------------------------------------------|
+| `model_name`         | `./wavlm-base-plus`          | Model WavLM (path lokal, sudah tersedia di repo)            |
+| `distance_metric`    | `cosine`                      | Metrik jarak untuk DTW                                   |
+| `sakoe_chiba_ratio`  | `0.1`                         | Lebar band Sakoe-Chiba (fraksi dari panjang sekuens)     |
+| `normalize_dtw`      | `True`                        | Normalisasi jarak DTW berdasarkan panjang warping path   |
+| `score_midpoint`     | `0.3`                         | Titik tengah sigmoid (jarak yang menghasilkan skor 50)   |
+| `score_steepness`    | `10.0`                        | Ketajaman transisi sigmoid                               |
+
+Parameter VAD (dikonfigurasi melalui `AudioLoader`):
+
+| Parameter                | Default | Keterangan                                                      |
+|--------------------------|---------|-----------------------------------------------------------------|
+| `vad_mode`               | `1`     | Agresivitas WebRTC VAD (0--3, 1--2 direkomendasikan)            |
+| `vad_frame_ms`           | `10`    | Panjang frame VAD dalam milidetik (10, 20, atau 30)             |
+| `vad_onset_frames`       | `2`     | Jumlah frame voiced berturut-turut untuk mendeteksi onset       |
+| `vad_offset_frames`      | `4`     | Jumlah frame unvoiced berturut-turut untuk mendeteksi offset    |
+| `energy_trim_threshold`  | `0.06`  | Threshold energi untuk pemangkasan tambahan pasca-VAD           |
+
+---
+
+## Analisis Korelasi
+
+File `dataset_final.csv` berisi 101 pasangan data (5 peserta x ~20 frasa) dengan kolom:
+
+| Kolom           | Keterangan                                         |
+|-----------------|-----------------------------------------------------|
+| `ID_Pasangan`   | Identifier unik pasangan peserta-frasa              |
+| `ID_Peserta`    | ID peserta (1--5)                                   |
+| `ID_Frasa`      | Nama file frasa (Dirosa Pertemuan X.wav)            |
+| `Score L1`--`Score L12` | Skor kemiripan dari masing-masing layer WavLM |
+| `rating`        | Penilaian manual Ustadz (ground truth)              |
+
+Analisis korelasi Spearman digunakan untuk mengidentifikasi layer WavLM yang paling berkorelasi dengan penilaian manusia, sehingga dapat dipilih representasi yang paling relevan secara perseptual.
+
+---
+
+## Lisensi
+
+Proyek ini dikembangkan untuk keperluan akademis (skripsi). Model WavLM Base Plus (`wavlm-base-plus/`) bersumber dari [microsoft/wavlm-base-plus](https://huggingface.co/microsoft/wavlm-base-plus) dan mengikuti lisensi yang ditetapkan oleh Microsoft Research.

app.py

@@ -0,0 +1,612 @@
+"""
+Streamlit App - Metode Penilaian Kemiripan Bacaan Al-Qur'an
+pada Pembelajaran DIROSA Menggunakan Representasi Audio WavLM dan DTW
+"""
+
+import os
+import tempfile
+import re
+from pathlib import Path
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import streamlit as st
+import torch
+
+from scoring import SimilarityScorer
+from correlation_analysis import (
+    run_correlation_analysis,
+    plot_correlation_bar,
+    plot_scatter_best_layer,
+    plot_heatmap,
+    plot_pairing_diagram
+)
+
+# ---------------------------------------------------------------------------
+# Model caching
+# ---------------------------------------------------------------------------
+
+@st.cache_resource(show_spinner="Memuat model WavLM dan Pipeline ...")
+def load_pipeline():
+    """Load pipeline components once and cache them.
+    
+    Model WavLM otomatis berjalan di GPU (CUDA) jika tersedia,
+    atau fallback ke CPU jika GPU tidak terdeteksi.
+    Deteksi device dilakukan oleh WavLMEncoder secara otomatis.
+    """
+    scorer = SimilarityScorer(
+        model_name="./wavlm-base-plus",
+        distance_metric="cosine",
+        sakoe_chiba_ratio=0.1,
+        normalize_dtw=True
+    )
+    return scorer
+
+
+def get_device_info() -> str:
+    """Kembalikan string info device yang sedang digunakan (GPU/CPU)."""
+    if torch.cuda.is_available():
+        gpu_name = torch.cuda.get_device_name(0)
+        return f"⚡ GPU — {gpu_name}"
+    return "🖥️ CPU (GPU tidak terdeteksi / PyTorch tanpa CUDA)"
+
+
+def run_pipeline(ref_path: str, test_path: str, use_vad: bool = True,
+                 layer_indices: list = None):
+    """Run full pipeline using SimilarityScorer."""
+    scorer = load_pipeline()
+    
+    # Delegate the processing to SimilarityScorer's multi-layer handler
+    detailed_data = scorer.compute_detailed_similarity(
+        audio_path1=ref_path, 
+        audio_path2=test_path, 
+        use_vad=use_vad, 
+        layer_indices=layer_indices
+    )
+    
+    results = detailed_data["results"]
+    waveforms = detailed_data["waveforms"]
+    
+    return (
+        results, 
+        waveforms["ref_raw"], 
+        waveforms["ref_vad"], 
+        waveforms.get("ref_normalized", waveforms["ref_vad"]),
+        waveforms["test_raw"], 
+        waveforms["test_vad"],
+        waveforms.get("test_normalized", waveforms["test_vad"]),
+    )
+
+
+
+def plot_alignment(warping_path):
+    """Create a simple DTW alignment line plot."""
+    path = np.array(warping_path)
+    fig, ax = plt.subplots(figsize=(6, 3.5))
+    ax.plot(path[:, 0], path[:, 1], linewidth=0.8, color="black")
+    ax.set_xlabel("Frame Referensi")
+    ax.set_ylabel("Frame Peserta")
+    ax.set_title("Alignment DTW")
+    fig.tight_layout()
+    return fig
+
+
+def plot_dtw_heatmap(dtw_matrix: np.ndarray, warping_path):
+    """Heatmap of the accumulated DTW cost matrix with the warping path overlay."""
+    # Remove the padding row/col used during DP (index 0)
+    matrix = dtw_matrix[1:, 1:]
+    # Replace inf with max finite value for colour mapping
+    finite_vals = matrix[np.isfinite(matrix)]
+    if finite_vals.size > 0:
+        matrix = np.where(np.isfinite(matrix), matrix, finite_vals.max())
+
+    path = np.array(warping_path)
+    fig, ax = plt.subplots(figsize=(6, 5))
+    im = ax.imshow(matrix.T, origin="lower", aspect="auto", cmap="magma_r",
+                   interpolation="nearest")
+    ax.plot(path[:, 0], path[:, 1], color="cyan", linewidth=1.0, alpha=0.85)
+    ax.set_xlabel("Frame Referensi")
+    ax.set_ylabel("Frame Peserta")
+    ax.set_title("DTW Cost Matrix & Warping Path")
+    fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04, label="Accumulated Cost")
+    fig.tight_layout()
+    return fig
+
+
+def plot_waveforms(
+    raw: np.ndarray,
+    vad: np.ndarray | None,
+    normalized: np.ndarray | None,
+    sr: int,
+    title: str,
+):
+    """Plot two preprocessing stages vertically for thesis report.
+
+    Stages shown:
+      1. Sebelum Pre-processing (raw waveform)
+      2. Setelah Pre-processing Lengkap (VAD + normalisasi amplitudo)
+
+    All subplots share a fixed Y-axis [-1, 1] so amplitude differences
+    before/after normalisation are visually obvious.
+    """
+
+    def _fmt_dur(n_samples: int) -> str:
+        """Format duration string: 'Durasi: xx,xx detik'."""
+        dur = n_samples / sr
+        return f"Durasi: {dur:,.2f} detik".replace(",", "X").replace(".", ",").replace("X", ".")
+
+    # Build stage list ---------------------------------------------------
+    stages: list[tuple[np.ndarray, str, str]] = []
+
+    # Stage 1 – Raw
+    stages.append((
+        raw,
+        f"{title} — Sebelum Pre-processing  ({_fmt_dur(len(raw))})",
+        "#4A90D9",
+    ))
+
+    # Stage 2 – After full pre-processing (normalised)
+    if normalized is not None:
+        stages.append((
+            normalized,
+            f"{title} — Setelah Pre-processing Lengkap  ({_fmt_dur(len(normalized))})",
+            "#2ECC71",
+        ))
+    elif vad is not None:
+        # Fallback: show VAD result as final stage if normalised is absent
+        stages.append((
+            vad,
+            f"{title} — Setelah Pre-processing Lengkap  ({_fmt_dur(len(vad))})",
+            "#2ECC71",
+        ))
+
+    n_plots = len(stages)
+    fig, axes = plt.subplots(
+        n_plots, 1,
+        figsize=(8, 1.7 * n_plots + 0.6),
+        sharex=False,
+        sharey=True,
+        constrained_layout=True,
+    )
+    if n_plots == 1:
+        axes = [axes]
+
+    for i, (data, label, color) in enumerate(stages):
+        ax = axes[i]
+        t = np.arange(len(data)) / sr
+        ax.plot(t, data, linewidth=0.35, color=color)
+        ax.set_title(label, fontsize=11, fontweight="bold", pad=6)
+        ax.set_ylabel("Amplitudo", fontsize=10)
+        ax.set_xlim(t[0], t[-1])
+        ax.set_ylim(-1, 1)
+        ax.tick_params(labelsize=9)
+        ax.grid(True, linewidth=0.3, alpha=0.5)
+
+    axes[-1].set_xlabel("Waktu (detik)", fontsize=10)
+
+    return fig
+
+
+def interpret_score(score: float) -> str:
+    """Interpret normalized similarity score."""
+    if score >= 80:
+        return "Sangat Mirip (>80)"
+    elif score >= 65:
+        return "Mirip (65 - 80)"
+    elif score >= 50:
+        return "Cukup Mirip (50 - 65)"
+    else:
+        return "Kurang Mirip (<50)"
+
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+
+st.set_page_config(
+    page_title="Penilaian Kemiripan Bacaan Al-Qur'an - DIROSA WavLM-DTW",
+    layout="centered",
+)
+
+# Tampilkan info device di sidebar
+with st.sidebar:
+    st.markdown("### ⚙️ Info Sistem")
+    st.info(f"**Device:** {get_device_info()}")
+    st.caption("Model WavLM berjalan di GPU jika PyTorch CUDA tersedia, " \
+               "atau fallback ke CPU secara otomatis.")
+
+st.markdown(
+    """
+    <style>
+    /* Mengubah max-width dari block container bawaan Streamlit */
+    .block-container {
+        max-width: 1000px !important;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+st.markdown(
+    "<h3 style='text-align:center;'>"
+    "Metode Penilaian Kemiripan Bacaan Al-Qur'an<br>"
+    "pada Pembelajaran DIROSA &mdash; WavLM + DTW"
+    "</h3>",
+    unsafe_allow_html=True,
+)
+
+st.divider()
+
+tab1, tab2, tab3 = st.tabs(["Single Processing", "Batch Processing (Folder)", "Analisis Korelasi (Overview)"])
+
+with tab1:
+    st.markdown("#### Uji Audio Individu")
+    
+    # Upload section
+    col_ref, col_test = st.columns(2)
+    
+    with col_ref:
+        st.subheader("Audio Referensi")
+        ref_file = st.file_uploader(
+            "Upload audio referensi",
+            type=["wav"],
+            key="ref",
+            label_visibility="collapsed",
+        )
+    
+    with col_test:
+        st.subheader("Audio Peserta")
+        test_file = st.file_uploader(
+            "Upload audio peserta",
+            type=["wav"],
+            key="test",
+            label_visibility="collapsed",
+        )
+    
+    st.write("")  # spacer
+    
+    use_vad = st.checkbox("Aktifkan VAD (Voice Activity Detection)", value=True, key="vad_single",
+                          help="Menghapus bagian hening di awal dan akhir audio sebelum diproses.")
+    
+    show_diagnostics = st.checkbox("Tampilkan diagnostik DTW", value=False,
+                                   help="Menampilkan metrik internal DTW untuk analisis lanjutan.")
+
+    st.write("")
+    st.markdown("#### Parameter Model")
+    select_all_layers = st.checkbox("Pilih Semua Layer (1-12)")
+    
+    if select_all_layers:
+        sel_layers_single = list(range(1, 13))
+        st.multiselect(
+            "Pilih Layer WavLM",
+            options=list(range(1, 13)),
+            default=list(range(1, 13)),
+            disabled=True,
+            help="Semua layer telah dipilih."
+        )
+    else:
+        sel_layers_single = st.multiselect(
+            "Pilih Layer WavLM",
+            options=list(range(1, 13)),
+            default=[9, 10, 11, 12],
+            help="Pilih satu atau lebih layer transformer WavLM (1-12) untuk diekstrak menjadi representasi khusus masing-masing layer."
+        )
+    
+    st.write("")
+    btn = st.button("Proses Penilaian Single", use_container_width=True)
+    
+    # ---------------------------------------------------------------------------
+    # Processing & results
+    # ---------------------------------------------------------------------------
+    
+    if btn:
+        if ref_file is None or test_file is None:
+            st.warning("Upload kedua file audio terlebih dahulu.")
+        elif not sel_layers_single:
+            st.warning("Pilih minimal satu layer WavLM.")
+        else:
+            # Save uploaded files to temp directory
+            tmp_dir = tempfile.mkdtemp()
+            ref_path = os.path.join(tmp_dir, "ref.wav")
+            test_path = os.path.join(tmp_dir, "test.wav")
+    
+            with open(ref_path, "wb") as f:
+                f.write(ref_file.getbuffer())
+            with open(test_path, "wb") as f:
+                f.write(test_file.getbuffer())
+    
+            with st.spinner("Memproses audio ..."):
+                ((results, 
+                 wf_ref_raw, wf_ref_vad, wf_ref_norm,
+                 wf_test_raw, wf_test_vad, wf_test_norm)) = run_pipeline(
+                    ref_path, test_path, use_vad,
+                    layer_indices=sel_layers_single,
+                )
+    
+            sr = 16_000  # pipeline target sample rate
+    
+            # --- Input Validation (Panjang Audio & Keheningan) ----------------
+            ref_raw_np = wf_ref_raw.squeeze().numpy()
+            test_raw_np = wf_test_raw.squeeze().numpy()
+            ref_vad_np = wf_ref_vad.squeeze().numpy() if use_vad else None
+            test_vad_np = wf_test_vad.squeeze().numpy() if use_vad else None
+            ref_norm_np = wf_ref_norm.squeeze().numpy() if use_vad else None
+            test_norm_np = wf_test_norm.squeeze().numpy() if use_vad else None
+
+            ref_dur = len(ref_raw_np) / sr
+            test_dur = len(test_raw_np) / sr
+            if ref_dur < 0.5 or test_dur < 0.5:
+                st.warning("**Peringatan Validation:** Salah satu atau kedua audio sangat pendek (< 0.5 detik). Hasil DTW mungkin menjadi kurang representatif.")
+            
+            silence_threshold = 0.005
+            if np.max(np.abs(ref_raw_np)) < silence_threshold or np.max(np.abs(test_raw_np)) < silence_threshold:
+                st.warning("**Peringatan Validation:** Terdeteksi audio yang hampir tidak bersuara (near-silent). VAD dan DTW kemungkinan kesulitan mencocokkan pola.")
+            
+            # --- Audio Preview ------------------------------------------------
+            st.divider()
+            st.subheader("Preview Audio & Tahapan Pre-Processing")
+            st.caption(
+                "Menampilkan dua tahap sinyal audio: "
+                "**Sebelum Pre-processing** (audio asli) dan "
+                "**Setelah Pre-processing Lengkap** (VAD + normalisasi amplitudo ke [-1, 1]).  \n"
+                "Seluruh grafik menggunakan skala sumbu Y tetap **[-1, 1]** agar perbedaan "
+                "amplitudo sebelum dan sesudah normalisasi terlihat jelas."
+            )
+
+            # --- Referensi ---
+            st.markdown("##### Audio Referensi")
+            fig_ref = plot_waveforms(ref_raw_np, ref_vad_np, ref_norm_np, sr, "Referensi")
+            st.pyplot(fig_ref, use_container_width=True)
+            plt.close(fig_ref)
+            if use_vad and ref_vad_np is not None:
+                dur_raw_ref = len(ref_raw_np) / sr
+                dur_trim_ref = len(ref_vad_np) / sr
+                delta_ref = dur_raw_ref - dur_trim_ref
+                st.caption(
+                    f"📐 **Efek Pre-processing (VAD):** "
+                    f"Durasi asli = {dur_raw_ref:.2f} detik → "
+                    f"Setelah VAD = {dur_trim_ref:.2f} detik "
+                    f"(terpotong {delta_ref:.2f} detik)"
+                )
+            st.audio(ref_norm_np if use_vad else ref_raw_np, sample_rate=sr)
+
+            # --- Peserta ---
+            st.markdown("##### Audio Peserta")
+            fig_test = plot_waveforms(test_raw_np, test_vad_np, test_norm_np, sr, "Peserta")
+            st.pyplot(fig_test, use_container_width=True)
+            plt.close(fig_test)
+            if use_vad and test_vad_np is not None:
+                dur_raw_test = len(test_raw_np) / sr
+                dur_trim_test = len(test_vad_np) / sr
+                delta_test = dur_raw_test - dur_trim_test
+                st.caption(
+                    f"📐 **Efek Pre-processing (VAD):** "
+                    f"Durasi asli = {dur_raw_test:.2f} detik → "
+                    f"Setelah VAD = {dur_trim_test:.2f} detik "
+                    f"(terpotong {delta_test:.2f} detik)"
+                )
+            st.audio(test_norm_np if use_vad else test_raw_np, sample_rate=sr)
+    
+            # --- Aggregated Results -------------------------------------------
+            st.divider()
+            st.subheader("Ringkasan Hasil Penilaian (Agregasi)")
+            
+            scores = {layer: results[layer]["score"] for layer in sel_layers_single}
+            mean_score = sum(scores.values()) / len(scores)
+            best_layer = max(scores, key=scores.get)
+            best_score = scores[best_layer]
+            
+            # --- Durasi Audio dalam ms ---
+            ref_dur_ms = round(len(ref_raw_np) / sr * 1000)
+            test_dur_ms = round(len(test_raw_np) / sr * 1000)
+            ref_dur_vad_ms = round(len(ref_vad_np) / sr * 1000) if ref_vad_np is not None else ref_dur_ms
+            test_dur_vad_ms = round(len(test_vad_np) / sr * 1000) if test_vad_np is not None else test_dur_ms
+
+            col_dur1, col_dur2 = st.columns(2)
+            with col_dur1:
+                st.metric("Durasi Audio Referensi", f"{ref_dur_ms} ms",
+                          delta=f"{ref_dur_vad_ms} ms setelah VAD" if use_vad else None,
+                          delta_color="off")
+            with col_dur2:
+                st.metric("Durasi Audio Peserta", f"{test_dur_ms} ms",
+                          delta=f"{test_dur_vad_ms} ms setelah VAD" if use_vad else None,
+                          delta_color="off")
+
+            col_agg1, col_agg2 = st.columns(2)
+            with col_agg1:
+                st.metric("Skor Rata-rata (Agregasi)", f"{mean_score:.2f} / 100")
+                st.info(f"**Interpretasi:** {interpret_score(mean_score)}")
+            with col_agg2:
+                st.metric(f"Skor Tertinggi (Layer {best_layer})", f"{best_score:.2f} / 100")
+               
+                
+            st.caption("Skor di atas berbasis kalibrasi sigmoid pada jarak _cosine_ DTW.")
+
+            # --- Results Breakdown --------------------------------------------
+            st.divider()
+            st.subheader("Detail per Layer")
+        
+            layer_tabs = st.tabs([f"Layer {l}" for l in sel_layers_single])
+            
+            for idx, layer in enumerate(sel_layers_single):
+                with layer_tabs[idx]:
+                    layer_data = results[layer]
+                    score = layer_data["score"]
+                    warping_path = layer_data["warping_path"]
+                    dtw_matrix = layer_data["dtw_matrix"]
+                    diagnostics = layer_data["diagnostics"]
+
+                    with st.container():
+                        st.metric(f"Skor Kemiripan (Layer {layer})", f"{score:.2f} / 100")
+            
+                    st.write("")  # spacer
+            
+                    with st.container():
+                        fig = plot_alignment(warping_path)
+                        st.pyplot(fig, use_container_width=True)
+                        plt.close(fig)
+            
+                    # --- DTW Diagnostics (optional) -----------------------------------
+                    if show_diagnostics:
+                        st.divider()
+                        st.subheader(f"Diagnostik DTW - Layer {layer}")
+            
+                        d = diagnostics  # shorthand
+                        c1, c2, c3 = st.columns(3)
+                        c1.metric("Raw DTW Distance", f"{d['raw_dtw_distance']:.6f}")
+                        c2.metric("Normalized Distance", f"{d['normalized_distance']:.6f}")
+                        c3.metric("Path Length", d["path_length"])
+            
+                        c4, c5, c6 = st.columns(3)
+                        c4.metric("Frames Referensi", d["num_frames_ref"])
+                        c5.metric("Frames Peserta", d["num_frames_test"])
+                        c6.metric("Sakoe-Chiba Ratio", d["sakoe_chiba_ratio"])
+            
+                        c7, c8, c9 = st.columns(3)
+                        c7.metric("Durasi Ref (detik)", f"{d['ref_duration_sec']:.3f}")
+                        c8.metric("Durasi Peserta (detik)", f"{d['test_duration_sec']:.3f}")
+                        c9.metric("Rasio Durasi", f"{d['duration_ratio']:.4f}")
+            
+                        # Heatmap DTW
+                        st.write("")
+                        fig_hm = plot_dtw_heatmap(dtw_matrix, warping_path)
+                        st.pyplot(fig_hm, use_container_width=True)
+                        plt.close(fig_hm)
+
+
+with tab2:
+    st.markdown("#### Batch Processing (Dari Folder Lokal)")
+    st.info("Fitur ini akan memproses semua audio di folder `audio peserta` dan membandingkannya dengan folder `audio referensi`.")
+    
+    use_vad_batch = st.checkbox("Aktifkan VAD", value=True, key="vad_batch")
+    
+    # Langsung pakai semua layer (1-12)
+    sel_layers = list(range(1, 13))
+    
+    btn_batch = st.button("Jalankan Batch Processing", use_container_width=True)
+    
+    if btn_batch:
+        if not sel_layers:
+            st.warning("Pilih minimal satu layer untuk diproses.")
+        else:
+            peserta_dir = Path("audio peserta")
+            referensi_dir = Path("audio referensi")
+            
+            if not peserta_dir.exists() or not referensi_dir.exists():
+                st.error("Folder `audio peserta` atau `audio referensi` tidak ditemukan di direktori saat ini.")
+            else:
+                with st.spinner("Memproses seluruh audio dalam batch..."):
+                    scorer = load_pipeline()
+                    
+                    pesertas = sorted(
+                        peserta_dir.glob("peserta *"), 
+                        key=lambda x: int(re.search(r"\d+", x.name).group()) if re.search(r"\d+", x.name) else 0
+                    )
+                    
+                    rows = []
+                    prog_bar = st.progress(0)
+                    total_p = len(pesertas)
+                    
+                    for idx_p, p in enumerate(pesertas):
+                        audios = [f for f in p.glob("*.wav") if re.search(r"\d+", f.name)]
+                        audios = sorted(audios, key=lambda x: int(re.search(r"\d+", x.name).group()))
+                        
+                        if not audios:
+                            continue
+                            
+                        for audio in audios:
+                            ref_audio = referensi_dir / audio.name
+                            if not ref_audio.exists(): continue
+                            
+                            detailed_data = scorer.compute_detailed_similarity(
+                                audio_path1=str(ref_audio), 
+                                audio_path2=str(audio), 
+                                use_vad=use_vad_batch, 
+                                layer_indices=sel_layers
+                            )
+                            
+                            row = {
+                                "Peserta": p.name,
+                                "File": audio.name,
+                            }
+                            
+                            for layer in sel_layers:
+                                l_res = detailed_data["results"][layer]
+                                row[f"Score L{layer}"] = round(l_res["score"], 2)
+                                row[f"Dist L{layer}"] = round(l_res["dtw_distance"], 4)
+                            
+                            rows.append(row)
+                            
+                        prog_bar.progress((idx_p + 1) / total_p)
+                
+                if rows:
+                    df = pd.DataFrame(rows)
+                    st.success("Batch processing selesai!")
+                    st.dataframe(df, use_container_width=True)
+                    
+                    csv = df.to_csv(index=False).encode("utf-8")
+                    st.download_button(
+                        label="Download Hasil CSV",
+                        data=csv,
+                        file_name="hasil_batch_multi_layer.csv",
+                        mime="text/csv",
+                        use_container_width=True
+                    )
+                else:
+                    st.warning("Tidak ada data valid yang diproses.")
+
+
+with tab3:
+    st.markdown("#### Analisis Korelasi (Overview)")
+    st.info("Visualisasi hubungan antara skor sistem (DTW) dan penilaian Ustadz (rating).")
+    
+    st.markdown("### Struktur Dataset Pasangan Frasa")
+    csv_path = "dataset_final.csv"
+    if os.path.exists(csv_path):
+        df_pairing = pd.read_csv(csv_path)
+        fig_pairing = plot_pairing_diagram(df_pairing)
+        st.pyplot(fig_pairing, use_container_width=True)
+        plt.close(fig_pairing)
+        
+    st.markdown("""
+    **Penjelasan Singkat:**
+    - Setiap peserta membaca frasa yang sama
+    - Setiap frasa memiliki satu audio referensi
+    - Sistem membandingkan pasangan audio pada frasa yang sama
+    """)
+    st.divider()
+    
+    
+    if not os.path.exists(csv_path):
+        st.warning(f"File {csv_path} tidak ditemukan. Jalankan grid_search atau buat dataset terlebih dahulu.")
+    else:
+        with st.spinner("Menjalankan analisis korelasi..."):
+            df, df_results = run_correlation_analysis(csv_path)
+            
+            # Cari best layer (Spearman tertinggi)
+            best_idx = df_results['spearman_rho'].idxmax()
+            best_layer_name = df_results.loc[best_idx, 'layer']
+            best_spearman = df_results.loc[best_idx, 'spearman_rho']
+            
+            st.subheader(f"Data Korelasi Per Layer")
+            st.dataframe(df_results, use_container_width=True)
+            
+            st.markdown(f"**Layer Terbaik:** `{best_layer_name}` dengan korelasi Spearman **{best_spearman:.4f}**")
+            
+            st.subheader("Bar Chart: Spearman Rho")
+            fig_bar = plot_correlation_bar(df_results)
+            st.pyplot(fig_bar, use_container_width=True)
+            plt.close(fig_bar)
+            
+            st.subheader(f"Scatter Plot: {best_layer_name} vs Rating")
+            fig_scatter = plot_scatter_best_layer(df, best_layer_name)
+            st.pyplot(fig_scatter, use_container_width=True)
+            plt.close(fig_scatter)
+            
+            st.subheader("Heatmap Korelasi")
+            fig_hm = plot_heatmap(df_results)
+            st.pyplot(fig_hm, use_container_width=True)
+            plt.close(fig_hm)

audio_loader.py

@@ -0,0 +1,331 @@
+"""Audio Loader Module.
+
+Loads and preprocesses WAV audio files for the similarity pipeline.
+
+Notes:
+- This pipeline uses a strict single-backend mechanism (torchaudio) for reading audio. 
+  This methodological decision ensures strict experimental reproducibility by 
+  avoiding backend-dependent variations in decoding or numerical representation.
+- Optional WebRTC VAD-based endpoint trimming removes leading/trailing silence
+  without cutting internal pauses.
+"""
+
+from __future__ import annotations
+
+import struct
+from typing import Tuple
+
+import numpy as np
+import torch
+import torchaudio
+
+try:
+    import soundfile as sf  # type: ignore
+
+    _SOUNDFILE_AVAILABLE = True
+except ImportError:
+    _SOUNDFILE_AVAILABLE = False
+
+try:
+    import webrtcvad  # type: ignore
+
+    _WEBRTCVAD_AVAILABLE = True
+except ImportError:
+    _WEBRTCVAD_AVAILABLE = False
+
+
+class AudioLoader:
+    """Loads and preprocesses audio files."""
+
+    def __init__(
+        self,
+        target_sr: int = 16000,
+        use_vad: bool = True,
+        vad_mode: int = 1,
+        vad_frame_ms: int = 10,
+        vad_onset_frames: int = 2,
+        vad_offset_frames: int = 4,
+        energy_trim_threshold: float = 0.06,
+    ):
+        """
+        Initialize AudioLoader.
+
+        Args:
+            target_sr: Target sampling rate (default: 16000 Hz for WavLM).
+            use_vad: If True, apply WebRTC VAD endpoint trimming to strip
+                leading/trailing silence.
+            vad_mode: WebRTC VAD aggressiveness (0–3). 1–2 recommended.
+            vad_frame_ms: Frame length in ms for VAD (10, 20, or 30).
+            vad_onset_frames: Minimum consecutive voiced frames to detect
+                speech onset (hysteresis).
+            vad_offset_frames: Minimum consecutive unvoiced frames to detect
+                speech offset (hysteresis).
+            energy_trim_threshold: Fraction of peak absolute amplitude used
+                as threshold for energy-based refinement after VAD (0.0–1.0).
+                Frames with amplitude below this fraction of the local peak
+                are trimmed from the head and tail.
+        """
+        self.target_sr = target_sr
+        self.use_vad = use_vad
+        self.vad_mode = vad_mode
+        self.vad_frame_ms = vad_frame_ms
+        self.vad_onset_frames = vad_onset_frames
+        self.vad_offset_frames = vad_offset_frames
+        self.energy_trim_threshold = energy_trim_threshold
+    
+    @staticmethod
+    def _load_with_soundfile(audio_path: str) -> Tuple[torch.Tensor, int]:
+        """Fallback loader using soundfile (libsndfile).
+        
+        Used when torchaudio's default backend (torchcodec) is unavailable,
+        e.g. on systems without FFmpeg DLLs.  Produces identical float32
+        waveform tensors for WAV files.
+        """
+        if not _SOUNDFILE_AVAILABLE:
+            raise ImportError(
+                "soundfile is not installed. Install it with: pip install soundfile"
+            )
+        data, sample_rate = sf.read(audio_path, dtype="float32", always_2d=True)
+        # soundfile returns (num_samples, channels) → transpose to (channels, num_samples)
+        waveform = torch.from_numpy(data.T)
+        return waveform, sample_rate
+
+    def load_audio(self, audio_path: str) -> Tuple[torch.Tensor, int]:
+        """
+        Load audio file and resample if necessary.
+        
+        Uses soundfile (libsndfile) as the primary loader because
+        torchaudio ≥2.11 requires torchcodec + FFmpeg DLLs which are
+        often unavailable on Windows.  soundfile handles WAV natively
+        and produces identical float32 results.
+        
+        Falls back to torchaudio.load() if soundfile is unavailable.
+        
+        Args:
+            audio_path: Path to WAV audio file
+            
+        Returns:
+            Tuple of (waveform tensor, sample_rate)
+            waveform shape: (1, num_samples) for mono
+            
+        Raises:
+            RuntimeError: If both soundfile and torchaudio fail to read the audio file.
+        """
+        # Primary: soundfile (no FFmpeg dependency, handles WAV natively)
+        try:
+            waveform, sample_rate = self._load_with_soundfile(audio_path)
+        except Exception as sf_err:
+            # Fallback: torchaudio (needs torchcodec/FFmpeg on ≥2.11)
+            try:
+                waveform, sample_rate = torchaudio.load(audio_path)
+            except Exception as torchaudio_err:
+                raise RuntimeError(
+                    f"Failed to read audio file '{audio_path}'. "
+                    f"soundfile error: {sf_err} | "
+                    f"torchaudio error: {torchaudio_err}"
+                )
+        
+        # Convert to mono if stereo
+        if waveform.shape[0] > 1:
+            waveform = torch.mean(waveform, dim=0, keepdim=True)
+        
+        # Resample if necessary
+        if sample_rate != self.target_sr:
+            resampler = torchaudio.transforms.Resample(
+                orig_freq=sample_rate, 
+                new_freq=self.target_sr
+            )
+            waveform = resampler(waveform)
+            sample_rate = self.target_sr
+        
+        return waveform, sample_rate
+    
+    # ------------------------------------------------------------------
+    # VAD-based endpoint trimming
+    # ------------------------------------------------------------------
+
+    def vad_trim_endpoints(
+        self, waveform: torch.Tensor, sample_rate: int
+    ) -> torch.Tensor:
+        """Trim leading and trailing silence using WebRTC VAD.
+
+        Only the outermost silent segments are removed; internal pauses
+        (e.g. between words or ayat) are preserved intact.
+
+        The algorithm uses a hysteresis mechanism:
+        * **Onset**: the first sample of the first window in a run of at
+          least ``vad_onset_frames`` consecutive *voiced* frames is taken
+          as the speech start.
+        * **Offset**: the last sample of the last *voiced* frame before a
+          run of at least ``vad_offset_frames`` consecutive *unvoiced*
+          frames that extends to the end of the signal is taken as the
+          speech end.
+
+        Args:
+            waveform: Mono waveform tensor of shape ``(1, num_samples)``
+                in float32 (values in roughly [-1, 1]).
+            sample_rate: Must be 8000, 16000, 32000, or 48000.
+
+        Returns:
+            Trimmed waveform tensor ``(1, trimmed_samples)``, float32.
+        """
+        if not _WEBRTCVAD_AVAILABLE:
+            raise ImportError(
+                "webrtcvad is not installed but VAD trimming was requested. "
+                "Please install it with: pip install webrtcvad"
+            )
+
+        # --- prepare int16 PCM bytes for webrtcvad -----------------------
+        audio_np: np.ndarray = waveform.squeeze(0).numpy()  # (num_samples,)
+        # Clip and convert float32 -> int16
+        pcm_int16 = np.clip(audio_np * 32767, -32768, 32767).astype(np.int16)
+
+        frame_len = int(sample_rate * self.vad_frame_ms / 1000)  # samples per frame
+        num_frames = len(pcm_int16) // frame_len
+
+        if num_frames == 0:
+            return waveform  # too short to analyse
+
+        vad = webrtcvad.Vad(self.vad_mode)
+
+        # --- per-frame voiced/unvoiced labels ----------------------------
+        is_voiced: list[bool] = []
+        for i in range(num_frames):
+            start = i * frame_len
+            end = start + frame_len
+            frame_bytes = struct.pack(f"<{frame_len}h", *pcm_int16[start:end])
+            is_voiced.append(vad.is_speech(frame_bytes, sample_rate))
+
+        # --- onset detection (left-to-right) -----------------------------
+        speech_start_frame: int = 0
+        consecutive_voiced = 0
+        for idx, voiced in enumerate(is_voiced):
+            if voiced:
+                consecutive_voiced += 1
+                if consecutive_voiced >= self.vad_onset_frames:
+                    speech_start_frame = idx - self.vad_onset_frames + 1
+                    break
+            else:
+                consecutive_voiced = 0
+        else:
+            # No onset found – return original waveform (all silence?)
+            return waveform
+
+        # --- offset detection (right-to-left) ----------------------------
+        trailing_unvoiced = 0
+        for idx in range(num_frames - 1, -1, -1):
+            if not is_voiced[idx]:
+                trailing_unvoiced += 1
+            else:
+                break
+
+        if trailing_unvoiced >= self.vad_offset_frames:
+            speech_end_frame = num_frames - trailing_unvoiced - 1
+        else:
+            speech_end_frame = num_frames - 1  # no significant trailing silence
+
+        # Sanity: ensure start <= end
+        if speech_start_frame > speech_end_frame:
+            return waveform
+
+        # --- reconstruct trimmed waveform --------------------------------
+        start_sample = speech_start_frame * frame_len
+        end_sample = (speech_end_frame + 1) * frame_len
+        end_sample = min(end_sample, waveform.shape[1])
+
+        trimmed = waveform[:, start_sample:end_sample]
+
+        # Guard against empty result
+        if trimmed.shape[1] == 0:
+            return waveform
+
+        # --- energy-based refinement -------------------------------------
+        trimmed = self._energy_refine(trimmed)
+
+        return trimmed
+
+    def _energy_refine(self, waveform: torch.Tensor) -> torch.Tensor:
+        """Refine VAD boundaries by trimming low-energy head/tail.
+
+        Uses a short-window RMS envelope to find the first and last
+        sample whose energy exceeds ``energy_trim_threshold`` of the
+        peak RMS value.  This removes residual breath or resonance
+        that WebRTC VAD may leave behind.
+
+        Args:
+            waveform: Mono waveform ``(1, num_samples)``.
+
+        Returns:
+            Refined waveform ``(1, refined_samples)``.
+        """
+        if self.energy_trim_threshold <= 0.0:
+            return waveform
+
+        audio = waveform.squeeze(0).numpy()  # (num_samples,)
+        abs_env = np.abs(audio)
+
+        # Short-window RMS (window ≈ 10 ms)
+        win = max(int(self.target_sr * 0.01), 1)
+        # Cumulative sum trick for fast moving average of squared signal
+        sq = audio.astype(np.float64) ** 2
+        cs = np.concatenate(([0.0], np.cumsum(sq)))
+        rms = np.sqrt((cs[win:] - cs[:-win]) / win).astype(np.float32)
+
+        if len(rms) == 0:
+            return waveform
+
+        peak_rms = rms.max()
+        if peak_rms == 0:
+            return waveform
+
+        threshold = self.energy_trim_threshold * peak_rms
+
+        # Find first and last frame above threshold
+        above = np.where(rms >= threshold)[0]
+        if len(above) == 0:
+            return waveform
+
+        start = int(above[0])
+        end = int(above[-1]) + win  # include the window trailing edge
+        end = min(end, len(audio))
+
+        refined = waveform[:, start:end]
+        if refined.shape[1] == 0:
+            return waveform
+
+        return refined
+
+    def normalize_audio(self, waveform: torch.Tensor) -> torch.Tensor:
+        """
+        Normalize audio waveform to [-1, 1] range.
+        
+        Args:
+            waveform: Audio waveform tensor
+            
+        Returns:
+            Normalized waveform
+        """
+        # Normalize to [-1, 1]
+        max_val = torch.max(torch.abs(waveform))
+        if max_val > 0:
+            waveform = waveform / max_val
+        return waveform
+    
+    def load_and_preprocess(self, audio_path: str) -> torch.Tensor:
+        """
+        Load and preprocess audio in one step.
+        
+        Args:
+            audio_path: Path to WAV audio file
+            
+        Returns:
+            Preprocessed waveform tensor (1, num_samples)
+        """
+        waveform, sr = self.load_audio(audio_path)
+
+        # VAD endpoint trimming (after resampling, before normalisation)
+        if self.use_vad:
+            waveform = self.vad_trim_endpoints(waveform, sr)
+
+        waveform = self.normalize_audio(waveform)
+        return waveform

correlation_analysis.py

@@ -0,0 +1,157 @@
+import pandas as pd
+import scipy.stats as stats
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+def interpret_correlation(rho):
+    abs_rho = abs(rho)
+    if abs_rho < 0.20:
+        return 'sangat lemah'
+    elif abs_rho < 0.40:
+        return 'lemah'
+    elif abs_rho < 0.60:
+        return 'sedang'
+    elif abs_rho < 0.80:
+        return 'kuat'
+    else:
+        return 'sangat kuat'
+
+def run_correlation_analysis(csv_path: str):
+    df = pd.read_csv(csv_path)
+    
+    results = []
+    
+    for layer in range(1, 13):
+        col_name = f'Score L{layer}'
+        
+        # Dropna just in case
+        valid_data = df.dropna(subset=[col_name, 'rating'])
+        
+        spearman_rho, spearman_p = stats.spearmanr(valid_data[col_name], valid_data['rating'])
+        pearson_r, pearson_p = stats.pearsonr(valid_data[col_name], valid_data['rating'])
+        
+        interpretation = interpret_correlation(spearman_rho)
+        
+        results.append({
+            'layer': col_name,
+            'spearman_rho': spearman_rho,
+            'spearman_p': spearman_p,
+            'pearson_r': pearson_r,
+            'pearson_p': pearson_p,
+            'interpretasi_spearman': interpretation
+        })
+        
+    df_results = pd.DataFrame(results)
+    return df, df_results
+
+def plot_correlation_bar(df_corr):
+    fig, ax = plt.subplots(figsize=(10, 6))
+    
+    ax.bar(df_corr['layer'], df_corr['spearman_rho'])
+    ax.set_title('Korelasi Spearman (rho) per Layer vs Rating Ustadz')
+    ax.set_xlabel('Layer')
+    ax.set_ylabel('Spearman rho')
+    plt.xticks(rotation=45)
+    
+    fig.tight_layout()
+    return fig
+
+def plot_scatter_best_layer(df, best_layer):
+    fig, ax = plt.subplots(figsize=(8, 6))
+    
+    valid_data = df.dropna(subset=[best_layer, 'rating'])
+    x = valid_data[best_layer]
+    y = valid_data['rating']
+    
+    ax.scatter(x, y, alpha=0.5, label='Data points')
+    
+    # Linear regression line
+    m, b = np.polyfit(x, y, 1)
+    ax.plot(x, m*x + b, label=f'Trend line')
+    
+    ax.set_title(f'Scatter Plot: {best_layer} vs Rating Ustadz')
+    ax.set_xlabel(f'Skor Sistem ({best_layer})')
+    ax.set_ylabel('Rating Ustadz')
+    ax.legend()
+    
+    fig.tight_layout()
+    return fig
+
+def plot_heatmap(df_corr):
+    fig, ax = plt.subplots(figsize=(10, 4))
+    
+    # Create a simple heatmap
+    data = df_corr[['spearman_rho', 'pearson_r']].values.T
+    cax = ax.imshow(data, aspect='auto')
+    
+    # Add values
+    for i in range(data.shape[0]):
+        for j in range(data.shape[1]):
+            ax.text(j, i, f'{data[i, j]:.2f}', ha='center', va='center', color='black')
+            
+    ax.set_yticks([0, 1])
+    ax.set_yticklabels(['Spearman rho', 'Pearson r'])
+    ax.set_xticks(range(len(df_corr)))
+    ax.set_xticklabels(df_corr['layer'], rotation=45)
+    ax.set_title('Heatmap Korelasi')
+    
+    fig.colorbar(cax)
+    fig.tight_layout()
+    return fig
+
+def plot_pairing_diagram(df):
+    # Get unique participants and files 
+    participants = df['ID_Peserta'].unique()[:1]
+    files = df['ID_Frasa'].unique()
+
+    # Sesuaikan ukuran agar tidak terlalu bertumpuk jika datanya banyak
+    height = max(5, max(len(participants), len(files)) * 0.4)
+    fig, ax = plt.subplots(figsize=(12, height))
+    
+    # Positions
+    x_peserta = 1
+    x_frasa = 2
+    x_ref = 3
+    
+    # Draw nodes
+    y_peserta = np.linspace(len(files), 1, len(files))
+    y_frasa = np.linspace(len(files), 1, len(files))
+    y_ref = np.linspace(len(files), 1, len(files))
+    
+    # Peserta nodes
+    ax.scatter([x_peserta]*len(files), y_peserta, s=200, zorder=2)
+    if len(participants) > 0:
+        p_name = participants[0]
+        for i, f in enumerate(files):
+            ax.annotate(f"Peserta {p_name} (Rekaman {i+1})", (x_peserta - 0.1, y_peserta[i]), ha='right', va='center', fontsize=10)
+        
+    # Frasa nodes
+    ax.scatter([x_frasa]*len(files), y_frasa, s=200, zorder=2)
+    for i, f in enumerate(files):
+        # f is filename, format slightly for display e.g. "01.wav" -> "Frasa 1"
+        frasa_label = f"Frasa {i+1}"
+        ax.annotate(frasa_label, (x_frasa, y_frasa[i] + 0.15), ha='center', va='bottom', fontsize=10)
+        
+    # Referensi nodes
+    ax.scatter([x_ref]*len(files), y_ref, s=200, zorder=2)
+    for i, f in enumerate(files):
+        ax.annotate(f"Referensi {i+1}", (x_ref + 0.1, y_ref[i]), ha='left', va='center', fontsize=10)
+        
+    # Draw lines
+    for j, _ in enumerate(files):
+        # Peserta to Frasa
+        ax.plot([x_peserta, x_frasa], [y_peserta[j], y_frasa[j]], zorder=1, alpha=0.5)
+            
+    for j, _ in enumerate(files):
+        # Frasa to Referensi
+        ax.plot([x_frasa, x_ref], [y_frasa[j], y_ref[j]], zorder=1, alpha=0.5)
+        
+    peserta_name = participants[0] if len(participants) > 0 else "Peserta"
+    ax.set_title(f"Ilustrasi Struktur Dataset Pasangan Frasa", fontsize=14)
+    ax.set_xlim(0.5, 3.5)
+    ax.set_ylim(0, len(files) + 1)
+    ax.axis('off')
+    
+    fig.tight_layout()
+    return fig

create_dataset.py

@@ -0,0 +1,42 @@
+import pandas as pd
+import re
+
+# Load data
+scores = pd.read_csv('hasil_batch_multi_layer.csv')
+ratings = pd.read_csv('ratings_rows Yunan.csv')
+
+# Preprocess scores: extract numeric ID from 'Peserta'
+def get_peserta_id(p):
+    match = re.search(r'\d+', p)
+    return int(match.group()) if match else None
+
+scores['ID_Peserta'] = scores['Peserta'].apply(get_peserta_id)
+scores['ID_Frasa'] = scores['File']
+
+# Preprocess ratings
+ratings['ID_Peserta'] = ratings['peserta_id']
+ratings['ID_Frasa'] = ratings['audio_filename']
+
+# Select relevant columns from scores
+score_cols = [f'Score L{i}' for i in range(1, 13)]
+scores = scores[['ID_Peserta', 'ID_Frasa'] + score_cols]
+
+# Select relevant columns from ratings
+ratings = ratings[['ID_Peserta', 'ID_Frasa', 'rating']]
+
+# Merge
+final = pd.merge(scores, ratings, on=['ID_Peserta', 'ID_Frasa'], how='inner')
+
+# Create ID_Pasangan
+final['ID_Pasangan'] = final['ID_Peserta'].astype(str) + '_' + final['ID_Frasa']
+
+# Rearrange columns
+cols = ['ID_Pasangan', 'ID_Peserta', 'ID_Frasa'] + score_cols + ['rating']
+final = final[cols]
+
+# Drop duplicates if any and non-matching rows are already dropped by inner join
+final = final.dropna().sort_values(['ID_Peserta', 'ID_Frasa'])
+
+# Save
+final.to_csv('dataset_final.csv', index=False)
+print('Shape dataset final:', final.shape)

dataset_final.csv

@@ -0,0 +1,101 @@
+ID_Pasangan,ID_Peserta,ID_Frasa,Score L1,Score L2,Score L3,Score L4,Score L5,Score L6,Score L7,Score L8,Score L9,Score L10,Score L11,Score L12,rating
+1_Dirosa Pertemuan 1.wav,1,Dirosa Pertemuan 1.wav,13.6,20.17,24.53,26.52,32.37,39.27,47.88,53.81,58.2,56.47,65.76,61.99,3
+1_Dirosa Pertemuan 10.wav,1,Dirosa Pertemuan 10.wav,17.34,26.43,30.16,33.24,40.28,47.93,56.92,61.51,63.94,63.14,69.73,66.99,4
+1_Dirosa Pertemuan 11.wav,1,Dirosa Pertemuan 11.wav,14.07,24.27,27.84,32.44,39.95,46.9,59.25,61.78,64.99,64.77,71.67,65.42,3
+1_Dirosa Pertemuan 12.wav,1,Dirosa Pertemuan 12.wav,12.63,17.47,19.0,22.53,29.65,37.42,44.16,49.75,56.08,55.35,64.22,59.29,3
+1_Dirosa Pertemuan 13.wav,1,Dirosa Pertemuan 13.wav,8.63,15.6,18.58,21.73,30.35,39.15,50.85,56.37,62.1,64.32,69.91,66.51,2
+1_Dirosa Pertemuan 14.wav,1,Dirosa Pertemuan 14.wav,12.04,22.77,26.99,29.98,38.25,49.92,63.03,70.49,74.67,76.39,79.34,79.7,4
+1_Dirosa Pertemuan 15.wav,1,Dirosa Pertemuan 15.wav,12.01,20.28,23.0,28.08,35.62,43.93,54.63,61.31,66.31,67.74,72.92,70.79,3
+1_Dirosa Pertemuan 16.wav,1,Dirosa Pertemuan 16.wav,6.76,12.12,13.74,14.85,21.03,28.84,40.29,48.96,56.82,60.38,65.39,65.14,3
+1_Dirosa Pertemuan 17.wav,1,Dirosa Pertemuan 17.wav,9.24,14.61,17.27,19.42,26.74,34.83,44.96,50.64,57.8,59.55,65.92,65.83,3
+1_Dirosa Pertemuan 18.wav,1,Dirosa Pertemuan 18.wav,10.58,20.2,26.37,29.61,36.87,43.18,51.53,55.18,60.31,62.85,66.78,63.58,2
+1_Dirosa Pertemuan 19.wav,1,Dirosa Pertemuan 19.wav,8.23,19.22,23.5,24.63,31.71,36.86,43.47,49.24,53.12,49.6,56.23,41.71,2
+1_Dirosa Pertemuan 2.wav,1,Dirosa Pertemuan 2.wav,13.3,19.62,22.99,25.19,32.36,40.23,48.74,53.94,59.5,58.87,66.68,62.57,2
+1_Dirosa Pertemuan 20.wav,1,Dirosa Pertemuan 20.wav,19.18,37.95,45.48,50.08,54.58,61.63,70.07,74.09,77.73,76.7,80.52,76.76,3
+1_Dirosa Pertemuan 3.wav,1,Dirosa Pertemuan 3.wav,8.31,14.56,17.39,21.17,28.35,34.5,42.47,48.12,50.83,48.44,60.32,52.11,2
+1_Dirosa Pertemuan 4.wav,1,Dirosa Pertemuan 4.wav,19.58,28.28,30.31,35.78,44.94,53.27,61.89,67.04,69.55,69.05,75.38,71.11,4
+1_Dirosa Pertemuan 5.wav,1,Dirosa Pertemuan 5.wav,12.92,21.33,23.35,26.32,33.49,42.35,51.21,54.85,59.45,60.72,66.01,65.19,3
+1_Dirosa Pertemuan 6.wav,1,Dirosa Pertemuan 6.wav,14.6,22.29,26.08,28.7,36.26,45.44,54.97,60.74,65.86,66.6,72.3,71.01,3
+1_Dirosa Pertemuan 7.wav,1,Dirosa Pertemuan 7.wav,8.74,13.66,15.32,16.97,22.7,29.73,39.65,45.88,52.22,54.26,62.38,60.79,2
+1_Dirosa Pertemuan 8.wav,1,Dirosa Pertemuan 8.wav,13.51,25.21,28.52,31.44,40.68,49.95,59.99,66.02,69.66,70.9,74.66,74.14,4
+1_Dirosa Pertemuan 9.wav,1,Dirosa Pertemuan 9.wav,6.82,10.36,12.68,13.24,20.47,30.12,42.0,51.56,59.14,61.76,67.8,68.99,4
+2_Dirosa Pertemuan 1.wav,2,Dirosa Pertemuan 1.wav,6.78,11.7,14.5,17.7,21.21,24.17,28.36,35.18,40.52,41.2,45.39,44.95,1
+2_Dirosa Pertemuan 10.wav,2,Dirosa Pertemuan 10.wav,12.58,20.55,23.85,28.25,34.22,37.34,44.55,46.24,49.0,46.16,56.52,49.19,1
+2_Dirosa Pertemuan 11.wav,2,Dirosa Pertemuan 11.wav,8.3,15.52,17.48,19.38,21.3,23.09,29.72,29.62,32.11,31.75,39.61,33.71,1
+2_Dirosa Pertemuan 12.wav,2,Dirosa Pertemuan 12.wav,4.07,4.93,5.16,5.11,6.32,7.1,7.91,9.14,12.55,12.26,21.03,16.06,1
+2_Dirosa Pertemuan 13.wav,2,Dirosa Pertemuan 13.wav,4.24,7.52,8.91,9.55,11.61,15.08,20.38,25.66,32.07,31.37,40.82,34.78,1
+2_Dirosa Pertemuan 14.wav,2,Dirosa Pertemuan 14.wav,7.18,12.8,14.38,14.12,19.26,24.77,33.13,38.32,44.38,47.06,56.23,53.9,2
+2_Dirosa Pertemuan 15.wav,2,Dirosa Pertemuan 15.wav,4.56,6.91,8.65,10.19,11.83,14.54,19.05,23.19,27.43,27.58,37.44,31.89,1
+2_Dirosa Pertemuan 16.wav,2,Dirosa Pertemuan 16.wav,3.85,5.57,6.22,6.64,9.7,14.27,19.91,24.15,30.64,33.65,42.3,38.45,1
+2_Dirosa Pertemuan 17.wav,2,Dirosa Pertemuan 17.wav,7.27,9.34,10.98,11.98,17.54,23.62,29.81,34.14,42.74,44.64,49.81,52.59,1
+2_Dirosa Pertemuan 18.wav,2,Dirosa Pertemuan 18.wav,6.91,13.71,15.91,17.08,20.35,22.73,27.42,29.97,33.81,35.8,45.71,38.25,1
+2_Dirosa Pertemuan 19.wav,2,Dirosa Pertemuan 19.wav,7.72,15.18,17.31,16.28,18.87,20.41,25.05,28.32,37.05,36.54,43.07,28.68,1
+2_Dirosa Pertemuan 2.wav,2,Dirosa Pertemuan 2.wav,6.91,11.15,13.18,15.0,18.37,20.67,24.16,28.06,33.0,33.58,35.08,34.03,1
+2_Dirosa Pertemuan 20.wav,2,Dirosa Pertemuan 20.wav,18.58,34.0,38.24,40.68,45.13,48.68,55.71,57.44,61.47,59.89,68.17,60.68,1
+2_Dirosa Pertemuan 3.wav,2,Dirosa Pertemuan 3.wav,5.5,7.99,8.24,8.53,11.74,14.05,18.67,25.15,29.64,30.83,43.83,34.59,1
+2_Dirosa Pertemuan 4.wav,2,Dirosa Pertemuan 4.wav,12.33,22.23,24.28,28.17,33.54,36.03,39.83,42.63,46.51,47.1,48.9,50.72,2
+2_Dirosa Pertemuan 5.wav,2,Dirosa Pertemuan 5.wav,6.46,11.59,12.91,13.4,15.67,17.68,19.7,21.91,25.71,27.04,28.71,31.21,1
+2_Dirosa Pertemuan 6.wav,2,Dirosa Pertemuan 6.wav,7.03,9.96,10.61,11.44,14.21,17.64,23.44,27.6,32.97,34.94,44.54,39.75,1
+2_Dirosa Pertemuan 7.wav,2,Dirosa Pertemuan 7.wav,3.57,5.21,5.86,6.04,8.09,9.42,12.24,15.18,21.46,23.38,31.26,27.68,1
+2_Dirosa Pertemuan 8.wav,2,Dirosa Pertemuan 8.wav,7.24,11.98,13.58,15.25,18.72,22.6,29.15,36.38,43.63,45.32,54.88,51.11,2
+2_Dirosa Pertemuan 9.wav,2,Dirosa Pertemuan 9.wav,5.53,8.49,8.95,9.11,12.49,17.4,22.47,28.61,34.22,35.84,42.72,42.15,1
+3_Dirosa Pertemuan 1.wav,3,Dirosa Pertemuan 1.wav,12.72,18.38,21.48,23.81,29.23,36.19,47.04,55.7,63.21,64.75,73.59,71.21,3
+3_Dirosa Pertemuan 10.wav,3,Dirosa Pertemuan 10.wav,14.85,21.1,25.74,27.92,32.29,39.04,44.67,49.6,53.09,55.77,65.94,62.44,1
+3_Dirosa Pertemuan 11.wav,3,Dirosa Pertemuan 11.wav,16.06,25.19,27.41,30.97,35.93,42.27,52.77,57.3,61.78,63.21,70.63,65.62,3
+3_Dirosa Pertemuan 12.wav,3,Dirosa Pertemuan 12.wav,10.9,15.2,17.0,19.71,23.3,25.22,26.97,34.33,42.21,44.63,57.5,51.49,1
+3_Dirosa Pertemuan 13.wav,3,Dirosa Pertemuan 13.wav,6.48,10.69,12.09,14.46,18.88,27.3,36.61,45.82,52.99,54.97,61.41,57.36,2
+3_Dirosa Pertemuan 14.wav,3,Dirosa Pertemuan 14.wav,7.75,13.54,15.94,17.38,23.58,32.52,44.31,53.79,61.13,63.99,69.28,67.19,3
+3_Dirosa Pertemuan 15.wav,3,Dirosa Pertemuan 15.wav,6.62,10.98,13.05,15.51,19.44,24.38,31.32,38.62,46.76,48.06,56.08,51.99,3
+3_Dirosa Pertemuan 16.wav,3,Dirosa Pertemuan 16.wav,6.64,9.6,10.28,10.35,13.58,18.98,25.99,34.44,43.43,48.15,54.38,54.21,3
+3_Dirosa Pertemuan 17.wav,3,Dirosa Pertemuan 17.wav,7.51,11.32,12.89,13.92,19.26,26.52,36.04,44.96,54.12,55.92,63.72,63.39,2
+3_Dirosa Pertemuan 18.wav,3,Dirosa Pertemuan 18.wav,13.76,22.43,24.38,25.92,29.31,31.68,36.5,40.85,46.38,51.24,58.98,53.43,2
+3_Dirosa Pertemuan 19.wav,3,Dirosa Pertemuan 19.wav,6.42,11.28,11.37,10.92,12.15,11.63,14.56,20.51,23.8,25.04,34.3,22.2,1
+3_Dirosa Pertemuan 2.wav,3,Dirosa Pertemuan 2.wav,9.5,12.29,14.1,15.66,20.48,25.39,33.6,42.53,48.74,49.9,60.26,56.71,2
+3_Dirosa Pertemuan 20.wav,3,Dirosa Pertemuan 20.wav,18.95,35.73,40.83,43.55,46.64,51.21,60.13,65.12,70.88,70.19,76.14,72.14,2
+3_Dirosa Pertemuan 3.wav,3,Dirosa Pertemuan 3.wav,7.18,9.69,9.08,9.08,12.48,14.31,18.19,22.32,28.92,29.05,41.3,31.33,2
+3_Dirosa Pertemuan 4.wav,3,Dirosa Pertemuan 4.wav,9.05,12.87,15.73,18.91,23.16,28.47,36.29,42.92,48.23,50.43,60.99,57.68,3
+3_Dirosa Pertemuan 5.wav,3,Dirosa Pertemuan 5.wav,7.92,10.57,10.83,11.37,14.91,19.69,25.25,30.03,36.17,38.16,48.29,45.1,2
+3_Dirosa Pertemuan 6.wav,3,Dirosa Pertemuan 6.wav,8.23,12.28,13.99,15.02,18.46,24.25,33.14,39.28,46.46,49.25,58.9,55.04,2
+3_Dirosa Pertemuan 7.wav,3,Dirosa Pertemuan 7.wav,6.34,8.97,10.02,10.65,13.92,17.86,23.89,29.83,37.82,42.63,52.51,47.81,2
+3_Dirosa Pertemuan 8.wav,3,Dirosa Pertemuan 8.wav,8.82,12.85,14.15,17.0,21.47,28.1,36.2,42.23,48.83,51.25,61.76,60.55,3
+3_Dirosa Pertemuan 9.wav,3,Dirosa Pertemuan 9.wav,4.33,7.12,8.24,8.51,12.32,19.6,29.1,38.09,47.55,50.29,59.1,56.03,2
+4_Dirosa Pertemuan 1.wav,4,Dirosa Pertemuan 1.wav,6.65,11.64,13.52,16.12,19.01,22.88,29.66,38.34,43.77,44.45,53.45,50.8,2
+4_Dirosa Pertemuan 10.wav,4,Dirosa Pertemuan 10.wav,6.22,13.33,15.91,18.8,20.56,23.82,28.62,33.5,36.47,37.09,43.45,40.45,1
+4_Dirosa Pertemuan 11.wav,4,Dirosa Pertemuan 11.wav,4.52,10.06,11.75,14.22,15.18,18.27,24.91,26.13,30.63,32.06,44.53,37.92,1
+4_Dirosa Pertemuan 12.wav,4,Dirosa Pertemuan 12.wav,2.34,3.63,4.04,4.45,5.24,6.47,8.01,9.56,13.37,13.02,20.02,16.36,1
+4_Dirosa Pertemuan 13.wav,4,Dirosa Pertemuan 13.wav,5.14,10.05,13.14,15.53,20.55,28.84,39.24,46.97,54.4,56.08,57.29,58.89,1
+4_Dirosa Pertemuan 14.wav,4,Dirosa Pertemuan 14.wav,9.16,15.85,18.21,17.93,23.42,33.43,42.18,47.9,55.19,57.14,61.75,63.03,1
+4_Dirosa Pertemuan 15.wav,4,Dirosa Pertemuan 15.wav,4.81,9.87,12.7,14.85,17.67,21.68,28.88,36.44,42.75,43.24,50.08,46.68,1
+4_Dirosa Pertemuan 16.wav,4,Dirosa Pertemuan 16.wav,3.96,6.52,7.42,7.63,10.08,13.63,18.52,25.58,30.6,34.11,39.11,39.49,1
+4_Dirosa Pertemuan 17.wav,4,Dirosa Pertemuan 17.wav,4.35,5.47,6.79,8.1,10.73,13.08,15.35,19.95,25.92,29.01,35.24,33.98,1
+4_Dirosa Pertemuan 18.wav,4,Dirosa Pertemuan 18.wav,3.1,6.91,11.11,12.15,13.53,14.63,18.74,22.01,26.09,30.64,37.35,37.56,1
+4_Dirosa Pertemuan 19.wav,4,Dirosa Pertemuan 19.wav,4.91,8.89,9.17,8.93,10.27,9.6,13.25,17.0,20.17,21.4,30.03,21.74,1
+4_Dirosa Pertemuan 2.wav,4,Dirosa Pertemuan 2.wav,4.47,8.36,10.04,12.57,15.41,17.92,23.51,26.1,30.96,31.06,38.03,32.87,1
+4_Dirosa Pertemuan 20.wav,4,Dirosa Pertemuan 20.wav,9.19,21.09,23.65,21.89,24.92,27.25,30.91,36.04,37.74,40.86,56.73,51.21,1
+4_Dirosa Pertemuan 3.wav,4,Dirosa Pertemuan 3.wav,5.72,10.25,11.08,11.78,15.22,18.82,24.8,31.06,34.62,34.93,42.47,35.01,1
+4_Dirosa Pertemuan 4.wav,4,Dirosa Pertemuan 4.wav,8.45,15.7,19.21,23.4,28.81,34.16,40.76,45.3,50.56,53.01,60.93,55.71,2
+4_Dirosa Pertemuan 5.wav,4,Dirosa Pertemuan 5.wav,6.01,10.97,13.26,15.12,20.11,26.89,35.49,39.08,44.19,46.59,53.5,51.15,2
+4_Dirosa Pertemuan 6.wav,4,Dirosa Pertemuan 6.wav,2.97,5.16,6.43,7.6,9.29,11.79,17.19,20.72,27.66,28.62,39.17,33.27,1
+4_Dirosa Pertemuan 7.wav,4,Dirosa Pertemuan 7.wav,2.91,5.34,6.24,7.02,8.41,10.13,14.27,19.36,26.79,28.85,36.68,31.09,1
+4_Dirosa Pertemuan 8.wav,4,Dirosa Pertemuan 8.wav,5.62,11.61,14.5,17.29,21.36,27.71,35.63,41.56,47.96,49.41,59.67,57.1,2
+4_Dirosa Pertemuan 9.wav,4,Dirosa Pertemuan 9.wav,4.97,6.78,7.99,9.44,13.88,20.26,28.12,37.23,45.12,47.95,54.6,56.13,1
+5_Dirosa Pertemuan 1.wav,5,Dirosa Pertemuan 1.wav,7.37,11.09,11.76,13.19,16.11,20.29,26.22,33.61,38.96,38.89,50.79,44.22,1
+5_Dirosa Pertemuan 10.wav,5,Dirosa Pertemuan 10.wav,5.01,6.23,7.8,10.38,14.9,17.39,20.53,24.4,27.57,33.82,47.79,45.61,1
+5_Dirosa Pertemuan 11.wav,5,Dirosa Pertemuan 11.wav,9.43,17.29,19.75,22.14,25.4,28.04,34.52,39.48,44.08,46.82,58.94,53.18,1
+5_Dirosa Pertemuan 12.wav,5,Dirosa Pertemuan 12.wav,8.14,10.18,12.12,13.1,15.14,19.05,24.74,30.85,39.55,39.84,50.16,45.71,1
+5_Dirosa Pertemuan 13.wav,5,Dirosa Pertemuan 13.wav,3.85,5.8,7.17,7.66,9.07,11.35,14.65,19.92,24.06,27.29,39.51,31.41,1
+5_Dirosa Pertemuan 14.wav,5,Dirosa Pertemuan 14.wav,6.55,11.8,14.14,14.36,18.74,24.66,34.61,44.15,52.89,55.57,63.42,58.86,2
+5_Dirosa Pertemuan 15.wav,5,Dirosa Pertemuan 15.wav,3.6,5.97,6.44,6.87,7.65,8.01,9.92,13.76,16.97,19.06,29.84,22.74,1
+5_Dirosa Pertemuan 16.wav,5,Dirosa Pertemuan 16.wav,4.7,7.44,8.79,10.05,12.54,16.97,24.8,32.54,41.58,44.62,51.28,46.4,1
+5_Dirosa Pertemuan 17.wav,5,Dirosa Pertemuan 17.wav,4.46,6.86,8.3,9.38,11.91,16.03,22.74,29.51,38.23,38.87,47.75,44.15,1
+5_Dirosa Pertemuan 18.wav,5,Dirosa Pertemuan 18.wav,7.78,16.21,19.09,20.09,22.84,25.47,32.97,38.21,42.85,47.18,56.51,50.3,1
+5_Dirosa Pertemuan 19.wav,5,Dirosa Pertemuan 19.wav,5.31,11.2,12.14,11.95,12.49,12.22,16.3,20.66,23.92,24.42,32.88,19.83,1
+5_Dirosa Pertemuan 2.wav,5,Dirosa Pertemuan 2.wav,6.55,8.05,9.62,10.25,12.61,15.75,18.24,21.05,25.29,26.79,37.24,30.04,1
+5_Dirosa Pertemuan 20.wav,5,Dirosa Pertemuan 20.wav,11.05,25.81,31.86,32.8,34.3,38.43,46.64,52.21,57.33,55.8,65.82,56.74,1
+5_Dirosa Pertemuan 3.wav,5,Dirosa Pertemuan 3.wav,5.53,8.37,7.74,8.19,10.79,11.9,15.97,21.36,25.17,25.74,35.63,25.3,1
+5_Dirosa Pertemuan 4.wav,5,Dirosa Pertemuan 4.wav,7.69,12.55,15.23,18.32,22.04,25.99,33.1,39.91,46.49,47.19,59.95,51.13,2
+5_Dirosa Pertemuan 5.wav,5,Dirosa Pertemuan 5.wav,9.31,14.24,15.52,18.12,21.15,25.92,31.8,37.69,43.0,45.78,53.41,48.79,1
+5_Dirosa Pertemuan 6.wav,5,Dirosa Pertemuan 6.wav,7.86,11.77,14.14,14.93,16.83,19.33,25.14,31.53,35.86,38.77,48.87,43.13,1
+5_Dirosa Pertemuan 7.wav,5,Dirosa Pertemuan 7.wav,4.09,5.61,6.31,6.77,8.13,10.2,13.64,18.28,24.61,27.02,37.87,31.63,1
+5_Dirosa Pertemuan 8.wav,5,Dirosa Pertemuan 8.wav,6.48,10.83,13.08,16.14,20.2,26.34,34.77,42.04,49.3,53.1,63.42,61.57,2
+5_Dirosa Pertemuan 9.wav,5,Dirosa Pertemuan 9.wav,4.02,6.49,7.71,8.51,12.31,16.84,23.16,30.14,37.21,40.39,50.89,46.1,1

dtw_similarity.py

@@ -0,0 +1,282 @@
+"""
+DTW Similarity Module
+Computes Dynamic Time Warping with cosine distance between frame sequences.
+Supports Sakoe-Chiba band constraint and path-length normalisation.
+"""
+
+import logging
+import math
+
+import torch
+import numpy as np
+from typing import Tuple, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class DTWSimilarity:
+    """Computes DTW-based similarity between feature sequences."""
+    
+    def __init__(self, distance_metric: str = "cosine", sakoe_chiba_ratio: float = 0.1):
+        """
+        Initialize DTW similarity calculator.
+        
+        Args:
+            distance_metric: Distance metric to use ("cosine" or "euclidean")
+            sakoe_chiba_ratio: Sakoe-Chiba band radius as a fraction of the
+                longer sequence length (0.0 disables the constraint).
+                Recommended range: 0.10 – 0.2.
+        """
+        self.distance_metric = distance_metric
+        self.sakoe_chiba_ratio = sakoe_chiba_ratio
+    
+    # ------------------------------------------------------------------
+    # Pairwise distance helpers
+    # ------------------------------------------------------------------
+
+    def cosine_distance(self, x: np.ndarray, y: np.ndarray) -> float:
+        """
+        Compute cosine distance between two vectors.
+        
+        Args:
+            x: First vector
+            y: Second vector
+            
+        Returns:
+            Cosine distance (1 - cosine similarity), clamped to [0, 2].
+        """
+        x_norm = x / (np.linalg.norm(x) + 1e-8)
+        y_norm = y / (np.linalg.norm(y) + 1e-8)
+        similarity = float(np.clip(np.dot(x_norm, y_norm), -1.0, 1.0))
+        return 1.0 - similarity
+
+    @staticmethod
+    def _cosine_distance_matrix(seq1: np.ndarray, seq2: np.ndarray) -> np.ndarray:
+        """
+        Vectorised cosine distance matrix between two frame sequences.
+
+        Args:
+            seq1: (N, D) array
+            seq2: (M, D) array
+
+        Returns:
+            (N, M) cosine-distance matrix with values in [0, 2].
+        """
+        norms1 = np.linalg.norm(seq1, axis=1, keepdims=True) + 1e-8
+        norms2 = np.linalg.norm(seq2, axis=1, keepdims=True) + 1e-8
+        sim = (seq1 / norms1) @ (seq2 / norms2).T
+        np.clip(sim, -1.0, 1.0, out=sim)
+        return 1.0 - sim
+    
+    def euclidean_distance(self, x: np.ndarray, y: np.ndarray) -> float:
+        """
+        Compute Euclidean distance between two vectors.
+        
+        Args:
+            x: First vector
+            y: Second vector
+            
+        Returns:
+            Euclidean distance
+        """
+        return np.linalg.norm(x - y)
+    
+    def compute_cost_matrix(
+        self, 
+        seq1: np.ndarray, 
+        seq2: np.ndarray
+    ) -> np.ndarray:
+        """
+        Compute pairwise distance cost matrix (vectorised).
+        
+        Args:
+            seq1: First sequence (n_frames1, feature_dim)
+            seq2: Second sequence (n_frames2, feature_dim)
+            
+        Returns:
+            Cost matrix (n_frames1, n_frames2)
+        """
+        if self.distance_metric == "cosine":
+            return self._cosine_distance_matrix(seq1, seq2)
+        else:
+            # Vectorised Euclidean distance
+            diff = seq1[:, np.newaxis, :] - seq2[np.newaxis, :, :]
+            return np.linalg.norm(diff, axis=2)
+    
+    def dtw(
+        self, 
+        seq1: np.ndarray, 
+        seq2: np.ndarray
+    ) -> Tuple[float, np.ndarray]:
+        """
+        Compute Dynamic Time Warping distance with Sakoe-Chiba band.
+        
+        Args:
+            seq1: First feature sequence (n_frames1, feature_dim)
+            seq2: Second feature sequence (n_frames2, feature_dim)
+            
+        Returns:
+            Tuple of (dtw_distance, accumulated_cost_matrix)
+        """
+        # Compute cost matrix
+        cost_matrix = self.compute_cost_matrix(seq1, seq2)
+        
+        n1, n2 = cost_matrix.shape
+        
+        # --- Sakoe-Chiba band ---
+        if self.sakoe_chiba_ratio > 0:
+            band_radius = max(1, int(round(self.sakoe_chiba_ratio * max(n1, n2))))
+            # Guarantee the band covers the endpoint when lengths differ
+            band_radius = max(band_radius, abs(n1 - n2))
+        else:
+            band_radius = max(n1, n2)  # no constraint
+        
+        # Initialize accumulated cost matrix
+        dtw_matrix = np.full((n1 + 1, n2 + 1), np.inf)
+        dtw_matrix[0, 0] = 0
+        
+        # Fill DTW matrix within Sakoe-Chiba band
+        for i in range(1, n1 + 1):
+            # Expected diagonal column for row i
+            j_centre = int(round(i * n2 / n1)) if n1 > 0 else i
+            j_start = max(1, j_centre - band_radius)
+            j_end = min(n2, j_centre + band_radius)
+            for j in range(j_start, j_end + 1):
+                cost = cost_matrix[i - 1, j - 1]
+                dtw_matrix[i, j] = cost + min(
+                    dtw_matrix[i - 1, j],      # insertion
+                    dtw_matrix[i, j - 1],      # deletion
+                    dtw_matrix[i - 1, j - 1]   # match
+                )
+        
+        # DTW distance is the value at bottom-right corner
+        dtw_distance = dtw_matrix[n1, n2]
+        
+        logger.info(
+            "DTW raw | total_cost=%.6f | seq1_len=%d | seq2_len=%d | "
+            "band_radius=%d (ratio=%.2f)",
+            dtw_distance, n1, n2, band_radius, self.sakoe_chiba_ratio,
+        )
+        
+        return dtw_distance, dtw_matrix
+    
+    def compute_similarity(
+        self, 
+        features1: torch.Tensor, 
+        features2: torch.Tensor,
+        normalize: bool = True
+    ) -> float:
+        """
+        Compute DTW-based similarity score between two feature sequences.
+        
+        Args:
+            features1: First feature sequence (n_frames1, feature_dim)
+            features2: Second feature sequence (n_frames2, feature_dim)
+            normalize: Whether to normalize by actual warping path length
+            
+        Returns:
+            Similarity score (higher is more similar)
+        """
+        # Convert to numpy
+        seq1 = features1.cpu().numpy() if torch.is_tensor(features1) else features1
+        seq2 = features2.cpu().numpy() if torch.is_tensor(features2) else features2
+        
+        # Compute DTW distance
+        dtw_distance, dtw_matrix = self.dtw(seq1, seq2)
+        
+        # Normalize by actual warping-path length
+        if normalize:
+            warping_path = self.compute_path(dtw_matrix)
+            path_length = len(warping_path)
+            normalized_distance = (
+                dtw_distance / path_length if path_length > 0 else dtw_distance
+            )
+        else:
+            path_length = None
+            normalized_distance = dtw_distance
+        
+        logger.info(
+            "DTW result | raw_distance=%.6f | path_length=%s | "
+            "normalized_distance=%.6f",
+            dtw_distance, path_length, normalized_distance,
+        )
+        
+        return normalized_distance
+    
+    def compute_path(
+        self, 
+        dtw_matrix: np.ndarray
+    ) -> list:
+        """
+        Backtrack to find optimal alignment path.
+        
+        Args:
+            dtw_matrix: Accumulated cost matrix from DTW
+            
+        Returns:
+            List of (i, j) tuples representing the alignment path
+        """
+        n1, n2 = dtw_matrix.shape
+        i, j = n1 - 1, n2 - 1
+        path = [(i - 1, j - 1)]
+        
+        while i > 1 or j > 1:
+            if i == 1:
+                j -= 1
+            elif j == 1:
+                i -= 1
+            else:
+                # Choose minimum of three neighbors
+                candidates = [
+                    dtw_matrix[i - 1, j - 1],  # diagonal
+                    dtw_matrix[i - 1, j],      # up
+                    dtw_matrix[i, j - 1]       # left
+                ]
+                min_idx = np.argmin(candidates)
+                
+                if min_idx == 0:
+                    i -= 1
+                    j -= 1
+                elif min_idx == 1:
+                    i -= 1
+                else:
+                    j -= 1
+            
+            path.append((i - 1, j - 1))
+        
+        return path[::-1]
+
+    # ------------------------------------------------------------------
+    # Score conversion
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def distance_to_score(
+        normalized_distance: float,
+        midpoint: float = 0.3,
+        steepness: float = 10.0,
+    ) -> float:
+        """
+        Convert a path-normalised DTW cosine distance to a 0-100 score
+        using a logistic (sigmoid) mapping.
+
+        Calibration (defaults `midpoint=0.3, steepness=10.0`):
+          * identical pairs  (d ≈ 0.05) → score ~ 92
+          * very similar     (d ≈ 0.15) → score ~ 82
+          * borderline       (d ≈ 0.30) → score = 50
+          * different pairs  (d ≈ 0.35) → score ~ 38
+          * noise/non-speech (d > 0.50) → score < 12
+
+        Args:
+            normalized_distance: Path-normalised DTW distance.
+            midpoint: Distance value that maps to score 50.
+            steepness: Logistic steepness (higher = sharper transition).
+
+        Returns:
+            Similarity score in [0, 100].
+        """
+        exponent = steepness * (normalized_distance - midpoint)
+        # Guard against overflow
+        exponent = max(-50.0, min(50.0, exponent))
+        score = 100.0 / (1.0 + math.exp(exponent))
+        return max(0.0, min(100.0, score))

requirements.txt

@@ -0,0 +1,22 @@
+# Requirements for Qur'an Recitation Similarity Pipeline
+# Python 3.9+
+
+# Core
+torch==2.12.0
+torchaudio==2.11.0
+transformers==4.57.3
+
+# Numeric Data & ML
+numpy==2.3.5
+scipy==1.16.3
+
+# Data Manipulation & I/O
+pandas==2.3.3
+soundfile==0.13.1
+
+# Audio Processing
+webrtcvad-wheels==2.0.14
+
+# Web App & Visualizations
+streamlit==1.52.2
+matplotlib==3.10.8

run_similarity.py

@@ -0,0 +1,331 @@
+"""Run Similarity Script.
+
+Supports:
+- single mode: compare one participant file vs one reference file
+- batch mode: compare all participant files in a folder against matching
+    reference files, then export tabular results to CSV/XLSX
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List
+
+from scoring import SimilarityScorer
+
+
+def _find_wav_files(folder: Path, recursive: bool) -> List[Path]:
+    if recursive:
+        return sorted(folder.rglob("*.wav"))
+    return sorted(folder.glob("*.wav"))
+
+
+def _write_batch_results(rows: List[Dict], output_path: Path) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if output_path.suffix.lower() == ".csv":
+        if not rows:
+            rows = [{"status": "no_data"}]
+
+        headers = sorted({k for row in rows for k in row.keys()})
+        with output_path.open("w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=headers)
+            writer.writeheader()
+            writer.writerows(rows)
+        return
+
+    if output_path.suffix.lower() == ".xlsx":
+        try:
+            import pandas as pd  # type: ignore
+        except ImportError as exc:
+            raise RuntimeError(
+                "Output .xlsx membutuhkan pandas + openpyxl. "
+                "Install dulu: pip install pandas openpyxl"
+            ) from exc
+
+        df = pd.DataFrame(rows)
+        df.to_excel(output_path, index=False)
+        return
+
+    raise ValueError("Format output tidak didukung. Pakai .csv atau .xlsx")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Compare Qur'an recitation audio in single or batch mode"
+    )
+
+    parser.add_argument(
+        "audio1",
+        nargs="?",
+        type=str,
+        help="Path audio peserta (single mode)",
+    )
+    parser.add_argument(
+        "audio2",
+        nargs="?",
+        type=str,
+        help="Path audio referensi (single mode)",
+    )
+
+    parser.add_argument(
+        "--participant-dir",
+        type=str,
+        default=None,
+        help="Folder audio peserta untuk batch mode",
+    )
+    parser.add_argument(
+        "--reference-dir",
+        type=str,
+        default=None,
+        help="Folder audio referensi untuk batch mode",
+    )
+    parser.add_argument(
+        "--recursive",
+        action="store_true",
+        help="Cari file .wav secara rekursif di subfolder (batch mode)",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="similarity_results.csv",
+        help="Path output hasil batch (.csv/.xlsx)",
+    )
+
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="./wavlm-base-plus",
+        help="WavLM model name (default: ./wavlm-base-plus)",
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default=None,
+        help="Device to use (cuda/cpu, default: auto-detect)",
+    )
+    parser.add_argument(
+        "--distance",
+        type=str,
+        default="cosine",
+        choices=["cosine", "euclidean"],
+        help="Distance metric for DTW (default: cosine)",
+    )
+    parser.add_argument(
+        "--no-normalize",
+        action="store_true",
+        help="Disable DTW distance normalization",
+    )
+    parser.add_argument(
+        "--detailed",
+        action="store_true",
+        help="Show detailed metrics in single mode",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output results in JSON format",
+    )
+
+    return parser
+
+
+def _run_single(args: argparse.Namespace, scorer: SimilarityScorer) -> None:
+    if not args.audio1 or not args.audio2:
+        raise ValueError(
+            "Single mode membutuhkan 2 file: audio1 audio2. "
+            "Atau pakai --participant-dir dan --reference-dir untuk batch mode."
+        )
+
+    print("\nComparing audio files:")
+    print(f"  Audio 1 (Participant): {args.audio1}")
+    print(f"  Audio 2 (Reference):   {args.audio2}")
+    print("\nProcessing...")
+
+    # One compute pass only to avoid doing the same heavy pipeline twice.
+    results = scorer.compute_detailed_similarity(args.audio1, args.audio2)
+
+    if not args.detailed:
+        results = {
+            "dtw_distance": results["dtw_distance"],
+            "similarity_score": results["similarity_score"],
+        }
+
+    if args.json:
+        print(json.dumps(results, indent=2))
+        return
+
+    print("\n" + "=" * 60)
+    print("SIMILARITY RESULTS")
+    print("=" * 60)
+    print(f"DTW Distance:      {results['dtw_distance']:.6f}")
+    print(f"Similarity Score:  {results['similarity_score']:.2f}/100")
+
+    if args.detailed:
+        print(f"\nAudio 1 Frames:    {results['num_frames_audio1']}")
+        print(f"Audio 2 Frames:    {results['num_frames_audio2']}")
+        print(f"Feature Dimension: {results['feature_dimension']}")
+        print(f"Distance Metric:   {results['distance_metric']}")
+        print(f"Normalized:        {results['normalized']}")
+        print(f"Path Length:       {results['path_length']}")
+
+    print("=" * 60)
+
+
+def _run_batch(args: argparse.Namespace, scorer: SimilarityScorer) -> None:
+    participant_dir = Path(args.participant_dir)
+    reference_dir = Path(args.reference_dir)
+    output_path = Path(args.output)
+
+    if not participant_dir.exists() or not participant_dir.is_dir():
+        raise ValueError(f"Folder peserta tidak valid: {participant_dir}")
+    if not reference_dir.exists() or not reference_dir.is_dir():
+        raise ValueError(f"Folder referensi tidak valid: {reference_dir}")
+
+    participant_files = _find_wav_files(participant_dir, args.recursive)
+    reference_files = _find_wav_files(reference_dir, args.recursive)
+
+    ref_by_name = {f.name.lower(): f for f in reference_files}
+    ref_by_stem = {f.stem.lower(): f for f in reference_files}
+
+    rows: List[Dict] = []
+    matched = 0
+    failed = 0
+    missing_ref = 0
+
+    print("\nBatch mode")
+    print(f"  Participant folder: {participant_dir}")
+    print(f"  Reference folder:   {reference_dir}")
+    print(f"  Participant files:  {len(participant_files)}")
+    print(f"  Reference files:    {len(reference_files)}")
+    print("\nProcessing...")
+
+    for idx, participant_file in enumerate(participant_files, 1):
+        key_name = participant_file.name.lower()
+        key_stem = participant_file.stem.lower()
+        reference_file = ref_by_name.get(key_name) or ref_by_stem.get(key_stem)
+
+        if reference_file is None:
+            missing_ref += 1
+            rows.append(
+                {
+                    "index": idx,
+                    "participant_file": str(participant_file),
+                    "reference_file": "",
+                    "status": "missing_reference",
+                    "dtw_distance": "",
+                    "similarity_score": "",
+                    "error": "No matching reference by filename/stem",
+                    "processed_at": datetime.now().isoformat(timespec="seconds"),
+                }
+            )
+            continue
+
+        try:
+            result = scorer.compute_detailed_similarity(
+                str(participant_file),
+                str(reference_file),
+            )
+            matched += 1
+            rows.append(
+                {
+                    "index": idx,
+                    "participant_file": str(participant_file),
+                    "reference_file": str(reference_file),
+                    "status": "ok",
+                    "dtw_distance": float(result["dtw_distance"]),
+                    "similarity_score": float(result["similarity_score"]),
+                    "raw_dtw_distance": float(result["raw_dtw_distance"]),
+                    "path_length": int(result["path_length"]),
+                    "num_frames_audio1": int(result["num_frames_audio1"]),
+                    "num_frames_audio2": int(result["num_frames_audio2"]),
+                    "feature_dimension": int(result["feature_dimension"]),
+                    "distance_metric": result["distance_metric"],
+                    "normalized": bool(result["normalized"]),
+                    "sakoe_chiba_ratio": float(result["sakoe_chiba_ratio"]),
+                    "processed_at": datetime.now().isoformat(timespec="seconds"),
+                }
+            )
+        except Exception as exc:  # pragma: no cover - runtime safety in batch
+            failed += 1
+            rows.append(
+                {
+                    "index": idx,
+                    "participant_file": str(participant_file),
+                    "reference_file": str(reference_file),
+                    "status": "error",
+                    "dtw_distance": "",
+                    "similarity_score": "",
+                    "error": str(exc),
+                    "processed_at": datetime.now().isoformat(timespec="seconds"),
+                }
+            )
+
+        if idx % 10 == 0:
+            print(f"  Processed {idx}/{len(participant_files)} files...")
+
+    _write_batch_results(rows, output_path)
+
+    summary = {
+        "mode": "batch",
+        "participant_dir": str(participant_dir),
+        "reference_dir": str(reference_dir),
+        "output_file": str(output_path),
+        "participant_total": len(participant_files),
+        "reference_total": len(reference_files),
+        "matched_ok": matched,
+        "missing_reference": missing_ref,
+        "failed": failed,
+    }
+
+    if args.json:
+        print(json.dumps(summary, indent=2))
+        return
+
+    print("\n" + "=" * 60)
+    print("BATCH SIMILARITY SUMMARY")
+    print("=" * 60)
+    print(f"Participant Total:  {summary['participant_total']}")
+    print(f"Reference Total:    {summary['reference_total']}")
+    print(f"Matched (OK):       {summary['matched_ok']}")
+    print(f"Missing Reference:  {summary['missing_reference']}")
+    print(f"Failed:             {summary['failed']}")
+    print(f"Output File:        {summary['output_file']}")
+    print("=" * 60)
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    is_batch = args.participant_dir is not None or args.reference_dir is not None
+
+    if is_batch and (args.audio1 or args.audio2):
+        raise ValueError(
+            "Jangan campur mode single dan batch. "
+            "Single: audio1 audio2 | Batch: --participant-dir --reference-dir"
+        )
+
+    if is_batch and (not args.participant_dir or not args.reference_dir):
+        raise ValueError("Batch mode membutuhkan --participant-dir dan --reference-dir")
+
+    print("Initializing similarity scorer...")
+    scorer = SimilarityScorer(
+        model_name=args.model,
+        device=args.device,
+        distance_metric=args.distance,
+        normalize_dtw=not args.no_normalize,
+    )
+
+    if is_batch:
+        _run_batch(args, scorer)
+    else:
+        _run_single(args, scorer)
+
+
+if __name__ == "__main__":
+    main()

scoring.py

@@ -0,0 +1,231 @@
+"""
+Scoring Module
+End-to-end pipeline for computing audio similarity scores.
+"""
+
+import logging
+
+import torch
+from typing import Optional, Dict
+from audio_loader import AudioLoader
+from wavlm_encoder import WavLMEncoder
+from dtw_similarity import DTWSimilarity
+
+logger = logging.getLogger(__name__)
+
+
+class SimilarityScorer:
+    """End-to-end similarity scoring pipeline."""
+    
+    def __init__(
+        self,
+        model_name: str = "./wavlm-base-plus",
+        device: Optional[str] = None,
+        distance_metric: str = "cosine",
+        sakoe_chiba_ratio: float = 0.1,
+        normalize_dtw: bool = True,
+        score_midpoint: float = 0.3,
+        score_steepness: float = 10.0
+    ):
+        """
+        Initialize similarity scorer.
+        
+        Args:
+            model_name: WavLM model name from HuggingFace
+            device: Device to run model on
+            distance_metric: Distance metric for DTW ("cosine" or "euclidean")
+            sakoe_chiba_ratio: Band radius ratio for DTW constraint
+            normalize_dtw: Whether to normalize DTW distance by path length
+            score_midpoint: Distance value that maps to 50 for the logisitic score
+            score_steepness: Logistic steepness for score mapping
+        """
+        self.audio_loader = AudioLoader(target_sr=16000)
+        self.encoder = WavLMEncoder(model_name=model_name, device=device)
+        self.dtw_similarity = DTWSimilarity(distance_metric=distance_metric, sakoe_chiba_ratio=sakoe_chiba_ratio)
+        self.normalize_dtw = normalize_dtw
+        self.score_midpoint = score_midpoint
+        self.score_steepness = score_steepness
+    
+    def compute_similarity(
+        self, 
+        audio_path1: str, 
+        audio_path2: str
+    ) -> float:
+        """
+        Compute similarity score between two audio files.
+        
+        Args:
+            audio_path1: Path to first audio file (participant's recitation)
+            audio_path2: Path to second audio file (reference recitation)
+            
+        Returns:
+            Similarity score (DTW distance - lower means more similar)
+        """
+        # Load and preprocess audio
+        waveform1 = self.audio_loader.load_and_preprocess(audio_path1)
+        waveform2 = self.audio_loader.load_and_preprocess(audio_path2)
+        
+        # Extract features
+        features1 = self.encoder.encode(waveform1)
+        features2 = self.encoder.encode(waveform2)
+        
+        # Compute DTW similarity
+        dtw_distance = self.dtw_similarity.compute_similarity(
+            features1, 
+            features2,
+            normalize=self.normalize_dtw
+        )
+        
+        logger.info(
+            "compute_similarity | audio1=%s | audio2=%s | dtw_distance=%.6f",
+            audio_path1, audio_path2, dtw_distance,
+        )
+        
+        return dtw_distance
+    
+    def compute_similarity_score_normalized(
+        self, 
+        audio_path1: str, 
+        audio_path2: str
+    ) -> float:
+        """
+        Compute normalized similarity score (0-100 scale, higher is better).
+        
+        Uses a logistic (sigmoid) mapping calibrated so that:
+          - identical pairs  (d ≈ 0.05) → score ~ 92
+          - very similar     (d ≈ 0.15) → score ~ 82
+          * borderline       (d ≈ 0.30) → score = 50
+          * different pairs  (d ≈ 0.35) → score ~ 38
+          * noise/non-speech (d > 0.50) → score < 12
+        
+        Args:
+            audio_path1: Path to first audio file
+            audio_path2: Path to second audio file
+            
+        Returns:
+            Normalized similarity score (0-100, where 100 is perfect match)
+        """
+        # Get DTW distance (already path-normalised when self.normalize_dtw)
+        dtw_distance = self.compute_similarity(audio_path1, audio_path2)
+        
+        # Logistic mapping (calibrated for cosine-distance DTW)
+        similarity_score = DTWSimilarity.distance_to_score(
+            dtw_distance,
+            midpoint=self.score_midpoint,
+            steepness=self.score_steepness
+        )
+        
+        logger.info(
+            "score_normalized | dtw_distance=%.6f | score=%.2f",
+            dtw_distance, similarity_score,
+        )
+        
+        return similarity_score
+    
+    def compute_detailed_similarity(
+        self, 
+        audio_path1: str, 
+        audio_path2: str,
+        use_vad: bool = True,
+        layer_indices: Optional[list] = None
+    ) -> Dict:
+        """
+        Compute detailed similarity analysis (supports multiple layers).
+        
+        Args:
+            audio_path1: Path to first audio file (reference)
+            audio_path2: Path to second audio file (test)
+            use_vad: Whether to use VAD endpoint trimming
+            layer_indices: List of WavLM layers to extract (defaults to [12])
+            
+        Returns:
+            Dictionary containing detailed metrics, warping paths, DTW matrices, and original waveforms.
+        """
+        if layer_indices is None:
+            layer_indices = [12]
+
+        self.audio_loader.use_vad = use_vad
+
+        # Process and retrieve both raw and VAD waveforms
+        waveform_ref_raw, sr_ref = self.audio_loader.load_audio(audio_path1)
+        waveform_test_raw, sr_test = self.audio_loader.load_audio(audio_path2)
+
+        if use_vad:
+            waveform_ref_vad = self.audio_loader.vad_trim_endpoints(waveform_ref_raw, sr_ref)
+            waveform_test_vad = self.audio_loader.vad_trim_endpoints(waveform_test_raw, sr_test)
+        else:
+            waveform_ref_vad = waveform_ref_raw
+            waveform_test_vad = waveform_test_raw
+
+        waveform_ref = self.audio_loader.normalize_audio(waveform_ref_vad)
+        waveform_test = self.audio_loader.normalize_audio(waveform_test_vad)
+        
+        # Extract features for all requested layers
+        feat_ref_dict = self.encoder.encode(waveform_ref, extract_layers=layer_indices)
+        feat_test_dict = self.encoder.encode(waveform_test, extract_layers=layer_indices)
+        
+        results = {}
+        for layer in layer_indices:
+            seq1 = feat_ref_dict[layer].cpu().numpy()
+            seq2 = feat_test_dict[layer].cpu().numpy()
+            
+            # Compute DTW
+            raw_distance, dtw_matrix = self.dtw_similarity.dtw(seq1, seq2)
+            warping_path = self.dtw_similarity.compute_path(dtw_matrix)
+            path_length = len(warping_path)
+            
+            # Normalize
+            if self.normalize_dtw and path_length > 0:
+                normalized_distance = raw_distance / path_length
+            else:
+                normalized_distance = raw_distance
+            
+            # Logistic score
+            normalized_score = DTWSimilarity.distance_to_score(
+                normalized_distance,
+                midpoint=self.score_midpoint,
+                steepness=self.score_steepness
+            )
+
+            num_frames_ref = seq1.shape[0]
+            num_frames_test = seq2.shape[0]
+            sr = 16000
+            ref_duration_sec = round(num_frames_ref * 320 / sr, 3)
+            test_duration_sec = round(num_frames_test * 320 / sr, 3)
+            duration_ratio = round(test_duration_sec / ref_duration_sec, 4) if ref_duration_sec > 0 else 0.0
+            
+            diagnostics = {
+                "raw_dtw_distance": float(raw_distance),
+                "normalized_distance": float(normalized_distance),
+                "path_length": int(path_length),
+                "num_frames_ref": num_frames_ref,
+                "num_frames_test": num_frames_test,
+                "feature_dimension": seq1.shape[1],
+                "ref_duration_sec": ref_duration_sec,
+                "test_duration_sec": test_duration_sec,
+                "duration_ratio": duration_ratio,
+                "distance_metric": self.dtw_similarity.distance_metric,
+                "normalized": self.normalize_dtw,
+                "sakoe_chiba_ratio": self.dtw_similarity.sakoe_chiba_ratio,
+            }
+
+            results[layer] = {
+                "score": normalized_score,
+                "dtw_distance": float(normalized_distance),
+                "raw_dtw_distance": float(raw_distance),
+                "warping_path": warping_path,
+                "dtw_matrix": dtw_matrix,
+                "diagnostics": diagnostics
+            }
+        
+        return {
+            "results": results,
+            "waveforms": {
+                "ref_raw": waveform_ref_raw,
+                "ref_vad": waveform_ref_vad,
+                "ref_normalized": waveform_ref,
+                "test_raw": waveform_test_raw,
+                "test_vad": waveform_test_vad,
+                "test_normalized": waveform_test,
+            }
+        }

wavlm-base-plus/config.json

@@ -0,0 +1,121 @@
+{
+  "activation_dropout": 0.0,
+  "adapter_kernel_size": 3,
+  "adapter_stride": 2,
+  "add_adapter": false,
+  "apply_spec_augment": true,
+  "architectures": [
+    "WavLMModel"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "codevector_dim": 256,
+  "contrastive_logits_temperature": 0.1,
+  "conv_bias": false,
+  "conv_dim": [
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512
+  ],
+  "conv_kernel": [
+    10,
+    3,
+    3,
+    3,
+    3,
+    2,
+    2
+  ],
+  "conv_stride": [
+    5,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "ctc_loss_reduction": "sum",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "do_stable_layer_norm": false,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_norm": "group",
+  "feat_proj_dropout": 0.1,
+  "feat_quantizer_dropout": 0.0,
+  "final_dropout": 0.0,
+  "freeze_feat_extract_train": true,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.05,
+  "mask_channel_length": 10,
+  "mask_channel_min_space": 1,
+  "mask_channel_other": 0.0,
+  "mask_channel_prob": 0.0,
+  "mask_channel_selection": "static",
+  "mask_feature_length": 10,
+  "mask_feature_min_masks": 0,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_masks": 2,
+  "mask_time_min_space": 1,
+  "mask_time_other": 0.0,
+  "mask_time_prob": 0.05,
+  "mask_time_selection": "static",
+  "max_bucket_distance": 800,
+  "model_type": "wavlm",
+  "no_mask_channel_overlap": false,
+  "no_mask_time_overlap": false,
+  "num_adapter_layers": 3,
+  "num_attention_heads": 12,
+  "num_buckets": 320,
+  "num_codevector_groups": 2,
+  "num_codevectors_per_group": 320,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_ctc_classes": 80,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 12,
+  "num_negatives": 100,
+  "output_hidden_size": 768,
+  "pad_token_id": 0,
+  "proj_codevector_dim": 256,
+  "replace_prob": 0.5,
+  "tdnn_dilation": [
+    1,
+    2,
+    3,
+    1,
+    1
+  ],
+  "tdnn_dim": [
+    512,
+    512,
+    512,
+    512,
+    1500
+  ],
+  "tdnn_kernel": [
+    5,
+    3,
+    3,
+    1,
+    1
+  ],
+  "tokenizer_class": "Wav2Vec2CTCTokenizer",
+  "transformers_version": "4.57.3",
+  "use_weighted_layer_sum": false,
+  "vocab_size": 32,
+  "xvector_output_dim": 512
+}

wavlm-base-plus/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f1f0adf5eb20d7c049ae512949fdc16cb846a631cb9b7a3ff7da4a147b069ff
+size 377555928

wavlm-base-plus/preprocessor_config.json

@@ -0,0 +1,9 @@
+{
+  "do_normalize": false,
+  "feature_extractor_type": "Wav2Vec2FeatureExtractor",
+  "feature_size": 1,
+  "padding_side": "right",
+  "padding_value": 0.0,
+  "return_attention_mask": true,
+  "sampling_rate": 16000
+}

wavlm_encoder.py

@@ -0,0 +1,140 @@
+"""WavLM Encoder Module
+
+Extracts frame-level features using pretrained WavLM model (frozen).
+
+Note:
+- Some Python environments have an incompatible TensorFlow install (commonly due
+    to NumPy 2.x ABI changes). HuggingFace `transformers` may try to import TF as
+    an optional dependency; we explicitly disable TF/Flax to keep this pipeline
+    PyTorch-only.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import torch
+
+
+class WavLMEncoder:
+    """Extracts features from audio using pretrained WavLM model."""
+    
+    def __init__(
+        self, 
+        model_name: str = "./wavlm-base-plus",
+        device: Optional[str] = None,
+        layer_idx: int = -1
+    ):
+        """
+        Initialize WavLM encoder.
+        
+        Args:
+            model_name: HuggingFace model identifier
+            device: Device to run model on ('cuda', 'cpu', or None for auto)
+            layer_idx: Which transformer layer to extract features from (-1 for last layer)
+        """
+        # Force transformers to stay PyTorch-only (avoid importing TensorFlow/Flax)
+        os.environ.setdefault("TRANSFORMERS_NO_TF", "1")
+        os.environ.setdefault("TRANSFORMERS_NO_FLAX", "1")
+        os.environ.setdefault("USE_TF", "0")
+        os.environ.setdefault("USE_FLAX", "0")
+
+        # Local import so env vars above take effect before transformers loads
+        from transformers import AutoFeatureExtractor, WavLMModel
+
+        # Set device
+        if device is None:
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        else:
+            self.device = torch.device(device)
+        
+        # Load feature extractor and model
+        self.feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
+        self.model = WavLMModel.from_pretrained(model_name)
+        
+        # Freeze model parameters (no fine-tuning)
+        for param in self.model.parameters():
+            param.requires_grad = False
+        
+        # Move model to device and set to eval mode
+        self.model = self.model.to(self.device)
+        self.model.eval()
+        self.layer_idx = layer_idx
+        
+        print(f"WavLM model loaded on {self.device}")
+    
+    def encode(self, waveform: torch.Tensor, extract_layers: Optional[list[int]] = None) -> torch.Tensor | dict[int, torch.Tensor]:
+        """
+        Extract frame-level features from audio waveform.
+        
+        Args:
+            waveform: Audio waveform tensor, shape (1, num_samples) or (num_samples,)
+            extract_layers: Optional list of layer indices to extract. If provided, returns a dict of layer representations.
+            
+        Returns:
+            If extract_layers is None, returns frame-level features for self.layer_idx, shape (num_frames, hidden_size)
+            If extract_layers is a list, returns a dictionary mapping layer index to feature tensor.
+        """
+        # Ensure correct shape and convert directly to 1D numpy array
+        if waveform.dim() == 1:
+            waveform_np = waveform.detach().cpu().numpy()
+        elif waveform.dim() == 2 and waveform.shape[0] == 1:
+            waveform_np = waveform.squeeze(0).detach().cpu().numpy()
+        else:
+            raise ValueError(f"Expected waveform shape (num_samples,) or (1, num_samples), got {waveform.shape}")
+        
+        # Extract features using feature extractor
+        inputs = self.feature_extractor(
+            waveform_np,
+            sampling_rate=16000,
+            return_tensors="pt",
+        )
+        
+        # Move inputs to device
+        input_values = inputs.input_values.to(self.device)
+        
+        # Extract features (no gradient computation)
+        with torch.no_grad():
+            outputs = self.model(input_values, output_hidden_states=True)
+            
+            if extract_layers is not None:
+                features_dict = {}
+                for idx in extract_layers:
+                    hidden_states = outputs.hidden_states[idx]
+                    features_dict[idx] = hidden_states.squeeze(0)
+                return features_dict
+            else:
+                # Get the specified hidden state layer: (batch_size, num_frames, hidden_size)
+                hidden_states = outputs.hidden_states[self.layer_idx]
+        
+        # Remove batch dimension and return
+        # Shape: (num_frames, hidden_size)
+        features = hidden_states.squeeze(0)
+        
+        return features
+    
+    def encode_batch(self, waveforms: list) -> list:
+        """
+        Encode multiple waveforms.
+        
+        Args:
+            waveforms: List of waveform tensors
+            
+        Returns:
+            List of feature tensors
+        """
+        features_list = []
+        for waveform in waveforms:
+            features = self.encode(waveform)
+            features_list.append(features)
+        return features_list
+    
+    def get_feature_dim(self) -> int:
+        """
+        Get the dimensionality of the feature vectors.
+        
+        Returns:
+            Feature dimension size
+        """
+        return self.model.config.hidden_size