Upload 6 files

Dockerfile

@@ -1,20 +1,21 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+FROM python:3.11-slim
+
+# System deps
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy project
+COPY . /app
+
+# Install Python deps
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+
+# Expose Streamlit port
+EXPOSE 8501
+
+# Run Streamlit
+CMD ["streamlit", "run", "streamlit_app.py", "--server.port", "8501", "--server.address", "0.0.0.0"]

config.yaml

@@ -0,0 +1,209 @@
+# =============================================================================
+# CONFIG.YAML - Konfigurasi Sistem Notulensi Rapat Otomatis
+# =============================================================================
+
+# Informasi Proyek
+project:
+  name: "Meeting Transcriber"
+  version: "1.0.0"
+  author: "Yermia Turangan"
+  description: "Sistem Notulensi Rapat Otomatis berbasis SpeechBrain dan BERT"
+
+# Konfigurasi Audio
+audio:
+  sample_rate: 16000
+  mono: true
+  normalize: true
+  trim_silence: false
+  max_duration_minutes: 60
+
+# Konfigurasi Speaker Diarization
+diarization:
+  # Voice Activity Detection
+  vad:
+    threshold: 0.5
+    min_speech_duration: 0.3
+    min_silence_duration: 0.3
+    speech_pad_ms: 30
+
+  # Segmentation
+  segmentation:
+    window_duration: 1.5
+    window_hop: 0.75
+    min_segment_duration: 0.5
+
+  # Speaker Embedding
+  embedding:
+    model_id: "speechbrain/spkrec-ecapa-voxceleb"
+    embedding_dim: 192
+
+  # Clustering
+  clustering:
+    method: "agglomerative"  # agglomerative, spectral, kmeans
+    threshold: 0.7
+    min_cluster_size: 2
+    linkage: "average"
+
+  # Post-processing
+  postprocessing:
+    merge_gap_threshold: 0.5
+    min_segment_duration: 0.3
+    smooth_segments: true
+
+# Konfigurasi ASR (Speech Recognition)
+asr:
+  model_id: "whisper/whisper-base"
+  # model_id: "indonesian-nlp/wav2vec2-large-xlsr-indonesian"
+  # Alternatif: "facebook/wav2vec2-large-xlsr-53"
+  chunk_length_s: 30
+  stride_length_s: 5
+  batch_size: 4
+  return_timestamps: false
+  backend: "transformers"  # options: 'transformers'|'whisper'|'speechbrain'
+
+  # Post-processing teks
+  text_postprocessing:
+    capitalize_sentences: true
+    normalize_whitespace: true
+    add_punctuation: false  # Bisa diaktifkan jika ada model punctuation
+
+# Konfigurasi BERT Summarization
+summarization:
+  # Model
+  model_id: "indobenchmark/indobert-base-p1"
+  sentence_model_id: "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+
+  # Extractive Summarization Settings
+  extractive:
+    num_sentences: 5
+    min_sentence_length: 10
+    max_sentence_length: 200
+    position_weight: 0.1
+    similarity_threshold: 0.3
+
+  # Keyword Detection
+  keywords:
+    decisions:
+      - "diputuskan"
+      - "disepakati"
+      - "kesimpulan"
+      - "keputusan"
+      - "jadi"
+      - "maka"
+      - "sepakat"
+      - "setuju"
+      - "final"
+      - "kesepakatan"
+
+    action_items:
+      - "akan"
+      - "harus"
+      - "perlu"
+      - "tolong"
+      - "mohon"
+      - "deadline"
+      - "target"
+      - "tugas"
+      - "tanggung jawab"
+      - "action item"
+      - "follow up"
+      - "tindak lanjut"
+      - "dikerjakan"
+      - "selesaikan"
+
+# Konfigurasi Document Generation
+document:
+  template: "default"
+
+  # Struktur dokumen
+  sections:
+    header: true
+    meeting_info: true
+    summary: true
+    decisions: true
+    action_items: true
+    transcript: true
+    footer: true
+
+  # Formatting
+  formatting:
+    title_font_size: 18
+    heading_font_size: 14
+    body_font_size: 11
+    font_family: "Calibri"
+    include_timestamps: true
+    include_speaker_colors: true
+
+  # Output
+  output:
+    directory: "./data/output"
+    filename_template: "notulensi_{title}_{date}_{timestamp}"
+
+# Konfigurasi Evaluasi
+evaluation:
+  # WER Settings
+  wer:
+    lowercase: true
+    remove_punctuation: true
+    normalize_whitespace: true
+
+  # DER Settings
+  der:
+    collar: 0.25  # Forgiveness collar in seconds
+    skip_overlap: false
+
+  # Output
+  output:
+    save_detailed_results: true
+    generate_plots: true
+    export_csv: true
+
+# Konfigurasi Hardware
+hardware:
+  device: "auto"  # auto, cuda, cpu
+  num_workers: 4
+  pin_memory: true
+
+  # Memory management
+  max_batch_size: 8
+  gradient_checkpointing: false
+
+# Konfigurasi Paths
+paths:
+  models_dir: "./models"
+  audio_dir: "./data/audio"
+  ground_truth_dir: "./data/ground_truth"
+  output_dir: "./data/output"
+  cache_dir: "./cache"
+  logs_dir: "./logs"
+
+# Konfigurasi Logging
+logging:
+  level: "INFO"  # DEBUG, INFO, WARNING, ERROR
+  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+  save_to_file: true
+  log_file: "./logs/pipeline.log"
+
+# Eksperimen (untuk skripsi)
+experiment:
+  name: "baseline_evaluation"
+  conditions:
+    - name: "bersih"
+      description: "Audio bersih, ruangan tenang"
+      expected_wer: 0.15
+      expected_der: 0.15
+
+    - name: "noisy"
+      description: "Audio dengan background noise"
+      expected_wer: 0.25
+      expected_der: 0.25
+
+    - name: "overlap"
+      description: "Audio dengan overlapping speech"
+      expected_wer: 0.35
+      expected_der: 0.40
+
+    - name: "multispeaker"
+      description: "Audio dengan 4-6 speaker"
+      expected_wer: 0.25
+      expected_der: 0.35

