feat: Add Predict text

README.md

@@ -1,87 +1,177 @@
----
-title: WhisperPyanoteLLM
-emoji: 📉
-colorFrom: indigo
-colorTo: green
-sdk: docker
-pinned: false
-license: apache-2.0
----
+# 🎤 Advanced Voice Diarization System
+
+ระบบแยกเสียงพูดและถอดเสียงขั้นสูงที่รองรับการพูดทับซ้อนกัน พร้อมการปรับปรุงข้อความด้วย AI สำหรับภาษาไทย
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## ✨ คุณสมบัติหลัก
 
-# WhisperPyanoteLLM
+### 🔄 **ขั้นตอนการประมวลผล 6 ขั้นตอน**
+1. **Preprocess** - ปรับเสียงเป็น 16 kHz mono และ normalize
+2. **Diarization** - แยก speaker และตรวจจับการพูดทับซ้อน
+3. **Branching Logic** - แยกเส้นทางการประมวลผล Clean vs Overlap
+4. **ASR Processing** - ถอดเสียงแบบ deterministic หรือแยกเสียงด้วย Asteroid
+5. **Timeline Stitching** - รวมผลลัพธ์ตามลำดับเวลา
+6. **Post-processing** - ปรับปรุงข้อความไทยด้วย LLM
 
-A FastAPI-based app for speaker diarization and transcription using Whisper and PyAnnote, with LLM-powered summarization.
+### 🎯 **เทคโนโลยีที่ใช้**
+- **PyAnnote** - Speaker diarization และ overlap detection
+- **Whisper** - Speech-to-text transcription
+- **Asteroid ConvTasNet** - Source separation สำหรับเสียงทับซ้อน
+- **SpeechBrain** - Speaker embedding และ matching
+- **LLM** - Text correction และ normalization
 
-## Features
-- Speaker diarization with pyannote.audio
-- Transcription with OpenAI Whisper
-- Summarization with Together LLM
-- REST API for video/audio upload and processing
+### 📊 **ผลลัพธ์ที่ได้**
+- แยก speaker พร้อมช่วงเวลาที่แม่นยำ
+- ข้อความที่ถอดจากเสียงพร้อมค่าความเชื่อมั่น
+- การตรวจจับและประมวลผลเสียงทับซ้อน
+- สถิติการประมวลผล (overlap ratio, confidence scores)
+- Export หลายรูปแบบ: JSON, SRT, VTT, TXT
 
-## Quick Start (Development)
+## 🚀 การติดตั้งและใช้งาน
 
-1. **Clone the repository:**
-   ```sh
+### การพัฒนา (Development)
+
+1. **Clone repository:**
+   ```bash
    git clone <your-repo-url>
-   cd WhisperPyanoteLLM
+   cd project-voice-diarzation
    ```
 
-2. **Create a `.env` file:**
+2. **ตั้งค่า Python Environment (เลือก 1 วิธี):**
+
+   **Option A: ใช้ Conda (แนะนำ)**
+   ```bash
+   # สร้าง environment ใหม่
+   conda create -n voice-diarization python=3.9
+   conda activate voice-diarization
+   
+   # ติดตั้ง PyTorch สำหรับ CUDA (ถ้ามี GPU)
+   conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
+   
+   # หรือสำหรับ CPU เท่านั้น
+   # conda install pytorch torchvision torchaudio cpuonly -c pytorch
+   ```
+
+   **Option B: ใช้ pyenv + venv**
+   ```bash
+   # ติดตั้ง Python version ที่ต้องการ
+   pyenv install 3.9.18
+   pyenv local 3.9.18
+   
+   # สร้าง virtual environment
+   python -m venv venv
+   source venv/bin/activate  # macOS/Linux
+   # หรือ venv\Scripts\activate  # Windows
+   ```
+
+   **Option C: ใช้ pip + venv (พื้นฐาน)**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # macOS/Linux
+   # หรือ venv\Scripts\activate  # Windows
+   ```
+
+3. **สร้างไฟล์ `.env`:**
    ```env
    HF_TOKEN=your_huggingface_token
    TOGETHER_API_KEY=your_together_api_key
    NGROK_AUTH_TOKEN=your_ngrok_token
    ```
 
-3. **Install dependencies:**
-   ```sh
+4. **ติดตั้ง dependencies:**
+   ```bash
    pip install -r requirements.txt
    ```
 
-4. **Run the app:**
-   ```sh
+5. **รันแอปพลิเคชัน:**
+   ```bash
    uvicorn app:app --reload --port 8300
    ```
 
