Upload 9 files

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 *.wav filter=lfs diff=lfs merge=lfs -text
+utils/phoneme_dict.json filter=lfs diff=lfs merge=lfs -text

utils/core_utils.py

@@ -1,12 +1,12 @@
 import re
+import os
 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())
+    sentences = re.split(r"(?<=[\.\!\?\…\n])\s+|(?<=\n)", text.strip())
     chunks: List[str] = []
     buffer = ""
 
@@ -45,3 +45,9 @@ def split_text_into_chunks(text: str, max_chars: int = 256) -> List[str]:
 
     flush_buffer()
     return [chunk for chunk in chunks if chunk]
+
+def env_bool(name: str, default: bool = False) -> bool:
+    v = os.getenv(name)
+    if v is None:
+        return default
+    return v.strip().lower() in ("1", "true", "yes", "y", "on")

utils/normalize_text.py

@@ -45,7 +45,18 @@ class VietnameseTTSNormalizer:
                       'năm', 'sáu', 'bảy', 'tám', 'chín']
     
     def normalize(self, text):
-        """Main normalization pipeline."""
+        """Main normalization pipeline with EN tag protection."""
+        # Step 1: Extract and protect EN tags
+        en_contents = []
+        placeholder_pattern = "___EN_PLACEHOLDER_{}___ "
+        
+        def extract_en(match):
+            en_contents.append(match.group(0))
+            return placeholder_pattern.format(len(en_contents) - 1)
+        
+        text = re.sub(r'<en>.*?</en>', extract_en, text, flags=re.IGNORECASE)
+        
+        # Step 2: Normal normalization pipeline
         text = text.lower()
         text = self._normalize_temperature(text)
         text = self._normalize_currency(text)
@@ -58,6 +69,14 @@ class VietnameseTTSNormalizer:
         text = self._number_to_words(text)
         text = self._normalize_special_chars(text)
         text = self._normalize_whitespace(text)
+        
+        # Step 3: Restore EN tags
+        for idx, en_content in enumerate(en_contents):
+            text = text.replace(placeholder_pattern.format(idx).lower(), en_content + ' ')
+        
+        # Final whitespace cleanup
+        text = self._normalize_whitespace(text)
+        
         return text
     
     def _normalize_temperature(self, text):
@@ -141,9 +160,8 @@ class VietnameseTTSNormalizer:
                 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
+                    return match.group(0)
                 if not (0 <= minute_int <= 59):
                     return match.group(0)
                 if not (0 <= second_int <= 59):
@@ -156,7 +174,6 @@ class VietnameseTTSNormalizer:
                 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):
@@ -174,7 +191,6 @@ class VietnameseTTSNormalizer:
                 
                 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)
