Upload 46 files

app.py

@@ -1,318 +1,514 @@
-import spaces  # PHẢI import TRƯỚC mọi thứ trên HF Spaces ZeroGPU
-import os
-os.environ['SPACES_ZERO_GPU'] = '1'  # Set environment variable explicitly
-
-import gradio as gr
-import soundfile as sf
-import tempfile
-import torch
-from vieneu_tts import VieNeuTTS
-import time
-
-print("⏳ Đang khởi động VieNeu-TTS...")
-
-# --- 1. SETUP MODEL ---
-print("📦 Đang tải model...")
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"🖥️ Sử dụng thiết bị: {device.upper()}")
-
-try:
-    tts = VieNeuTTS(
-        backbone_repo="pnnbao-ump/VieNeu-TTS",
-        backbone_device=device,
-        codec_repo="neuphonic/neucodec",
-        codec_device=device
-    )
-    print("✅ Model đã tải xong!")
-except Exception as e:
-    print(f"⚠️ Không thể tải model (Chế độ UI Demo): {e}")
-    class MockTTS:
-        def encode_reference(self, path): return None
-        def infer(self, text, ref, ref_text): 
-            import numpy as np
-            # Giả lập độ trễ để test tính năng đo thời gian
-            time.sleep(1.5) 
-            return np.random.uniform(-0.5, 0.5, 24000*3)
-    tts = MockTTS()
-
-# --- 2. DATA ---
-VOICE_SAMPLES = {
-    "Tuyên (nam miền Bắc)": {"audio": "./sample/Tuyên (nam miền Bắc).wav", "text": "./sample/Tuyên (nam miền Bắc).txt"},
-    "Vĩnh (nam miền Nam)": {"audio": "./sample/Vĩnh (nam miền Nam).wav", "text": "./sample/Vĩnh (nam miền Nam).txt"},
-    "Bình (nam miền Bắc)": {"audio": "./sample/Bình (nam miền Bắc).wav", "text": "./sample/Bình (nam miền Bắc).txt"},
-    "Nguyên (nam miền Nam)": {"audio": "./sample/Nguyên (nam miền Nam).wav", "text": "./sample/Nguyên (nam miền Nam).txt"},
-    "Sơn (nam miền Nam)": {"audio": "./sample/Sơn (nam miền Nam).wav", "text": "./sample/Sơn (nam miền Nam).txt"},
-    "Đoan (nữ miền Nam)": {"audio": "./sample/Đoan (nữ miền Nam).wav", "text": "./sample/Đoan (nữ miền Nam).txt"},
-    "Ngọc (nữ miền Bắc)": {"audio": "./sample/Ngọc (nữ miền Bắc).wav", "text": "./sample/Ngọc (nữ miền Bắc).txt"},
-    "Ly (nữ miền Bắc)": {"audio": "./sample/Ly (nữ miền Bắc).wav", "text": "./sample/Ly (nữ miền Bắc).txt"},
-    "Dung (nữ miền Nam)": {"audio": "./sample/Dung (nữ miền Nam).wav", "text": "./sample/Dung (nữ miền Nam).txt"}
-}
-
-# --- 3. HELPER FUNCTIONS ---
-def load_reference_info(voice_choice):
-    if voice_choice in VOICE_SAMPLES:
-        audio_path = VOICE_SAMPLES[voice_choice]["audio"]
-        text_path = VOICE_SAMPLES[voice_choice]["text"]
-        try:
-            if os.path.exists(text_path):
-                with open(text_path, "r", encoding="utf-8") as f:
-                    ref_text = f.read()
-                return audio_path, ref_text
-            else:
-                return audio_path, "⚠️ Không tìm thấy file text mẫu."
-        except Exception as e:
-            return None, f"❌ Lỗi: {str(e)}"
-    return None, ""
-
-@spaces.GPU(duration=120) 
-def synthesize_speech(text, voice_choice, custom_audio, custom_text, mode_tab):
-    try:
-        if not text or text.strip() == "":
-            return None, "⚠️ Vui lòng nhập văn bản cần tổng hợp!"
-        
-        # --- LOGIC CHECK LIMIT 250 ---
-        if len(text) > 250:
-            return None, f"❌ Văn bản quá dài ({len(text)}/250 ký tự)! Vui lòng cắt ngắn lại để đảm bảo chất lượng."
-
-        # Logic chọn Reference
-        if mode_tab == "custom_mode": 
-            if custom_audio is None or not custom_text:
-                return None, "⚠️ Vui lòng tải lên Audio và nhập nội dung Audio đó."
-            ref_audio_path = custom_audio
-            ref_text_raw = custom_text
-            print("🎨 Mode: Custom Voice")
-        else: # Preset
-            if voice_choice not in VOICE_SAMPLES:
-                 return None, "⚠️ Vui lòng chọn một giọng mẫu."
-            ref_audio_path = VOICE_SAMPLES[voice_choice]["audio"]
-            ref_text_path = VOICE_SAMPLES[voice_choice]["text"]
-            
-            if not os.path.exists(ref_audio_path):
-                 return None, f"❌ Không tìm thấy file audio: {ref_audio_path}"
-                 
-            with open(ref_text_path, "r", encoding="utf-8") as f:
-                ref_text_raw = f.read()
-            print(f"🎤 Mode: Preset Voice ({voice_choice})")
-
-        # Inference & Đo thời gian
-        print(f"📝 Text: {text[:50]}...")
-        
-        start_time = time.time() # <--- Bắt đầu bấm giờ
-        
-        ref_codes = tts.encode_reference(ref_audio_path)
-        wav = tts.infer(text, ref_codes, ref_text_raw)
-        
-        end_time = time.time()   # <--- Kết thúc bấm giờ
-        process_time = end_time - start_time # <--- Tính thời gian xử lý
-        
-        # Save
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-            sf.write(tmp_file.name, wav, 24000)
-            output_path = tmp_file.name
-        
-        # <--- Cập nhật thông báo kết quả
-        return output_path, f"✅ Thành công! (Mất {process_time:.2f} giây để tạo)"
-
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return None, f"❌ Lỗi hệ thống: {str(e)}"
-
-# --- 4. UI SETUP ---
-# SỬA LỖI Ở ĐÂY: Đổi gr.themes.Ocean -> gr.themes.Soft
-theme = gr.themes.Soft(
-    primary_hue="indigo",
-    secondary_hue="cyan",
-    neutral_hue="slate",
-    font=[gr.themes.GoogleFont('Inter'), 'ui-sans-serif', 'system-ui'],
-).set(
-    button_primary_background_fill="linear-gradient(90deg, #6366f1 0%, #0ea5e9 100%)",
-    button_primary_background_fill_hover="linear-gradient(90deg, #4f46e5 0%, #0284c7 100%)",
-    block_shadow="0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)",
-)
-
-# <--- CSS ĐÃ SỬA (Background xanh đen + Chữ sáng)
-css = """
-.container { max-width: 1200px; margin: auto; }
-.header-box { 
-    text-align: center; 
-    margin-bottom: 25px; 
-    padding: 25px; 
-    background: linear-gradient(135deg, #0f172a 0%, #1e293b 100%); /* Xanh đen (Slate 900 -> 800) */
-    border-radius: 12px; 
-    border: 1px solid #334155; 
-    box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.3);
-}
-.header-title { 
-    font-size: 2.5rem; 
-    font-weight: 800; 
-    color: white; /* Chữ trắng */
-    background: -webkit-linear-gradient(45deg, #60A5FA, #22D3EE); /* Gradient xanh sáng cho chữ nổi bật */
-    -webkit-background-clip: text; 
-    -webkit-text-fill-color: transparent; 
-    margin-bottom: 10px; 
-}
-.header-desc {
-    font-size: 1.1rem; 
-    color: #cbd5e1; /* Màu xám sáng (Slate-300) */
-    margin-bottom: 15px;
-}
-.link-group a { 
-    text-decoration: none; 
-    margin: 0 10px; 
-    font-weight: 600; 
-    color: #94a3b8; /* Màu link sáng hơn chút */
-    transition: color 0.2s; 
-}
-.link-group a:hover { color: #38bdf8; text-shadow: 0 0 5px rgba(56, 189, 248, 0.5); }
-
-.status-box { font-weight: bold; text-align: center; border: none; background: transparent; }
-.warning-note { 
-    background-color: #fff7ed; 
-    border-left: 4px solid #f97316; 
-    padding: 12px; 
-    color: #9a3412; 
-    font-size: 0.9rem; 
-    border-radius: 4px;
-    margin-top: 10px;
-    margin-bottom: 10px;
-}
-"""
-
-EXAMPLES_LIST = [
-    # Nam Miền Nam
-    ["Về miền Tây không chỉ để ngắm nhìn sông nước hữu tình, mà còn để cảm nhận tấm chân tình của người dân nơi đây. Cùng ngồi xuồng ba lá len lỏi qua rặng dừa nước, nghe câu vọng cổ ngọt ngào thì còn gì bằng.", "Vĩnh (nam miền Nam)"],
-    
-    # Nam Miền Bắc
-    ["Hà Nội những ngày vào thu mang một vẻ đẹp trầm mặc và cổ kính đến lạ thường. Đi dạo quanh Hồ Gươm vào sáng sớm, hít hà mùi hoa sữa nồng nàn và thưởng thức chút cốm làng Vòng là trải nghiệm khó quên.", "Bình (nam miền Bắc)"],
-    
-    # Nam Miền Bắc
-    ["Sự bùng nổ của trí tuệ nhân tạo đang định hình lại cách chúng ta làm việc và sinh sống. Từ xe tự lái đến trợ lý ảo thông minh, công nghệ đang dần xóa nhòa ranh giới giữa thực tại và những bộ phim viễn tưởng.", "Tuyên (nam miền Bắc)"],
-    
-    # Nam Miền Nam
-    ["Sài Gòn hối hả là thế, nhưng chỉ cần tấp vào một quán cà phê ven đường, gọi ly bạc xỉu đá và ngắm nhìn dòng người qua lại, bạn sẽ thấy thành phố này cũng có những khoảng lặng thật bình yên và đáng yêu.", "Nguyên (nam miền Nam)"],
-    
-    # Nam Miền Nam
-    ["Để đảm bảo tiến độ dự án quan trọng này, chúng ta cần tập trung tối đa nguồn lực và phối hợp chặt chẽ giữa các phòng ban. Mọi khó khăn phát sinh cần được báo cáo ngay lập tức để ban lãnh đạo xử lý kịp thời.", "Sơn (nam miền Nam)"],
-
-    # Nữ Miền Nam
-    ["Ngày xửa ngày xưa, ở một ngôi làng nọ có cô Tấm xinh đẹp, nết na nhưng sớm mồ côi mẹ. Dù bị mẹ kế và Cám hãm hại đủ đường, Tấm vẫn giữ được tấm lòng lương thiện và cuối cùng tìm được hạnh phúc xứng đáng.", "Đoan (nữ miền Nam)"],
-    
-    # Nữ Miền Bắc
-    ["Dạ em chào anh chị, hiện tại bên em đang có chương trình ưu đãi đặc biệt cho căn hộ hướng sông này. Với thiết kế hiện đại và không gian xanh mát, đây chắc chắn là tổ ấm lý tưởng mà gia đình mình đang tìm kiếm.", "Ly (nữ miền Bắc)"],
-    
-    # Nữ Miền Bắc
-    ["Dưới cơn mưa phùn lất phất của những ngày cuối đông, em khẽ nép vào vai anh, cảm nhận hơi ấm lan tỏa. Những khoảnh khắc bình dị như thế này khiến em nhận ra rằng, hạnh phúc đôi khi chỉ đơn giản l�� được ở bên nhau.", "Ngọc (nữ miền Bắc)"],
-]
-
-with gr.Blocks(theme=theme, css=css, title="VieNeu-TTS Studio") as demo:
-    
-    with gr.Column(elem_classes="container"):
-        # Header - Cập nhật class cho HTML
-        gr.HTML("""
-            <div class="header-box">
-                <div class="header-title">🎙️ VieNeu-TTS Studio</div>
-                <div class="header-desc">
-                    Phiên bản: VieNeu-TTS-1000h (model mới nhất, train trên 1000 giờ dữ liệu)
-                </div>
-                <div class="link-group">
-                    <a href="https://huggingface.co/pnnbao-ump/VieNeu-TTS" target="_blank">🤗 Model Card</a> • 
-                    <a href="https://huggingface.co/datasets/pnnbao-ump/VieNeu-TTS-1000h" target="_blank">📖 Dataset 1000h</a> • 
-                    <a href="https://github.com/pnnbao97/VieNeu-TTS" target="_blank">🦜 GitHub</a>
-                </div>
-            </div>
-        """)
-    
-    with gr.Row(elem_classes="container", equal_height=False):
-        
-        # --- LEFT: INPUT ---
-        with gr.Column(scale=3, variant="panel"):
-            gr.Markdown("### 📝 Văn bản đầu vào")
-            text_input = gr.Textbox(
-                label="Nhập văn bản",
-                placeholder="Nhập nội dung tiếng Việt cần chuyển thành giọng nói...",
-                lines=4,
-                value="Sự bùng nổ của trí tuệ nhân tạo đang định hình lại cách chúng ta làm việc và sinh sống. Từ xe tự lái đến trợ lý ảo thông minh, công nghệ đang dần xóa nhòa ranh giới giữa thực tại và những bộ phim viễn tưởng.",
-                show_label=False
-            )
-            
-            # Counter + Warning
-            with gr.Row():
-                char_count = gr.HTML("<div style='text-align: right; color: #64748B; font-size: 0.8rem;'>0 / 250 ký tự</div>")
-            
-            gr.Markdown("### 🗣️ Chọn giọng đọc")
-            with gr.Tabs() as tabs:
-                with gr.TabItem("👤 Giọng có sẵn (Preset)", id="preset_mode"):
-                    voice_select = gr.Dropdown(
-                        choices=list(VOICE_SAMPLES.keys()),
-                        value="Tuyên (nam miền Bắc)",
-                        label="Danh sách giọng",
-                        interactive=True
-                    )
-                    with gr.Accordion("Thông tin giọng mẫu", open=False):
-                        ref_audio_preview = gr.Audio(label="Audio mẫu", interactive=False, type="filepath")
-                        ref_text_preview = gr.Markdown("...")
-
-                with gr.TabItem("🎙️ Giọng tùy chỉnh (Custom)", id="custom_mode"):
-                    gr.Markdown("Tải lên giọng của bạn (Zero-shot Cloning)")
-                    custom_audio = gr.Audio(label="File ghi âm (.wav)", type="filepath")
-                    custom_text = gr.Textbox(label="Nội dung ghi âm", placeholder="Nhập chính xác lời thoại...")
-
-            current_mode = gr.Textbox(visible=False, value="preset_mode")
-            btn_generate = gr.Button("Tổng hợp giọng nói", variant="primary", size="lg")
-
-        # --- RIGHT: OUTPUT ---
-        with gr.Column(scale=2):
-            gr.Markdown("### 🎧 Kết quả")
-            with gr.Group():
-                audio_output = gr.Audio(label="Audio đầu ra", type="filepath", show_download_button=True, autoplay=True)
-                status_output = gr.Textbox(label="Trạng thái", show_label=False, elem_classes="status-box", placeholder="Sẵn sàng...")
-
-    # --- EXAMPLES ---
-    with gr.Row(elem_classes="container"):
-        with gr.Column():
-            gr.Markdown("### 📚 Ví dụ mẫu")
-            gr.Examples(examples=EXAMPLES_LIST, inputs=[text_input, voice_select], label="Thử nghiệm nhanh")
-
-    # --- LOGIC ---
-    def update_count(text):
-        l = len(text)
-        if l > 250:
-            color = "#dc2626" # Red
-            msg = f"⚠️ <b>{l} / 250</b> - Quá giới hạn!"
-        elif l > 200:
-            color = "#ea580c" # Orange
-            msg = f"{l} / 250"
-        else:
-            color = "#64748B" # Gray
-            msg = f"{l} / 250 ký tự"
-        return f"<div style='text-align: right; color: {color}; font-size: 0.8rem; font-weight: bold'>{msg}</div>"
-
-    text_input.change(update_count, text_input, char_count)
-
-    def update_ref_preview(voice):
-        audio, text = load_reference_info(voice)
-        return audio, f"> *\"{text}\"*"
-    
-    voice_select.change(update_ref_preview, voice_select, [ref_audio_preview, ref_text_preview])
-    demo.load(update_ref_preview, voice_select, [ref_audio_preview, ref_text_preview])
-
-    # Tab handling - FIXED WITH *ARGS
-    tab_preset = tabs.children[0]
-    tab_custom = tabs.children[1]
-    
-    # Dùng *args để nhận bất kỳ số lượng tham số nào (0 hoặc 1), tránh lỗi Warning
-    tab_preset.select(fn=lambda *args: "preset_mode", inputs=None, outputs=current_mode)
-    tab_custom.select(fn=lambda *args: "custom_mode", inputs=None, outputs=current_mode)
-
-    btn_generate.click(
-        fn=synthesize_speech,
-        inputs=[text_input, voice_select, custom_audio, custom_text, current_mode],
-        outputs=[audio_output, status_output]
-    )
-
-if __name__ == "__main__":
-    demo.queue().launch(
-        server_name="0.0.0.0",
-        server_port=7860
+import spaces  # PHẢI import TRƯỚC mọi thứ trên HF Spaces ZeroGPU
+import os
+os.environ['SPACES_ZERO_GPU'] = '1'
+
+import gradio as gr
+import soundfile as sf
+import tempfile
+import torch
+from vieneu_tts import VieNeuTTS, FastVieNeuTTS
+import time
+import numpy as np
+import yaml
+from utils.core_utils import split_text_into_chunks
+import queue
+import threading
+
+print("⏳ Đang khởi động VieNeu-TTS...")
+
+# --- LOAD CONFIG ---
+CONFIG_PATH = os.path.join(os.path.dirname(__file__), "config.yaml")
+try:
+    with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+        _config = yaml.safe_load(f) or {}
+except Exception as e:
+    raise RuntimeError(f"Không thể đọc config.yaml: {e}")
+
+BACKBONE_CONFIGS = _config.get("backbone_configs", {})
+CODEC_CONFIGS = _config.get("codec_configs", {})
+VOICE_SAMPLES = _config.get("voice_samples", {})
+
+_text_settings = _config.get("text_settings", {})
+MAX_CHARS_PER_CHUNK = _text_settings.get("max_chars_per_chunk", 256)
+MAX_TOTAL_CHARS_STREAMING = _text_settings.get("max_total_chars_streaming", 3000)
+
+# --- KHỞI TẠO MODEL MẶC ĐỊNH ---
+print("📦 Đang tải model...")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"🖥️ Sử dụng thiết bị: {device.upper()}")
+
+tts = None
+using_fast_backend = False
+
+try:
+    backbone_config = BACKBONE_CONFIGS["VieNeu-TTS (GPU)"]
+    codec_config = CODEC_CONFIGS["NeuCodec (Standard)"]
+    
+    # Thử dùng FastVieNeuTTS nếu có GPU và đã cài LMDeploy
+    if device == "cuda":
+        try:
+            print("🚀 Thử tải FastVieNeuTTS (LMDeploy backend)...")
+            tts = FastVieNeuTTS(
+                backbone_repo=backbone_config["repo"],
+                backbone_device="cuda",
+                codec_repo=codec_config["repo"],
+                codec_device="cuda",
+                memory_util=0.3,
+                tp=1,
+                enable_prefix_caching=True,
+                quant_policy=8,
+                enable_triton=True,
+                max_batch_size=8,
+            )
+            using_fast_backend = True
+            print("✅ FastVieNeuTTS đã tải thành công!")
+            
+            # Pre-cache voices
+            print("📝 Pre-caching voices...")
+            for voice_name, voice_info in VOICE_SAMPLES.items():
+                audio_path = voice_info["audio"]
+                text_path = voice_info["text"]
+                if os.path.exists(audio_path) and os.path.exists(text_path):
+                    with open(text_path, "r", encoding="utf-8") as f:
+                        ref_text = f.read()
+                    tts.get_cached_reference(voice_name, audio_path, ref_text)
+            print(f"   ✅ Cached {len(VOICE_SAMPLES)} voices")
+            
+        except ImportError:
+            print("⚠️ LMDeploy không có, fallback về VieNeuTTS standard...")
+            using_fast_backend = False
+    
+    # Fallback về standard VieNeuTTS
+    if tts is None:
+        print("📦 Đang tải VieNeuTTS (Standard backend)...")
+        tts = VieNeuTTS(
+            backbone_repo=backbone_config["repo"],
+            backbone_device=device,
+            codec_repo=codec_config["repo"],
+            codec_device=device
+        )
+        using_fast_backend = False
+    
+    print("✅ Model đã tải xong!")
+    
+except Exception as e:
+    print(f"⚠️ Không thể tải model (Chế độ UI Demo): {e}")
+    class MockTTS:
+        def encode_reference(self, path): return None
+        def get_cached_reference(self, name, path, text): return None
+        def infer(self, text, ref, ref_text): 
+            time.sleep(1.5)
+            return np.random.uniform(-0.5, 0.5, 24000*3)
+        def infer_batch(self, texts, ref, ref_text):
+            return [self.infer(t, ref, ref_text) for t in texts]
+    tts = MockTTS()
+    using_fast_backend = False
+
+# --- HELPER FUNCTIONS ---
+def load_reference_info(voice_choice):
+    if voice_choice in VOICE_SAMPLES:
+        audio_path = VOICE_SAMPLES[voice_choice]["audio"]
+        text_path = VOICE_SAMPLES[voice_choice]["text"]
+        try:
+            if os.path.exists(text_path):
+                with open(text_path, "r", encoding="utf-8") as f:
+                    ref_text = f.read()
+                return audio_path, ref_text
+            else:
+                return audio_path, "⚠️ Không tìm thấy file text mẫu."
+        except Exception as e:
+            return None, f"❌ Lỗi: {str(e)}"
+    return None, ""
+
+@spaces.GPU(duration=120)
+def synthesize_speech(text, voice_choice, custom_audio, custom_text, mode_tab, generation_mode, use_batch):
+    """Tổng hợp giọng nói với GPU acceleration"""
+    global tts, using_fast_backend
+    
+    if tts is None:
+        yield None, "⚠️ Model chưa được tải!"
+        return
+    
+    if not text or text.strip() == "":
+        yield None, "⚠️ Vui lòng nhập văn bản!"
+        return
+    
+    raw_text = text.strip()
+    
+    # Setup Reference
+    if mode_tab == "custom_mode":
+        if custom_audio is None or not custom_text:
+            yield None, "⚠️ Thiếu Audio hoặc Text mẫu custom."
+            return
+        ref_audio_path = custom_audio
+        ref_text_raw = custom_text
+        use_cached = False
+    else:
+        if voice_choice not in VOICE_SAMPLES:
+            yield None, "⚠️ Vui lòng chọn giọng mẫu."
+            return
+        ref_audio_path = VOICE_SAMPLES[voice_choice]["audio"]
+        ref_text_path = VOICE_SAMPLES[voice_choice]["text"]
+        
+        if not os.path.exists(ref_audio_path):
+            yield None, "❌ Không tìm thấy file audio mẫu."
+            return
+        
+        with open(ref_text_path, "r", encoding="utf-8") as f:
+            ref_text_raw = f.read()
+        use_cached = True
+    
+    yield None, "📄 Đang xử lý Reference..."
+    
+    # Encode reference
+    try:
+        if use_cached and using_fast_backend and hasattr(tts, 'get_cached_reference'):
+            ref_codes = tts.get_cached_reference(voice_choice, ref_audio_path, ref_text_raw)
+        else:
+            ref_codes = tts.encode_reference(ref_audio_path)
+        
+        if isinstance(ref_codes, torch.Tensor):
+            ref_codes = ref_codes.cpu().numpy()
+    except Exception as e:
+        yield None, f"❌ Lỗi xử lý reference: {e}"
+        return
+    
+    # Split text
+    text_chunks = split_text_into_chunks(raw_text, max_chars=MAX_CHARS_PER_CHUNK)
+    total_chunks = len(text_chunks)
+    
+    # === STANDARD MODE ===
+    if generation_mode == "Standard (Một lần)":
+        backend_name = "🚀 LMDeploy" if using_fast_backend else "📦 Standard"
+        batch_info = " (Batch Mode)" if use_batch and using_fast_backend and total_chunks > 1 else ""
+        
+        yield None, f"{backend_name} Đang tổng hợp{batch_info} ({total_chunks} đoạn)..."
+        
+        all_audio_segments = []
+        sr = 24000
+        silence_pad = np.zeros(int(sr * 0.15), dtype=np.float32)
+        
+        start_time = time.time()
+        
+        try:
+            # Batch processing nếu có FastVieNeuTTS
+            if use_batch and using_fast_backend and hasattr(tts, 'infer_batch') and total_chunks > 1:
+                yield None, f"⚡ Xử lý batch ({total_chunks} đoạn cùng lúc)..."
+                chunk_wavs = tts.infer_batch(text_chunks, ref_codes, ref_text_raw)
+                
+                for i, chunk_wav in enumerate(chunk_wavs):
+                    if chunk_wav is not None and len(chunk_wav) > 0:
+                        all_audio_segments.append(chunk_wav)
+                        if i < total_chunks - 1:
+                            all_audio_segments.append(silence_pad)
+            else:
+                # Sequential processing
+                for i, chunk in enumerate(text_chunks):
+                    yield None, f"⏳ Đang xử lý đoạn {i+1}/{total_chunks}..."
+                    chunk_wav = tts.infer(chunk, ref_codes, ref_text_raw)
+                    
+                    if chunk_wav is not None and len(chunk_wav) > 0:
+                        all_audio_segments.append(chunk_wav)
+                        if i < total_chunks - 1:
+                            all_audio_segments.append(silence_pad)
+            
+            if not all_audio_segments:
+                yield None, "❌ Không sinh được audio nào."
+                return
+            
+            yield None, "💾 Đang ghép file và lưu..."
+            
+            final_wav = np.concatenate(all_audio_segments)
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
+                sf.write(tmp.name, final_wav, sr)
+                output_path = tmp.name
+            
+            process_time = time.time() - start_time
+            speed_info = f", Tốc độ: {len(final_wav)/sr/process_time:.2f}x realtime" if process_time > 0 else ""
+            
+            yield output_path, f"✅ Hoàn tất! (Thời gian: {process_time:.2f}s{speed_info}) {backend_name}"
+            
+            # Cleanup memory
+            if using_fast_backend and hasattr(tts, 'cleanup_memory'):
+                tts.cleanup_memory()
+            
+        except torch.cuda.OutOfMemoryError as e:
+            yield None, f"❌ GPU hết VRAM! Hãy thử giảm độ dài văn bản.\n\nChi tiết: {str(e)}"
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            return
+            
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            yield None, f"❌ Lỗi: {str(e)}"
+            return
+    
+    # === STREAMING MODE ===
+    else:
+        sr = 24000
+        crossfade_samples = int(sr * 0.03)
+        audio_queue = queue.Queue(maxsize=100)
+        PRE_BUFFER_SIZE = 3
+        
+        end_event = threading.Event()
+        error_event = threading.Event()
+        error_msg = ""
+        
+        def producer_thread():
+            nonlocal error_msg
+            try:
+                previous_tail = None
+                
+                for i, chunk_text in enumerate(text_chunks):
+                    stream_gen = tts.infer_stream(chunk_text, ref_codes, ref_text_raw)
+                    
+                    for part_idx, audio_part in enumerate(stream_gen):
+                        if audio_part is None or len(audio_part) == 0:
+                            continue
+                        
+                        if previous_tail is not None and len(previous_tail) > 0:
+                            overlap = min(len(previous_tail), len(audio_part), crossfade_samples)
+                            if overlap > 0:
+                                fade_out = np.linspace(1.0, 0.0, overlap, dtype=np.float32)
+                                fade_in = np.linspace(0.0, 1.0, overlap, dtype=np.float32)
+                                
+                                blended = (audio_part[:overlap] * fade_in + 
+                                         previous_tail[-overlap:] * fade_out)
+                                
+                                processed = np.concatenate([
+                                    previous_tail[:-overlap] if len(previous_tail) > overlap else np.array([]),
+                                    blended,
+                                    audio_part[overlap:]
+                                ])
+                            else:
+                                processed = np.concatenate([previous_tail, audio_part])
+                            
+                            tail_size = min(crossfade_samples, len(processed))
+                            previous_tail = processed[-tail_size:].copy()
+                            output_chunk = processed[:-tail_size] if len(processed) > tail_size else processed
+                        else:
+                            tail_size = min(crossfade_samples, len(audio_part))
+                            previous_tail = audio_part[-tail_size:].copy()
+                            output_chunk = audio_part[:-tail_size] if len(audio_part) > tail_size else audio_part
+                        
+                        if len(output_chunk) > 0:
+                            audio_queue.put((sr, output_chunk))
+                
+                if previous_tail is not None and len(previous_tail) > 0:
+                    audio_queue.put((sr, previous_tail))
+                    
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                error_msg = str(e)
+                error_event.set()
+            finally:
+                end_event.set()
+                audio_queue.put(None)
+        
+        threading.Thread(target=producer_thread, daemon=True).start()
+        
+        yield (sr, np.zeros(int(sr * 0.05))), "📄 Đang buffering..."
+        
+        pre_buffer = []
+        while len(pre_buffer) < PRE_BUFFER_SIZE:
+            try:
+                item = audio_queue.get(timeout=5.0)
+                if item is None:
+                    break
+                pre_buffer.append(item)
+            except queue.Empty:
+                if error_event.is_set():
+                    yield None, f"❌ Lỗi: {error_msg}"
+                    return
+                break
+        
+        full_audio_buffer = []
+        backend_info = "🚀 LMDeploy" if using_fast_backend else "📦 Standard"
+        for sr, audio_data in pre_buffer:
+            full_audio_buffer.append(audio_data)
+            yield (sr, audio_data), f"🔊 Đang phát ({backend_info})..."
+        
+        while True:
+            try:
+                item = audio_queue.get(timeout=0.05)
+                if item is None:
+                    break
+                sr, audio_data = item
+                full_audio_buffer.append(audio_data)
+                yield (sr, audio_data), f"🔊 Đang phát ({backend_info})..."
+            except queue.Empty:
+                if error_event.is_set():
+                    yield None, f"❌ Lỗi: {error_msg}"
+                    break
+                if end_event.is_set() and audio_queue.empty():
+                    break
+                continue
+        
+        if full_audio_buffer:
+            final_wav = np.concatenate(full_audio_buffer)
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
+                sf.write(tmp.name, final_wav, sr)
+                yield tmp.name, f"✅ Hoàn tất Streaming! ({backend_info})"
+            
+            if using_fast_backend and hasattr(tts, 'cleanup_memory'):
+                tts.cleanup_memory()
+
+# --- UI SETUP ---
+theme = gr.themes.Soft(
+    primary_hue="indigo",
+    secondary_hue="cyan",
+    neutral_hue="slate",
+    font=[gr.themes.GoogleFont('Inter'), 'ui-sans-serif', 'system-ui'],
+).set(
+    button_primary_background_fill="linear-gradient(90deg, #6366f1 0%, #0ea5e9 100%)",
+    button_primary_background_fill_hover="linear-gradient(90deg, #4f46e5 0%, #0284c7 100%)",
+    block_shadow="0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)",
+)
+
+css = """
+.container { max-width: 1200px; margin: auto; }
+.header-box { 
+    text-align: center; 
+    margin-bottom: 25px; 
+    padding: 25px; 
+    background: linear-gradient(135deg, #0f172a 0%, #1e293b 100%);
+    border-radius: 12px; 
+    border: 1px solid #334155; 
+    box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.3);
+}
+.header-title { 
+    font-size: 2.5rem; 
+    font-weight: 800; 
+    color: white;
+    background: -webkit-linear-gradient(45deg, #60A5FA, #22D3EE);
+    -webkit-background-clip: text; 
+    -webkit-text-fill-color: transparent; 
+    margin-bottom: 10px; 
+}
+.header-desc {
+    font-size: 1.1rem; 
+    color: #cbd5e1;
+    margin-bottom: 15px;
+}
+.link-group a { 
+    text-decoration: none; 
+    margin: 0 10px; 
+    font-weight: 600; 
+    color: #94a3b8;
+    transition: color 0.2s; 
+}
+.link-group a:hover { color: #38bdf8; text-shadow: 0 0 5px rgba(56, 189, 248, 0.5); }
+.status-box { font-weight: bold; text-align: center; border: none; background: transparent; }
+"""
+
+EXAMPLES_LIST = [
+    ["Về miền Tây không chỉ để ngắm nhìn sông nước hữu tình, mà còn để cảm nhận tấm chân tình của người dân nơi đây. Cùng ngồi xuồng ba lá len lỏi qua rặng dừa nước, nghe câu vọng cổ ngọt ngào thì còn gì bằng.", "Vĩnh (nam miền Nam)"],
+    ["Hà Nội những ngày vào thu mang một vẻ đẹp trầm mặc và cổ kính đến lạ thường. Đi dạo quanh Hồ Gươm vào sáng sớm, hít hà mùi hoa sữa nồng nàn và thưởng thức chút cốm làng Vòng là trải nghiệm khó quên.", "Bình (nam miền Bắc)"],
+    ["Sự bùng nổ của trí tuệ nhân tạo đang định hình lại cách chúng ta làm việc và sinh sống. Từ xe tự lái đến trợ lý ảo thông minh, công nghệ đang dần xóa nhòa ranh giới giữa thực tại và những bộ phim viễn tưởng.", "Tuyên (nam miền Bắc)"],
+    ["Ngày xửa ngày xưa, ở một ngôi làng nọ có cô Tấm xinh đẹp, nết na nhưng sớm mồ côi mẹ. Dù bị mẹ kế và Cám hãm hại đủ đường, Tấm vẫn giữ được tấm lòng lương thiện và cuối cùng tìm được hạnh phúc xứng đáng.", "Đoan (nữ miền Nam)"],
+]
+
+with gr.Blocks(theme=theme, css=css, title="VieNeu-TTS Studio") as demo:
+    with gr.Column(elem_classes="container"):
+        # Header
+        gr.HTML("""
+            <div class="header-box">
+                <div class="header-title">🎙️ VieNeu-TTS Studio</div>
+                <div class="header-desc">
+                    Phiên bản: VieNeu-TTS-1000h (GPU-optimized với LMDeploy)
+                </div>
+                <div class="link-group">
+                    <a href="https://huggingface.co/pnnbao-ump/VieNeu-TTS" target="_blank">🤗 Model Card</a> • 
+                    <a href="https://huggingface.co/datasets/pnnbao-ump/VieNeu-TTS-1000h" target="_blank">📖 Dataset 1000h</a> • 
+                    <a href="https://github.com/pnnbao97/VieNeu-TTS" target="_blank">🦜 GitHub</a>
+                </div>
+            </div>
+        """)
+        
+        # Status info
+        backend_status = "🚀 LMDeploy (GPU-optimized)" if using_fast_backend else "📦 Standard Backend"
+        gr.Markdown(f"**Backend hiện tại:** {backend_status}")
+    
+    with gr.Row(elem_classes="container", equal_height=False):
+        # --- LEFT: INPUT ---
+        with gr.Column(scale=3, variant="panel"):
+            gr.Markdown("### 📝 Văn bản đầu vào")
+            text_input = gr.Textbox(
+                label="Nhập văn bản",
+                placeholder="Nhập nội dung tiếng Việt cần chuyển thành giọng nói...",
+                lines=4,
+                value="Sự bùng nổ của trí tuệ nhân tạo đang định hình lại cách chúng ta làm việc và sinh sống. Từ xe tự lái đến trợ lý ảo thông minh, công nghệ đang dần xóa nhòa ranh giới giữa thực tại và những bộ phim viễn tưởng.",
+                show_label=False
+            )
+            
+            gr.Markdown("### 🗣️ Chọn giọng đọc")
+            with gr.Tabs() as tabs:
+                with gr.TabItem("👤 Giọng có sẵn (Preset)", id="preset_mode"):
+                    voice_select = gr.Dropdown(
+                        choices=list(VOICE_SAMPLES.keys()),
+                        value=list(VOICE_SAMPLES.keys())[0] if VOICE_SAMPLES else None,
+                        label="Danh sách giọng",
+                        interactive=True
+                    )
+                    with gr.Accordion("Thông tin giọng mẫu", open=False):
+                        ref_audio_preview = gr.Audio(label="Audio mẫu", interactive=False, type="filepath")
+                        ref_text_preview = gr.Markdown("...")
+
+                with gr.TabItem("🎙️ Giọng tùy chỉnh (Custom)", id="custom_mode"):
+                    gr.Markdown("Tải lên giọng của bạn (Zero-shot Cloning)")
+                    custom_audio = gr.Audio(label="File ghi âm (.wav)", type="filepath")
+                    custom_text = gr.Textbox(label="Nội dung ghi âm", placeholder="Nhập chính xác lời thoại...")
+            
+            gr.Markdown("### ⚙️ Cài đặt tổng hợp")
+            generation_mode = gr.Radio(
+                ["Standard (Một lần)", "Streaming (Thời gian thực)"],
+                value="Standard (Một lần)",
+                label="Chế độ sinh"
+            )
+            use_batch = gr.Checkbox(
+                value=True, 
+                label="⚡ Batch Processing (chỉ có hiệu lực khi dùng LMDeploy backend)",
+                info="Xử lý nhiều đoạn cùng lúc để tăng tốc"
+            )
+
+            current_mode = gr.Textbox(visible=False, value="preset_mode")
+            btn_generate = gr.Button("Tổng hợp giọng nói", variant="primary", size="lg")
+
+        # --- RIGHT: OUTPUT ---
+        with gr.Column(scale=2):
+            gr.Markdown("### 🎧 Kết quả")
+            with gr.Group():
+                audio_output = gr.Audio(label="Audio đầu ra", type="filepath", show_download_button=True, autoplay=True)
+                status_output = gr.Textbox(label="Trạng thái", show_label=False, elem_classes="status-box", placeholder="Sẵn sàng...")
+
+    # --- EXAMPLES ---
+    with gr.Row(elem_classes="container"):
+        with gr.Column():
+            gr.Markdown("### 📚 Ví dụ mẫu")
+            gr.Examples(examples=EXAMPLES_LIST, inputs=[text_input, voice_select], label="Thử nghiệm nhanh")
+
+    # --- EVENT HANDLERS ---
+    def update_ref_preview(voice):
+        audio, text = load_reference_info(voice)
+        return audio, f"> *\"{text}\"*"
+    
+    voice_select.change(update_ref_preview, voice_select, [ref_audio_preview, ref_text_preview])
+    demo.load(update_ref_preview, voice_select, [ref_audio_preview, ref_text_preview])
+
+    # Tab handling
+    tabs.children[0].select(fn=lambda: "preset_mode", outputs=current_mode)
+    tabs.children[1].select(fn=lambda: "custom_mode", outputs=current_mode)
+
+    btn_generate.click(
+        fn=synthesize_speech,
+        inputs=[text_input, voice_select, custom_audio, custom_text, current_mode, generation_mode, use_batch],
+        outputs=[audio_output, status_output]
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=7860
     )