-5. **Access the API:**
-   - Health check: [http://localhost:8300/health](http://localhost:8300/health)
+6. **เข้าใช้งาน API:**
+   - Health check: http://localhost:8300/health
    - Upload endpoint: `/upload_video/`
+   - API docs: http://localhost:8300/docs
 
----
-
-## Production (Docker)
+### การใช้งานจริง (Production)
 
-1. **Create a `.env.prod` file:**
+1. **สร้างไฟล์ `.env.prod`:**
    ```env
    HF_TOKEN=your_huggingface_token
    TOGETHER_API_KEY=your_together_api_key
    NGROK_AUTH_TOKEN=your_ngrok_token
    ```
 
-2. **Build the Docker image:**
-   ```sh
-   docker build -t whisperpyanote .
+2. **Build Docker image:**
+   ```bash
+   docker build -t voice-diarization .
    ```
 
-3. **Run the Docker container:**
-   ```sh
-   docker run --env-file .env.prod -p 8300:8300 whisperpyanote
+3. **Run Docker container:**
+   ```bash
+   docker run --env-file .env.prod -p 8300:8300 voice-diarization
    ```
 
-4. **Access the API:**
-   - Health check: [http://localhost:8300/health](http://localhost:8300/health)
-   - Upload endpoint: `/upload_video/`
-
----
+## 📋 ตัวอย่างผลลัพธ์
+
+```json
+{
+  "data": [
+    {
+      "speaker": "SPEAKER_00",
+      "start": 0.5,
+      "end": 3.2,
+      "text": "สวัสดีครับทุกคน วันนี้เราจะมาประชุมเรื่องโปรเจคใหม่",
+      "confidence": 0.92,
+      "has_overlap": false,
+      "processing_type": "clean"
+    }
+  ],
+  "processing_stats": {
+    "clean_segments": 3,
+    "overlap_segments": 2,
+    "overlap_ratio": 0.192,
+    "avg_confidence": 0.856
+  }
+}
+```
+
+## 🔧 การกำหนดค่า
+
+### ข้อกำหนดระบบ
+- **GPU**: CUDA-enabled GPU แนะนำสำหรับประสิทธิภาพสูงสุด
+- **RAM**: อย่างน้อย 8GB
+- **Python**: 3.8+
+
+### ไฟล์ที่รองรับ
+- **Audio**: WAV, MP3, M4A, FLAC
+- **Video**: MP4, AVI, MOV, MKV
+
+## 📚 API Documentation
+
+### POST `/upload_video/`
+อัปโหลดไฟล์เสียงหรือวิดีโอเพื่อประมวลผล
+
+**Parameters:**
+- `file`: ไฟล์เสียงหรือวิดีโอ
+- `num_speakers` (optional): จำนวน speaker ที่คาดหวัง
+
+**Response:**
+- ผลลัพธ์การแยกเสียงและถอดเสียงแบบละเอียด
+- สถิติการประมวลผล
+- ข้อมูลการพูดทับซ้อน
+
+## ⚠️ ข้อควรระวัง
+
+- ไฟล์ `.env` และ `.env.prod` **ห้าม** commit ลง version control
+- สำหรับประสิทธิภาพสูงสุด ควรใช้เครื่องที่มี CUDA GPU
+- การประมวลผลไฟล์ขนาดใหญ่อาจใช้เวลานาน
+
+## 📄 License
 
-## Notes
-- Make sure your `.env` and `.env.prod` files are **not** committed to version control.
-- For best performance, run on a machine with a CUDA-enabled GPU.
-- For more details, see the code and comments in `app.py`.
+Apache-2.0
 
 ---
 
-## License
-Apache-2.0
+**พัฒนาโดย:** Advanced Voice Processing Team  
+**เวอร์ชัน:** 2.0  
+**อัปเดตล่าสุด:** สิงหาคม 2024

app.py

@@ -27,6 +27,7 @@ from utils import (
     summarize_texts,
     add_llm_spell_corrected_text_column,
     download_to_temp,
+    process_segments_with_branching
 )
 # from supabase import create_client, Client
 
@@ -59,7 +60,7 @@ async def startup_event():
 
         logger.info("🔁 Loading models at startup...")
         try:
-            pipeline, model = await load_model_bundle()
+            pipeline, model, overlap_pipeline = await load_model_bundle()
         except Exception as e:
             logger.exception(f"❌ Model loading failed: {e}")
             import sys; sys.exit(1)
@@ -135,25 +136,86 @@ def upload_video(video_path: str):
     from config import together_api_key
     # video_path = save_uploaded_file(file)
     audio_path = extract_and_normalize_audio(video_path)
+    
+    # (1) Diarization + Overlap Detection
     df_diarization = diarize_audio(audio_path)
-    segment_folder = split_segments(audio_path, df_diarization)
-    df_transcriptions = transcribe_segments(segment_folder)
-    min_len = min(len(df_diarization), len(df_transcriptions))
-    df_merged = pd.concat([
-        df_diarization.iloc[:min_len].reset_index(drop=True),
-        df_transcriptions.iloc[:min_len].reset_index(drop=True)
-    ], axis=1)
-    # df_merged = add_corrected_text_column(df_merged)
-    df_merged = add_llm_spell_corrected_text_column(df_merged)
-    # summaries = summarize_texts(df_merged["text"].tolist(), together_api_key, delay=0)
-    result = df_merged.to_dict(orient="records")
+    
+    # (2-4) Branching Logic + Source Separation + Transcription + Timeline Stitching
+    branching_results = process_segments_with_branching(audio_path, df_diarization)
+    
+    # รวมผลลัพธ์จาก clean และ overlap segments
+    all_transcriptions = []
+    
+    # เพิ่มผลจาก clean segments
+    for i, clean_trans in enumerate(branching_results["clean_transcriptions"]):
+        # ใช้ index ในการจับคู่แทน filename
+        if i < len(branching_results["clean_segments"]):
+            segment = branching_results["clean_segments"][i]
+            all_transcriptions.append({
+                "speaker": segment["speaker"],
+                "start": segment["start"],
+                "end": segment["end"],
+                "duration": segment["duration"],
+                "confidence": segment.get("confidence", 0.5),
+                "text": clean_trans["text"],
+                "text_array": clean_trans.get("text_array", [clean_trans["text"]]),
+                "avg_probability": clean_trans["avg_probability"],
+                "has_overlap": segment.get("has_overlap", False),
+                "overlap_ratio": segment.get("overlap_ratio", 0.0),
+                "is_remove": segment.get("is_remove", False),
+                "remove_reason": segment.get("remove_reason", ""),
+                "processing_type": "clean",
+                "overlap_detail": []
+            })
+    
+    # เพิ่มผลจาก overlap segments
+    for overlap_trans in branching_results["overlap_transcriptions"]:
+        original_segment = overlap_trans["original_segment"]
+        all_transcriptions.append({
+            "speaker": overlap_trans["speaker"],
+            "start": original_segment["start"],
+            "end": original_segment["end"],
+            "duration": original_segment["duration"],
+            "confidence": original_segment.get("confidence", 0.5),
+            "text": overlap_trans["transcription"]["text"],
+            "text_array": overlap_trans["transcription"].get("text_array", [overlap_trans["transcription"]["text"]]),
+            "avg_probability": overlap_trans["transcription"]["avg_probability"],
+            "has_overlap": True,
+            "overlap_ratio": original_segment.get("overlap_ratio", 1.0),
+            "is_remove": original_segment.get("is_remove", False),
+            "remove_reason": original_segment.get("remove_reason", ""),
+            "processing_type": "overlap_separated",
+            "stream_id": overlap_trans["stream_id"],
+            "overlap_detail": overlap_trans.get("matched_streams", [])
+        })
+    
+    # เรียงตามเวลา
+    all_transcriptions.sort(key=lambda x: x["start"])
+    
+    # (5) Post-process - LLM correction
+    df_merged = pd.DataFrame(all_transcriptions)
+    if not df_merged.empty:
+        df_merged = add_llm_spell_corrected_text_column(df_merged)
+        result = df_merged.to_dict(orient="records")
+    else:
+        result = []
+    
+    # สถิติ
     speaker_array = df_diarization["speaker"].unique().tolist()
     counter = Counter(df_diarization["speaker"])
     result_array = [{"speaker": spk, "count": cnt} for spk, cnt in counter.most_common()]
+    
     from pydub import AudioSegment
     duration_minutes = len(AudioSegment.from_wav(audio_path)) / 1000 / 60
-    # save result to supabase
-    # supabase.table("summaries").insert(result).execute()
+    
+    # คำนวณ metrics
+    overlap_segments_count = len(branching_results["overlap_segments"])
+    clean_segments_count = len(branching_results["clean_segments"])
+    total_segments = overlap_segments_count + clean_segments_count
+    overlap_ratio = overlap_segments_count / max(total_segments, 1)
+    
+    avg_confidence = np.mean([r.get("confidence", 0.5) for r in result]) if result else 0.0
+    
     return {
         "video_path": video_path,
         "audio_path": audio_path,
@@ -162,8 +224,16 @@ def upload_video(video_path: str):
         "speaker_array": speaker_array,
         "count_speaker": result_array,
         "num_speakers": len(speaker_array),
-        "total_sentence": len(df_merged['text']),
+        "total_sentence": len(result),
         "summaries": 'This feature not available',
+        # เพิ่ม metrics ใหม่
+        "processing_stats": {
+            "clean_segments": clean_segments_count,
+            "overlap_segments": overlap_segments_count,
+            "overlap_ratio": round(overlap_ratio, 3),
+            "avg_confidence": round(avg_confidence, 3),
+            "branching_enabled": True
+        }
     }
 
 

models.py

@@ -34,11 +34,10 @@ def setup_together_and_ngrok():
 together = setup_together_and_ngrok()
 
 async def load_model_bundle():
-    global pipelines, models
-    # , overlap_pipeline
-    if pipelines and models:
+    global pipelines, models, overlap_pipeline
+    if pipelines and models and overlap_pipeline:
         logger.info("✅ Models already loaded. Skipping reinitialization.")
-        return pipelines[0], models[0]
+        return pipelines[0], models[0], overlap_pipeline
     def _load_models():
         n = torch.cuda.device_count()
         logger.info(f"🖥️ Found {n} CUDA device(s)")
@@ -58,11 +57,11 @@ async def load_model_bundle():
             cache_dir=HF_CACHE_DIR
         ).to(device_torch)
 
-        # overlap_pipeline = Pipeline.from_pretrained(
-        #         "pyannote/overlapped-speech-detection",
-        #         use_auth_token=token,
-        #         cache_dir=HF_CACHE_DIR  # ใช้ cache เดียวกับโมเดลอื่น
-        #     )
+        overlap_pipeline = Pipeline.from_pretrained(
+                "pyannote/overlapped-speech-detection",
+                use_auth_token=token,
+                cache_dir=HF_CACHE_DIR
+            ).to(device_torch)
         model_fallback_chain = [PREFERRED_MODEL] + [m for m in FALLBACK_MODELS if m != PREFERRED_MODEL]
 
         model = None
@@ -80,7 +79,7 @@ async def load_model_bundle():
         
         pipelines.append(pipeline)
         models.append(model)
-        return pipeline, model,
+        return pipeline, model, overlap_pipeline
 
     loop = asyncio.get_event_loop()
     return await loop.run_in_executor(None, _load_models)

requirements.txt

@@ -16,6 +16,11 @@ faster-whisper==1.1.1
 librosa==0.10.1
 soundfile==0.12.1
 
+# Source separation and speaker recognition
+asteroid-filterbanks==0.4.0
+speechbrain==0.5.16
+torchaudio>=0.13.0
+
 # API and networking
 python-multipart==0.0.6
 pyngrok==7.0.0

utils.py

@@ -11,7 +11,7 @@ import numpy as np
 from collections import Counter
 import time
 from config import UPLOAD_FOLDER
-from models import pipelines, models, together
+from models import pipelines, models, together, overlap_pipeline
 import subprocess
 import librosa
 from pydantic import BaseModel, AnyHttpUrl
@@ -133,7 +133,7 @@ def split_segments(audio_path: str, df: pd.DataFrame, stretch_factor: float = 1.
 
     return segment_folder
 
-def transcribe_segments(segment_folder: str) -> pd.DataFrame:
+def transcribe_segments(segment_folder: str, num_rounds: int = 3) -> pd.DataFrame:
     files = sorted([f for f in os.listdir(segment_folder) if f.endswith(".wav")])
     model = models[0]
 
@@ -143,41 +143,60 @@ def transcribe_segments(segment_folder: str) -> pd.DataFrame:
         segment_path = os.path.join(segment_folder, filename)
 
         try:
-            segments, _ = model.transcribe(
-                segment_path,
-                language="th",
-                beam_size=5,
-                vad_filter=True,
-                word_timestamps=True
-            )
-
-            # ดึงคำทั้งหมดจากทุก segment
-            words = [word for seg in segments if hasattr(seg, "words") for word in seg.words]
-
-            if words:
-                full_text = ''.join([w.word for w in words])
-                probs = [w.probability for w in words if w.probability is not None]
-                avg_prob = float(np.mean(probs)) if probs else 0.0
-                avg_prob = round(avg_prob, 4)       
-
-                results.append({
-                    "filename": filename,
-                    "text": full_text,
-                    "avg_probability": avg_prob,
-                })
+            text_array = []
+            prob_array = []
+            
+            # ทำ transcription หลายรอบ
+            for round_num in range(num_rounds):
+                segments, _ = model.transcribe(
+                    segment_path,
+                    language="th",
+                    beam_size=5,
+                    vad_filter=True,
+                    word_timestamps=True,
+                    temperature=0.0 if round_num == 0 else 0.2  # รอบแรกใช้ deterministic
+                )
+
+                # ดึงคำทั้งหมดจากทุก segment
+                words = [word for seg in segments if hasattr(seg, "words") for word in seg.words]
+
+                if words:
+                    full_text = ''.join([w.word for w in words])
+                    probs = [w.probability for w in words if w.probability is not None]
+                    avg_prob = round(np.mean(probs), 4) if probs else 0.0
+                    avg_prob = round(avg_prob, 4)
+                    
+                    text_array.append(full_text)
+                    prob_array.append(avg_prob)
+                else:
+                    text_array.append("")
+                    prob_array.append(0.0)
+
+            # เลือกผลลัพธ์ที่ดีที่สุด (probability สูงสุด)
+            if prob_array and max(prob_array) > 0:
+                best_idx = prob_array.index(max(prob_array))
+                best_text = text_array[best_idx]
+                best_prob = prob_array[best_idx]
             else:
-                results.append({
-                    "filename": filename,
-                    "text": "",
-                    "avg_probability": 0.0,
-                })
+                best_text = text_array[0] if text_array else ""
+                best_prob = prob_array[0] if prob_array else 0.0
+
+            results.append({
+                "filename": filename,
+                "text": best_text,
+                "text_array": text_array,
+                "avg_probability": best_prob,
+                "prob_array": prob_array,
+            })
 
         except Exception as e:
             print(f"❌ Error with {filename}: {e}")
             results.append({
                 "filename": filename,
                 "text": "",
+                "text_array": ["", "", ""],
                 "avg_probability": 0.0,
+                "prob_array": [0.0, 0.0, 0.0],
                 "error": str(e)
             })
 
@@ -301,18 +320,43 @@ def add_llm_spell_corrected_text_column(df, model="google/gemma-3-27b-it", delay
         ]
         return any(k in msg for k in keys)
 
-    texts = df["text"].fillna("").astype(str).tolist()
+    # ใช้ text_array ถ้ามี ไม่งั้นใช้ text เดี่ยว
+    if "text_array" in df.columns:
+        text_arrays = df["text_array"].fillna("").tolist()
+    else:
+        texts = df["text"].fillna("").astype(str).tolist()
+        text_arrays = [[text] for text in texts]  # แปลงเป็น array
+    
     corrected = []
 
-    for idx, text in enumerate(texts):
+    for idx, text_array in enumerate(text_arrays):
+        # ถ้าเป็น string เดี่ยว แปลงเป็น list
+        if isinstance(text_array, str):
+            text_array = [text_array]
+        
+        # ถ้าไม่มีข้อความ skip
+        if not text_array or all(not t.strip() for t in text_array):
+            corrected.append("")
+            continue
+
+        # สร้าง prompt ให้ LLM เลือกและแก้ไข
+        text_options = "\n".join([f"ตัวเลือก {i+1}: {text}" for i, text in enumerate(text_array) if text.strip()])
+        
         prompt = f"""
-                กรุณาแก้ไขข้อความต่อไปนี้ให้ถูกต้องตามหลักภาษาไทย:
+                จากตัวเลือกข้อความต่อไปนี้ กรุณาเลือกตัวเลือกที่ดีที่สุด แล้วแก้ไขให้ถูกต้องตามหลักภาษาไทย:
+
+                {text_options}
+
+                หลักเกณฑ์การเลือก:
+                - เลือกข้อความที่มีความหมายชัดเจนที่สุด
+                - เลือกข้อความที่สมบูรณ์ที่สุด (ไม่ขาดคำ)
+                - หลีกเลี่ยงข้อความที่ซ้ำซ้อนหรือผิดพลาดชัดเจน
 
-                - แก้ไขคำสะกดผิด คำพิมพ์ผิด หรือคำที่ไม่ถูกต้องและการผันวรรณยุกต์ผิด
+                การแก้ไข:
+                - แก้ไขคำสะกดผิด คำพิมพ์ผิด หรือการผันวรรณยุกต์ผิด
                 - ห้ามเปลี่ยนความหมาย
-                - ห้ามตอบเกิน
-                - **ตอบกลับเฉพาะข้อความที่แก้แล้ว**
-            {text}
+                - ห้ามอธิบายหรือใส่คำพูดเพิ่มเติม
+                - **ตอบกลับเฉพาะข้อความที่เลือกและแก้ไขแล้วเท่านั้น**
             """.strip()
 
         try:
@@ -321,33 +365,20 @@ def add_llm_spell_corrected_text_column(df, model="google/gemma-3-27b-it", delay
                 messages=[
                     {
                         "role": "system",
-                        "content": """คุณคือนักภาษาศาสตร์ผู้เชี่ยวชาญด้านการตรวจสอบคำสะกดผิด คำพิมพ์ผิด และการผันวรรณยุกต์ผิดของภาษาไทย
-                                        หน้าที่ของคุณคือแก้ไขคำผิดในข้อความที่ได้รับให้ถูกต้องตามมาตรฐานภาษาไทย โดยไม่เปลี่ยนความหมายเดิม
-
-                                        หน้าที่ของคุณ:
-                                        - แก้ไขข้อความภาษาไทยให้ถูกต้องตามหลักภาษาไทยมาตรฐาน
-                                        - ตรวจสอบคำสะกดผิด คำพิมพ์ผิด และการผันวรรณยุกต์ผิด
-                                        - แก้คำเพี้ยน คำที่มาจากเสียงพูด เช่น ภาษาวัยรุ่นหรือคำพูดที่ออกเสียงคล้ายกัน ให้เป็นคำที่ถูกต้อง
-                                        - รักษาความหมายเดิมของข้อความให้มากที่สุด
-                                        - ห้ามแปลความใหม่ ห้ามตีความเกิน ห้ามปรับสำนวน
-                                        - ห้ามอธิบาย หรือใส่คำพูดใด ๆ เพิ่มเติมก่อนหรือหลังข้อความ
-                                        - **ให้ตอบกลับเฉพาะข้อความที่แก้ไขแล้วเท่านั้น**
-
-                                        ตัวอย่าง:
-
-                                        ผู้ใช้: ผมไช้คอมพิวเตอรทุกวัน
-                                        คุณ: ผมใช้คอมพิวเตอร์ทุกวั��
-
-                                        ผู้ใช้: ปวดหัวจะตายุ่ละ
-                                        คุณ: ปวดหัวจะตายอยู่ละ
-
-                                        ผู้ใช้: ไอ้เส้นหลั่งกุ้ง
-                                        คุณ: ไอ้เส้นหลังกุ้ง
-
-                                        ผู้ใช้: เซโยโมมันน่ากลัว
-                                        คุณ: เชื้อโรคมันน่ากลัว
-
-                                        จงตอบกลับเฉพาะข้อความที่แก้ไขแล้วตามตัวอย่างข้างต้นเท่านั้น
+                        "content": """คุณคือนักภาษาศาสตร์ผู้เชี่ยวชาญด้านการตรวจสอบและแก้ไขข้อความภาษาไทย
+                                        หน้าที่ของคุณคือเลือกข้อความที่ดีที่สุดจากตัวเลือกที่ให้มา แล้วแก้ไขให้ถูกต้องตามมาตรฐานภาษาไทย
+
+                                        หลักเกณฑ์การเลือก:
+                                        1. ความสมบูรณ์ของข้อความ (ไม่ขาดคำสำคัญ)
+                                        2. ความชัดเจนของความหมาย
+                                        3. ความถูกต้องทางไวยากรณ์
+                                        4. หลีกเลี่ยงการซ้ำซ้อนหรือข้อผิดพลาดชัดเจน
+
+                                        การแก้ไข:
+                                        - แก้ไขคำสะกดผิด คำพิมพ์ผิด และการผันวรรณยุกต์ผิด
+                                        - รักษาความหมายเดิมของข้อความ
+                                        - ห้ามแปลความใหม่ ห้ามตีความเกิน
+                                        - **ตอบกลับเฉพาะข้อความที่เลือกและแก้ไขแล้วเท่านั้น**
                         """
                     },
                     {"role": "user", "content": prompt}
@@ -365,45 +396,47 @@ def add_llm_spell_corrected_text_column(df, model="google/gemma-3-27b-it", delay
             if _is_quota_error(err):
                 corrected.append(" - ")
             else:
-                corrected.append("")
+                # Fallback: ใช้ตัวเลือกแรกที่ไม่ว่าง
+                fallback_text = next((t for t in text_array if t.strip()), "")
+                corrected.append(fallback_text)
 
-        if idx < len(texts) - 1:
+        if idx < len(text_arrays) - 1:
             time.sleep(delay)
 
     df["llm_corrected_text"] = corrected
     return df
 
-# def _merge_intervals(intervals, gap=0.0):
-#     if not intervals:
-#         return []
-#     intervals = sorted(intervals, key=lambda x: x[0])
-#     merged = [list(intervals[0])]
-#     for s, e in intervals[1:]:
-#         if s <= merged[-1][1] + gap:
-#             merged[-1][1] = max(merged[-1][1], e)
-#         else:
-#             merged.append([s, e])
-#     return [(float(a), float(b)) for a, b in merged]
-
-# def _interval_intersection(a, b):
-#     s = max(a[0], b[0]); e = min(a[1], b[1])
-#     return (s, e) if e > s else None
-
-# def detect_overlap_timeline(audio_path: str):
-#     """
-#     คืนรายการช่วงเวลาที่มีการพูดซ้อน [(start, end), ...]
-#     ถ้าโหลดโมเดลไม่ได้ → คืน []
-#     """
-#     if overlap_pipeline is None:
-#         return []
-
-#     try:
-#         ov = overlap_pipeline(audio_path)   # pyannote Annotation
-#         intervals = [(float(seg.start), float(seg.end)) for seg in ov.get_timeline()]
-#         return _merge_intervals(intervals)
-#     except Exception as e:
-#         print(f"⚠️ Overlap detection failed: {e}")
-#         return []
+def _merge_intervals(intervals, gap=0.0):
+    if not intervals:
+        return []
+    intervals = sorted(intervals, key=lambda x: x[0])
+    merged = [list(intervals[0])]
+    for s, e in intervals[1:]:
+        if s <= merged[-1][1] + gap:
+            merged[-1][1] = max(merged[-1][1], e)
+        else:
+            merged.append([s, e])
+    return [(float(a), float(b)) for a, b in merged]
+
+def _interval_intersection(a, b):
+    s = max(a[0], b[0]); e = min(a[1], b[1])
+    return (s, e) if e > s else None
+
+def detect_overlap_timeline(audio_path: str):
+    """
+    คืนรายการช่วงเวลาที่มีการพูดซ้อน [(start, end), ...]
+    ถ้าโหลดโมเดลไม่ได้ → คืน []
+    """
+    if overlap_pipeline is None:
+        return []
+
+    try:
+        ov = overlap_pipeline(audio_path)   # pyannote Annotation
+        intervals = [(float(seg.start), float(seg.end)) for seg in ov.get_timeline()]
+        return _merge_intervals(intervals)
+    except Exception as e:
+        print(f"⚠️ Overlap detection failed: {e}")
+        return []
 
 def _confidence_metrics(audio_seg, sr):
     try:
@@ -464,24 +497,24 @@ def tag_segments_use_or_remove(segments: list, min_segment_duration=3.0, min_spe
 
     return kept, removed, sorted(list(valid_speakers))
 
-# def enrich_with_overlap(segments: list, overlap_timeline: list):
-#     """
-#     เติม: has_overlap, overlap_intervals, overlap_ratio
-#     """
-#     for seg in segments:
-#         s, e = float(seg["start"]), float(seg["end"])
-#         overlaps = []
-#         total = 0.0
-#         for (os, oe) in overlap_timeline:
-#             inter = _interval_intersection((s, e), (os, oe))
-#             if inter:
-#                 overlaps.append([round(inter[0], 3), round(inter[1], 3)])
-#                 total += (inter[1] - inter[0])
-#         dur = max(1e-9, e - s)
-#         seg["has_overlap"] = bool(overlaps)
-#         seg["overlap_intervals"] = overlaps
-#         seg["overlap_ratio"] = float(total / dur)
-#     return segments
+def enrich_with_overlap(segments: list, overlap_timeline: list):
+    """
+    เติม: has_overlap, overlap_intervals, overlap_ratio
+    """
+    for seg in segments:
+        s, e = float(seg["start"]), float(seg["end"])
+        overlaps = []
+        total = 0.0
+        for (os, oe) in overlap_timeline:
+            inter = _interval_intersection((s, e), (os, oe))
+            if inter:
+                overlaps.append([round(inter[0], 3), round(inter[1], 3)])
+                total += (inter[1] - inter[0])
+        dur = max(1e-9, e - s)
+        seg["has_overlap"] = bool(overlaps)
+        seg["overlap_intervals"] = overlaps
+        seg["overlap_ratio"] = float(total / dur)
+    return segments
 
 def diarize_audio(audio_path: str) -> pd.DataFrame:
     sr = 16000
@@ -514,10 +547,10 @@ def diarize_audio(audio_path: str) -> pd.DataFrame:
         min_speaker_total=min_speaker_total
     )
 
-    # # 4) Overlap
-    # ov_tl = detect_overlap_timeline(audio_path)
-    # kept = enrich_with_overlap(kept, ov_tl)
-    # removed = enrich_with_overlap(removed, ov_tl)
+    # 4) Overlap
+    ov_tl = detect_overlap_timeline(audio_path)
+    kept = enrich_with_overlap(kept, ov_tl)
+    removed = enrich_with_overlap(removed, ov_tl)
 
     # 5) Combine
     all_rows = kept + removed
@@ -525,6 +558,365 @@ def diarize_audio(audio_path: str) -> pd.DataFrame:
 
     df = pd.DataFrame(all_rows, columns=[
         "speaker","start","end","duration","confidence",
-        "tag","remove_reason"
+        "is_remove","remove_reason","has_overlap","overlap_intervals","overlap_ratio"
     ])
-    return df
+    return df
+
+def detect_speech_boundaries(audio_data: np.ndarray, sample_rate: int, offset_time: float, 
+                           energy_threshold: float = 0.01, min_speech_duration: float = 0.1):
+    """
+    หาขอบเขตของการพูดจริงใน audio stream ด้วย energy-based detection
+    """
+    import numpy as np
+    
+    # คำนวณ energy ของ audio
+    frame_size = int(0.025 * sample_rate)  # 25ms frames
+    hop_size = int(0.010 * sample_rate)    # 10ms hop
+    
+    energy = []
+    for i in range(0, len(audio_data) - frame_size, hop_size):
+        frame = audio_data[i:i + frame_size]
+        frame_energy = np.sum(frame ** 2) / len(frame)
+        energy.append(frame_energy)
+    
+    energy = np.array(energy)
+    
+    # หา threshold แบบ adaptive
+    if len(energy) > 0:
+        max_energy = np.max(energy)
+        adaptive_threshold = max_energy * energy_threshold
+        
+        # หาจุดเริ่มต้นและสิ้นสุดของการพูด
+        speech_frames = energy > adaptive_threshold
+        
+        if np.any(speech_frames):
+            # หาจุดเริ่มต้น
+            start_frame = np.where(speech_frames)[0][0]
+            end_frame = np.where(speech_frames)[0][-1]
+            
+            # แปลงเป็นเวลา
+            start_time = offset_time + (start_frame * hop_size / sample_rate)
+            end_time = offset_time + ((end_frame + 1) * hop_size / sample_rate)
+            
+            # ตรวจสอบ minimum duration
+            if end_time - start_time >= min_speech_duration:
+                return start_time, end_time
+    
+    # Fallback: ใช้เวลาเต็ม
+    duration = len(audio_data) / sample_rate
+    return offset_time, offset_time + duration
+
+def separate_overlapping_segments(audio_path: str, overlap_segments: list):
+    """
+    แยกเสียงสำหรับ segments ที่มี overlap ด้วย Asteroid
+    """
+    try:
+        import torch
+        import torchaudio
+        from asteroid.models import ConvTasNet
+        
+        # โหลด pre-trained model
+        model = ConvTasNet.from_pretrained("JorisCos/ConvTasNet_Libri2Mix_sepclean_8k")
+        
+        separated_results = []
+        
+        for segment in overlap_segments:
+            try:
+                # โหลดเสียงในช่วงที่ overlap
+                start_time = float(segment["start"])
+                end_time = float(segment["end"])
+                
+                # โหลดเสียงด้วย torchaudio
+                waveform, sample_rate = torchaudio.load(audio_path, 
+                                                       frame_offset=int(start_time * sample_rate),
+                                                       num_frames=int((end_time - start_time) * sample_rate))
+                
+                # แยกเสียง (ConvTasNet คาดหวัง mono input)
+                if waveform.shape[0] > 1:
+                    waveform = torch.mean(waveform, dim=0, keepdim=True)
+                
+                # Separate audio
+                with torch.no_grad():
+                    separated = model(waveform.unsqueeze(0))  # Add batch dimension
+                
+                # บันทึกผลลัพธ์
+                segment_result = {
+                    "original_segment": segment,
+                    "separated_streams": [],
+                    "num_streams": separated.shape[1]
+                }
+                
+                # บันทึกแต่ละ stream พร้อมหาเวลาจริง
+                for i in range(separated.shape[1]):
+                    stream_audio = separated[0, i, :].cpu().numpy()
+                    stream_duration = len(stream_audio) / sample_rate
+                    
+                    # หาเวลาจริงด้วย energy-based detection
+                    stream_start, stream_end = detect_speech_boundaries(stream_audio, sample_rate, start_time)
+                    
+                    segment_result["separated_streams"].append({
+                        "stream_id": i,
+                        "audio_data": stream_audio,
+                        "sample_rate": sample_rate,
+                        "start": stream_start,
+                        "end": stream_end,
+                        "duration": stream_end - stream_start
+                    })
+                
+                separated_results.append(segment_result)
+                
+            except Exception as e:
+                print(f"❌ Error separating segment {segment}: {e}")
+                # Fallback: ใช้เสียงต้นฉบับ
+                separated_results.append({
+                    "original_segment": segment,
+                    "separated_streams": [],
+                    "num_streams": 0,
+                    "error": str(e)
+                })
+        
+        return separated_results
+        
+    except ImportError:
+        print("⚠️ Asteroid not installed. Install with: pip install asteroid-filterbanks torch-audio")
+        return []
+    except Exception as e:
+        print(f"❌ Source separation failed: {e}")
+        return []
+
+def match_streams_to_speakers(separated_results: list, audio_path: str):
+    """
+    จับคู่ separated streams กับ speakers โดยใช้ speaker embeddings
+    """
+    try:
+        from speechbrain.pretrained import EncoderClassifier
+        from sklearn.metrics.pairwise import cosine_similarity
+        import numpy as np
+        
+        # โหลด speaker embedding model
+        classifier = EncoderClassifier.from_hparams(
+            source="speechbrain/spkrec-ecapa-voxceleb",
+            savedir="tmp/spkrec-ecapa-voxceleb"
+        )
+        
+        matched_results = []
+        
+        # สร้าง speaker profiles จาก clean segments ก่อน
+        speaker_profiles = {}
+        
+        for result in separated_results:
+            if result.get("error") or not result["separated_streams"]:
+                matched_results.append(result)
+                continue
+                
+            segment = result["original_segment"]
+            streams = result["separated_streams"]
+            
+            # สร้าง embeddings สำหรับแต่ละ stream
+            stream_embeddings = []
+            for stream in streams:
+                try:
+                    # แปลง audio data เป็น tensor
+                    audio_tensor = torch.FloatTensor(stream["audio_data"]).unsqueeze(0)
+                    embedding = classifier.encode_batch(audio_tensor)
+                    stream_embeddings.append(embedding.squeeze().cpu().numpy())
+                except Exception as e:
+                    print(f"⚠️ Failed to create embedding for stream: {e}")
+                    stream_embeddings.append(None)
+            
+            # สร้าง speaker profile ถ้ายังไม่มี
+            if segment["speaker"] not in speaker_profiles and len(stream_embeddings) > 0:
+                valid_embeddings = [emb for emb in stream_embeddings if emb is not None]
+                if valid_embeddings:
+                    speaker_profiles[segment["speaker"]] = np.mean(valid_embeddings, axis=0)
+            
+            # จับคู่กับ speaker (ใช้ cosine similarity)
+            matched_streams = []
+            for i, (stream, embedding) in enumerate(zip(streams, stream_embeddings)):
+                if embedding is not None and len(speaker_profiles) > 0:
+                    # คำนวณ similarity กับทุก speaker
+                    similarities = {}
+                    for speaker_id, profile_embedding in speaker_profiles.items():
+                        similarity = cosine_similarity([embedding], [profile_embedding])[0][0]
+                        similarities[speaker_id] = similarity
+                    
+                    # เลือก speaker ที่มี similarity สูงสุด
+                    best_match = max(similarities, key=similarities.get)
+                    confidence = float(similarities[best_match])
+                    
+                    matched_streams.append({
+                        **stream,
+                        "speaker_embedding": embedding,
+                        "matched_speaker": best_match,
+                        "confidence": round(confidence, 3)
+                    })
+                else:
+                    # Fallback ถ้าไม่มี embedding หรือ profile
+                    matched_streams.append({
+                        **stream,
+                        "matched_speaker": segment["speaker"] if embedding is not None else f"unknown_{i}",
+                        "confidence": 0.5
+                    })
+            
+            result["matched_streams"] = matched_streams
+            matched_results.append(result)
+        
+        return matched_results
+        
+    except ImportError:
+        print("⚠️ SpeechBrain not installed. Install with: pip install speechbrain")
+        # Fallback: ใช้ speaker เดิม
+        for result in separated_results:
+            if not result.get("error") and result["separated_streams"]:
+                result["matched_streams"] = [
+                    {**stream, "matched_speaker": result["original_segment"]["speaker"], "confidence": 0.5}
+                    for stream in result["separated_streams"]
+                ]
+        return separated_results
+    except Exception as e:
+        print(f"❌ Speaker matching failed: {e}")
+        return separated_results
+
+def branch_segments_by_overlap(df_diarization: pd.DataFrame, overlap_threshold: float = 0.1):
+    """
+    แยก segments เป็น clean และ overlap ตาม overlap_ratio
+    """
+    clean_segments = []
+    overlap_segments = []
+    
+    for _, row in df_diarization.iterrows():
+        segment = row.to_dict()
+        
+        # ตรวจสอบว่ามี overlap หรือไม่
+        has_overlap = segment.get("has_overlap", False)
+        overlap_ratio = segment.get("overlap_ratio", 0.0)
+        
+        if has_overlap and overlap_ratio > overlap_threshold:
+            overlap_segments.append(segment)
+        else:
+            clean_segments.append(segment)
+    
+    return clean_segments, overlap_segments
+
+def process_segments_with_branching(audio_path: str, df_diarization: pd.DataFrame):
+    """
+    ประมวลผล segments แบบแยกเส้นทาง: Clean vs Overlap
+    """
+    # แยก segments
+    clean_segments, overlap_segments = branch_segments_by_overlap(df_diarization)
+    
+    print(f"🔍 Found {len(clean_segments)} clean segments, {len(overlap_segments)} overlap segments")
+    
+    results = {
+        "clean_segments": clean_segments,
+        "overlap_segments": overlap_segments,
+        "clean_transcriptions": [],
+        "overlap_transcriptions": []
+    }
+    
+    # ประมวลผล clean segments (ใช้วิธีเดิม)
+    if clean_segments:
+        print("🎯 Processing clean segments...")
+        clean_df = pd.DataFrame(clean_segments)
+        segment_folder = split_segments(audio_path, clean_df)
+        clean_transcriptions = transcribe_segments(segment_folder)
+        results["clean_transcriptions"] = clean_transcriptions.to_dict(orient="records")
+    
+    # ประมวลผล overlap segments (ใช้ source separation)
+    if overlap_segments:
+        print("🔀 Processing overlap segments with source separation...")
+        separated_results = separate_overlapping_segments(audio_path, overlap_segments)
+        matched_results = match_streams_to_speakers(separated_results, audio_path)
+        
+        # Transcribe แต่ละ separated stream
+        overlap_transcriptions = []
+        for result in matched_results:
+            if result.get("matched_streams"):
+                for stream in result["matched_streams"]:
+                    # บันทึก audio stream เป็นไฟล์ชั่วคราว
+                    temp_audio_path = save_temp_audio_stream(stream)
+                    if temp_audio_path:
+                        # Transcribe stream
+                        stream_transcription = transcribe_single_audio(temp_audio_path)
+                        overlap_transcriptions.append({
+                            "original_segment": result["original_segment"],
+                            "stream_id": stream["stream_id"],
+                            "speaker": stream.get("matched_speaker", "unknown"),
+                            "transcription": stream_transcription,
+                            "matched_streams": result["matched_streams"]  # เพิ่ม matched_streams ทั้งหมด
+                        })
+                        # ลบไฟล์ชั่วคราว
+                        os.remove(temp_audio_path)
+        
+        results["overlap_transcriptions"] = overlap_transcriptions
+    
+    return results
+
+def save_temp_audio_stream(stream_data: dict) -> str:
+    """บันทึก audio stream เป็นไฟล์ชั่วคราว"""
+    try:
+        import tempfile
+        import soundfile as sf
+        
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
+            sf.write(tmp_file.name, stream_data["audio_data"], stream_data["sample_rate"])
+            return tmp_file.name
+    except Exception as e:
+        print(f"❌ Failed to save temp audio: {e}")
+        return None
+
+def transcribe_single_audio(audio_path: str, num_rounds: int = 3) -> dict:
+    """Transcribe ไฟล์เสียงเดี่ยว"""
+    try:
+        model = models[0]
+        text_array = []
+        prob_array = []
+        
+        # ทำ transcription หลายรอบ
+        for round_num in range(num_rounds):
+            segments, _ = model.transcribe(
+                audio_path,
+                language="th",
+                beam_size=5,
+                vad_filter=True,
+                word_timestamps=True,
+                temperature=0.0 if round_num == 0 else 0.2  # รอบแรกใช้ deterministic
+            )
+            
+            words = [word for seg in segments if hasattr(seg, "words") for word in seg.words]
+            
+            if words:
+                full_text = ''.join([w.word for w in words])
+                probs = [w.probability for w in words if w.probability is not None]
+                avg_prob = round(np.mean(probs), 4) if probs else 0.0
+                
+                text_array.append(full_text)
+                prob_array.append(avg_prob)
+            else:
+                text_array.append("")
+                prob_array.append(0.0)
+        
+        # เลือกผลลัพธ์ที่ดีที่สุด (probability สูงสุด)
+        if prob_array and max(prob_array) > 0:
+            best_idx = prob_array.index(max(prob_array))
+            best_text = text_array[best_idx]
+            best_prob = prob_array[best_idx]
+        else:
+            best_text = text_array[0] if text_array else ""
+            best_prob = prob_array[0] if prob_array else 0.0
+            
+        return {
+            "text": best_text,
+            "text_array": text_array,
+            "avg_probability": best_prob,
+            "prob_array": prob_array,
+        }
+    except Exception as e:
+        print(f"❌ Transcription failed: {e}")
+        return {
+            "text": "",
+            "text_array": ["", "", ""],
+            "avg_probability": 0.0,
+            "prob_array": [0.0, 0.0, 0.0],
+            "error": str(e)
+        }