main.py

@@ -0,0 +1,602 @@
+#!/usr/bin/env python3
+"""
+Main Entry Point - Meeting Transcriber System
+==============================================
+
+Automatic Meeting Minutes Generation using SpeechBrain + BERT
+
+Usage:
+    # Basic transcription
+    python main.py --audio meeting.wav --title "Team Meeting"
+
+    # With evaluation
+    python main.py --audio meeting.wav --evaluate --reference transcript.txt
+
+    # Batch processing
+    python main.py --batch ./audio_folder/ --output ./results/
+
+    # Specify number of speakers
+    python main.py --audio meeting.wav --speakers 4
+"""
+
+import argparse
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import List
+
+from src.evaluator import EvaluationResult, Evaluator
+from src.pipeline import MeetingTranscriberPipeline, PipelineConfig, PipelineResult
+from src.utils import (
+    format_duration,
+    list_audio_files,
+    parse_rttm_file,
+    parse_transcript_file,
+    validate_audio_file,
+)
+
+
+def parse_args():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(
+        description="Sistem Notulensi Rapat Otomatis (SpeechBrain + BERT)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Contoh Penggunaan:
+==================
+
+  # Transkripsi dasar
+  python main.py --audio rapat.wav
+
+  # Dengan detail rapat
+  python main.py --audio rapat.wav --title "Rapat Sprint" --speakers 4 --location "Zoom"
+
+  # Dengan evaluasi WER
+  python main.py --audio rapat.wav --evaluate --reference transkrip_manual.txt
+
+  # Batch processing
+  python main.py --batch ./folder_audio/ --output ./hasil/
+
+Untuk dokumentasi lengkap, lihat README.md
+        """,
+    )
+
+    # Input arguments
+    input_group = parser.add_argument_group("Input")
+    input_group.add_argument(
+        "--audio", "-a", type=str, help="Path ke file audio (.wav, .mp3, .m4a)"
+    )
+    input_group.add_argument(
+        "--batch", "-b", type=str, help="Direktori berisi file audio untuk batch processing"
+    )
+
+    # Meeting metadata
+    meta_group = parser.add_argument_group("Meeting Metadata")
+    meta_group.add_argument(
+        "--title",
+        "-t",
+        type=str,
+        default="Notulensi Rapat",
+        help="Judul rapat (default: 'Notulensi Rapat')",
+    )
+    meta_group.add_argument(
+        "--date", "-d", type=str, default=None, help="Tanggal rapat (default: hari ini)"
+    )
+    meta_group.add_argument("--location", "-l", type=str, default="", help="Lokasi/platform rapat")
+    meta_group.add_argument(
+        "--speakers",
+        "-s",
+        type=int,
+        default=None,
+        help="Jumlah speaker (opsional, auto-detect jika tidak disebut)",
+    )
+
+    meta_group.add_argument(
+        "--speaker-map",
+        type=str,
+        default=None,
+        help='Path ke JSON/YAML file yang memetakan speaker label (SPEAKER_00) ke nama (mis: {"SPEAKER_00": "Budi"})',
+    )
+
+    meta_group.add_argument(
+        "--tune-diarization",
+        action="store_true",
+        help="Jalankan tuning hyperparameter diarization sebelum clustering (tries several settings)",
+    )
+
+    meta_group.add_argument(
+        "--target-speakers",
+        type=int,
+        default=None,
+        help="Target jumlah speaker untuk dipaksakan (opsional). Jika diset, pipeline akan mencoba merge cluster hingga jumlah ini.",
+    )
+
+    # Performance and tuning flags
+    misc_group = parser.add_argument_group("Performance")
+    misc_group.add_argument(
+        "--fast",
+        action="store_true",
+        help="Aktifkan modus cepat (mengorbankan sedikit akurasi demi kinerja)",
+    )
+    misc_group.add_argument(
+        "--preset",
+        type=str,
+        choices=["deployment", "balanced", "fast", "accurate"],
+        default="deployment",
+        help="Preset pipeline yang merekomendasikan konfigurasi (default: deployment - prefer 'large-v3-turbo')",
+    )
+    misc_group.add_argument(
+        "--quick-asr",
+        action="store_true",
+        help="Gunakan backend ASR lebih ringan/cepat (model kecil) jika memungkinkan (opsional override)",
+    )
+    misc_group.add_argument(
+        "--prefer-whisper-small",
+        action="store_true",
+        help="Paksa penggunaan `openai/whisper-small` untuk ASR (lebih cepat, lebih ringan)",
+    )
+    misc_group.add_argument(
+        "--cst-hz",
+        type=float,
+        default=None,
+        help="(opsional) Approximate Continuous Speech Tokenizer token rate in Hz (e.g., 7.5). Applies lossy compression preprocessor for speed.",
+    )
+    misc_group.add_argument(
+        "--diarization-compare",
+        action="store_true",
+        help="Jalankan perbandingan metode diarization (agglomerative vs spectral) selama evaluasi",
+    )
+    misc_group.add_argument(
+        "--parallel-workers",
+        type=int,
+        default=None,
+        help="Override jumlah worker paralel untuk per-segment ASR (default: auto berdasarkan CPU atau preset)",
+    )
+    misc_group.add_argument(
+        "--no-embedding-cache",
+        action="store_true",
+        help="Nonaktifkan cache embeddings di disk (default: aktif)",
+    )
+
+    # Output settings
+    output_group = parser.add_argument_group("Output")
+    output_group.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        default="./data/output",
+        help="Direktori output (default: ./data/output)",
+    )
+    output_group.add_argument(
+        "--filename",
+        "-f",
+        type=str,
+        default=None,
+        help="Nama file output (auto-generate jika tidak disebut)",
+    )
+
+    # Evaluation
+    eval_group = parser.add_argument_group("Evaluation")
+    eval_group.add_argument("--evaluate", "-e", action="store_true", help="Aktifkan mode evaluasi")
+    eval_group.add_argument(
+        "--reference",
+        "-r",
+        type=str,
+        default=None,
+        help="Path ke file reference transcript untuk WER",
+    )
+    eval_group.add_argument(
+        "--reference-rttm", type=str, default=None, help="Path ke file RTTM untuk DER"
+    )
+    eval_group.add_argument(
+        "--reference-summary",
+        type=str,
+        default=None,
+        help="Path ke file reference summary untuk evaluasi ringkasan (ROUGE/BERTScore)",
+    )
+    eval_group.add_argument(
+        "--condition",
+        type=str,
+        default="unknown",
+        help="Nama kondisi untuk evaluasi (misal: bersih, noisy)",
+    )
+
+    # Model settings
+    model_group = parser.add_argument_group("Model Settings")
+    model_group.add_argument(
+        "--asr-model",
+        type=str,
+        default="large-v3-turbo",
+        help="ASR model (HF model id / alias / path folder model lokal). Default: large-v3-turbo for better accuracy.",
+    )
+    model_group.add_argument(
+        "--asr-backend",
+        type=str,
+        default="whisper",
+        choices=["whisperx", "whisper", "transformers", "speechbrain"],
+        help="Backend ASR (default: whisper)",
+    )
+    model_group.add_argument(
+        "--asr-language",
+        type=str,
+        default="id",
+        help="Kode bahasa (mis: id, en, auto). Untuk WhisperX: 'auto' = autodetect.",
+    )
+    model_group.add_argument(
+        "--whisperx-compute-type",
+        type=str,
+        default="auto",
+        help="WhisperX compute_type (auto|float16|int8|int8_float16). Default auto.",
+    )
+    model_group.add_argument(
+        "--whisperx-no-vad-filter",
+        action="store_true",
+        help="Matikan VAD filter WhisperX (kadang berguna untuk audio sangat pendek/aneh).",
+    )
+    model_group.add_argument(
+        "--device",
+        type=str,
+        default="auto",
+        choices=["auto", "cuda", "cpu"],
+        help="Device untuk inferensi (default: auto)",
+    )
+
+    # Misc
+    misc_group = parser.add_argument_group("Misc")
+    misc_group.add_argument(
+        "--verbose", "-v", action="store_true", default=True, help="Output verbose"
+    )
+    misc_group.add_argument("--quiet", "-q", action="store_true", help="Minimal output")
+    misc_group.add_argument(
+        "--no-save-intermediate", action="store_true", help="Jangan simpan hasil intermediate"
+    )
+
+    return parser.parse_args()
+
+
+def print_banner():
+    """Print application banner"""
+    banner = """
+╔══════════════════════════════════════════════════════════════════╗
+║                                                                  ║
+║   ███╗   ███╗███████╗███████╗████████╗██╗███╗   ██╗ ██████╗     ║
+║   ████╗ ████║██╔════╝██╔════╝╚══██╔══╝██║████╗  ██║██╔════╝     ║
+║   ██╔████╔██║█████╗  █████╗     ██║   ██║██╔██╗ ██║██║  ███╗    ║
+║   ██║╚██╔╝██║██╔══╝  ██╔══╝     ██║   ██║██║╚██╗██║██║   ██║    ║
+║   ██║ ╚═╝ ██║███████╗███████╗   ██║   ██║██║ ╚████║╚██████╔╝    ║
+║   ╚═╝     ╚═╝╚══════╝╚══════╝   ╚═╝   ╚═╝╚═╝  ╚═══╝ ╚═════╝     ║
+║                                                                  ║
+║          TRANSCRIBER - Notulensi Rapat Otomatis                 ║
+║                  SpeechBrain + BERT Pipeline                     ║
+║                                                                  ║
+╚══════════════════════════════════════════════════════════════════╝
+    """
+    print(banner)
+
+
+def process_single_audio(args, pipeline: MeetingTranscriberPipeline) -> PipelineResult:
+    """Process a single audio file"""
+
+    # Validate audio file
+    validate_audio_file(args.audio)
+
+    print(f"\n{'='*60}")
+    print(f"Processing: {args.audio}")
+    print(f"{'='*60}")
+
+    # Run pipeline
+    result = pipeline.process(
+        audio_path=args.audio,
+        title=args.title,
+        date=args.date,
+        location=args.location,
+        num_speakers=args.speakers,
+        output_filename=args.filename,
+    )
+
+    # Print summary
+    print_result_summary(result)
+
+    # Run evaluation if requested
+    if args.evaluate:
+        run_evaluation(args, pipeline, result)
+
+    return result
+
+
+def process_batch(args, pipeline: MeetingTranscriberPipeline) -> List[PipelineResult]:
+    """Process multiple audio files in a directory"""
+
+    batch_dir = Path(args.batch)
+
+    if not batch_dir.is_dir():
+        print(f"Error: Direktori tidak ditemukan: {args.batch}")
+        sys.exit(1)
+
+    # Find audio files
+    audio_files = list_audio_files(batch_dir)
+
+    if not audio_files:
+        print(f"Tidak ada file audio ditemukan di: {args.batch}")
+        sys.exit(1)
+
+    print(f"\nDitemukan {len(audio_files)} file audio untuk diproses")
+    print("-" * 60)
+
+    results = []
+    failed = []
+
+    for i, audio_path in enumerate(audio_files, 1):
+        print(f"\n[{i}/{len(audio_files)}] Processing: {audio_path.name}")
+
+        try:
+            # Generate title from filename
+            title = audio_path.stem.replace("_", " ").replace("-", " ").title()
+
+            result = pipeline.process(
+                audio_path=str(audio_path),
+                title=title,
+                date=args.date,
+                location=args.location,
+                num_speakers=args.speakers,
+            )
+            results.append(result)
+
+            # Clear state for next file
+            pipeline.clear_state()
+
+        except Exception as e:
+            print(f"Error processing {audio_path.name}: {e}")
+            failed.append((audio_path.name, str(e)))
+            continue
+
+    # Print batch summary
+    print_batch_summary(results, failed, audio_files)
+
+    return results
+
+
+def run_evaluation(args, pipeline: MeetingTranscriberPipeline, result: PipelineResult):
+    """Run evaluation with reference files"""
+
+    print(f"\n{'='*60}")
+    print("EVALUASI")
+    print(f"{'='*60}")
+
+    reference_transcript = None
+    reference_diarization = None
+
+    # Load reference transcript
+    if args.reference:
+        if not os.path.exists(args.reference):
+            print(f"Warning: File reference tidak ditemukan: {args.reference}")
+        else:
+            reference_transcript = parse_transcript_file(args.reference)
+            print(f"Reference transcript loaded: {len(reference_transcript.split())} words")
+
+    # Load reference diarization
+    if args.reference_rttm:
+        if not os.path.exists(args.reference_rttm):
+            print(f"Warning: File RTTM tidak ditemukan: {args.reference_rttm}")
+        else:
+            reference_diarization = parse_rttm_file(args.reference_rttm)
+            print(f"Reference diarization loaded: {len(reference_diarization)} segments")
+    else:
+        # If user didn't provide an RTTM, try to find a *_vibevoice.rttm for the sample
+        try:
+            audio_stem = Path(args.audio).stem
+            cand = Path("data/ground_truth") / f"{audio_stem}_vibevoice.rttm"
+            if cand.exists():
+                reference_diarization = parse_rttm_file(str(cand))
+                print(f"Reference RTTM auto-loaded: {cand} ({len(reference_diarization)} segments)")
+        except Exception:
+            pass
+
+    # Load reference summary (optional)
+    reference_summary = None
+    if getattr(args, "reference_summary", None):
+        if not os.path.exists(args.reference_summary):
+            print(f"Warning: File reference summary tidak ditemukan: {args.reference_summary}")
+        else:
+            try:
+                reference_summary = Path(args.reference_summary).read_text(encoding="utf-8")
+                print(f"Reference summary loaded (len={len(reference_summary.split())} words)")
+            except Exception as e:
+                print(f"Warning: gagal membaca file summary: {e}")
+
+    # Run evaluation
+    eval_result = pipeline.evaluate(
+        reference_transcript=reference_transcript,
+        reference_diarization=reference_diarization,
+        reference_summary=reference_summary,
+        sample_name=Path(args.audio).stem,
+        condition=args.condition,
+    )
+
+    # Print evaluation results
+    print_evaluation_results(eval_result)
+
+    # Generate and save report
+    evaluator = Evaluator(output_dir=args.output)
+
+    wer_results = [eval_result.wer_result] if eval_result.wer_result else []
+    der_results = [eval_result.der_result] if eval_result.der_result else []
+
+    # Pass evaluation metadata for reproducibility & documentation
+    report = evaluator.generate_evaluation_report(
+        wer_results=wer_results,
+        der_results=der_results,
+        summary_results=[eval_result.summary_result] if eval_result.summary_result else None,
+        sample_names=[eval_result.sample_name],
+        condition_name=args.condition,
+        metadata=eval_result.metadata,
+    )
+
+    # Save report
+    report_path = evaluator.save_report(
+        report,
+        f"evaluation_{eval_result.sample_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
+    )
+    print(f"\nEvaluation report saved: {report_path}")
+
+
+def print_result_summary(result: PipelineResult):
+    """Print processing result summary"""
+    print(f"\n{'='*60}")
+    print("HASIL PEMROSESAN")
+    print(f"{'='*60}")
+    print(f"  Audio Duration    : {format_duration(result.audio_duration)}")
+    print(f"  Speakers Found    : {result.num_speakers}")
+    print(f"  Total Segments    : {result.num_segments}")
+    print(f"  Total Words       : {result.total_words}")
+    print(f"  Processing Time   : {format_duration(result.processing_time)}")
+    print(f"  Output Document   : {result.document_path}")
+    print(f"{'='*60}")
+
+
+def print_evaluation_results(eval_result: EvaluationResult):
+    """Print evaluation results"""
+    print("\n--- Hasil Evaluasi ---")
+
+    if eval_result.wer_result:
+        wer = eval_result.wer_result
+        print("\nWord Error Rate (WER):")
+        print(f"  WER           : {wer.wer:.4f} ({wer.wer*100:.2f}%)")
+        print(f"  Substitutions : {wer.substitutions}")
+        print(f"  Deletions     : {wer.deletions}")
+        print(f"  Insertions    : {wer.insertions}")
+        print(f"  Correct       : {wer.hits}")
+
+    if eval_result.der_result:
+        der = eval_result.der_result
+        print("\nDiarization Error Rate (DER):")
+        print(f"  DER               : {der.der:.4f} ({der.der*100:.2f}%)")
+        print(f"  Missed Speech     : {der.missed_speech:.4f} ({der.missed_speech*100:.2f}%)")
+        print(f"  False Alarm       : {der.false_alarm:.4f} ({der.false_alarm*100:.2f}%)")
+        print(
+            f"  Speaker Confusion : {der.speaker_confusion:.4f} ({der.speaker_confusion*100:.2f}%)"
+        )
+
+    # Summary metrics (if available)
+    if eval_result.summary_result:
+        s = eval_result.summary_result
+        print("\nRingkasan (Summary) Evaluation:")
+        try:
+            print(f"  ROUGE-1 F1    : {s.rouge.get('rouge1_f', 0.0):.4f}")
+            print(f"  ROUGE-2 F1    : {s.rouge.get('rouge2_f', 0.0):.4f}")
+            print(f"  ROUGE-L F1    : {s.rouge.get('rougel_f', 0.0):.4f}")
+            print(f"  BERTScore F1  : {s.bertscore.get('bertscore_f1', 0.0):.4f}")
+        except Exception as e:
+            print(f"  (failed to print summary metrics: {e})")
+
+
+def print_batch_summary(
+    results: List[PipelineResult], failed: List[tuple], total_files: List[Path]
+):
+    """Print batch processing summary"""
+    print(f"\n{'='*60}")
+    print("RINGKASAN BATCH PROCESSING")
+    print(f"{'='*60}")
+    print(f"  Total files       : {len(total_files)}")
+    print(f"  Successful        : {len(results)}")
+    print(f"  Failed            : {len(failed)}")
+
+    if results:
+        total_duration = sum(r.audio_duration for r in results)
+        total_time = sum(r.processing_time for r in results)
+        avg_time = total_time / len(results)
+
+        print(f"  Total audio       : {format_duration(total_duration)}")
+        print(f"  Total proc. time  : {format_duration(total_time)}")
+        print(f"  Avg time/file     : {format_duration(avg_time)}")
+
+    if failed:
+        print("\n  Failed files:")
+        for filename, error in failed:
+            print(f"    - {filename}: {error[:50]}...")
+
+    print(f"{'='*60}")
+
+
+def main():
+    """Main entry point"""
+    args = parse_args()
+
+    # Handle quiet mode
+    verbose = not args.quiet and args.verbose
+
+    if verbose:
+        print_banner()
+
+    # Validate input
+    if not args.audio and not args.batch:
+        print("Error: Harap tentukan --audio atau --batch")
+        print("Gunakan --help untuk informasi penggunaan")
+        sys.exit(1)
+
+    # Determine device
+    device = args.device
+    if device == "auto":
+        import torch
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    if verbose:
+        print("\nDevice: {}".format(device))
+        print("ASR Backend: {}".format(args.asr_backend))
+        print("ASR Model: {}".format(args.asr_model))
+        print("ASR Language: {}".format(args.asr_language))
+        print("Output Dir: {}".format(args.output))
+
+    # Initialize pipeline
+    config = PipelineConfig(
+        output_dir=args.output,
+        asr_model_id=args.asr_model,
+        asr_backend=args.asr_backend,
+        asr_language=args.asr_language,
+        whisperx_compute_type=args.whisperx_compute_type,
+        whisperx_vad_filter=not args.whisperx_no_vad_filter,
+        device=device,
+        verbose=verbose,
+        save_intermediate=not args.no_save_intermediate,
+        fast_mode=args.fast,
+        quick_asr=args.quick_asr,
+        prefer_whisper_small=args.prefer_whisper_small,
+        cst_hz=args.cst_hz,
+        diarization_compare=args.diarization_compare,
+        embedding_cache=not args.no_embedding_cache,
+        target_speakers=args.target_speakers,
+        # New flags
+        asr_parallel_workers=args.parallel_workers,
+        speaker_map_path=args.speaker_map,
+        tune_diarization=args.tune_diarization,
+        num_speakers=args.speakers,
+        preset=args.preset,
+    )
+
+    pipeline = MeetingTranscriberPipeline(config)
+
+    # Run processing
+    try:
+        if args.batch:
+            process_batch(args, pipeline)
+        else:
+            process_single_audio(args, pipeline)
+
+        print("\nSelesai!")
+
+    except KeyboardInterrupt:
+        print("\n\nProses dibatalkan oleh user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\nError: {e}")
+        if verbose:
+            import traceback
+
+            traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,72 @@
-altair
-pandas
-streamlit
+# =============================================================================
+# REQUIREMENTS - Sistem Notulensi Rapat Otomatis
+# SpeechBrain + BERT Pipeline
+# =============================================================================
+
+# Core Deep Learning
+torch>=2.0.0
+torchaudio>=2.0.0
+
+# Speech Processing (SpeechBrain)
+speechbrain>=0.5.15
+
+# NLP & Transformers
+transformers>=4.30.0
+sentence-transformers>=2.2.0
+tokenizers>=0.13.0
+
+# Audio Processing
+librosa>=0.10.0
+soundfile>=0.12.0
+pydub>=0.25.1
+webrtcvad>=2.0.10
+
+# Document Generation
+python-docx>=0.8.11
+
+# Evaluation Metrics
+jiwer>=3.0.0
+
+# Data Processing
+numpy>=1.24.0
+pandas>=2.0.0
+scipy>=1.10.0
+
+# Machine Learning
+scikit-learn>=1.3.0
+
+# Visualization
+matplotlib>=3.7.0
+seaborn>=0.12.0
+
+# Configuration
+pyyaml>=6.0
+python-dotenv>=1.0.0
+
+# Utilities
+tqdm>=4.65.0
+colorama>=0.4.6
+tabulate>=0.9.0
+
+# Jupyter (untuk notebooks)
+jupyter>=1.0.0
+ipywidgets>=8.0.0
+
+# Testing
+pytest>=7.0.0
+
+# Web UI
+streamlit>=1.18.0
+
+# Optional: GPU monitoring
+# nvidia-ml-py>=12.0.0
+
+# Training & Evaluation (for Whisper fine-tuning)
+datasets>=2.14.0
+evaluate>=0.4.0
+accelerate>=0.20.3
+peft>=0.4.0
+transformers[torch]>=4.30.0
+ffmpeg-python>=0.1.18
+langdetect>=1.0.9
+whisperx>=1.0.0

setup.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""
+Setup script for Meeting Transcriber package
+"""
+
+from setuptools import find_packages, setup
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh if line.strip() and not line.startswith("#")]
+
+setup(
+    name="meeting-transcriber",
+    version="1.0.0",
+    author="Yermia Turangan",
+    author_email="yermiaturangan026@student.unsrat.ac.id",
+    description="Sistem Notulensi Rapat Otomatis berbasis SpeechBrain dan BERT",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/username/meeting-transcriber",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Topic :: Multimedia :: Sound/Audio :: Speech",
+    ],
+    python_requires=">=3.8",
+    install_requires=requirements,
+    entry_points={
+        "console_scripts": [
+            "meeting-transcriber=main:main",
+        ],
+    },
+)