requirements.txt

@@ -1,9 +1,9 @@
-gradio
-spaces
-torchaudio
-transformers
-librosa
-soundfile
-numpy
-phonemizer
-neucodec
+torchaudio
+transformers
+librosa
+soundfile
+numpy
+phonemizer
+neucodec
+lmdeploy
+pyyaml

sample/Bình (nam miền Bắc).pt

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

sample/Dung (nữ miền Nam).pt

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

sample/Hương (nữ miền Bắc).pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:919035b7c762956a7d568cebc6e69fea22eb9be02bf906c1d32c1db1d8c7b9ff
+size 2217

sample/Ly (nữ miền Bắc).pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69b6bc9bb1062122dc3755be907d87f232fa8be5129b54f6994dead35f4935c6
+size 2153

sample/Nguyên (nam miền Nam).pt

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

sample/Ngọc (nữ miền Bắc).pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78ab670f177092dc8586e45536faea20fdb84471dc8d8a8b1b95dd76a4ed3d0d
+size 2281

sample/Sơn (nam miền Nam).pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:114cb04ee2357d06de2f038853bbeb0dc57fc8ed30e085118a9e0bf5a70f7857
+size 2281

sample/Tuyên (nam miền Bắc).pt

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

sample/Vĩnh (nam miền Nam).pt

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