@@ -189,7 +205,6 @@ class VietnameseTTSNormalizer:
             """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):
@@ -201,7 +216,7 @@ class VietnameseTTSNormalizer:
             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
+            return match.group(0)
         
         def date_iso_to_text(match):
             year, month, day = match.groups()
@@ -216,7 +231,6 @@ class VietnameseTTSNormalizer:
                 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', 
@@ -248,10 +262,8 @@ class VietnameseTTSNormalizer:
     
     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)
@@ -259,9 +271,7 @@ class VietnameseTTSNormalizer:
             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
@@ -335,7 +345,9 @@ class VietnameseTTSNormalizer:
             remainder = num % 1000
             result = f"{self._read_three_digits(thousand)} nghìn"
             if remainder > 0:
-                if remainder < 100:
+                if remainder < 10:
+                    result += f" không trăm lẻ {self.digits[remainder]}"
+                elif remainder < 100:
                     result += f" không trăm {self._read_two_digits(remainder)}"
                 else:
                     result += f" {self._read_three_digits(remainder)}"
@@ -363,7 +375,7 @@ class VietnameseTTSNormalizer:
         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)
+        text = re.sub(r'[^\w\sàáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ.,!?;:@%_]', ' ', text)
         return text
     
     def _normalize_whitespace(self, text):
@@ -377,32 +389,19 @@ 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",
+        "Chào mừng <en>hello world</en> đến với AI",
+        "Công nghệ <en>machine learning</en> và <en>deep learning</en>",
+        "Giá 2.500.000đ với <en>discount</en> 50%",
+        "Nhiệt độ 25°C, <en>temperature</en> cao",
+        "Hệ thống <en>text-to-speech</en> tiếng Việt",
     ]
     
     print("=" * 80)
-    print("VIETNAMESE TTS NORMALIZATION TEST")
+    print("VIETNAMESE TTS NORMALIZATION TEST (WITH EN TAG)")
     print("=" * 80)
     
     for text in test_texts:
         print(f"\n📝 Input: {text}")
         normalized = normalizer.normalize(text)
         print(f"🎵 Output: {normalized}")
-        print("-" * 80)
+        print("-" * 80)

utils/phonemize_text.py

@@ -2,6 +2,7 @@ import os
 import json
 import platform
 import glob
+import re
 from phonemizer import phonemize
 from phonemizer.backend.espeak.espeak import EspeakWrapper
 from utils.normalize_text import VietnameseTTSNormalizer
@@ -106,7 +107,10 @@ except Exception as e:
     raise
 
 def phonemize_text(text: str) -> str:
-    """Convert text to phonemes using phonemizer."""
+    """
+    Convert text to phonemes (simple version without dict, without EN tag).
+    Kept for backward compatibility.
+    """
     text = normalizer.normalize(text)
     return phonemize(
         text,
@@ -117,34 +121,226 @@ def phonemize_text(text: str) -> str:
         language_switch="remove-flags"
     )
 
+
 def phonemize_with_dict(text: str, phoneme_dict=phoneme_dict) -> str:
-    """Phonemize text with dictionary lookup."""
+    """
+    Phonemize single text with dictionary lookup and EN tag support.
+    """
     text = normalizer.normalize(text)
-    words = text.split()
-    result = []
     
-    for word in words:
-        if word in phoneme_dict:
-            phone_word = phoneme_dict[word]
+    # Split by EN tags
+    parts = re.split(r'(<en>.*?</en>)', text, flags=re.IGNORECASE)
+    
+    en_texts = []
+    en_indices = []
+    vi_texts = []
+    vi_indices = []
+    vi_word_maps = []
+    
+    processed_parts = []
+    
+    for part_idx, part in enumerate(parts):
+        if re.match(r'<en>.*</en>', part, re.IGNORECASE):
+            # English part
+            en_content = re.sub(r'</?en>', '', part, flags=re.IGNORECASE).strip()
+            en_texts.append(en_content)
+            en_indices.append(part_idx)
+            processed_parts.append(None)
         else:
-            try:
-                phone_word = phonemize(
-                    word,
-                    language='vi',
-                    backend='espeak',
-                    preserve_punctuation=True,
-                    with_stress=True,
-                    language_switch='remove-flags'
-                )
+            # Vietnamese part
+            words = part.split()
+            processed_words = []
+            
+            for word_idx, word in enumerate(words):
+                match = re.match(r'^(\W*)(.*?)(\W*)$', word)
+                pre, core, suf = match.groups() if match else ("", word, "")
+                
+                if not core:
+                    processed_words.append(word)
+                elif core in phoneme_dict:
+                    processed_words.append(f"{pre}{phoneme_dict[core]}{suf}")
+                else:
+                    vi_texts.append(word)
+                    vi_indices.append(part_idx)
+                    vi_word_maps.append((part_idx, len(processed_words)))
+                    processed_words.append(None)
+            
+            processed_parts.append(processed_words)
+    
+    if en_texts:
+        try:
+            en_phonemes = phonemize(
+                en_texts,
+                language='en-us',
+                backend='espeak',
+                preserve_punctuation=True,
+                with_stress=True,
+                language_switch="remove-flags"
+            )
+            
+            if isinstance(en_phonemes, str):
+                en_phonemes = [en_phonemes]
+            
+            for idx, (part_idx, phoneme) in enumerate(zip(en_indices, en_phonemes)):
+                processed_parts[part_idx] = phoneme.strip()
+        except Exception as e:
+            print(f"Warning: Could not phonemize EN texts: {e}")
+            for part_idx in en_indices:
+                processed_parts[part_idx] = en_texts[en_indices.index(part_idx)]
+    
+    if vi_texts:
+        try:
+            vi_phonemes = phonemize(
+                vi_texts,
+                language='vi',
+                backend='espeak',
+                preserve_punctuation=True,
+                with_stress=True,
+                language_switch='remove-flags'
+            )
+            
+            if isinstance(vi_phonemes, str):
+                vi_phonemes = [vi_phonemes]
+            
+            for idx, (part_idx, word_idx) in enumerate(vi_word_maps):
+                phoneme = vi_phonemes[idx].strip()
+                
+                original_word = vi_texts[idx]
+                if original_word.lower().startswith('r'):
+                    phoneme = 'ɹ' + phoneme[1:] if len(phoneme) > 0 else phoneme
                 
-                if word.lower().startswith('r'):
-                    phone_word = 'ɹ' + phone_word[1:]
+                phoneme_dict[original_word] = phoneme
                 
-                phoneme_dict[word] = phone_word
-            except Exception as e:
-                print(f"Warning: Could not phonemize '{word}': {e}")
-                phone_word = word
+                if processed_parts[part_idx] is not None:
+                    processed_parts[part_idx][word_idx] = phoneme
+        except Exception as e:
+            print(f"Warning: Could not phonemize VI texts: {e}")
+            for idx, (part_idx, word_idx) in enumerate(vi_word_maps):
+                if processed_parts[part_idx] is not None:
+                    processed_parts[part_idx][word_idx] = vi_texts[idx]
+    
+    final_parts = []
+    for part in processed_parts:
+        if isinstance(part, list):
+            final_parts.append(' '.join(str(w) for w in part if w is not None))
+        elif part is not None:
+            final_parts.append(part)
+    
+    result = ' '.join(final_parts)
+    
+    result = re.sub(r'\s+([.,!?;:])', r'\1', result)
+    
+    return result
+
+
+def phonemize_batch(texts: list, phoneme_dict=phoneme_dict) -> list:
+    """
+    Phonemize multiple texts with optimal batching.
+    
+    Args:
+        texts: List of text strings to phonemize
+        phoneme_dict: Phoneme dictionary for lookup
+    
+    Returns:
+        List of phonemized texts
+    """
+    normalized_texts = [normalizer.normalize(text) for text in texts]
+    
+    all_en_texts = []
+    all_en_maps = []
+    
+    all_vi_texts = []
+    all_vi_maps = []
+    
+    results = []
+    
+    for text_idx, text in enumerate(normalized_texts):
+        parts = re.split(r'(<en>.*?</en>)', text, flags=re.IGNORECASE)
+        processed_parts = []
+        
+        for part_idx, part in enumerate(parts):
+            if re.match(r'<en>.*</en>', part, re.IGNORECASE):
+                en_content = re.sub(r'</?en>', '', part, flags=re.IGNORECASE).strip()
+                all_en_texts.append(en_content)
+                all_en_maps.append((text_idx, part_idx))
+                processed_parts.append(None)
+            else:
+                words = part.split()
+                processed_words = []
+                
+                for word in words:
+                    match = re.match(r'^(\W*)(.*?)(\W*)$', word)
+                    pre, core, suf = match.groups() if match else ("", word, "")
+                    
+                    if not core:
+                        processed_words.append(word)
+                    elif core in phoneme_dict:
+                        processed_words.append(f"{pre}{phoneme_dict[core]}{suf}")
+                    else:
+                        all_vi_texts.append(word)
+                        all_vi_maps.append((text_idx, part_idx, len(processed_words)))
+                        processed_words.append(None)
+                
+                processed_parts.append(processed_words)
+        
+        results.append(processed_parts)
+    
+    if all_en_texts:
+        try:
+            en_phonemes = phonemize(
+                all_en_texts,
+                language='en-us',
+                backend='espeak',
+                preserve_punctuation=True,
+                with_stress=True,
+                language_switch="remove-flags"
+            )
+            
+            if isinstance(en_phonemes, str):
+                en_phonemes = [en_phonemes]
+            
+            for (text_idx, part_idx), phoneme in zip(all_en_maps, en_phonemes):
+                results[text_idx][part_idx] = phoneme.strip()
+        except Exception as e:
+            print(f"Warning: Batch EN phonemization failed: {e}")
+    
+    if all_vi_texts:
+        try:
+            vi_phonemes = phonemize(
+                all_vi_texts,
+                language='vi',
+                backend='espeak',
+                preserve_punctuation=True,
+                with_stress=True,
+                language_switch='remove-flags'
+            )
+            
+            if isinstance(vi_phonemes, str):
+                vi_phonemes = [vi_phonemes]
+            
+            for idx, (text_idx, part_idx, word_idx) in enumerate(all_vi_maps):
+                phoneme = vi_phonemes[idx].strip()
+                
+                original_word = all_vi_texts[idx]
+                if original_word.lower().startswith('r'):
+                    phoneme = 'ɹ' + phoneme[1:] if len(phoneme) > 0 else phoneme
+                
+                phoneme_dict[original_word] = phoneme
+                results[text_idx][part_idx][word_idx] = phoneme
+        except Exception as e:
+            print(f"Warning: Batch VI phonemization failed: {e}")
+    
+    final_results = []
+    for processed_parts in results:
+        final_parts = []
+        for part in processed_parts:
+            if isinstance(part, list):
+                final_parts.append(' '.join(str(w) for w in part if w is not None))
+            elif part is not None:
+                final_parts.append(part)
         
-        result.append(phone_word)
+        result = ' '.join(final_parts)
+        result = re.sub(r'\s+([.,!?;:])', r'\1', result)
+        final_results.append(result)
     
-    return ' '.join(result)
+    return final_results