streamlit_app.py

@@ -0,0 +1,259 @@
+import os
+import tempfile
+from pathlib import Path
+
+import streamlit as st
+
+from src.pipeline import MeetingTranscriberPipeline, PipelineConfig
+
+st.set_page_config(page_title="Meeting Transcriber", layout="wide")
+
+st.title("Meeting Transcriber — Demo")
+st.markdown(
+    "Upload an audio file or pick a sample to generate transcript, summary and downloadable DOCX."
+)
+
+# Sample audio chooser
+AUDIO_DIR = Path.cwd() / "data" / "audio"
+# Build safe sample list: prefer paths relative to cwd, but fall back to absolute paths if not possible
+SAMPLES = []
+for p in AUDIO_DIR.rglob("*.mp3"):
+    try:
+        SAMPLES.append(str(p.relative_to(Path.cwd())))
+    except ValueError:
+        # Path is not under cwd (different drive or external mount), use absolute path
+        SAMPLES.append(str(p.resolve()))
+
+with st.sidebar:
+    st.header("Settings")
+    # Detect deployment target (e.g., set STREAMLIT_DEPLOY_TARGET=community on Streamlit Cloud)
+    deploy_target = os.getenv("STREAMLIT_DEPLOY_TARGET", "")
+    # Community Cloud has no GPU and limited CPU/time; default to 'fast' preset there
+    default_index = 0
+    default_quick_asr = False
+    if deploy_target.lower() == "community":
+        default_index = 2  # 'fast'
+        default_quick_asr = True
+        st.info(
+            "Running in Streamlit Community mode: using fast preset and quick ASR for responsiveness."
+        )
+
+    preset = st.selectbox(
+        "Preset", ["deployment", "balanced", "fast", "accurate"], index=default_index
+    )
+    quick_asr = st.checkbox("Quick ASR (override)", value=default_quick_asr)
+    parallel_workers = st.number_input(
+        "Parallel workers (0 = auto)", min_value=0, max_value=16, value=0
+    )
+    sample_choice = st.selectbox("Pick sample audio (optional)", ["None"] + SAMPLES)
+
+uploaded_file = st.file_uploader("Upload audio (.wav, .mp3, .m4a)")
+
+# Determine audio path
+audio_path = None
+if uploaded_file is not None:
+    tmpdir = tempfile.gettempdir()
+    tmp_path = Path(tmpdir) / uploaded_file.name
+    with open(tmp_path, "wb") as f:
+        f.write(uploaded_file.read())
+    audio_path = str(tmp_path)
+elif sample_choice and sample_choice != "None":
+    audio_path = sample_choice
+
+if not audio_path:
+    st.info("Upload an audio file or pick a sample from the sidebar to begin.")
+
+# Interactive flow: run diarization first and allow manual mapping
+# Clear existing session state if user changed audio selection
+if "diarization_done" in st.session_state and st.session_state.get("audio_path") != audio_path:
+    # Keep only unrelated session keys
+    for k in [
+        "diarization_done",
+        "pipeline",
+        "dz_res",
+        "sample_segments",
+        "snippet_transcripts",
+        "result",
+        "mapping",
+    ]:
+        if k in st.session_state:
+            del st.session_state[k]
+
+if st.button("Run diarization only"):
+    if not audio_path:
+        st.error("Please provide audio first.")
+    else:
+        cfg = PipelineConfig(preset=preset, quick_asr=quick_asr)
+        if parallel_workers and parallel_workers > 0:
+            cfg.asr_parallel_workers = int(parallel_workers)
+        pipeline = MeetingTranscriberPipeline(cfg)
+
+        with st.spinner("Running diarization..."):
+            try:
+                dz_res = pipeline.run_diarization(audio_path)
+                st.success("Diarization complete")
+            except Exception as e:
+                st.error(f"Diarization failed: {e}")
+                raise
+
+        # Persist state so interactive widgets survive reruns
+        st.session_state["diarization_done"] = True
+        st.session_state["pipeline"] = pipeline
+        st.session_state["dz_res"] = dz_res
+        st.session_state["audio_path"] = audio_path
+
+# If we already have diarization state (either just-run or from previous interaction), show mapping UI
+if st.session_state.get("diarization_done") and audio_path:
+    pipeline = st.session_state["pipeline"]
+    dz_res = st.session_state["dz_res"]
+
+    st.write(
+        f"Detected {len(dz_res['unique_speakers'])} speakers and {dz_res['num_segments']} segments"
+    )
+
+    # Playable sample and quick per-speaker snippets so user can listen/read before mapping
+    st.subheader("Sample snippets (listen + read before mapping)")
+
+    # Try to reuse cached sample snippets if present
+    sample_segments = st.session_state.get("sample_segments") or {}
+    snippet_transcripts = st.session_state.get("snippet_transcripts") or {}
+
+    if not sample_segments:
+        try:
+            dsegs = pipeline._diarization_segments or []
+            for spk in dz_res["unique_speakers"]:
+                cand = [s for s in dsegs if s.speaker_id == spk]
+                if not cand:
+                    continue
+                best = max(cand, key=lambda x: x.duration)
+                cap_end = min(best.end, best.start + 10.0)
+                from src.diarization import SpeakerSegment
+
+                sample_segments[spk] = SpeakerSegment(
+                    speaker_id=best.speaker_id,
+                    start=best.start,
+                    end=cap_end,
+                    confidence=best.confidence,
+                    is_overlap=best.is_overlap,
+                    metadata=best.metadata.copy() if getattr(best, "metadata", None) else {},
+                )
+            st.session_state["sample_segments"] = sample_segments
+        except Exception as e:
+            st.warning(f"Could not prepare sample segments: {e}")
+            sample_segments = {}
+
+    # Run quick per-segment ASR for the sample snippets (avoid full-audio mapping for speed)
+    if not snippet_transcripts and sample_segments:
+        try:
+            transcriber = pipeline.transcriber
+            orig_full_audio = getattr(transcriber.config, "use_full_audio_for_segments", False)
+            transcriber.config.use_full_audio_for_segments = False
+            orig_workers = getattr(transcriber.config, "parallel_workers", 1)
+            transcriber.config.parallel_workers = 1
+
+            transcripts = transcriber.transcribe_segments(
+                pipeline._waveform, list(sample_segments.values()), pipeline._sample_rate
+            )
+            for t in transcripts:
+                snippet_transcripts[t.speaker_id] = t.text
+
+            transcriber.config.use_full_audio_for_segments = orig_full_audio
+            transcriber.config.parallel_workers = orig_workers
+
+            st.session_state["snippet_transcripts"] = snippet_transcripts
+        except Exception as e:
+            st.warning(f"Quick snippet transcription failed: {e}")
+
+    # Display snippets in columns with audio player + short transcript
+    import tempfile
+
+    import soundfile as sf
+
+    mapping = st.session_state.get("mapping") or {}
+    st.subheader("Manual speaker mapping")
+    audio_id = Path(audio_path).stem
+    for spk in dz_res["unique_speakers"]:
+        with st.expander(f"Speaker: {spk}"):
+            col1, col2 = st.columns([1, 2])
+            with col1:
+                seg = sample_segments.get(spk)
+                if seg is not None:
+                    try:
+                        sr = pipeline._sample_rate
+                        start_sample = int(seg.start * sr)
+                        end_sample = int(seg.end * sr)
+                        audio_np = (
+                            pipeline._waveform[:, start_sample:end_sample].squeeze().cpu().numpy()
+                        )
+                        tmpf = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+                        sf.write(tmpf.name, audio_np, sr)
+                        st.audio(tmpf.name)
+                    except Exception as e:
+                        st.warning(f"Could not prepare audio snippet: {e}")
+                else:
+                    st.write("No sample segment available for this speaker")
+            with col2:
+                st.write("**Sample transcript:**")
+                st.write(snippet_transcripts.get(spk, "(no transcription available)"))
+                key = f"map_{audio_id}_{spk}"
+                # Preserve user input across reruns by using session state keys
+                default_val = mapping.get(spk, spk)
+                mapping_val = st.text_input(f"Map {spk} to name", value=default_val, key=key)
+                mapping[spk] = mapping_val
+
+    st.session_state["mapping"] = mapping
+
+    if st.button("Apply mapping and continue processing"):
+        pipeline.apply_speaker_map(mapping, save_to_cache=True, audio_id=audio_id)
+        with st.spinner("Running full processing..."):
+            try:
+                res = pipeline.continue_from_diarization(title="Streamlit run")
+                st.session_state["result"] = res
+                st.success("Processing complete")
+            except Exception as e:
+                st.error(f"Processing failed: {e}")
+                raise
+
+    # If result available, display
+    if st.session_state.get("result"):
+        res = st.session_state["result"]
+        st.subheader("Summary")
+        st.json(res.summary or {})
+
+        st.subheader("Transcript (first 5000 characters)")
+        st.text(res.transcript_text[:5000])
+
+        if res.document_path and os.path.exists(res.document_path):
+            with open(res.document_path, "rb") as fh:
+                doc_bytes = fh.read()
+            st.download_button(
+                "Download .docx", data=doc_bytes, file_name=Path(res.document_path).name
+            )
+
+        st.write("---")
+        st.write("Processing metadata:")
+        st.write(
+            {
+                "Audio duration": res.audio_duration,
+                "Speakers found": res.num_speakers,
+                "Segments": res.num_segments,
+                "Total words": res.total_words,
+                "Processing time (s)": res.processing_time,
+            }
+        )
+
+        st.balloons()
+
+    # Allow clearing state
+    if st.button("Clear diarization state"):
+        for k in [
+            "diarization_done",
+            "pipeline",
+            "dz_res",
+            "sample_segments",
+            "snippet_transcripts",
+            "result",
+            "mapping",
+        ]:
+            if k in st.session_state:
+                del st.session_state[k]