sample/Đoan (nữ miền Nam).pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28b48dbae193adc88aa26243086ba3ce862def7035d9793613c2967df29f9afe
+size 2793

utils/core_utils.py

@@ -0,0 +1,47 @@
+import re
+from typing import List
+
+def split_text_into_chunks(text: str, max_chars: int = 256) -> List[str]:
+    """
+    Split raw text into chunks no longer than max_chars.
+    Preference is given to sentence boundaries; otherwise falls back to word-based splitting.
+    """
+    sentences = re.split(r"(?<=[\.\!\?\…])\s+", text.strip())
+    chunks: List[str] = []
+    buffer = ""
+
+    def flush_buffer():
+        nonlocal buffer
+        if buffer:
+            chunks.append(buffer.strip())
+            buffer = ""
+
+    for sentence in sentences:
+        sentence = sentence.strip()
+        if not sentence:
+            continue
+
+        if len(sentence) <= max_chars:
+            candidate = f"{buffer} {sentence}".strip() if buffer else sentence
+            if len(candidate) <= max_chars:
+                buffer = candidate
+            else:
+                flush_buffer()
+                buffer = sentence
+            continue
+
+        flush_buffer()
+        words = sentence.split()
+        current = ""
+        for word in words:
+            candidate = f"{current} {word}".strip() if current else word
+            if len(candidate) > max_chars and current:
+                chunks.append(current.strip())
+                current = word
+            else:
+                current = candidate
+        if current:
+            chunks.append(current.strip())
+
+    flush_buffer()
+    return [chunk for chunk in chunks if chunk]

utils/normalize_text.py

@@ -1,408 +1,408 @@
-import re
-
-class VietnameseTTSNormalizer:
-    """
-    A text normalizer for Vietnamese Text-to-Speech systems.
-    Converts numbers, dates, units, and special characters into readable Vietnamese text.
-    """
-    
-    def __init__(self):
-        self.units = {
-            'km': 'ki lô mét', 'dm': 'đê xi mét', 'cm': 'xen ti mét',
-            'mm': 'mi li mét', 'nm': 'na nô mét', 'µm': 'mic rô mét',
-            'μm': 'mic rô mét', 'm': 'mét',
-            
-            'kg': 'ki lô gam', 'g': 'gam', 'mg': 'mi li gam',
-            
-            'km²': 'ki lô mét vuông', 'km2': 'ki lô mét vuông',
-            'm²': 'mét vuông', 'm2': 'mét vuông',
-            'cm²': 'xen ti mét vuông', 'cm2': 'xen ti mét vuông',
-            'mm²': 'mi li mét vuông', 'mm2': 'mi li mét vuông',
-            'ha': 'héc ta',
-            
-            'km³': 'ki lô mét khối', 'km3': 'ki lô mét khối',
-            'm³': 'mét khối', 'm3': 'mét khối',
-            'cm³': 'xen ti mét khối', 'cm3': 'xen ti mét khối',
-            'mm³': 'mi li mét khối', 'mm3': 'mi li mét khối',
-            'l': 'lít', 'dl': 'đê xi lít', 'ml': 'mi li lít', 'hl': 'héc tô lít',
-            
-            'v': 'vôn', 'kv': 'ki lô vôn', 'mv': 'mi li vôn',
-            'a': 'am pe', 'ma': 'mi li am pe', 'ka': 'ki lô am pe',
-            'w': 'oát', 'kw': 'ki lô oát', 'mw': 'mê ga oát', 'gw': 'gi ga oát',
-            'kwh': 'ki lô oát giờ', 'mwh': 'mê ga oát giờ', 'wh': 'oát giờ',
-            'ω': 'ôm', 'ohm': 'ôm', 'kω': 'ki lô ôm', 'mω': 'mê ga ôm',
-            
-            'hz': 'héc', 'khz': 'ki lô héc', 'mhz': 'mê ga héc', 'ghz': 'gi ga héc',
-            
-            'pa': 'pát cal', 'kpa': 'ki lô pát cal', 'mpa': 'mê ga pát cal',
-            'bar': 'ba', 'mbar': 'mi li ba', 'atm': 'át mốt phia', 'psi': 'pi ét xai',
-            
-            'j': 'giun', 'kj': 'ki lô giun',
-            'cal': 'ca lo', 'kcal': 'ki lô ca lo',
-        }
-        
-        self.digits = ['không', 'một', 'hai', 'ba', 'bốn', 
-                      'năm', 'sáu', 'bảy', 'tám', 'chín']
-    
-    def normalize(self, text):
-        """Main normalization pipeline."""
-        text = text.lower()
-        text = self._normalize_temperature(text)
-        text = self._normalize_currency(text)
-        text = self._normalize_percentage(text)
-        text = self._normalize_units(text)
-        text = self._normalize_time(text)
-        text = self._normalize_date(text)
-        text = self._normalize_phone(text)
-        text = self._normalize_numbers(text)
-        text = self._number_to_words(text)
-        text = self._normalize_special_chars(text)
-        text = self._normalize_whitespace(text)
-        return text
-    
-    def _normalize_temperature(self, text):
-        """Convert temperature notation to words."""
-        text = re.sub(r'-(\d+(?:[.,]\d+)?)\s*°\s*c\b', r'âm \1 độ xê', text, flags=re.IGNORECASE)
-        text = re.sub(r'-(\d+(?:[.,]\d+)?)\s*°\s*f\b', r'âm \1 độ ép', text, flags=re.IGNORECASE)
-        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*°\s*c\b', r'\1 độ xê', text, flags=re.IGNORECASE)
-        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*°\s*f\b', r'\1 độ ép', text, flags=re.IGNORECASE)
-        text = re.sub(r'°', ' độ ', text)
-        return text
-    
-    def _normalize_currency(self, text):
-        """Convert currency notation to words."""
-        def decimal_currency(match):
-            whole = match.group(1)
-            decimal = match.group(2)
-            unit = match.group(3)
-            decimal_words = ' '.join([self.digits[int(d)] for d in decimal])
-            unit_map = {'k': 'nghìn', 'm': 'triệu', 'b': 'tỷ'}
-            unit_word = unit_map.get(unit.lower(), unit)
-            return f"{whole} phẩy {decimal_words} {unit_word}"
-        
-        text = re.sub(r'(\d+)[.,](\d+)\s*([kmb])\b', decimal_currency, text, flags=re.IGNORECASE)
-        text = re.sub(r'(\d+)\s*k\b', r'\1 nghìn', text, flags=re.IGNORECASE)
-        text = re.sub(r'(\d+)\s*m\b', r'\1 triệu', text, flags=re.IGNORECASE)
-        text = re.sub(r'(\d+)\s*b\b', r'\1 tỷ', text, flags=re.IGNORECASE)
-        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*đ\b', r'\1 đồng', text)
-        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*vnd\b', r'\1 đồng', text, flags=re.IGNORECASE)
-        text = re.sub(r'\$\s*(\d+(?:[.,]\d+)?)', r'\1 đô la', text)
-        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*\$', r'\1 đô la', text)
-        return text
-    
-    def _normalize_percentage(self, text):
-        """Convert percentage to words."""
-        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*%', r'\1 phần trăm', text)
-        return text
-    
-    def _normalize_units(self, text):
-        """Convert measurement units to words."""
-        def expand_compound_with_number(match):
-            number = match.group(1)
-            unit1 = match.group(2).lower()
-            unit2 = match.group(3).lower()
-            full_unit1 = self.units.get(unit1, unit1)
-            full_unit2 = self.units.get(unit2, unit2)
-            return f"{number} {full_unit1} trên {full_unit2}"
-        
-        def expand_compound_without_number(match):
-            unit1 = match.group(1).lower()
-            unit2 = match.group(2).lower()
-            full_unit1 = self.units.get(unit1, unit1)
-            full_unit2 = self.units.get(unit2, unit2)
-            return f"{full_unit1} trên {full_unit2}"
-        
-        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*([a-zA-Zμµ²³°]+)/([a-zA-Zμµ²³°0-9]+)\b', 
-                     expand_compound_with_number, text)
-        text = re.sub(r'\b([a-zA-Zμµ²³°]+)/([a-zA-Zμµ²³°0-9]+)\b', 
-                     expand_compound_without_number, text)
-        
-        sorted_units = sorted(self.units.items(), key=lambda x: len(x[0]), reverse=True)
-        for unit, full_name in sorted_units:
-            pattern = r'(\d+(?:[.,]\d+)?)\s*' + re.escape(unit) + r'\b'
-            text = re.sub(pattern, rf'\1 {full_name}', text, flags=re.IGNORECASE)
-        
-        for unit, full_name in sorted_units:
-            if any(c in unit for c in '²³°'):
-                pattern = r'\b' + re.escape(unit) + r'\b'
-                text = re.sub(pattern, full_name, text, flags=re.IGNORECASE)
-        
-        return text
-    
-    def _normalize_time(self, text):
-        """Convert time notation to words with validation."""
-        
-        def validate_and_convert_time(match):
-            """Validate time components before converting."""
-            groups = match.groups()
-            
-            # HH:MM:SS format
-            if len(groups) == 3:
-                hour, minute, second = groups
-                hour_int, minute_int, second_int = int(hour), int(minute), int(second)
-                
-                # Validate ranges
-                if not (0 <= hour_int <= 23):
-                    return match.group(0)  # Return original if invalid
-                if not (0 <= minute_int <= 59):
-                    return match.group(0)
-                if not (0 <= second_int <= 59):
-                    return match.group(0)
-                
-                return f"{hour} giờ {minute} phút {second} giây"
-            
-            # HH:MM or HHhMM format
-            elif len(groups) == 2:
-                hour, minute = groups
-                hour_int, minute_int = int(hour), int(minute)
-                
-                # Validate ranges
-                if not (0 <= hour_int <= 23):
-                    return match.group(0)
-                if not (0 <= minute_int <= 59):
-                    return match.group(0)
-                
-                return f"{hour} giờ {minute} phút"
-            
-            # HHh format
-            else:
-                hour = groups[0]
-                hour_int = int(hour)
-                
-                if not (0 <= hour_int <= 23):
-                    return match.group(0)
-                
-                return f"{hour} giờ"
-        
-        # Apply patterns with validation
-        text = re.sub(r'(\d{1,2}):(\d{2}):(\d{2})', validate_and_convert_time, text)
-        text = re.sub(r'(\d{1,2}):(\d{2})', validate_and_convert_time, text)
-        text = re.sub(r'(\d{1,2})h(\d{2})', validate_and_convert_time, text)
-        text = re.sub(r'(\d{1,2})h\b', validate_and_convert_time, text)
-        
-        return text
-    
-    def _normalize_date(self, text):
-        """Convert date notation to words with validation."""
-        
-        def is_valid_date(day, month, year):
-            """Check if date components are valid."""
-            day, month, year = int(day), int(month), int(year)
-            
-            # Basic range checks
-            if not (1 <= day <= 31):
-                return False
-            if not (1 <= month <= 12):
-                return False
-
-            return True
-        
-        def date_to_text(match):
-            day, month, year = match.groups()
-            if is_valid_date(day, month, year):
-                return f"ngày {day} tháng {month} năm {year}"
-            return match.group(0)  # Return original if invalid
-        
-        def date_iso_to_text(match):
-            year, month, day = match.groups()
-            if is_valid_date(day, month, year):
-                return f"ngày {day} tháng {month} năm {year}"
-            return match.group(0)
-        
-        def date_short_year(match):
-            day, month, year = match.groups()
-            full_year = f"20{year}" if int(year) < 50 else f"19{year}"
-            if is_valid_date(day, month, full_year):
-                return f"ngày {day} tháng {month} năm {full_year}"
-            return match.group(0)
-        
-        # Apply patterns with validation
-        text = re.sub(r'\bngày\s+(\d{1,2})[/\-](\d{1,2})[/\-](\d{4})\b', 
-                    lambda m: date_to_text(m).replace('ngày ngày', 'ngày'), text)
-        text = re.sub(r'\bngày\s+(\d{1,2})[/\-](\d{1,2})[/\-](\d{2})\b', 
-                    lambda m: date_short_year(m).replace('ngày ngày', 'ngày'), text)
-        text = re.sub(r'\b(\d{4})-(\d{1,2})-(\d{1,2})\b', date_iso_to_text, text)
-        text = re.sub(r'\b(\d{1,2})[/\-](\d{1,2})[/\-](\d{4})\b', date_to_text, text)
-        text = re.sub(r'\b(\d{1,2})[/\-](\d{1,2})[/\-](\d{2})\b', date_short_year, text)
-        
-        return text
-    
-    def _normalize_phone(self, text):
-        """Convert phone numbers to digit-by-digit reading."""
-        def phone_to_text(match):
-            phone = match.group(0)
-            phone = re.sub(r'[^\d]', '', phone)
-            
-            if phone.startswith('84') and len(phone) >= 10:
-                phone = '0' + phone[2:]
-            
-            if 10 <= len(phone) <= 11:
-                words = [self.digits[int(d)] for d in phone]
-                return ' '.join(words) + ' '
-            
-            return match.group(0)
-        
-        text = re.sub(r'(\+84|84)[\s\-\.]?\d[\d\s\-\.]{7,}', phone_to_text, text)
-        text = re.sub(r'\b0\d[\d\s\-\.]{8,}', phone_to_text, text)
-        return text
-    
-    def _normalize_numbers(self, text):
-        text = re.sub(r'(\d+(?:[,.]\d+)?)%', lambda m: f'{m.group(1)} phần trăm', text)
-        # 1. Xóa dấu thousand separator trước
-        text = re.sub(r'(\d{1,3})(?:\.(\d{3}))+', lambda m: m.group(0).replace('.', ''), text)
-    
-        # 2. Chuyển số thập phân thành chữ
-        def decimal_to_words(match):
-            whole = match.group(1)
-            decimal = match.group(2)
-            decimal_words = ' '.join([self.digits[int(d)] for d in decimal])
-            separator = 'phẩy' if ',' in match.group(0) else 'chấm'
-            return f"{whole} {separator} {decimal_words}"
-        
-        # 2a. Dấu phẩy
-        text = re.sub(r'(\d+),(\d+)', decimal_to_words, text)
-        # 2b. Dấu chấm (1-2 chữ số thập phân)
-        text = re.sub(r'(\d+)\.(\d{1,2})\b', decimal_to_words, text)
-        
-        return text
-    
-    def _read_two_digits(self, n):
-        """Read two-digit numbers in Vietnamese."""
-        if n < 10:
-            return self.digits[n]
-        elif n == 10:
-            return "mười"
-        elif n < 20:
-            if n == 15:
-                return "mười lăm"
-            return f"mười {self.digits[n % 10]}"
-        else:
-            tens = n // 10
-            ones = n % 10
-            if ones == 0:
-                return f"{self.digits[tens]} mươi"
-            elif ones == 1:
-                return f"{self.digits[tens]} mươi mốt"
-            elif ones == 5:
-                return f"{self.digits[tens]} mươi lăm"
-            else:
-                return f"{self.digits[tens]} mươi {self.digits[ones]}"
-    
-    def _read_three_digits(self, n):
-        """Read three-digit numbers in Vietnamese."""
-        if n < 100:
-            return self._read_two_digits(n)
-        
-        hundreds = n // 100
-        remainder = n % 100
-        result = f"{self.digits[hundreds]} trăm"
-        
-        if remainder == 0:
-            return result
-        elif remainder < 10:
-            result += f" lẻ {self.digits[remainder]}"
-        else:
-            result += f" {self._read_two_digits(remainder)}"
-        
-        return result
-    
-    def _convert_number_to_words(self, num):
-        """Convert a number to Vietnamese words."""
-        if num == 0:
-            return "không"
-        
-        if num < 0:
-            return f"âm {self._convert_number_to_words(-num)}"
-        
-        if num >= 1000000000:
-            billion = num // 1000000000
-            remainder = num % 1000000000
-            result = f"{self._read_three_digits(billion)} tỷ"
-            if remainder > 0:
-                result += f" {self._convert_number_to_words(remainder)}"
-            return result
-        
-        elif num >= 1000000:
-            million = num // 1000000
-            remainder = num % 1000000
-            result = f"{self._read_three_digits(million)} triệu"
-            if remainder > 0:
-                result += f" {self._convert_number_to_words(remainder)}"
-            return result
-        
-        elif num >= 1000:
-            thousand = num // 1000
-            remainder = num % 1000
-            result = f"{self._read_three_digits(thousand)} nghìn"
-            if remainder > 0:
-                if remainder < 100:
-                    result += f" không trăm {self._read_two_digits(remainder)}"
-                else:
-                    result += f" {self._read_three_digits(remainder)}"
-            return result
-        
-        else:
-            return self._read_three_digits(num)
-    
-    def _number_to_words(self, text):
-        """Convert all remaining numbers to words."""
-        def convert_number(match):
-            num = int(match.group(0))
-            return self._convert_number_to_words(num)
-        
-        text = re.sub(r'\b\d+\b', convert_number, text)
-        return text
-    
-    def _normalize_special_chars(self, text):
-        """Handle special characters."""
-        text = text.replace('&', ' và ')
-        text = text.replace('+', ' cộng ')
-        text = text.replace('=', ' bằng ')
-        text = text.replace('#', ' thăng ')
-        text = re.sub(r'[\[\]\(\)\{\}]', ' ', text)
-        text = re.sub(r'\s+[-–—]+\s+', ' ', text)
-        text = re.sub(r'\.{2,}', ' ', text)
-        text = re.sub(r'\s+\.\s+', ' ', text)
-        text = re.sub(r'[^\w\sàáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ.,!?;:@%]', ' ', text)
-        return text
-    
-    def _normalize_whitespace(self, text):
-        """Normalize whitespace."""
-        text = re.sub(r'\s+', ' ', text)
-        text = text.strip()
-        return text
-
-
-if __name__ == "__main__":
-    normalizer = VietnameseTTSNormalizer()
-    
-    test_texts = [
-        "Giá 2.500.000đ (giảm 50%), mua trước 14h30 ngày 15/12/2025",
-        "Liên hệ: 0912-345-678 hoặc email@example.com",
-        "Tốc độ 120km/h, trọng lượng 75kg",
-        "Nhiệt độ 36,5°C, độ ẩm 80%",
-        "Số pi = 3,14159",
-        "Giá trị tăng 2.5M, đạt 10B",
-        "Nhiệt độ -15°C vào mùa đông",
-        "Điện áp 220V, công suất 2.5kW, tần số 50Hz",
-        "Tôi đi lấy l nước về nhà",
-        "Cần 5l nước cho công thức này",
-        "Vận tốc ánh sáng 299792km/s",
-        "Mật độ dân số 450 người/km2",
-        "Công suất 100 W/m2",
-        "Hôm nay 2025-01-15",
-        "Gọi +84 912 345 678",
-        "Nhiệt độ 25°C lúc 14:30:45",
-        "Ngày 15/12/25",
-        "Giá 3.140.159",
-    ]
-    
-    print("=" * 80)
-    print("VIETNAMESE TTS NORMALIZATION TEST")
-    print("=" * 80)
-    
-    for text in test_texts:
-        print(f"\n📝 Input: {text}")
-        normalized = normalizer.normalize(text)
-        print(f"🎵 Output: {normalized}")
-        print("-" * 80)
+import re
+
+class VietnameseTTSNormalizer:
+    """
+    A text normalizer for Vietnamese Text-to-Speech systems.
+    Converts numbers, dates, units, and special characters into readable Vietnamese text.
+    """
+    
+    def __init__(self):
+        self.units = {
+            'km': 'ki lô mét', 'dm': 'đê xi mét', 'cm': 'xen ti mét',
+            'mm': 'mi li mét', 'nm': 'na nô mét', 'µm': 'mic rô mét',
+            'μm': 'mic rô mét', 'm': 'mét',
+            
+            'kg': 'ki lô gam', 'g': 'gam', 'mg': 'mi li gam',
+            
+            'km²': 'ki lô mét vuông', 'km2': 'ki lô mét vuông',
+            'm²': 'mét vuông', 'm2': 'mét vuông',
+            'cm²': 'xen ti mét vuông', 'cm2': 'xen ti mét vuông',
+            'mm²': 'mi li mét vuông', 'mm2': 'mi li mét vuông',
+            'ha': 'héc ta',
+            
+            'km³': 'ki lô mét khối', 'km3': 'ki lô mét khối',
+            'm³': 'mét khối', 'm3': 'mét khối',
+            'cm³': 'xen ti mét khối', 'cm3': 'xen ti mét khối',
+            'mm³': 'mi li mét khối', 'mm3': 'mi li mét khối',
+            'l': 'lít', 'dl': 'đê xi lít', 'ml': 'mi li lít', 'hl': 'héc tô lít',
+            
+            'v': 'vôn', 'kv': 'ki lô vôn', 'mv': 'mi li vôn',
+            'a': 'am pe', 'ma': 'mi li am pe', 'ka': 'ki lô am pe',
+            'w': 'oát', 'kw': 'ki lô oát', 'mw': 'mê ga oát', 'gw': 'gi ga oát',
+            'kwh': 'ki lô oát giờ', 'mwh': 'mê ga oát giờ', 'wh': 'oát giờ',
+            'ω': 'ôm', 'ohm': 'ôm', 'kω': 'ki lô ôm', 'mω': 'mê ga ôm',
+            
+            'hz': 'héc', 'khz': 'ki lô héc', 'mhz': 'mê ga héc', 'ghz': 'gi ga héc',
+            
+            'pa': 'pát cal', 'kpa': 'ki lô pát cal', 'mpa': 'mê ga pát cal',
+            'bar': 'ba', 'mbar': 'mi li ba', 'atm': 'át mốt phia', 'psi': 'pi ét xai',
+            
+            'j': 'giun', 'kj': 'ki lô giun',
+            'cal': 'ca lo', 'kcal': 'ki lô ca lo',
+        }
+        
+        self.digits = ['không', 'một', 'hai', 'ba', 'bốn', 
+                      'năm', 'sáu', 'bảy', 'tám', 'chín']
+    
+    def normalize(self, text):
+        """Main normalization pipeline."""
+        text = text.lower()
+        text = self._normalize_temperature(text)
+        text = self._normalize_currency(text)
+        text = self._normalize_percentage(text)
+        text = self._normalize_units(text)
+        text = self._normalize_time(text)
+        text = self._normalize_date(text)
+        text = self._normalize_phone(text)
+        text = self._normalize_numbers(text)
+        text = self._number_to_words(text)
+        text = self._normalize_special_chars(text)
+        text = self._normalize_whitespace(text)
+        return text
+    
+    def _normalize_temperature(self, text):
+        """Convert temperature notation to words."""
+        text = re.sub(r'-(\d+(?:[.,]\d+)?)\s*°\s*c\b', r'âm \1 độ xê', text, flags=re.IGNORECASE)
+        text = re.sub(r'-(\d+(?:[.,]\d+)?)\s*°\s*f\b', r'âm \1 độ ép', text, flags=re.IGNORECASE)
+        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*°\s*c\b', r'\1 độ xê', text, flags=re.IGNORECASE)
+        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*°\s*f\b', r'\1 độ ép', text, flags=re.IGNORECASE)
+        text = re.sub(r'°', ' độ ', text)
+        return text
+    
+    def _normalize_currency(self, text):
+        """Convert currency notation to words."""
+        def decimal_currency(match):
+            whole = match.group(1)
+            decimal = match.group(2)
+            unit = match.group(3)
+            decimal_words = ' '.join([self.digits[int(d)] for d in decimal])
+            unit_map = {'k': 'nghìn', 'm': 'triệu', 'b': 'tỷ'}
+            unit_word = unit_map.get(unit.lower(), unit)
+            return f"{whole} phẩy {decimal_words} {unit_word}"
+        
+        text = re.sub(r'(\d+)[.,](\d+)\s*([kmb])\b', decimal_currency, text, flags=re.IGNORECASE)
+        text = re.sub(r'(\d+)\s*k\b', r'\1 nghìn', text, flags=re.IGNORECASE)
+        text = re.sub(r'(\d+)\s*m\b', r'\1 triệu', text, flags=re.IGNORECASE)
+        text = re.sub(r'(\d+)\s*b\b', r'\1 tỷ', text, flags=re.IGNORECASE)
+        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*đ\b', r'\1 đồng', text)
+        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*vnd\b', r'\1 đồng', text, flags=re.IGNORECASE)
+        text = re.sub(r'\$\s*(\d+(?:[.,]\d+)?)', r'\1 đô la', text)
+        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*\$', r'\1 đô la', text)
+        return text
+    
+    def _normalize_percentage(self, text):
+        """Convert percentage to words."""
+        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*%', r'\1 phần trăm', text)
+        return text
+    
+    def _normalize_units(self, text):
+        """Convert measurement units to words."""
+        def expand_compound_with_number(match):
+            number = match.group(1)
+            unit1 = match.group(2).lower()
+            unit2 = match.group(3).lower()
+            full_unit1 = self.units.get(unit1, unit1)
+            full_unit2 = self.units.get(unit2, unit2)
+            return f"{number} {full_unit1} trên {full_unit2}"
+        
+        def expand_compound_without_number(match):
+            unit1 = match.group(1).lower()
+            unit2 = match.group(2).lower()
+            full_unit1 = self.units.get(unit1, unit1)
+            full_unit2 = self.units.get(unit2, unit2)
+            return f"{full_unit1} trên {full_unit2}"
+        
+        text = re.sub(r'(\d+(?:[.,]\d+)?)\s*([a-zA-Zμµ²³°]+)/([a-zA-Zμµ²³°0-9]+)\b', 
+                     expand_compound_with_number, text)
+        text = re.sub(r'\b([a-zA-Zμµ²³°]+)/([a-zA-Zμµ²³°0-9]+)\b', 
+                     expand_compound_without_number, text)
+        
+        sorted_units = sorted(self.units.items(), key=lambda x: len(x[0]), reverse=True)
+        for unit, full_name in sorted_units:
+            pattern = r'(\d+(?:[.,]\d+)?)\s*' + re.escape(unit) + r'\b'
+            text = re.sub(pattern, rf'\1 {full_name}', text, flags=re.IGNORECASE)
+        
+        for unit, full_name in sorted_units:
+            if any(c in unit for c in '²³°'):
+                pattern = r'\b' + re.escape(unit) + r'\b'
+                text = re.sub(pattern, full_name, text, flags=re.IGNORECASE)
+        
+        return text
+    
+    def _normalize_time(self, text):
+        """Convert time notation to words with validation."""
+        
+        def validate_and_convert_time(match):
+            """Validate time components before converting."""
+            groups = match.groups()
+            
+            # HH:MM:SS format
+            if len(groups) == 3:
+                hour, minute, second = groups
+                hour_int, minute_int, second_int = int(hour), int(minute), int(second)
+                
+                # Validate ranges
+                if not (0 <= hour_int <= 23):
+                    return match.group(0)  # Return original if invalid
+                if not (0 <= minute_int <= 59):
+                    return match.group(0)
+                if not (0 <= second_int <= 59):
+                    return match.group(0)
+                
+                return f"{hour} giờ {minute} phút {second} giây"
+            
+            # HH:MM or HHhMM format
+            elif len(groups) == 2:
+                hour, minute = groups
+                hour_int, minute_int = int(hour), int(minute)
+                
+                # Validate ranges
+                if not (0 <= hour_int <= 23):
+                    return match.group(0)
+                if not (0 <= minute_int <= 59):
+                    return match.group(0)
+                
+                return f"{hour} giờ {minute} phút"
+            
+            # HHh format
+            else:
+                hour = groups[0]
+                hour_int = int(hour)
+                
+                if not (0 <= hour_int <= 23):
+                    return match.group(0)
+                
+                return f"{hour} giờ"
+        
+        # Apply patterns with validation
+        text = re.sub(r'(\d{1,2}):(\d{2}):(\d{2})', validate_and_convert_time, text)
+        text = re.sub(r'(\d{1,2}):(\d{2})', validate_and_convert_time, text)
+        text = re.sub(r'(\d{1,2})h(\d{2})', validate_and_convert_time, text)
+        text = re.sub(r'(\d{1,2})h\b', validate_and_convert_time, text)
+        
+        return text
+    
+    def _normalize_date(self, text):
+        """Convert date notation to words with validation."""
+        
+        def is_valid_date(day, month, year):
+            """Check if date components are valid."""
+            day, month, year = int(day), int(month), int(year)
+            
+            # Basic range checks
+            if not (1 <= day <= 31):
+                return False
+            if not (1 <= month <= 12):
+                return False
+
+            return True
+        
+        def date_to_text(match):
+            day, month, year = match.groups()
+            if is_valid_date(day, month, year):
+                return f"ngày {day} tháng {month} năm {year}"
+            return match.group(0)  # Return original if invalid
+        
+        def date_iso_to_text(match):
+            year, month, day = match.groups()
+            if is_valid_date(day, month, year):
+                return f"ngày {day} tháng {month} năm {year}"
+            return match.group(0)
+        
+        def date_short_year(match):
+            day, month, year = match.groups()
+            full_year = f"20{year}" if int(year) < 50 else f"19{year}"
+            if is_valid_date(day, month, full_year):
+                return f"ngày {day} tháng {month} năm {full_year}"
+            return match.group(0)
+        
+        # Apply patterns with validation
+        text = re.sub(r'\bngày\s+(\d{1,2})[/\-](\d{1,2})[/\-](\d{4})\b', 
+                    lambda m: date_to_text(m).replace('ngày ngày', 'ngày'), text)
+        text = re.sub(r'\bngày\s+(\d{1,2})[/\-](\d{1,2})[/\-](\d{2})\b', 
+                    lambda m: date_short_year(m).replace('ngày ngày', 'ngày'), text)
+        text = re.sub(r'\b(\d{4})-(\d{1,2})-(\d{1,2})\b', date_iso_to_text, text)
+        text = re.sub(r'\b(\d{1,2})[/\-](\d{1,2})[/\-](\d{4})\b', date_to_text, text)
+        text = re.sub(r'\b(\d{1,2})[/\-](\d{1,2})[/\-](\d{2})\b', date_short_year, text)
+        
+        return text
+    
+    def _normalize_phone(self, text):
+        """Convert phone numbers to digit-by-digit reading."""
+        def phone_to_text(match):
+            phone = match.group(0)
+            phone = re.sub(r'[^\d]', '', phone)
+            
+            if phone.startswith('84') and len(phone) >= 10:
+                phone = '0' + phone[2:]
+            
+            if 10 <= len(phone) <= 11:
+                words = [self.digits[int(d)] for d in phone]
+                return ' '.join(words) + ' '
+            
+            return match.group(0)
+        
+        text = re.sub(r'(\+84|84)[\s\-\.]?\d[\d\s\-\.]{7,}', phone_to_text, text)
+        text = re.sub(r'\b0\d[\d\s\-\.]{8,}', phone_to_text, text)
+        return text
+    
+    def _normalize_numbers(self, text):
+        text = re.sub(r'(\d+(?:[,.]\d+)?)%', lambda m: f'{m.group(1)} phần trăm', text)
+        # 1. Xóa dấu thousand separator trước
+        text = re.sub(r'(\d{1,3})(?:\.(\d{3}))+', lambda m: m.group(0).replace('.', ''), text)
+    
+        # 2. Chuyển số thập phân thành chữ
+        def decimal_to_words(match):
+            whole = match.group(1)
+            decimal = match.group(2)
+            decimal_words = ' '.join([self.digits[int(d)] for d in decimal])
+            separator = 'phẩy' if ',' in match.group(0) else 'chấm'
+            return f"{whole} {separator} {decimal_words}"
+        
+        # 2a. Dấu phẩy
+        text = re.sub(r'(\d+),(\d+)', decimal_to_words, text)
+        # 2b. Dấu chấm (1-2 chữ số thập phân)
+        text = re.sub(r'(\d+)\.(\d{1,2})\b', decimal_to_words, text)
+        
+        return text
+    
+    def _read_two_digits(self, n):
+        """Read two-digit numbers in Vietnamese."""
+        if n < 10:
+            return self.digits[n]
+        elif n == 10:
+            return "mười"
+        elif n < 20:
+            if n == 15:
+                return "mười lăm"
+            return f"mười {self.digits[n % 10]}"
+        else:
+            tens = n // 10
+            ones = n % 10
+            if ones == 0:
+                return f"{self.digits[tens]} mươi"
+            elif ones == 1:
+                return f"{self.digits[tens]} mươi mốt"
+            elif ones == 5:
+                return f"{self.digits[tens]} mươi lăm"
+            else:
+                return f"{self.digits[tens]} mươi {self.digits[ones]}"
+    
+    def _read_three_digits(self, n):
+        """Read three-digit numbers in Vietnamese."""
+        if n < 100:
+            return self._read_two_digits(n)
+        
+        hundreds = n // 100
+        remainder = n % 100
+        result = f"{self.digits[hundreds]} trăm"
+        
+        if remainder == 0:
+            return result
+        elif remainder < 10:
+            result += f" lẻ {self.digits[remainder]}"
+        else:
+            result += f" {self._read_two_digits(remainder)}"
+        
+        return result
+    
+    def _convert_number_to_words(self, num):
+        """Convert a number to Vietnamese words."""
+        if num == 0:
+            return "không"
+        
+        if num < 0:
+            return f"âm {self._convert_number_to_words(-num)}"
+        
+        if num >= 1000000000:
+            billion = num // 1000000000
+            remainder = num % 1000000000
+            result = f"{self._read_three_digits(billion)} tỷ"
+            if remainder > 0:
+                result += f" {self._convert_number_to_words(remainder)}"
+            return result
+        
+        elif num >= 1000000:
+            million = num // 1000000
+            remainder = num % 1000000
+            result = f"{self._read_three_digits(million)} triệu"
+            if remainder > 0:
+                result += f" {self._convert_number_to_words(remainder)}"
+            return result
+        
+        elif num >= 1000:
+            thousand = num // 1000
+            remainder = num % 1000
+            result = f"{self._read_three_digits(thousand)} nghìn"
+            if remainder > 0:
+                if remainder < 100:
+                    result += f" không trăm {self._read_two_digits(remainder)}"
+                else:
+                    result += f" {self._read_three_digits(remainder)}"
+            return result
+        
+        else:
+            return self._read_three_digits(num)
+    
+    def _number_to_words(self, text):
+        """Convert all remaining numbers to words."""
+        def convert_number(match):
+            num = int(match.group(0))
+            return self._convert_number_to_words(num)
+        
+        text = re.sub(r'\b\d+\b', convert_number, text)
+        return text
+    
+    def _normalize_special_chars(self, text):
+        """Handle special characters."""
+        text = text.replace('&', ' và ')
+        text = text.replace('+', ' cộng ')
+        text = text.replace('=', ' bằng ')
+        text = text.replace('#', ' thăng ')
+        text = re.sub(r'[\[\]\(\)\{\}]', ' ', text)
+        text = re.sub(r'\s+[-–—]+\s+', ' ', text)
+        text = re.sub(r'\.{2,}', ' ', text)
+        text = re.sub(r'\s+\.\s+', ' ', text)
+        text = re.sub(r'[^\w\sàáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ.,!?;:@%]', ' ', text)
+        return text
+    
+    def _normalize_whitespace(self, text):
+        """Normalize whitespace."""
+        text = re.sub(r'\s+', ' ', text)
+        text = text.strip()
+        return text
+
+
+if __name__ == "__main__":
+    normalizer = VietnameseTTSNormalizer()
+    
+    test_texts = [
+        "Giá 2.500.000đ (giảm 50%), mua trước 14h30 ngày 15/12/2025",
+        "Liên hệ: 0912-345-678 hoặc email@example.com",
+        "Tốc độ 120km/h, trọng lượng 75kg",
+        "Nhiệt độ 36,5°C, độ ẩm 80%",
+        "Số pi = 3,14159",
+        "Giá trị tăng 2.5M, đạt 10B",
+        "Nhiệt độ -15°C vào mùa đông",
+        "Điện áp 220V, công suất 2.5kW, tần số 50Hz",
+        "Tôi đi lấy l nước về nhà",
+        "Cần 5l nước cho công thức này",
+        "Vận tốc ánh sáng 299792km/s",
+        "Mật độ dân số 450 người/km2",
+        "Công suất 100 W/m2",
+        "Hôm nay 2025-01-15",
+        "Gọi +84 912 345 678",
+        "Nhiệt độ 25°C lúc 14:30:45",
+        "Ngày 15/12/25",
+        "Giá 3.140.159",
+    ]
+    
+    print("=" * 80)
+    print("VIETNAMESE TTS NORMALIZATION TEST")
+    print("=" * 80)
+    
+    for text in test_texts:
+        print(f"\n📝 Input: {text}")
+        normalized = normalizer.normalize(text)
+        print(f"🎵 Output: {normalized}")
+        print("-" * 80)

utils/phonemize_text.py

@@ -1,150 +1,150 @@
-import os
-import json
-import platform
-import glob
-from phonemizer import phonemize
-from phonemizer.backend.espeak.espeak import EspeakWrapper
-from utils.normalize_text import VietnameseTTSNormalizer
-
-# Configuration
-PHONEME_DICT_PATH = os.getenv(
-    'PHONEME_DICT_PATH',
-    os.path.join(os.path.dirname(__file__), "phoneme_dict.json")
-)
-
-def load_phoneme_dict(path=PHONEME_DICT_PATH):
-    """Load phoneme dictionary from JSON file."""
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except FileNotFoundError:
-        raise FileNotFoundError(
-            f"Phoneme dictionary not found at {path}. "
-            "Please create it or set PHONEME_DICT_PATH environment variable."
-        )
-
-def setup_espeak_library():
-    """Configure eSpeak library path based on operating system."""
-    system = platform.system()
-    
-    if system == "Windows":
-        _setup_windows_espeak()
-    elif system == "Linux":
-        _setup_linux_espeak()
-    elif system == "Darwin":
-        _setup_macos_espeak()
-    else:
-        raise OSError(
-            f"Unsupported OS: {system}. "
-            "Only Windows, Linux, and macOS are supported."
-        )
-
-def _setup_windows_espeak():
-    """Setup eSpeak for Windows."""
-    default_path = r"C:\Program Files\eSpeak NG\libespeak-ng.dll"
-    if os.path.exists(default_path):
-        EspeakWrapper.set_library(default_path)
-    else:
-        raise FileNotFoundError(
-            f"eSpeak library not found at {default_path}. "
-            "Please install eSpeak NG from: https://github.com/espeak-ng/espeak-ng/releases"
-        )
-
-def _setup_linux_espeak():
-    """Setup eSpeak for Linux."""
-    search_patterns = [
-        "/usr/lib/x86_64-linux-gnu/libespeak-ng.so*",
-        "/usr/lib/x86_64-linux-gnu/libespeak.so*",
-        "/usr/lib/libespeak-ng.so*",
-        "/usr/lib64/libespeak-ng.so*",
-        "/usr/local/lib/libespeak-ng.so*",
-    ]
-    
-    for pattern in search_patterns:
-        matches = glob.glob(pattern)
-        if matches:
-            EspeakWrapper.set_library(sorted(matches, key=len)[0])
-            return
-    
-    raise RuntimeError(
-        "eSpeak NG library not found. Install with:\n"
-        "  Ubuntu/Debian: sudo apt-get install espeak-ng\n"
-        "  Fedora: sudo dnf install espeak-ng\n"
-        "  Arch: sudo pacman -S espeak-ng\n"
-        "See: https://github.com/pnnbao97/VieNeu-TTS/issues/5"
-    )
-
-def _setup_macos_espeak():
-    """Setup eSpeak for macOS."""
-    espeak_lib = os.environ.get('PHONEMIZER_ESPEAK_LIBRARY')
-    
-    paths_to_check = [
-        espeak_lib,
-        "/opt/homebrew/lib/libespeak-ng.dylib",  # Apple Silicon
-        "/usr/local/lib/libespeak-ng.dylib",     # Intel
-        "/opt/local/lib/libespeak-ng.dylib",     # MacPorts
-    ]
-    
-    for path in paths_to_check:
-        if path and os.path.exists(path):
-            EspeakWrapper.set_library(path)
-            return
-    
-    raise FileNotFoundError(
-        "eSpeak library not found. Install with:\n"
-        "  brew install espeak-ng\n"
-        "Or set: export PHONEMIZER_ESPEAK_LIBRARY=/path/to/libespeak-ng.dylib"
-    )
-
-# Initialize
-try:
-    setup_espeak_library()
-    phoneme_dict = load_phoneme_dict()
-    normalizer = VietnameseTTSNormalizer()
-except Exception as e:
-    print(f"Initialization error: {e}")
-    raise
-
-def phonemize_text(text: str) -> str:
-    """Convert text to phonemes using phonemizer."""
-    text = normalizer.normalize(text)
-    return phonemize(
-        text,
-        language="vi",
-        backend="espeak",
-        preserve_punctuation=True,
-        with_stress=True,
-        language_switch="remove-flags"
-    )
-
-def phonemize_with_dict(text: str, phoneme_dict=phoneme_dict) -> str:
-    """Phonemize text with dictionary lookup."""
-    text = normalizer.normalize(text)
-    words = text.split()
-    result = []
-    
-    for word in words:
-        if word in phoneme_dict:
-            phone_word = phoneme_dict[word]
-        else:
-            try:
-                phone_word = phonemize(
-                    word,
-                    language='vi',
-                    backend='espeak',
-                    preserve_punctuation=True,
-                    with_stress=True,
-                    language_switch='remove-flags'
-                )
-                
-                if word.lower().startswith('r'):
-                    phone_word = 'ɹ' + phone_word[1:]
-                
-                phoneme_dict[word] = phone_word
-            except Exception as e:
-                print(f"Warning: Could not phonemize '{word}': {e}")
-                phone_word = word
-        
-        result.append(phone_word)
-    
+import os
+import json
+import platform
+import glob
+from phonemizer import phonemize
+from phonemizer.backend.espeak.espeak import EspeakWrapper
+from utils.normalize_text import VietnameseTTSNormalizer
+
+# Configuration
+PHONEME_DICT_PATH = os.getenv(
+    'PHONEME_DICT_PATH',
+    os.path.join(os.path.dirname(__file__), "phoneme_dict.json")
+)
+
+def load_phoneme_dict(path=PHONEME_DICT_PATH):
+    """Load phoneme dictionary from JSON file."""
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        raise FileNotFoundError(
+            f"Phoneme dictionary not found at {path}. "
+            "Please create it or set PHONEME_DICT_PATH environment variable."
+        )
+
+def setup_espeak_library():
+    """Configure eSpeak library path based on operating system."""
+    system = platform.system()
+    
+    if system == "Windows":
+        _setup_windows_espeak()
+    elif system == "Linux":
+        _setup_linux_espeak()
+    elif system == "Darwin":
+        _setup_macos_espeak()
+    else:
+        raise OSError(
+            f"Unsupported OS: {system}. "
+            "Only Windows, Linux, and macOS are supported."
+        )
+
+def _setup_windows_espeak():
+    """Setup eSpeak for Windows."""
+    default_path = r"C:\Program Files\eSpeak NG\libespeak-ng.dll"
+    if os.path.exists(default_path):
+        EspeakWrapper.set_library(default_path)
+    else:
+        raise FileNotFoundError(
+            f"eSpeak library not found at {default_path}. "
+            "Please install eSpeak NG from: https://github.com/espeak-ng/espeak-ng/releases"
+        )
+
+def _setup_linux_espeak():
+    """Setup eSpeak for Linux."""
+    search_patterns = [
+        "/usr/lib/x86_64-linux-gnu/libespeak-ng.so*",
+        "/usr/lib/x86_64-linux-gnu/libespeak.so*",
+        "/usr/lib/libespeak-ng.so*",
+        "/usr/lib64/libespeak-ng.so*",
+        "/usr/local/lib/libespeak-ng.so*",
+    ]
+    
+    for pattern in search_patterns:
+        matches = glob.glob(pattern)
+        if matches:
+            EspeakWrapper.set_library(sorted(matches, key=len)[0])
+            return
+    
+    raise RuntimeError(
+        "eSpeak NG library not found. Install with:\n"
+        "  Ubuntu/Debian: sudo apt-get install espeak-ng\n"
+        "  Fedora: sudo dnf install espeak-ng\n"
+        "  Arch: sudo pacman -S espeak-ng\n"
+        "See: https://github.com/pnnbao97/VieNeu-TTS/issues/5"
+    )
+
+def _setup_macos_espeak():
+    """Setup eSpeak for macOS."""
+    espeak_lib = os.environ.get('PHONEMIZER_ESPEAK_LIBRARY')
+    
+    paths_to_check = [
+        espeak_lib,
+        "/opt/homebrew/lib/libespeak-ng.dylib",  # Apple Silicon
+        "/usr/local/lib/libespeak-ng.dylib",     # Intel
+        "/opt/local/lib/libespeak-ng.dylib",     # MacPorts
+    ]
+    
+    for path in paths_to_check:
+        if path and os.path.exists(path):
+            EspeakWrapper.set_library(path)
+            return
+    
+    raise FileNotFoundError(
+        "eSpeak library not found. Install with:\n"
+        "  brew install espeak-ng\n"
+        "Or set: export PHONEMIZER_ESPEAK_LIBRARY=/path/to/libespeak-ng.dylib"
+    )
+
+# Initialize
+try:
+    setup_espeak_library()
+    phoneme_dict = load_phoneme_dict()
+    normalizer = VietnameseTTSNormalizer()
+except Exception as e:
+    print(f"Initialization error: {e}")
+    raise
+
+def phonemize_text(text: str) -> str:
+    """Convert text to phonemes using phonemizer."""
+    text = normalizer.normalize(text)
+    return phonemize(
+        text,
+        language="vi",
+        backend="espeak",
+        preserve_punctuation=True,
+        with_stress=True,
+        language_switch="remove-flags"
+    )
+
+def phonemize_with_dict(text: str, phoneme_dict=phoneme_dict) -> str:
+    """Phonemize text with dictionary lookup."""
+    text = normalizer.normalize(text)
+    words = text.split()
+    result = []
+    
+    for word in words:
+        if word in phoneme_dict:
+            phone_word = phoneme_dict[word]
+        else:
+            try:
+                phone_word = phonemize(
+                    word,
+                    language='vi',
+                    backend='espeak',
+                    preserve_punctuation=True,
+                    with_stress=True,
+                    language_switch='remove-flags'
+                )
+                
+                if word.lower().startswith('r'):
+                    phone_word = 'ɹ' + phone_word[1:]
+                
+                phoneme_dict[word] = phone_word
+            except Exception as e:
+                print(f"Warning: Could not phonemize '{word}': {e}")
+                phone_word = word
+        
+        result.append(phone_word)
+    
     return ' '.join(result)

vieneu_tts/__init__.py

@@ -0,0 +1,4 @@
+from .vieneu_tts import VieNeuTTS, FastVieNeuTTS
+
+__all__ = ["VieNeuTTS", "FastVieNeuTTS"]
+

vieneu_tts/vieneu_tts.py

@@ -0,0 +1,869 @@
+from pathlib import Path
+from typing import Generator
+import librosa
+import numpy as np
+import torch
+from neucodec import NeuCodec, DistillNeuCodec
+from utils.phonemize_text import phonemize_with_dict
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor
+import re
+import gc
+
+# ============================================================================
+# Shared Utilities
+# ============================================================================
+
+def _linear_overlap_add(frames: list[np.ndarray], stride: int) -> np.ndarray:
+    """Linear overlap-add for smooth audio concatenation"""
+    assert len(frames)
+    dtype = frames[0].dtype
+    shape = frames[0].shape[:-1]
+
+    total_size = 0
+    for i, frame in enumerate(frames):
+        frame_end = stride * i + frame.shape[-1]
+        total_size = max(total_size, frame_end)
+
+    sum_weight = np.zeros(total_size, dtype=dtype)
+    out = np.zeros(*shape, total_size, dtype=dtype)
+
+    offset: int = 0
+    for frame in frames:
+        frame_length = frame.shape[-1]
+        t = np.linspace(0, 1, frame_length + 2, dtype=dtype)[1:-1]
+        weight = np.abs(0.5 - (t - 0.5))
+
+        out[..., offset : offset + frame_length] += weight * frame
+        sum_weight[offset : offset + frame_length] += weight
+        offset += stride
+    assert sum_weight.min() > 0
+    return out / sum_weight
+
+
+def _compile_codec_with_triton(codec):
+    """Compile codec with Triton for faster decoding (Windows/Linux compatible)"""
+    try:
+        import triton
+        
+        if hasattr(codec, 'dec') and hasattr(codec.dec, 'resblocks'):
+            if len(codec.dec.resblocks) > 2:
+                codec.dec.resblocks[2].forward = torch.compile(
+                    codec.dec.resblocks[2].forward,
+                    mode="reduce-overhead",
+                    dynamic=True
+                )
+                print("   ✅ Triton compilation enabled for codec")
+        return True
+        
+    except ImportError:
+        print("   ⚠️ Triton not found. Install for faster speed:")
+        print("      • Linux: pip install triton")
+        print("      • Windows: pip install triton-windows")
+        print("      (Optional but recommended)")
+        return False
+
+
+# ============================================================================
+# VieNeuTTS - Standard implementation (CPU/GPU compatible)
+# Supports: PyTorch Transformers, GGUF/GGML quantized models
+# ============================================================================
+
+class VieNeuTTS:
+    """
+    Standard VieNeu-TTS implementation.
+    
+    Supports:
+    - PyTorch + Transformers backend (CPU/GPU)
+    - GGUF quantized models via llama-cpp-python (CPU optimized)
+    
+    Use this for:
+    - CPU-only environments
+    - Standard PyTorch workflows
+    - GGUF quantized models
+    """
+    
+    def __init__(
+        self,
+        backbone_repo="pnnbao-ump/VieNeu-TTS",
+        backbone_device="cpu",
+        codec_repo="neuphonic/neucodec",
+        codec_device="cpu",
+    ):
+        """
+        Initialize VieNeu-TTS.
+        
+        Args:
+            backbone_repo: Model repository or path to GGUF file
+            backbone_device: Device for backbone ('cpu', 'cuda', 'gpu')
+            codec_repo: Codec repository
+            codec_device: Device for codec
+        """
+
+        # Constants
+        self.sample_rate = 24_000
+        self.max_context = 2048
+        self.hop_length = 480
+        self.streaming_overlap_frames = 1
+        self.streaming_frames_per_chunk = 25
+        self.streaming_lookforward = 5
+        self.streaming_lookback = 50
+        self.streaming_stride_samples = self.streaming_frames_per_chunk * self.hop_length
+
+        # Flags
+        self._is_quantized_model = False
+        self._is_onnx_codec = False
+
+        # HF tokenizer
+        self.tokenizer = None
+
+        # Load models
+        self._load_backbone(backbone_repo, backbone_device)
+        self._load_codec(codec_repo, codec_device)
+    
+    def _load_backbone(self, backbone_repo, backbone_device):
+        print(f"Loading backbone from: {backbone_repo} on {backbone_device} ...")
+
+        if backbone_repo.lower().endswith("gguf") or "gguf" in backbone_repo.lower():
+            try:
+                from llama_cpp import Llama
+            except ImportError as e:
+                raise ImportError(
+                    "Failed to import `llama_cpp`. "
+                    "Please install it with:\n"
+                    "    pip install llama-cpp-python"
+                ) from e
+            self.backbone = Llama.from_pretrained(
+                repo_id=backbone_repo,
+                filename="*.gguf",
+                verbose=False,
+                n_gpu_layers=-1 if backbone_device == "gpu" else 0,
+                n_ctx=self.max_context,
+                mlock=True,
+                flash_attn=True if backbone_device == "gpu" else False,
+            )
+            self._is_quantized_model = True
+            
+        else:
+            from transformers import AutoTokenizer, AutoModelForCausalLM
+            self.tokenizer = AutoTokenizer.from_pretrained(backbone_repo)
+            self.backbone = AutoModelForCausalLM.from_pretrained(backbone_repo).to(
+                torch.device(backbone_device)
+            )
+    
+    def _load_codec(self, codec_repo, codec_device):
+        print(f"Loading codec from: {codec_repo} on {codec_device} ...")
+        match codec_repo:
+            case "neuphonic/neucodec":
+                self.codec = NeuCodec.from_pretrained(codec_repo)
+                self.codec.eval().to(codec_device)
+            case "neuphonic/distill-neucodec":
+                self.codec = DistillNeuCodec.from_pretrained(codec_repo)
+                self.codec.eval().to(codec_device)
+            case "neuphonic/neucodec-onnx-decoder":
+                if codec_device != "cpu":
+                    raise ValueError("Onnx decoder only currently runs on CPU.")
+                try:
+                    from neucodec import NeuCodecOnnxDecoder
+                except ImportError as e:
+                    raise ImportError(
+                        "Failed to import the onnx decoder."
+                        "Ensure you have onnxruntime installed as well as neucodec >= 0.0.4."
+                    ) from e
+                self.codec = NeuCodecOnnxDecoder.from_pretrained(codec_repo)
+                self._is_onnx_codec = True
+            case _:
+                raise ValueError(f"Unsupported codec repository: {codec_repo}")
+
+    def encode_reference(self, ref_audio_path: str | Path):
+        """Encode reference audio to codes"""
+        wav, _ = librosa.load(ref_audio_path, sr=16000, mono=True)
+        wav_tensor = torch.from_numpy(wav).float().unsqueeze(0).unsqueeze(0)  # [1, 1, T]
+        with torch.no_grad():
+            ref_codes = self.codec.encode_code(audio_or_path=wav_tensor).squeeze(0).squeeze(0)
+        return ref_codes
+
+    def infer(self, text: str, ref_codes: np.ndarray | torch.Tensor, ref_text: str) -> np.ndarray:
+        """
+        Perform inference to generate speech from text using the TTS model and reference audio.
+
+        Args:
+            text (str): Input text to be converted to speech.
+            ref_codes (np.ndarray | torch.tensor): Encoded reference.
+            ref_text (str): Reference text for reference audio.
+        Returns:
+            np.ndarray: Generated speech waveform.
+        """
+
+        # Generate tokens
+        if self._is_quantized_model:
+            output_str = self._infer_ggml(ref_codes, ref_text, text)
+        else:
+            prompt_ids = self._apply_chat_template(ref_codes, ref_text, text)
+            output_str = self._infer_torch(prompt_ids)
+
+        # Decode
+        wav = self._decode(output_str)
+
+        return wav
+
+    def infer_stream(self, text: str, ref_codes: np.ndarray | torch.Tensor, ref_text: str) -> Generator[np.ndarray, None, None]:
+        """
+        Perform streaming inference to generate speech from text using the TTS model and reference audio.
+
+        Args:
+            text (str): Input text to be converted to speech.
+            ref_codes (np.ndarray | torch.tensor): Encoded reference.
+            ref_text (str): Reference text for reference audio.
+        Yields:
+            np.ndarray: Generated speech waveform.
+        """
+
+        if self._is_quantized_model:
+            return self._infer_stream_ggml(ref_codes, ref_text, text)
+        else:
+            raise NotImplementedError("Streaming is not implemented for the torch backend!")
+
+    def _decode(self, codes: str):
+        """Decode speech tokens to audio waveform."""
+        # Extract speech token IDs using regex
+        speech_ids = [int(num) for num in re.findall(r"<\|speech_(\d+)\|>", codes)]
+        
+        if len(speech_ids) == 0:
+            raise ValueError(
+                "No valid speech tokens found in the output. "
+                "The model may not have generated proper speech tokens."
+            )
+        
+        # Onnx decode
+        if self._is_onnx_codec:
+            codes = np.array(speech_ids, dtype=np.int32)[np.newaxis, np.newaxis, :]
+            recon = self.codec.decode_code(codes)
+        # Torch decode
+        else:
+            with torch.no_grad():
+                codes = torch.tensor(speech_ids, dtype=torch.long)[None, None, :].to(
+                    self.codec.device
+                )
+                recon = self.codec.decode_code(codes).cpu().numpy()
+        
+        return recon[0, 0, :]
+    
+    def _apply_chat_template(self, ref_codes: list[int], ref_text: str, input_text: str) -> list[int]:
+        input_text = phonemize_with_dict(ref_text) + " " + phonemize_with_dict(input_text)
+
+        speech_replace = self.tokenizer.convert_tokens_to_ids("<|SPEECH_REPLACE|>")
+        speech_gen_start = self.tokenizer.convert_tokens_to_ids("<|SPEECH_GENERATION_START|>")
+        text_replace = self.tokenizer.convert_tokens_to_ids("<|TEXT_REPLACE|>")
+        text_prompt_start = self.tokenizer.convert_tokens_to_ids("<|TEXT_PROMPT_START|>")
+        text_prompt_end = self.tokenizer.convert_tokens_to_ids("<|TEXT_PROMPT_END|>")
+
+        input_ids = self.tokenizer.encode(input_text, add_special_tokens=False)
+        chat = """user: Convert the text to speech:<|TEXT_REPLACE|>\nassistant:<|SPEECH_REPLACE|>"""
+        ids = self.tokenizer.encode(chat)
+
+        text_replace_idx = ids.index(text_replace)
+        ids = (
+            ids[:text_replace_idx]
+            + [text_prompt_start]
+            + input_ids
+            + [text_prompt_end]
+            + ids[text_replace_idx + 1 :]  # noqa
+        )
+
+        speech_replace_idx = ids.index(speech_replace)
+        codes_str = "".join([f"<|speech_{i}|>" for i in ref_codes])
+        codes = self.tokenizer.encode(codes_str, add_special_tokens=False)
+        ids = ids[:speech_replace_idx] + [speech_gen_start] + list(codes)
+
+        return ids
+
+    def _infer_torch(self, prompt_ids: list[int]) -> str:
+        prompt_tensor = torch.tensor(prompt_ids).unsqueeze(0).to(self.backbone.device)
+        speech_end_id = self.tokenizer.convert_tokens_to_ids("<|SPEECH_GENERATION_END|>")
+        with torch.no_grad():
+            output_tokens = self.backbone.generate(
+                prompt_tensor,
+                max_length=self.max_context,
+                eos_token_id=speech_end_id,
+                do_sample=True,
+                temperature=1.0,
+                top_k=50,
+                use_cache=True,
+                min_new_tokens=50,
+            )
+        input_length = prompt_tensor.shape[-1]
+        output_str = self.tokenizer.decode(
+            output_tokens[0, input_length:].cpu().numpy().tolist(), add_special_tokens=False
+        )
+        return output_str
+
+    def _infer_ggml(self, ref_codes: list[int], ref_text: str, input_text: str) -> str:
+        ref_text = phonemize_with_dict(ref_text)
+        input_text = phonemize_with_dict(input_text)
+
+        codes_str = "".join([f"<|speech_{idx}|>" for idx in ref_codes])
+        prompt = (
+            f"user: Convert the text to speech:<|TEXT_PROMPT_START|>{ref_text} {input_text}"
+            f"<|TEXT_PROMPT_END|>\nassistant:<|SPEECH_GENERATION_START|>{codes_str}"
+        )
+        output = self.backbone(
+            prompt,
+            max_tokens=self.max_context,
+            temperature=1.0,
+            top_k=50,
+            stop=["<|SPEECH_GENERATION_END|>"],
+        )
+        output_str = output["choices"][0]["text"]
+        return output_str
+
+    def _infer_stream_ggml(self, ref_codes: torch.Tensor, ref_text: str, input_text: str) -> Generator[np.ndarray, None, None]:
+        ref_text = phonemize_with_dict(ref_text)
+        input_text = phonemize_with_dict(input_text)
+
+        codes_str = "".join([f"<|speech_{idx}|>" for idx in ref_codes])
+        prompt = (
+            f"user: Convert the text to speech:<|TEXT_PROMPT_START|>{ref_text} {input_text}"
+            f"<|TEXT_PROMPT_END|>\nassistant:<|SPEECH_GENERATION_START|>{codes_str}"
+        )
+
+        audio_cache: list[np.ndarray] = []
+        token_cache: list[str] = [f"<|speech_{idx}|>" for idx in ref_codes]
+        n_decoded_samples: int = 0
+        n_decoded_tokens: int = len(ref_codes)
+
+        for item in self.backbone(
+            prompt,
+            max_tokens=self.max_context,
+            temperature=1.0,
+            top_k=50,
+            stop=["<|SPEECH_GENERATION_END|>"],
+            stream=True
+        ):
+            output_str = item["choices"][0]["text"]
+            token_cache.append(output_str)
+
+            if len(token_cache[n_decoded_tokens:]) >= self.streaming_frames_per_chunk + self.streaming_lookforward:
+
+                # decode chunk
+                tokens_start = max(
+                    n_decoded_tokens
+                    - self.streaming_lookback
+                    - self.streaming_overlap_frames,
+                    0
+                )
+                tokens_end = (
+                    n_decoded_tokens
+                    + self.streaming_frames_per_chunk
+                    + self.streaming_lookforward
+                    + self.streaming_overlap_frames
+                )
+                sample_start = (
+                    n_decoded_tokens - tokens_start
+                ) * self.hop_length
+                sample_end = (
+                    sample_start
+                    + (self.streaming_frames_per_chunk + 2 * self.streaming_overlap_frames) * self.hop_length
+                )
+                curr_codes = token_cache[tokens_start:tokens_end]
+                recon = self._decode("".join(curr_codes))
+                recon = recon[sample_start:sample_end]
+                audio_cache.append(recon)
+
+                # postprocess
+                processed_recon = _linear_overlap_add(
+                    audio_cache, stride=self.streaming_stride_samples
+                )
+                new_samples_end = len(audio_cache) * self.streaming_stride_samples
+                processed_recon = processed_recon[
+                    n_decoded_samples:new_samples_end
+                ]
+                n_decoded_samples = new_samples_end
+                n_decoded_tokens += self.streaming_frames_per_chunk
+                yield processed_recon
+
+        # final decoding handled separately as non-constant chunk size
+        remaining_tokens = len(token_cache) - n_decoded_tokens
+        if len(token_cache) > n_decoded_tokens:
+            tokens_start = max(
+                len(token_cache)
+                - (self.streaming_lookback + self.streaming_overlap_frames + remaining_tokens), 
+                0
+            )
+            sample_start = (
+                len(token_cache) 
+                - tokens_start 
+                - remaining_tokens 
+                - self.streaming_overlap_frames
+            ) * self.hop_length
+            curr_codes = token_cache[tokens_start:]
+            recon = self._decode("".join(curr_codes))
+            recon = recon[sample_start:]
+            audio_cache.append(recon)
+
+            processed_recon = _linear_overlap_add(audio_cache, stride=self.streaming_stride_samples)
+            processed_recon = processed_recon[n_decoded_samples:]
+            yield processed_recon
+
+
+# ============================================================================
+# FastVieNeuTTS - GPU-optimized implementation
+# Requires: LMDeploy with CUDA
+# ============================================================================
+
+class FastVieNeuTTS:
+    """
+    GPU-optimized VieNeu-TTS using LMDeploy TurbomindEngine.
+    """
+    
+    def __init__(
+        self,
+        backbone_repo="pnnbao-ump/VieNeu-TTS",
+        backbone_device="cuda",
+        codec_repo="neuphonic/neucodec",
+        codec_device="cuda",
+        memory_util=0.3,
+        tp=1,
+        enable_prefix_caching=True,
+        quant_policy=8,
+        enable_triton=True,
+        max_batch_size=8,
+    ):
+        """
+        Initialize FastVieNeuTTS with LMDeploy backend and optimizations.
+        
+        Args:
+            backbone_repo: Model repository
+            backbone_device: Device for backbone (must be CUDA)
+            codec_repo: Codec repository
+            codec_device: Device for codec
+            memory_util: GPU memory utilization (0.0-1.0)
+            tp: Tensor parallel size for multi-GPU
+            enable_prefix_caching: Enable prefix caching for faster batch processing
+            quant_policy: KV cache quantization (0=off, 8=int8, 4=int4)
+            enable_triton: Enable Triton compilation for codec
+            max_batch_size: Maximum batch size for inference (prevent GPU overload)
+        """
+        
+        if backbone_device != "cuda" and not backbone_device.startswith("cuda:"):
+            raise ValueError("LMDeploy backend requires CUDA device")
+        
+        # Constants
+        self.sample_rate = 24_000
+        self.max_context = 2048
+        self.hop_length = 480
+        self.streaming_overlap_frames = 1
+        self.streaming_frames_per_chunk = 50
+        self.streaming_lookforward = 5
+        self.streaming_lookback = 50
+        self.streaming_stride_samples = self.streaming_frames_per_chunk * self.hop_length
+        
+        self.max_batch_size = max_batch_size
+        
+        self._ref_cache = {}
+        
+        self.stored_dict = defaultdict(dict)
+        
+        # Flags
+        self._is_onnx_codec = False
+        self._triton_enabled = False
+        
+        # Load models
+        self._load_backbone_lmdeploy(backbone_repo, memory_util, tp, enable_prefix_caching, quant_policy)
+        self._load_codec(codec_repo, codec_device, enable_triton)
+
+        self._warmup_model()
+        
+        print("✅ FastVieNeuTTS with optimizations loaded successfully!")
+        print(f"   Max batch size: {self.max_batch_size} (adjustable to prevent GPU overload)")
+    
+    def _load_backbone_lmdeploy(self, repo, memory_util, tp, enable_prefix_caching, quant_policy):
+        """Load backbone using LMDeploy's TurbomindEngine"""
+        print(f"Loading backbone with LMDeploy from: {repo}")
+        
+        try:
+            from lmdeploy import pipeline, TurbomindEngineConfig, GenerationConfig
+        except ImportError as e:
+            raise ImportError(
+                "Failed to import `lmdeploy`. "
+                "Please install it with: pip install lmdeploy"
+            ) from e
+        
+        backend_config = TurbomindEngineConfig(
+            cache_max_entry_count=memory_util,
+            tp=tp,
+            enable_prefix_caching=enable_prefix_caching,
+            dtype='bfloat16',
+            quant_policy=quant_policy
+        )
+        
+        self.backbone = pipeline(repo, backend_config=backend_config)
+        
+        self.gen_config = GenerationConfig(
+            top_p=0.95,
+            top_k=50,
+            temperature=1.0,
+            max_new_tokens=1024,
+            repetition_penalty=1.0,
+            do_sample=True,
+            min_new_tokens=40,
+            min_p=0.1,
+        )
+        
+        print(f"   LMDeploy TurbomindEngine initialized")
+        print(f"   - Memory util: {memory_util}")
+        print(f"   - Tensor Parallel: {tp}")
+        print(f"   - Prefix caching: {enable_prefix_caching}")
+        print(f"   - KV quant: {quant_policy} ({'Enabled' if quant_policy > 0 else 'Disabled'})")
+    
+    def _load_codec(self, codec_repo, codec_device, enable_triton):
+        """Load codec with optional Triton compilation"""
+        print(f"Loading codec from: {codec_repo} on {codec_device}")
+        
+        match codec_repo:
+            case "neuphonic/neucodec":
+                self.codec = NeuCodec.from_pretrained(codec_repo)
+                self.codec.eval().to(codec_device)
+            case "neuphonic/distill-neucodec":
+                self.codec = DistillNeuCodec.from_pretrained(codec_repo)
+                self.codec.eval().to(codec_device)
+            case "neuphonic/neucodec-onnx-decoder":
+                if codec_device != "cpu":
+                    raise ValueError("ONNX decoder only runs on CPU")
+                try:
+                    from neucodec import NeuCodecOnnxDecoder
+                except ImportError as e:
+                    raise ImportError(
+                        "Failed to import ONNX decoder. "
+                        "Ensure onnxruntime and neucodec >= 0.0.4 are installed."
+                    ) from e
+                self.codec = NeuCodecOnnxDecoder.from_pretrained(codec_repo)
+                self._is_onnx_codec = True
+            case _:
+                raise ValueError(f"Unsupported codec repository: {codec_repo}")
+        
+        if enable_triton and not self._is_onnx_codec and codec_device != "cpu":
+            self._triton_enabled = _compile_codec_with_triton(self.codec)
+    
+    def _warmup_model(self):
+        """Warmup inference pipeline to reduce first-token latency"""
+        print("🔥 Warming up model...")
+        try:
+            dummy_codes = list(range(10))
+            dummy_prompt = self._format_prompt(dummy_codes, "warmup", "test")
+            _ = self.backbone([dummy_prompt], gen_config=self.gen_config, do_preprocess=False)
+            print("   ✅ Warmup complete")
+        except Exception as e:
+            print(f"   ⚠️ Warmup failed (non-critical): {e}")
+    
+    def encode_reference(self, ref_audio_path: str | Path):
+        """Encode reference audio to codes"""
+        wav, _ = librosa.load(ref_audio_path, sr=16000, mono=True)
+        wav_tensor = torch.from_numpy(wav).float().unsqueeze(0).unsqueeze(0)
+        with torch.no_grad():
+            ref_codes = self.codec.encode_code(audio_or_path=wav_tensor).squeeze(0).squeeze(0)
+        return ref_codes
+    
+    def get_cached_reference(self, voice_name: str, audio_path: str, ref_text: str = None):
+        """
+        Get or create cached reference codes.
+        
+        Args:
+            voice_name: Unique identifier for this voice
+            audio_path: Path to reference audio
+            ref_text: Optional reference text (stored with codes)
+            
+        Returns:
+            ref_codes: Encoded reference codes
+        """
+        cache_key = f"{voice_name}_{audio_path}"
+        
+        if cache_key not in self._ref_cache:
+            ref_codes = self.encode_reference(audio_path)
+            self._ref_cache[cache_key] = {
+                'codes': ref_codes,
+                'ref_text': ref_text
+            }
+        
+        return self._ref_cache[cache_key]['codes']
+    
+    def add_speaker(self, user_id: int, audio_file: str, ref_text: str):
+        """
+        Add a speaker to the stored dictionary for easy access.
+        
+        Args:
+            user_id: Unique user ID
+            audio_file: Reference audio file path
+            ref_text: Reference text
+            
+        Returns:
+            user_id: The user ID for use in streaming
+        """
+        codes = self.encode_reference(audio_file)
+        
+        if isinstance(codes, torch.Tensor):
+            codes = codes.cpu().numpy()
+        if isinstance(codes, np.ndarray):
+            codes = codes.flatten().tolist()
+        
+        self.stored_dict[f"{user_id}"]['codes'] = codes
+        self.stored_dict[f"{user_id}"]['ref_text'] = ref_text
+        
+        return user_id
+    
+    def _decode(self, codes: str):
+        """Decode speech tokens to audio waveform"""
+        speech_ids = [int(num) for num in re.findall(r"<\|speech_(\d+)\|>", codes)]
+        
+        if len(speech_ids) == 0:
+            raise ValueError("No valid speech tokens found in output")
+        
+        if self._is_onnx_codec:
+            codes = np.array(speech_ids, dtype=np.int32)[np.newaxis, np.newaxis, :]
+            recon = self.codec.decode_code(codes)
+        else:
+            with torch.no_grad():
+                codes = torch.tensor(speech_ids, dtype=torch.long)[None, None, :].to(
+                    self.codec.device
+                )
+                recon = self.codec.decode_code(codes).cpu().numpy()
+        
+        return recon[0, 0, :]
+    
+    def _decode_batch(self, codes_list: list[str], max_workers: int = None):
+        """
+        Decode multiple code strings in parallel.
+        
+        Args:
+            codes_list: List of code strings to decode
+            max_workers: Number of parallel workers (auto-tuned if None)
+            
+        Returns:
+            List of decoded audio arrays
+        """
+        # Auto-tune workers based on GPU memory and batch size
+        if max_workers is None:
+            if torch.cuda.is_available():
+                gpu_mem_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
+                # 1 worker per 4GB VRAM, max 4 workers
+                max_workers = min(max(1, int(gpu_mem_gb / 4)), 4)
+            else:
+                max_workers = 2
+        
+        # For small batches, use sequential to avoid overhead
+        if len(codes_list) <= 2:
+            return [self._decode(codes) for codes in codes_list]
+        
+        # Parallel decoding with controlled workers
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [executor.submit(self._decode, codes) for codes in codes_list]
+            results = [f.result() for f in futures]
+        return results
+    
+    def _format_prompt(self, ref_codes: list[int], ref_text: str, input_text: str) -> str:
+        """Format prompt for LMDeploy"""
+        ref_text_phones = phonemize_with_dict(ref_text)
+        input_text_phones = phonemize_with_dict(input_text)
+        
+        codes_str = "".join([f"<|speech_{idx}|>" for idx in ref_codes])
+        
+        prompt = (
+            f"user: Convert the text to speech:<|TEXT_PROMPT_START|>{ref_text_phones} {input_text_phones}"
+            f"<|TEXT_PROMPT_END|>\nassistant:<|SPEECH_GENERATION_START|>{codes_str}"
+        )
+        
+        return prompt
+    
+    def infer(self, text: str, ref_codes: np.ndarray | torch.Tensor, ref_text: str) -> np.ndarray:
+        """
+        Single inference.
+        
+        Args:
+            text: Input text to synthesize
+            ref_codes: Encoded reference audio codes
+            ref_text: Reference text for reference audio
+            
+        Returns:
+            Generated speech waveform as numpy array
+        """
+        if isinstance(ref_codes, torch.Tensor):
+            ref_codes = ref_codes.cpu().numpy()
+        if isinstance(ref_codes, np.ndarray):
+            ref_codes = ref_codes.flatten().tolist()
+        
+        prompt = self._format_prompt(ref_codes, ref_text, text)
+        
+        # Use LMDeploy pipeline for generation
+        responses = self.backbone([prompt], gen_config=self.gen_config, do_preprocess=False)
+        output_str = responses[0].text
+        
+        # Decode to audio
+        wav = self._decode(output_str)
+        
+        return wav
+    
+    def infer_batch(self, texts: list[str], ref_codes: np.ndarray | torch.Tensor, ref_text: str, max_batch_size: int = None) -> list[np.ndarray]:
+        """
+        Batch inference for multiple texts.
+        
+        Args:
+            texts: List of input texts to synthesize
+            ref_codes: Encoded reference audio codes
+            ref_text: Reference text for reference audio
+            max_batch_size: Maximum chunks to process at once (prevent GPU overload)
+            
+        Returns:
+            List of generated speech waveforms
+        """
+        if max_batch_size is None:
+            max_batch_size = self.max_batch_size
+            
+        if not isinstance(texts, list):
+            texts = [texts]
+        
+        if isinstance(ref_codes, torch.Tensor):
+            ref_codes = ref_codes.cpu().numpy()
+        if isinstance(ref_codes, np.ndarray):
+            ref_codes = ref_codes.flatten().tolist()
+        
+        all_wavs = []
+        
+        # Process in smaller batches to avoid GPU OOM
+        for i in range(0, len(texts), max_batch_size):
+            batch_texts = texts[i:i+max_batch_size]
+            
+            # Format prompts for this batch
+            prompts = [self._format_prompt(ref_codes, ref_text, text) for text in batch_texts]
+            
+            # Batch generation with LMDeploy
+            responses = self.backbone(prompts, gen_config=self.gen_config, do_preprocess=False)
+            
+            # Decode outputs (with smart parallelization)
+            batch_codes = [response.text for response in responses]
+            
+            # Auto-tune parallel workers based on batch size
+            if len(batch_codes) > 3:
+                batch_wavs = self._decode_batch(batch_codes)
+            else:
+                # Sequential for small batches (less overhead)
+                batch_wavs = [self._decode(codes) for codes in batch_codes]
+            
+            all_wavs.extend(batch_wavs)
+            
+            # Clean up memory between batches
+            if i + max_batch_size < len(texts):
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+        
+        return all_wavs
+    
+    def infer_stream(self, text: str, ref_codes: np.ndarray | torch.Tensor, ref_text: str) -> Generator[np.ndarray, None, None]:
+        """
+        Streaming inference with low latency.
+        
+        Args:
+            text: Input text to synthesize
+            ref_codes: Encoded reference audio codes
+            ref_text: Reference text for reference audio
+            
+        Yields:
+            Audio chunks as numpy arrays
+        """
+        if isinstance(ref_codes, torch.Tensor):
+            ref_codes = ref_codes.cpu().numpy()
+        if isinstance(ref_codes, np.ndarray):
+            ref_codes = ref_codes.flatten().tolist()
+        
+        prompt = self._format_prompt(ref_codes, ref_text, text)
+        
+        audio_cache = []
+        token_cache = [f"<|speech_{idx}|>" for idx in ref_codes]
+        n_decoded_samples = 0
+        n_decoded_tokens = len(ref_codes)
+        
+        for response in self.backbone.stream_infer([prompt], gen_config=self.gen_config, do_preprocess=False):
+            output_str = response.text
+            
+            # Extract new tokens
+            new_tokens = output_str[len("".join(token_cache[len(ref_codes):])):] if len(token_cache) > len(ref_codes) else output_str
+            
+            if new_tokens:
+                token_cache.append(new_tokens)
+            
+            # Check if we have enough tokens to decode a chunk
+            if len(token_cache[n_decoded_tokens:]) >= self.streaming_frames_per_chunk + self.streaming_lookforward:
+                
+                # Decode chunk with context
+                tokens_start = max(
+                    n_decoded_tokens - self.streaming_lookback - self.streaming_overlap_frames,
+                    0
+                )
+                tokens_end = (
+                    n_decoded_tokens
+                    + self.streaming_frames_per_chunk
+                    + self.streaming_lookforward
+                    + self.streaming_overlap_frames
+                )
+                sample_start = (n_decoded_tokens - tokens_start) * self.hop_length
+                sample_end = (
+                    sample_start
+                    + (self.streaming_frames_per_chunk + 2 * self.streaming_overlap_frames) * self.hop_length
+                )
+                
+                curr_codes = token_cache[tokens_start:tokens_end]
+                recon = self._decode("".join(curr_codes))
+                recon = recon[sample_start:sample_end]
+                audio_cache.append(recon)
+                
+                # Overlap-add processing
+                processed_recon = _linear_overlap_add(
+                    audio_cache, stride=self.streaming_stride_samples
+                )
+                new_samples_end = len(audio_cache) * self.streaming_stride_samples
+                processed_recon = processed_recon[n_decoded_samples:new_samples_end]
+                n_decoded_samples = new_samples_end
+                n_decoded_tokens += self.streaming_frames_per_chunk
+                
+                yield processed_recon
+        
+        # Final chunk
+        remaining_tokens = len(token_cache) - n_decoded_tokens
+        if remaining_tokens > 0:
+            tokens_start = max(
+                len(token_cache) - (self.streaming_lookback + self.streaming_overlap_frames + remaining_tokens),
+                0
+            )
+            sample_start = (
+                len(token_cache) - tokens_start - remaining_tokens - self.streaming_overlap_frames
+            ) * self.hop_length
+            
+            curr_codes = token_cache[tokens_start:]
+            recon = self._decode("".join(curr_codes))
+            recon = recon[sample_start:]
+            audio_cache.append(recon)
+            
+            processed_recon = _linear_overlap_add(audio_cache, stride=self.streaming_stride_samples)
+            processed_recon = processed_recon[n_decoded_samples:]
+            yield processed_recon
+    
+    def cleanup_memory(self):
+        """Clean up GPU memory"""
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        gc.collect()
+        print("🧹 Memory cleaned up")
+    
+    def get_optimization_stats(self) -> dict:
+        """
+        Get current optimization statistics.
+        
+        Returns:
+            Dictionary with optimization info
+        """
+        return {
+            'triton_enabled': self._triton_enabled,
+            'cached_references': len(self._ref_cache),
+            'active_sessions': len(self.stored_dict),
+            'kv_quant': self.gen_config.__dict__.get('quant_policy', 0),
+            'prefix_caching': True,  # Always enabled in our config
+        }