diff --git a/.gitignore b/.gitignore index 802312cb3128658c9a65ee6c1b60219c98a0a33f..3d3fa81d0f78820c33021a90f7621903a9044c27 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,5 @@ downloaded_audio/ figures/ audio_cut/ -audio_cut.zip \ No newline at end of file +audio_cut.zip +dataset/ \ No newline at end of file diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..1c2fda565b94d0f2b94cb65ba7cca866e7a25478 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/Generate Audio Data.iml b/.idea/Generate Audio Data.iml new file mode 100644 index 0000000000000000000000000000000000000000..c5493fcdb85934f9e061d6c22b99d133592480ae --- /dev/null +++ b/.idea/Generate Audio Data.iml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000000000000000000000000000000000000..ac851fd3d24f3fb61997deb12f17fa15404f5743 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,40 @@ + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000000000000000000000000000000000000..105ce2da2d6447d11dfe32bfb846c3d5b199fc99 --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000000000000000000000000000000000000..77746b3ca07240047c0516942c67b080e4b61cf9 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000000000000000000000000000000000000..5869b6476ba97fc3f248e52d69eb35d51b878855 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000000000000000000000000000000000000..9661ac713428efbad557d3ba3a62216b5bb7d226 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml new file mode 100644 index 0000000000000000000000000000000000000000..136c8f9378616d86b963491d1e13fb7d837d8547 --- /dev/null +++ b/.idea/workspace.xml @@ -0,0 +1,98 @@ + + + + + + + + + + + + + { + "associatedIndex": 6 +} + + + + + + + + + + + + + + + + + + + + + 1727278271929 + + + + + + + + + + + + + + \ No newline at end of file diff --git a/__pycache__/gemini_normalize.cpython-310.pyc b/__pycache__/gemini_normalize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..30f0b0a9d2769b8f0c8f3dccb6cd03c3524750e9 Binary files /dev/null and b/__pycache__/gemini_normalize.cpython-310.pyc differ diff --git a/__pycache__/text_nomalize.cpython-310.pyc b/__pycache__/text_nomalize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25f5f2feed6ddb7238d5e14d2905cd60a61b4e82 Binary files /dev/null and b/__pycache__/text_nomalize.cpython-310.pyc differ diff --git a/converters/Cardinal.py b/converters/Cardinal.py new file mode 100644 index 0000000000000000000000000000000000000000..0f5e8dadbea5d6e1cc1ccb89a780370fbf84da37 --- /dev/null +++ b/converters/Cardinal.py @@ -0,0 +1,189 @@ +from typing import List + +from singleton_decorator import singleton +import re +from .Roman import RomanVietnamese + + +@singleton +class CardinalVietnamese: + """ + Các bước: + - 1 Loại bỏ dấu chấm + - 2 Kiểm tra xem có phải là số La Mã không + - 3 Nếu đúng, chuyển đổi số La Mã lớn nhất tìm thấy thành số nguyên, sau đó thành chuỗi đại diện cho số nguyên đó + - 4 Nếu đúng, kiểm tra xem có nên thêm hậu tố "'s" không (xem trường hợp đặc biệt) + - 5 Lọc bỏ các ký tự không phải số, trừ "-" + - 6 Kiểm tra xem có nên sử dụng tiền tố "âm" không + - 7 Loại bỏ tất cả các ký tự "-" còn lại + - 8 Nếu là "0", thêm "không" vào danh sách đầu ra + - 9 Nếu không phải "0", chia chuỗi thành các phần tối đa 3 chữ số, sao cho phần nhỏ nhất bao gồm các ký tự ngoài cùng bên trái + - 10 Chia mỗi phần thành `trăm` và `phần còn lại` + - 11 Thêm "x trăm" nếu `trăm` > 0 + - 12 Thêm giá trị văn bản đại diện cho `phần còn lại` + - 13 Thêm hậu tố cho phần, ví dụ: triệu, tỷ, v.v. + - 14 Thêm đầu ra cho phần vào tổng đầu ra + - 15 Kết hợp danh sách đầu ra tổng thành một chuỗi + - 16 Thêm tiền tố và/hoặc hậu tố + + Trường hợp đặc biệt: + II -> hai + -2 -> âm hai + I. -> một + IV's -> bốn's + + Ghi chú: + - Không có "và" hoặc dấu gạch ngang trong kết quả, ví dụ: không có "hai mươi mốt" hoặc "một trăm lẻ một" + """ + + def __init__(self): + super().__init__() + self.filter_regex = re.compile("[^0-9\-]") + self.filter_strict_regex = re.compile("[^0-9]") + self.dot_filter_regex = re.compile("[.]") + + self.scale_suffixes = [ + "nghìn", + "triệu", + "tỷ", + "nghìn tỷ", + "triệu tỷ", + "tỷ tỷ" + ] + + self.small_trans_dict = { + "1": "một", + "2": "hai", + "3": "ba", + "4": "bốn", + "5": "năm", + "6": "sáu", + "7": "bảy", + "8": "tám", + "9": "chín", + } + + self.tens_trans_dict = { + "1": "mười", + "2": "hai mươi", + "3": "ba mươi", + "4": "bốn mươi", + "5": "năm mươi", + "6": "sáu mươi", + "7": "bảy mươi", + "8": "tám mươi", + "9": "chín mươi", + } + + self.special_trans_dict = { + 11: "mười một", + 12: "mười hai", + 13: "mười ba", + 14: "mười bốn", + 15: "mười lăm", + 16: "mười sáu", + 17: "mười bảy", + 18: "mười tám", + 19: "mười chín" + } + + self.roman = RomanVietnamese() + + def _give_chunk(self, num_str: str, size: int = 3) -> str: + while num_str: + yield num_str[-size:] + num_str = num_str[:-size] + + def convert(self, token: str) -> str: + token = self.dot_filter_regex.sub("", token) + + suffix = "" + if self.roman.check_if_roman(token): + token, suffix = self.roman.convert(token) + + token = self.filter_regex.sub("", token) + + prefix = "" + while len(token) > 0 and token[0] == "-": + token = token[1:] + prefix = "âm" if prefix == "" else "" + + token = self.filter_strict_regex.sub("", token) + + if token == len(token) * "0": + return "không" + + chunks = list(self._give_chunk(token)) + text_list = [] + + for depth, chunk in enumerate(chunks): + chunk_text = self._convert_chunk(chunk, depth == len(chunks) - 1) + if chunk_text: + if depth > 0: + chunk_text.append(self.scale_suffixes[depth - 1]) + text_list = chunk_text + text_list + + result = " ".join(text_list) + + if prefix: + result = f"{prefix} {result}" + if suffix: + result = f"{result}{suffix}" + + return result + + def _convert_chunk(self, chunk: str, is_last_chunk: bool) -> List[str]: + chunk_text = [] + length = len(chunk) + + # Xử lý hàng trăm + if length == 3: + if chunk[0] != '0': + chunk_text.append(self.small_trans_dict[chunk[0]]) + chunk_text.append("trăm") + elif not is_last_chunk and (chunk[1] != '0' or chunk[2] != '0'): + chunk_text.append("không trăm") + + # Xử lý hàng chục và đơn vị + if length >= 2: + if chunk[-2:] in self.special_trans_dict: + chunk_text.append(self.special_trans_dict[chunk[-2:]]) + else: + if chunk[-2] != '0': + chunk_text.append(self.tens_trans_dict[chunk[-2]]) + if chunk[-1] != '0': + if chunk[-1] == '1' and chunk[-2] != '1': + chunk_text.append("mốt") + else: + chunk_text.append(self.small_trans_dict[chunk[-1]]) + elif chunk[-1] != '0': + if len(chunk_text) > 0 or not is_last_chunk: + chunk_text.append("lẻ") + chunk_text.append(self.small_trans_dict[chunk[-1]]) + elif length == 1 and chunk != '0': + chunk_text.append(self.small_trans_dict[chunk]) + + return chunk_text + +if __name__ == "__main__": + cardinal_converter = CardinalVietnamese() + + # Ví dụ 1 + example1 = "20211231" + result1 = cardinal_converter.convert(example1) + print(f"Số: {example1}") + print(f"Chuyển đổi: {result1}") + print() + + # Ví dụ 2 + example2 = "-5678213" + result2 = cardinal_converter.convert(example2) + print(f"Số: {example2}") + print(f"Chuyển đổi: {result2}") + print() + + # Ví dụ 3 + example3 = "1000000" + result3 = cardinal_converter.convert(example3) + print(f"Số: {example3}") + print(f"Chuyển đổi: {result3}") \ No newline at end of file diff --git a/converters/Date.py b/converters/Date.py new file mode 100644 index 0000000000000000000000000000000000000000..eaa99428d85201aa8c96d475cd736c0939e0049d --- /dev/null +++ b/converters/Date.py @@ -0,0 +1,107 @@ +import re +from singleton_decorator import singleton +import re +from .Cardinal import CardinalVietnamese +import re + +@singleton +class DateVietnamese: + """ + Chuyển đổi ngày tháng từ dạng số sang dạng chữ tiếng Việt. + Hỗ trợ các định dạng: "DD/MM/YYYY", "DD-MM-YYYY", "DD.MM.YYYY". + Ví dụ: "25/12/2023", "01-01-2024", "10.05.2023" + """ + + def __init__(self): + self.day_trans_dict = { + "1": "một", + "2": "hai", + "3": "ba", + "4": "bốn", + "5": "năm", + "6": "sáu", + "7": "bảy", + "8": "tám", + "9": "chín", + "10": "mười", + "11": "mười một", + "12": "mười hai", + "13": "mười ba", + "14": "mười bốn", + "15": "mười lăm", + "16": "mười sáu", + "17": "mười bảy", + "18": "mười tám", + "19": "mười chín", + "20": "hai mươi", + "21": "hai mươi mốt", + "22": "hai mươi hai", + "23": "hai mươi ba", + "24": "hai mươi bốn", + "25": "hai mươi lăm", + "26": "hai mươi sáu", + "27": "hai mươi bảy", + "28": "hai mươi tám", + "29": "hai mươi chín", + "30": "ba mươi", + "31": "ba mươi mốt" + } + + self.month_trans_dict = { + "1": "một", + "2": "hai", + "3": "ba", + "4": "tư", + "5": "năm", + "6": "sáu", + "7": "bảy", + "8": "tám", + "9": "chín", + "10": "mười", + "11": "mười một", + "12": "mười hai" + } + + def convert_year(self, year: str) -> str: + cardinal_converter = CardinalVietnamese() + return cardinal_converter.convert(year) + + def convert_date(self, date: str) -> str: + # Tìm và tách ngày, tháng, năm dựa trên dấu phân cách + date_parts = re.split(r"[\/\-\.\s]", date) + if len(date_parts) ==3 : + day, month, year = date_parts[0], date_parts[1], date_parts[2] + + day_text = f"ngày {self.day_trans_dict[day.lstrip('0')]}" + month_text = f"tháng {self.month_trans_dict[month.lstrip('0')]}" + year_text = f"năm {self.convert_year(year)}" + + return f"{day_text} {month_text} {year_text}" + else: + month, year = date_parts[0], date_parts[1], + month_text = f"tháng {self.month_trans_dict[month.lstrip('0')]}" + year_text = f"năm {self.convert_year(year)}" + return f"{month_text} {year_text}" +if __name__ == "__main__": + date_converter = DateVietnamese() + + # Ví dụ 1 + example1 = "25/12/1990" + result1 = date_converter.convert_date(example1) + print(f"Ngày tháng: {example1}") + print(f"Chuyển đổi: {result1}") + print() + + # Ví dụ 2 + example2 = "01-01-1991" + result2 = date_converter.convert_date(example2) + print(f"Ngày tháng: {example2}") + print(f"Chuyển đổi: {result2}") + print() + + # Ví dụ 3 + example3 = "10.05.2023" + result3 = date_converter.convert_date(example3) + print(f"Ngày tháng: {example3}") + print(f"Chuyển đổi: {result3}") + diff --git a/converters/Decimal.py b/converters/Decimal.py new file mode 100644 index 0000000000000000000000000000000000000000..bcd2f618b29e4bffd80b1243aec641ecdf6ae941 --- /dev/null +++ b/converters/Decimal.py @@ -0,0 +1,86 @@ +from .Digit import DigitVietnamese +from .Cardinal import CardinalVietnamese +import re +from singleton_decorator import singleton +@singleton +class Decimal: + def __init__(self): + super().__init__() + self.decimal_regex = re.compile(r"(-?\d*)\.(\d+)(.*)") + self.number_regex = re.compile(r"(-?\d+)(.*)") + self.filter_regex = re.compile(r"[,]") + self.cardinal = CardinalVietnamese() + self.digit = DigitVietnamese() + self.suffixes = [ + "nghìn", + "triệu", + "tỷ", + "nghìn tỷ", + "triệu tỷ", + "tỷ tỷ" + ] + self.suffix_regex = re.compile(f" *({'|'.join(self.suffixes)})") + self.e_suffix_regex = re.compile(r" *E(-?\d+)") + + def convert(self, token: str) -> str: + token = self.filter_regex.sub("", token) + + number = "" + decimal = "" + + match = self.decimal_regex.match(token) + if match: + number = match.group(1) + decimal = match.group(2) + token = match.group(3) + else: + match = self.number_regex.match(token) + if match: + number = match.group(1) + token = match.group(2) + + match = self.suffix_regex.match(token) + suffix = "" + if match: + suffix = match.group(1) + else: + match = self.e_suffix_regex.match(token) + if match: + suffix = f"nhân mười mũ {self.cardinal.convert(match.group(1))}" + + result_list = [] + if len(decimal) > 0: + result_list.append("phẩy") + result_list.append(self.digit.convert(decimal)) + + if number: + result_list.insert(0, self.cardinal.convert(number)) + + if suffix: + result_list.append(suffix) + + result = " ".join(result_list) + + return result + +if __name__ == "__main__": + decimal = Decimal() + + test_cases = [ + "123,456.789", + "0.5", + "1000000", + "3.14", + "2.718E3", + "1.23E-5", + "9.99999", + "1234.5678 tỷ", + "0.000001", + "1000000.000001", + ] + + for case in test_cases: + result = decimal.convert(case) + print(f"Số: {case}") + print(f"Chuyển đổi: {result}") + print() \ No newline at end of file diff --git a/converters/Digit.py b/converters/Digit.py new file mode 100644 index 0000000000000000000000000000000000000000..d9dd2426fda6e5787dfe2036fddb9929a756a91b --- /dev/null +++ b/converters/Digit.py @@ -0,0 +1,62 @@ +from singleton_decorator import singleton +import re + +@singleton +class DigitVietnamese: + """ + Các bước: + - 1 Lọc bỏ tất cả các ký tự không phải số + - 2 Kiểm tra trường hợp đặc biệt + - 3 Chuyển đổi mỗi chữ số thành văn bản tiếng Việt + - 4 Thêm khoảng trắng giữa các từ + Trường hợp đặc biệt: + 007 -> không không bảy + trong khi 003 -> không không ba + """ + def __init__(self): + super().__init__() + # Regex để lọc bỏ các ký tự không phải số + self.filter_regex = re.compile("[^0-9]") + # Từ điển chuyển đổi chữ số sang chữ tiếng Việt + self.trans_dict = { + "0": "không", + "1": "một", + "2": "hai", + "3": "ba", + "4": "bốn", + "5": "năm", + "6": "sáu", + "7": "bảy", + "8": "tám", + "9": "chín" + } + + def convert(self, token: str) -> str: + # 1 Lọc bỏ tất cả các ký tự không phải số + token = self.filter_regex.sub("", token) + # 2 Kiểm tra trường hợp đặc biệt + if token == "007": + return "không không bảy" + # 3 & 4 Chuyển đổi mỗi chữ số thành văn bản và thêm khoảng trắng + token = " ".join([self.trans_dict[c] for c in token]) + return token +if __name__ == "__main__": + # Tạo một thể hiện của lớp DigitVietnamese + digit_converter = DigitVietnamese() + + # Ví dụ 1: Số điện thoại + phone_number = "0912345678" + print(f"Số điện thoại: {phone_number}") + print(f"Chuyển đổi: {digit_converter.convert(phone_number)}") + print() + + # Ví dụ 2: Mã số sinh viên + student_id = "SV20210001" + print(f"Mã số sinh viên: {student_id}") + print(f"Chuyển đổi: {digit_converter.convert(student_id)}") + print() + + # Ví dụ 3: Trường hợp đặc biệt + special_case = "007" + print(f"Số đặc biệt: {special_case}") + print(f"Chuyển đổi: {digit_converter.convert(special_case)}") diff --git a/converters/Fraction.py b/converters/Fraction.py new file mode 100644 index 0000000000000000000000000000000000000000..23b3712867801b82a7d28013574a0a650e7b52a1 --- /dev/null +++ b/converters/Fraction.py @@ -0,0 +1,110 @@ +from .Cardinal import CardinalVietnamese +import re +from singleton_decorator import singleton + +@singleton +class Fraction: + def __init__(self): + super().__init__() + self.filter_regex = re.compile(",") + self.space_filter_regex = re.compile(" ") + self.trans_dict = { + "½": {"prepended": "một", "single": "một", "text": "phần hai"}, + "⅓": {"prepended": "một", "single": "một", "text": "phần ba"}, + "⅔": {"prepended": "hai", "single": "hai", "text": "phần ba"}, + "¼": {"prepended": "một", "single": "một", "text": "phần tư"}, + "¾": {"prepended": "ba", "single": "ba", "text": "phần tư"}, + "⅕": {"prepended": "một", "single": "một", "text": "phần năm"}, + "⅖": {"prepended": "hai", "single": "hai", "text": "phần năm"}, + "⅗": {"prepended": "ba", "single": "ba", "text": "phần năm"}, + "⅘": {"prepended": "bốn", "single": "bốn", "text": "phần năm"}, + "⅙": {"prepended": "một", "single": "một", "text": "phần sáu"}, + "⅚": {"prepended": "năm", "single": "năm", "text": "phần sáu"}, + "⅐": {"prepended": "một", "single": "một", "text": "phần bảy"}, + "⅛": {"prepended": "một", "single": "một", "text": "phần tám"}, + "⅜": {"prepended": "ba", "single": "ba", "text": "phần tám"}, + "⅝": {"prepended": "năm", "single": "năm", "text": "phần tám"}, + "⅞": {"prepended": "bảy", "single": "bảy", "text": "phần tám"}, + "⅑": {"prepended": "một", "single": "một", "text": "phần chín"}, + "⅒": {"prepended": "một", "single": "một", "text": "phần mười"} + } + self.special_regex = re.compile(f"({'|'.join(self.trans_dict.keys())})") + self.cardinal = CardinalVietnamese() + self.slash_regex = re.compile(r"(-?\d{1,3}( \d{3})+|-?\d+) *\/ *(-?\d{1,3}( \d{3})+|-?\d+)") + + # Không cần chuyển đổi từ Cardinal sang Ordinal trong tiếng Việt + self.trans_denominator = {} + + self.edge_dict = { + "1": {"singular": "trên một", "plural": "trên một"}, + "2": {"singular": "phần hai", "plural": "phần hai"}, + "4": {"singular": "phần tư", "plural": "phần tư"} + } + + def convert(self, token: str) -> str: + token = self.filter_regex.sub("", token) + match = self.special_regex.search(token) + if match: + frac = match.group(1) + frac_dict = self.trans_dict[frac] + + remainder = self.special_regex.sub("", token) + if remainder: + prefix = self.cardinal.convert(remainder) + result = f"{prefix} và {frac_dict['prepended']} {frac_dict['text']}" + else: + result = f"{frac_dict['single']} {frac_dict['text']}" + + else: + match = self.slash_regex.search(token) + if match: + numerator = match.group(1) + denominator = match.group(3) + + numerator = self.space_filter_regex.sub("", numerator) + denominator = self.space_filter_regex.sub("", denominator) + + numerator_text = self.cardinal.convert(numerator) + + if denominator in self.edge_dict: + result = f"{numerator_text} {self.edge_dict[denominator]['singular']}" + + else: + denominator_text = self.cardinal.convert(denominator) + result = f"{numerator_text} phần {denominator_text}" + + remainder = self.slash_regex.sub("", token) + if remainder: + remainder_text = self.cardinal.convert(remainder) + result = f"{remainder_text} và {result}" + + else: + result = token + + return result + +if __name__ == "__main__": + fraction = Fraction() + + test_cases = [ + "½", + "1½", + "2¼", + "3⅔", + "1/4", + "3/4", + "5/8", + "10/3", + "100/25", + "1000/999", + "2 1/2", + "3 3/4", + "5 2/3", + "100 1/100", + ] + + for case in test_cases: + result = fraction.convert(case) + print(f"Phân số: {case}") + print(f"Chuyển đổi: {result}") + print() \ No newline at end of file diff --git a/converters/Meansure.py b/converters/Meansure.py new file mode 100644 index 0000000000000000000000000000000000000000..1c260c2656ba869cdb93d8473a613b8bfb75aef1 --- /dev/null +++ b/converters/Meansure.py @@ -0,0 +1,473 @@ +from singleton_decorator import singleton + +import re + +from .Decimal import Decimal +from .Fraction import Fraction + + +@singleton +class Measure: + def __init__(self): + super().__init__() + # Regex để phát hiện phân số + self.fraction_regex = re.compile( + r"(((?:-?\d* )?-?\d+ *\/ *-? *\d+)|(-?\d* *(?:½|⅓|⅔|¼|¾|⅕|⅖|⅗|⅘|⅙|⅚|⅐|⅛|⅜|⅝|⅞|⅑|⅒)))") + # Regex để phát hiện xem có nên sử dụng "của một" hay không + self.of_a_regex = re.compile(r"(-?\d+ -?\d+ *\/ *-? *\d+)|(-?\d+ *(?:½|⅓|⅔|¼|¾|⅕|⅖|⅗|⅘|⅙|⅚|⅐|⅛|⅜|⅝|⅞|⅑|⅒))") + # Regex để phát hiện đầu vào để chuyển đổi số, bao gồm cả hậu tố triệu/tỷ tiềm năng + self.value_regex = re.compile(r"(-?(?: |\d)*\.?\d+ *(?:nghìn|triệu|tỷ|nghìn tỷ|triệu tỷ|tỷ tỷ)?)") + # Regex để lọc bỏ dấu phẩy + self.filter_regex = re.compile(r"[,]") + # Regex để lọc bỏ khoảng trắng + self.filter_space_regex = re.compile(r"[ ]") + # Regex để lọc bỏ chữ cái + self.letter_filter_regex = re.compile(r"[^0-9\-\.]") + + # Từ điển tiền tố cho 10^i với i > 0 + self.prefix_dict = { + "Y": "yotta", + "Z": "zetta", + "E": "exa", + "P": "peta", + "T": "tera", + "G": "giga", + "M": "mega", + "k": "kilo", + "h": "hecto", + "da": "deca", + "d": "deci", + "c": "centi", + "m": "milli", + "μ": "micro", + "µ": "micro", + "n": "nano", + "p": "pico", + "f": "femto", + "a": "atto", + "z": "zepto", + "y": "yocto" + } + + # Từ điển dịch cho các loại đơn vị có thể thêm tiền tố + self.prefixable_trans_dict = { + "m": { + "singular": "mét", + "plural": "mét" + }, + "b": { + "singular": "bit", + "plural": "bit" + }, + "B": { + "singular": "byte", + "plural": "byte" + }, + "bps": { + "singular": "bit trên giây", + "plural": "bit trên giây" + }, + "Bps": { + "singular": "byte trên giây", + "plural": "byte trên giây" + }, + "g": { + "singular": "gram", + "plural": "gram" + }, + "gf": { + "singular": "gram lực", + "plural": "gram lực" + }, + "W": { + "singular": "oát", + "plural": "oát" + }, + "Wh": { + "singular": "oát giờ", + "plural": "oát giờ" + }, + "Hz": { + "singular": "héc", + "plural": "héc" + }, + "J": { + "singular": "jun", + "plural": "jun" + }, + "L": { + "singular": "lít", + "plural": "lít" + }, + "V": { + "singular": "vôn", + "plural": "vôn" + }, + "f": { + "singular": "fara", + "plural": "fara" + }, + "s": { + "singular": "giây", + "plural": "giây" + }, + "A": { + "singular": "ampe", + "plural": "ampe" + }, + "Ah": { + "singular": "ampe giờ", + "plural": "ampe giờ" + }, + "Pa": { + "singular": "pascal", + "plural": "pascal" + }, + "C": { + "singular": "culông", + "plural": "culông" + }, + "Bq": { + "singular": "becquerel", + "plural": "becquerel" + }, + "N": { + "singular": "niutơn", + "plural": "niutơn" + }, + "bar": { + "singular": "bar", + "plural": "bar" + }, + "lm": { + "singular": "lumen", + "plural": "lumen" + }, + "cal": { + "singular": "calo", + "plural": "calo" + }, + } + + # Từ điển đã được biến đổi sử dụng self.prefixable_trans_dict và từ điển tiền tố + self.prefixed_dict = { + prefix + prefixed: {"singular": self.prefix_dict[prefix] + self.prefixable_trans_dict[prefixed]["singular"], + "plural": self.prefix_dict[prefix] + self.prefixable_trans_dict[prefixed]["plural"]} for + prefixed in self.prefixable_trans_dict for prefix in self.prefix_dict} + self.prefixed_dict = {**self.prefixed_dict, **self.prefixable_trans_dict} + + # Từ điển dịch cho các loại đơn vị không có tiền tố + self.custom_dict = { + "%": { + "singular": "phần trăm", + "plural": "phần trăm" + }, + "pc": { + "singular": "phần trăm", + "plural": "phần trăm" + }, + "ft": { + "singular": "foot", + "plural": "foot" + }, + "mi": { + "singular": "dặm", + "plural": "dặm" + }, + "mb": { + "singular": "megabyte", + "plural": "megabyte" + }, + "ha": { + "singular": "hecta", + "plural": "hecta" + }, + "\"": { + "singular": "inch", + "plural": "inch" + }, + "in": { + "singular": "inch", + "plural": "inch" + }, + "\'": { + "singular": "foot", + "plural": "foot" + }, + "rpm": { + "singular": "vòng trên phút", + "plural": "vòng trên phút" + }, + "hp": { + "singular": "mã lực", + "plural": "mã lực" + }, + "cc": { + "singular": "xăng-ti-mét khối", + "plural": "xăng-ti-mét khối" + }, + "oz": { + "singular": "aoxơ", + "plural": "aoxơ", + }, + "mph": { + "singular": "dặm trên giờ", + "plural": "dặm trên giờ" + }, + "lb": { + "singular": "pao", + "plural": "pao" + }, + "lbs": { + "singular": "pao", + "plural": "pao" + }, + "kt": { + "singular": "nút", + "plural": "nút" + }, + "dB": { + "singular": "đề-xi-ben", + "plural": "đề-xi-ben" + }, + "AU": { + "singular": "đơn vị thiên văn", + "plural": "đơn vị thiên văn" + }, + "st": { + "singular": "stone", + "plural": "stone" + }, + "yd": { + "singular": "yard", + "plural": "yard" + }, + "yr": { + "singular": "năm", + "plural": "năm" + }, + "yrs": { + "singular": "năm", + "plural": "năm" + }, + "eV": { + "singular": "electron vôn", + "plural": "electron vôn" + }, + "/": { + "singular": "trên", + "plural": "trên" + }, + "sq": { + "singular": "vuông", + "plural": "vuông" + }, + "2": { + "singular": "vuông", + "plural": "vuông" + }, + "²": { + "singular": "vuông", + "plural": "vuông" + }, + "3": { + "singular": "khối", + "plural": "khối" + }, + "³": { + "singular": "khối", + "plural": "khối" + }, + "h": { + "singular": "giờ", + "plural": "giờ" + }, + "hr": { + "singular": "giờ", + "plural": "giờ" + }, + "hrs": { + "singular": "giờ", + "plural": "giờ" + }, + "ch": { + "singular": "chain", + "plural": "chain" + }, + "KiB": { + "singular": "kibibyte", + "plural": "kibibyte" + }, + "MiB": { + "singular": "mebibyte", + "plural": "mebibyte" + }, + "GiB": { + "singular": "gibibyte", + "plural": "gibibyte" + }, + "pH": { + "singular": "pH", + "plural": "pH" + }, + "kph": { + "singular": "kilômét trên giờ", + "plural": "kilômét trên giờ" + }, + "Da": { + "singular": "đalton", + "plural": "đalton" + }, + "cwt": { + "singular": "hundredweight", + "plural": "hundredweight" + }, + "Sv": { + "singular": "sievert", + "plural": "sievert", + }, + "C": { + "singular": "độ xen-xi-út", + "plural": "độ xen-xi-út" + }, + "degrees": { + "singular": "độ", + "plural": "độ" + }, + "degree": { + "singular": "độ", + "plural": "độ" + }, + "atm": { + "singular": "át-mốt-phê", + "plural": "át-mốt-phê" + }, + "min": { + "singular": "phút", + "plural": "phút" + }, + "cd": { + "singular": "can-đê-la", + "plural": "can-đê-la" + }, + "ly": { + "singular": "năm ánh sáng", + "plural": "năm ánh sáng" + }, + "kts": { + "singular": "nút", + "plural": "nút" + }, + "mol": { + "singular": "mol", + "plural": "mol" + }, + "Nm": { + "singular": "niutơn mét", + "plural": "niutơn mét" + }, + "Ω": { + "singular": "ôm", + "plural": "ôm" + }, + "bbl": { + "singular": "thùng", + "plural": "thùng" + }, + "gal": { + "singular": "gallon", + "plural": "gallon" + }, + "cal": { + "singular": "cỡ nòng", + "plural": "cỡ nòng" + } + } + + # Ghi đè và thêm giá trị từ custom_dict vào prefixed_dict + self.prefixed_dict = {**self.prefixed_dict, **self.custom_dict} + + # Phiên bản viết thường của self.prefixed_dict + self.lower_prefixed_dict = {key.lower(): self.prefixed_dict[key] for key in self.prefixed_dict} + + # Hậu tố đặc biệt mà tổng hậu tố nên được tách ra + self.special_suffixes = re.compile(r"(\/|trên(?!trăm)|vuông|2|²|3|³)") + + # Chuyển đổi Decimal và Fraction + self.decimal = Decimal() + self.fraction = Fraction() + + + def convert(self, token: str) -> str: + # 1 Lọc bỏ dấu phẩy + token = self.filter_regex.sub("", token) + + result_list = [] + + # Số nhiều mặc định là false, vì "/s" nên là "trên giây" + plural = False + + # 2 Thử khớp với một phân số + match = self.fraction_regex.match(token) + if match: + # 2.1 Nếu tồn tại, chuyển đổi thành văn bản sử dụng bộ chuyển đổi Fraction + result_list.append(self.fraction.convert(match.group(0))) + # Chuyển token thành phần còn lại. Vì sử dụng match thay vì search, + # phần đầu của dòng tiếp theo có thể không cần thiết + token = token[:match.span()[0]] + token[match.span()[1]:] + + # Lọc bỏ khoảng trắng + token = self.filter_space_regex.sub("", token) + + # Nếu có một số trước phân số, ví dụ "8 1/2" hoặc "8 ½", thì chúng ta thêm "của một", và giữ nguyên số ít + # Ngược lại, chúng ta chuyển sang số nhiều + if self.of_a_regex.match(match.group(0)): + plural = True + else: + result_list.append("của một") + + else: + # 3 Thử khớp với "x,y" hoặc "x" + match = self.value_regex.match(token) + if match: + # 3.1 Chuyển không có khoảng trắng cho bộ chuyển đổi decimal + result_list.append(self.decimal.convert(self.filter_space_regex.sub("", match.group(1)))) + token = token[:match.span()[0]] + token[match.span()[1]:] + # Số nhiều là False khi giá trị tuyệt đối của số thập phân là 1, và giá trị thập phân không có dạng "1,x" + # Ngược lại là True + if abs(float(self.letter_filter_regex.sub("", match.group(1)))) != 1 or "," in match.group(1): + plural = True + + # Biến chỉ ra liệu từ "trên" vừa được sử dụng + # Điều này được sử dụng để phát hiện số nhiều + per = False + # 4 Lặp qua phần còn lại của token + for split_token in token.split(" "): + for i, token in enumerate(self.split_token(split_token)): + # Thêm tên thích hợp của hậu tố nếu tồn tại + # Thử không phân biệt chữ hoa chữ thường nếu lần trước thất bại + if token in self.prefixed_dict: + result_list.append(self.prefixed_dict[token]["plural" if plural and not per else "singular"]) + elif token.lower() in self.lower_prefixed_dict: + result_list.append( + self.lower_prefixed_dict[token.lower()]["plural" if plural and not per else "singular"]) + else: + result_list.append(token) + + # Nếu kết quả trước đó là "trên", đặt per thành True để sử dụng "singular" cho từ tiếp theo. + # Nhưng chỉ khi "trên" không phải là hậu tố đầu tiên. Ví dụ: "5/km2" là "năm trên kilômét vuông" + if result_list[-1] == "trên" and i != 0: + per = True + + # Nếu từ cuối cùng không phải là "trên", và không phải "vuông" hoặc "khối", đặt lại per thành False. + # Nếu "trên" được sử dụng, tiếp theo là "vuông" hoặc "khối", chúng ta muốn giữ "singular" cho + # từ sắp tới + elif result_list[-1] not in ("vuông", "khối"): + per = False + + result = " ".join(result_list) + + # 5 Xử lý trường hợp đặc biệt: xentimét khối -> xăng-ti-mét khối + result = re.sub(r"xentimét khối", "xăng-ti-mét khối", result) + + return result \ No newline at end of file diff --git a/converters/Money.py b/converters/Money.py new file mode 100644 index 0000000000000000000000000000000000000000..b73a55be997fdb41c61d71d01f0ccc4e3cd1bbe8 --- /dev/null +++ b/converters/Money.py @@ -0,0 +1,155 @@ +from singleton_decorator import singleton +import re, os +from .Cardinal import CardinalVietnamese +from .Digit import DigitVietnamese + + +@singleton +class Money: + def __init__(self): + super().__init__() + self.decimal_regex = re.compile(r"(.*?)(-?\d*)\.(\d+)(.*)") + self.number_regex = re.compile(r"(.*?)(-?\d+)(.*)") + self.filter_regex = re.compile(r"[, ]") + + self.currencies = { + "đ": { + "number": { + "singular": "đồng", + "plural": "đồng" + }, + "decimal": { + "singular": "xu", + "plural": "xu" + } + }, + "vnd": { + "number": { + "singular": "đồng Việt Nam", + "plural": "đồng Việt Nam" + }, + "decimal": { + "singular": "xu", + "plural": "xu" + } + } + } + + self.suffixes = [ + "nghìn", + "triệu", + "tỷ", + "nghìn tỷ", + "triệu tỷ", + "tỷ tỷ" + ] + + self.abbr_suffixes = { + "k": "nghìn", + "tr": "triệu", + "t": "tỷ" + } + + self.suffix_regex = re.compile( + f"({'|'.join(sorted(self.suffixes + list(self.abbr_suffixes.keys()), key=len, reverse=True))})(.*)", + flags=re.I) + + self.currency_regex = re.compile(r"(.*?)(đồng|vnd|đ)(.*?)", flags=re.I) + + self.cardinal = CardinalVietnamese() # Giả sử đã có lớp Cardinal cho tiếng Việt + self.digit = DigitVietnamese() # Giả sử đã có lớp Digit cho tiếng Việt + + def convert(self, token: str) -> str: + token = self.filter_regex.sub("", token) + + before = "" + after = "" + currency = None + number = "" + decimal = "" + scale = "" + + match = self.decimal_regex.search(token[::-1]) + if match: + before = match.group(4)[::-1] + number = match.group(3)[::-1] + decimal = match.group(2)[::-1] + after = match.group(1)[::-1] + else: + match = self.number_regex.search(token) + if match: + before = match.group(1) + number = match.group(2) + after = match.group(3) + + if before: + before = before.lower() + if before in self.currencies: + currency = self.currencies[before] + elif before[-1] in self.currencies: + currency = self.currencies[before[-1]] + + if after: + match = self.suffix_regex.match(after) + if match: + scale = match.group(1).lower() + scale = self.abbr_suffixes[scale] if scale in self.abbr_suffixes else scale + after = match.group(2) + + if after.lower() in self.currencies: + currency = self.currencies[after.lower()] + after = "" + + decimal_support = currency and "number" in currency + + result_list = [] + if decimal_support and not scale: + if number and (number != "0" or not decimal): + result_list.append(self.cardinal.convert(number)) + result_list.append(currency["number"]["singular"]) + if decimal and decimal != "0" * len(decimal): + result_list.append("và") + if decimal and decimal != "0" * len(decimal): + decimal = f"{decimal:0<2}" + result_list.append(self.cardinal.convert(decimal)) + result_list.append(currency["decimal"]["singular"]) + else: + if number: + result_list.append(self.cardinal.convert(number)) + if decimal and decimal != "0" * len(decimal): + result_list.append("phẩy") + result_list.append(self.digit.convert(decimal)) + if scale: + result_list.append(scale) + if currency: + if decimal_support: + currency = currency["number"] + result_list.append(currency["singular"]) + + if after: + result_list.append(after.lower()) + + result = " ".join(result_list) + return result + + +if __name__ == "__main__": + money = Money() + + # Ví dụ 1: Số tiền đơn giản + print(money.convert("15000đ")) # Kết quả mong đợi: mười lăm nghìn đồng + + # Ví dụ 2: Số tiền có phần thập phân + print(money.convert("1500.50đ")) # Kết quả mong đợi: một nghìn năm trăm đồng và năm mươi xu + + # Ví dụ 3: Số tiền lớn + print(money.convert("1000000000đ")) # Kết quả mong đợi: một tỷ đồng + + # Ví dụ 4: Sử dụng VND + print(money.convert("5000000VND")) # Kết quả mong đợi: năm triệu đồng Việt Nam + + # Ví dụ 5: Sử dụng hậu tố + print(money.convert("2tr đồng")) # Kết quả mong đợi: hai triệu đồng + + # Ví dụ 6: Số tiền rất lớn + print(money.convert("1000000000000đ")) # Kết quả mong đợi: một nghìn tỷ đồng \ No newline at end of file diff --git a/converters/Ordinal.py b/converters/Ordinal.py new file mode 100644 index 0000000000000000000000000000000000000000..07a112605581fe16601a0a47624c47ed8f3af1bd --- /dev/null +++ b/converters/Ordinal.py @@ -0,0 +1,74 @@ +from singleton_decorator import singleton +import re +from Roman import RomanVietnamese +from Cardinal import CardinalVietnamese + + +@singleton +class OrdinalVietnamese: + """ + Các bước: + - 1 Lọc bỏ dấu phẩy và khoảng trắng + - 2 Kiểm tra số La Mã và chuyển đổi thành chuỗi số nguyên nếu có + - 3 Nếu là số La Mã, đặt tiền tố là "thứ" + - 4 Nếu không, kiểm tra xem có phải là số thứ tự tiếng Việt không (ví dụ: "thứ nhất", "thứ 2", "thứ ba") + - 5 Chuyển đổi chuỗi số còn lại thành Cardinal, và thêm "thứ" vào trước + - 6 Áp dụng các quy tắc đặc biệt cho số thứ tự tiếng Việt + """ + + def __init__(self): + super().__init__() + self.filter_regex = re.compile(r"[, ]") + self.vietnamese_ordinal_regex = re.compile(r"(?i)(thứ\s*)?(\d+|nhất|nhì|hai|ba|tư|năm|sáu|bảy|tám|chín|mười)") + self.roman = RomanVietnamese() + self.cardinal = CardinalVietnamese() + + self.special_cases = { + "nhất": "thứ nhất", + "nhì": "thứ nhì", + "hai": "thứ hai", + "ba": "thứ ba", + "tư": "thứ tư", + "năm": "thứ năm", + "sáu": "thứ sáu", + "bảy": "thứ bảy", + "tám": "thứ tám", + "chín": "thứ chín", + "mười": "thứ mười" + } + + def convert(self, token: str) -> str: + token = self.filter_regex.sub("", token) + + if self.roman.check_if_roman(token): + number, _ = self.roman.convert(token) + + return f"thứ {number}" + + match = self.vietnamese_ordinal_regex.fullmatch(token) + if match: + prefix = match.group(1) or "" + number = match.group(2) + + if number.lower() in self.special_cases: + return self.special_cases[number.lower()] + + if number.isdigit(): + cardinal = self.cardinal.convert(number) + return f"thứ {cardinal}" + + return f"{prefix}{number}" + + return f"thứ {self.cardinal.convert(token)}" + + +if __name__ == "__main__": + ordinal_converter = OrdinalVietnamese() + + examples = ["nhất", "thứ nhì", "thứ 3", "thứ tư", "thứ năm", "thứ 10", "21", "100", "1000", "II", "IV"] + + for example in examples: + result = ordinal_converter.convert(example) + print(f"Số thứ tự: {example}") + print(f"Chuyển đổi: {result}") + print() \ No newline at end of file diff --git a/converters/Range.py b/converters/Range.py new file mode 100644 index 0000000000000000000000000000000000000000..c3bf465bd71d7962ff7e8ccf5903e04ecce8b608 --- /dev/null +++ b/converters/Range.py @@ -0,0 +1,36 @@ +from singleton_decorator import singleton +import re +from .Cardinal import CardinalVietnamese + + +@singleton +class Range: + """ + Steps: + - Check for - splitting numbers + + Note: + Punctuation always stays the same + """ + + def __init__(self): + super().__init__() + self.cardinal = CardinalVietnamese() + + def convert(self, token: str) -> str: + numbers = re.split('-', token) + if len(numbers) == 1: + token = self.cardinal.convert(numbers[0]) + elif len(numbers) == 2: + + token = self.cardinal.convert(numbers[0]) + token += ' đến ' + token += self.cardinal.convert(numbers[1]) + + else: + token = '' + for number in numbers: + token += self.cardinal.convert(number) + token += ' ' + + return token \ No newline at end of file diff --git a/converters/Roman.py b/converters/Roman.py new file mode 100644 index 0000000000000000000000000000000000000000..6bd038605f6a29b83eaab4d2f299aac78dc4bd45 --- /dev/null +++ b/converters/Roman.py @@ -0,0 +1,88 @@ +from singleton_decorator import singleton +import re + + +@singleton +class RomanVietnamese: + """ + Các bước: + - 1 Lấy phần lớn nhất + - 2 Kiểm tra hậu tố 's' + - 3 Áp dụng lọc nghiêm ngặt + - 4 Tính tổng giá trị của chữ số La Mã bằng số nguyên + - 5 Trả về biểu diễn chuỗi của tổng, cùng với hậu tố + Trường hợp đặc biệt: + II I -> hai + IIs -> hai's + II. -> hai + """ + + def __init__(self): + super().__init__() + # Regex để lọc bỏ các ký tự không phải chữ số La Mã + self.roman_filter_strict_regex = re.compile("[^IVXLCDM]") + # Regex để phát hiện chữ số La Mã + self.roman_filter_regex = re.compile(r"[.IVXLCDM]+(th|nd|st|rd|'s|s)?") + + # Từ điển giá trị chữ số La Mã + self.roman_numerals = { + "I": 1, + "V": 5, + "X": 10, + "L": 50, + "C": 100, + "D": 500, + "M": 1000 + } + + + + def convert(self, token: str) -> (str, str): + # 1 Tách token thành các phần và làm việc với phần lớn nhất, trong trường hợp đầu vào là "I II" + token = max(token.split(" "), key=len) + # 2 Kiểm tra xem có cần sử dụng hậu tố "'s" không + suffix = "" + if token[-1:] == "s": + suffix = "'s" + + # 3 Áp dụng lọc nghiêm ngặt để loại bỏ ".", "'" và "s" + token = self.roman_filter_strict_regex.sub("", token) + # 4 Chúng ta lặp qua token theo chiều ngược lại, liên tục cộng hoặc trừ giá trị được biểu diễn + # bởi ký tự, dựa trên các token trước đó. + total = 0 + prev = 0 + for c in reversed(token): + cur = self.roman_numerals[c] + total += cur if cur >= prev else -cur + prev = cur + + return (str(total), suffix) + + + def check_if_roman(self, token: str) -> bool: + # Kiểm tra xem phần lớn nhất của token có được coi là chữ số La Mã hay không + return self.roman_filter_regex.fullmatch(max(token.split(" "), key=len)) != None + + +if __name__ == "__main__": + roman_converter = RomanVietnamese() + + # Ví dụ 1 + example1 = "XIV" + result1, suffix1 = roman_converter.convert(example1) + print(f"Chữ số La Mã: {example1}") + print(f"Chuyển đổi: {result1}{suffix1}") + print() + + # Ví dụ 2 + example2 = "MCMLIV" + result2, suffix2 = roman_converter.convert(example2) + print(f"Chữ số La Mã: {example2}") + print(f"Chuyển đổi: {result2}{suffix2}") + print() + + # Ví dụ 3 + example3 = "IIs" + result3, suffix3 = roman_converter.convert(example3) + print(f"Chữ số La Mã: {example3}") + print(f"Chuyển đổi: {result3}{suffix3}") \ No newline at end of file diff --git a/converters/Telephone.py b/converters/Telephone.py new file mode 100644 index 0000000000000000000000000000000000000000..59e673bd35dc3472812d2140b0bf7b71e9de9957 --- /dev/null +++ b/converters/Telephone.py @@ -0,0 +1,90 @@ +from singleton_decorator import singleton +import re + + +@singleton +class TelephoneVietnamese: + """ + Các bước: + - 1 Chuyển đổi thành chữ thường và thay thế dấu ngoặc đơn bằng dấu gạch ngang + - 2 Chuyển đổi từng ký tự trong token + - 3 Loại bỏ nhiều "ngat" liên tiếp. Đồng thời loại bỏ "ngat" ở đầu. + - 4 Thay thế các "khong" liên tiếp bằng "tram" hoặc "nghin" khi thích hợp + Lưu ý: + Số điện thoại chứa 0-9, "-", a-z, A-Z, " ", "(", ")" + """ + + def __init__(self): + super().__init__() + # Từ điển dịch + self.tu_dien_dich = { + " ": "ngat", + "-": "ngat", + "x": "may_nhanh", + "0": "không", + "1": "môt", + "2": "hai", + "3": "ba", + "4": "bốn", + "5": "năm", + "6": "sáu", + "7": "bảy", + "8": "tám", + "9": "chín", + } + # Regex để lọc dấu ngoặc đơn + self.regex_loc = re.compile(r"[()]") + + def convert(self, token: str) -> str: + # 1 Chuyển đổi thành chữ thường và thay thế dấu ngoặc đơn bằng dấu gạch ngang + token = self.regex_loc.sub("-", token.lower()) + + # 2 Chuyển đổi danh sách các ký tự + danh_sach_ket_qua = [self.tu_dien_dich[c] if c in self.tu_dien_dich else c for c in token] + + # 3 Loại bỏ nhiều "ngat" liên tiếp. Đồng thời loại bỏ "ngat" ở đầu. + danh_sach_ket_qua = [phan for i, phan in enumerate(danh_sach_ket_qua) if + phan != "ngat" or (i - 1 >= 0 and danh_sach_ket_qua[i - 1] != "ngat")] + + # 4 Lặp qua danh_sach_ket_qua và thay thế nhiều "khong" liên tiếp bằng "tram" hoặc "nghin", + # nhưng chỉ khi đứng trước là thứ khác ngoài "khong" hoặc "ngat", và đứng sau là "ngat" hoặc kết thúc danh sách. + i = 0 + while i < len(danh_sach_ket_qua): + do_lech = 0 + while i + do_lech < len(danh_sach_ket_qua) and danh_sach_ket_qua[i + do_lech] == "khong": + do_lech += 1 + if (i + do_lech >= len(danh_sach_ket_qua) or danh_sach_ket_qua[i + do_lech] == "ngat") and ( + i - 1 < 0 or danh_sach_ket_qua[i - 1] not in ("khong", "ngat")) and do_lech in (2, 3): + danh_sach_ket_qua[i: do_lech + i] = ["tram"] if do_lech == 2 else ["nghin"] + i += 1 + + return " ".join(danh_sach_ket_qua) + + +def main(): + so_dien_thoai = TelephoneVietnamese() + + # Ví dụ sử dụng + cac_vi_du = [ + "0123-456-789", + "(098) 765-4321", + "0909 333 222", + "1800 1560", + "19001560", + "0336444027", + "+84-912345678", + ] + + print("Ví dụ chuyển đổi số điện thoại:") + for vi_du in cac_vi_du: + ket_qua = so_dien_thoai.convert(vi_du) + print(f"Gốc: {vi_du}") + print(f"Kết quả: {ket_qua}") + print() + + +if __name__ == "__main__": + # main() + x ="027321" + if x.startswith(("19", "18", "0")): + print(1) \ No newline at end of file diff --git a/converters/Time.py b/converters/Time.py new file mode 100644 index 0000000000000000000000000000000000000000..921b7db3513adee3a17b4c4e47230999d2e35a36 --- /dev/null +++ b/converters/Time.py @@ -0,0 +1,100 @@ +from singleton_decorator import singleton +import re +from .Cardinal import CardinalVietnamese + + +@singleton +class Time: + def __init__(self): + super().__init__() + + self.filter_regex = re.compile(r"[. ]") + self.time_regex = re.compile(r"^(?P\d{1,2}) *((?::|.) *(?P\d{1,2}))? *(?P[a-zA-Z\. ]*)$", + flags=re.I) + self.full_time_regex = re.compile( + r"^(?:(?P\d{1,2}) *:)? *(?P\d{1,2})(?: *: *(?P\d{1,2})(?: *. *(?P\d{1,3}))?)? *(?P[a-zA-Z\. ]*)$", + flags=re.I) + self.ampm_time_regex = re.compile(r"^(?P[a-zA-Z\. ]*)(?P\d{1,2})", flags=re.I) + + self.cardinal = CardinalVietnamese() + + def convert(self, token: str) -> str: + token = token.strip() + result_list = [] + + match = self.time_regex.match(token) + if match: + hour, minute, suffix = match.group("hour"), match.group("minute"), match.group("suffix") + + result_list.append(self.cardinal.convert(hour)) + result_list.append("giờ") + + if minute and minute != "00": + result_list.append(self.cardinal.convert(minute)) + result_list.append("phút") + + if suffix: + suffix = self.filter_regex.sub("", suffix).lower() + if suffix == "sa": + result_list.append("sáng") + elif suffix == "ch": + result_list.append("chiều") + + return " ".join(result_list) + + match = self.full_time_regex.match(token) + if match: + hour, minute, seconds, milliseconds, suffix = match.group("hour"), match.group("minute"), match.group( + "seconds"), match.group("milliseconds"), match.group("suffix") + + if hour: + result_list.append(self.cardinal.convert(hour)) + result_list.append("giờ") + if minute: + result_list.append(self.cardinal.convert(minute)) + result_list.append("phút") + if seconds: + result_list.append(self.cardinal.convert(seconds)) + result_list.append("giây") + if milliseconds: + result_list.append(self.cardinal.convert(milliseconds)) + result_list.append("phần nghìn giây") + + if suffix: + suffix = self.filter_regex.sub("", suffix).lower() + if suffix == "sa": + result_list.append("sáng") + elif suffix == "ch": + result_list.append("chiều") + + return " ".join(result_list) + + match = self.ampm_time_regex.match(token) + if match: + hour, suffix = match.group("hour"), match.group("suffix") + + result_list.append(self.cardinal.convert(hour)) + result_list.append("giờ") + + suffix = self.filter_regex.sub("", suffix).lower() + if suffix == "sa": + result_list.append("sáng") + elif suffix == "ch": + result_list.append("chiều") + + return " ".join(result_list) + + return token + + +if __name__ == "__main__": + time = Time() + + print(time.convert("7:30")) # Kết quả mong đợi: bảy giờ ba mươi phút + print(time.convert("8:00 SA")) # Kết quả mong đợi: tám giờ sáng + print(time.convert("3:00 CH")) # Kết quả mong đợi: ba giờ chiều + print(time.convert( + "11:59:59.999")) # Kết quả mong đợi: mười một giờ năm mươi chín phút năm mươi chín giây chín trăm chín mươi chín phần nghìn giây + print(time.convert("SA7")) # Kết quả mong đợi: bảy giờ sáng + print(time.convert("CH5")) # Kết quả mong đợi: năm giờ chiều + print(time.convert("9:30:21")) # Kết quả mong đợi: năm giờ chiều \ No newline at end of file diff --git a/converters/__init__.py b/converters/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/converters/__pycache__/Cardinal.cpython-310.pyc b/converters/__pycache__/Cardinal.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9fd415f19b598690d7e2d2d91e9ca5071a129fe2 Binary files /dev/null and b/converters/__pycache__/Cardinal.cpython-310.pyc differ diff --git a/converters/__pycache__/Date.cpython-310.pyc b/converters/__pycache__/Date.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3d76651987abec7ce6c0e6164f3a828887bcc53 Binary files /dev/null and b/converters/__pycache__/Date.cpython-310.pyc differ diff --git a/converters/__pycache__/Decimal.cpython-310.pyc b/converters/__pycache__/Decimal.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f803db610edcd32a854e78d429297ebf61c0c4c Binary files /dev/null and b/converters/__pycache__/Decimal.cpython-310.pyc differ diff --git a/converters/__pycache__/Digit.cpython-310.pyc b/converters/__pycache__/Digit.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4a2dd47c9ac89e4a6ac993b99c16d2ad9c9c1f7 Binary files /dev/null and b/converters/__pycache__/Digit.cpython-310.pyc differ diff --git a/converters/__pycache__/Fraction.cpython-310.pyc b/converters/__pycache__/Fraction.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c137278cea1305fb1496c9e4508aadd4c1f66486 Binary files /dev/null and b/converters/__pycache__/Fraction.cpython-310.pyc differ diff --git a/converters/__pycache__/Meansure.cpython-310.pyc b/converters/__pycache__/Meansure.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..08e6937f135f983f56215e20723642f2c9600dc4 Binary files /dev/null and b/converters/__pycache__/Meansure.cpython-310.pyc differ diff --git a/converters/__pycache__/Money.cpython-310.pyc b/converters/__pycache__/Money.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9abefc5273f4d37fa660add2a130291464e354ba Binary files /dev/null and b/converters/__pycache__/Money.cpython-310.pyc differ diff --git a/converters/__pycache__/Range.cpython-310.pyc b/converters/__pycache__/Range.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6d9de4fdfafc4015762c2c84a52fd084973fafc1 Binary files /dev/null and b/converters/__pycache__/Range.cpython-310.pyc differ diff --git a/converters/__pycache__/Roman.cpython-310.pyc b/converters/__pycache__/Roman.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..baa2c5735eeb9c010bcb0f763b51d60fdc38f22a Binary files /dev/null and b/converters/__pycache__/Roman.cpython-310.pyc differ diff --git a/converters/__pycache__/Telephone.cpython-310.pyc b/converters/__pycache__/Telephone.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac2a05f29b2c86b594fdb954eb0e15fe42e78378 Binary files /dev/null and b/converters/__pycache__/Telephone.cpython-310.pyc differ diff --git a/converters/__pycache__/Time.cpython-310.pyc b/converters/__pycache__/Time.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fdb458520d011c4892475008f7a7e5ffce6320ed Binary files /dev/null and b/converters/__pycache__/Time.cpython-310.pyc differ diff --git a/converters/__pycache__/__init__.cpython-310.pyc b/converters/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..366e4fa9a533fb1a1df0e7fd99d0f7efc1968adc Binary files /dev/null and b/converters/__pycache__/__init__.cpython-310.pyc differ diff --git a/download.sh b/download.sh new file mode 100644 index 0000000000000000000000000000000000000000..a83fbb0d93777155df6e0e97d721879b7b60009e --- /dev/null +++ b/download.sh @@ -0,0 +1,8 @@ +#!/usr/bin/env bash + +if [ ! -f uvr5_weights/2_HP-UVR.pth ]; then + echo "Download the model weights" + wget -q -O uvr5_weights/2_HP-UVR.pth 2_HP-UVR.pth https://huggingface.co/fastrolling/uvr/resolve/main/Main_Models/2_HP-UVR.pth +fi + +echo "The model weights have been downloaded" diff --git a/train_list.txt b/train_list.txt new file mode 100644 index 0000000000000000000000000000000000000000..a492f2926cb5e4b04508a044d7bf092fbb5826ab --- /dev/null +++ b/train_list.txt @@ -0,0 +1,497 @@ +dataset/Xanh24h/speaker_0/4.wav|ŋwˈiɛn fˈɔŋ , nˈiɲ twˈə6n , ˈu mˈyə2j bˈa4j xˈe-ɜɲ hwˈaː2 , stˈɑː kˈɪdz , hˈaj kˌaːɜc tʃˈaːŋ tʃwˈiɛ2n lˈyə4 tʃˌɔ bˈɔɜŋ ɗˈaːɜ tʃˈen mˈaː6ŋ sˈaː5 hˈo6j . |0 +dataset/Xanh24h/speaker_0/14.wav|mˈo6t0 sˈoɜ lwˈaː6j sˈiɛn kwˈɛ fˈo4 bˈiɛɜn vˌaː2 ɗˌyə6c xˈe-ɜc hˈaː2ŋ ˈyə tʃˈuə6ŋ ɲˈəɜt0 kˈɔɜ tˈe4 kˈe4 ɗˌeɜn ɲˌy kˈaːɜ vˈiɛn , bˈɔ2 vˈiɛn , sˈuɜc sˈiɜc , lˈaː6p sˈyə4ŋ , tˈi6t0 vˈiɛn , nˈɛɜm tʃˈuə . |0 +dataset/Xanh24h/speaker_0/17.wav|ɗˈiɛ2w nˈa2j zˈuɜp ɗˈyə zˈaː tˈi6 tʃˈyə2ŋ mˈo6t0 sˈaː4n fˈə4m ˈan vˈa6t0 xˌoŋ tʃˈi4 ŋˈɔn mˈiɛ6ŋ mˌaː2 kˌɔ2n ɗˈo6k ɗˈaːɜw vˌaː2 ɗˈaːɜp ˈyɜŋ ɗˈuɜŋ ɲˈu kˈə2w kˌuə4 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/21.wav|kˈaɜt0 tˈe-ɲ lˈɔŋ tˈe-2ɲ t0ˈy2ŋ mˈiɛɜŋ ɲˈɔ4 zˈo2j tʃˌɔ vˈaː2w mˈaɜj sˈaj sˈiɲ t0ˈoɜ sˈaj ɲwˈiɛ5n , sˈaw ɗˈɔɜ tʃˌɔ bˈo6t0 mˈi2 vˈaː2w t0ˈo zˈo2j tʃˌɔ tˈem ɗˈyə2ŋ , mˈɛn nˈəː4 , zˈə2w ˈan vˌaː2 sˈyə5 ɗˈa6c . |0 +dataset/Xanh24h/speaker_0/22.wav|ɗˈo2ŋ tˈəː2j , ɗˈəɪ kˈu5ŋ lˌaː2 ɗˈiɛ4m tˈaːm kwˈaːn , tʃˈaːw ɗˈo4j , hˈɔ6k t0ˈə6p kˈiɲ ŋˈiɛ6m tʃˌɔ kˌaːɜc hˈo6j vˈiɛn kˈɔɜ kˈu2ŋ sˈəː4 tˈiɜc tʃˈan nˈuəj zˈe . |0 +dataset/Xanh24h/speaker_0/24.wav|tʃˈen kˈe-ɜɲ ɗˈo2ŋ ŋˈo nˈeɜp ˈəː4 tˈon mˈo6t0 , sˈaː5 t0ˈyə2ŋ sˈəːn , ŋˈaj t0ˌy2 sˈaːɜŋ sˈəːɜm ŋˈyə2j zˈən ɗˌaː5 ɲˈo6n ɲˈi6p zˈaː ɗˈo2ŋ tˈu hwˈe-6c ɗˌe4 bˈaːɜn tʃˌɔ tˈyəŋ lˈaːɜj . |0 +dataset/Xanh24h/speaker_0/25.wav|nˌeɜw ɲˌy bˈaː6n tʃˈam tʃˈi4 vˌaː2 kˈɔɜ kˈi5 nˈaŋ vˈiɛɜt0 ˈo4n tˌi2 vˈiɛ6c mˈo6t0 tˈaːɜŋ bˈaː6n kˈɔɜ tˈe4 kˈiɛɜm ɗˌyə6c hˈaːj ɗˌeɜn bˈaː tʃˈiɛ6w ɗˈo2ŋ lˌaː2 mˈo6t0 ɗˈiɛ2w hˈeɜt0 sˈyɜc bˈi2ɲ tˈyə2ŋ . |0 +dataset/Xanh24h/speaker_0/30.wav|nˈyəɜc hwˈaː tʃˈo2n hˈyəŋ kˈɔɜ hˈyəŋ tˈəːm ɗˈa6c tʃˈyŋ , ɗˌyə6c sˈy4 zˈu6ŋ tʃˈɔŋ ɲˈiɛ2w lˈi5ɲ vˈy6c xˈaːɜc ɲˈaw ɲˌy sˈaː4n swˈəɜt0 nˈyəɜc hwˈaː , mˈi5 fˈə4m , zˈyə6c fˈə4m . |0 +dataset/Xanh24h/speaker_0/32.wav|tˈoŋ tˈyə2ŋ , t0ˈy2ŋ xˈu vˈy6c , fˈən xˈuɜc xˈe-ɜc hˈaː2ŋ ɗˌaː5 kˈɔɜ mˈo6t0 mˈyɜc zˈaːɜ ɲˈəɜt0 ɗˈi6ɲ , vˌi2 vˈəɪ6 bˈaː6n kˈə2n bˈiɛɜt0 ɗˌyə6c mˈyɜc zˈaːɜ bˈaːw ɲˈiɛw lˌaː2 fˈu2 hˈəː6p . |0 +dataset/Xanh24h/speaker_0/37.wav|nˌeɜw xˌoŋ kˈɔɜ kˈi2 wˈɜːld kˈʌp hˈaːj ŋˈi2n xˌoŋ tʃˈam hˈaːj mˈyəj hˈaːj , tˌi2 kˈɔɜ lˈɛ5 hˈi2ɲ zˈuŋ kˌuə4 tʃˈuɜŋ t0ˈaː vˈe2 ɗˈəɜt0 nˈyəɜc nˈa2j tʃˈi4 lˌaː2 mˈo6t0 ɗˈəɜt0 nˈyəɜc tʃˈuŋ ɗˈoŋ ɲˈɔ4 bˈɛɜ vˌaː2 zˈa2w kˈɔɜ . |0 +dataset/Xanh24h/speaker_0/38.wav|vˌəːɜj tˈəː2j zˈaːn ŋˈəm ˈu4 ɲˌy vˈəɪ6 , tˈyɜc ˈan xˌoŋ bˌi6 ˈoj tˈiɛw , nˈəɜm mˈoɜk , ɗˈaː4m bˈaː4w ˈaːn t0wˈaː2n tˈy6c fˈə4m vˌaː2 sˈyɜc xwˈɛ4 vˈə6t0 nˈuəj . |0 +dataset/Xanh24h/speaker_0/39.wav|hˈəːn tˈeɜ nˈyə5 , ɗˈo2 hˈandmeɪd lˈuən zˈe5 zˈaː2ŋ t0ˈaː6w ɗˈiɛ4m ɲˈəɜn vˌi2 nˈɔɜ mˈaːŋ t0ˈiɜɲ kˈaːɜ ɲˈən hwˈaːɜ kˈaːw xˈiɛɜn ɲˈiɛ2w ŋˈyə2j tˈiɜc tˈuɜ . |0 +dataset/Xanh24h/speaker_0/40.wav|xˌi ɲˌy5ŋ ŋˈyə2j zˈa2w kˈɔɜ t0ˈə6n hˈyə4ŋ sˈy6 nˈɔɜŋ tʃˈaɜj kˌuə4 mˈoj tʃˈyə2ŋ sˈaː mˈaː6c , vˈiɛ6c t0ˈi2m kˈiɛɜm bˈɔɜŋ mˈaːɜt0 vˌaː2 sˈe-ɲ t0ˈyəj tʃˈəː4 nˌen kwˈaːn tʃˈɔ6ŋ . |0 +dataset/Xanh24h/speaker_0/43.wav|vˈan fˈɔ2ŋ fˈə4m ɣˈə2n tʃˈyə2ŋ hˈɔ6k zˈəɜt0 kwˈaːn tʃˈɔ6ŋ vˌi2 tʃˈuɜŋ lˌaː2 ɲˌy5ŋ vˈə6t0 zˈu6ŋ kˈə2n tˈiɛɜt0 tʃˌɔ vˈiɛ6c hˈɔ6k t0ˈə6p vˌaː2 lˈaː2m vˈiɛ6c kˌuə4 hˈɔ6k sˈiɲ , sˈiɲ vˈiɛn kˈu5ŋ ɲˌy zˈaːɜw vˈiɛn . |0 +dataset/Xanh24h/speaker_0/49.wav|vˈiɛ6c ŋˈiɛn kˈiɜw vˌaː2 t0ˈi2m hˈiɛ4w kˈi5 vˈe2 tˈi6 tʃˈyə2ŋ zˈuɜp zwˈe-ɲ ŋˈiɛ6p kˈɔɜ kˌaːɜj ɲˈi2n zˈɔ5 zˈaː2ŋ vˈe2 ɗˈa6c ɗˈiɛ4m , sˈu hˈyəɜŋ vˌaː2 ɲˈu kˈə2w kˌuə4 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/51.wav|nˌeɜw bˈɔ4 kwˈaː bˈyəɜc nˈa2j , bˈaː6n sˌɛ5 xˌoŋ kˈɔɜ sˈoɜ lˈiɛ6w vˈe2 ŋˈyə2j zˈu2ŋ , xˌoŋ bˈiɛɜt0 ɗˌyə6c ɗˈə1w lˌaː2 ɲˌy5ŋ mˈɔŋ mˈuəɜn kˌuə4 xˈe-ɜc hˈaː2ŋ , t0ˌy2 ɗˈɔɜ xˌoŋ t0ˈə6p tʃˈuŋ sˈəɪ zˈy6ŋ ɲˌy5ŋ lˈəː6j ˈiɜc tʃˌɔ xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/52.wav|vˌəːɜj mˌo5j mˈiɛɜŋ nˈɛm , ŋˈyə2j tˈyə4ŋ tˈyɜc xˌoŋ tʃˈi4 kˈaː4m ɲˈə6n ɗˌyə6c vˈi6 bˈiɛ4n mˈa6n mˌaː2 kˌɔ2n bˌi6 kˈuəɜn hˈuɜt0 bˌəː4j sˈy6 ɗˈo6k ɗˈaːɜw vˌaː2 hˈəɜp zˈə5n kˌuə4 mˈɔɜn ˈan . |0 +dataset/Xanh24h/speaker_0/54.wav|t0ˈə2m kˌɔn ɗˈa6c bˈiɛ6t0 ˈiɛw kˈə2w ˈe-ɜɲ sˈaːɜŋ ˈiɛɜw , zˈɔ ɗˈɔɜ fˈɔ2ŋ nˈuəj t0ˈə2m kˌɔn kˈə2n kˈɔɜ ˈe-ɜɲ sˈaːɜŋ ˈiɜt0 hˈəːn zˈɔ vˌəːɜj fˈɔ2ŋ nˈuəj t0ˈə2m lˈəːɜn . |0 +dataset/Xanh24h/speaker_0/57.wav|t0ˌy2 tˈe-2ɲ kˈoŋ bˈyəɜc ɗˈə2w , nˈam hˈaːj ŋˈi2n xˌoŋ tʃˈam hˈaːj mˈyəj , ˈoŋ hwˈaː6t0 bˈaː2n vˌəːɜj zˈaː ɗˈi2ɲ , ɗˈə2w t0ˈy fˈaːɜt0 tʃˈiɛ4n tʃˈan nˈuəj lˈəː6n tˈɛw hˈyəɜŋ kˈoŋ ŋˈiɛ6p mˈəːɜj . |0 +dataset/Xanh24h/speaker_0/58.wav|xˌoŋ nˌen ɗˈa6t0 tʃˈuə2ŋ nˈuəj tˈɔ4 ɣˈə2n tʃˈuə2ŋ nˈuəj kˌaːɜc zˈaː4 sˈuɜc xˈaːɜc , vˈyə2 ŋˈo6t0 ŋˈaː6t0 , hˈoj tˈoɜj , lˈaː6j ɲˈiɛ5m ɗˈo6k vˌaː2 lˈəɪ lˈaːn bˈe6ɲ t0ˈə6t0 tʃˌɔ tˈɔ4 . |0 +dataset/Xanh24h/speaker_0/65.wav|vˌi2 vˈəɪ6 , hˈa5j tʃˈaɜc tʃˈaɜn bˈaː6n kˈɔɜ mˈo6t0 xwˈaː4n t0ˈiɛ2n zˈy6 tʃˈu2 ɗˈu4 ɗˌe4 zwˈi tʃˈi2 kˌaːɜc hwˈaː6t0 ɗˈo6ŋ tʃˈɔŋ vˈɔ2ŋ hˈaːj ɗˌeɜn sˈaɜw tˈaːɜŋ ɗˈə2w t0ˈiɛn . |0 +dataset/Xanh24h/speaker_0/74.wav|tʃˈɔŋ kˈeɜ hwˈe-6c kˈiɲ zwˈe-ɲ kˌuə4 mˈo6t0 kˈyə4 hˈaː2ŋ sˈe-ɜc , bˈaː6n kˈə2n fˌaː4j tʃˈi t0ˈiɛɜt0 vˌaː2 sˈaːɜc ɗˈi6ɲ zˈɔ5 ɲˌy5ŋ ˈiɛɜw t0ˈoɜ vˌaː2 tʃˈi fˈiɜ ˈe-4ɲ hˈyə4ŋ ɗˌeɜn ŋˈuə2n vˈoɜn ɗˈə2w t0ˈy . |0 +dataset/Xanh24h/speaker_0/87.wav|tʃˈuɜc kˌaːɜc bˈaː6n sˌɛ5 ˈaːɜp zˈu6ŋ tˈe-2ɲ kˈoŋ bˈaː2j hˈɔ6k ŋˈa2j hˈom nˈaj , vˌaː2 ɗˈy2ŋ kwˈen ɗˌe4 lˈaː6j ɲˌy5ŋ bˈi2ɲ lwˈə6n tʃˈiə sˈɛ4 tˈem kˈiɲ ŋˈiɛ6m , kˈu5ŋ ɲˌy tʃˈaːw ɗˈo4j kˈaː4m ɲˈə6n kˌuə4 kˌaːɜc bˈaː6n tʃˌɔ tʃˈuɜŋ t0ˈoj kˈu2ŋ bˈiɛɜt0 ɲˈɛɜ . |0 +dataset/Xanh24h/speaker_0/97.wav|nˈuəj tˈɔ4 lˌaː2 mˈo6t0 ŋˈe2 mˈaːŋ lˈaː6j hˈiɛ6w kwˈaː4 kˈiɲ t0ˈeɜ kˈaːw , t0wˈi ɲˈiɛn lˈaː6j ɗˈɔ2j hˈɔ4j ŋˈyə2j nˈuəj fˌaː4j kˈɔɜ ɲˈiɛ2w kˈi5 twˈə6t0 vˌaː2 kˈiɲ ŋˈiɛ6m . |0 +dataset/Xanh24h/speaker_0/109.wav|bˈen kˈe-6ɲ ɗˈɔɜ , nˈuəj zˈu2j lˈiɜɲ ɗˈɛn kˌɔ2n kˈuŋ kˈəɜp ŋˈuə2n fˈən bˈɔɜn tʃˈəɜt0 lˈyə6ŋ t0ˈoɜt0 tʃˌɔ kˈəɪ tʃˈo2ŋ , twˈi4 sˈaː4n , ɣˈɔɜp fˈə2n bˈaː4w vˈe6 mˈoj tʃˈyə2ŋ . |0 +dataset/Xanh24h/speaker_0/111.wav|kˈu6 tˈe4 , bˈaɜt0 ɗˈə2w t0ˌy2 xwˌaː4ŋ tˈaːɜŋ nˈam ˈəm lˈi6c , ˈoŋ bˈaɜt0 ɗˈə2w hˈyɜŋ nˈyəɜc mˈyə tʃˈɔŋ ˈaːw ɗˌe4 kˈɔɜ nˈyəɜc ŋˈɔ6t0 tʃˌɔ ɗˈəɪ2 ˈaːw , sˈaw ɗˈɔɜ kˈaː4j t0ˈaː6w vˌaː2 ˈyəŋ kˌɔn zˈoɜŋ t0ˈom sˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/114.wav|tˈɛw tˈoɜŋ kˈe , vˈiɛ6t0 nˈaːm kˈɔɜ hˈəːn hˈaːj mˈyəj lˈam tʃˈiɛ6w tʃˈɛ4 ˈɛm zˈyəɜj mˈyə2j lˈam t0ˈuə4j , tʃˈiɛɜm hˈəːn hˈaːj mˈyəj lˈam fˈə2n tʃˈam zˈən sˈoɜ kˈaː4 nˈyəɜc . |0 +dataset/Xanh24h/speaker_0/117.wav|kˈiɲ zwˈe-ɲ hwˈaː xˈo lˌaː2 mˈo6t0 lˈyə6 tʃˈɔ6n kˈiɲ zwˈe-ɲ hˈəɜp zˈə5n tʃˌɔ ɲˌy5ŋ ŋˈyə2j kˈɔɜ nˈiɛ2m ɗˈaːm mˈe vˌəːɜj hwˈaː vˌaː2 mˈuəɜn t0ˈy6 mˈi2ɲ lˈaː2m tʃˈu4 , ɗˈo6k lˈə6p vˌaː2 t0ˈy6 zˈɔ t0ˈaː2j tʃˈiɜɲ . |0 +dataset/Xanh24h/speaker_0/125.wav|mˈo6t0 t0wˈə2n sˈaw , tʃˈuə2ŋ t0ˈom ɗˌyə6c sˈy4 lˈiɜ bˈa2ŋ tʃˈeɜ fˈə4m sˈiɲ hˈɔ6k , vˌaː2 sˈaw bˈaː ŋˈa2j , t0ˈom ɗˌyə6c ɗˈyə vˈaː2w nˈuəj xˌi lˈyə6ŋ nˈyəɜc ɗˈaː6t0 t0ˈoɜj tˈiɛ4w t0ˈaːɜm mˈyəj sˈaŋt0ˈimˈɛɜt0 . |0 +dataset/Xanh24h/speaker_0/126.wav|tˈoŋ tˈyə2ŋ kˈoŋ vˈiɛ6c nˈa2j ɗˌyə6c t0ˈiɜɲ tˈɛw t0ˈiɛɜŋ , mˈo6t0 ŋˈa2j lˈaː2m xwˌaː4ŋ bˈoɜn ɗˌeɜn nˈam t0ˈiɛɜŋ tˌi2 mˈo6t0 tˈaːɜŋ bˈaː6n kˈɔɜ tˈe4 kˈiɛɜm vˈe2 xwˌaː4ŋ bˈaː ɗˌeɜn bˈoɜn tʃˈiɛ6w ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/128.wav|mˈɔɜn bˈe-ɜɲ nˈa2j hˈiɛ6n ɗˌaːŋ ɗˌyə6c fˈu6c vˈu6 t0ˈaː6j ɲˈaː2 hˈaː2ŋ ɹɪnˈɑːtəʊ vaɪˈəʊlə ˈiɜ vˌəːɜj zˈaːɜ xwˌaː4ŋ mˈyə2j hˈaːj ŋˈi2n ɗˈo lˈaː mˈi5 , hˈaːj tʃˈam sˈaɜw mˈyəj sˈaɜw tʃˈiɛ6w ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/131.wav|nˌeɜw bˈaː6n kˈiɲ zwˈe-ɲ kˌaːɜc mˈɔɜn ˈan zˈaː ɗˈi2ɲ , bˈaː6n kˈɔɜ tˈe4 t0ˈə6p tʃˈuŋ kwˈaː4ŋ bˈaːɜ tʃˈen kˌaːɜc hˈo6j ɲˈɔɜm zˈe-2ɲ tʃˌɔ mˈɛ6 vˌaː2 bˈɛɜ , kˌaːɜc hˈo6j ɲˈɔɜm nˈəɜw ˈan . |0 +dataset/Xanh24h/speaker_0/133.wav|sˈaw xˌi nwˈaː5n hwˈaː2n t0ˈiɛw hˈeɜt0 , tʃˈuɜŋ kˈɔɜ tˈe4 t0ˈy6 ˈan kˌaːɜc tˈyɜc ˈan ɲˌy bˈɔ2 bˈɔ2 , kˌaːɜc sˈiɲ vˈə6t0 ˈu zˈu hwˌa6c lˈɔ2ŋ ɗˈɔ4 tʃˈyɜŋ tʃˈiɜn . |0 +dataset/Xanh24h/speaker_0/134.wav|tˈəː2j ɗˈiɛ4m ɗˈə2w t0ˈə6p t0ˈe-2ɲ kˈiɲ zwˈe-ɲ , ˈe-ɲ mˈaj mˈaɜn ɲˈə6n ɗˌyə6c sˈy6 ˈu4ŋ hˈo6 kˌuə4 mˌɔ6j ŋˈyə2j , nˌen kˈoŋ vˈiɛ6c kˈiɲ zwˈe-ɲ xˈaːɜ ˈo4n ɗˈi6ɲ . |0 +dataset/Xanh24h/speaker_0/137.wav|nˌeɜw bˈaː6n kˈɔɜ ˈiɜ ɗˈi6ɲ kˈiɲ zwˈe-ɲ tʃˈen sˈaː2n tˈyəŋ mˈaː6j ɗˈiɛ6n t0ˈy4 , hˈa5j t0ˈi2m hˈiɛ4w kˈi5 tˈi6 tʃˈyə2ŋ vˌaː2 lˈyə6 tʃˈɔ6n sˈaː4n fˈə4m zˈi6c vˈu6 fˈu2 hˈəː6p ɗˌe4 kˈiɲ zwˈe-ɲ hˈiɛ6w kwˈaː4 . |0 +dataset/Xanh24h/speaker_0/140.wav|tʃˈaː4j kwˈaː ɲˈiɛ2w kˈuə6c tˈy4 ŋˈiɛ6m , kˈuəɜj kˈu2ŋ sˈaw hˈaːj nˈam , tʃˈi6 ɗˌaː5 tˈe-2ɲ kˈoŋ tʃˈɔŋ kˈe-ɜc tʃˈeɜ bˈiɛɜn tˈyɜc ˈan tˈaː4w zˈyə6c , ɗˈaː6t0 hˈiɛ6w kwˈaː4 lˈen mˈɛn kˈaːw ɲˈəɜt0 . |0 +dataset/Xanh24h/speaker_0/145.wav|tˈɛw mˈo6t0 sˈoɜ t0ˈaː2j lˈiɛ6w xwˈaː hˈɔ6k , kˈaːɜ kˈɔj swˈəɜt0 hˈiɛ6n t0ˌy2 ɲˌy5ŋ nˈam mˈo6t0 ŋˈi2n t0ˈaːɜm tʃˈam hˈaːj mˈyəj t0ˈaː6j tˈi6 tʃˈəɜn ˈɒdʒɪjə , t0ˈi4ɲ nˌɪɪɡˈɑːtə , ɲˈə6t0 bˈaː4n . |0 +dataset/Xanh24h/speaker_0/147.wav|sˈy6 tʃˈuɜ tʃˈɔ6ŋ vˈaː2w vˈiɛ6c kˈiɛ4m swˈaːɜt0 tʃˈa6t0 tʃˈɛ5 kwˈi tʃˈi2ɲ sˈaː4n swˈəɜt0 t0ˌy2 ŋˈuə2n ɣˈoɜk ɗˌeɜn xˌi ɗˌeɜn t0ˈaj ŋˈyə2j t0ˈiɛw zˈu2ŋ mˈaːŋ lˈaː6j ɲˈiɛ2w lˈəː6j ˈiɜc ɗˈoɜj vˌəːɜj kˈaː4 zwˈe-ɲ ŋˈiɛ6p vˌaː2 ŋˈyə2j t0ˈiɛw zˈu2ŋ . |0 +dataset/Xanh24h/speaker_0/152.wav|nˌeɜw kˌaːɜc bˈaː6n kˈɔɜ mˈo6t0 zˈiɛ6n t0ˈiɜc vˈyə2n fˈu2 hˈəː6p ɗˌe4 tʃˈiɛ4n xˈaːj mˈo hˈi2ɲ nˈa2j tˌi2 ɗˈəɪ hwˈaː2n t0wˈaː2n lˌaː2 mˈo hˈi2ɲ lˈiɜ t0ˈyə4ŋ , kˈɔɜ tˈe4 zˈuɜp bˈaː2 kˌɔn lˈaː2m zˈa2w . |0 +dataset/Xanh24h/speaker_0/154.wav|t0wˈi ɲˈiɛn , zˌu2 bˈaː6n lˌaː2 ŋˈyə2j bˈaːɜn hˈaː2ŋ ˈɒnlaɪn lˈə1w nˈam hˈaj ɗˌaːŋ tʃwˈə4n bˌi6 xˈəː4j ŋˈiɛ6p , tˌi2 hˈa5j t0ˈin zˈa2ŋ kˈəː hˈo6j ɗˌe4 fˈaːɜt0 tʃˈiɛ4n kˌuə4 lˈi5ɲ vˈy6c kˈiɲ zwˈe-ɲ ˈɒnlaɪn vˌə5n kˌɔ2n zˈəɜt0 lˈəːɜn . |0 +dataset/Xanh24h/speaker_0/159.wav|tʃˈɔŋ xˌi mˈo6t0 bˈo6 fˈə6n ɲˈɔ4 zˈən sˈoɜ sˈoɜŋ tʃˈɔŋ ɲˈuŋ lˈuə6 , tˌi2 fˈə2n lˈəːɜn zˈən sˈoɜ kˌɔ2n lˈaː6j vˌə5n fˌaː4j vˈə6t0 lwˈə6n vˌəːɜj kˈuə6c sˈoɜŋ ŋˈɛ2w xˈɔɜ . |0 +dataset/Xanh24h/speaker_0/164.wav|bˈaː6n kˈu5ŋ nˌen sˈəɪ zˈy6ŋ mˈoɜj kwˈaːn hˈe6 t0ˈoɜt0 vˌəːɜj kˌaːɜc ɲˈaː2 kˈuŋ kˈəɜp ɗˌe4 ɗˌyə6c hˈyə4ŋ ˈiw ɗˈaː5j vˈe2 zˈaːɜ kˈaː4 vˌaː2 tʃˈəɜt0 lˈyə6ŋ sˈaː4n fˈə4m . |0 +dataset/Xanh24h/speaker_0/169.wav|kˌaːɜc lwˈaː6j kwˈaː4 t0ˈa6ŋ ɗˈo2 fˈɔŋ twˈi4 ɲˌy t0ˈyə6ŋ tˈə2n t0ˈaː2j , tʃˈe-ɲ fˈɔŋ twˈi4 kˈu5ŋ lˌaː2 ɲˌy5ŋ mˈa6t0 hˈaː2ŋ ɗˌyə6c ɲˈiɛ2w ŋˈyə2j mˈuə vˈaː2w ŋˈa2j fˈiəɜ tˈə2n t0ˈaː2j . |0 +dataset/Xanh24h/speaker_0/170.wav|vˌəːɜj lˈyə6ŋ ŋˈyə2j zˈu2ŋ xˈo4ŋ lˈo2 , tˈɪk tˈɒk tʃˈəː4 tˈe-2ɲ mˈo6t0 kˈeɲ bˈaːɜn hˈaː2ŋ t0ˈiɛ2m nˈaŋ tʃˌɔ kˌaːɜc zwˈe-ɲ ŋˈiɛ6p , kˈaːɜ ɲˈən kˈiɲ zwˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/178.wav|vˌi2 vˈəɪ6 , hˈə2w hˈeɜt0 kˌaːɜc xˈe-ɜc sˈaː6n hˈaj ɲˈaː2 hˈaː2ŋ vˈyə2 vˌaː2 ɲˈɔ4 lˈuən sˈa5n sˈaː2ŋ t0wˈiɛ4n zˈu6ŋ ɲˌy5ŋ ɲˈən vˈiɛn tʃˌyə kˈɔɜ kˈiɲ ŋˈiɛ6m ɗˌe4 ɗˈaː2w t0ˈaː6w lˈaː6j . |0 +dataset/Xanh24h/speaker_0/179.wav|t0ˈiɛ2n zˈaː4 vˌaː2 vˈu5 xˈiɜ hwˈi4 zˈiɛ6t0 hˈaː2ŋ lwˈaː6t0 . kˈɔɜ mˈo6t0 sˈoɜ ŋˈuə2n kˈɔɜ tˈe4 kˈuŋ kˈəɜp tˈoŋ t0ˈin vˈe2 t0ˈaː2j sˈaː4n kˌuə4 kˈim ʒˈɔŋˈun . mˈo6t0 ŋˈuə2n lˌaː2 lˈiɛn hˈəː6p kˈuəɜc . |0 +dataset/Xanh24h/speaker_0/185.wav|tʃˈɔŋ kwˈaːɜ tʃˈi2ɲ xˈaːɜm fˈaːɜ tˈi6 tʃˈyə2ŋ , kwˈaːn tʃˈɔ6ŋ ɲˈəɜt0 lˌaː2 bˈaː6n nˌen zˈe-2ɲ tˈəː2j zˈaːn vˌaː2 kˈoŋ sˈyɜc ɗˌe4 tˈy6c hˈiɛ6n mˈo6t0 ŋˈiɛn kˈiɜw tʃˈi t0ˈiɛɜt0 . |0 +dataset/Xanh24h/speaker_0/194.wav|ɗˈəɪ lˌaː2 mˈo6t0 tʃˈɔŋ ɲˌy5ŋ kˈə1w hˈɔ4j zˈəɜt0 hˈaj vˌaː2 t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˌɛ5 ɗˌyə6c tʃˈaː4 lˈəː2j kˈə1w hˈɔ4j nˈa2j bˈa2ŋ ɲˌy5ŋ kˈiɲ ŋˈiɛ6m mˌaː2 tʃˈuɜŋ t0ˈoj kˈɔɜ vˌaː2 t0ˈi2m hˈiɛ4w ɗˌyə6c . |0 +dataset/Xanh24h/speaker_0/197.wav|vˈaː2ŋ tˈɔ4j lˌaː2 bˈiɛ4w t0ˈyə6ŋ kˌuə4 sˈy6 zˈa2w kˈɔɜ , sˈuŋ t0ˈuɜc . vˈaː2ŋ tˈɔ4j tˈyə2ŋ ɗˌyə6c ɗˈa6t0 ˈəː4 bˈaː2n tˈəː tˈə2n t0ˈaː2j , tˈo4 ɗˈiə6 , hwˌa6c tʃˈaːŋ tʃˈiɜ tʃˈɔŋ ɲˈaː2 . |0 +dataset/Xanh24h/speaker_0/199.wav|tʃˈi4 ɲˌy5ŋ ˈoŋ tʃˈu2m tˈəː2j tʃˈaːŋ ɲˌy zˈaːlf lˈawzɛn hˈaj ɲˈaː2 sˈaː4n swˈəɜt0 fˈim nˈo4j t0ˈiɛɜŋ dʒˈɛɹəʊm ɐlˈeɪn dʒˈɛɹi ɗˌe4 kˈɔɜ tˈe4 sˈiw t0ˈə2m ɲˌy5ŋ tʃˈiɛɜc sˈɛ ɲˌy vˈəɪ6 . |0 +dataset/Xanh24h/speaker_0/203.wav|bˈyəɜc nˈa2j ɗˈɔɜŋ ɣˈɔɜp vˈaː2w vˈiɛ6c t0ˈaː6w ˈəɜn t0ˈyə6ŋ t0ˈiɜc kˈy6c vˌəːɜj xˈe-ɜc hˈaː2ŋ , nˈəŋ kˈaːw sˈy6 kˈe-6ɲ tʃˈe-ɲ kˌuə4 kˈyə4 hˈaː2ŋ lˈəʊkəl bɹˈand vˌaː2 t0ˌy2 ɗˈɔɜ t0ˈaŋ kˈyə2ŋ zwˈe-ɲ tˈu vˌaː2 lˈəː6j ɲwˈə6n mˈo6t0 kˈe-ɜc hˈiɛ6w kwˈaː4 . |0 +dataset/Xanh24h/speaker_0/212.wav|t0wˈi ɲˈiɛn , tʃˈɔŋ zˈaːj ɗwˈaː6n zˈi6c kˈɒvɪd mˈyə2j tʃˈiɜn bˈu2ŋ fˈaːɜt0 , kˈə1w tʃwˈiɛ6n kˈe1w ɣˈɔ6j zˈaː4j kˈiɜw tˈe-ɲ lˈɔŋ ɗˈɔ4 ɣˈəɪ sˈoɜt0 zˈəːɜj tʃwˈiɛ2n tˈoŋ kˈaː4 tʃˈɔŋ vˌaː2 ŋwˈaː2j nˈyəɜc . |0 +dataset/Xanh24h/speaker_0/213.wav|ŋˈaj bˈəɪ zˈəː2 , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˌɛ5 tʃˈo4 t0ˈaː2j hˈyəɜŋ zˈə5n kˌaːɜc bˈaː6n mˈo6t0 sˈoɜ mˈɔɜn ˈan ɗˈəːn zˈaː4n , ɲˌyŋ kˈu5ŋ xˌoŋ kˈɛɜm fˈə2n hˈəɜp zˈə5n t0ˌy2 kwˈaː4 tˈe-ɲ lˈɔŋ zˈuə6t0 ɗˈɔ4 ɲˈɛɜ . |0 +dataset/Xanh24h/speaker_0/218.wav|nˌeɜw bˈaː6n ɗˌaːŋ mˈuəɜn t0ˈi2m kˈiɛɜm mˈo6t0 ˈiɜ t0ˈyə4ŋ kˈiɲ zwˈe-ɲ mˌaː2 tʃˌyə bˈiɛɜt0 nˌen bˈaːɜn ɗˈo2 ˈan t0ˈeɜt0 zˈi2 mˌaː2 vˈoɜn ˈiɜt0 lˈəː2j ɲˈiɛ2w , hˈa5j tˈaːm xˈaː4w ŋˈaj t0ˈɔp bˈa4j mˈɔɜn ˈan sˈaw ɗˈəɪ ɲˈɛɜ ! |0 +dataset/Xanh24h/speaker_0/219.wav|kˌaːɜc zˈi6c vˈu6 nˈa2j sˌɛ5 zˈuɜp bˈaː6n tʃwˈə4n bˌi6 mˈəm kˈuɜŋ ɗˈəɪ2 ɗˈu4 , tʃˈuɜ ɗˈaːɜw , ɗˈuɜŋ fˈɔŋ t0ˈu6c . ɗˌe4 kˈiɲ zwˈe-ɲ zˈi6c vˈu6 nˈa2j tˈe-2ɲ kˈoŋ , bˈaː6n kˈə2n lˈiw ˈiɜ ɲˌy5ŋ vˈəɜn ɗˈe2 sˈaw . |0 +dataset/Xanh24h/speaker_0/220.wav|t0wˈi ɲˈiɛn , xˌi kwˈiɛɜt0 ɗˈi6ɲ tˈy6c hˈiɛ6n ˈiɜ t0ˈyə4ŋ nˈa2j , kˈə2n tʃˈuɜ ˈiɜ ɗˌeɜn vˈiɛ6c lˈyə6 tʃˈɔ6n ŋˈuə2n kˈuŋ tʃˈən ɣˈaː2 vˌaː2 kˈe-ɜɲ ɣˈaː2 kˈɔɜ ŋˈuə2n ɣˈoɜk zˈɔ5 zˈaː2ŋ ɗˌe4 ɗˈaː4m bˈaː4w vˈe6 sˈiɲ vˌaː2 ˈaːn t0wˈaː2n . |0 +dataset/Xanh24h/speaker_0/228.wav|ˈə4m tˈy6c vˈiɛ6t0 nˈaːm lˈuən ɗˌyə6c bˈiɛɜt0 ɗˌeɜn vˌəːɜj sˈy6 ɗˈaː zˈaː6ŋ vˌaː2 fˈɔŋ fˈuɜ , tʃˈɔŋ ɗˈɔɜ kˈɔɜ ɲˌy5ŋ mˈɔɜn ˈan vˈa6t0 tˈəːm ŋˈɔn , ɗˈə6m vˈi6 , xˈɔɜ kˈyə5ŋ . |0 +dataset/Xanh24h/speaker_0/235.wav|sˈaː2n tˈyəŋ mˈaː6j ɗˈiɛ6n t0ˈy4 ɗˌaː5 tʃˈəː4 tˈe-2ɲ mˈo6t0 sˈu hˈyəɜŋ kˈiɲ zwˈe-ɲ fˈo4 bˈiɛɜn tʃˈɔŋ ɲˌy5ŋ nˈam ɣˈə2n ɗˈəɪ , ɗˈa6c bˈiɛ6t0 lˌaː2 tʃˈɔŋ vˌaː2 sˈaw tˈəː2j kˈi2 ɗˈaː6j zˈi6c kˈɒvɪd mˈyə2j tʃˈiɜn . |0 +dataset/Xanh24h/speaker_0/240.wav|ŋwˈaː2j zˈaː , bˈaː6n kˈu5ŋ kˈɔɜ tˈe4 lˈyə6 tʃˈɔ6n kˈiɲ zwˈe-ɲ kwˈə2n ˈaːɜw tʃˈɛ4 ˈɛm tˈɛw t0ˈy2ŋ tˈyəŋ hˈiɛ6w , tʃˈəɜt0 lˈiɛ6w hwˌa6c fˈɔŋ kˈe-ɜc tˈəː2j tʃˈaːŋ . |0 +dataset/Xanh24h/speaker_0/244.wav|tʃˈɔŋ ɲˌy5ŋ nˈam kwˈaː , ɣˈy4j t0ˈiɛɜt0 kˈiɛ6m t0ˈaː6j ŋˈən hˈaː2ŋ lˈuən lˌaː2 kˈeɲ ɗˈə2w t0ˈy ˈaːn t0wˈaː2n , hˈiɛ6w kwˈaː4 vˌaː2 ɗˈɛm lˈaː6j lˈaː5j swˈəɜt0 kˈaːw , zˈe5 tˈy6c hˈiɛ6n ɗˈoɜj vˌəːɜj kˌaːɜc ɲˈaː2 ɗˈə2w t0ˈy ɲˈɔ4 . |0 +dataset/Xanh24h/speaker_0/249.wav|sˈy6 twˈə6n t0ˈiɛ6n vˌaː2 t0ˈoɜk ɗˈo6 fˈu6c vˈu6 kˌuə4 ɗˈo2 ˈan ɲˈe-ɲ ɗˌaː5 t0ˈaː6w nˌen mˈo6t0 sˈu hˈyəɜŋ ɗˈa6c bˈiɛ6t0 mˈe-6ɲ mˈɛ5 vˌaː2 ɗˈəɪ kˈu5ŋ tʃˈiɜɲ lˌaː2 lˈiɜ zˈɔ . |0 +dataset/Xanh24h/speaker_0/253.wav|xˌi mˈuə ɗˌyə6c tˈe-ɲ lˈɔŋ zˈaːɜ zˈɛ4 , tʃˈəɜt0 lˈyə6ŋ t0ˈoɜt0 , tʃˈi6 ŋˈɔ6k ɗˌaː5 t0ˈi2m hˈiɛ4w vˌaː2 bˈiɛɜn t0ˈəɜw kˌaːɜc mˈɔɜn ˈan tʃwˈiɛ2n tˈoɜŋ tʃˈəː4 nˌen ɗˈo6k ɗˈaːɜw hˈəːn xˌi kˈeɜt0 hˈəː6p kˈu2ŋ tˈe-ɲ lˈɔŋ ɗˈɔ4 . |0 +dataset/Xanh24h/speaker_0/259.wav|tˈɛw tˈoŋ t0ˈin t0ˈoj t0ˈi2m hˈiɛ4w ɗˌyə6c , zˈoɜŋ ˈoɜk mˌaː2 hwˈaː2ŋ mˈe-6ɲ kˈyə2ŋ nˈuəj lˌaː2 zˈoɜŋ ˈoɜk ɲˈo2j t0ˈaː , kˌɔ2n ɗˌyə6c ɣˈɔ6j lˌaː2 ˈoɜk bˈiw t0ˈaː . |0 +dataset/Xanh24h/speaker_0/276.wav|ŋwˈaː2j zˈaː , mˈo6t0 ˈiɜ t0ˈyə4ŋ xˈaːɜc vˈe2 bˈe-ɜɲ zˈaːɜn kˈɔɜ tˈe4 lˌaː2 bˈe-ɜɲ zˈaːɜn dˈɔːɹiːmən , mˈo6t0 sˈaː4n fˈə4m hˈəɜp zˈə5n ɗˈa6c bˈiɛ6t0 tˈu hˈuɜt0 ɗˈoɜj t0ˈyə6ŋ tʃˈɛ4 kˌɔn vˌaː2 hˈɔ6k sˈiɲ . |0 +dataset/Xanh24h/speaker_0/278.wav|ɣˈaː2 ɗˈoŋ t0ˈaː4w lˌaː2 mˈo6t0 tʃˈɔŋ ɲˌy5ŋ lwˈaː6j ɣˈaː2 kwˈiɜ hˈiɛɜm lˈə1w ɗˈəː2j , t0ˈy2ŋ ɗˌyə6c t0ˈa6ŋ tʃˌɔ kˌaːɜc vˈi6 vˈuə vˌaː2 tʃˈuəɜ ɗˌe4 tˈyə4ŋ tˈyɜc . |0 +dataset/Xanh24h/speaker_0/279.wav|ɗˈiɛ2w nˈa2j zˈuɜp tˈyəŋ hˈiɛ6w tˈuɜ hˈuɜt0 mˈo6t0 kˈe-ɜc hˈiɛ6w kwˈaː4 ɲˈɔɜm xˈe-ɜc hˈaː2ŋ mˈu6c t0ˈiɛw , t0ˈaː6w nˌen sˈy6 hˈəɜp zˈə5n vˌaː2 ɗˈo6k ɗˈaːɜw tʃˈɔŋ tˈi6 tʃˈyə2ŋ ɗˈəɪ2 kˈe-6ɲ tʃˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/281.wav|tˈəː2j ɗˈiɛ4m bˈaːn ɗˈə2w , ˈoŋ sˈəm sˈəɪ bˈaː bˈe4 nˈuəj vˌəːɜj t0ˈo4ŋ zˈiɛ6n t0ˈiɜc bˈaː tʃˈam mˈɛɜt0 vˈuəŋ , tˈaː4 hˈəːn sˈaɜw ŋˈi2n kˌɔn kˈaːɜ zˈoɜŋ . |0 +dataset/Xanh24h/speaker_0/282.wav|tˈɛw zˈɔ5j hˈiɛ6w swˈəɜt0 tʃˈiɛɜn zˈi6c , lˈaɜŋ ŋˈɛ fˈaː4n hˈo2j t0ˌy2 xˈe-ɜc hˈaː2ŋ vˌaː2 t0ˈoɜj ˈiw hwˈaːɜ tʃˈiɛɜn lˈyə6c kwˈaː4ŋ kˈaːɜw kˌuə4 bˈaː6n tˈɛw tˈəː2j zˈaːn ɗˌe4 ɗˈaː6t0 ɗˌyə6c kˈeɜt0 kwˈaː4 t0ˈoɜt0 ɲˈəɜt0 . |0 +dataset/Xanh24h/speaker_0/306.wav|bˈaː6n kˈə2n tˈy6c hˈiɛ6n kˌaːɜc hwˈaː6t0 ɗˈo6ŋ t0ˈiɛɜp tˈi6 vˌaː2 kwˈaː4ŋ bˈaːɜ ɗˌe4 tˈu hˈuɜt0 hˈɔ6k vˈiɛn , tʃˌa4ŋ hˈaː6n ɲˌy tʃˈa6j kwˈaː4ŋ kˈaːɜw , tˈaːm zˈaː kˌaːɜc hˈo6j ɲˈɔɜm lˈaː2m bˈe-ɜɲ . |0 +dataset/Xanh24h/speaker_0/310.wav|ŋwˈaː2j zˈaː , lˈaːɜ sˈaː4 sˈaw xˌi ɗˌaː5 t0ˈe-ɜc t0ˈiɲ zˈə2w , ɗˌyə6c bˈaː2 kˌɔn zˈu2ŋ ɗˈun tˈaj kˈu4j , zˈu2ŋ lˈaː2m fˈən hˈi5w kˈəː bˈɔɜn ŋˈo , lˈuəɜ , t0ˈiɛɜt0 kˈiɛ6m t0ˈoɜj ɗˈaː tʃˈi fˈiɜ sˈaː4n swˈəɜt0 . |0 +dataset/Xanh24h/speaker_0/319.wav|tˈoŋ t0ˈin vˈe2 zˈoɜŋ bˈiɜ ɗˈo6k lˈaː6 zˈoɜŋ sˈəː6j mˈi2 xˌoŋ zˈɔ5 zˈaː2ŋ vˌaː2 kˈɔɜ tˈe4 lˌaː2 mˈo6t0 hˈiɛ6n t0ˈyə6ŋ ɗˈa6c bˈiɛ6t0 hwˌa6c hˈiɛɜm ɣˈa6p tʃˈɔŋ nˈoŋ ŋˈiɛ6p . |0 +dataset/Xanh24h/speaker_0/329.wav|tʃˈi4 kˈə2n ɗˈi kwˈaː ɲˌy5ŋ kˌɔn fˈoɜ lˈəːɜn , bˈaː6n sˌɛ5 zˈe5 zˈaː2ŋ bˈaɜt0 ɣˈa6p ɲˌy5ŋ ɲˈɔɜm bˈaː6n ŋˈyə2j ɗˈi ɗˈyə2ŋ ɗˌaːŋ ŋˈo2j ɲˈəm ɲˈi bˈen bˈeɜp tˈaː2n hˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/330.wav|t0ˈɔɜm lˈaː6j , vˈiɛ6c bˈaː4w kwˈaː4n sˈe-ɜc vˌaː2 kwˈaː4n lˈiɜ xˈɔ sˈe-ɜc lˌaː2 ɲˌy5ŋ ˈiɛɜw t0ˈoɜ vˈoɜn kwˈaːn tʃˈɔ6ŋ kwˈiɛɜt0 ɗˈi6ɲ sˈy6 tˈe-2ɲ kˈoŋ kˌuə4 hˈiɛ6w sˈe-ɜc . |0 +dataset/Xanh24h/speaker_0/336.wav|t0wˈi tʃˌyə ɗˌyə6c fˈo4 bˈiɛɜn zˈo6ŋ zˈaː5j , ɲˌyŋ zˈɔ2ŋ sˈaː4n fˈə4m t0ˈoɜt0 tʃˌɔ sˈyɜc xwˈɛ4 nˈa2j lˈuən ɲˈə6n ɗˌyə6c sˈy6 lˈaːn t0wˈaː4 vˌaː2 hˈyə4ŋ ˈyɜŋ lˈəːɜn t0ˌy2 ɗˈoŋ ɗˈaː4w xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/337.wav|xˌoŋ kˈɔɜ kˌɔn sˈoɜ kˈu6 tˈe4 vˈe2 vˈoɜn kˈiɲ zwˈe-ɲ xˈəː4j ɗˈiɛ4m mˌaː2 nˈɔɜ sˌɛ5 zˈaːw ɗˈo6ŋ t0ˌy2 vˈaː2j tʃˈu6c tʃˈiɛ6w tʃˌɔ t0ˌəːɜj vˈaː2j tʃˈam tʃˈiɛ6w ɗˈo2ŋ , t0wˈi2 tˈuə6c vˈaː2w mˈu6c ɗˈiɜc kˈiɲ zwˈe-ɲ xˈaːɜc ɲˈaw kˌuə4 t0ˈy2ŋ ŋˈyə2j . |0 +dataset/Xanh24h/speaker_0/338.wav|ɗˌe4 t0ˈi2m kˈiɛɜm ɲˌy5ŋ mˈɔɜn kwˈaː4 vˈə6t0 bˈi2ɲ zˈən nˈa2j , bˈaː6n tʃˈi4 kˈə2n zˈaː6w kwˈaː kˌaːɜc vˈiə4 hˈɛ2 ˈəː4 hˈaː2 nˈo6j , nˈəːj mˌaː2 bˈəɜt0 kˈi2 ɗˈə1w kˈu5ŋ kˈɔɜ tˈe4 t0ˈi2m tˈəɪɜ . |0 +dataset/Xanh24h/speaker_0/346.wav|xˌi ɲˈə6n hˈaː2ŋ , kˈyə4 hˈaː2ŋ kˈə2n ɲˈe-ɲ tʃˈɔɜŋ tʃwˈiɛ4n hˈaː4j sˈaː4n vˈaː2w tˈu2ŋ sˈoɜp , ɗˈaːɜ hwˌa6c bˈe4 sˈu6c nˈyəɜc bˈiɛ4n ɗˌe4 bˈaː4w kwˈaː4n . |0 +dataset/Xanh24h/speaker_0/349.wav|bˈaː6n kˈə2n tʃˈɔ6n ɗˌyə6c vˈi6 tʃˈiɜ tˈiɜc hˈəː6p ɗˌe4 lˈaː2m ɲˈaː2 vˌaː2 kˈə2n fˌaː4j ɗˈaː4m bˈaː4w kˈɔɜ t0ˈə2m hˈaːj tʃˈam nˈam mˈyəj kˌɔn tʃˈim ˈiɛɜn , tˌi2 vˈiɛ6c ɗˈə2w t0ˈy kˈi5 twˈə6t0 mˈəːɜj mˈaːŋ lˈaː6j kˈeɜt0 kwˈaː4 kˈaːw . |0 +dataset/Xanh24h/speaker_0/353.wav|zˈu2ŋ kˈəɪ ɣˈaɜp ɲˈɔ4 ɣˈim zˈe5 kˈəɪ ɲˈɛ6 sˈuəɜŋ zˈyəɜj lˈəːɜp kˈaːɜt0 sˈɔ4j ɗˌe4 kˈəɪ hˈuɜt0 vˈən vˌaː2 sˈiɲ tʃˈyə4ŋ , t0ˈaː6w mˈoj tʃˈyə2ŋ sˈiɲ tˈaːɜj tʃˈɔŋ sˈe-6c tʃˌɔ hˈo2 nˈuəj . |0 +dataset/Xanh24h/speaker_0/354.wav|bˈaː6n kˈə2n bˈiɛɜt0 ˈiɜ ŋˈiə5 kˌuə4 ŋˈa2j vˈiəɜ tˈə2n t0ˈaː2j , kˌaːɜc lˈe5 vˈə6t0 kˈə2n kˈɔɜ tʃˈɔŋ mˈəm kˈuɜŋ tˈə2n t0ˈaː2j , kˈe-ɜc kˈuɜŋ tˈə2n t0ˈaː2j ɗˈuɜŋ kˈe-ɜc . |0 +dataset/Xanh24h/speaker_0/355.wav|kˈiɲ zwˈe-ɲ bˈa2ŋ kwˈəɪ2 sˈaɜt0 bˈaːɜn bˈe-ɜɲ tʃˈaːɜŋ tʃˈo6n tˌi2 tʃˈi fˈiɜ tʃˌɔ mˈo6t0 fˈə2n bˈe-ɜɲ tʃˈaːɜŋ tʃˈo6n lˌaː2 mˈyə2j ŋˈi2n ɗˈo2ŋ bˈaː6n bˈaːɜn vˌəːɜj zˈaːɜ mˈyə2j lˈam ŋˈi2n ɗˈo2ŋ sˌɛ5 tˈu lˈəː2j nˈam ŋˈi2n ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/363.wav|ŋwˈaː2j zˈaː , mˈoj tʃˈyə2ŋ sˈoɜŋ kˌuə4 tʃˈim kˈuɜt0 kˈə2n ɗˌyə6c ɗˈaː4m bˈaː4w ˈiɛn t0ˈi5ɲ , tʃˈe-ɜɲ t0ˈiɛɜŋ ˈo2n vˌaː2 ˈe-ɜɲ sˈaːɜŋ mˈe-6ɲ ɗˌe4 xˌoŋ ˈe-4ɲ hˈyə4ŋ ɗˌeɜn hwˈaː6t0 ɗˈo6ŋ sˈiɲ sˈaː4n . |0 +dataset/Xanh24h/speaker_0/365.wav|ŋwˈaː2j zˈaː kˌaːɜc lwˈaː6j kˈɔ4 tʃˈo2ŋ ɲˌy kˈɔ4 sˈaː4 lˈaːɜ ɲˈɔ4 , kˈɔ4 zˈu zˈi , kˈɔ4 kˈaɪn kˈu5ŋ lˌaː2 tˈyɜc ˈan xwˈaːɜj xˈə4w kˌuə4 zˈeɜ mˈɛn . |0 +dataset/Xanh24h/speaker_0/366.wav|nˌeɜw bˈaː6n mˈuəɜn tˈe-2ɲ kˈoŋ tʃˈɔŋ kˈiɲ zwˈe-ɲ nˈa2j , bˈaː6n kˈə2n t0ˈə6p tʃˈuŋ vˈaː2w vˈiɛ6c kˈaː4j tˈiɛ6n tʃˈəɜt0 lˈyə6ŋ vˌaː2 sˈəɪ zˈy6ŋ zˈe-ɲ t0ˈiɛɜŋ tˈyəŋ hˈiɛ6w t0ˈoɜt0 . |0 +dataset/Xanh24h/speaker_0/371.wav|ɗˌeɜn vˌəːɜj vˈɪdɪəʊ nˈa2j , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˈin ɣˈy4j ɗˌeɜn kˌaːɜc bˈaː6n tˈoŋ t0ˈin vˈe2 mˈo6t0 zˈoɜŋ kˈaːɜ zˈuɜp ŋˈyə2j nˈoŋ zˈən tˈu vˈe2 t0ˈiɛ2n tʃˈiɛ6w mˌo5j ŋˈa2j . |0 +dataset/Xanh24h/speaker_0/378.wav|zˈɔ ɗˈɔɜ , t0ˈə6n zˈu6ŋ tˈəː2j kˈəː nˈa2j ɗˌe4 bˈaːɜn zˈu6ŋ kˈu6 t0ˈə6p tˈe4 tˈaːw t0ˈaː6j ɲˈaː2 lˌaː2 kˈəː hˈo6j t0ˈoɜt0 ɗˌe4 tˈu ɗˌyə6c lˈəː6j ɲwˈə6n kˈaːw tʃˌɔ ŋˈyə2j kˈiɲ zwˈe-ɲ ˈɒnlaɪn . |0 +dataset/Xanh24h/speaker_0/380.wav|ˈəː4 ɣˈɔɜk ɗˈo6 kˌuə4 ŋˈyə2j lˈaː2m mˈɑːkɪtɪŋ , ɗˈəɪ lˌaː2 mˈo6t0 lˈəː6j tˈeɜ , vˌi2 xˌi ŋˈyə2j zˈu2ŋ hwˈaː6t0 ɗˈo6ŋ kˈaː2ŋ lˈə1w , t0ˈə2n swˈəɜt0 t0ˈiɛɜp kˈə6n ɗˌyə6c t0ˌəːɜj kwˈaː4ŋ kˈaːɜw kˈaː2ŋ t0ˈaŋ kˈaːw . |0 +dataset/Xanh24h/speaker_0/393.wav|tˈɛw ˈe-ɲ ɗˈyɜc , tʃˈɔŋ bˈəɜt0 kˈyɜ mˈo hˈi2ɲ tʃˈaːŋ nˈuəj nˈaː2w , tˌi2 kˌɔn sˈoɜŋ vˌaː2 tˈyɜc ˈan lˌaː2 ˈiɛɜw t0ˈoɜ kwˈiɛɜt0 ɗˈi6ɲ ɗˌeɜn vˈiɛ6c tˈe-2ɲ , bˈaː6j . |0 +dataset/Xanh24h/speaker_0/406.wav|vˌəːɜj hˈaː2m lˈyə6ŋ mˈeɪz vˌaː2 tʃˈəɜt0 sˈəː zˈo2j zˈaː2w vˌaː2 kˈalə kˈy6c tˈəɜp , tˈe-ɲ lˈɔŋ kˈu5ŋ lˌaː2 lwˈaː6j tʃˈaːɜj kˈəɪ kˈɔɜ t0ˈaːɜc zˈu6ŋ zˈəɜt0 t0ˈoɜt0 tʃˈɔŋ zwˈi tʃˈi2 kˈən ɗˈa6ŋ vˌaː2 zˈy5 zˈi2n vˈɔɜk zˈaːɜŋ . |0 +dataset/Xanh24h/speaker_0/407.wav|mˈa6c zˌu2 kˈɔɜ sˈy6 bˈiɛɜn ɗˈo6ŋ , tʃˈi fˈiɜ tʃˈuŋ bˈi2ɲ ɲˈə6p hˈaː2ŋ mˈəːɜj tʃˌɔ kˈyə4 hˈaː2ŋ ɗˈo2 tʃˈəːj tʃˈɛ4 ˈɛm tˈyə2ŋ nˈa2m tʃˈɔŋ xwˌaː4ŋ nˈam mˈyəj ɗˌeɜn mˈo6t0 tʃˈam tʃˈiɛ6w ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/409.wav|ɗˈəɪ ɗˌyə6c kˈɔj lˌaː2 mˈo6t0 kˈe-ɜc lˈaː2m zˈa2w ˈəː4 nˈoŋ tˈon nˈa2j kˈɔɜ tˈe4 bˈiɛɜn bˈaː6n tˈe-2ɲ tʃˈiɛ6w fˈuɜ ɲˈəː2 fˈyəŋ fˈaːɜp t0ˈi2m mˈuəɜj bˈɔ4 sˈi4 , zˈaːɜ ɣˈoɜk vˌaː2 bˈaːɜn lˈaː6j kˈiɛɜm lˈəː2j . |0 +dataset/Xanh24h/speaker_0/412.wav|nˌeɜw bˈaː6n ˈiɛw tˈiɜc ɗˈaːn lˈɛn vˌaː2 kˈɔɜ t0ˈaj ŋˈe2 t0ˈoɜt0 , bˈaː6n kˈɔɜ tˈe4 bˈiɛɜn sˈəː4 tˈiɜc kˌuə4 mˈi2ɲ tˈe-2ɲ mˈo6t0 zwˈe-ɲ ŋˈiɛ6p ɲˈɔ4 kˈɔɜ tˈe4 t0ˈaː6w zˈaː lˈəː6j ɲwˈə6n bˈaːɜn tˈəː2j zˈaːn . |0 +dataset/Xanh24h/speaker_0/415.wav|bˈaː6n tˈaːm xˈaː4w vˌaː2 lˈyə6 tʃˈɔ6n tʃˌɔ mˈi2ɲ mˈa6t0 hˈaː2ŋ bˈaːɜn zˈi2 vˈaː2w zˈi6p t0ˈeɜt0 fˈu2 hˈəː6p vˌəːɜj ɗˈiɛ2w kˈiɛ6n , ŋˈuə2n vˈoɜn kˈu5ŋ ɲˌy tˈy6c t0ˈeɜ tˈəː2j zˈaːn bˈaːɜn hˈaː2ŋ kˌuə4 mˈi2ɲ ɗˌe4 kˈɔɜ lˈəː6j ɲwˈə6n t0ˈoɜt0 ɲˈəɜt0 . |0 +dataset/Xanh24h/speaker_0/416.wav|ɗˈo2ŋ tˈəː2j , tʃˈiɛɜn lˈyə6c nˈa2j zˈuɜp t0ˈaŋ kˈyə2ŋ zwˈe-ɲ tˈu ɲˈe-ɲ tʃˈɔɜŋ , hˈəː6p zˈə5n kˈaː4 ŋˈyə2j t0ˈiɛw zˈu2ŋ tʃˈy6c t0wˈiɛɜn vˌaː2 ˈɔ ˈɛɜp ˈɛɜp ˈɛləː2 ˈi ˈɛnəː2 ˈɛ , t0ˈaː6w nˌen mˈo6t0 tʃˈiɛɜn lˈyə6c kˈiɲ zwˈe-ɲ t0wˈaː2n zˈiɛ6n . |0 +dataset/Xanh24h/speaker_0/417.wav|tʃˈuɜŋ kˈɔɜ ŋwˈaː6j hˈi2ɲ ɗˈa6c bˈiɛ6t0 vˌəːɜj bˈo6 lˈoŋ mˈyə6t0 mˌaː2 , mˈa2w sˈaɜc sˈaː6c zˈəː5 , ɗˈoj mˈaɜt0 t0ˈɔ tʃˈɔ2n vˌaː2 tʃˈiɛɜc mˈa2w t0ˈɔ ɲˌy tʃˈiɛɜc vˈyəŋ mˈiɛ6n . |0 +dataset/Xanh24h/speaker_0/419.wav|vˈe2 tʃˈəɜt0 lˈyə6ŋ sˈaː4n fˈə4m , ɗˈoɜj t0ˈaːɜc wˈi t0ˈiɜn sˌɛ5 kˈɔɜ ɗˈo6j ŋˈu5 ɲˈən vˈiɛn lˈe-2ɲ ŋˈe2 , sˈy4 zˈu6ŋ tʃˈəɜt0 lˈiɛ6w kˈaːw kˈəɜp vˌaː2 ɗˈaːɜp ˈyɜŋ kˌaːɜc t0ˈiɛw tʃwˈə4n tʃˈəɜt0 lˈyə6ŋ . |0 +dataset/Xanh24h/speaker_0/422.wav|bˈaː6n kˈɔɜ tˈe4 sˈy4 zˈu6ŋ kˌaːɜc bˈaː4ŋ hˈiɛ6w , ɗˈɛ2n lˈɛd hwˌa6c kˌaːɜc vˈə6t0 lˈiɛ6w tʃˈaːŋ tʃˈiɜ xˈaːɜc ɗˌe4 t0ˈaː6w ɗˈiɛ4m ɲˈəɜn tʃˌɔ mˈa6t0 t0ˈiɛ2n kˈyə4 hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/429.wav|zˈaː ɗˈi2ɲ tʃˈi6 fˈaː6m tˈi6 hˈo2ŋ t0ˈaː6j fˈoɜ hˈo2ŋ sˈəːn , tˈi6 tʃˈəɜn kˈe-4ɲ nˈaː2ŋ , hwˈiɛ6n bˈaːɜ tˈyəɜc lˌaː2 mˈo6t0 tʃˈɔŋ ɲˌy5ŋ hˈo6 nˈuəj t0ˈə2m lˈaːɜ sˈaɜn ɲˈiɛ2w ɲˈəɜt0 ˈəː4 xˈu vˈy6c nˈa2j . |0 +dataset/Xanh24h/speaker_0/434.wav|tʃˈi4 kˈə2n sˈoɜ t0ˈiɛ2n vˈoɜn bˈɔ4 zˈaː bˈaːn ɗˈə2w t0ˌy2 mˈyə2j ɗˌeɜn mˈyə2j lˈam tʃˈiɛ6w ɗˈo2ŋ lˌaː2 bˈaː6n ɗˌaː5 hwˈaː2n t0ˈəɜt0 mˌɔ6j fˈyəŋ t0ˈiɛ6n ɗˌe4 tˈy6c hˈiɛ6n kˈoŋ vˈiɛ6c kˈiɲ zwˈe-ɲ kˌuə4 mˈi2ɲ zˈo2j . |0 +dataset/Xanh24h/speaker_0/454.wav|ˈoŋ hˈaː4j tʃˌɔ bˈiɛɜt0 , tˈi6 tʃˈyə2ŋ hˈiɛ6n nˈaj tʃˌyə zˈo6ŋ mˈəː4 nˌen tˈyə2ŋ ˈoŋ fˌaː4j tˈu hwˈe-6c zˈaː4j vˈu6 , tʃˈəː2 ɗˌeɜn vˈu6 hˈɛ2 tˈu mˈəːɜj tʃˈo2ŋ lˈuəɜ vˌaː2 tˈaː4 t0ˈom . |0 +dataset/Xanh24h/speaker_0/460.wav|xˌi t0ˈə2m tʃˈiɜn sˌɛ5 ŋˈy2ŋ ˈan vˌaː2 bˈɔ2 lˈen nˈɔ2ŋ ɗˈiə , bˈaː2 kˌɔn kˈə2n tʃwˈə4n bˌi6 sˈo hwˌa6c tʃˈə6w , bˈɔ4 ˈiɜt0 nˈyəɜc lˈe-6ɲ vˈaː2w zˈu6ŋ kˈu6 zˈo2j bˈaɜt0 t0ˈə2m tʃˈiɜn vˈaː2w . |0 +dataset/Xanh24h/speaker_0/461.wav|kˈu6 tˈe4 , vˌəːɜj sˈoɜ vˈoɜn t0ˌy2 bˈaː ɗˌeɜn bˈoɜn tʃˈiɛ6w ɗˈo2ŋ , bˈaː6n kˈɔɜ tˈe4 kˈiɲ zwˈe-ɲ kˌaːɜc lwˈaː6j hwˈaː tˈoŋ zˈu6ŋ ɲˌy hwˈaː hˈo2ŋ , hwˈaː kˈuɜc , hwˈaː ɗˈo2ŋ t0ˈiɛ2n . |0 +dataset/Xanh24h/speaker_0/464.wav|t0ˈi2m kˈiɛɜm kwˈaː kˌaːɜc ɲˈaː2 fˈən fˈoɜj vˌaː2 ɗˈaː6j lˈiɜ tʃˈɔŋ nˈyəɜc hwˌa6c lˈyə6 tʃˈɔ6n ɲˈaː2 kˈuŋ kˈəɜp nˈyəɜc ŋwˈaː2j , tˈaːɜj lˈaːn , hˈaː2n kˈuəɜc , tʃˈuŋ kˈuəɜc , ɲˈə6t0 bˈaː4n . |0 +dataset/Xanh24h/speaker_0/467.wav|t0ˈoj mˈɔŋ mˈuəɜn kˌaːɜc kˈə2w tˈu4 t0ˌy2 tʃwˈiɛn ŋˈiɛ6p ɗˌeɜn fˈɔŋ tʃˈaː2w , ɗˌyə6c tʃˈaː4j ŋˈiɛ6m tʃˈəɜt0 lˈyə6ŋ kˌaːɜc zˈɔ2ŋ sˈaː4n fˈə4m mˈaːŋ tˈyəŋ hˈiɛ6w kˌuə4 mˈɑːsuː . |0 +dataset/Xanh24h/speaker_0/468.wav|vˌəːɜj mˈo6t0 tʃˈiɛɜn lˈyə6c kˈiɲ zwˈe-ɲ lˈiɲ hwˈaː6t0 vˌaː2 sˈaːɜŋ t0ˈaː6w , kˈyə4 hˈaː2ŋ t0ˈaː6p hwˈaːɜ kˌuə4 bˈaː6n kˈɔɜ tˈe4 tʃˈəː4 tˈe-2ɲ ɗˈiɛ4m ɗˌeɜn ˈiɛw tˈiɜc kˌuə4 mˌɔ6j ŋˈyə2j tʃˈɔŋ xˈu vˈy6c . |0 +dataset/Xanh24h/speaker_0/469.wav|kˈaːɜ xˈɔ vˈu5 ɗˈaː6j xˌoŋ tʃˈi4 ɗˈɛ6p mˈaɜt0 tʃˈen bˈaː2n ˈan , mˌaː2 kˌɔ2n lˌaː2 mˈo6t0 hˈe-2ɲ tʃˈi2ɲ nˈəɜw ˈan mˈaːŋ ɗˈəɪ2 t0ˈi2ɲ kˈaː4m vˌaː2 sˈy6 t0ˈy4 t0ˈeɜ . |0 +dataset/Xanh24h/speaker_0/482.wav|ɲˌy5ŋ tʃˈy5 nˈa2j xˌi kˈeɜt0 hˈəː6p lˈaː6j t0ˈaː6w tˈe-2ɲ ɲˌy5ŋ kˈə1w tʃˈuɜc t0ˈeɜt0 ˈiɜ ŋˈiə5 ɲˌy vˈaː6n sˈy6 ɲˌy ˈiɜ , fˈuɜc lˈo6k tˈɔ6 . |0 +dataset/Xanh24h/speaker_0/484.wav|hˈəːn nˈyə5 , tʃˈi fˈiɜ ɗˈə2w t0ˈy bˈaːn ɗˈə2w tʃˌɔ mˈo hˈi2ɲ nˈuəj tʃˈim kˈuɜt0 kˈu5ŋ tˈəɜp , bˈaː6n kˈɔɜ tˈe4 tˈu hˈo2j vˈoɜn ɲˈe-ɲ tʃˈɔɜŋ vˌaː2 zˈuɜp bˈaː6n ɗˈaː6t0 ɗˌyə6c mˈo6t0 ŋˈuə2n lˈəː6j ɲwˈə6n kˈaːw . |0 +dataset/Xanh24h/speaker_0/488.wav|ɲˌyŋ mˈaj mˈaɜn mˈi4m kˈyə2j vˌəːɜj ˈoŋ xˌi ˈoŋ tʃˈi4 kˌɔ2n vˈɔ4n vˈɛ6n nˈam tʃˈiɛ6w ɗˈo2ŋ t0ˈiɛ2n vˈoɜn vˌaː2 xˈəː4j ŋˈiɛ6p lˈaː6j bˈa2ŋ kˈe-ɜc nˈuəj zˈe . |0 +dataset/Xanh24h/speaker_0/492.wav|xˌoŋ tʃˈi4 zˈiɛŋ dɹˈɒpʃɪpɪŋ mˌaː2 mˌɔ6j hˈi2ɲ tˈyɜc kˈiɲ zwˈe-ɲ nˌeɜw mˈuəɜn xˈəː4j ɗˈə2w vˌaː2 tˈe-2ɲ kˈoŋ , bˈaː6n ɗˈe2w kˈə2n fˌaː4j tˈy6c hˈiɛ6n ŋˈiɛm t0ˈuɜc vˌaː2 zˈe-2ɲ tˈəː2j zˈaːn kˈoɜŋ hˈiɛɜn . |0 +dataset/Xanh24h/speaker_0/493.wav|vˈe2 ŋˈuə2n kˈuŋ sˈaː4n fˈə4m , ɗˈoɜj t0ˈaːɜc wˈi t0ˈiɜn sˌɛ5 kˈɔɜ xˈaː4 nˈaŋ ɗˈaːɜp ˈyɜŋ ɲˈu kˈə2w sˈaː4n swˈəɜt0 kˌuə4 tʃˈu4 ʃˈɒp , tʃˈe-ɜɲ t0ˈi2ɲ tʃˈaː6ŋ tˈiɛɜw hˈu6t0 hˈaː2ŋ hwˈaːɜ tʃˈɔŋ kwˈaːɜ tʃˈi2ɲ kˈiɲ zwˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/497.wav|kˌaːɜc fˈu6 hwˈiɲ hwˈaː2n t0wˈaː2n sˈa5n sˈaː2ŋ tʃˈi tʃˈaː4 tʃˌɔ bˈaː6n mˈo6t0 mˈyɜc lˈyəŋ twˈaː4 twˈə6n tˈɛw mˈɔŋ mˈuəɜn nˌeɜw bˈaː6n lˈaː2m t0ˈoɜt0 kˈoŋ vˈiɛ6c mˌaː2 zˈe-ɲ t0ˈiɛɜŋ kˈu5ŋ nˈo4j lˈen ɲˈe-ɲ tʃˈɔɜŋ . |0 +dataset/Xanh24h/speaker_0/499.wav|ˈe-ɲ t0wˈəɜn ˈe-ɲ ɲˈəɜn mˈe-6ɲ vˈe2 kˈi5 twˈə6t0 nˈuəj tˈɔ4 , bˈaːw ɣˈo2m vˈiɛ6c ɗˈaː4m bˈaː4w mˈoj tʃˈyə2ŋ sˈoɜŋ twˈaːɜŋ mˈaːɜt0 vˈaː2w mˈuə2 hˈɛ2 vˌaː2 ˈəɜm ˈaːɜp vˈaː2w mˈuə2 ɗˈoŋ . |0 +dataset/Xanh24h/speaker_0/504.wav|t0wˈi ɲˈiɛn , ɗˈiɛ2w t0ˈaː6w nˌen sˈy6 ɗˈa6c bˈiɛ6t0 kˌuə4 kˈɛ6w lˈaː6c , kˈɛ6w vˈy2ŋ xˌoŋ tʃˈi4 lˌaː2 ŋwˈiɛn lˈiɛ6w mˌaː2 kˌɔ2n lˌaː2 kwˈaːɜ tʃˈi2ɲ tʃˈeɜ bˈiɛɜn ɗˈɔ2j hˈɔ4j sˈy6 xˈɛɜw lˈɛɜw , kˈiɲ ŋˈiɛ6m vˌaː2 bˈiɜ kwˈiɛɜt0 zˈaː tʃwˈiɛ2n . |0 +dataset/Xanh24h/speaker_0/505.wav|tʃˈɔŋ ɗˈɔɜ ˈoŋ t0ˈu2ŋ vˌaː2 mˈo6t0 sˈoɜ hˈo6 ɗˌyə6c t0ˈə6p hwˈəɜn , hˈyəɜŋ zˈə5n kˈi5 twˈə6t0 nˈuəj hˈaːj vˈu6 t0ˈom vˌaː2 tʃˈo2ŋ mˈo6t0 vˈu6 lˈuəɜ , mˈaːŋ lˈaː6j lˈəː6j ɲwˈə6n xˈaːɜ . |0 +dataset/Xanh24h/speaker_0/512.wav|nˌeɜw bˈaː6n kˈɔɜ xˈaː4 nˈaŋ sˈaːɜŋ t0ˈaː6w vˌaː2 ˈiɛw tˈiɜc t0ˈeɜt0 ŋwˈiɛn ɗˈaːɜn , ɗˈəɪɜ kˈɔɜ tˈe4 lˌaː2 mˈo6t0 kˈəː hˈo6j kˈiɲ zwˈe-ɲ hˈəɜp zˈə5n zˈe-2ɲ tʃˌɔ bˈaː6n . |0 +dataset/Xanh24h/speaker_0/533.wav|hwˈaː ɗˈo2ŋ t0ˈiɛ2n lˌaː2 mˈo6t0 lwˈaː6j hwˈaː fˈo4 bˈiɛɜn ˈəː4 vˈiɛ6t0 nˈaːm tˈyə2ŋ ɗˌyə6c tʃˈo2ŋ tʃˈɔŋ tʃˈə6w ɗˌe4 tʃˈaːŋ tʃˈiɜ ɲˈaː2 kˈyə4 , ɗˈa6c bˈiɛ6t0 lˌaː2 tʃˈɔŋ zˈi6p t0ˈeɜt0 ŋwˈiɛn ɗˈaɜn . |0 +dataset/Xanh24h/speaker_0/535.wav|ɗˈəɪ xˌoŋ tʃˈi4 lˌaː2 mˈo6t0 mˈɔɜn ˈan , mˌaː2 kˌɔ2n lˌaː2 mˈo6t0 fˈə2n xˌoŋ tˈe4 tˈiɛɜw tʃˈɔŋ bˈyə5 ˈan kˌuə4 mˌɔ6j zˈaː ɗˈi2ɲ xˌi ɗˈɔɜn tʃˈaː2w ɗˈo6 swˈən vˈe2 . |0 +dataset/Xanh24h/speaker_0/540.wav|ɣˈaː2 ɗˌyə6c tˈaː4 nˈuəj tʃˈen mˈa6t0 ˈaːw sˌɛ5 kˈɔɜ tʃˈəɜt0 lˈyə6ŋ tˈi6t0 tˈəːm ŋˈɔn , zˈən tʃˈaɜc hˈəːn sˈɔ vˌəːɜj ɣˈaː2 nˈuəj tʃˈɔŋ tʃˈuə2ŋ tʃˈaː6j , bˌəː4j ɣˈaː2 ɗˌyə6c vˈə6n ɗˈo6ŋ ɲˈiɛ2w , ˈan tˈyɜc ˈan t0ˈy6 ɲˈiɛn . |0 +dataset/Xanh24h/speaker_0/550.wav|t0wˈi ɲˈiɛn , ɗˌe4 tˈe-2ɲ kˈoŋ , zwˈe-ɲ ŋˈiɛ6p kˈə2n kˈɔɜ sˈy6 tʃwˈə4n bˌi6 kˈi5 lˈyə5ŋ vˈe2 ŋˈuə2n hˈaː2ŋ , tʃˈəɜt0 lˈyə6ŋ sˈaː4n fˈə4m , zˈaːɜ kˈaː4 , tˈyəŋ hˈiɛ6w vˌaː2 tʃˈiɛɜn lˈyə6c kˈiɲ zwˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/565.wav|tˈyɜc ˈan kˌuə4 zˈuə2j lˈiɜɲ ɗˈɛn lˌaː2 mˈu2n bˈaː5 hˈi5w kˈəː , kˈeɜt0 hˈəː6p bˈoɜn mˈyəj fˈə2n tʃˈam bˈaː5 bˈiə , bˈoɜn mˈyəj fˈə2n tʃˈam bˈaː5 sˈaɜn vˌaː2 hˈaːj mˈyəj fˈə2n tʃˈam bˈaː5 ɗˈə6w . |0 +dataset/Xanh24h/speaker_0/573.wav|tˈaːm zˈaː kˈə1w lˈaː6c bˈo6 ɡˈɒlf kˈuəɜc zˈaː lˈɪbəti ˈəː4 njˈuː dʒˈɜːsi nˈəːj kˈɔɜ t0ˈə2m ɲˈi2n zˈaː ɗˈyə2ŋ tʃˈən tʃˈəː2j kˌuə4 tˈe-2ɲ fˈoɜ njˈuː jˈɔːk sˌɛ5 t0ˈoɜn bˈaː tʃˈam ŋˈi2n ɗˈo lˈaː mˈi5 . |0 +dataset/Xanh24h/speaker_0/574.wav|ŋˈa2j nˈaj , kˌaːɜc tʃˈaːŋ tˈyəŋ mˈaː6j ɗˈiɛ6n t0ˈy4 ɲˌy ʃˈəʊpiː , lazˈɑːdə , tˈɪki kˈu5ŋ lˌaː2 mˈo6t0 ŋˈuə2n ɲˈə6p hˈaː2ŋ ɗˈo2 tʃˈəːj tʃˈɛ4 ˈɛm wˈi t0ˈiɜn . |0 +dataset/Xanh24h/speaker_0/575.wav|t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ hˈom nˈaj kˈu5ŋ sˌɛ5 fˈən t0ˈiɜc vˌaː2 hˈyəɜŋ zˈə5n kwˈiɜ vˈi6 vˌaː2 kˌaːɜc bˈaː6n t0ˈi2m hˈiɛ4w vˌi2 sˈaːw mˈo hˈi2ɲ nˈuəj zˈyəɜj lˈaː6j kˈɔɜ tˈe4 lˈaː2m sˈaːw . |0 +dataset/Xanh24h/speaker_0/580.wav|nˌeɜw bˈaː6n kˈaː4m tˈəɪɜ ɲˌy5ŋ ɣˈəː6j ˈiɜ tʃˈyəɜc ɗˈɔɜ ɗˌaː5 kwˈaːɜ kwˈɛn tˈuə6c , tʃˈuɜŋ t0ˈoj mˈuəɜn ɗˈɛm ɗˌeɜn tʃˌɔ bˈaː6n mˈo6t0 ˈiɜ t0ˈyə4ŋ mˈəːɜj vˌaː2 ɗˈəɪ2 t0ˈiɛ2m nˈaŋ , ɗˈɔɜ lˌaː2 bˈoŋ lˈaːn tʃˈyɜŋ mˈuəɜj . |0 +dataset/Xanh24h/speaker_0/581.wav|t0wˈi2 tˈɛw sˈoɜ vˈoɜn ɗˈə2w t0ˈy bˈaːn ɗˈə2w mˌaː2 bˈaː6n kˈɔɜ tˈe4 kwˈiɛɜt0 ɗˈi6ɲ mˈyɜc zˈaːɜ twˈe , ɲˌyŋ kˈyə4 hˈaː2ŋ ɗˈə2w t0ˈiɛn nˌen twˈe ˈəː4 mˈyɜc t0ˌy2 sˈaɜw ɗˌeɜn mˈyə2j lˈam tʃˈiɛ6w ɗˌe4 ˈaːn t0wˈaː2n . |0 +dataset/Xanh24h/speaker_0/583.wav|bˌəː4j kˈoŋ vˈiɛ6c nˈa2j kˈɔɜ tˈe4 lˈaː2m t0ˈaː6j ɲˈaː2 vˌaː2 zˈəɜt0 tʃˈu4 ɗˈo6ŋ vˈe2 tˈəː2j zˈaːn , nˌen kˈɔɜ tˈe4 kˈɔj ɗˈəɪ kˈɔɜ tˈe4 lˌaː2 mˈo6t0 kˈoŋ vˈiɛ6c zˈəɜt0 fˈu2 hˈəː6p vˌəːɜj sˈiɲ vˈiɛn . |0 +dataset/Xanh24h/speaker_0/585.wav|vˌəːɜj ɲˌy5ŋ ˈiw ɗˈiɛ4m vˌaː2 t0ˈiɛ2m nˈaŋ fˈaːɜt0 tʃˈiɛ4n , sˈiɛn kwˈɛ nˈyəɜŋ lˌaː2 mˈo6t0 lˈyə6 tʃˈɔ6n kˈiɲ zwˈe-ɲ hˈəɜp zˈə5n tʃˌɔ ɲˌy5ŋ ŋˈyə2j tʃˈɛ4 mˈuəɜn xˈəː4j ŋˈiɛ6p . |0 +dataset/Xanh24h/speaker_0/586.wav|bˈaː6n kˈɔɜ tˈe4 zˈe5 zˈaː2ŋ t0ˈi2m kˈiɛɜm kˌaːɜc sˈaː4n fˈə4m ɗˈo2 tʃˈəːj vˌəːɜj ɗˈaː zˈaː6ŋ mˈə5w mˈaː5 , tʃˈu2ŋ lwˈaː6j , zˈaːɜ kˈaː4 tʃˈen kˌaːɜc tʃˈaːŋ tˈyəŋ mˈaː6j ɗˈiɛ6n t0ˈy4 . |0 +dataset/Xanh24h/speaker_0/592.wav|kˌaːɜc kˈoŋ vˈiɛ6c tʃˈen mˌaː2 t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ ɣˈəː6j ˈiɜ tʃˌɔ kˌaːɜc bˈaː6n ɗˈe2w lˌaː2 ɲˌy5ŋ ŋˈe-2ɲ ŋˈe2 kˈɔɜ ˈiw ɗˈiɛ4m vˌaː2 lˈəː6j tˈeɜ fˈaːɜt0 tʃˈiɛ4n kˈaːw . |0 +dataset/Xanh24h/speaker_0/598.wav|ɗˌeɜn vˌəːɜj vˈɪdɪəʊ nˈa2j , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˈin ɣˈy4j ɗˌeɜn kˌaːɜc bˈaː6n tˈoŋ t0ˈin vˈe2 t0ˈɔp mˈyə2j ŋˈe-2ɲ ŋˈe2 ɲˈaː2n hˈaː6 zˈe5 kˈiɛɜm t0ˈiɛ2n ɲˈəɜt0 ŋˈa2j nˈaj . |0 +dataset/Xanh24h/speaker_0/600.wav|ŋwˈaː2j zˈaː , xˌi kˈə2n mˈuə sˈaɜm ɗˈo2 zˈu2ŋ kˈaːɜ ɲˈən hwˌa6c kwˈaː2 t0ˈa6ŋ tʃˌɔ hˈɔ6k sˈiɲ , hˈɔ6 kˈu5ŋ kˈɔɜ tˈe4 t0ˈi2m tˈəɪɜ ɲˌy5ŋ sˈaː4n fˈə4m fˈu2 hˈəː6p ŋˈaj ɣˈə2n tʃˈyə2ŋ hˈɔ6k . |0 +dataset/Xanh24h/speaker_0/601.wav|kˈɔɜ ɲˈiɛ2w tʃˈiɜɲ sˈe-ɜc mˈəːɜj , kˈə6p ɲˈə6t0 xˈaːɜ lˈiɛn t0ˈu6c , vˌi2 vˈəɪ6 bˈaː6n kˈə2n bˈaːɜm sˈaːɜt0 nˌeɜw ɲˌy xˌoŋ mˈuəɜn ɗˌe4 t0ˈaː2j xwˈaː4n kˌuə4 mˈi2ɲ bˌi6 bˈɔɜp bɹˈeɪk , zˈaː4m t0ˈyəŋ t0ˈaːɜc . |0 +dataset/Xanh24h/speaker_0/602.wav|ˈe-ɲ ŋwˈiɛ5n zwˈi t0wˈəɜn , mˈo6t0 tˈe-2ɲ nˈiɛn ɗˈəɪ2 ɲˈiɛ6t0 hwˈiɛɜt0 , hˈiɛ6n ɗˌaːŋ lˈaː2m tʃˈu4 tʃˈaːŋ tʃˈaː6j nˈuəj hˈɛw nˈaːɜj ŋwˈaː6j , sˈiɲ sˈaː4n t0ˈaː6j sˈaː5 hwˈaː2 xˈyəŋ . |0 +dataset/Xanh24h/speaker_0/603.wav|ɗˈə2w t0ˈiɛn , kˈə2n fˌaː4j tʃˈuɜ ˈiɜ ɗˌeɜn ŋˈuə2n tˈyɜc ˈan nˈuəj lˈəː6n zˈy2ŋ , bˌəː4j lˈəː6n zˈy2ŋ lˌaː2 lwˈaː2j ˈan t0ˈaː6p , zˈaː6 zˈa2j vˌaː2 hˈe6 tˈoɜŋ t0ˈiɛw hwˈaːɜ kˌuə4 tʃˈuɜŋ zˈəɜt0 t0ˈoɜt0 . |0 +dataset/Xanh24h/speaker_0/604.wav|tˈyɜc ˈan tʃˌɔ zˈeɜ zˈəɜt0 zˈe5 kˈiɛɜm vˌaː2 hˈə2w ɲˌy ˈəː4 ɗˈə1w kˈu5ŋ kˈɔɜ , ɲˌy kˈɔ4 , zˈaw sˈaɜn , zˈaw lˈaːŋ , lˈaːɜ ɗˈu ɗˈu4 . |0 +dataset/Xanh24h/speaker_0/608.wav|ɗˈoɜj vˌəːɜj kˌaːɜc ɗˈaː6j zˈaː ˈəː4 kˈatɑː , vˈiɛ6c zˈu lˈi6c vˌaː2 t0ˈiɛw zˈu2ŋ xˌoŋ tʃˈi4 lˌaː2 ɗˌe4 kˈɔɜ ɗˌyə6c ɲˌy5ŋ tʃˈaː4j ŋˈiɛ6m sˈaː hwˈaː , mˌaː2 kˌɔ2n lˌaː2 ɗˌe4 tˈe4 hˈiɛ6n ɗˈa4ŋ kˈəɜp vˌaː2 vˈi6 tˈeɜ tʃˈɔŋ sˈaː5 hˈo6j . |0 +dataset/Xanh24h/speaker_0/611.wav|ɗˌyə6c sˈy4 zˈu6ŋ lˈaː2m tˈyɜc ˈan tʃˌɔ tʃˈan nˈuəj lˈəː6n , zˈaː kˈə2m , twˈi4 sˈaː4n vˌaː2 sˈy4 lˈiɜ sˈaːɜt0 tˈaː4j hˈi5w kˈəː , tʃˈəɜt0 tˈaː4j , zˈaː sˈuɜc , zˈaː kˈə2m . |0 +dataset/Xanh24h/speaker_0/624.wav|nˌeɜw bˈaː6n kˈɔɜ kˈi5 nˈaŋ ɗˈaːn lˈɛn t0ˈoɜt0 vˌaː2 sˈa5n sˈaː2ŋ zˈe-2ɲ tˈəː2j zˈaːn vˌaː2 kˈoŋ sˈyɜc , bˈaː6n kˈɔɜ tˈe4 bˈaɜt0 ɗˈə2w kˈiɲ zwˈe-ɲ ɗˈaːn lˈɛn tˈe-2ɲ kˈoŋ . |0 +dataset/Xanh24h/speaker_0/627.wav|kˈə2n ɗˌe4 tˈyɜc ˈan tʃˈɔŋ mˈaːɜŋ vˌi2 vˈiɛ6c tʃˌɔ tʃˈim ˈan lˈiɛn t0ˈu6c hˈaːj mˈyəj t0ˈy zˈəː2 mˌo5j ŋˈa2j sˌɛ5 ɗˈɛm lˈaː6j nˈaŋ swˈəɜt0 tʃˈyɜŋ kˈaːw hˈəːn . |0 +dataset/Xanh24h/speaker_0/629.wav|lˌuɜc nˈaː2w , tʃˈaːŋ tʃˈaː6j tʃˈan nˈuəj kˌuə4 ˈoŋ kˈu5ŋ kˈɔɜ mˈo6t0 tʃˈam bˈaː mˈyəj kˌɔn hˈɛw nˈaːɜj , t0ˈaːɜm tʃˈam kˌɔn hˈɛw tˈi6t0 vˌaː2 hˈaː2ŋ tʃˈam kˌɔn hˈɛw sˈyə5 . |0 +dataset/Xanh24h/speaker_0/632.wav|kˈuəɜj kˈu2ŋ , zˈy2ŋ vˈɛn sˈoŋ vˌaː2 zˈy2ŋ tʃˈan ɗˈo2j tˈyə2ŋ kˈuŋ kˈəɜp ɗˈiɛ2w kˈiɛ6n ɗˈəɜt0 ɗˈaːj vˌaː2 mˌaɪkɹəʊklˈaɪmət t0ˈoɜt0 tʃˌɔ ɲˈiɛ2w lwˈaː6j kˈəɪ zˈyə6c lˈiɛ6w . |0 +dataset/Xanh24h/speaker_0/644.wav|xˈəː4j ɗˈə2w bˈa2ŋ kˈe-ɜc bˈaːɜn hˈaː2ŋ zˈɔŋ tʃˈen vˈiə4 hˈɛ2 ɣˈɔɜk ŋˈaː5 t0ˈy hwˈaː2ŋ hwˈaː tˈaːɜm , kˈo6ŋ hwˈaː2 tˈuə6c t0ˈən bˈi2ɲ , tˌepˈe.hˌaɜtsˌeˈɛməː2 . |0 +dataset/Xanh24h/speaker_0/649.wav|ɗˌe4 kˈɔɜ tˈe4 tˈe-2ɲ kˈoŋ tʃˈɔŋ ŋˈe-2ɲ nˈa2j , zwˈe-ɲ ŋˈiɛ6p kˈə2n nˈaɜm bˈaɜt0 vˌaː2 ˈaːɜp zˈu6ŋ kˌaːɜc sˈu hˈyəɜŋ fˈaːɜt0 tʃˈiɛ4n mˈəːɜj ɲˈəɜt0 , kˈu5ŋ ɲˌy t0ˈaː6w zˈaː ɲˌy5ŋ zˈaːɜ tʃˈi6 ɗˈo6k ɗˈaːɜw vˌaː2 xˈaːɜc bˈiɛ6t0 tʃˌɔ xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/662.wav|ŋˈo2j ɲˈəm ɲˈi tʃˈən ɣˈaː2 , kˈe-ɜɲ ɣˈaː2 nˈyəɜŋ zˈɔ2n , zˈaː2j tˈəːm lˈy2ŋ kˈu2ŋ bˈaː6n bˈɛ2 vˌaː2 tˈem tʃˈɛɜn zˈyə6w , xˌoŋ zˈi2 t0wˈiɛ6t0 vˈəː2j hˈəːn . vˈəɪ6 t0ˈaː6j sˈaːw bˈaː6n lˈaː6j xˌoŋ t0ˈə6n zˈu6ŋ kˈəː hˈo6j nˈa2j ŋˈaj ? |0 +dataset/Xanh24h/speaker_0/663.wav|t0ˈyə6ŋ tˈə2n t0ˈaː2j , tˈo4 ɗˈiə6 lˌaː2 hˈaːj vˈi6 tˈə2n ɗˌyə6c tˈəː2 kˈuɜŋ tʃˈɔŋ ɲˈiɛ2w zˈaː ɗˈi2ɲ vˈiɛ6t0 nˈaːm , ɗˈa6c bˈiɛ6t0 lˌaː2 ɲˌy5ŋ zˈaː ɗˈi2ɲ kˈiɲ zwˈe-ɲ bˈuən bˈaːɜn . |0 +dataset/Xanh24h/speaker_0/664.wav|vˈaː2ŋ mˈaː5 lˌaː2 tˈyɜ bˈaɜt0 bˈuə6c fˌaː4j kˈɔɜ vˌaː2 zˈəɜt0 ɗˌyə6c kˈɔj tʃˈɔ6ŋ tʃˈɔŋ ŋˈa2j nˈa2j , nˌen ɗˈəɪ sˌɛ5 lˌaː2 mˈa6t0 hˈaː2ŋ bˈaːɜn kˈy6c kˈi2 tʃˈa6j tʃˈɔŋ ŋˈa2j nˈa2j . |0 +dataset/Xanh24h/speaker_0/669.wav|hˈiɛ6n nˈaj kˈɔɜ kˌaːɜc zˈaː6ŋ vˈiɛɜt0 bˈaː2j fˈo4 bˈiɛɜn ɲˌy vˈiɛɜt0 bˈaː2j , vˈiɛɜt0 kˈɒntɛnt tʃˌɔ kˌaːɜc tˈyəŋ hˈiɛ6w mˈi5 fˈə4m , vˈiɛɜt0 bˈaː2j ɹɪvjˈuː , bˈaː2j tʃwˈə4n sˈɛl , vˈiɛɜt0 bˈaː2j tʃˌɔ wˈɛbsaɪt , vˈiɛɜt0 bˈaː2j tʃˌɔ pˈeɪdʒ . |0 +dataset/Xanh24h/speaker_0/671.wav|nˌeɜw bˈaː6n ɗˈi6ɲ hˈyəɜŋ tʃˈu4 ˈiɛɜw vˈaː2w hˈɔ6k sˈiɲ , sˈiɲ vˈiɛn vˌaː2 fˈu6 hwˈiɲ , vˈiɛ6c mˈəː4 kˈyə4 hˈaː2ŋ ɣˈə2n tʃˈyə2ŋ hˈɔ6k lˌaː2 mˈo6t0 tʃˈiɛɜn lˈyə6c t0ˈoɜt0 zˈuɜp zˈe5 zˈaː2ŋ t0ˈiɛɜp kˈə6n ɗˈoɜj t0ˈyə6ŋ xˈe-ɜc hˈaː2ŋ t0ˈiɛ2m nˈaŋ . |0 +dataset/Xanh24h/speaker_0/673.wav|bˈaː6n kˈɔɜ tˈe4 bˈaːɜn kˌaːɜc lwˈaː6j bˈuɜt0 , sˈe-ɜc , fˈəː4 , ɗˈo2 zˈu2ŋ hˈɔ6k t0ˈə6p , ɗˈo2 ˈan ɲˈɛ6 vˌaː2 ɗˈo2 ˈuəɜŋ kˈu5ŋ ɲˌy kˌaːɜc vˈə6t0 zˈu6ŋ hˈaː2ŋ ŋˈa2j ɲˌy bˈaŋ zˈiɜɲ , zˈəɪɜ ɣˈɔɜj kwˈaː2 vˌaː2 ɲˈiɛ2w sˈaː4n fˈə4m xˈaːɜc . |0 +dataset/Xanh24h/speaker_0/682.wav|nˈam hˈaːj ŋˈi2n hˈaːj mˈyəj , zˈaː ɗˈi2ɲ ˈoŋ swˈəɜt0 bˈaːɜn ɗˌyə6c bˈaː lˈyəɜj lˈəː6n xwˌaː4ŋ mˈo6t0 ŋˈi2n nˈam tʃˈam kˌɔn , kˈɔɜ t0ˈo4ŋ tʃˈɔ6ŋ lˈyə6ŋ mˈo6t0 tʃˈam sˈaɜw mˈyəj t0ˈəɜn . |0 +dataset/Xanh24h/speaker_0/684.wav|zwˈe-ɲ ŋˈiɛ6p kˈə2n lˈyə6 tʃˈɔ6n ŋˈuə2n hˈaː2ŋ wˈi t0ˈiɜn , kˈɔɜ ŋˈuə2n ɣˈoɜk swˈəɜt0 sˈyɜ zˈɔ5 zˈaː2ŋ , ɗˈaː4m bˈaː4w tʃˈəɜt0 lˈyə6ŋ , t0ˈaː6w nˈiɛ2m t0ˈin vˌaː2 zˈy5 tʃˈən xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/690.wav|ɗˈa6c bˈiɛ6t0 tʃˈɔŋ ɲˌy5ŋ ŋˈa2j nˈa2j , xˌi tˈəː2j t0ˈiɛɜt0 sˈɛ lˈe-6ɲ , zˈi6c vˈu6 tˈaksi ŋˈa2j kˈaː2ŋ tʃˈəː4 nˌen hˈəɜp zˈə5n hˈəːn bˌəː4j kˌaːɜc bˈə6c fˈu6 hwˈiɲ mˈuəɜn ɗˈaː4m bˈaː4w sˈyɜc xwˈɛ4 tʃˌɔ kˌɔn ˈɛm mˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/693.wav|kˈuŋ kˈəɜp kˌaːɜc tˈoŋ t0ˈin hˈi5w ˈiɜc tʃˌɔ xˈe-ɜc hˈaː2ŋ , tʃˌa4ŋ hˈaː6n ɲˌy bˈiɜ kwˈiɛɜt0 tʃˈɔ6n vˌaː2 bˈaː4w kwˈaː4n hˈaː4j sˈaː4n t0ˈyəj ŋˈɔn , kˈe-ɜc tʃˈeɜ bˈiɛɜn hˈaː4j sˈaː4n . |0 +dataset/Xanh24h/speaker_0/709.wav|vˈəɪ6 nˌen , nˌeɜw bˈaː6n ɗˌaːŋ kˈɔɜ ɗˈi6ɲ hˈyəɜŋ tʃˈəː4 tˈe-2ɲ hwˈəɜn lwˈiɛ6n vˈiɛn tˈe4 hˈi2ɲ , tˌi2 kˈɔɜ tˈe4 tˈaːm xˈaː4w ɲˌy5ŋ ˈiɛɜw t0ˈoɜ kˈə2n tˈiɛɜt0 ɗˌe4 ɗˈaːɜp ˈyɜŋ ˈiɛw kˈə2w vˈe2 ŋˈe2 ŋˈiɛ6p nˈa2j . |0 +dataset/Xanh24h/speaker_0/710.wav|xˌi t0ˈə2m nˈəː4 , ɗˈa6t0 t0ˈəː2 zˈəɪɜ bˈaː4n lˈen tʃˈen , zˈaɜc mˈo6t0 lˈəːɜp mˈɔ4ŋ tˈyɜc ˈan tˈaːɜj ɲˈɔ4 lˈen tʃˈen t0ˈəː2 zˈəɪɜ bˈaː4n ɗˌe4 ɲˈy4 t0ˈə2m bˈaːɜm vˈaː2w mˈa6t0 zˈyəɜj t0ˈəː2 zˈəɪɜ bˈaː4n . |0 +dataset/Xanh24h/speaker_0/723.wav|ɲˌy5ŋ mˈɔɜn ˈan tʃwˈiɛ2n tˈoɜŋ xˌi ɗˌyə6c kˈeɜt0 hˈəː6p vˌəːɜj tˈe-ɲ lˈɔŋ ɗˈɔ4 t0ˈaː6w tˈe-2ɲ mˈo6t0 t0ˈo4ŋ tˈe4 hˈaːj hwˈaː t0ˌy2 hˈyəŋ vˈi6 ɗˌeɜn mˈa2w sˈaɜc . |0 +dataset/Xanh24h/speaker_0/725.wav|ˈe-ɲ hˈɔ2n kˈu5ŋ lˌaː2 ŋˈyə2j ɗˌaː5 t0ˈi2m zˈaː hˈyəɜŋ ɗˈi mˈəːɜj , ɗˈyə kˈəɪ sˈaː4 ɗˌeɜn vˌəːɜj bˈaː2 kˌɔn tʃˈɔŋ sˈɔɜm ɗˌe4 fˈaːɜt0 tʃˈiɛ4n kˈiɲ t0ˈeɜ . |0 +dataset/Xanh24h/speaker_0/729.wav|ɲˈu kˈə2w nˈyəɜc kˌuə4 hˈyəw sˈaːw t0ˈiɜɲ tˈɛw mˈuə2 , vˈaː2w mˈuə2 hˈɛ2 kˈə2n t0ˌy2 sˈaɜw ɗˌeɜn t0ˈaːɜm lˈiɜt0 nˈyəɜc mˈo6t0 ŋˈa2j , vˈaː2w mˈuə2 ɗˈoŋ kˈə2n t0ˌy2 bˈoɜn ɗˌeɜn sˈaɜw lˈiɜt0 mˈo6t0 ŋˈa2j . |0 +dataset/Xanh24h/speaker_0/732.wav|hˈiɛ6n nˈaj , sˈoɜ lˈyə6ŋ ŋˈyə2j zˈu2ŋ nˈe2n t0ˈaː4ŋ nˈa2j zˈəɜt0 lˈəːɜn , hˈəːn mˈyə2j hˈaːj tʃˈiɛ6w ŋˈyə2j , tʃˈu4 ˈiɛɜw lˌaː2 ɗˈoɜj t0ˈyə6ŋ tʃˈɛ4 mˈyə2j t0ˈaːɜm ɗˌeɜn bˈaː mˈyəj t0ˈuə4j . |0 +dataset/Xanh24h/speaker_0/734.wav|ɗˈa6c bˈiɛ6t0 ɗˈoɜj vˌəːɜj ɲˌy5ŋ ŋˈyə2j mˈəːɜj kˈiɲ zwˈe-ɲ , vˈiɛ6c ɗˈi kˈu2ŋ ŋˈyə2j kˈɔɜ kˈiɲ ŋˈiɛ6m lˌaː2 lˈyə6 tʃˈɔ6n tˈoŋ mˈiɲ ɗˌe4 tʃˈe-ɜɲ zˈu4j zˈɔ mˈuə hˈaː2ŋ xˌoŋ tʃˈəɜt0 lˈyə6ŋ . |0 +dataset/Xanh24h/speaker_0/738.wav|sˈɔ vˌəːɜj kˌaːɜc mˈa6t0 hˈaː2ŋ kˈiɲ zwˈe-ɲ t0ˈeɜt0 xˈaːɜc ɲˌy hwˈaː t0ˈyəj , kˈəɪ kˈe-4ɲ , ɗˈo2 ˈan , tˈyɜc ˈuəɜŋ , tˌi2 kˈə1w ɗˈoɜj , tʃˈe-ɲ ˈe-4ɲ t0ˈeɜt0 kˈɔɜ vˈoɜn ɗˈə2w t0ˈy tˈəɜp hˈəːn . |0 +dataset/Xanh24h/speaker_0/739.wav|kˌaːɜc tˈiɛɜt0 bˌi6 nˈa2j bˈaːw ɣˈo2m mˈaɜj t0ˈiɜɲ t0ˈiɛ2n , fˈə2n mˈe2m kwˈaː4n lˈiɜ bˈaːɜn hˈaː2ŋ , mˈaɜj ˈin hwˈaːɜ ɗˈəːn , mˈaɜj kwˈɛɜt0 mˈaː5 vˈe-6c , hˈe6 tˈoɜŋ kˈamɹə ˈaːn nˈiɲ . |0 +dataset/Xanh24h/speaker_0/740.wav|kˈiɲ zwˈe-ɲ lˈi5ɲ vˈy6c sˈyɜc xwˈɛ4 vˌaː2 tˈe4 zˈu6c kˈɔɜ tˈe4 mˈaːŋ lˈaː6j ɲˈiɛ2w kˈəː hˈo6j tʃˌɔ ŋˈa2j kˈaː2ŋ ɲˈiɛ2w ŋˈyə2j kwˈaːn t0ˈəm ɗˌeɜn vˈiɛ6c zwˈi tʃˈi2 mˈo6t0 lˈoɜj sˈoɜŋ lˈe-2ɲ mˈe-6ɲ . |0 +dataset/Xanh24h/speaker_0/741.wav|zˌu2 kˈɔɜ vˈɛ4 xˈɔɜ t0ˈin , ɲˌyŋ vˈiɛ6c t0ˈaː6w zˈaː kˌaːɜc xˈu vˈyə2n sˈe-ɲ t0ˈyəj tʃˈɔŋ sˈaː mˈaː6c kˈaɜt0 tʃˈaɜŋ nˈa2j lˌaː2 mˈo6t0 tˈe-2ɲ t0ˈi6w ɗˈaːɜŋ kˈe4 . |0 +dataset/Xanh24h/speaker_0/742.wav|bˈaː6n kˈə2n kˈən ɲˈaɜc ɗˌeɜn t0ˈi4 lˈe6 pɹˈəʊtiːn , tʃˈəɜt0 bˈɛɜw vˌaː2 kˌaːɜc tʃˈəɜt0 xwˈaːɜŋ tʃˈɔŋ tˈyɜc ˈan ɗˌe4 ɗˈaːɜp ˈyɜŋ ɲˈu kˈə2w kˈu6 tˈe4 kˌuə4 ɣˈaː2 vˌaː2 kˈaːɜ tʃˈɔŋ mˈoj tʃˈyə2ŋ ˈaːw nˈuəj . |0 +dataset/Xanh24h/speaker_0/745.wav|vˈɪdɪəʊ nˈa2j , tʃˈuɜŋ t0ˈoj sˌɛ5 ɗˈi sˈə1w vˈaː2w t0ˈi2m hˈiɛ4w vˌaː2 tʃˈiə sˈɛ4 ɗˌeɜn vˌəːɜj kwˈiɜ vˈi6 vˌaː2 kˌaːɜc bˈaː6n kˈe-ɜc nˈuəj zˈe bˈe-ɜc tˈaː4w ɗˌyə6c hˈiɛ6w kwˈaː4 kˈiɲ t0ˈeɜ kˈaːw ɲˈəɜt0 ɲˈəɜt0 . |0 +dataset/Xanh24h/speaker_0/748.wav|t0ˈaː6j vˈiɛ6t0 nˈaːm , ɣˈaː2 kˈuɜŋ ˈoŋ kˈoŋ ˈoŋ t0ˈaːɜw tˈyə2ŋ ɗˌyə6c bˈaːɜn t0ˈaː6j kˌaːɜc tʃˈəː6 tʃwˈiɛ2n tˈoɜŋ , kˌaːɜc kˈyə4 hˈaː2ŋ bˈaːɜn ɗˈo2 kˈuɜŋ hwˌa6c kˌaːɜc kˈyə4 hˈaː2ŋ tˈy6c fˈə4m . |0 +dataset/Xanh24h/speaker_0/750.wav|nˌeɜw ɲˌy bˈaː6n kˈɔɜ xˈaː4 nˈaŋ vˈiɛɜt0 lˈe-ɜc hwˌa6c ˈiɛw tˈiɜc ɲˌy5ŋ kˈoŋ vˈiɛ6c sˈaːɜŋ t0ˈaː6w , tˌi2 ɗˈəɪ lˌaː2 mˈo6t0 kˈe-ɜc kˈiɛɜm t0ˈiɛ2n ˈɒnlaɪn mˌaː2 bˈaː6n xˌoŋ tˈe4 bˈɔ4 kwˈaː . |0 +dataset/Xanh24h/speaker_0/762.wav|ɗˈiɛ2w nˈa2j kˈɔɜ tˈe4 t0ˈaː6w zˈaː sˈy6 ɗˈo2ŋ kˈaː4m vˌaː2 hˈo5 tʃˈəː6 t0ˌy2 kˈo6ŋ ɗˈo2ŋ , t0ˈaŋ kˈyə2ŋ wˈi t0ˈiɜn vˌaː2 zˈuɜp tˈyəŋ hˈiɛ6w kˌuə4 bˈaː6n tʃˈəː4 nˌen tˈən tˈiɛ6n vˌaː2 ɗˈaːɜŋ t0ˈin kˈəɪ6 tʃˈɔŋ t0ˈəm tʃˈiɜ kˌuə4 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/763.wav|vˈəɪ6 nˌen ɗˈəɪ lˌaː2 hˈyəɜŋ ɗˈi ɗˌyə6c xˈaːɜ ɲˈiɛ2w ŋˈyə2j lˈyə6 tʃˈɔ6n ɗˌe4 xˈəː4j ŋˈiɛ6p bˌəː4j ŋˈe-2ɲ ŋˈe2 nˈa2j xˌoŋ kˈə2n sˈoɜ vˈoɜn ɗˈə2w t0ˈy lˈəːɜn , ɲˈu kˈə2w tˈi6 tʃˈyə2ŋ xˈaːɜ kˈaːw , t0ˈiɛ6n lˈəː6j , zˈe5 lˈaː2m . |0 +dataset/Xanh24h/speaker_0/774.wav|hˈiɛ6n nˈaj , ɲˌy5ŋ ŋˈyə2j bˈɔ4 mˈuəɜj nˈoŋ sˈaː4n zˈyə2ŋ ɲˌy xˌoŋ kˌɔ2n lˈaː6 lˈə5m . ɗˈəɪ tʃˈiɜɲ lˌaː2 mˈo6t0 xˈəɜw kwˈaːn tʃˈɔ6ŋ tʃˈɔŋ t0ˈiɛɜn tʃˈi2ɲ ɗˈyə sˈaː4n fˈə4m ɗˌeɜn t0ˈaj ŋˈyə2j t0ˈiɛw zˈu2ŋ . |0 +dataset/Xanh24h/speaker_0/775.wav|ɣˈaː2 kˈi2 lˈən lˌaː2 zˈoɜŋ ɣˈaː2 kˈɔɜ sˈyɜc ɗˈe2 xˈaːɜŋ t0ˈoɜt0 ɲˌyŋ vˌə5n kˈɔɜ tˈe4 mˈaɜc mˈo6t0 sˈoɜ bˈe6ɲ ɲˌy bˈe6ɲ kˈə2w tʃˈu2ŋ , bˈe6ɲ ɡˈʌmbəɹˌəʊ , bˈe6ɲ t0ˈu6 hwˈiɛɜt0 tʃˈu2ŋ . |0 +dataset/Xanh24h/speaker_0/776.wav|vˌəːɜj mˈo6t0 tˈyəŋ hˈiɛ6w nˈo4j t0ˈiɛɜŋ , tʃˈaɜc tʃˈaɜn mˈyɜc zˈaːɜ ɗˈo2ŋ hˈo2 kˈu5ŋ sˌɛ5 tʃˈe-ɲ lˈe6c sˈɔ vˌəːɜj tˈyəŋ hˈiɛ6w tˈyə2ŋ . xˌoŋ ɲˌy5ŋ tˈeɜ , zˈaːɜ tʃˈi6 kˌuə4 ɗˈo2ŋ hˈo2 t0ˈaŋ tˈɛw tˈəː2j zˈaːn . |0 +dataset/Xanh24h/speaker_0/778.wav|nˌeɜw bˈaː6n kˈɔɜ ɗˈaːm mˈe vˌaː2 kˈiɛɜn tˈyɜc vˈy5ŋ vˈe2 ɗˈo2 tʃˈəːj tʃˈɛ4 ˈɛm , ɗˈəɪɜ tʃˈaɜc tʃˈaɜn lˌaː2 mˈo6t0 lˈi5ɲ vˈy6c kˈiɲ zwˈe-ɲ ɗˈaːɜŋ ɗˌe4 bˈaː6n tˈaːm xˈaː4w vˌaː2 xˈaːj tˈaːɜc . |0 +dataset/Xanh24h/speaker_0/781.wav|tʃˈɔŋ kwˈaːɜ tʃˈi2ɲ kˈiɲ zwˈe-ɲ hˈaː4j sˈaː4n , vˈiɛ6c ɗˈi6ɲ zˈɔ5 ɗˈoɜj t0ˈyə6ŋ xˈe-ɜc hˈaː2ŋ lˌaː2 mˈo6t0 bˈyəɜc kwˈaːn tʃˈɔ6ŋ ɗˌe4 ɗˈaː4m bˈaː4w hˈiɛ6w kwˈaː4 vˌaː2 tˈe-2ɲ kˈoŋ tʃˈɔŋ kˈiɲ zwˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/789.wav|lˈəː6j ɲwˈə6n kˌuə4 kˈiɲ zwˈe-ɲ ɗˈo2 tʃˈaːŋ tʃˈiɜ t0ˈeɜt0 ŋwˈiɛn ɗˈaːɜn hˈandmeɪd fˈu6 tˈuə6c vˈaː2w ɲˈiɛ2w ˈiɛɜw t0ˈoɜ , bˈaːw ɣˈo2m lwˈaː6j ɗˈo2 tʃˈaːŋ tʃˈiɜ bˈaː6n bˈaːɜn , zˈaːɜ kˈaː4 vˌaː2 sˈoɜ lˈyə6ŋ bˈaːɜn ɗˌyə6c . |0 +dataset/Xanh24h/speaker_0/790.wav|vˈiɛ6c t0ˈi2m kˈiɛɜm mˈo6t0 ŋˈuə2n hˈaː2ŋ tʃˈəɜt0 lˈyə6ŋ , wˈi t0ˈiɜn xˌoŋ tʃˈi4 zˈuɜp bˈaː6n kˈɔɜ mˈo6t0 kˌaːɜj zˈaːɜ ɲˈə6p hˈaː2ŋ fˌaː4j tʃˈaŋ mˌaː2 kˌɔ2n t0ˈaŋ nˈiɛ2m t0ˈin t0ˌy2 xˈe-ɜc hˈaː2ŋ kˌuə4 bˈaː6n . |0 +dataset/Xanh24h/speaker_0/798.wav|ɗˈəɪ lˌaː2 ŋˈe-2ɲ ŋˈe2 mˈəːɜj nˈo4j ɲˌy5ŋ nˈam ɣˈə2n ɗˈəɪ , t0wˈi ɲˈiɛn vˌi2 ɲˈu kˈə2w vˈə6n tʃwˈiɛ4n hˈaː2ŋ hwˈaːɜ ŋˈa2j kˈaː2ŋ kˈaːw mˌaː2 kˈoŋ vˈiɛ6c nˈa2j kˌɔ2n kˈə2n ŋˈyə2j zˈəɜt0 lˈəːɜn . |0 +dataset/Xanh24h/speaker_0/801.wav|t0ˈəɜt0 kˈaː4 ɲˌy5ŋ lwˈaː6j zˈy2ŋ nˈa2j ɗˈe2w kˈə2n ɗˌyə6c kwˈaː4n lˈiɜ mˈo6t0 kˈe-ɜc bˈe2n vˈy5ŋ ɗˌe4 bˈaː4w vˈe6 ŋˈuə2n lˈəː6j zˈyə6c lˈiɛ6w vˌaː2 zwˈi tʃˈi2 sˈy6 ɗˈaː zˈaː6ŋ sˈiɲ hˈɔ6k tʃˈɔŋ mˈoj tʃˈyə2ŋ zˈy2ŋ . |0 +dataset/Xanh24h/speaker_0/807.wav|hˈiɛ6n t0ˈaː6j vˌəːɜj zˈaːɜ bˈaːɜn t0ˌy2 hˈaːj ŋˈi2n ɗˈo2ŋ tʃˈen mˌo5j bˈaɜp , sˈaw xˌi tʃˈy2 kˌaːɜc xwˈaː4n tʃˈi fˈiɜ tʃˌɔ ŋˈyə2j nˈoŋ zˈən , tˈu ɲˈə6p sˈaɜw mˈyəj tʃˈiɛ6w ɗˈo2ŋ mˈo6t0 hˈɛktə . |0 +dataset/Xanh24h/speaker_0/815.wav|ɲˌyŋ kˈuəɜj nˈam , mˈuə mˈuəɜj lˌaː2 ɗˌe4 kwˈɛɜt0 lˈaː6j kˈan ɲˈaː2 , t0ˈyə2ŋ kˈo4ŋ tʃˌɔ sˈe-6c sˌɛ5 , tʃˈaɜŋ t0ˈiɲ t0ˈyəm , tʃwˈə4n bˌi6 ɗˈɔɜn nˈam mˈəːɜj . |0 +dataset/Xanh24h/speaker_0/820.wav|tʃˈyəɜc xˌi sˈoŋ hˈəːj , kˈə2n vˈəɪ4 nˈyəɜc lˈen t0ˈyə2ŋ , sˈaː2n ɲˈaː2 vˌaː2 zˈu6ŋ kˈu6 , ɗˈo2ŋ tˈəː2j kˈiɛ4m tʃˈa6t0 t0ˈəɜt0 kˈaː4 kˌaːɜc xˈɛ hˈəː4 ɗˌe4 zwˈi tʃˈi2 ɲˈiɛ6t0 ɗˈo6 tʃˈɔŋ fˈɔ2ŋ tʃˈen hˈaːj mˈyəj lˈam ɗˈo6 sˈe . |0 +dataset/Xanh24h/speaker_0/821.wav|mˈo6t0 ŋˈa2j , bˈaː6n tʃˈi4 kˈə2n zˈe-2ɲ zˈaː t0ˈoɜj tˈiɛ4w bˈoɜn zˈəː2 t0ˈaː6w nˈo6j zˈuŋ ɗˈaŋ bˈaː2j vˌaː2 tʃˈaː4 lˈəː2j t0ˈin ɲˈaɜn tˈaɜc mˈaɜc kˌuə4 xˈe-ɜc hˈaː2ŋ tˌi2 ɗˌaː5 kˈɔɜ tˈe4 kˈiɛɜm ɗˌyə6c t0ˈiɛ2n t0ˌy2 kˈoŋ vˈiɛ6c nˈa2j . |0 +dataset/Xanh24h/speaker_0/824.wav|sˈəm bˈoɜ tʃˈiɜɲ fˈaːɜt0 tʃˈiɛ4n t0ˈoɜt0 zˈyəɜj t0ˈaːɜn zˈy2ŋ t0ˈy6 ɲˈiɛn hwˌa6c tʃˈɔŋ zˈy2ŋ tʃˈo2ŋ , ɗˈa6c bˈiɛ6t0 lˌaː2 tʃˈɔŋ kˌaːɜc vˈu2ŋ kˈɔɜ xˈiɜ hˈə6w ɲˈiɛ6t0 ɗˈəːɜj ˈə4m . |0 +dataset/Xanh24h/speaker_0/828.wav|vˈaː2w nˈam mˈo6t0 ŋˈi2n t0ˈaːɜm tʃˈam nˈam mˈyəj hˈaːj , zˈoɜŋ ɣˈaː2 nˈa2j ɗˌyə6c ɗˈiɜc tˈən nˈy5 hwˈaː2ŋ ˈe-ɲ vɪktˈɔːɹiə nˈuəj zˈyə5ŋ vˌaː2 sˈaw ɗˈɔɜ tʃˈiə sˈɛ4 tʃˌɔ kˌaːɜc ɲˈaː2 kwˈiɜ t0ˈo6k ˈe-ɲ ɲˈən zˈoɜŋ . |0 +dataset/Xanh24h/speaker_0/834.wav|t0wˈi ɲˈiɛn , mˈa6c zˌu2 kˈɔɜ ɲˈu kˈə2w t0ˈiɛw tˈu6 zˈəɜt0 kˈaːw vˈaː2w zˈi6p kˈuəɜj nˈam , ɲˌyŋ xˌoŋ fˌaː4j ˈaːj kˈiɲ zwˈe-ɲ hwˈaː ɗˈaː2w ŋˈa2j t0ˈeɜt0 kˈu5ŋ tˈe-2ɲ kˈoŋ . |0 +dataset/Xanh24h/speaker_0/836.wav|tʃˈe-ɲ tˈu4 ɣˈa6t0 sˈɔŋ vˈu6 mˈuə2 , tʃˈi6 lˈiɜ tˈi6 vˈiɲ vˌaː2 kˌaːɜc tʃˈi6 ˈɛm tʃˈɔŋ sˈɔɜm nˈaːm mˈɔn lˈaː6j t0ˈəɜt0 bˈə6t0 kˈu2ŋ ɲˈaw ɗˈi tˈu hwˈe-6c sˈaː4 ɗˌe4 tʃˈiɛɜt0 swˈəɜt0 t0ˈiɜɲ zˈə2w . |0 +dataset/Xanh24h/speaker_0/840.wav|ɗˈiɛ6m lˈɔɜt0 sˈiɲ tˈaːɜj tʃˈɔŋ tʃˈuə2ŋ nˈuəj ɣˈaː2 kˈɔɜ ɲˈiɛ2w t0ˈaːɜc zˈu6ŋ kwˈaːn tʃˈɔ6ŋ . tʃˈyəɜc hˈeɜt0 , nˈɔɜ zˈuɜp fˈən zˈaː4j vˌaː2 lˈaː2m t0ˈiɛw hˈeɜt0 fˈən , zˈaː4m tˈiɛ4w xˈiɜ ɗˈo6k vˌaː2 mˈu2j hˈoj tʃˈɔŋ mˈoj tʃˈyə2ŋ nˈuəj . |0 +dataset/Xanh24h/speaker_0/853.wav|lˈe5 vˈə6t0 kˈuɜŋ tˈə2n t0ˈaː2j tˈyə2ŋ bˈaːw ɣˈo2m kˌaːɜc lwˈaː6j tʃˈaːɜj kˈəɪ , hwˈaː t0ˈyəj , tʃˈə2w kˈaːw , zˈyə6w , nˈyəɜc , ɣˈaː6w , mˈuəɜj , vˈaː2ŋ mˈaː5 . |0 +dataset/Xanh24h/speaker_0/870.wav|kˈe-ɜc lˈaː2m bˈe-ɜɲ ɲˈaː5n vˈo kˈu2ŋ ɗˈəːn zˈaː4n , xˌoŋ ɗˈɔ2j hˈɔ4j sˈy4 zˈu6ŋ lˈɔ2 nˈyəɜŋ hˈaj nˈo2j tʃˈiɛn xˌoŋ zˈə2w , mˌaː2 tʃˈi4 kˈə2n zˈaːɜn lˈen tʃˈaː4w . |0 +dataset/Xanh24h/speaker_0/871.wav|kˈuəɜj kˈu2ŋ tʃˈɔŋ zˈe-ɲ sˈe-ɜc kˌaːɜc ɗˈo6ŋ vˈə6t0 zˈe5 nˈuəj , ɗˈaː4m bˈaː4w ɗˈə2w zˈaː vˌaː2 kˈɔɜ ɲˈiɛ2w lˈəː6j ɲwˈə6n tˌi2 tʃˈaɜc tʃˈaɜn xˌoŋ tˈe4 bˈɔ4 kwˈaː zˈəːj . |0 +dataset/Xanh24h/speaker_0/875.wav|ɗˈəɪ lˌaː2 zˈi6p ɗˌe4 mˌɔ6j ŋˈyə2j tˈe4 hˈiɛ6n t0ˈi2ɲ kˈaː4m , sˈy6 kwˈaːn t0ˈəm vˌaː2 lˈɔ2ŋ bˈiɛɜt0 ˈəːn vˌəːɜj ŋˈyə2j tˈən , bˈaː6n bˈɛ2 , ɗˈoɜj t0ˈaːɜc . |0 +dataset/Xanh24h/speaker_0/877.wav|ɗˌeɜn vˌəːɜj vˈɪdɪəʊ nˈa2j , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˌɛ5 zˈəːɜj tˈiɛ6w ɗˌeɜn kwˈiɜ vˈi6 t0ˈaːɜm kˈe-ɜc lˈaː2m zˈa2w t0ˈaː6j nˈoŋ tˈon vˈoɜn ˈiɜt0 lˈəː2j ɲˈiɛ2w ɲˌyŋ ˈiɜt0 ˈaːj tʃˈuɜ ˈiɜ ɗˌeɜn . |0 +dataset/Xanh24h/speaker_0/880.wav|sˈaw ɗˈɔɜ , hˈo5n hˈəː6p nˈa2j ɗˌyə6c bˈɔ6k tʃˈɔŋ lˈaːɜ ˈo4j hwˌa6c lˈaːɜ tʃˈu2m zˈuə6t0 vˌaː2 ɗˌe4 lˈen mˈɛn tʃˈɔŋ vˈaː2j ŋˈa2j , t0ˈaː6w nˌen mˈo6t0 vˈiɛn nˈɛm tʃˈuə ɗˈo6k ɗˈaːɜw . |0 +dataset/Xanh24h/speaker_0/888.wav|tʃˈaː2 tʃˈe-ɲ zˈaː5 t0ˈaj vˈoɜn lˌaː2 ɗˈo2 ˈuəɜŋ fˈo4 bˈiɛɜn ˈəː4 tʃˈuŋ kˈuəɜc sˈy4 zˈu6ŋ ŋwˈiɛn lˈiɛ6w nˈo6j ɗˈiə6 t0ˈy2ŋ zˈəɜt0 hˈɔt0 tʃˈen kˌaːɜc mˈaː6ŋ sˈaː5 hˈo6j ɗˈəɜt0 nˈyəɜc t0ˈi4 zˈən . |0 +dataset/Xanh24h/speaker_0/895.wav|kˈɔɜ tʃˈəɜt0 lˈyə6ŋ zˈəɜt0 kˈaːw , t0wˈaː2n bˈo6 ɗˌyə6c ɣˈaɜn tʃˈɪp , kˈɔɜ mˈaː5 sˈoɜ nˌen kˈəː sˈəː4 kˈuŋ kˈəɜp zˈoɜŋ t0ˌy2 nˈyəɜc ŋwˈaː2j vˌə5n tˈɛw zˈɔ5j ɗˌyə6c kwˈaːɜ tʃˈi2ɲ fˈaːɜt0 tʃˈiɛ4n kˌuə4 hˈɛw . |0 +dataset/Xanh24h/speaker_0/899.wav|ɣˈaːn ŋˈo5ŋ , nˈəɜm , tʃˈuə fˈo4 tʃˈaɜŋ ɣˈoɜk ˈiɜ , zˈaːɜ lˈen t0ˌəːɜj hˈaːj mˈyəj tʃˈiɛ6w ɗˈo2ŋ tʃˌɔ mˈo6t0 kˈɪləɡɹˌam , vˌaː2 mˈo6t0 lˈəːɜp tʃˈyɜŋ kˈaːɜ t0ˈə2m mˈuəɜj . |0 +dataset/Xanh24h/speaker_0/907.wav|ˈiw ɗˈiɛ4m , t0ˈiɛɜt0 kˈiɛ6m tʃˈi fˈiɜ vˈə6n hˈe-2ɲ vˌaː2 mˈəː4 zˈo6ŋ zˈɔ xˌoŋ kˈə2n mˈa6t0 bˈa2ŋ tʃˈy6c t0ˈiɛɜp , twˈə6n t0ˈiɛ6n vˌaː2 lˈiɲ hwˈaː6t0 tʃˌɔ xˈe-ɜc hˈaː2ŋ bˈə6n zˈo6n . |0 +dataset/Xanh24h/speaker_0/923.wav|lˈəː6n zˈy2ŋ kˌaːɜj kˈɔɜ t0ˌy2 t0ˈaːɜm ɗˌeɜn mˈyə2j vˈuɜ , mˌo5j nˈam ɗˈɛ4 hˈaːj lˈyəɜ , mˌo5j lˈyəɜ nˈam ɗˌeɜn mˈyə2j kˌɔn , lˈyəɜ ɗˈə2w kˈɔɜ tˈe4 bˈaː ɗˌeɜn nˈam kˌɔn . |0 +dataset/Xanh24h/speaker_0/934.wav|tʃˈi6 hˈyəŋ ˈyəɜc t0ˈiɜɲ , nˌeɜw bˈaːɜn hˈeɜt0 zˈiɛ6n t0ˈiɜc ŋˈo tʃˈɔŋ vˈu6 nˈa2j , kˈɔɜ tˈe4 tˈu ɲˈə6p ɣˈə2n mˈyə2j tʃˈiɛ6w ɗˈo2ŋ , kˈaːw hˈəːn kˌaːɜc lwˈaː6j kˈəɪ tʃˈyəɜc ɗˈəɪ zˈaː ɗˈi2ɲ tʃˈi6 ɗˌaː5 tʃˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/937.wav|vˌəːɜj sˈaː4n lˈyə6ŋ sˈaː4n fˈə4m ˈiɛɜn hˈiɛ6n nˈaj ɗˈaː6t0 xwˌaː4ŋ hˈaːj tʃˈam t0ˈəɜn mˌo5j nˈam , mˈaːŋ lˈaː6j zˈaːɜ tʃˈi6 xwˌaː4ŋ hˈaːj tʃˈam tʃˈiɛ6w ɗˈo2ŋ mˈo6t0 nˈam . |0 +dataset/Xanh24h/speaker_0/941.wav|t0wˈi ɲˈiɛn , ɗˌe4 kˈɔɜ lˈəː6j ɲwˈə6n t0ˈoɜt0 xˌi kˈiɲ zwˈe-ɲ ɗˈo2 ˈan t0ˈeɜt0 , vˈiɛ6c ɲˈə6p ŋwˈiɛn lˈiɛ6w sˈoɜ lˈyə6ŋ lˈəːɜn kˈɔɜ tˈe4 mˈaːŋ lˈaː6j mˈyɜc zˈaːɜ tʃˈeɜt0 xˈəɜw hˈəɜp zˈə5n , hˈo5 tʃˈəː6 tʃˌɔ bˈaː6n . |0 +dataset/Xanh24h/speaker_0/948.wav|sˈy4 zˈu6ŋ kˌaːɜc t0ˌy2 ŋˈy5 tˈe4 hˈiɛ6n sˈy6 ˈaːn t0wˈaː2n , tʃˈəɜt0 lˈyə6ŋ , ɲˌy ˈaːn t0wˈaː2n , tˈiɛ6n lˈe-2ɲ , vˌi2 sˈyɜc xwˈɛ4 , vˌi2 t0ˈyəŋ lˈaːj . |0 +dataset/Xanh24h/speaker_0/950.wav|ɗˈa6c bˈiɛ6t0 lˌaː2 vˌəːɜj ɲˌy5ŋ zˈɔ2ŋ ɗˈo2ŋ hˈo2 kˈɔɜ tˈyəŋ hˈiɛ6w nˈo4j t0ˈiɛɜŋ vˌaː2 kˈaːw kˈəɜp , zˈaːɜ ɲˈə6p ɗˈo2ŋ hˈo2 zˈəːj vˈaː2w xwˌaː4ŋ bˈaː mˈyəj ɗˌeɜn bˈa4j mˈyəj tʃˈiɛ6w ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/951.wav|ɗˈəɪ lˌaː2 mˈo6t0 ˈiɛɜw t0ˈoɜ kwˈaːn tʃˈɔ6ŋ xˌi bˈaɜt0 t0ˈaj vˈaː2w nˈuəj tʃˈu2n kwˈeɜ , bˌəː4j mˈoj tʃˈyə2ŋ sˈoɜŋ fˌaː4j tˈiɜc hˈəː6p xˌi tʃˈu2n kwˈeɜ mˈəːɜj twˈə6n t0ˈiɛ6n ɗˌe4 fˈaːɜt0 tʃˈiɛ4n . |0 +dataset/Xanh24h/speaker_0/956.wav|t0wˈi ɲˈiɛn , bˈəɜt0 ŋˈəː2 lˈaː6j nˈa2m bˈen tʃˈɔŋ , xˌi ɗˌyə6c ɗˈɛm ɗˈi nˈəɜw tʃˈiɜn , tʃˈuɜŋ kˈɔɜ fˈə2n zˈuə6t0 ɗˈa6c bˈiɛ6t0 , kˈəɜw t0ˈaː6w bˌəː4j zˈəɜt0 ɲˈiɛ2w sˈəː6j zˈaːj , mˈɔ4ŋ , zˈoɜŋ ɲˌy ɲˌy5ŋ sˈəː6j mˈi2 . |0 +dataset/Xanh24h/speaker_0/960.wav|tʃˈɔŋ ɗˈɔɜ kˈɔɜ bˈe-ɜɲ ˈɛməː2 ˈi5 vˈiɛ6t0 nˈaːm ɗˌyə6c ɲˈaɜc ˈəː4 vˈi6 tʃˈiɜ ɗˈə2w t0ˈiɛn , ɗˌaːŋ nˈɔɜj lˌaː2 mˈɔɜn ˈan vˈiɛ6t0 ɗˌyə6c tˈeɜ zˈəːɜj vˈiɲ zˈe-ɲ nˈa2j kˈɔɜ swˈəɜt0 sˈyɜ t0ˌy2 fˈaːɜp . |0 +dataset/Xanh24h/speaker_0/964.wav|vˌi2 vˈəɪ6 , ŋˈaj zˈyəɜj ɗˈəɪ lˌaː2 ɲˌy5ŋ kˈiɲ ŋˈiɛ6m , kˈi5 twˈə6t0 nˈuəj tʃˈɛw tʃˈɛw ɗˌyə6c t0ˈo4ŋ hˈəː6p t0ˌy2 tʃˈan nˈuəj tˈy6c t0ˈeɜ kˌuə4 kˌaːɜc tʃˈaːŋ tʃˈaː6j ɗˌaː5 nˈuəj tˈe-2ɲ kˈoŋ . |0 +dataset/Xanh24h/speaker_0/975.wav|vˈaː2w tˈəː2j ɗˈiɛ4m nˈa2j , ɲˈu kˈə2w mˈuə kˈəɪ kˈe-4ɲ kˌuə4 ŋˈyə2j zˈən t0ˈaŋ kˈaːw , vˌi2 vˈəɪ6 ɗˈəɪ lˌaː2 tˈəː2j ɗˈiɛ4m vˈaː2ŋ ɗˌe4 kˈiɲ zwˈe-ɲ kˈəɪ bˈɔnsaːj . |0 +dataset/Xanh24h/speaker_0/984.wav|vˌi2 zˈaːɜ tˈe-2ɲ zˈoɜŋ hˈyəw xˈaːɜ ɗˈaɜt0 nˌen bˈaː2 kˌɔn kˈə2n mˈuə hˈyəw sˈaːw zˈoɜŋ ˈəː4 ɲˌy5ŋ ɗˈiə6 tʃˈi4 bˈaːɜn zˈoɜŋ wˈi t0ˈiɜn , kˈɔɜ zˈəɪɜ tʃˈyɜŋ ɲˈə6n . |0 +dataset/Xanh24h/speaker_0/989.wav|sˈoɜ vˈoɜn kˈə2n tˈiɛɜt0 ɗˌe4 mˈəː4 kˈyə4 hˈaː2ŋ nˈoŋ sˈaː4n sˈe-6c sˌɛ5 t0wˈi2 tˈuə6c vˈaː2w kwˈi mˈo kˈiɲ zwˈe-ɲ . tˈoŋ tˈyə2ŋ , sˈoɜ vˈoɜn sˌɛ5 bˈaːw ɣˈo2m kˌaːɜc xwˈaː4n tʃˈi fˈiɜ sˈaw . |0 +dataset/Xanh24h/speaker_0/998.wav|sˈaw sˈaɜw tˈaːɜŋ nˈuəj , ŋˈyə2j nˈuəj kˈɔɜ tˈe4 tˈu hwˈe-6c ɗˌyə6c hˈaːj tʃˈam ɗˌeɜn bˈaː tʃˈam kˌɔn ɣˈaː2 ˈaːɜc , vˌəːɜj zˈaːɜ bˈaːɜn zˈaːw ɗˈo6ŋ t0ˌy2 hˈaːj tʃˈam nˈam mˈyəj ɗˌeɜn bˈaː tʃˈam ŋˈi2n ɗˈo2ŋ mˈo6t0 kˌɔn . |0 +dataset/Xanh24h/speaker_0/1000.wav|tʃwˈə4n bˌi6 ŋwˈiɛn lˈiɛ6w t0ˈyəj ŋˈɔn , ɗˈaː4m bˈaː4w vˈe6 sˈiɲ ˈaːn t0wˈaː2n tˈy6c fˈə4m , nˈaɜm bˈaɜt0 ɗˌyə6c tˈi6 hˈiɛɜw kˌuə4 xˈe-ɜc hˈaː2ŋ ɗˌe4 lˈyə6 tʃˈɔ6n kˌaːɜc lwˈaː6j sˈiɛn kwˈɛ fˈu2 hˈəː6p . |0 +dataset/Xanh24h/speaker_0/1005.wav|tʃˈaː4j kwˈaː zˈiɛ6n t0ˈiɜc zˈo6ŋ mˈo6t0 ŋˈi2n hˈɛktə , hˈɔ6 tʃˈam sˈɔɜk hˈəːn bˈaː ŋˈi2n kˌɔn ɣˈaː2 tˈi6t0 vˌaː2 ɣˈaː2 zˈoɜŋ tˈoŋ kwˈaː kˈeɜt0 hˈəː6p zˈyə5 nˈuəj ɲˈoɜt0 vˌaː2 tʃˈan tˈaː4 . |0 +dataset/Xanh24h/speaker_0/1007.wav|hˈaː6t0 bˈiɜ ɗˌyə6c zˈɛw ˈəː4 ɗˈo6 sˈə1w t0ˌy2 hˈaːj fˈəɪ4 nˈam ɗˌeɜn bˈaː fˈəɪ4 nˈam sˈaŋt0ˈimˈɛɜt0 vˌaː2 bˈaː6n kˈɔɜ tˈe4 ˈaːɜp zˈu6ŋ mˈo6t0 sˈoɜ kˈi5 twˈə6t0 xˈaːɜc ɲˈaw . |0 +dataset/Xanh24h/speaker_0/1010.wav|mˈa2w sˈaɜc kˌuə4 t0ˈyə2ŋ ɗˌyə6c tʃˈɔ6n kˈu5ŋ ɗˈɔɜŋ vˈaːj tʃˈɔ2 kwˈaːn tʃˈɔ6ŋ , vˌəːɜj ɣˈaːm mˈa2w tʃˈaɜŋ hwˌa6c ɲˌy5ŋ mˈa2w ɲˈɛ6 ɲˈaː2ŋ tˈyə2ŋ t0ˈaː6w nˌen xˌoŋ zˈaːn sˈaːŋ tʃˈɔ6ŋ vˌaː2 t0ˈiɲ t0ˈeɜ . |0 +dataset/Xanh24h/speaker_0/1013.wav|tʃˈi fˈiɜ tʃˈaːŋ tʃˈiɜ bˈaːw ɣˈo2m vˈiɛ6c lˈaɜp ɗˈa6t0 kˌaːɜc tʃˈaːŋ tˈiɛɜt0 bˌi6 ɲˌy kˈe6 sˈe-ɜc , ɗˈɛ2n , bˈaː4ŋ hˈiɛ6w , kˈamɹə , zˈaːw ɗˈo6ŋ tʃˈɔŋ xwˌaː4ŋ bˈaː mˈyəj ɗˌeɜn nˈam mˈyəj tʃˈiɛ6w ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/1023.wav|tˈyɜc ˈan tˈo sˈe-ɲ tʃˈu4 ˈiɛɜw lˌaː2 ˈan kˈɔ4 , lˈaːɜ kˈəɪ nˈɔn , zˈaw sˈaː2 lˈe-ɜc , zˈaw sˈaːm , bˈaɜp kˈaː4j , lˈaːɜ zˈaw xwˈaːj lˈaːŋ . |0 +dataset/Xanh24h/speaker_0/1041.wav|vˌəːɜj zˈiɛ6n t0ˈiɜc bˈaː sˈaː2w , ɣˈo2m ɗˈəɜt0 bˈaː5j vˌaː2 ɗˈəɜt0 vˈe6 , zˈaː ɗˈi2ɲ tʃˈi6 ŋwˈiɛ5n tˈi6 hˈyəŋ , tˈon mˈo6t0 , sˈaː5 t0ˈyə2ŋ sˈəːn ɗˌaː5 tʃwˈiɛ4n ɗˈo4j sˈaːŋ tʃˈo2ŋ ŋˈo nˈeɜp . |0 +dataset/Xanh24h/speaker_0/1042.wav|tʃwˈiɛ4n zˈaːw xwˈaː hˈɔ6k kˈi5 twˈə6t0 , tʃwˈiɛ4n ɗˈo4j kˈəː kˈəɜw kˈəɪ tʃˈo2ŋ vˈə6t0 nˈuəj zˈɔ hˈo6j nˈoŋ zˈən hwˈiɛ6n tʃˈy pˈy t0ˈo4 tʃˈyɜc . |0 +dataset/Xanh24h/speaker_0/1044.wav|ɲˌy vˈəɪ6 lˌaː2 kwˈaː4 mˈəːɜj ɗˌyə6c tˈu hwˈe-6c kˌɔ2n t0ˈyəj mˈəːɜj , xˌoŋ tʃˈɔ6n kwˈaː4 kˈɔɜ fˈə2n t0ˈaːj kwˈan kwˈɛw hˈaj xˈo hˈɛɜw , xˌoŋ bˌi6 nˈə1w tˈəːm kˈuəɜj ŋˈɔ6t0 . |0 +dataset/Xanh24h/speaker_0/1045.wav|lwˈaː6j hwˈaː kˈiɲ zwˈe-ɲ , hwˈaː tˈoŋ zˈu6ŋ ɲˌy hwˈaː hˈo2ŋ , hwˈaː kˈuɜc , hwˈaː ɗˈo2ŋ t0ˈiɛ2n kˈɔɜ zˈaːɜ tˈe-2ɲ tˈəɜp hˈəːn sˈɔ vˌəːɜj kˌaːɜc lwˈaː6j hwˈaː kˈaːw kˈəɜp ɲˌy hwˈaː lˈi , hwˈaː fˈɔ2ŋ lˈaːn , hwˈaː hˈaː4j ɗˈyə2ŋ . |0 +dataset/Xanh24h/speaker_0/1068.wav|nˌeɜw kˈaː4m tˈəɪɜ tˈiɜc vˈɪdɪəʊ kˌuə4 tʃˈuɜŋ t0ˈoj , mˈɔŋ kˌaːɜc bˈaː6n hˈa5j lˈaɪk , ʃˈeə vˌaː2 ɲˈəɜn ɗˈaŋ kˈiɜ kˈeɲ ɗˌe4 ɲˈə6n ɗˌyə6c tˈoŋ bˈaːɜw mˌo5j xˌi kˈɔɜ tˈem ɲˌy5ŋ vˈɪdɪəʊ bˈo4 ˈiɜc hˈəːn ɲˈɛɜ . |0 +dataset/Xanh24h/speaker_0/1069.wav|ɲˌy5ŋ lˈaːɜ vˈaː2ŋ hˈaːj mˈyəj t0ˈy kˈɑːɹə ŋwˈiɛn tʃˈəɜt0 ɗˌyə6c fˈu4 ɗˈəɪ2 tʃˈen mˈa6t0 bˈe-ɜɲ , mˈəːɜj tʃˈiɜɲ lˌaː2 ɗˈiɛ2w nˈəŋ t0ˈə2m zˈaːɜ tʃˈi6 kˌuə4 tʃˈiɛɜc bˈe-ɜɲ pˈiːtsə nˈa2j . |0 +dataset/Xanh24h/speaker_0/1074.wav|vˌi2 tˈeɜ , nˌeɜw bˈaː6n ɗˌaːŋ kˈɔɜ sˈa5n mˈo6t0 ŋˈuə2n vˈoɜn xˈaːɜ lˈəːɜn kˈɔɜ tˈe4 mˈe-6ɲ zˈaː6n kˈən ɲˈaɜc hˈi2ɲ tˈyɜc ɗˈə2w t0ˈy mˈuə sˈɛ tʃˈəː4 hˈaː2ŋ hwˈaːɜ ɗˌe4 tʃˌɔ twˈe . |0 +dataset/Xanh24h/speaker_0/1079.wav|ŋˈyə6c lˈaː6j , nˌeɜw bˈaː6n tʃˈəː4 tˈe-2ɲ mˈo6t0 hwˈəɜn lwˈiɛ6n vˈiɛn tˈe4 hˈi2ɲ , bˈuə6c bˈaː6n fˌaː4j kˈɔɜ ˈiɜ tˈyɜc vˈe2 tˈe4 hˈi2ɲ vˌaː2 sˈyɜc xwˈɛ4 , nˌen ɗˈəɪ kˈu5ŋ lˌaː2 ˈiw ɗˈiɛ4m ɗˌe4 bˈaː6n kˈaː4j tˈiɛ6n bˈaː4n tˈən . |0 +dataset/Xanh24h/speaker_0/1080.wav|tʃˈyəɜc xˌi ɗˈyə zˈaː kwˈiɛɜt0 ɗˈi6ɲ vˈe2 vˈiɛ6c kˈiɲ zwˈe-ɲ ɗˈo2ŋ hˈo2 , bˈaː6n kˈə2n fˌaː4j bˈiɛɜt0 ɗˌyə6c tʃˈɔŋ lˈi5ɲ vˈy6c mˌaː2 bˈaː6n sˈaɜp lˈaː2m kˈɔɜ ɲˌy5ŋ lwˈaː6j mˈo hˈi2ɲ nˈaː2w . |0 +dataset/Xanh24h/speaker_0/1081.wav|zˈyə6w kˈə2n vˌəːɜj kˈe-ɜc tʃˈeɜ bˈiɛɜn ɗˈa6c bˈiɛ6t0 vˌaː2 kwˈi tʃˈi2ɲ ˈu4 zˈiɛŋ mˈaːŋ ɗˌeɜn hˈyəŋ vˈi6 mˈe-6ɲ mˈɛ5 vˌaː2 ɗˈo6 ɗˈə6m ɗˈaː2 , t0ˈaː6w nˌen sˈy6 xˈaːɜc bˈiɛ6t0 vˌaː2 ɗˈo6 ɗˈo6k ɗˈaːɜw sˈɔ vˌəːɜj zˈyə6w kˈuəɜc t0ˈeɜ . |0 +dataset/Xanh24h/speaker_0/1090.wav|t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ hˈom nˈaj sˌɛ5 xˌoŋ t0ˈi2m hˈiɛ4w kˈə1w tʃwˈiɛ6n tˈe-2ɲ kˈoŋ ɗˈa2ŋ sˈaw ɗˈɔɜ lˌaː2 ɲˌy tˈeɜ nˈaː2w , mˌaː2 sˌɛ5 t0ˈi2m hˈiɛ4w sˈɛm zˈoɜŋ zˈe mˌaː2 ˈoŋ ɗˌaː5 ɗˈaː6t0 ɗˌyə6c tˈe-2ɲ kˈoŋ ɲˈɛɜ . |0 +dataset/Xanh24h/speaker_0/1095.wav|ˈoŋ fˈu2ŋ swˈən hwˈaː6t0 tʃˈiə sˈɛ4 zˈa2ŋ , nˈuəj lˈəː6n tˈɛw hˈyəɜŋ kˈoŋ ŋˈiɛ6p mˈəːɜj vˌə5n ɗˌyə6c zˈaːɜ hˈəːn sˈɔ vˌəːɜj nˈuəj bˈo6 ɲˌy tʃˈyəɜc kˈiə . |0 +dataset/Xanh24h/speaker_0/1101.wav|bˈaːɜn hwˈaː t0ˈeɜt0 kˈɔɜ tˈe4 nˈɔɜj lˌaː2 mˈo6t0 ˈiɜ t0ˈyə4ŋ kˈiɲ zwˈe-ɲ vˈo kˈu2ŋ tˈoŋ mˈiɲ , xˌi tʃˈi4 kˈə2n bˈɔ4 zˈaː mˈo6t0 sˈoɜ vˈoɜn ˈiɜt0 ˈɔ4j lˌaː2 ɗˌaː5 tˈu ɗˌyə6c kwˈaː4n lˈəː6j ɲwˈə6n hˈə6w hˈi5ɲ . |0 +dataset/Xanh24h/speaker_0/1103.wav|ˌaːˈi tˈɪk tˈɒk zˈəɜt0 tˈoŋ mˈiɲ , sˌɛ5 zˈe5 zˈaː2ŋ fˈaːɜt0 hˈiɛ6n nˌeɜw tʃˈuɜŋ t0ˈaː lˈaː2m vˈɪdɪəʊ xˌoŋ tʃwˈə4n sˈaːɜc vˌəːɜj ɗˈoɜj t0ˈyə6ŋ xˈe-ɜc hˈaː2ŋ fˈɒləʊ tʃˈen kˈeɲ tʃˈuɜŋ t0ˈaː . |0 +dataset/Xanh24h/speaker_0/1106.wav|vˈyə2 sˈaː xˈɔ4j ɲˌy5ŋ mˈɔɜn tʃˈaːɜŋ mˈiɛ6ŋ bˈi2ɲ tˈyə2ŋ , vˈəɪ6 ɗˈiɛ2w zˈi2 ɗˌaː5 lˈaː2m ɗˌeɜn sˈy6 xˈaːɜc bˈiɛ6t0 kˌuə4 kˈɛm sˈokˈolˈaː fɹˈəʊzən hˈaːlt0 ? |0 +dataset/Xanh24h/speaker_0/1112.wav|nˈɔɜj ɗˌeɜn mˈa6t0 hˈaː2ŋ kˈiɲ zwˈe-ɲ t0ˈeɜt0 tˌi2 xˌoŋ tˈe4 bˈɔ4 kwˈaː bˈaːɜn ɗˈaː2w t0ˈeɜt0 , bˌəː4j ɗˈəɪ lˌaː2 tˈyɜ hwˈaː ɗˈa6c tʃˈyŋ ɲˈəɜt0 ˈəː4 vˈiɛ6t0 nˈaːm vˈaː2w zˈi6p t0ˈeɜt0 ɗˌeɜn swˈən vˈe2 . |0 +dataset/Xanh24h/speaker_0/1121.wav|kˈɔɜ mˈo6t0 sˈoɜ tʃˈi4 sˈoɜ kwˈaːn tʃˈɔ6ŋ mˌaː2 bˈaː6n nˌen tˈɛw zˈɔ5j , tʃˌa4ŋ hˈaː6n ɲˌy zwˈe-ɲ sˈoɜ bˈaːɜn hˈaː2ŋ , lˈəː6j ɲwˈə6n , tʃˈi fˈiɜ , t0ˈi4 lˈe6 tʃwˈiɛ4n ɗˈo4j , t0ˈi4 lˈe6 twˈaːɜt0 . |0 +dataset/Xanh24h/speaker_0/1123.wav|mˈuə sˈaɜm tʃˈy6c t0wˈiɛɜn zˈuɜp ŋˈyə2j t0ˈiɛw zˈu2ŋ , kˈɔɜ tˈe4 tʃˈɔ6n vˌaː2 mˈuə sˈaɜm sˈaː4n fˈə4m bˈəɜt0 kˈi2 lˌuɜc nˈaː2w , ˈəː4 bˈəɜt0 kˈyɜ ɗˈə1w , tʃˈi4 kˈə2n kˈɔɜ kˈeɜt0 nˈoɜj ˌintəːnˈɛɜt . |0 +dataset/Xanh24h/speaker_0/1127.wav|t0ˈaː6j kˌaːɜc tˈe-2ɲ fˈoɜ lˈəːɜn ɲˌy hˈaː2 nˈo6j , tˈe-2ɲ fˈoɜ hˈo2 tʃˈiɜ mˈiɲ ɲˌy5ŋ ɣˈe-ɜɲ hˈaː2ŋ ŋˈo xwˈaːj nˈyəɜŋ vˈiə4 hˈɛ2 swˈəɜt0 hˈiɛ6n ŋˈa2j kˈaː2ŋ ɲˈiɛ2w . |0 +dataset/Xanh24h/speaker_0/1131.wav|t0wˈi ɲˈiɛn , ɗˌe4 tˈe-2ɲ kˈoŋ vˌəːɜj mˈo hˈi2ɲ nˈa2j , bˈaː6n kˈə2n kˈɔɜ sˈy6 t0ˈi2m hˈiɛ4w kˈi5 lˈyə5ŋ vˈe2 tˈi6 tʃˈyə2ŋ , ɲˈu kˈə2w xˈe-ɜc hˈaː2ŋ vˌaː2 kˈɔɜ tʃˈiɛɜn lˈyə6c kˈiɲ zwˈe-ɲ fˈu2 hˈəː6p . |0 +dataset/Xanh24h/speaker_0/1133.wav|bˈen kˈe-6ɲ ɗˈɔɜ , kˈɔɜ tˈe4 sˈəɪ zˈy6ŋ mˈo6t0 sˈoɜ lˈaːɜn ɲˈɔ4 ɗˌe4 t0ˈaː6w ɗˈiɛ2w kˈiɛ6n tˈaːm kwˈaːn bˈen kˈe-6ɲ bˈəː2 ˈaːw kˈaːɜ ɗˌe4 t0ˈaŋ tˈem mˈo6t0 fˈə2n tˈu ɲˈə6p tʃˌɔ mˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/1134.wav|ɗˈəɪ lˌaː2 mˈo6t0 kˈəː hˈo6j t0ˈoɜt0 ɗˌe4 t0ˈaː6w zˈaː ŋˈuə2n tˈu ɲˈə6p ˈo4n ɗˈi6ɲ ɗˈaːɜp ˈyɜŋ ɲˈu kˈə2w ɣˈy4j sˈɛ kˌuə4 sˈiɲ vˈiɛn vˌaː2 zˈaː4ŋ vˈiɛn vˈaː2w bˈaːn ŋˈa2j . |0 +dataset/Xanh24h/speaker_0/1140.wav|t0ˌy2 xˌi kˌɔ2n lˌaː2 hˈɔ6k sˈiɲ fˈo4 tˈoŋ , ˈe-ɲ vˈiɲ ɗˌaː5 sˈaːɜc ɗˈi6ɲ sˌɛ5 tˈɛw hˈɔ6k ŋˈe-2ɲ tʃˈan nˈuəj bˌəː4j ɣˈə2n ɣˈu5j tˈy6c t0ˈeɜ kˈuə6c sˈoɜŋ vˌaː2 kˈɔɜ tˈe4 kˈiɛɜm kˈoŋ vˈiɛ6c ɣˈə2n ɲˈaː2 . |0 +dataset/Xanh24h/speaker_0/1143.wav|kˈə1w ɗˈoɜj , tʃˈe-ɲ ˈe-4ɲ t0ˈeɜt0 tˈyə2ŋ ɗˌyə6c tʃˈɛw ˈəː4 ɲˈaː2 , nˈəːj lˈaː2m vˈiɛ6c , vˈan fˈɔ2ŋ , kˈyə4 hˈaː2ŋ ɗˌe4 kˈə2w mˈɔŋ mˈo6t0 nˈam mˈəːɜj ˈaːn xˈaːŋ tˈi6ɲ vˈyə6ŋ , vˈaː6n sˈy6 ɲˌy ˈiɜ . |0 +dataset/Xanh24h/speaker_0/1148.wav|bˈaː6n kˈɔɜ tˈe4 sˈy4 zˈu6ŋ kˌaːɜc kˈeɲ kwˈaː4ŋ bˈaːɜ tʃwˈiɛ2n tˈoɜŋ , ɲˌy fˈatə zˈaj , tʃˈabaŋ ɹˈəʊl , hwˌa6c kˌaːɜc kˈeɲ kwˈaː4ŋ bˈaːɜ ˈɒnlaɪn , ɲˌy wˈɛbsaɪt , mˈaː6ŋ sˈaː5 hˈo6j . |0 +dataset/Xanh24h/speaker_0/1152.wav|kwˈaː4n lˈiɜ xˈɔ sˈe-ɜc lˌaː2 mˈo6t0 kˈoŋ vˈiɛ6c kwˈaːn tʃˈɔ6ŋ , zˈuɜp tʃˈu4 hˈiɛ6w sˈe-ɜc nˈaɜm bˈaɜt0 ɗˌyə6c t0ˈi2ɲ tʃˈaː6ŋ hˈaː2ŋ hwˈaːɜ , tʃˈe-ɜɲ tˈəɜt0 twˈaːɜt0 , sˈaːj sˈɔɜt0 . |0 +dataset/Xanh24h/speaker_0/1156.wav|vˌaː2 tˈɛw xˈaː4w sˈaːɜt0 , zˈoɜŋ tˈi6t0 kˌuə4 zˈe bˈə1w ˈəː2 hˈiɛ6n ɗˈaːɜŋ zˈəɜt0 tˈi6ɲ mˈa6c zˌu2 zˈaːɜ tˈi6t0 kˈɔɜ fˈə2n hˈəːj kˈaːw hˈəːn , t0wˈi ɲˈiɛn tˈi6 tʃˈyə2ŋ lˈaː6j kˈy6c kˈi2 sˈan ɗˈɔɜn . |0 +dataset/Xanh24h/speaker_0/1161.wav|tˈoŋ t0ˈin vˈe2 t0ˈaː2j sˈaː4n kˌuə4 kˈim ʒˈɔŋˈun vˌaː2 kˌaːɜc kwˈaːn tʃˈyɜc kˈəɜp kˈaːw xˈaːɜc ˈəː4 tʃˈiɛ2w t0ˈiɛn tˈyə2ŋ zˈəɜt0 xˈɔɜ sˈaːɜc ɗˈi6ɲ vˌaː2 tˈyə2ŋ bˌi6 tʃˈɛ zˈəɜw . |0 +dataset/Xanh24h/speaker_0/1163.wav|tʃˈen tˈeɜ zˈəːɜj hˈiɛ6n nˈaj , kˈɔɜ vˈo sˈoɜ ɲˌy5ŋ bˈo6 sˈiw t0ˈə2m zˈaːɜ tʃˈi6 t0ˌy2 t0ˈɛm , ɗˈaːɜ kwˈiɜ t0ˌəːɜj sˈɛ kˈo6 , mˈaɜj bˈaj xˈiɛɜn bˈaːw ŋˈyə2j mˈəː ˈyəɜc mˈo6t0 lˈə2n ɗˌyə6c ɲˈi2n tʃˈuɜŋ t0ˈə6n mˈaɜt0 . |0 +dataset/Xanh24h/speaker_0/1170.wav|ˈaːw kˈaːɜ kˌuə4 ˈe-ɲ tʃˈu4 ˈiɛɜw vˌəːɜj kˌaːɜc lwˈaː6j kˈaːɜ ɲˌy zˈo ɗˈo2ŋ , tʃˈe , tʃˈɛɜp kˈɔ4 , zˈiɛw hˈo2ŋ , zˈuɜp kˈɔɜ ŋˈuə2n tˈu tˈem t0ˌy2 bˈoɜn mˈyəj ɗˌeɜn nˈam mˈyəj tʃˈiɛ6w ɗˈo2ŋ mˈo6t0 nˈam . |0 +dataset/Xanh24h/speaker_0/1175.wav|vˈəɪ6 nˌen sˌɛ5 kˈɔɜ ɗˈaː zˈaː6ŋ zˈaːɜ tˈe-2ɲ xˈaːɜc ɲˈaw , t0wˈi2 tˈuə6c vˈaː2w tʃˈəɜt0 lˈyə6ŋ sˈaː4n fˈə4m vˌaː2 t0ˈe6p xˈe-ɜc hˈaː2ŋ vˌaː2 zwˈe-ɲ ŋˈiɛ6p mˈuəɜn hˈyəɜŋ ɗˌeɜn . |0 +dataset/Xanh24h/speaker_0/1177.wav|mˈo hˈi2ɲ kˈiɲ zwˈe-ɲ sˈɛ ɗˈəɪ4 bˈaːɜn ɗˈo2 ˈan ɗˌaːŋ lˌaː2 sˈu hˈyəɜŋ bˌəː4j t0ˈiɜɲ t0ˈiɛ6n lˈəː6j ɗˈoɜj vˌəːɜj xˈe-ɜc hˈaː2ŋ vˌaː2 ɗˈoɜj vˌəːɜj ŋˈyə2j kˈiɲ zwˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/1184.wav|fəɹˈɑːɹi lˈaː fəɹˈɑːɹi zˈaːɜ xwˌaː4ŋ hˈaːj tʃˈiɛ6w ɗˈo lˈaː mˈi5 vˌaː2 fəɹˈɑːɹi ˈɛɜp mˈyə2j hˈaːj tˌedˌeˈɛɜp zˈaːɜ bˈoɜn tʃˈam bˈaː mˈyəj hˈaːj ŋˈi2n ɗˈo lˈaː mˈi5 . |0 +dataset/Xanh24h/speaker_0/1188.wav|zˌu2 vˈəɪ6 , nˌeɜw tˈu ɲˈɔ4 bˈyɜc tʃˈe-ɲ mˈi5 fˈə4m vˈiɛ6t0 tˌi2 t0ˈi4 tʃˈɔ6ŋ kˌaːɜc zˈɔ2ŋ mˈi5 fˈə4m nˈaːm tʃˈi4 lˌaː2 kˌɔn sˈoɜ xˈiɛm t0ˈoɜn , ˈyəɜc t0ˈiɜɲ ɗˈaː6t0 bˈaː mˈyəj tʃˈiɛ6w ɗˈo lˈaː mˈi5 tʃˈen nˈam . |0 +dataset/Xanh24h/speaker_0/1190.wav|bˌəː4j hˈiɛ6n nˈaj , ɲˈiɛ2w ŋˈyə2j kˈɔɜ ɲˈu kˈə2w tˈy zˈaː5n , zˈaː4m stɹˈɛs , nˌen vˈiɛ6c sˈy4 zˈu6ŋ kˌaːɜc lwˈaː6j nˈeɜn tˈəːm ɗˌe4 zˈe5 ŋˈu4 lˌaː2 tʃwˈiɛ6n xˌoŋ kˌɔ2n sˈaː lˈaː6 . |0 +dataset/Xanh24h/speaker_0/1191.wav|ɗˈo2ŋ tˈəː2j , kˈɔɜ tˈe4 ɲˈə6p hˈaː2ŋ hwˈaːɜ tˈɛw sˈu hˈyəɜŋ nˈo4j bˈə6t0 ɲˌy fˈim hwˈaː6t0 hˈi2ɲ , tʃwˈiɛ6n tʃˈe-ɲ , zˈuɜp ɗˈaː zˈaː6ŋ sˈaː4n fˈə4m , ɗˈo2 tʃˈəːj tˈuɜ vˈi6 , ɲˈəː2 ɗˈɔɜ t0ˈaŋ sˈyɜc hˈuɜt0 tʃˌɔ sˈoɜk . |0 +dataset/Xanh24h/speaker_0/1192.wav|tˈyɜc ˈan vˈiə4 hˈɛ2 ɗˈaː zˈaː6ŋ , zˈu6c sˈiɜc , nˈɛm tʃˈuə zˈaːɜn , sˈiɛn zˈaːɜn , hˈi2ɲ tˈyɜc t0ˈy6 fˈu6c vˈu6 zˈuɜp t0ˈiɛɜt0 kˈiɛ6m ŋˈuə2n ɲˈən lˈy6c . |0 +dataset/Xanh24h/speaker_0/1198.wav|kˌaːɜc zwˈe-ɲ ŋˈiɛ6p lˈəʊkəl bɹˈand tˈyə2ŋ swˈiɛn mˈaːŋ ɗˈa6c tʃˈyŋ vˈan hwˈaːɜ , lˈoɜj sˈoɜŋ , ɗˈa6c ɗˈiɛ4m ɗˈo6k ɗˈaːɜw kˌuə4 ɗˈiə6 fˈyəŋ mˌaː2 tˈyəŋ hˈiɛ6w hwˈaː6t0 ɗˈo6ŋ . |0 +dataset/Xanh24h/speaker_0/1200.wav|xˌi kˈiɲ zwˈe-ɲ hwˈaː lˈi tʃˈɔŋ zˈi6p t0ˈeɜt0 , vˈiɛ6c lˈyə6 tʃˈɔ6n vˈe2 lwˈaː6j hwˈaː , tʃˈəɜt0 lˈyə6ŋ vˌaː2 kˈe-ɜc bˈa2j tʃˈiɜ ɗˈe2w ɗˈɔɜŋ vˈaːj tʃˈɔ2 zˈəɜt0 kwˈaːn tʃˈɔ6ŋ . |0 +dataset/Xanh24h/speaker_0/1220.wav|ɲˌy5ŋ lwˈaː6j kˈəɪ nˈa2j xˌoŋ kˈə2n ɗˈə2w t0ˈy kwˈaːɜ ɲˈiɛ2w vˈoɜn , tʃˈi4 kˈə2n bˈɔ4 tˈəː2j zˈaːn tʃˈam sˈɔɜk , t0ˈaɜt0 t0ˈiɛ4 , kˈɔɜ tˈe4 tˈu lˈaː5j hˈaː2ŋ tʃˈu6c tʃˈiɛ6w mˌo5j tˈaːɜŋ . |0 +dataset/Xanh24h/speaker_0/1230.wav|bˈen kˈe-6ɲ ɗˈɔɜ , ɗˌe4 ɗˈaː4m bˈaː4w tʃˈəɜt0 lˈyə6ŋ sˈaː4n fˈə4m xˌi ɗˈyə zˈaː tˈi6 tʃˈyə2ŋ lˌaː2 hwˈaː2n t0wˈaː2n twˈə2n hˈi5w kˈəː , hˈəː6p t0ˈaːɜc zˈaː4 ˈiɛw kˈə2w t0ˈəɜt0 kˈaː4 kˌaːɜc hˈo6 zˈən tʃˈi4 sˈy4 zˈu6ŋ vˈən bˈɔɜn vˈi sˈiɲ . |0 +dataset/Xanh24h/speaker_0/1232.wav|mˈa6c zˌu2 zˈaːɜ tˈe-2ɲ ɗˌaː5 zˈaː4m sˈɔ vˌəːɜj tʃˈyəɜc ɗˈəɪ , ɲˌyŋ zˈoɜŋ ɣˈaː2 nˈa2j vˌə5n tˈyə2ŋ swˈiɛn bˌi6 tʃˈaɜj hˈaː2ŋ vˌaː2 ŋˈyə2j mˈuəɜn mˈuə tˈyə2ŋ fˌaː4j ɗˈa6t0 hˈaː2ŋ tʃˈyəɜc t0ˌy2 hˈaːj ɗˌeɜn bˈaː t0wˈə2n . |0 +dataset/Xanh24h/speaker_0/1235.wav|lˈəʊkəl bɹˈand hˈaj kˌɔ2n ɣˈɔ6j lˌaː2 tˈyəŋ hˈiɛ6w ɗˈiə6 fˈyəŋ lˌaː2 mˈo6t0 zˈaː6ŋ tˈyəŋ hˈiɛ6w kˈɔɜ ŋˈuə2n ɣˈoɜk nˈəːj sˈaː4n swˈəɜt0 vˌaː2 tˈi6 tʃˈyə2ŋ t0ˈiɛw tˈu6 tʃˈu4 ˈiɛɜw t0ˈə6p tʃˈuŋ ˈəː4 mˈo6t0 xˈu vˈy6c , ɗˈiə6 fˈyəŋ kˈu6 tˈe4 . |0 +dataset/Xanh24h/speaker_0/1240.wav|kwˈi tʃˈi2ɲ tʃˈeɜ bˈiɛɜn ɗˈəːn zˈaː4n tʃˈiɜɲ lˌaː2 lˈiɜ zˈɔ tˈeɪk ɐwˈeɪ tʃˈiɜɲ lˌaː2 mˈo hˈi2ɲ zˈi2ɲ lˈəː2j lˈiɜ t0ˈyə4ŋ tʃˌɔ ɲˌy5ŋ ŋˈyə2j kˈiɲ zwˈe-ɲ hwˌa6c ɗˈaːɜŋ xˈəː4j ŋˈiɛ6p . |0 +dataset/Xanh24h/speaker_0/1247.wav|tˈeɜ ɲˌyŋ ˈiɜt0 ˈaːj bˈiɛɜt0 zˈa2ŋ , ɗˌe4 kˈɔɜ ɗˌyə6c tˈe-2ɲ kˈoŋ ɲˌy ŋˈa2j hˈom nˈaj , ˈoŋ t0wˈaː4n ɗˌaː5 fˌaː4j tʃˈaː4j kwˈaː mˈo6t0 hˈe-2ɲ tʃˈi2ɲ zˈaː2j , ɗˈəɪ2 zˈaːn nˈaːn vˌaː2 tˈy4 tˈe-ɜc . |0 +dataset/Xanh24h/speaker_0/1251.wav|kˌaːɜc lwˈaː6j kwˈaː2 t0ˈa6ŋ kˈaːw kˈəɜp ɲˌy ɗˈo2ŋ hˈo2 , ɗˈiɛ6n twˈaː6j , mˈi5 fˈə4m kˈu5ŋ ɗˌyə6c ɲˈiɛ2w ŋˈyə2j lˈyə6 tʃˈɔ6n lˈaː2m kwˈaː4 bˈiɛɜw t0ˈeɜt0 tʃˌɔ ɗˈoɜj t0ˈaːɜc , xˈe-ɜc hˈaː2ŋ kwˈaːn tʃˈɔ6ŋ . |0 +dataset/Xanh24h/speaker_0/1253.wav|ɗˌeɜn ɗˈəɪ tˌi2 t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˈin t0ˈo4ŋ kˈeɜt0 lˈaː6j mˈo6t0 lˈə2n nˈyə5 , ɗˌe4 kwˈiɜ vˈi6 vˌaː2 kˌaːɜc bˈaː6n nˈaɜm zˈɔ5 hˈəːn vˌaː2 tʃˈi t0ˈiɛɜt0 ŋˈaɜn ɣˈɔ6n hˈəːn ɲˈɛɜ . |0 +dataset/Xanh24h/speaker_0/1263.wav|mˈo6t0 sˈoɜ bˈyɜc tʃˈe-ɲ fˈɔŋ twˈi4 ɗˌyə6c ˈyə tʃˈuə6ŋ ŋˈaj fˈiəɜ tˈə2n t0ˈaː2j lˌaː2 tʃˈe-ɲ kˈaːɜ tʃˈɛɜp vˈyə6t0 vˈu5 mˈon , tʃˈe-ɲ hwˈaː sˈɛn , tʃˈe-ɲ mˈaː5 ɗˈaːɜw tˈe-2ɲ kˈoŋ . |0 +dataset/Xanh24h/speaker_0/1265.wav|vˌəːɜj sˈy6 fˈaːɜt0 tʃˈiɛ4n kˌuə4 ŋˈe-2ɲ kˈoŋ ŋˈiɛ6p ɡˈeɪm , kwˈaːɜn ɡˈeɪm ɗˌaː5 tʃˈəː4 tˈe-2ɲ ɗˈiɛ4m ɗˌeɜn hˈəɜp zˈə5n ɗˈoɜj vˌəːɜj kˌaːɜc ɡˈeɪm tˈu4 , ɗˈa6c bˈiɛ6t0 lˌaː2 kˌaːɜc bˈaː6n nˈaːm . |0 +dataset/Xanh24h/speaker_0/1266.wav|vˌəːɜj ɲˌy5ŋ ɗˈa6c ɗˈiɛ4m zˈiɛŋ bˈiɛ6t0 vˌaː2 bˈiɜ kwˈiɛɜt0 tʃˈeɜ bˈiɛɜn tʃwˈiɛ2n tˈoɜŋ , kˈaːɜ xˈɔ lˈaː2ŋ vˈu5 ɗˈaː6j xˌoŋ tʃˈi4 lˌaː2 mˈo6t0 mˈɔɜn ŋˈɔn , mˌaː2 kˌɔ2n lˌaː2 bˈiɛ4w t0ˈyə6ŋ kˌuə4 sˈy6 ɣˈaɜn bˈɔɜ vˌaː2 tʃwˈiɛ2n tˈoɜŋ zˈaː ɗˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/1269.wav|ɗˌe4 kˈiɲ zwˈe-ɲ tˈe-2ɲ kˈoŋ tʃˈɔŋ zˈi6p vˈiəɜ tˈə2n t0ˈaː2j , bˈaː6n kˈə2n tʃwˈə4n bˌi6 ɗˈəɪ2 ɗˈu4 ŋˈuə2n lˈy6c , bˈaːw ɣˈo2m ŋˈuə2n vˈoɜn , ɲˈən lˈy6c , hˈaː2ŋ hwˈaːɜ , zˈi6c vˈu6 . |0 +dataset/Xanh24h/speaker_0/1272.wav|ɗˈoɜj vˌəːɜj ŋwˈi kˈəː xˈiɛɜw nˈaː6j t0ˌy2 xˈe-ɜc hˈaː2ŋ vˌaː2 kˈiɛ6n t0ˈu6ŋ , ɲˈaː2 bˈaːɜn hˈaː2ŋ kˈə2n lˈyə6 tʃˈɔ6n ŋˈuə2n kˈuŋ kˈəɜp ɗˈaːɜŋ t0ˈin kˈəɪ6 vˌaː2 t0wˈən tˈu4 ŋˈiɛm ŋˈa6t0 kˌaːɜc kwˈi ɗˈi6ɲ fˈaːɜp lwˈə6t0 . |0 +dataset/Xanh24h/speaker_0/1279.wav|tˈaj vˌi2 ɗˈa6t0 bˈe-ɜɲ kˈyəɜj t0ˈaː6j kˌaːɜc tʃˈuŋ t0ˈəm t0ˈo4 tʃˈyɜc t0ˈiɛ6c kˈyəɜj ɲˌy tʃˈyəɜc ɗˈəɪ , ɲˈiɛ2w bˈaː6n tʃˈɛ4 hˈiɛ6n nˈaj mˈuəɜn kˈɔɜ mˈo6t0 tʃˈiɛɜc bˈe-ɜɲ kˈyəɜj mˈaːŋ zˈəɜw ˈəɜn zˈiɛŋ kˌuə4 mˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/1284.wav|tʃˈaː4j kwˈaː mˈo6t0 tˈəː2j zˈaːn lˈaː2m vˈiɛ6c sˈaː ɲˈaː2 , vˌi2 mˈuəɜn kˈɔɜ ɲˈiɛ2w tˈəː2j zˈaːn hˈəːn bˈen kˌɔn kˌaːɜj vˌaː2 tʃˈam sˈɔɜk zˈaː ɗˈi2ɲ nˌen ˈe-ɲ kwˈiɛɜt0 ɗˈi6ɲ ŋˈi4 vˈiɛ6c . |0 +dataset/Xanh24h/speaker_0/1285.wav|ˈoŋ fˈaː6m ŋwˈiɛn bˈi2ɲ , tʃˈyə2ŋ fˈɔ2ŋ nˈoŋ ŋˈiɛ6p fˈaːɜt0 tʃˈiɛ4n nˈoŋ tˈon hwˈiɛ6n vˈan tʃˈəɜn tʃˌɔ bˈiɛɜt0 , kˈəɪ zˈyə6c lˈiɛ6w t0ˌy2 lˈə1w ɗˌaː5 t0ˈo2n t0ˈaː6j vˌaː2 fˈaːɜt0 tʃˈiɛ4n ˈəː4 ɲˈiɛ2w nˈəːj ˈəː4 hwˈiɛ6n vˈan tʃˈəɜn . |0 +dataset/Xanh24h/speaker_0/1287.wav|vˌi2 ɲˈu kˈə2w mˈuə sˈaɜm , sˈy4 zˈu6ŋ kˌaːɜc zˈi6c vˈu6 lˈiɛn kwˈaːn ɗˌeɜn ŋˈa2j vˈiəɜ tˈə2n t0ˈaː2j tˈyə2ŋ zˈəɜt0 lˈəːɜn , nˌen bˈaː6n kˈə2n tʃwˈə4n bˌi6 ɗˈəɪ2 ɗˈu4 hˈaː2ŋ hwˈaːɜ , zˈi6c vˈu6 ɗˌe4 ɗˈaːɜp ˈyɜŋ ɲˈu kˈə2w kˌuə4 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1289.wav|mˈo6t0 bˈyɜc tʃˈe-ɲ kˌuə4 vˈaːn ɣˈɔɣ hˈaj pɪkˈasəʊ kˈɔɜ tˈe4 kˈɔɜ zˈaːɜ ɗˌeɜn kˈaː4 tʃˈam tʃˈiɛ6w ɗˈo lˈaː hˈaj ɗˈi4ɲ kˈaːw lˌaː2 bˈo6 bˈaː bˈyɜc tʃˈe-ɲ ɲˈaː2 tˈəː2 . |0 +dataset/Xanh24h/speaker_0/1290.wav|ɗˌe4 nˈuəj ɗˌyə6c zˈoɜŋ ɣˈaː2 kwˈiɜ hˈiɛɜm vˌaː2 kˈo4 tʃwˈiɛ2n ɗˈaː6j tˈe-2ɲ kˈoŋ , tʃˈyəɜc hˈeɜt0 bˈaː2 kˌɔn nˌen t0ˈi2m hˈiɛ4w kwˈaː vˈe2 kˌaːɜc kˈi5 twˈə6t0 vˌaː2 kˈe-ɜc nˈuəj ɣˈaː2 ɗˈoŋ t0ˈaː4w kˈəː bˈaː4n sˈaw ɗˈəɪ . |0 +dataset/Xanh24h/speaker_0/1291.wav|bˈaː6n kˈə2n sˈəɪ zˈy6ŋ mˈo6t0 tʃˈaːŋ kˈaːɜ ɲˈən hwˌa6c vˈaːɜn bˈe-ɜc tʃwˈiɛn ŋˈiɛ6p , tˈyə2ŋ swˈiɛn ɗˈaŋ t0ˈaː4j kˌaːɜc bˈaː2j vˈiɛɜt0 , hˈi2ɲ ˈe-4ɲ , vˈɪdɪəʊ vˈe2 hˈaː4j sˈaː4n ɗˌe4 tˈu hˈuɜt0 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1301.wav|bˈen kˈe-6ɲ kˌaːɜc lwˈaː6j bˈe-ɜɲ ŋˈɔ6t0 tʃwˈiɛ2n tˈoɜŋ , kˌaːɜc t0ˈiɛ6m kˈə2n kˈə6p ɲˈə6t0 sˈu hˈyəɜŋ mˈəːɜj , zˈəːɜj tˈiɛ6w kˌaːɜc lwˈaː6j bˈe-ɜɲ ɗˈo6k ɗˈaːɜw , mˈəːɜj lˈaː6 . |0 +dataset/Xanh24h/speaker_0/1305.wav|ˈəː4 hwˈiɛ6n lˈaːŋ tʃˈe-ɜɲ , bˈəɜt0 kˈi2 ŋˈyə2j zˈən nˈaː2w kˈu5ŋ ɣˈɔ6j ˈoŋ hˈaː2 xˈaɜc sˈəm lˌaː2 vˈuə kˈaːɜ t0ˈə2m bˌəː4j tʃˈiɜɲ mˈo hˈi2ɲ nˈa2j ɗˌaː5 mˈaːŋ vˈe2 tʃˌɔ ˈoŋ tˈu ɲˈə6p t0ˈiɛ2n tʃˈiɛ6w mˌo5j ŋˈa2j . |0 +dataset/Xanh24h/speaker_0/1309.wav|kˈi5 twˈə6t0 nˈa2j ɲˈi2n tʃˈuŋ xˌoŋ xˈɔɜ , ɲˌyŋ kˈə2n lˈiw ˈiɜ ɲˈəɜt0 lˌaː2 vˈiɛ6c lˈaː2m ɲˈaː2 tʃˌɔ tʃˈim ˈiɛɜn zˈɔ tʃˈuɜŋ ɗˌaː5 kwˈɛn tˈuə6c vˌəːɜj mˈoj tʃˈyə2ŋ hwˈaːŋ zˈaː5 ŋwˈaː2j tˈiɛn ɲˈiɛn . |0 +dataset/Xanh24h/speaker_0/1310.wav|ɲˌy5ŋ lwˈaː2j hwˈaː vˌəːɜj mˈa2w sˈaɜc zˈaː6c zˈəː5 , ɗˌaː5 ɗˈɔɜŋ vˈaːj tʃˈɔ2 kwˈaːn tʃˈɔ6ŋ tʃˈɔŋ vˈiɛ6c tʃˈaːŋ tʃˈiɜ xˌoŋ zˈaːn vˌaː2 t0ˈaː6w nˌen bˈə2w xˌoŋ xˈiɜ fˈəɜn xˈəː4j tʃˈɔŋ zˈi6p t0ˈeɜt0 ŋwˈiɛn ɗˈaɜn . |0 +dataset/Xanh24h/speaker_0/1311.wav|nˌeɜw bˈaː6n lˌaː2 ŋˈyə2j ˈyə ɲˈi2n , kˈɔɜ nˈu6 kˈyə2j t0wˈaː2n ɗˈaɜŋ kˈu2ŋ vˌəːɜj t0ˈaːɜc fˈɔŋ lˈaː2m vˈiɛ6c ɲˈe-ɲ ɲˈɛ6n , tʃˈaɜc tʃˈaɜn sˌɛ5 lˈaː2m hˈaː2j lˈɔ2ŋ xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1313.wav|vˈiɛ6t0 nˈaːm kˈɔɜ zˈən sˈoɜ hˈəːn tʃˈiɜn mˈyəj bˈa4j tʃˈiɛ6w ŋˈyə2j , tʃˈɔŋ ɗˈɔɜ kˈɔɜ xwˌaː4ŋ bˈa4j mˈyəj fˈə2n tʃˈam zˈən sˈoɜ ˈəː4 ɗˈo6 t0ˈuə4j lˈaːw ɗˈo6ŋ . |0 +dataset/Xanh24h/speaker_0/1314.wav|ŋwˈaː2j zˈaː , vˈiɛ6c t0ˈaː6w zˈaː xˌoŋ zˈaːn twˈaː4j mˈaːɜj , t0ˈiɛ6n ŋˈi kˈu5ŋ ɲˌy xˈu vˈy6c tʃˈəːj ɡˈeɪm zˈiɛŋ bˈiɛ6t0 tʃˌɔ ɲˌy5ŋ ŋˈyə2j hˈuɜt0 tˈuəɜc sˌɛ5 t0ˈaː6w sˈy6 twˈaː4j mˈaːɜj vˌaː2 hˈaː2j lˈɔ2ŋ tʃˌɔ xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1319.wav|ɲˈən vˈiɛn t0ˈy vˈəɜn tˈə4m mˈi5 lˌaː2 ɲˌy5ŋ ŋˈyə2j lˈaː2m vˈiɛ6c tʃˈɔŋ ŋˈe-2ɲ tˈə4m mˈi5 lˈaː2m ɗˈɛ6p vˌəːɜj ɲˈiɛ6m vˈu6 tʃˈiɜɲ lˌaː2 t0ˈy vˈəɜn zˈəːɜj tˈiɛ6w . |0 +dataset/Xanh24h/speaker_0/1323.wav|kˈəɪ kˈe-4ɲ xˌoŋ tʃˈi4 zˈuɜp t0ˈoj ɗˈiɛ4m ŋˈoj ɲˈaː2 tˈem lˈuŋ lˈiɲ , zˈy6c zˈəː5 , mˌaː2 kˌɔ2n mˈaːŋ ˈiɜ ŋˈiə5 fˈɔŋ twˈi4 t0ˈoɜt0 lˈe-2ɲ , kˈə2w mˈɔŋ mˈo6t0 nˈam mˈəːɜj mˈaj mˈaɜn , sˈuŋ t0ˈuɜc . |0 +dataset/Xanh24h/speaker_0/1336.wav|vˌəːɜj ŋˈe-2ɲ ŋˈe2 bˈaːɜn zˈi6c vˈu6 nˈa2j tˌi2 t0ˈiɛw tʃˈiɜ xˈe-ɜc hˈaː2ŋ ɗˈe-ɜɲ zˈaːɜ ɗˈə2w t0ˈiɛn tʃˈiɜɲ lˌaː2 tˈaːɜj ɗˈo6 vˌaː2 zˈi6c vˈu6 mˌaː2 hˈɔ6 ɲˈə6n ɗˌyə6c xˌi hˈɔ6 ɗˈa6t0 tʃˈən ɗˌeɜn hˈəʊmsteɪ kˌuə4 bˈaː6n . |0 +dataset/Xanh24h/speaker_0/1337.wav|ɗˈəɪ lˌaː2 kˈə1w tʃwˈiɛ6n ɗˈəː2j tˈy6c vˈe2 mˈo6t0 tʃˈuɜ t0ˈy2ŋ kˈiɲ zwˈe-ɲ hˈɛw ŋwˈaː6j lˈaːj tʃˈəː4 vˈe2 tʃˈan nˈuəj zˈe vˌaː2 kˈe-ɜc tˈyɜc kˈiɲ zwˈe-ɲ tʃˈəː4 tˈe-2ɲ t0ˈi4 fˈuɜ tʃˈi4 tʃˈɔŋ hˈaːj nˈam . |0 +dataset/Xanh24h/speaker_0/1350.wav|tʃˈɔŋ ɲˌy5ŋ vˈɪdɪəʊ tʃˈyəɜc , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ ɗˌaː5 zˈəːɜj tˈiɛ6w t0ˌəːɜj kˌaːɜc bˈaː6n ɲˌy5ŋ kˌɔn vˈə6t0 sˌɛ5 tʃˈan nˈuəj , kˈu5ŋ ɲˌy kˌaːɜc kˈi5 twˈə6t0 tʃˈan nˈuəj hˈiɛ6w kwˈaː4 ɗˌe4 tˈu lˈaː6j lˈəː6j ɲwˈə6n kˈaːw . |0 +dataset/Xanh24h/speaker_0/1352.wav|ɗˌeɜn vˌəːɜj vˈɪdɪəʊ ŋˈa2j hˈom nˈaj , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˌɛ5 tʃˈiə sˈɛ4 mˈo6t0 sˈoɜ tˈoŋ t0ˈin , kˈiɲ ŋˈiɛ6m vˌaː2 tʃˈiɛɜn lˈyə6c hˈo5 tʃˈəː6 bˈaː6n xˈəː4j ŋˈiɛ6p hˈiɛ6w kwˈaː4 . |0 +dataset/Xanh24h/speaker_0/1355.wav|tʃˈiɜɲ vˌi2 ɲˌy5ŋ lˈəː6j ˈiɜc tʃˈen , ŋˈe-2ɲ tˈyəŋ mˈaː6j ɗˈiɛ6n t0ˈy4 ɗˌaː5 fˈaːɜt0 tʃˈiɛ4n zˈəɜt0 ɲˈe-ɲ tʃˈɔɜŋ tʃˈɔŋ ɲˌy5ŋ nˈam ɣˈə2n ɗˈəɪ , ɲˈəɜt0 lˌaː2 sˈaw xˌi ɗˈaː6j zˈi6c kˈɒvɪd mˈyə2j tʃˈiɜn bˈu2ŋ fˈaːɜt0 . |0 +dataset/Xanh24h/speaker_0/1358.wav|sˈy6 sˈaːɜŋ t0ˈaː6w tʃˈɔŋ vˈiɛ6c lˈaː2m bˈe-ɜɲ xˌoŋ tʃˈi4 lˈaː2m fˈɔŋ fˈuɜ tˈem bˈyə5 ˈan t0ˈeɜt0 , mˌaː2 kˌɔ2n t0ˈaː6w nˌen tʃˈaː4j ŋˈiɛ6m tˈuɜ vˈi6 vˌaː2 ɗˈo6k ɗˈaːɜw tʃˌɔ ŋˈyə2j ɲˈə6n kwˈaː2 . |0 +dataset/Xanh24h/speaker_0/1364.wav|zˈaːɜ bˈaːɜn t0ˈaː6j nˈoŋ tˈon kˈɔɜ tˈe4 zˈaːw ɗˈo6ŋ t0ˌy2 hˈaːj mˈyəj ŋˈi2n ɗˌeɜn hˈaːj mˈyəj lˈam ŋˈi2n lˌaː2 hˈəː6p lˈiɜ , vˈyə2 hˈəː6p t0ˈuɜj t0ˈiɛ2n xˈe-ɜc hˈaː2ŋ mˌaː2 vˌə5n ɗˈaː4m bˈaː4w lˈəː6j ɲwˈə6n . |0 +dataset/Xanh24h/speaker_0/1367.wav|ɲˈi2n tʃˈuŋ , lwˈaː2j tʃˈɛw tʃˈɛw xˈaːɜ zˈe5 nˈuəj , xˌoŋ kˈɛɜn tˈyɜc ˈan , tˈəː2j t0ˈiɛɜt0 , vˌaː2 ɗˈa6c bˈiɛ6t0 lˌaː2 lˈəː6j ɲwˈə6n mˈaːŋ lˈaː6j kˈy6c kˈi2 kˈaːw tʃˌɔ ŋˈyə2j nˈuəj . |0 +dataset/Xanh24h/speaker_0/1368.wav|swˈən fˈoɜ ɗˈə1w ɗˈə1w kˈu5ŋ bˈaɜt0 ɣˈa6p , zˈu ɲˈə6p vˈe2 hˈaː2 nˈo6j vˈaː2w mˈuə2 hˈɛ2 nˈam nˈaj ɲˌyŋ ɣˈə2n ɗˈəɪ tʃˈaː2 tʃˈe-ɲ zˈaː5 t0ˈaj ɗˌaː5 tʃˈəː4 tˈe-2ɲ tʃˈaː2w lˈiw hˈɔt0 xˈaɜp tˈe-2ɲ fˈoɜ hˈo2 tʃˈiɜ mˈiɲ vˌaː2 ɗˈaː2 nˈa5ŋ . |0 +dataset/Xanh24h/speaker_0/1379.wav|sˈy6 lˈyə6 tʃˈɔ6n nˈa2j xˌoŋ tʃˈi4 mˈaːŋ lˈaː6j xˌoŋ zˈaːn t0ˈyəj mˈəːɜj vˌaː2 zˈy6c zˈəː5 , mˌaː2 kˌɔ2n tʃˈyəɜ ɗˈy6ŋ ˈiɜ ŋˈiə5 fˈɔŋ twˈi4 t0ˈoɜt0 lˈe-2ɲ , mˈo6t0 lˈəː2j tʃˈuɜc mˈy2ŋ nˈam mˈəːɜj tʃˈaː2n ɗˈəɪ2 mˈaj mˈaɜn vˌaː2 hˈe-6ɲ fˈuɜc . |0 +dataset/Xanh24h/speaker_0/1380.wav|xˌi ɗˌaː5 nˈaɜm tʃˈaɜc ɗˌyə6c kˌaːɜc kˈi5 twˈə6t0 tʃˈan nˈuəj zˈe bˈe-ɜc tˈaː4w , nˈam hˈaːj ŋˈi2n mˈyə2j sˈaɜw , ˈe-ɲ bˈaɜt0 ɗˈə2w xˈəː4j ŋˈiɛ6p vˌəːɜj mˈyə2j kˌɔn zˈe . |0 +dataset/Xanh24h/speaker_0/1383.wav|zwˈe-ɲ tˈu mˈo6t0 ŋˈa2j hˈaːj mˈyəj mˈaɜj , bˈa2ŋ hˈaːj mˈyəj mˈaɜj ɲˈən vˌəːɜj mˈyə2j t0ˈiɛɜŋ ɲˈən vˌəːɜj bˈaː ŋˈi2n ɗˈo2ŋ , bˈa2ŋ sˈaɜw tʃˈam ŋˈi2n ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/1384.wav|sˈaː4n fˈə4m ˈoɜk ɲˈo2j kˌuə4 kˈyə2ŋ ɗˌyə6c t0ˈiɛw tˈu6 t0ˈaː6j ɲˈiɛ2w ɲˈaː2 hˈaː2ŋ , kwˈaːɜn ˈan tʃˈen ɗˈiə6 bˈaː2n t0ˈi4ɲ hˈyŋ ˈiɛn vˌaː2 kˌaːɜc t0ˈi4ɲ lˈən kˈə6n . |0 +dataset/Xanh24h/speaker_0/1395.wav|kˌaːɜc tʃˈəː6 kˈyə4 xˈə4w ɲˌy tʃˈəː6 bˈɔɜŋ kˌaːɜj t0ˈaː6j kwˈaː4ŋ nˈiɲ vˌaː2 tʃˈəː6 t0ˈən tˈe-ɲ t0ˈaː6j lˈaː6ŋ sˈəːn kˈuŋ kˈəɜp ŋˈuə2n hˈaː2ŋ ɗˈaː zˈaː6ŋ vˈe2 kˈiɛ4w zˈaːɜŋ vˌaː2 zˈaːɜ tˈe-2ɲ hˈəː6p lˈiɜ . |0 +dataset/Xanh24h/speaker_0/1396.wav|hˈə2w hˈeɜt0 ɲˌy5ŋ ŋˈyə2j mˈuəɜn bˈyəɜc tʃˈən vˈaː2w lˈi5ɲ vˈy6c ˈɛɜp ɟˈəʊɜvˌaː2 bˈe ɗˈe2w mˈɔŋ mˈuəɜn kˈɔɜ tˈe4 sˈəːɜm tˈe-2ɲ kˈoŋ zˈyə6 tʃˈen tʃˈuə5j kˈyə4 hˈaː2ŋ ɗˌaː5 kˈɔɜ t0ˈiɛ2n t0ˈam ɲˈəɜt0 ɗˈi6ɲ tʃˈen tˈi6 tʃˈyə2ŋ . |0 +dataset/Xanh24h/speaker_0/1397.wav|ŋwˈaː2j zˈaː , tʃˈuɜŋ kˌɔ2n ɗˌyə6c sˈy4 zˈu6ŋ tʃˈɔŋ ɲˈaː2 hˈaː2ŋ ɗˌe4 t0ˈaː6w zˈaː xˌoŋ zˈaːn kˈɔɜ mˈu2j tˈəːm zˈe5 tʃˈi6w ɲˈa2m zˈuɜp tˈy6c xˈe-ɜc , ŋˈɔn mˈiɛ6ŋ hˈəːn . |0 +dataset/Xanh24h/speaker_0/1403.wav|ɲˌy5ŋ ŋwˈiɛn lˈiɛ6w nˈa2j kˈɔɜ t0ˈaːɜc zˈu6ŋ hˈo5 tʃˈəː6 t0ˈiɛw hwˈaːɜ , xˈaːɜŋ vˈaɪɹəs , hˈo5 tʃˈəː6 tʃˈyɜc nˈaŋ ɣˈaːn kˌuə4 ɣˈaː2 ɲˈa2m nˈəŋ kˈaːw tʃˈəɜt0 lˈyə6ŋ tˈyɜc ˈan tʃˌɔ ɣˈaː2 . |0 +dataset/Xanh24h/speaker_0/1405.wav|tʃˈɔŋ zˈi6p t0ˈeɜt0 , bˈəɜt0 kˈi2 bˈuə4j t0ˈiɛ6c nˈaː2w kˈu5ŋ tʃˈəː4 nˌen ˈəɜm kˈuɜŋ vˌaː2 tʃˈaː2n ɗˈəɪ2 nˈiɛ2m vˈuj xˌi tʃˈen bˈaː2n t0ˈiɛɜp xˈe-ɜc swˈəɜt0 hˈiɛ6n ɗˈiə5 kˈɛ6w lˈaː6c , kˈɛ6w vˈy2ŋ . |0 +dataset/Xanh24h/speaker_0/1414.wav|ɗˈəɪ tˈy6c sˈy6 lˌaː2 mˈo6t0 mˈɔɜn ˈan vˈa6t0 t0ˈiɛ2m nˈaŋ , sˈa5n sˈaː2ŋ ɣˈɔɜp vˈuj tʃˈɔŋ xˌoŋ xˈiɜ ˈəɜm ˈaːɜp vˌaː2 tʃˈaːŋ tʃˈɔ6ŋ kˌuə4 mˌo5j zˈaː ɗˈi2ɲ vˈiɛ6t0 nˈaːm zˈi6p t0ˈeɜt0 . |0 +dataset/Xanh24h/speaker_0/1417.wav|kwˈaːɜn ɡˈeɪm kˈə2n ɗˈə2w t0ˈy vˈaː2w kˌaːɜc tˈiɛɜt0 bˌi6 hˈiɛ6n ɗˈaː6j ɲˌy mˈaɜj t0ˈiɜɲ kˈəɜw hˈi2ɲ kˈaːw , mˈaː6ŋ hˈi2ɲ sˈaɜc nˈɛɜt0 , mˈaː6ŋ ˌintəːnˈɛɜt ˈo4n ɗˈi6ɲ ɗˌe4 ɗˈaːɜp ˈyɜŋ ɲˈu kˈə2w tʃˈəːj ɡˈeɪm kˌuə4 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1418.wav|bˈaː2j vˈiɛɜt0 nˈa2j kˈu5ŋ ɗˈe2 kˈə6p ɗˌeɜn ˈoŋ kˈu6 kˈɔɜ t0ˈen , ˈoŋ lˈe tʃˈɔ6ŋ lˈe6 , vˈoɜn lˌaː2 kˈi5 sˈy sˈəɪ zˈy6ŋ bˈɔ4 ŋˈe2 vˈe2 kwˈe nˈuəj zˈyəɜj . |0 +dataset/Xanh24h/speaker_0/1419.wav|tʃˈuə2ŋ tʃˈaː6j lˌaː2 mˈo6t0 fˈə2n kwˈaːn tʃˈɔ6ŋ tʃˈɔŋ tʃˈan nˈuəj , ˈe-4ɲ hˈyə4ŋ tʃˈy6c t0ˈiɛɜp ɗˌeɜn sˈyɜc xwˈɛ4 vˌaː2 xˈaː4 nˈaŋ sˈiɲ tʃˈyə2ŋ , fˈaːɜt0 tʃˈiɛ4n kˌuə4 vˈə6t0 nˈuəj . |0 +dataset/Xanh24h/speaker_0/1420.wav|nˌeɜw bˈaː6n ɗˌaːŋ kwˈaːn t0ˈəm ɗˌeɜn vˈiɛ6c tʃˈo2ŋ vˌaː2 bˈaːɜn zˈoɜŋ bˈiɜ ɗˈo6k lˈaː6 nˈa2j , tʃˈɔŋ vˈɪdɪəʊ ŋˈa2j hˈom nˈaj , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˌɛ5 zˈuɜp bˈaː6n t0ˈi2m hˈiɛ4w nˈɔɜ . |0 +dataset/Xanh24h/speaker_0/1421.wav|tʃˈiɜɲ ɲˌy5ŋ tʃˈiɛɜc mˈaɜj ˈe-4ɲ kˌuə4 ɗˈiɛ6n twˈaː6j tˈoŋ mˈiɲ , xˌoŋ fˌaː4j kˌɔn ŋˈyə2j hˈaj tˈyəŋ hˈiɛ6w , ɗˌaː5 xˈiɛɜn ɗˈaː2n ˈoŋ kwˈaːn t0ˈəm hˈəːn ɗˌeɜn ŋwˈaː6j hˈi2ɲ kˌuə4 hˈɔ6 . |0 +dataset/Xanh24h/speaker_0/1422.wav|kˈɔɜ xˌi ɗˌaː5 ŋˈi5 ɗˌeɜn t0ˌy2 bˈɔ4 ɗˌe4 kˈiɛɜm kˈoŋ vˈiɛ6c xˈaːɜc , lˈyəɜ nˈuəj tˈy4 ɗˈə2w t0ˈiɛn ɣˈaː2 bˌi6 bˈe6ɲ , kˈy lˈan zˈaː tʃˈeɜt0 hˈaː2ŋ lwˈaː6t0 , tʃˈyɜŋ ɗˈɛ4 xˌoŋ ɗˈe2w , xˈiɛɜn t0ˈoj zˈəɜt0 lˈɔ lˈaɜŋ . |0 +dataset/Xanh24h/speaker_0/1427.wav|tˈy6c fˈə4m hˈi5w kˈəː ɗˌyə6c sˈaː4n swˈəɜt0 tˈɛw kˌaːɜc ŋwˈiɛn t0ˈaɜc kˌuə4 nˈoŋ ŋˈiɛ6p hˈi5w kˈəː , xˌoŋ tʃˈyəɜ fˈən bˈɔɜn t0ˈo4ŋ hˈəː6p , tˈuəɜc tʃˈy2 sˈə1w vˌaː2 kˌaːɜc hwˈaːɜ tʃˈəɜt0 ɗˈo6k hˈaː6j xˈaːɜc . |0 +dataset/Xanh24h/speaker_0/1436.wav|tˈɛw tˈoɜŋ kˈe kˌuə4 zˈəːɜj tʃwˈiɛ2n tˈoŋ , kˈe4 t0ˌy2 xˌi lˈen nˈaɜm kwˈiɛ2n , ˈoŋ kˈim ʒˈɔŋˈun ɗˌaː5 t0ˈiɛɜn hˈe-2ɲ hˈəːn t0ˈaːɜm mˈyəj kˈuə6c tˈy4 t0ˈen lˈyə4 ɗˈaː6n ɗˈaː6w hwˌa6c hˈaː6t0 ɲˈən . |0 +dataset/Xanh24h/speaker_0/1445.wav|ˈoŋ sˈəɪ zˈy6ŋ tˈe-2ɲ hˈaːj xˈu tʃˈuə2ŋ zˈiɛŋ bˈiɛ6t0 zˈe-2ɲ nˈuəj lˈəː6n nˈaːɜj vˌaː2 lˈəː6n tˈi6t0 , lˈaɜp ɗˈa6t0 kˌaːɜc tʃˈaːŋ tˈiɛɜt0 bˌi6 , kˈoŋ ŋˈe6 hˈiɛ6n ɗˈaː6j . |0 +dataset/Xanh24h/speaker_0/1460.wav|t0ˈiɜɲ ɗˌeɜn nˈaj , lwˈaː2j tˈɔ4 nˈa2j ɗˈɔɜŋ ɣˈɔɜp vˈaː2w sˈy6 fˈaːɜt0 tʃˈiɛ4n bˈe2n vˈy5ŋ kˌuə4 ŋˈe-2ɲ tʃˈan nˈuəj tˈɔ4 , ɗˈa6c bˈiɛ6t0 tʃˈɔŋ vˈiɛ6c kˈuŋ kˈəɜp tˈi6t0 vˌəːɜj zˈaːɜ tˈyəŋ mˈaː6j kˈaːw . |0 +dataset/Xanh24h/speaker_0/1461.wav|kˈuəɜj kˈu2ŋ , vˈiɛ6c tˈoŋ bˈaːɜw tˈyə2ŋ swˈiɛn vˈe2 kˌaːɜc sˈaː4n fˈə4m mˈəːɜj zˈuɜp zˈy5 tʃˌɔ xˈe-ɜc hˈaː2ŋ lˈuən ɣˈə6p ɲˈə6t0 kˌaːɜc zˈu hˈyəɜŋ vˌaː2 sˈaː4n fˈə4m mˈəːɜj ɲˈəɜt0 tʃˈɔŋ kˈyə4 hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1464.wav|vˌəːɜj ɲˌy5ŋ ˈiw ɗˈiɛ4m vˌaː2 t0ˈiɛ2m nˈaŋ fˈaːɜt0 tʃˈiɛ4n kˈiɲ zwˈe-ɲ bˈe-ɜɲ tʃˈaːɜŋ vˈiə4 hˈɛ2 kˈɔɜ tˈe4 mˈaːŋ lˈaː6j lˈəː6j ɲwˈə6n kˈaːw tʃˌɔ bˈaː6n nˌeɜw bˈaː6n bˈiɛɜt0 kˈe-ɜc kˈiɲ zwˈe-ɲ vˌaː2 lˈyə6 tʃˈɔ6n ɗˈiə6 ɗˈiɛ4m fˈu2 hˈəː6p . |0 +dataset/Xanh24h/speaker_0/1467.wav|ɗˌe4 kˈiɲ zwˈe-ɲ sˈaː4n fˈə4m kˈoŋ ŋˈe6 tˈe-2ɲ kˈoŋ , bˈaː6n kˈə2n lˌaː2 ŋˈyə2j t0ˈiɛn fˈɔŋ , lˈuən kˈə6p ɲˈə6t0 ɲˌy5ŋ sˈaː4n fˈə4m mˈəːɜj ɲˈəɜt0 , hˈɔt0 ɲˈəɜt0 vˌaː2 hˈiɛ4w zˈɔ5 vˈe2 tʃˈuɜŋ ɗˌe4 zˈəːɜj tˈiɛ6w ɗˌeɜn ŋˈyə2j t0ˈiɛw zˈu2ŋ . |0 +dataset/Xanh24h/speaker_0/1468.wav|vˈiɜ zˈu6 , vˈiɛ6c sˈy4 zˈu6ŋ kwˈaːɜ ɲˈiɛ2w nˈaŋ lˈyə6ŋ tʃˌɔ kˌaːɜc hwˈaː6t0 ɗˈo6ŋ zˈaː4j tʃˈiɜ sˈaː sˈi4 kˈɔɜ tˈe4 ɣˈɔɜp fˈə2n ɣˈəɪ zˈaː bˈiɛɜn ɗˈo4j xˈiɜ hˈə6w . |0 +dataset/Xanh24h/speaker_0/1471.wav|nˌeɜw bˈaː6n lˌaː2 ŋˈyə2j mˈəːɜj bˈaɜt0 ɗˈə2w , bˈaː6n nˌen lˈyə6 tʃˈɔ6n fˈən xˈuɜc tˈi6 tʃˈyə2ŋ ˈiɜt0 kˈe-6ɲ tʃˈe-ɲ hˈəːn , ɲˌy ɗˈo2ŋ hˈo2 bˈi2ɲ zˈən hwˌa6c ɗˈo2ŋ hˈo2 tʃˈuŋ kˈəɜp . |0 +dataset/Xanh24h/speaker_0/1473.wav|kˈi5 twˈə6t0 nˈuəj zˈeɜ sˈiɲ sˈaː4n ɗˈəːn zˈaː4n , ˈiɜt0 vˈoɜn , ˈiɜt0 zˈi6c bˈe6ɲ , xˌoŋ kˈə2n zˈiɛ6n t0ˈiɜc zˈo6ŋ , tˈəː2j zˈaːn tˈu hwˈe-6c lˈaː6j ɲˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/1479.wav|t0wˈi ɲˈiɛn , lˈaː2m tˈeɜ nˈaː2w ɗˌe4 kˈiɲ zwˈe-ɲ tˈe-2ɲ kˈoŋ tʃˈɔŋ mˈo6t0 tˈi6 tʃˈyə2ŋ mˌaː2 kˈɔɜ ɗˌeɜn tʃˈam ŋˈyə2j bˈaːɜn , vˈaː6n ŋˈyə2j mˈuə lˌaː2 mˈo6t0 vˈəɜn ɗˈe2 ɗˌe4 ɲˈiɛ2w ŋˈyə2j kwˈaːn t0ˈəm . |0 +dataset/Xanh24h/speaker_0/1486.wav|hˈa5j lˈaɪk , ʃˈeə nˌeɜw tˈəɪɜ vˈɪdɪəʊ nˈa2j bˈo4 ˈiɜc vˌaː2 ɗˈy2ŋ kwˈen ɗˈaŋ kˈiɜ kˈeɲ ɗˌe4 kˈə6p ɲˈə6t0 tˈem ɲˌy5ŋ vˈɪdɪəʊ mˈəːɜj ɲˈəɜt0 kˌuə4 t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ ɲˈɛɜ . |0 +dataset/Xanh24h/speaker_0/1487.wav|kˈuə6c sˈoɜŋ sˈaː hwˈaː kˌuə4 kˈim ʒˈɔŋˈun ɗˌaː5 bˌi6 ɲˈiɛ2w ŋˈyə2j tʃˈi4 tʃˈiɜc , ɗˈa6c bˈiɛ6t0 lˌaː2 tʃˈɔŋ bˈoɜj kˈe-4ɲ tʃˈiɛ2w t0ˈiɛn lˌaː2 mˈo6t0 kˈuəɜc zˈaː ŋˈɛ2w ɗˈɔɜj . |0 +dataset/Xanh24h/speaker_0/1490.wav|hˈe6 sˈiɲ tˈaːɜj tʃˈyə2ŋ tʃˈaː6j ɗˌyə6c lˈaː2m xˈɛɜp kˈiɜn ɗˌe4 ɗˈaː4m bˈaː4w tʃˈyə2ŋ tʃˈaː6j xˌoŋ kˈɔɜ mˈu2j hˈoj ɗˈa6c tʃˈyŋ zˈɔ tʃˈaːŋ nˈuəj lˈəː6n . |0 +dataset/Xanh24h/speaker_0/1498.wav|t0wˈi ɲˈiɛn , ɗˈəɪ tʃˈi4 lˌaː2 mˈo6t0 xˈəː4j ɗˈiɛ4m kwˈi mˈo ɲˈɔ4 , bˈaːɜn ˈɒnlaɪn , kˌaːɜc xˈə4w mˈaj vˌaː2 hwˈaː2n tˈiɛ6n sˈaː4n fˈə4m ɗˈe2w ɗˌyə6c twˈe ŋwˈaː2j . |0 +dataset/Xanh24h/speaker_0/1507.wav|nˌeɜw bˈaː6n ɗˈɔɜŋ vˈaːj tʃˈɔ2 lˌaː2 mˈo6t0 zˈu xˈe-ɜc t0ˈi2m hˈiɛ4w vˈe2 kˌaːɜc hˈəʊmsteɪ tʃˌɔ vˈiɛ6c zˈy2ŋ tʃˈən tʃˈɔŋ tʃwˈiɛɜn hˈe-2ɲ tʃˈi2ɲ kˌuə4 mˈi2ɲ , bˈaː6n sˌɛ5 lˈyə6 tʃˈɔ6n zˈyə6 tʃˈen ɲˌy5ŋ t0ˈiɛw tʃˈiɜ nˈaː2w . |0 +dataset/Xanh24h/speaker_0/1510.wav|nˈyəɜc nˈaː2w kˈu5ŋ tʃˌɔ zˈa2ŋ zˈoɜŋ ɣˈaː2 kwˈiɜ hˈiɛɜm nˈa2j lˌaː2 kˈuəɜc sˈaː4n kˌuə4 nˈyəɜc mˈi2ɲ , t0ˌy2 ˈəɜn ɗˈo6 , bˌaŋɡlɐdˈɛʃ , tˈo4 ɲˈi5 kˈi2 , tʃˈuŋ kˈuəɜc , ŋˈaː , mˈi5 vˌaː2 kˈuəɜj kˈu2ŋ lˌaː2 ˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/1511.wav|tʃˈi2ɲ lˈaː2ŋ nˈam hˈaːj ŋˈi2n xˌoŋ tʃˈam hˈaːj mˈyəj mˈoɜt0 , ɲˌyŋ t0ˈiɜɲ zˈiɛŋ zwˈe-ɲ tˈu kwˈiɜ mˈo6t0 nˈam hˈaːj ŋˈi2n xˌoŋ tʃˈam hˈaːj mˈyəj hˈaːj kˌuə4 hˈaː5ŋ ɗˌaː5 lˈen t0ˌəːɜj mˈo6t0 fˈəɪ4 bˈaː tʃˈiɛ6w ɗˈo lˈaː mˈi5 . |0 +dataset/Xanh24h/speaker_0/1513.wav|nˈam nˈaj , kˌaːɜc ɲˈaː2 vˈyə2n kˈuŋ kˈəɜp tʃˌɔ tˈi6 tʃˈyə2ŋ t0ˈeɜt0 zˈaːɜp tˈi2n hˈaːj ŋˈi2n xˌoŋ tʃˈam hˈaːj mˈyəj t0ˈy ɲˌy5ŋ ɣˈoɜk kwˈəɜt0 vˌəːɜj ɲˈiɛ2w kˈiɜc kˈəː5 , zˈaːɜŋ tˈeɜ xˈaːɜc ɲˈaw . |0 +dataset/Xanh24h/speaker_0/1516.wav|t0wˈi ɲˈiɛn , nˌeɜw lˈyə6 tʃˈɔ6n xˈu vˈy6c kˈɔɜ ɗˈoŋ zˈən sˈiɲ sˈoɜŋ , ɗˈaː4m bˈaː4w zˈa2ŋ nˈɔɜ vˌə5n zwˈi tʃˈi2 xˌoŋ xˈiɜ ˈiɛn t0ˈi5ɲ ɗˌe4 t0ˈaː6w ɗˈiɛ2w kˈiɛ6n twˈə6n lˈəː6j tʃˌɔ vˈiɛ6c ɗˈɔ6k sˈe-ɜc vˌaː2 mˈuə sˈaɜm . |0 +dataset/Xanh24h/speaker_0/1520.wav|t0wˈi ɲˈiɛn , zˌu2 ɣˈa6p fˌaː4j mˈuən vˈaː4n xˈɔɜ xˈan , sˈə1w tʃˈɔŋ lˈɔ2ŋ ˈe-ɲ vˌə5n nˈuŋ nˈəɜw vˈe2 mˈo6t0 sˈaː4n fˈə4m mˌeɪd ˈin vˈiɛ6t0 nˈaːm tʃˌɔ kˌaːɜc sˈaː4n fˈə4m tˈe4 tˈaːw . |0 +dataset/Xanh24h/speaker_0/1521.wav|hˈiɛ6n nˈaj ˈaːɜp lˈy6c ɗˌeɜn t0ˌy2 mˌɔ6j xˈiəɜ kˈe-6ɲ kˌuə4 kˈuə6c sˈoɜŋ kˈaː2ŋ lˈəːɜn , kˌɔn ŋˈyə2j zˈəːj vˈaː2w kˌaːɜc tʃˈaː6ŋ tˈaːɜj kˈaŋ tˈa4ŋ , ˈaːɜp lˈy6c vˌaː2 mˈe6t0 mˈɔ4j vˈo kˈu2ŋ lˈəːɜn . |0 +dataset/Xanh24h/speaker_0/1527.wav|vˈiɜ zˈu6 , vˌəːɜj kˈyə4 hˈaː2ŋ kwˈi mˈo ɲˈɔ4 , bˈaːɜn sˈaː4n fˈə4m bˈi2ɲ zˈən , sˈoɜ vˈoɜn kˈɔɜ tˈe4 zˈaːw ɗˈo6ŋ xwˌaː4ŋ nˈam mˈyəj ɗˌeɜn mˈo6t0 tʃˈam tʃˈiɛ6w ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/1533.wav|tˈyɜc ˈan hˈi5w kˈəː tˈyə2ŋ tʃˈyəɜ ˈiɜt0 hwˈaːɜ tʃˈəɜt0 vˌaː2 tʃˈəɜt0 vˈu6 zˈaː zˈuɜp ɣˈaː2 vˌaː2 kˈaːɜ fˈaːɜt0 tʃˈiɛ4n xwˈɛ4 mˈe-6ɲ vˌaː2 sˈaː4n fˈə4m kˈuəɜj kˈu2ŋ ˈaːn t0wˈaː2n tʃˈɔŋ ŋˈyə2j t0ˈiɛw zˈu2ŋ . |0 +dataset/Xanh24h/speaker_0/1534.wav|ɗˈəɪ lˌaː2 mˈo6t0 tʃˈɔŋ ɲˌy5ŋ ɗˈiɛ2w kˈiɛ6n ˈe-4ɲ hˈyə4ŋ tʃˈy6c t0ˈiɛɜp t0ˌəːɜj sˈyɜc xwˈɛ4 , xˈaː4 nˈaŋ fˈaːɜt0 tʃˈiɛ4n kˌuə4 lwˈaː6j kˈaːɜ nˈa2j , kˈə2n kˈɔɜ zˈəɜt0 ɲˈiɛ2w ˈiɛɜw t0ˈoɜ . |0 +dataset/Xanh24h/speaker_0/1541.wav|bˌəː4j ŋˈa2j nˈaj , zˈaɜn mˈoɜj hˈiɛ6n nˈaj ɗˌyə6c mˈuə zˈəɜt0 ɲˈiɛ2w ɗˌe4 lˈaː2m tˈuəɜc , lˈaː2m tˈy6c fˈə4m tʃˈyɜc nˈaŋ vˌaː2 tʃˈeɜ bˈiɛɜn kˌaːɜc mˈɔɜn ˈan ɗˈo6k lˈaː6 . |0 +dataset/Xanh24h/speaker_0/1544.wav|zˈaːɜ ɣˈaː2 kˈuɜŋ ˈoŋ kˈoŋ ˈoŋ t0ˈaːɜw tˈyə2ŋ zˈaːw ɗˈo6ŋ t0ˌy2 nˈam tʃˈam ŋˈi2n ɗˈo2ŋ ɗˌeɜn mˈo6t0 tʃˈiɛ6w ɗˈo2ŋ mˈo6t0 kˌɔn , t0wˈi2 tˈuə6c vˈaː2w kˈiɜc tˈyəɜc vˌaː2 lwˈaː6j ɣˈaː2 . |0 +dataset/Xanh24h/speaker_0/1546.wav|bˈaː6n kˈə2n tʃˈuɜ tʃˈɔ6ŋ tʃˈam sˈɔɜk xˈe-ɜc hˈaː2ŋ , t0ˈaː6w zˈy6ŋ mˈoɜj kwˈaːn hˈe6 t0ˈoɜt0 ɗˈɛ6p vˌəːɜj xˈe-ɜc hˈaː2ŋ ɗˌe4 hˈɔ6 kwˈaj lˈaː6j mˈuə sˈaɜm tʃˈɔŋ kˌaːɜc zˈi6p t0ˈiɛɜp tˈɛw . |0 +dataset/Xanh24h/speaker_0/1547.wav|kˈiɲ zwˈe-ɲ kwˈə2n ˈaːɜw fˈu6 kˈiɛ6n t0ˈeɜt0 tˈyə2ŋ kˈɔɜ vˈɔ2ŋ kwˈaj vˈoɜn ɲˈe-ɲ , zˈɔ ɗˈɔɜ bˈaː6n kˈə2n kwˈaː4n lˈiɜ t0ˈaː2j tʃˈiɜɲ kˈə4n tˈə6n ɗˌe4 tʃˈe-ɜɲ t0ˈi2ɲ tʃˈaː6ŋ tˈəɜt0 twˈaːɜt0 . |0 +dataset/Xanh24h/speaker_0/1553.wav|tʃˈi fˈiɜ ɗˈə2w t0ˈy bˈaːn ɗˈə2w tʃˌɔ mˈo hˈi2ɲ nˈa2j tʃˈi4 xwˌaː4ŋ bˈoɜn mˈyəj tʃˈiɛ6w ɗˈo2ŋ , tʃˈɔŋ ɗˈɔɜ tʃˈi fˈiɜ tʃˈiɜɲ lˌaː2 mˈuə sˈɛ kˈaː2 fˈe vˌaː2 mˈaɜj fˈaː kˈaː2 fˈe . |0 +dataset/Xanh24h/speaker_0/1555.wav|vˈɔ4 zˈyə hˈəɜw , zˈyə ɣˈaŋ , zˈyə hˈo2ŋ , kˈaː2 zˈoɜt0 , sˈaɜn , xwˈaːj lˈaːŋ , xwˈaːj mˈi2 , bˈiɜ ɗˈɔ4 , zˈyə lˈɛw . |0 +dataset/Xanh24h/speaker_0/1561.wav|bˈaː6n kˈɔɜ tˈe4 sˈy4 zˈu6ŋ kˌaːɜc kˈeɲ tʃwˈiɛ2n tˈoŋ ɲˌy wˈɛbsaɪt , mˈaː6ŋ sˈaː5 hˈo6j ɗˌe4 kwˈaː4ŋ bˈaːɜ sˈaː4n fˈə4m vˌaː2 tˈyəŋ hˈiɛ6w kˌuə4 mˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/1563.wav|t0ˈoɜt0 ɲˈəɜt0 , sˈy4 zˈu6ŋ ɲˈaː2 lˈyəɜj ɗˌe4 nˈuəj sˌɛ5 bˈaː4w ɗˈaː4m tʃˈe-ɜɲ ɲˌy5ŋ lwˈaː2j , ɲˌy tʃˈuə6t0 , tʃˈim , tˈa2n lˈa2n , kˈɔɜ tˈe4 lˈɔ6t0 vˈaː2w vˌaː2 ˈan zˈu2j . |0 +dataset/Xanh24h/speaker_0/1584.wav|t0ˈoɜt0 ɲˈəɜt0 , ɲˌy5ŋ ŋˈa2j ɗˈə2w lˈəː6n mˈəːɜj mˈuə vˈe2 ɗˌyə6c ɲˈoɜt0 zˈiɛŋ , nˌeɜw lˌaː2 mˈuə tˈem ɗˌe4 bˈo4 sˈuŋ tʃˌɔ ɗˈaː2n lˈəː6n sˈa5n kˈɔɜ ˈəː4 tʃˈaːŋ tʃˈaː6j . |0 +dataset/Xanh24h/speaker_0/1591.wav|hˈə2w hˈeɜt0 ɲˌy5ŋ ˈap tʃˈəːj ɡˈeɪm ɗˌe4 kˈiɛɜm t0ˈiɛ2n ɗˈe2w bˈa2ŋ kˈe-ɜc t0ˈaː4j kˌaːɜc tʃˈɔ2 tʃˈəːj hˈəɜp zˈə5n tʃˈen ˈyɜŋ zˈu6ŋ vˌaː2 bˈaɜt0 ɗˈə2w tʃˈəːj ɡˈeɪm ɗˌe4 t0ˈiɜc ɗˈiɛ4m . |0 +dataset/Xanh24h/speaker_0/1601.wav|ŋwˈaː2j zˈaː , vˈiɛ6c fˈaːɜt0 tʃˈiɛ4n hˈi2ɲ tˈyɜc kˈiɲ zwˈe-ɲ ˈɒnlaɪn tʃˈen kˌaːɜc nˈe2n t0ˈaː4ŋ ɲˌy fˈeɪsbʊk , ʃˈəʊpiː , lazˈɑːdə , zˈɛndə kˈu5ŋ lˌaː2 bˈyəɜc kwˈaːn tʃˈɔ6ŋ . |0 +dataset/Xanh24h/speaker_0/1602.wav|mˈo6t0 nˈo2j kˈaːɜ xˈɔ lˈaː2ŋ vˈu5 ɗˈaː6j lˌaː2 mˈo6t0 t0ˈaːɜc fˈə4m nˈəɜw ˈan ɗˈəɪ2 t0ˈəm hwˈiɛɜt0 , ɗˈɔ2j hˈɔ4j sˈy6 kˈiɛn tʃˈi2 vˌaː2 kˈi5 twˈə6t0 kˈaːw . |0 +dataset/Xanh24h/speaker_0/1605.wav|tʃˈiɜɲ tʃˈi6 tˈeɜ zˈəːɜj ɗˌaː5 tʃˈuɜ ˈiɜ ɗˈa6c bˈiɛ6t0 ɗˌeɜn kˈim ʒˈɔŋˈun xˌi ˈoŋ lˈen nˈaɜm kwˈiɛ2n vˈaː2w nˈam hˈaːj ŋˈi2n xˌoŋ tʃˈam mˈyə2j mˈo6t0 , kˈeɜ tˈyə2 vˈi6 tˈeɜ lˈe-5ɲ ɗˈaː6w t0ˌy2 tʃˈaː ˈoŋ , kˈim ʒˈɔŋˈɪl . |0 +dataset/Xanh24h/speaker_0/1628.wav|kˌaːɜc zwˈe-ɲ ŋˈiɛ6p kˈə2n ɗˈaː4m bˈaː4w zˈa2ŋ kˈəɪ bˈɔnsaːj kˌuə4 hˈɔ6 xˌoŋ tʃˈi4 ɗˈɛ6p mˈaɜt0 mˌaː2 kˌɔ2n fˈaː4n ˈe-ɜɲ ɗˈuɜŋ zˈaːɜ tʃˈi6 vˈan hwˈaːɜ vˌaː2 t0ˈəm hwˈiɛɜt0 tʃˈɔŋ t0ˈy2ŋ tʃˈiɛɜc lˈaːɜ , t0ˈy2ŋ kˈe-2ɲ kˈəɪ . |0 +dataset/Xanh24h/speaker_0/1642.wav|lˌaː2 mˈo6t0 ŋˈyə2j ɗˌaː5 fˈaːɜt0 tʃˈiɛ4n tˈe-2ɲ kˈoŋ mˈo hˈi2ɲ ɣˈaː2 kˈaːɜ kˈeɜt0 hˈəː6p , ˈe-ɲ tʃˈə2n kwˈaːŋ ɗˈyɜc , bˈoɜn mˈyəj bˈa4j t0ˈuə4j , ˈəː4 tˈon ˈaːn t0ˈən , sˈaː5 ɗˈaː6j hˈyŋ , hwˈiɛ6n ɗˈaː6j lˈo6k , kwˈaː4ŋ nˈaːm tʃˌɔ bˈiɛɜt0 . |0 +dataset/Xanh24h/speaker_0/1654.wav|tʃˈɔŋ zˈaːj ɗwˈaː6n ɗˈə2w , ˈe-ɲ t0ˈə6p tʃˈuŋ tʃˈu4 ˈiɛɜw vˈaː2w vˈiɛ6c fˈaːɜt0 tʃˈiɛ4n ɲˈən ɗˈaː2n t0ˌy2 hˈaːj mˈyəj kˌɔn bˈaːn ɗˈə2w lˈen ɗˌeɜn hˈəːn nˈam tʃˈam kˌɔn tʃˈɔŋ vˈɔ2ŋ hˈaːj nˈam . |0 +dataset/Xanh24h/speaker_0/1655.wav|vˈiɜ zˈu6 , nˌeɜw bˈaː6n ɲˈə6p xˈə4w t0ˈaːɜw t0ˌy2 tʃˈuŋ kˈuəɜc , bˈaː6n kˈə2n t0ˈiɜɲ t0wˈaːɜn tʃˈi fˈiɜ mˈuə t0ˈaːɜw , tʃˈi fˈiɜ vˈə6n tʃwˈiɛ4n , tʃˈi fˈiɜ bˈaː4w kwˈaː4n ɗˌe4 sˈaːɜc ɗˈi6ɲ tʃˈi fˈiɜ ɲˈə6p xˈə4w . |0 +dataset/Xanh24h/speaker_0/1657.wav|hˈa5j t0ˈaː6w mˈoɜj kwˈaːn hˈe6 t0ˈoɜt0 vˌəːɜj ɲˈaː2 kˈuŋ kˈəɜp ɗˌe4 ɗˈaː4m bˈaː4w tʃˈəɜt0 lˈyə6ŋ sˈaː4n fˈə4m , zˈaːɜ kˈaː4 kˈe-6ɲ tʃˈe-ɲ vˌaː2 zˈi6c vˈu6 hˈə6w mˈaː5j t0ˈoɜt0 . |0 +dataset/Xanh24h/speaker_0/1661.wav|ɗˈiɛ2w nˈa2j lˌaː2 mˈo6t0 kˈəː hˈo6j lˈiɜ t0ˈyə4ŋ tʃˌɔ ɲˌy5ŋ ŋˈyə2j mˈuəɜn bˈaɜt0 ɗˈə2w kˈiɲ zwˈe-ɲ vˌəːɜj ŋˈuə2n vˈoɜn kˈɔɜ hˈaː6n tʃˈɔŋ lˈi5ɲ vˈy6c fˈu6 kˈiɛ6n ɗˈiɛ6n twˈaː6j . |0 +dataset/Xanh24h/speaker_0/1662.wav|lˈyə6 tʃˈɔ6n ɲˈaː2 kˈuŋ kˈəɜp wˈi t0ˈiɜn , tʃˈəɜt0 lˈyə6ŋ , ɗˈaː4m bˈaː4w ŋˈuə2n ɣˈoɜk swˈəɜt0 sˈyɜ zˈɔ5 zˈaː2ŋ , ɗˈaːɜp ˈyɜŋ kˌaːɜc t0ˈiɛw tʃwˈə4n ˈaːn t0wˈaː2n tʃˌɔ tʃˈɛ4 ˈɛm . |0 +dataset/Xanh24h/speaker_0/1663.wav|tʃˈɔŋ mˈo6t0 , hˈaːj nˈam ɗˈə2w , t0wˈaː2n bˈo6 sˈoɜ t0ˈiɛ2n lˈaː5j ˈe-ɲ tˈu ɗˌyə6c , ˈe-ɲ ɗˈe2w bˈɔ4 vˈaː2w sˈəɪ zˈy6ŋ hˈe6 tˈoɜŋ , ɗˈə2w t0ˈy tʃˈaːɜŋ tˈiɛɜt0 bˌi6 , tˈyɜc ˈan tʃˈan nˈuəj . |0 +dataset/Xanh24h/speaker_0/1665.wav|ɗˈəɪ kˈu5ŋ lˌaː2 zˈi6p mˌaː2 ɲˈiɛ2w ŋˈyə2j tʃˈe-ɲ tˈu4 kˈiɛɜm tˈem tˈu ɲˈə6p , tˈoŋ kwˈaː kˌaːɜc hwˈaː6t0 ɗˈo6ŋ kˈiɲ zwˈe-ɲ vˈon bˈaːɜn tʃˈɔŋ xwˌaː4ŋ tˈəː2j zˈaːn ŋˈaɜn , tʃˈi4 xwˌaː4ŋ mˈo6t0 tˈaːɜŋ . |0 +dataset/Xanh24h/speaker_0/1669.wav|kˈɔɜ tˈe4 tˈaːɜj tˈyɜc ˈan tˈe-2ɲ sˈəː6j , hwˌa6c tˈaːɜj tˈe-2ɲ hˈi2ɲ vˈuəŋ kˈe-6ɲ zˈaː2j mˈo6t0 sˈaŋt0ˈimˈɛɜt0 vˌaː2 kˈiɜc tˈyəɜc t0ˈaŋ zˈə2n tˈɛw ɗˈo6 t0ˈuə4j kˌuə4 t0ˈə2m . |0 +dataset/Xanh24h/speaker_0/1677.wav|tʃˈɔŋ vˈɪdɪəʊ nˈa2j , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˌɛ5 hˈyəɜŋ zˈə5n kˌaːɜc bˈaː6n lˈaː2m tˈeɜ nˈaː2w ɗˌe4 bˈaɜt0 ɗˈə2w kˈiɲ zwˈe-ɲ dɹˈɒpʃɪpɪŋ , kˈe-ɜc zˈe5 ɲˈəɜt0 ɗˌe4 bˈaːɜn hˈaː2ŋ ˈɒnlaɪn . |0 +dataset/Xanh24h/speaker_0/1680.wav|fˈu6 kˈiɛ6n kˈoŋ ŋˈe6 bˈaːw ɣˈo2m ɲˈiɛ2w mˈa6t0 hˈaː2ŋ xˈaːɜc ɲˈaw , t0ˌy2 ˈoɜp lˈyŋ , kˈiɜɲ kˈyə2ŋ lˈy6c , t0ˈaːj ŋˈɛ , lwˈaː2 , zˈaː6c , ɗˌeɜn kˌaːɜc tˈiɛɜt0 bˌi6 kˈoŋ ŋˈe6 kˈaːw ɲˌy mˈaɜj tʃˈəːj ɡˈeɪm , ɗˈo2 zˈun . |0 +dataset/Xanh24h/speaker_0/1681.wav|ŋwˈaː2j zˈaː , vˈiɛ6c bˈaːɜn kˈɛ2m kˌaːɜc mˈɔɜn ɲˌy sˈuɜc sˈiɜc , zˈɔ2 t0ˈaːj , zˈɔ2 lˈuə6 kˈu5ŋ lˌaː2 mˈo6t0 kˈe-ɜc ɗˌe4 lˈaː2m fˈɔŋ fˈuɜ tˈem tˈy6c ɗˈəːn vˌaː2 tˈu hˈuɜt0 sˈy6 kwˈaːn t0ˈəm t0ˌy2 fˈiəɜ xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1682.wav|sˈaw mˈyə2j hˈaːj zˈəː2 tˈyɜc ˈan xˌoŋ ɗˌyə6c tˈɔ4 ˈan hˈeɜt0 , tʃˈuɜŋ t0ˈaː kˈə2n lwˈaː6j bˈɔ4 vˌaː2 tˈaj tˈyɜc ˈan mˈəːɜj ɗˌe4 tʃˈe-ɜɲ ˈoj tˈiw , ˈə4m mˈoɜk , lˈaː2m tˈɔ4 t0ˈiɛw tʃˈa4j . |0 +dataset/Xanh24h/speaker_0/1684.wav|mˈaɜj tʃˈuə2ŋ kˈə2n tʃˈɔ6n lˈyəɜj kˈɔɜ ɗˈo6 bˈe2n kˈaːw , tʃˈi6w ɗˌyə6c mˈyə zˈɔɜ , nˈaɜŋ nˈɔɜŋ , mˈaɜt0 lˈyəɜj ɲˈɔ4 tʃˈe-ɜɲ zˈu2j bˈaj zˈaː ŋwˈaː2j . |0 +dataset/Xanh24h/speaker_0/1686.wav|kwˈaː ɲˌy5ŋ bˈyəɜc tʃˈiə sˈɛ4 vˈe2 kˈi5 twˈə6t0 nˈuəj kˈaːɜ t0ˈə2m kˌuə4 t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ , kˈɔɜ lˈɛ5 ɗˌaː5 zˈuɜp ɗˌyə6c bˈaː2 kˌɔn nˈaɜm ɗˌyə6c ɲˌy5ŋ tˈoŋ t0ˈin kˈəː bˈaː4n vˌaː2 bˈo4 sˈuŋ tˈem ɲˌy5ŋ kˈiɲ ŋˈiɛ6m tʃˈɔŋ kwˈaːɜ tʃˈi2ɲ nˈuəj kˈaːɜ t0ˈə2m . |0 +dataset/Xanh24h/speaker_0/1696.wav|tʃˈɔŋ zˈaːj ɗwˈaː6n xˈəː4j ŋˈiɛ6p , vˌəːɜj tʃˈi4 mˈyə2j tʃˈiɛ6w ɗˈo2ŋ tʃˈɔŋ t0ˈaj , tʃˈaː2ŋ tʃˈaːj tʃˈɛ4 ɗˌaː5 kwˈiɛɜt0 ɗˈi6ɲ vˈaj mˈyə6n bˈa4j mˈyəj tʃˈiɛ6w ɗˈo2ŋ t0ˌy2 ŋˈən hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1698.wav|kˌaːɜc vˈu6 tˈy4 ŋˈiɛ6m nˈa2j tˈyə2ŋ swˈiɛn ɗˈoɜj zˈiɛ6n vˌəːɜj lˈəː2j tʃˈi4 tʃˈiɜc t0ˌy2 fˈiəɜ kˈo6ŋ ɗˈo2ŋ kˈuəɜc t0ˈeɜ vˌaː2 kˈɔɜ tˈe4 lˈaː2m zˈaː t0ˈaŋ kˈaŋ tˈa4ŋ tʃˈɔŋ xˈu vˈy6c tʃˈə1w ˈaːɜ . |0 +dataset/Xanh24h/speaker_0/1702.wav|xˌi bˈaː6n tʃˌyə kˈɔɜ ɲˈiɛ2w kˈiɲ ŋˈiɛ6m hˈaj kˈiɛɜn tˈyɜc ɗˌe4 bˈaɜt0 ɗˈə2w vˌəːɜj mˈo6t0 tˈi6 tʃˈyə2ŋ mˈəːɜj , kˈu5ŋ t0ˈaː6w zˈaː ɲˌy5ŋ xˈɔɜ xˈan vˌaː2 ɲˈyə6c ɗˈiɛ4m tʃˈɔŋ kˈiɲ zwˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/1706.wav|ˈiɜ t0ˈyə4ŋ kˈiɲ zwˈe-ɲ nˈa2j kˈɔɜ tˈe4 ɗˌyə6c tʃˈiɛ4n xˈaːj t0ˈaː6j kˌaːɜc xˈu tʃˈuŋ t0ˈəm tˈyəŋ mˈaː6j hwˌa6c tʃˈyə2ŋ hˈɔ6k tʃˈɔŋ kˌaːɜc zˈəː2 kˈaːw ɗˈiɛ4m lˌaː2 nˈəːj twˈə6n lˈəː6j ɗˌe4 tˈu hˈuɜt0 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1707.wav|mˈo hˈi2ɲ nˈuəj ˈoɜk ɲˈo2j kˌuə4 kˈyə2ŋ ɗˌyə6c tʃˈiɛ4n xˈaːj tʃˈen zˈiɛ6n t0ˈiɜc mˈyə2j ŋˈi2n mˈɛɜt0 vˈuəŋ vˌəːɜj kwˈi mˈo hˈəːn mˈo6t0 tʃˈam t0ˈəɜn ˈoɜk tʃˈen mˈo6t0 nˈam . |0 +dataset/Xanh24h/speaker_0/1708.wav|tʃˈɔŋ kwˈaːɜ tʃˈi2ɲ tʃˈam sˈɔɜk , ŋˈyə2j nˈuəj kˈu5ŋ kˈə2n tʃˈuɜ ˈiɜ ɗˌeɜn zˈəɜw hˈiɛ6w hˈyəw bˌi6 bˈe6ɲ vˈe2 ɗˈyə2ŋ zˈuə6t0 ɲˌy bˈu6ŋ tʃˈyəɜŋ , vˈən lˈɔ2ŋ . |0 +dataset/Xanh24h/speaker_0/1709.wav|kˈe-ɜc ɗˈəɪ bˈoɜn nˈam , tʃˈɔŋ mˈo6t0 lˈə2n t0ˈi2ɲ kˈəː2 , tʃˈi6 vˈaː2w mˈaː6ŋ jˈuːtjuːb vˌaː2 tˈəɪɜ kˈɔɜ zˈoɜŋ bˈiɜ kˈɛɜw zˈaː ɗˌyə6c ɲˌy5ŋ sˈəː6j ɲˌy sˈəː6j mˈi2 . |0 +dataset/Xanh24h/speaker_0/1713.wav|bˈaː6n kˈɔɜ tˈe4 tˈaːm xˈaː4w ˈiɜ kˈiɛɜn kˌuə4 ɲˌy5ŋ ŋˈyə2j kˈɔɜ kˈiɲ ŋˈiɛ6m tʃˈɔŋ lˈi5ɲ vˈy6c kˈiɲ zwˈe-ɲ hˈaː4j sˈaː4n ɗˌe4 t0ˈi2m hˈiɛ4w vˈe2 kˌaːɜc kˈəː sˈəː4 nˈuəj tʃˈo2ŋ ɗˈe-ɜɲ bˈaɜt0 wˈi t0ˈiɜn . |0 +dataset/Xanh24h/speaker_0/1717.wav|nˌeɜw bˈaː6n kˈɔɜ nˈiɛ2m ɗˈaːm mˈe vˌəːɜj bˈe-ɜɲ ŋˈɔ6t0 vˌaː2 kˈɔɜ xˈaː4 nˈaŋ lˈaː2m zˈaː ɲˌy5ŋ tʃˈiɛɜc bˈe-ɜɲ ŋˈɔn , ɗˈɛ6p mˈaɜt0 , tˌi2 vˈiɛ6c kˈiɲ zwˈe-ɲ bˈe-ɜɲ ŋˈɔ6t0 sˌɛ5 lˌaː2 mˈo6t0 lˈyə6 tʃˈɔ6n lˈiɜ t0ˈyə4ŋ zˈe-2ɲ tʃˌɔ bˈaː6n . |0 +dataset/Xanh24h/speaker_0/1722.wav|vˈəɪ6 nˌen , kˈiɲ zwˈe-ɲ tʃˈaː2 tʃˈe-ɲ zˈaː5 t0ˈaj lˌaː2 mˈo6t0 mˈo hˈi2ɲ kˈiɲ zwˈe-ɲ ɗˌaːŋ ɗˌyə6c ɲˈiɛ2w ŋˈyə2j tʃˈɛ4 lˈyə6 tʃˈɔ6n xˈəː4j ŋˈiɛ6p bˌəː4j nˈɔɜ kˈɔɜ tˈe4 mˈaːŋ lˈaː6j t0ˈiɛ2m nˈaŋ fˈaːɜt0 tʃˈiɛ4n lˈəːɜn . |0 +dataset/Xanh24h/speaker_0/1731.wav|mˈo6t0 sˈoɜ zˈoɜŋ ɣˈaː2 fˈu2 hˈəː6p vˌəːɜj mˈo hˈi2ɲ nˈuəj ɣˈaː2 kˈeɜt0 hˈəː6p tʃˈen mˈa6t0 ˈaːw ɲˌy ɣˈaː2 t0ˈaː , ɣˈaː2 lˈoŋ mˈa2w , ɣˈaː2 ˈaːɜc . |0 +dataset/Xanh24h/speaker_0/1732.wav|tʃˈɔŋ vˈɪdɪəʊ hˈom nˈaj kˌuə4 t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ , sˌɛ5 tʃˈiə sˈɛ4 kˈiɲ ŋˈiɛ6m hˈi5w ˈiɜc vˌaː2 bˈə6t0 mˈiɜ ɲˌy5ŋ ɗˈiɛ2w kwˈaːn tʃˈɔ6ŋ mˌaː2 xˌoŋ fˌaː4j ˈaːj kˈu5ŋ bˈiɛɜt0 xˌi mˈuəɜn mˈəː4 kˈyə4 hˈaː2ŋ nˈoŋ sˈaː4n sˈe-6c . |0 +dataset/Xanh24h/speaker_0/1736.wav|kˈɔɜ ɲˈiɛ2w ŋwˈiɛn ɲˈən zˈə5n ɗˌeɜn t0ˈi2ɲ tʃˈaː6ŋ nˈa2j , bˈaːw ɣˈo2m ˈiɛɜw t0ˈoɜ tʃˈəɜt0 lˈiɛ6w , ˈiɛɜw t0ˈoɜ tˈiɛɜt0 kˈeɜ , ˈiɛɜw t0ˈoɜ tˈyəŋ hˈiɛ6w . |0 +dataset/Xanh24h/speaker_0/1737.wav|ɗˌeɜn kˈuəɜj nˈam hˈaːj ŋˈi2n xˌoŋ tʃˈam mˈyə2j bˈoɜn , sˈoɜ kˈaːɜ t0ˈə2m , kˈaːɜ hˈo2j ɗˌyə6c bˈaːɜn hˈeɜt0 tʃˌɔ kˌaːɜc ɲˈaː2 hˈaː2ŋ tʃˈen ɗˈiə6 bˈaː2n t0ˈi4ɲ tˈe-ɲ hwˈaːɜ , tˈu vˈe2 tʃˈen hˈaːj t0ˈi4 ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/1738.wav|kˈɛ6w lˈaː6c vˌəːɜj hˈaː6t0 lˈaː6c bˈɛɜw ŋˈɔn vˌaː2 lˈəːɜp ɗˈyə2ŋ vˈy2ŋ mˈə6t0 ˈɔŋ zˈɔ2n t0ˈaːn xˌoŋ tʃˈi4 lˌaː2 mˈɔɜn kwˈaː2 tʃwˈiɛ2n tˈoɜŋ mˌaː2 kˌɔ2n lˌaː2 bˈiɛ4w t0ˈyə6ŋ kˌuə4 sˈy6 fˈo2n tˈi6ɲ mˈaj mˈaɜn . |0 +dataset/Xanh24h/speaker_0/1739.wav|xˌi tʃˈɔ6n mˈo hˈi2ɲ kˈiɲ zwˈe-ɲ , kˈən ɲˈaɜc ɗˌeɜn ɗˈoɜj t0ˈyə6ŋ xˈe-ɜc hˈaː2ŋ , tʃˈi fˈiɜ hwˈaː6t0 ɗˈo6ŋ , kwˈaː4n lˈiɜ xˈɔ vˌaː2 tʃˈiɛɜn lˈyə6c kwˈaː4ŋ kˈaːɜw . |0 +dataset/Xanh24h/speaker_0/1741.wav|ɗˌe4 sˈəɪ zˈy6ŋ mˈo6t0 tˈyəŋ hˈiɛ6w mˈe-6ɲ mˈɛ5 , vˈiɛ6c tʃˈɔ6n t0ˈen kˈə2n fˌaː4j ŋˈaɜn ɣˈɔ6n , zˈe5 ɗˈɔ6k vˌaː2 fˈaː4n ˈe-ɜɲ ɗˈuɜŋ sˈaː4n fˈə4m kˈiɲ zwˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/1750.wav|ɗˈəɪ lˌaː2 ŋˈuə2n hˈaː2ŋ wˈi t0ˈiɜn vˌaː2 tʃˈəɜt0 lˈyə6ŋ ɲˈəɜt0 bˌəː4j kˌaːɜc tʃˈaːŋ tʃˈaː6j , hˈəː6p t0ˈaːɜc zˈaː5 nˈa2j ɗˌyə6c kˈiɛ4m tʃˈaː ŋˈiɛm ŋˈa6t0 vˈe2 tʃˈəɜt0 lˈyə6ŋ sˈaː4n fˈə4m vˌaː2 kwˈi tʃˈi2ɲ sˈaː4n swˈəɜt0 . |0 +dataset/Xanh24h/speaker_0/1754.wav|vˈaː2w sˈaːɜŋ sˈəːɜm , ŋˈyə2j bˈaːɜn kˈə2n sˈy4 zˈu6ŋ tˈu2ŋ nˈyəɜc bˈiɛ4n kˈɔɜ sˈu6c ˈɔsi ɗˌe4 hˈaː4j sˈaː4n lˈuən t0ˈyəj sˈoɜŋ tʃˈɔŋ kwˈaːɜ tʃˈi2ɲ vˈə6n tʃwˈiɛ4n . |0 +dataset/Xanh24h/speaker_0/1763.wav|ɗˈa6t0 tʃˈuə2ŋ tˈɛw hˈyəɜŋ ɗˈoŋ nˈaːm , hˈyəɜŋ twˈə6n t0ˈiɛ6n tʃˌɔ vˈiɛ6c tʃˈan nˈuəj , kˈɔɜ tˈe4 tʃˈe-ɜɲ zˈɔɜ vˈaː2w mˈuə2 ɗˈoŋ vˌaː2 twˈaːɜŋ mˈaːɜt0 vˈaː2w mˈuə2 hˈɛ2 . |0 +dataset/Xanh24h/speaker_0/1765.wav|mˈo6t0 kˌɔn tʃˈim kˈuɜt0 kˈə2n xwˌaː4ŋ xˌoŋ fˈəɪ4 mˈo6t0 mˈɛɜt0 vˈuəŋ zˈiɛ6n t0ˈiɜc tʃˈuə2ŋ , vˈəɪ6 nˌen fˌaː4j ɗˈaː4m bˈaː4w ɗˈu4 xˌoŋ zˈaːn tʃˌɔ t0ˈəɜt0 kˈaː4 kˌaːɜc kˌɔn tʃˈim kˈuɜt0 tʃˈɔŋ tʃˈuə2ŋ . |0 +dataset/Xanh24h/speaker_0/1766.wav|bˈaː6n xˌoŋ kˈə2n fˌaː4j bˈə6n t0ˈəm vˈe2 ɲˌy5ŋ ŋˈyə2j mˌaː2 bˈaː6n kˈu2ŋ ɗˈi tʃˈen zˈu twˈiɛ2n zˈa2ŋ lˈiɛ6w hˈɔ6 kˈɔɜ ɗˈu4 xˈaː4 nˈaŋ ɗˌe4 lˈaːɜj twˈiɛ2n hˈaj xˌoŋ . |0 +dataset/Xanh24h/speaker_0/1767.wav|lˈəː6n kˌɔn sˈaw kˈaːj sˈyə5 zˈəɜt0 tˈiɜc tʃˈa6j ɲˈa4j nˌen tʃˈuə2ŋ tʃˈaː6j kˈə2n zˈo6ŋ zˈaː5j , hwˈaːɜŋ mˈaːɜt0 vˌaː2 kˈɔɜ ˈe-ɜɲ sˈaːɜŋ mˈa6t0 tʃˈəː2j tʃˈiɛɜw vˈaː2w . |0 +dataset/Xanh24h/speaker_0/1774.wav|tʃˈuɜ tʃˈɔ6ŋ zˈi6c vˈu6 tʃˈam sˈɔɜk xˈe-ɜc hˈaː2ŋ , hˈə6w mˈaː5j , kˈɔɜ tʃˈiɜɲ sˈe-ɜc ɗˈo4j tʃˈaː4 , bˈaː4w hˈe-2ɲ zˈɔ5 zˈaː2ŋ , t0ˈy vˈəɜn ɲˈiɛ6t0 t0ˈi2ɲ tʃˌɔ xˈe-ɜc . |0 +dataset/Xanh24h/speaker_0/1783.wav|tˈaːm xˈaː4w hˈəʊmsteɪ kˈo6ŋ ɗˈo2ŋ ˈəː4 lˈaː2ŋ nˈə6m ɗˈam , hˈaː2 zˈaːŋ , lˈaː2ŋ kˈɔ4 , sˈaː hwˈi2ɲ , kˌɔn kˈəː t0ˈu , kˌɔn t0ˈum , lˈo lˈo tʃˈaː4j , hˈaː2 zˈaːŋ , xˈuə4j xˈɔn , bˈaː4w lˈaː6c . |0 +dataset/Xanh24h/speaker_0/1786.wav|kˌaːɜc zˈi6c vˈu6 nˈa2j kˈɔɜ tˈe4 ɗˌyə6c kˈuŋ kˈəɜp bˌəː4j kˌaːɜc tʃwˈiɛn zˈaː ɲˌy bˈaːɜc sˈi5 t0ˈəm tˈə2n , bˈaːɜc sˈi5 t0ˈəm lˈiɜ , ɲˈaː2 tʃˈi6 lˈiɛ6w t0ˈəm lˈiɜ , ɲˈən vˈiɛn sˈaː5 hˈo6j . |0 +dataset/Xanh24h/speaker_0/1789.wav|vˈe2 bˈəɜt0 bˈi2ɲ ɗˈa4ŋ sˈaː5 hˈo6j , kˈuə6c sˈoɜŋ sˈaː hwˈaː kˌuə4 zˈəːɜj sˈiɛw zˈa2w kˈatɑː lˌaː2 mˈo6t0 mˈiɲ tʃˈyɜŋ zˈɔ5 zˈaː2ŋ tʃˌɔ sˈy6 fˈən tʃˈiə zˈa2w ŋˈɛ2w tʃˈɔŋ sˈaː5 hˈo6j . |0 +dataset/Xanh24h/speaker_0/1792.wav|bˌəː4j tʃˈi4 kˈə2n kˈɔɜ mˈaɜj t0ˈiɜɲ hwˌa6c ɗˈiɛ6n twˈaː6j kˈeɜt0 nˈoɜj ɗˌyə6c vˌəːɜj mˈaː6ŋ ˌintəːnˈɛɜt , tˌi2 ŋˈyə2j zˈu2ŋ kˈɔɜ tˈe4 zˈe5 zˈaː2ŋ mˈuə ɗˌyə6c hˈaː2ŋ hwˈaːɜ tˈiɜc hˈəː6p mˌaː2 xˌoŋ kˈə2n t0ˈi2m kˈiɛɜm mˈəɜt0 tˈəː2j zˈaːn . |0 +dataset/Xanh24h/speaker_0/1807.wav|vˌəːɜj sˈoɜ vˈoɜn bˈaːn ɗˈə2w lˌaː2 bˈoɜn mˈyəj tʃˈiɛ6w , t0wˈi xˌoŋ fˌaː4j lˌaː2 kˌɔn sˈoɜ kwˈaːɜ lˈəːɜn , ɲˌyŋ vˌə5n ɗˈu4 lˈiɜ t0ˈyə4ŋ ɗˌe4 bˈaː6n bˈaɜt0 ɗˈə2w kˈiɲ zwˈe-ɲ zˈo2j ɗˈəɪɜ . |0 +dataset/Xanh24h/speaker_0/1808.wav|vˌi2 vˈəɪ6 , kˈyɜ vˈaː2w ŋˈa2j mˈu2ŋ mˈyə2j tˈaːɜŋ zˈiɛ1ŋ hˈaː2ŋ nˈam , mˌɔ6j ŋˈyə2j sˌɛ5 ɗˈi mˈuə vˈaː2ŋ vˌaː2 kˈuɜŋ kˈiɛɜŋ , ɗˌe4 kˈaː4m t0ˈaː6 vˌaː2 mˈɔŋ ŋˈaː2j t0ˈiɛɜp t0ˈu6c fˈu2 hˈo6 . |0 +dataset/Xanh24h/speaker_0/1815.wav|ŋwˈaː2j zˈaː , kˌɔ2n kˈɔɜ mˈo6t0 sˈoɜ mˈa6t0 hˈaː2ŋ kˈiɲ zwˈe-ɲ ɗˈo2 fˈɔŋ twˈi4 ŋˈaj tˈə2n t0ˈaː2j xˈaːɜc ɲˌy lˈiw hˈyəŋ , ɗˈɛ2n zˈə2w , bˈi2ɲ hwˈaː , kˈəɪ kˈe-4ɲ fˈɔŋ twˈi4 . |0 +dataset/Xanh24h/speaker_0/1816.wav|t0wˈi ɲˈiɛn , ˈoŋ kˈim vˌə5n t0ˈiɛɜp t0ˈu6c sˈoɜŋ mˈo6t0 kˈuə6c sˈoɜŋ sˈaː hwˈaː , tʃˌɔ zˈa2ŋ ɗˈiɛ2w nˈa2j lˌaː2 kˈə2n tˈiɛɜt0 ɗˌe4 tˈe4 hˈiɛ6n vˈi6 tˈeɜ kˌuə4 mˈi2ɲ lˌaː2 ɲˈaː2 lˈe-5ɲ ɗˈaː6w t0ˈoɜj kˈaːw kˌuə4 tʃˈiɛ2w t0ˈiɛn . |0 +dataset/Xanh24h/speaker_0/1823.wav|ɗˈəɪ lˌaː2 zˈoɜŋ hˈɛw ɗˌyə6c tʃˈɔ6n lˈɔ6k tˈɛw t0ˈiɛw tʃwˈə4n kˌuə4 kˈoŋ t0ˈi ɡɹˈiːn fˈɑːm ˈeɪʃə vˌaː2 kˈoŋ t0ˈi pˌeˌisˈe kˌuə4 mˈi5 . |0 +dataset/Xanh24h/speaker_0/1824.wav|tʃˈiɜɲ vˌi2 vˈəɪ6 , mˌaː2 hˈɔ6 kˈɔɜ tˈe4 sˈa5n sˈaː2ŋ bˈɔ4 t0ˈiɛ2n zˈaː twˈe ɲˌy5ŋ ŋˈyə2j ɗˌaː5 kˈɔɜ kˈiɲ ŋˈiɛ6m vˌaː2 kˈɔɜ xˈaː4 nˈaŋ kwˈaː4n tʃˈi6 fˈanpeɪdʒ ɗˌe4 kˈɔɜ tˈe4 zˈuɜp hˈɔ6 zˈaː t0ˈaŋ zwˈe-ɲ sˈoɜ . |0 +dataset/Xanh24h/speaker_0/1826.wav|ɗˈyə2ŋ fˈoɜ nˈo4j t0ˈiɛɜŋ kˌuə4 vˈiɛ6t0 nˈaːm ɗˌyə6c ɗˈoŋ ɗˈaː4w bˈaː6n bˈɛ2 kˈuəɜc t0ˈeɜ ˈyə tˈiɜc ɗˈo2ŋ tˈəː2j lˌaː2 tˈyɜc kwˈaː2 tʃˈiɛ2w kˈɔɜ tˈe4 tˈyə4ŋ tˈyɜc mˌo5j ŋˈa2j . |0 +dataset/Xanh24h/speaker_0/1827.wav|vˈəɪ6 , hˈom nˈaj t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˌɛ5 hˈyəɜŋ zˈə5n kwˈiɜ vˈi6 vˌaː2 kˌaːɜc bˈaː6n kˈe-ɜc tʃˈan nˈuəj zˈoɜŋ zˈe bˈo ˈəː2 sˈaːw tʃˌɔ hˈiɛ6w kwˈaː4 vˈe2 kˈiɲ t0ˈeɜ kˈaːw ɲˈəɜt0 kˈɔɜ tˈe4 . |0 +dataset/Xanh24h/speaker_0/1830.wav|vˈəɪ6 nˌen , vˈiɛ6c ŋˈiɛn kˈiɜw tˈi6 tʃˈyə2ŋ tʃˈyəɜc xˌi mˈəː4 kˈyə4 hˈaː2ŋ ˈaːɜw kˈyəɜj lˌaː2 ɗˈiɛ2w vˈo kˈu2ŋ kˈə2n tˈiɛɜt0 ɗˌe4 kˈyə4 hˈaː2ŋ kˌuə4 bˈaː6n ɲˈe-ɲ tʃˈɔɜŋ ɲˈə6n ɗˌyə6c sˈy6 ˈu4ŋ hˈo6 t0ˌy2 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1834.wav|tˈɛw tˈoɜŋ kˈe kˌuə4 hˈiɛ6p hˈo6j kˈiɲ zwˈe-ɲ vˈaː2ŋ vˈiɛ6t0 nˈaːm , mˌo5j nˈam xwˌaː4ŋ nˈam tʃˈam ŋˈi2n ɗˌeɜn mˈo6t0 tʃˈiɛ6w lˈyə6ŋ vˈaː2ŋ ɗˌyə6c bˈaːɜn zˈaː vˈaː2w ŋˈa2j vˈiəɜ tˈə2n t0ˈaː2j . |0 +dataset/Xanh24h/speaker_0/1838.wav|t0ˈy vˈəɜn xˈe-ɜc hˈaː2ŋ ɲˈiɛ6t0 t0ˈi2ɲ , tʃˈuɜ ɗˈaːɜw lˌaː2 mˈo6t0 tʃˈɔŋ ɲˌy5ŋ ˈiɛɜw t0ˈoɜ kwˈaːn tʃˈɔ6ŋ zˈuɜp bˈaː6n zˈy5 tʃˈən xˈe-ɜc hˈaː2ŋ vˌaː2 t0ˈaŋ zwˈe-ɲ tˈu . |0 +dataset/Xanh24h/speaker_0/1846.wav|mˌo5j kˈəɪ kˈɔ4 , mˌo5j xˈɔɜm hwˈaː xˌoŋ tʃˈi4 ɗˌyə6c ɗˈe-ɜɲ zˈaːɜ bˈa2ŋ ɗˈo lˈaː mˈi5 mˌaː2 kˌɔ2n kˈɛ2m tˈɛw hˈe6 tˈoɜŋ ˈoɜŋ zˈə5n nˈyəɜc t0ˌəːɜj t0ˈy6 ɗˈo6ŋ . |0 +dataset/Xanh24h/speaker_0/1848.wav|vˈiɜ zˈu6 ɲˌy , ɲˈiɛ2w sˈɛ bˈe-ɜɲ mˈi2 tˈo4 ɲˈi5 kˈi2 ɗˌaː5 ˈaːɜp zˈu6ŋ kˈɔmbɔ mˈuə bˈe-ɜɲ mˈi2 sˌɛ5 t0ˈa6ŋ tˈɛw nˈyəɜc ŋˈɔ6t0 kˈu2ŋ kˌaːɜc vˈə6t0 zˈu6ŋ kˈə2n tˈiɛɜt0 ɲˌy t0ˈam , xˈan zˈəɪɜ . |0 +dataset/Xanh24h/speaker_0/1850.wav|kˌaːɜc t0ˈyə6 hˈaː2ŋ kˈiɲ zwˈe-ɲ kwˈaː4 t0ˈa6ŋ ɗˈo2 fˈɔŋ twˈi4 tˈyə2ŋ kˈɔɜ ɲˈiɛ2w mˈə5w mˈaː5 kˈiɛ4w zˈaːɜŋ ɗˈaː zˈaː6ŋ fˈu2 hˈəː6p vˌəːɜj ɲˈiɛ2w ɗˈoɜj t0ˈyə6ŋ xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1854.wav|ɗˌyə6c tʃˈɛw bˈen ŋwˈaː2j vˈe-ɜc ŋˈan kˈaːw , vˈyə2 t0ˈə2m tʃˌɔ t0ˈy2ŋ lwˈaː6j zˈe , xwˌaː4ŋ bˈaː mˈyəj ɗˌeɜn nˈam mˈyəj sˈaŋt0ˈimˈɛɜt0 , kˈɔɜ tʃˈo5 ɗˈu4 tʃˌɔ zˈe ɗˈyə ɗˈə2w zˈaː ŋwˈaː2j mˈo6t0 kˈe-ɜc zˈe5 zˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1856.wav|kˈəɪ hˈɔ6 ɗˈə6w nˈam mˈyəj fˈə2n tʃˈam , hˈaː6t0 ŋˈu5 kˈoɜk hˈaːj mˈyəj fˈə2n tʃˈam , kˈaːɜm bˈaː mˈyəj fˈə2n tʃˈam , kˈə2n ɗˈaː4m bˈaː4w ŋˈɔn mˈiɛ6ŋ , kˈiɜc tˈiɜc hˈyəw ˈan ɲˈiɛ2w , xwˈɛ4 mˈe-6ɲ . |0 +dataset/Xanh24h/speaker_0/1864.wav|kˈɔɜ zˈəɜt0 ɲˈiɛ2w ˈəm tˈe-ɲ ɗˌe4 bˈaː6n tˈy4 ˈəm ɲˌy sˈuːpə hˈaːj tʃˈam lˈiɲ t0ˈaːɜm , blˈak klˈaʊd , sˈuːpə bˈeɪbi kˈiŋ . |0 +dataset/Xanh24h/speaker_0/1866.wav|sˈy6 hwˈaː2 kwˈiɛ6n kˌuə4 kˌaːɜc lwˈaː6j hwˈaːɜ kwˈaː4 xˈo , tˈaː4w mˈo6k ɗˌaː5 t0ˈaː6w nˌen vˈi6 ŋˈɔ6t0 tˈe-ɲ mˈo6t0 hˈyəŋ vˈi6 vˈo kˈu2ŋ mˈəːɜj lˈaː6 vˌaː2 xˈaːɜc bˈiɛ6t0 tʃˌɔ tʃˈaː2 sˈyə5 vˈən nˈaːm . |0 +dataset/Xanh24h/speaker_0/1876.wav|ɲˈə6n tˈyɜc kˌuə4 ŋˈyə2j t0ˈiɛw zˈu2ŋ vˈe2 bˈaː4w vˈe6 mˈoj tʃˈyə2ŋ ŋˈa2j kˈaː2ŋ nˈəŋ kˈaːw zˈə5n ɗˌeɜn sˈu hˈyəɜŋ sˈy4 zˈu6ŋ kwˈə2n ˈaːɜw sˈɛkənd hˈand ɗˌe4 zˈaː4m tˈiɛ4w sˈaɜc , tˈaː4j . |0 +dataset/Xanh24h/speaker_0/1880.wav|kˈu6 tˈe4 , mˌo5j ɲˈən vˈiɛn bˈaːɜn hˈaː2ŋ sˌɛ5 fˈu6 tʃˈe-ɜc mˈo6t0 ŋˈe-2ɲ hˈaː2ŋ tˈɛw sˈy6 fˈən kˈoŋ kˌuə4 kwˈaː4n lˈiɜ hwˌa6c zˈaːɜm sˈaːɜt0 ŋˈe-2ɲ hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1890.wav|tˈɛw kˈeɜt0 kwˈaː4 xˈaː4w sˈaːɜt0 kˌuə4 kˌaːɜc ɗˈəːn vˈi6 tʃˈyɜc nˈaŋ , tʃˈo2ŋ zˈyə6c lˈiɛ6w zˈyəɜj t0ˈaːɜn zˈy2ŋ kˈɔɜ tˈe4 mˈaːŋ lˈaː6j tˈu ɲˈə6p kˈaːw hˈəːn ɣˈəɜp ɲˈiɛ2w lˈə2n sˈɔ vˌəːɜj tʃˈo2ŋ kˈəɪ lˈəm ŋˈiɛ6p twˈə2n t0wˈiɜ . |0 +dataset/Xanh24h/speaker_0/1892.wav|kˈiɲ zwˈe-ɲ hˈaː4j sˈaː4n lˌaː2 mˈo6t0 lˈyə6 tʃˈɔ6n hˈəɜp zˈə5n , ɗˈa6c bˈiɛ6t0 tʃˈɔŋ bˈoɜj kˈe-4ɲ ɲˈu kˈə2w vˈe2 tˈy6c fˈə4m , tʃˈəɜt0 lˈyə6ŋ vˌaː2 zˈiɲ zˈyə5ŋ ŋˈa2j kˈaː2ŋ t0ˈaŋ kˈaːw . |0 +dataset/Xanh24h/speaker_0/1893.wav|tʃˈiɜɲ vˌi2 vˈəɪ6 , nˌeɜw kˈɔɜ tˈəː2j zˈaːn zˈe-4ɲ zˈo5j , bˈaː2 kˌɔn nˈoŋ zˈən kˈɔɜ tˈe4 tˈaːm xˈaː4w hˈi2ɲ tˈyɜc tʃˈo2ŋ kˈəɪ kˈe-4ɲ , kˈəɪ tʃˈaːŋ tʃˈiɜ t0ˈaŋ tˈem tˈu ɲˈə6p . |0 +dataset/Xanh24h/speaker_0/1898.wav|xˈe-ɜc hˈaː2ŋ tˈyə2ŋ swˈiɛn t0ˈi2m kˈiɛɜm ɲˌy5ŋ sˈaː4n fˈə4m mˈəːɜj ɲˈəɜt0 vˌaː2 hˈiɛ6n ɗˈaː6j ɲˈəɜt0 , vˌaː2 vˈiɛ6c kˈuŋ kˈəɜp ɲˌy5ŋ lˈyə6 tʃˈɔ6n ɗˈuɜŋ ɗˈaɜn sˌɛ5 zˈuɜp kˈyə4 hˈaː2ŋ tˈu hˈuɜt0 vˌaː2 sˈy5 tʃwˈə4n xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1903.wav|tˈɛw kˌaːɜc ŋˈuə2n tˈoŋ t0ˈin , ɲˈaː2 lˈe-5ɲ ɗˈaː6w kˈim ʒˈɔŋˈun ɗˌyə6c tʃˌɔ lˌaː2 tʃˈi xwˌaː4ŋ bˈaː mˈyəj tʃˈiɛ6w ɗˈo lˈaː mˈi5 mˌo5j nˈam ɗˌe4 tˈyə4ŋ tˈyɜc zˈyə6w , ɗˈa6c bˈiɛ6t0 lˌaː2 zˈyə6w kˈaːw kˈəɜp . |0 +dataset/Xanh24h/speaker_0/1905.wav|sˈaw xˌi ŋˈiɛn kˈiɜw tˈi6 tʃˈyə2ŋ , bˈaː6n kˈə2n lˈə6p kˈeɜ hwˈe-6c kˈiɲ zwˈe-ɲ ɗˌe4 sˈaːɜc ɗˈi6ɲ mˈu6c t0ˈiɛw , tʃˈiɛɜn lˈyə6c vˌaː2 kˈeɜ hwˈe-6c tˈy6c hˈiɛ6n . |0 +dataset/Xanh24h/speaker_0/1909.wav|bˈaː6n kˈɔɜ tˈe4 sˈy4 zˈu6ŋ kˌaːɜc kˈoŋ kˈu6 vˈən t0ˈiɜc ɗˌe4 ɗˈɔ lˈyə2ŋ hˈiɛ6w kwˈaː4 kˌuə4 tʃˈiɛɜn zˈi6c ɲˌy ðˈe7 ˈɔ ˈɔ ðˈe7 ˈɛləː2 ˈɛ ˌanɐlˈɪtɪks , fˈeɪsbʊk ˈɪnsaɪt . |0 +dataset/Xanh24h/speaker_0/1911.wav|mˈa6c zˌu2 tʃˈi fˈiɜ ɗˈə2w t0ˈy kˌɔ2n zˈoɜŋ bˈaːn ɗˈə2w kˈaːw , ɲˌyŋ hˈyəw sˈaːw lˌaː2 ɗˈo6ŋ vˈə6t0 hwˈaːŋ zˈaː5 , nˌen zˈe5 nˈuəj , kˈɔɜ sˈyɜc ɗˌe4 xˈaːɜŋ t0ˈoɜt0 , ˈiɜt0 zˈi6c bˈe6ɲ . |0 +dataset/Xanh24h/speaker_0/1915.wav|hˈɔ6 tˈyə2ŋ swˈiɛn tʃˈi hˈaː2ŋ tʃˈiɛ6w , tˈə6m tʃˈiɜ hˈaː2ŋ t0ˈi4 ɗˈo lˈaː mˈi5 tʃˌɔ ɲˌy5ŋ mˈɔɜn ɗˈo2 sˈaː sˈi4 , ɲˌy tʃˈaːŋ sˈyɜc , kwˈə2n ˈaːɜw , sˈɛ hˈəːj , zˈu twˈiɛ2n . |0 +dataset/Xanh24h/speaker_0/1919.wav|vˈe6 sˈiɲ tʃˈuə2ŋ tʃˈaː6j tˈyə2ŋ swˈiɛn , sˈy4 zˈu6ŋ ɗˈiɛ4m lˈɔɜt0 sˈiɲ hˈɔ6k ɗˌe4 ɗˈaː4m bˈaː4w vˈe6 sˈiɲ vˌaː2 ˈaːn t0wˈaː2n sˈiɲ hˈɔ6k tʃˌɔ tʃˈan nˈuəj ɣˈaː2 tˈaː4w zˈyə6c . |0 +dataset/Xanh24h/speaker_0/1925.wav|tˈaj ɗˈo4j t0ˈy t0ˈyə4ŋ vˌaː2 ˈaːɜp zˈu6ŋ fˈə2n mˈe2m kwˈaː4n lˈiɜ bˈaːɜn hˈaː2ŋ lˌaː2 mˈo6t0 sˈu hˈyəɜŋ t0ˈəɜt0 ˈiɛɜw ɗˈoɜj vˌəːɜj kˌaːɜc kˈyə4 hˈaː2ŋ kˈiɲ zwˈe-ɲ kwˈə2n ˈaːɜw tʃˈɛ4 ˈɛm . |0 +dataset/Xanh24h/speaker_0/1927.wav|vˈəɪ6 nˌen , nˌeɜw bˈaː6n ɗˌaːŋ mˈuəɜn fˈaːɜt0 tʃˈiɛ4n , mˈo6t0 mˈo hˈi2ɲ tʃˈan nˈuəj ɗˈɛm lˈaː6j lˈəː6j ɲwˈə6n kˈaːw , kˈɔɜ tˈe4 tˈaːm xˈaː4w kwˈaː vˈiɛ6c nˈuəj ˈiɛɜn nˈa2j ɲˈɛɜ . |0 +dataset/Xanh24h/speaker_0/1929.wav|ɗˈə2w t0ˈiɛn , bˈaː6n kˈɔɜ tˈe4 sˈəɪ zˈy6ŋ tʃˈuə2ŋ tʃˈaː6j , nˈuəj kˌaːɜc lwˈaː6j zˈaː sˈuɜc , zˈaː kˈə2m , sˈaw ɗˈɔɜ kˈɔɜ tˈe4 t0ˈə6n zˈu6ŋ tʃˈəɜt0 tˈaː4j t0ˌy2 tʃˈan nˈuəj lˈaː2m fˈən bˈɔɜn tʃˌɔ kˌaːɜc lwˈaː6j kˈəɪ . |0 +dataset/Xanh24h/speaker_0/1936.wav|ŋwˈaː2j zˈaː , kˈɔɜ tˈe4 sˈy4 zˈu6ŋ zˈaw , kˈu4 , kwˈaː4 , sˈaːɜc ɗˈo6ŋ vˈə6t0 , kˈaːɜ ˈyən , fˈeɜ fˈə4m lˈɔ2 mˈo4 , fˈən ɗˈo6ŋ vˈə6t0 ɗˌe4 t0ˈiɛɜt0 kˈiɛ6m tʃˈi fˈiɜ . |0 +dataset/Xanh24h/speaker_0/1939.wav|kˌaːɜc vˈe6t0 sˈɔ6k nˈa2j mˈəɜt0 zˈə2n xˌi lˈəː6n ɗˈaː6t0 t0ˌy2 mˈyə2j hˈaːj kˈilˈoɣˈaːm mˈo6t0 kˌɔn tʃˈəː4 lˈen , vˌaː2 mˈəɜt0 hˈa4n xˌi ɗˈaː6t0 mˈyə2j bˈa4j ɗˌeɜn mˈyə2j t0ˈaːɜm kˈilˈoɣˈaːm mˈo6t0 kˌɔn , xwˌaː4ŋ bˈaː tˈaːɜŋ t0ˈuə4j . |0 +dataset/Xanh24h/speaker_0/1942.wav|bˈaː6n kˈɔɜ tˈe4 t0ˈaː6w zˈaː mˈo6t0 sˈaː4n fˈə4m mˈəːɜj , lˈɔɣɔ , slˈɔɣaːn , hwˌa6c hˈi2ɲ ˈe-4ɲ ɲˈə6n zˈiɛ6n zˈiɛŋ tʃˌɔ sˈɛ kˈaː2 fˈe kˌuə4 mˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/1946.wav|tʃˈuə2ŋ nˈuəj fˌaː4j tˈoŋ twˈaːɜŋ , sˈe-6c sˌɛ5 , tʃˈoɜŋ ɗˌyə6c zˈɔɜ lˈuə2 , ɗˈoŋ ˈəɜm , hˈɛ4 mˈaːɜt0 , zˈe5 kwˈɛɜt0 zˈɔ6n vˈe6 sˈiɲ , twˈaːɜt0 vˈən vˌaː2 nˈyəɜc t0ˈiɛ4w zˈe5 zˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1947.wav|bˈen kˈe-6ɲ ɗˈɔɜ , ˈiw ɗˈiɛ4m kˌuə4 lˈəː6n zˈy2ŋ tˈaː4 zˈoŋ tʃˈiɜɲ lˌaː2 tʃˈuɜŋ hˈə2w ɲˌy xˌoŋ bˌi6 bˈe6ɲ vˌaː2 sˈiɲ sˈaː4n zˈəɜt0 ɗˈo2ŋ ɗˈe2w . |0 +dataset/Xanh24h/speaker_0/1948.wav|tʃˈuŋ bˈi2ɲ mˌo5j ŋˈa2j , tʃˈi6 ŋˈɔ6k bˈaːɜn t0ˌy2 mˈyə2j lˈam ɗˌeɜn hˈaːj mˈyəj bˈaːɜt0 hwˈe-2ɲ tˈe-ɜɲ vˌaː2 mˈi2 ɣˈaː6w , xwˌaː4ŋ nˈam mˈyəj tʃˈiɛɜc bˈe-ɜɲ mˈi2 tˈe-ɲ lˈɔŋ tˈyə2ŋ vˌaː2 mˈyə2j tʃˈiɛɜc hˈambɜːɡə . |0 +dataset/Xanh24h/speaker_0/1949.wav|hˈəː6p ɗˈo2ŋ kˈə2n bˈaːw ɣˈo2m kˌaːɜc nˈo6j zˈuŋ ɲˌy sˈaː4n fˈə4m , zˈaːɜ kˈaː4 , tˈəː2j zˈaːn zˈaːw hˈaː2ŋ , bˈaː4w hˈe-2ɲ ɗˌe4 ɗˈaː4m bˈaː4w kwˈiɛ2n lˈəː6j kˌuə4 kˈaː4 hˈaːj bˈen . |0 +dataset/Xanh24h/speaker_0/1955.wav|zˈɔ xˌoŋ ɗˈu4 vˈoɜn , ˈe-ɲ ɗˈe-2ɲ tˈeɜ tʃˈəɜp sˈo4 ɗˈɔ4 ɗˌe4 fˈaj t0ˈiɛ2n mˈuə kˈaːɜ , sˈəɪ zˈy6ŋ hˈe6 tˈoɜŋ sˈy4 lˈiɜ nˈyəɜc , ɗˈaː2w vˌaː2 kˈaː4j t0ˈaː6w lˈaː6j ˈaːw . |0 +dataset/Xanh24h/speaker_0/1957.wav|ɗˈiɛ2w nˈa2j zˈuɜp ɗˈaː4m bˈaː4w zˈa2ŋ sˈaː4n fˈə4m vˌə5n zˈy5 ɗˌyə6c sˈy6 sˈoɜŋ , xwˈɛ4 mˈe-6ɲ vˌaː2 xˌoŋ bˌi6 tʃˈɔɜk vˈəɪ4 , zˈu6ŋ kˈaː2ŋ hˈaj kˈɔɜ vˈeɜt0 sˈyəɜc tʃˈen mˈaj vˌaː2 zˈaː . |0 +dataset/Xanh24h/speaker_0/1968.wav|t0ˌy2 ɗˈɔɜ , kˈɔɜ kˌaːɜj ɲˈi2n zˈɔ5 hˈəːn vˈe2 hˈaː2ŋ mˌeɪd ˈin vˌiːətnˈɑːm , xˌoŋ hˈe2 kˈɛɜm kˌaːɜc sˈaː4n fˈə4m kˈuəɜc t0ˈeɜ " , t0wˈəɜn tˈe-ɲ tʃˌɔ bˈiɛɜt0 . |0 +dataset/Xanh24h/speaker_0/1972.wav|ɗˈa6c bˈiɛ6t0 tʃˈɔŋ kˈaː2 zˈoɜt0 kˈɔɜ tʃˈyəɜ ɲˈiɛ2w kˈaɹəʊtˌiːn , bˈo4 sˈuŋ vˈɪtəmɪn tʃˈɔŋ mˈuə2 ɗˈoŋ vˌaː2 mˈuə2 swˈən nˌen hˈyəw zˈəɜt0 tˈiɜc ˈan . |0 +dataset/Xanh24h/speaker_0/1973.wav|sˈaw bˈaː mˈyəj ɗˌeɜn bˈoɜn mˈyəj lˈam fˈuɜt0 , bˈɔ4 lˈəːɜp tˈyɜc ˈan zˈaː vˌaː2 ɲˈɛ6 ɲˈaː2ŋ kˈə2m t0ˈəː2 zˈəɪɜ lˈen , lˈə6t0 ŋˈyə6c , ɗˈa6t0 vˈaː2w nˈɔ2ŋ vˌaː2 tʃˌɔ t0ˈa2m ˈan bˈyə5 ɗˈə2w t0ˈiɛn . |0 +dataset/Xanh24h/speaker_0/1977.wav|mˈiɛ6ŋ kˈaːɜ , mˈaːŋ vˌaː2 hˈoɜk mˈaːŋ , hˈə6w mˈon , ɣˈoɜk vˈəɪ2 bˌi6 sˈyŋ ɗˈɔ4 , ɗˈə2w t0ˈɔ , mˈi2ɲ ɣˈəɪ2 , zˈaː kˈaːɜ tʃwˈiɛ4n mˈa2w sˈaːɜm , kˈaːɜ mˈəɜt0 fˈyəŋ hˈyəɜŋ . |0 +dataset/Xanh24h/speaker_0/1979.wav|sˈaw hˈaːj mˈyəj t0ˈy zˈəː2 , sˈoŋ hˈəːj , kˈyə4 fˈɔ2ŋ mˈəːɜj ɗˌyə6c mˈəː4 vˌaː2 sˈaw bˈa4j ɗˌeɜn mˈyə2j ŋˈa2j nˈa2j , kwˈaːɜ tʃˈi2ɲ nˈuəj t0ˈa2m mˈəːɜj ɗˌyə6c bˈaɜt0 ɗˈə2w . |0 +dataset/Xanh24h/speaker_0/1980.wav|tʃˈɔŋ lˈi5ɲ vˈy6c tʃˈan nˈuəj , vˈiɛ6c nˈuəj tʃˈim kˈuɜt0 ɗˌe4 tʃˈyɜŋ ɗˌaː5 tʃˈəː4 tˈe-2ɲ mˈo6t0 lˈyə6 tʃˈɔ6n hˈəɜp zˈə5n vˌəːɜj hˈiɛ6w swˈəɜt0 kˈiɲ t0ˈeɜ kˈaːw . |0 +dataset/Xanh24h/speaker_0/1981.wav|sˈaːɜc ɗˈi6ɲ mˈu6c t0ˈiɛw tʃˈiɜɲ sˈaːɜc sˌɛ5 zˈuɜp zwˈe-ɲ ŋˈiɛ6p kˈɔɜ tˈe4 t0ˈaː6w zˈaː ɲˌy5ŋ sˈaː4n fˈə4m , zˈi6c vˈu6 ɗˈaːɜp ˈyɜŋ ɗˈuɜŋ mˈɔŋ ɗˈəː6j kˌuə4 xˈe-ɜc hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1983.wav|ɲˌy5ŋ ˈiɜ t0ˈyə4ŋ nˈa2j ɗˌyə6c lˈyə6 tʃˈɔ6n zˈyə6 tʃˈen ɲˈu kˈə2w tˈy6c t0ˈeɜ kˌuə4 ŋˈyə2j t0ˈiɛw zˈu2ŋ , kˈu5ŋ ɲˌy t0ˈiɛ2m nˈaŋ mˈaːŋ lˈaː6j lˈəː6j ɲwˈə6n kˈaːw tʃˈɔŋ ɗˈem zˈaːw tˈyə2 . |0 +dataset/Xanh24h/speaker_0/1985.wav|hˈi2ɲ tˈyɜc kˈiɲ zwˈe-ɲ nˈa2j kˌɔ2n kˈɔɜ ɲˈiɛ2w ˈiw ɗˈiɛ4m ɲˌy bˈaː6n xˌoŋ t0ˈoɜn tʃˈi fˈiɜ twˈe mˈa6t0 bˈa2ŋ , kˈɔɜ tˈe4 zˈi tʃwˈiɛ4n lˈiw ɗˈo6ŋ ɗˌeɜn mˌɔ6j nˈəːj , zˈe5 zˈaː2ŋ t0ˈiɛɜp kˈə6n ŋˈuə2n xˈe-ɜc hˈaː2ŋ mˈəːɜj . |0 +dataset/Xanh24h/speaker_0/1991.wav|vˌəːɜj ɗˈaː2n zˈe tʃˈɛw t0ˌy2 ɲˈɔ4 ɗˌeɜn vˈyə2 , tʃˈi4 t0ˈiɜɲ zˈiɛŋ bˈaːɜn zˈoɜŋ mˌo5j nˈam , bˈaː2 kˌɔn ɗˌaː5 kˈɔɜ tʃˈɔŋ t0ˈaj ɣˈə2n mˈo6t0 tʃˈam tʃˈiɛ6w ɗˈo2ŋ mˈo6t0 kˈe-ɜc zˈe5 zˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/1992.wav|tʃˈaːw ɗˈo4j tˈaː4w lwˈə6n kˌuə4 kˌaːɜc tʃwˈiɛn zˈaː , ɗˈaː6j bˈiɛ4w t0ˈaː6j zˈiɛ5n ɗˈaː2n ɗˌaː5 tˈoŋ ɲˈəɜt0 vˌəːɜj ɲˈaw zˈa2ŋ tˈi6 tʃˈyə2ŋ bˈaɜt0 ɗˈo6ŋ sˈaː4n ɗˌaːŋ ɗˈoɜj zˈiɛ6n vˌəːɜj ɲˈiɛ2w xˈɔɜ xˈan , tˈe-ɜc tˈyɜc . |0 +dataset/Xanh24h/speaker_0/1994.wav|ŋwˈaː2j ɲˌy5ŋ tˈoŋ t0ˈin kˈəː bˈaː4n vˈe2 sˈaː4n fˈə4m , bˈaː6n kˈɔɜ tˈe4 kˈuŋ kˈəɜp tʃˌɔ xˈe-ɜc hˈaː2ŋ tˈem tˈoŋ t0ˈin bˈo4 sˈuŋ vˈe2 kˈe-ɜc sˈy4 zˈu6ŋ , bˈaː4w kwˈaː4n sˈaː4n fˈə4m . |0 +dataset/Xanh24h/speaker_0/1999.wav|tˈə6m tʃˈiɜ kˌɔ2n kˈɔɜ kˈɛ2m ŋwˈi6 tʃˈaːŋ kwˈən sˈy6 ðˈe7 tʃˈiɜn kˈɑːməʊ ɗˌyə6c t0ˈiɛɜp tˈi6 tʃˌɔ kˌaːɜc kwˈən ɲˈən , ŋˈiə5 vˈu6 kwˈən sˈy6 kˌuə4 hˈaː2n kˈuəɜc vˌə5n lˌaː2 bˈaɜt0 bˈuə6c . |0 +dataset/Xanh24h/speaker_0/2010.wav|nˈam hˈaːj ŋˈi2n xˌoŋ tʃˈam mˈyə2j bˈa4j , xˌi ɗˌaːŋ lˈaː2m kˈoŋ ɲˈən , ˈe-ɲ t0ˈi2ɲ kˈəː2 xˈaːɜm fˈaːɜ mˈo hˈi2ɲ nˈuəj tˈɔ4 tʃˈen ˌintəːnˈɛɜt vˌaː2 ɲˈə6n tˈəɪɜ zˈa2ŋ nˈɔɜ mˈaːŋ lˈaː6j hˈiɛ6w kwˈaː4 kˈiɲ t0ˈeɜ kˈaːw . |0 +dataset/Xanh24h/speaker_0/2016.wav|ˈiw t0ˈiɛn tʃˈɔ6n ɲˌy5ŋ kˌɔn zˈe kˌaːɜj kˈɔɜ kwˈaːɜ tʃˈi2ɲ sˈiɲ tʃˈyə4ŋ vˈyə6t0 tʃˈuə5j ɲˈəɜt0 tʃˈɔŋ ɗˈaː2n t0ˌy2 lˌuɜc zˈəː2 sˈiɲ ɗˌeɜn xˌi tʃˈyə4ŋ tˈe-2ɲ . |0 +dataset/Xanh24h/speaker_0/2023.wav|kˈo6t0 mˈoɜk kwˈaːn tʃˈɔ6ŋ ɲˈəɜt0 vˌəːɜj t0ˈoj lˌaː2 ŋˈa2j sˈoɜ kwˈə2n ˈaːɜw lˈaː2m vˈoɜn ɗˌyə6c tʃˈɔ2n hˈaːj mˈyəj bˈo6 , tˈe-2ɲ kwˈaː4 sˈaw ɣˈə2n mˈo6t0 nˈam zˈɔ2ŋ zˈaː5 ɗˌe4 zˈe-2ɲ t0ˈy2ŋ ɗˈo2ŋ , t0ˈy2ŋ kˈaɜt0 . |0 +dataset/Xanh24h/speaker_0/2027.wav|nˌeɜw ɲˈə6p vˈe2 lwˈaː6j lˈəː6n kˈəː5 mˈyə2j ɗˌeɜn mˈyə2j hˈaːj kˈɪləɡɹˌam mˈo6t0 kˌɔn , ˈyɜŋ vˌəːɜj tʃˈen bˈaː ɗˌeɜn bˈoɜn tˈaːɜŋ t0ˈuə4j , tˌi2 vˈiɛ6c nˈuəj t0ˈiɛɜp t0ˌəːɜj xˌi swˈəɜt0 tʃˈuə2ŋ sˌɛ5 ɗˈəːn zˈaː4n hˈəːn ɲˈiɛ2w . |0 +dataset/Xanh24h/speaker_0/2028.wav|vˌaː2 nˌeɜw tˈiɜc vˈɪdɪəʊ nˈa2j kˌuə4 tʃˈuɜŋ t0ˈoj , hˈa5j lˈaɪk , ʃˈeə vˌaː2 ɲˈəɜn nˈuɜt0 ɗˈaŋ kˈiɜ kˈeɲ ɗˌe4 ɗˈɔɜn ɗˈɔ6k ɲˌy5ŋ tˈoŋ t0ˈin bˈo4 ˈiɜc t0ˈiɛɜp tˈɛw ɲˈɛɜ ! |0 +dataset/Xanh24h/speaker_0/2036.wav|sˈuŋ kwˈe-ɲ tʃˈaː6j kˈə2n sˈəɪ t0ˈyə2ŋ hwˌa6c kwˈəɪ kˈiɜn bˈa2ŋ lˈyəɜj bˈe bˈoɜn mˈyəj , kˈə2n kˈaː6p kˈi5 fˈə2n sˈaɜt0 mˈa6t0 ɗˈəɜt0 , tʃˈe-ɜɲ lˈəː6n zˈy2ŋ ɗˈaː2w ɗˈəɜt0 tʃˈuj zˈaː . |0 +dataset/Xanh24h/speaker_0/2044.wav|kˌaːɜc ɲˈaː2 kˈuŋ kˈəɜp wˈi t0ˈiɜn tˈyə2ŋ kˈɔɜ ɲˈiɛ2w kˈiɲ ŋˈiɛ6m vˌaː2 ŋˈuə2n lˈy6c ɗˈaː4m bˈaː4w kˈuŋ kˈəɜp sˈaː4n fˈə4m tʃˈəɜt0 lˈyə6ŋ t0ˈoɜt0 , zˈaːɜ kˈaː4 kˈe-6ɲ tʃˈe-ɲ vˌaː2 zˈi6c vˈu6 hˈə6w mˈaː5j t0ˈoɜt0 . |0 +dataset/Xanh24h/speaker_0/2058.wav|tʃˈyəɜc xˌi bˈaɜt0 ɗˈə2w , ŋˈyə2j tʃˈu4 kˈə2n t0ˈiɜɲ t0wˈaːɜn kˌaːɜc xwˈaː4n tʃˈi fˈiɜ fˌaː4j bˈɔ4 zˈaː ɗˌe4 kˈəɜt0 lˈoɜj t0ˈaː2j tʃˈiɜɲ vˌaː2 tʃˈu4 ɗˈo6ŋ hˈəːn tʃˈɔŋ vˈiɛ6c tʃwˈiɛ4n xˈaːj ˈiɜ ɗˈo2 kˌuə4 mˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/2060.wav|kˌaːɜc t0ˈuə kˌuə4 bˈiɜ xˌoŋ tˈe4 bˈaːɜm vˈaː2w kˌaːɜc tˈe-ɲ ɣˈo5 zˈa2j , vˌi2 vˈəɪ6 kˈə2n bˈuə6c kˌaːɜc zˈəɪ lˈɛw vˈaː2w hˈaː2ŋ zˈaː2w bˈa2ŋ sˈəː6j sˈɛ nˈoŋ ŋˈiɛ6p xˌi tʃˈuɜŋ fˈaːɜt0 tʃˈiɛ4n ɗˌe4 kˌaːɜc t0ˈuə bˈaːɜm vˈaː2w . |0 +dataset/Xanh24h/speaker_0/2075.wav|nˌeɜw kwˈiɜ vˈi6 vˌaː2 kˌaːɜc bˈaː6n mˈuəɜn bˈiɛɜt0 tˈem vˈe2 bˈəɜt0 kˈi2 tˈoŋ t0ˈin nˈaː2w , vˈuj lˈɔ2ŋ hˈa5j ɗˌe4 lˈaː6j bˈi2ɲ lwˈə6n ɗˌe4 tʃwˈiɛn zˈaː kˌuə4 tʃˈuɜŋ t0ˈoj lˈiw ˈiɜ . |0 +dataset/Xanh24h/speaker_0/2081.wav|tʃˈen ɗˈəɪ lˌaː2 ɲˌy5ŋ tʃˈiə sˈɛ4 ɲˈɔ4 kˌuə4 t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ vˈe2 tʃˈu4 ɗˈe2 kˈiɲ zwˈe-ɲ nˈam mˈa6t0 hˈaː2ŋ bˈaːɜn tʃˈa6j ɲˈəɜt0 t0ˈeɜt0 hˈaːj mˈyəj bˈaː tˈaːɜŋ tʃˈaː6p . |0 +dataset/Xanh24h/speaker_0/2090.wav|vˌəːɜj fˈə2n mˈe2m kwˈaː4n lˈiɜ bˈaːɜn hˈaː2ŋ , tʃˈu4 hˈiɛ6w sˈe-ɜc sˌɛ5 xˌoŋ kˌɔ2n fˌaː4j kˈiɛ4m swˈaːɜt0 zˈɔ t0ˈy2ŋ tʃˈaːŋ ɗˌe4 sˈɔ sˈe-ɜɲ ɗˈoɜj tʃˈiɛɜw vˌəːɜj xˈɔ hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/2091.wav|mˈa2w vˈaː2ŋ ɗˈə6m kˌuə4 vˈɔ4 xˌoŋ tʃˈi4 lˈaː2m t0ˈaŋ zˈaːɜ tʃˈi6 tˈə4m mˈi5 mˌaː2 kˌɔ2n lˌaː2 zˈəɜw hˈiɛ6w kˌuə4 sˈy6 tʃˈiɜn mˈɔ6ŋ vˌaː2 zˈa2w tʃˈəɜt0 zˈiɲ zˈyə5ŋ . |0 +dataset/Xanh24h/speaker_0/2093.wav|nˌeɜw tʃˈi4 mˈuəɜn nˈuəj tʃˈɛw tʃˈɛw lˈəɪɜ zˈoɜŋ , bˈaː2 kˌɔn zˈəɜt0 kˈə2n tʃˈuɜ ˈiɜ vˈəɜn ɗˈe2 tˈyɜ t0ˈy nˈa2j , ɗˈɔɜ tʃˈiɜɲ lˌaː2 kˈi5 twˈə6t0 nˈuəj tʃˈɛw tʃˈɛw sˈiɲ sˈaː4n . |0 +dataset/Xanh24h/speaker_0/2095.wav|t0wˈi ɲˈiɛn , nˌeɜw mˈuə kˌɔn zˈoɜŋ sˈiɲ sˈaː4n , tˈiɛɜt0 ŋˈi5 kwˈiɜ vˈi6 vˌaː2 kˌaːɜc bˈaː6n nˌen tʃˈɔ6n vˈu2ŋ ɗˈəɜt0 zˈe5 sˈəɪ zˈy6ŋ tʃˈuə2ŋ vˌi2 zˈoɜŋ zˈe nˈa2j ɲˈən ɗˈaː2n zˈəɜt0 ɲˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/2096.wav|ɗˌe4 kˈuŋ kˈəɜp zˈaːɜ kˈaː4 hˈəː6p lˈiɜ , bˈaː6n kˈə2n tˈaːm xˈaː4w zˈaːɜ kˈaː4 kˌaːɜc ɗˈoɜj tˈu4 kˈe-6ɲ tʃˈe-ɲ , ɗˈo2ŋ tˈəː2j t0ˈiɜɲ t0wˈaːɜn tʃˈi fˈiɜ vˌaː2 lˈəː6j ɲwˈə6n hˈəː6p lˈiɜ . |0 +dataset/Xanh24h/speaker_0/2099.wav|mˈo6t0 kˌaːɜj t0ˈen hˈaj , zˈe5 ɲˈəːɜ , zˈe5 fˈaːɜt0 ˈəm sˌɛ5 zˈuɜp xˈe-ɜc hˈaː2ŋ ɣˈi ɲˈəːɜ vˌaː2 zˈe5 zˈaː2ŋ t0ˈi2m kˈiɛɜm kˈyə4 hˈaː2ŋ kˌuə4 bˈaː6n . |0 +dataset/Xanh24h/speaker_0/2101.wav|tˈɛw t0ˈiɛɜt0 lˈo6 kˌuə4 ɲˌy5ŋ ŋˈyə2j tʃˈiɛ2w t0ˈiɛn ɗˈaː2w t0ˈə4w , kˈuə6c sˈoɜŋ sˈaː hwˈaː kˌuə4 ɲˈaː2 lˈe-5ɲ ɗˈaː6w t0ˈo2j kˈaːw kˈim ʒˈɔŋˈun ɗˌyə6c mˈo t0ˈaː4 vˌəːɜj ɲˌy5ŋ ˈiɛɜw t0ˈoɜ sˈaː hwˈaː vˌaː2 ɗˈa6c sˈaɜc . |0 +dataset/Xanh24h/speaker_0/2103.wav|t0wˈi ɲˈiɛn , xˌi ɗˌyə6c tˈo4j t0ˈɔ , tʃˈaːŋ tʃˈiɜ tˈem kwˈɛ kˈə2m vˌaː2 kˌaːɜc ˈiɛɜw t0ˈoɜ ɗˈa6c bˈiɛ6t0 xˈaːɜc , zˈaːɜ bˈaːɜn kˌuə4 mˌo5j kwˈaː4 bˈɔɜŋ kˈɔɜ tˈe4 t0ˈaŋ lˈen ɗˈaːɜŋ kˈe4 . |0 +dataset/Xanh24h/speaker_0/2110.wav|xˌoŋ tʃˈi4 zˈuɜp ɗˈəː5 bˈaː2 kˌɔn nˈoŋ zˈən t0ˈiɛw tˈu6 sˈaː4n fˈə4m , mˌaː2 kˌɔ2n mˈaːŋ lˈaː6j zwˈe-ɲ tˈu lˈəːɜn tʃˌɔ zwˈe-ɲ ŋˈiɛ6p vˌaː2 kˌaːɜc t0ˈiɛ4w tˈyəŋ . |0 +dataset/Xanh24h/speaker_0/2114.wav|mˈo6t0 tʃˈiɛɜc bˈe-ɜɲ kˈyəɜj ɗˈɛ6p xˌoŋ tʃˈi4 kˈə2n kˈɔɜ hˈyəŋ vˈi6 tˈəːm ŋˈɔn , mˌaː2 kˌɔ2n fˌaː4j kˈɔɜ tˈiɛɜt0 kˈeɜ ˈəɜn t0ˈyə6ŋ , fˈu2 hˈəː6p vˌəːɜj sˈəː4 tˈiɜc kˌuə4 kˈo zˈə1w vˌaː2 tʃˈuɜ zˈe4 . |0 +dataset/Xanh24h/speaker_0/2130.wav|tˈaj vˈaː2w ɗˈɔɜ , ŋˈyə2j t0ˈiɛw zˈu2ŋ tˈyə2ŋ t0ˈi2m kˈiɛɜm ɲˌy5ŋ sˈaː4n fˈə4m tˈe-ɲ tˈe-ɲ , ˈiɜt0 ɗˈyə2ŋ , xˌoŋ kwˈaːɜ ŋˈɔ6t0 , vˌaː2 kˈɔɜ tˈe4 tˈyə4ŋ tˈyɜc mˌaː2 xˌoŋ kˈaː4m tˈəɪɜ ŋˈaɜn . |0 +dataset/Xanh24h/speaker_0/2133.wav|hˈəːn tˈeɜ nˈyə5 , mˈo hˈi2ɲ nˈuəj lˈəː6n tˈɛw hˈyəɜŋ kˈoŋ ŋˈiɛ6p kˌuə4 ˈoŋ hwˈaː6t0 ɣˈə2n ɗˈəɪ ɗˌyə6c ɲˈiɛ2w ŋˈyə2j ˈəː4 tʃˈɔŋ vˌaː2 ŋwˈaː2j hwˈiɛ6n ɗˌeɜn tˈaːm kwˈaːn , hˈɔ6k t0ˈə6p kˈiɲ ŋˈiɛ6m . |0 +dataset/Xanh24h/speaker_0/2135.wav|hˈyəŋ vˈi6 ɗˈa6c tʃˈyŋ kˌuə4 mˈɔɜn ˈan nˈa2j xˌoŋ tʃˈi4 lˌaː2 nˈiɛ2m t0ˈy6 hˈaː2w kˌuə4 ŋˈyə2j zˈən lˈaː2ŋ ɗˈaː6j hwˈaː2ŋ , mˌaː2 kˌɔ2n lˌaː2 ɗˈa6c sˈaː4n ɗˈo6k ɗˈaːɜw , tˈu hˈuɜt0 sˈy6 tʃˈuɜ ˈiɜ kˌuə4 ɲˈiɛ2w tˈy6c xˈe-ɜc xˈaɜp nˈəːj . |0 +dataset/Xanh24h/speaker_0/2136.wav|ɗˈem zˈaːw tˈyə2 lˌaː2 tˈəː2j xˈaɜc tˈiɛ2n lˈiɛ2n ɲˈəɜt0 tʃˈɔŋ nˈam , lˌaː2 lˌuɜc mˌɔ6j ŋˈyə2j kˈu2ŋ ɲˈaw sˈuŋ vˈəɪ2 ɗˈɔɜn tʃˈaː2w mˈo6t0 nˈam mˈəːɜj ˈaːn lˈe-2ɲ , hˈe-6ɲ fˈuɜc . |0 +dataset/Xanh24h/speaker_0/2141.wav|lˌɒs dˈɒbli lˌaː2 mˈo6t0 xˈe-ɜc sˈaː6n sˈaːŋ tʃˈɔ6ŋ t0wˈiɛ6t0 ɗˈɛ6p mˈaːŋ ɗˌeɜn tʃˌɔ zˈu xˈe-ɜc ɲˌy5ŋ xˈuŋ kˈe-4ɲ , tʃˈo5 ˈəː4 vˌaː2 ˈə4m tˈy6c t0wˈiɛ6t0 vˈəː2j ɲˈəɜt0 kˌuə4 ˈuɜc . |0 +dataset/Xanh24h/speaker_0/2148.wav|nˌeɜw bˈaː6n ɗˌaː5 kˈɔɜ tˈyəŋ hˈiɛ6w kˈaːɜ ɲˈən , kˈeɜt0 hˈəː6p nˈɔɜ vˈaː2w tˈyəŋ hˈiɛ6w mˈəːɜj kˈɔɜ tˈe4 lˈaː2m tʃˌɔ bɹˈand tʃˈəː4 nˌen nˈo4j bˈə6t0 , zˈe5 ɲˈə6n zˈiɛ6n vˌaː2 fˈaːɜt0 tʃˈiɛ4n . |0 +dataset/Xanh24h/speaker_0/2151.wav|vˌəːɜj ɲˌy5ŋ tˈoŋ t0ˈin tʃˈen mˌaː2 t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ tʃˈiə sˈɛ4 , hˈi vˈɔ6ŋ kˌaːɜc bˈaː6n sˈiɲ vˈiɛn sˌɛ5 t0ˈi2m ɗˌyə6c mˈo6t0 kˈoŋ vˈiɛ6c fˈu2 hˈəː6p ɗˌe4 kˈiɛɜm tˈem tˈu ɲˈə6p ɲˈɛɜ . |0 +dataset/Xanh24h/speaker_0/2155.wav|xˌi kˈɔɜ zˈəɜw hˈiɛ6w tʃˈen tˌi2 kˈə2n tʃˌɔ hˈyəw ˈan kˌaːɜc lwˈaː6j tˈyɜc ˈan kˈɔɜ vˈi6 tʃˈaːɜt0 ɲˌy tʃˈuəɜj sˈe-ɲ , lˈaːɜ ˈo4j ɗˌe4 tʃˈyə5 bˈe6ɲ . |0 +dataset/Xanh24h/speaker_0/2160.wav|kˈiɲ zwˈe-ɲ ɗˈo2 tʃˈəːj tʃˈɛ4 ˈɛm lˌaː2 mˈo6t0 ŋˈe-2ɲ kˈɔɜ t0ˈiɛ2m nˈaŋ lˈəːɜn , t0wˈi ɲˈiɛn kˈu5ŋ ɗˈo2ŋ tˈəː2j mˈaːŋ tˈɛw ɲˈiɛ2w zˈu4j zˈɔ , kˈə2n ɲˈaː2 bˈaːɜn hˈaː2ŋ tʃˈuɜ ˈiɜ . |0 +dataset/Xanh24h/speaker_0/2172.wav|ɲˌy5ŋ ŋˈyə2j tˈəː6 lˈaː2m bˈe-ɜɲ xˈɛɜw lˈɛɜw ɗˌaː5 bˈiɛɜn ɲˌy5ŋ tʃˈiɛɜc bˈe-ɜɲ ŋˈɔ6t0 tʃˈəː4 tˈe-2ɲ ɲˌy5ŋ t0ˈaːɜc fˈə4m ŋˈe6 twˈə6t0 tˈy6c tˈu6 , xˈiɛɜn ŋˈyə2j tˈyə4ŋ tˈyɜc xˌoŋ xˈɔ4j mˈe ɗˈaɜm . |0 +dataset/Xanh24h/speaker_0/2173.wav|tʃˈɔŋ vˈɪdɪəʊ nˈa2j , tʃˈuɜŋ t0ˈaː sˌɛ5 xˈaːɜm fˈaːɜ sˈaɜw bˈiɜ kwˈiɛɜt0 kwˈaːn tʃˈɔ6ŋ ɗˌe4 mˈəː4 kˈyə4 hˈaː2ŋ kˈiɲ zwˈe-ɲ ɗˈo2 tʃˈəːj tʃˈɛ4 ˈɛm mˈo6t0 kˈe-ɜc tˈe-2ɲ kˈoŋ . |0 +dataset/Xanh24h/speaker_0/2176.wav|tˈɛw tʃˈiə sˈɛ4 kˌuə4 mˈo6t0 tʃˈu4 kwˈaːɜn nˈɛɜt0 kˈɔɜ kˈiɲ ŋˈiɛ6m t0ˈiɛɜt0 lˈo6 vˌəːɜj tʃˈuɜŋ t0ˈoj , tʃˈuŋ bˈi2ɲ mˈo6t0 ŋˈa2j , t0ˈiɛ6m tʃˈa6j t0ˈoɜj ɗˈaː mˈyə2j t0ˈiɛɜŋ , mˌo5j zˈəː2 tʃˈəːj bˈaː ŋˈi2n ɗˈo2ŋ . |0 +dataset/Xanh24h/speaker_0/2179.wav|ɗˌe4 kˈɔɜ tˈem ɗˈo2ŋ ɗˈo6j , ˈe-ɲ kwˈən zˈu4 tˈem ŋˈyə2j ˈɛm tʃˈaːj vˈe2 kwˈe kˈu2ŋ ɲˈaw xˈəː4j ŋˈiɛ6p vˌəːɜj hˈi vˈɔ6ŋ sˌɛ5 twˈə6n lˈəː6j kˈiɛɜm tˈem tˈu ɲˈə6p lˈɔ tʃˌɔ zˈaː ɗˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/2181.wav|tʃˈɔŋ ɲˌy5ŋ nˈam kwˈaː , nˈeɜn tˈəːm ɗˌyə6c zˈəɜt0 ɲˈiɛ2w tˈyəŋ hˈiɛ6w spˈaː vˌaː2 mˈasɑːʒ sˈy4 zˈu6ŋ ɗˌe4 t0ˈaː6w hˈiɛ6w ˈyɜŋ ɲˈɛ6 ɲˈaː2ŋ vˌaː2 tˈy tˈaːɜj . |0 +dataset/Xanh24h/speaker_0/2184.wav|nˌeɜw mˈuəɜn bˈaɜt0 ɗˈə2w vˌəːɜj kˈoŋ vˈiɛ6c vˈiɛɜt0 kˈɒntɛnt , bˈaː6n kˈɔɜ tˈe4 sˈɛm bˈaː4n tˈən mˈi2ɲ tˈiɜc tˈe4 lwˈaː6j nˈaː2w tˌi2 hˈa5j lˈyə6 tʃˈɔ6n tʃˌɔ fˈu2 hˈəː6p . |0 +dataset/Xanh24h/speaker_0/2188.wav|ɗˈiɛ2w nˈa2j zˈuɜp tʃˌɔ kˌaːɜc tʃˈu4 kˈyə4 hˈaː2ŋ kˈɔɜ tˈe4 zˈe5 zˈaː2ŋ lˈyə6 tʃˈɔ6n mˈa6t0 hˈaː2ŋ kˈiɲ zwˈe-ɲ fˈu2 hˈəː6p vˌəːɜj ɲˈu kˈə2w vˌaː2 xˈaː4 nˈaŋ kˌuə4 mˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/2190.wav|nˈam ɗˈə2w t0ˈiɛn , zˈɔ mˈəːɜj hˈi2ɲ tˈe-2ɲ mˈo hˈi2ɲ nˌen ŋˈuə2n t0ˈiɛ2n tˈu ɗˌyə6c , ˈe-ɲ zˈe-2ɲ ɗˌe4 tʃˈaː4 lˈaː6j ŋˈən hˈaː2ŋ , ɗˈə2w t0ˈy kˈəː sˈəː4 vˈə6t0 tʃˈəɜt0 tˈem vˈaː2w tʃˈaːŋ tʃˈaː6j . |0 +dataset/Xanh24h/speaker_0/2196.wav|ŋwˈaː2j zˈaː , vˈiɛ6c t0ˈa6ŋ sˈe-ɜc tʃˌɔ hˈɔ6k sˈiɲ kˈɔɜ hwˈaː2n kˈe-4ɲ xˈɔɜ xˈan xˌoŋ tʃˈi4 lˌaː2 hˈe-2ɲ ɗˈo6ŋ kˈɔɜ ˈiɜ ŋˈiə5 mˌaː2 kˌɔ2n lˌaː2 mˈo6t0 kˈe-ɜc t0wˈiɛ6t0 vˈəː2j ɗˌe4 kwˈaː4ŋ kˈaːɜw tˈyəŋ hˈiɛ6w . |0 +dataset/Xanh24h/speaker_0/2199.wav|bˈa2ŋ kˈe-ɜc nˈa2j , bˈaː6n kˈɔɜ tˈe4 t0ˈaː6w zˈaː mˈo6t0 tˈyəŋ hˈiɛ6w bˈe-ɜɲ ŋˈɔ6t0 xˌoŋ tʃˈi4 ŋˈɔn mˈiɛ6ŋ mˌaː2 kˌɔ2n ɗˈaːɜp ˈyɜŋ ɗˌyə6c ɲˈu kˈə2w ŋˈaj kˈaː2ŋ kˈaːw kˌuə4 tˈi6 tʃˈyə2ŋ vˈe2 sˈy6 lˈe-2ɲ mˈe-6ɲ vˌaː2 tʃˈam sˈɔɜk sˈyɜc xwˈɛ4 . |0 +dataset/Xanh24h/speaker_0/2202.wav|zˈɔ ɗˈɔɜ , nˌeɜw bˈaː6n mˈuəɜn kˈiɲ zwˈe-ɲ ɗˈo2 sˈaːɜt0 zˈu6ŋ tʃˈen tˈɪk tˈɒk , hˈa5j tʃˈuɜ ˈiɜ lˈyə6 tʃˈɔ6n ɲˌy5ŋ mˈa6t0 hˈaː2ŋ fˈu2 hˈəː6p vˌəːɜj tˈi6 hˈiɛɜw kˌuə4 ɲˈɔɜm ɗˈoɜj t0ˈyə6ŋ nˈa2j . |0 +dataset/Xanh24h/speaker_0/2204.wav|mˈo hˈi2ɲ nˈa2j ɗˌaː5 zˈaː4j kwˈiɛɜt0 vˈiɛ6c lˈaː2m tʃˌɔ mˈo6t0 tʃˈam tʃˈen mˈo6t0 tʃˈam nˈam mˈyəj bˈaː hˈo6 zˈaː ɗˈi2ɲ tʃˈɔŋ sˈɔɜm nˈaːm mˈɔn , nˈəŋ t0ˈo4ŋ sˈoɜ hˈo6 zˈaː ɗˈi2ɲ xˈaːɜ zˈaː4 . |0 +dataset/Xanh24h/speaker_0/2210.wav|ŋˈyə2j t0ˈiɛw zˈu2ŋ kˈɔɜ tˈe4 zˈe5 zˈaː2ŋ t0ˈiɛɜp sˈuɜc vˌəːɜj kˌaːɜc tˈyəŋ hˈiɛ6w mˌaː2 hˈɔ6 tʃˌyə t0ˈy2ŋ bˈiɛɜt0 ɗˌeɜn vˌaː2 kˈɔɜ tˈe4 tʃˈaː4j ŋˈiɛ6m tˈy4 kˌaːɜc sˈaː4n fˈə4m mˈəːɜj . |0 +dataset/Xanh24h/speaker_0/2211.wav|vˈiɛ6c lˈɔ6k nˈyəɜc bˈiɛ4n tˈe-2ɲ nˈyəɜc ŋˈɔ6t0 ɗˌe4 t0ˈyəɜj kˈəɪ vˌaː2 sˈy4 zˈu6ŋ sˈiɲ hwˈaː6t0 lˌaː2 mˈo6t0 kˈi2 kˈoŋ kˌuə4 kˌaːɜc kˈuəɜc zˈaː tʃˈuŋ ɗˈoŋ , vˌaː2 kˈatɑː xˌoŋ fˌaː4j lˌaː2 ŋwˈaː6j lˈe6 . |0 +dataset/Xanh24h/speaker_0/2214.wav|kˈɔɜ mˈo6t0 sˈoɜ bˈaː2 kˌɔn tʃˈiə sˈɛ4 zˈa2ŋ tʃˈɛw tʃˈɛw ɗˈɛ4 hˈaːj nˈam ɗˌyə6c nˈam lˈyəɜ , vˌəːɜj mˈo6t0 kˌɔn ɗˈy6c kˈɔɜ tˈe4 ɣˈɛɜp tʃˌɔ bˈoɜn ɗˌeɜn bˈa4j kˌɔn kˌaːɜj . |0 +dataset/Xanh24h/speaker_0/2220.wav|ŋˈuə2n nˈyəɜc ˈuəɜŋ kˈɔɜ tˈe4 kˈuŋ kˈəɜp tʃˈɔŋ ˈo tʃˈuə2ŋ bˈa2ŋ sˈo , tʃˈə6w , ɣˈaɜn tʃˈa6t0 vˈaː2w vˈe-ɜc , hwˌa6c kˈɔɜ tˈe4 zˈu2ŋ tʃˈum ɗˈy6ŋ nˈyəɜc ɗˌe4 ˈəː4 sˈən vˈə6n ɗˈo6ŋ tʃˌɔ zˈe ˈuəɜŋ . |0 +dataset/Xanh24h/speaker_0/2225.wav|t0wˈi ɲˈiɛn , bˈaː6n kˈə2n tʃˈuɜ ˈiɜ ɗˌeɜn mˈa6t0 kˈe-6ɲ tʃˈe-ɲ vˌaː2 xˈaː4 nˈaŋ kwˈaː4ŋ kˈaːɜw , mˈɑːkɪtɪŋ ɗˈa6c bˈiɛ6t0 ɗˌe4 t0ˈoɜj ˈiw hwˈaːɜ xˈaː4 nˈaŋ kˈiɲ zwˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/2242.wav|tʃˈɔŋ xˈu tʃˈuə2ŋ nˈuəj , bˈaː2 kˌɔn kˈə2n tʃˈiə tˈe-2ɲ ˈo tʃˈuə2ŋ ɲˈɔ4 vˌəːɜj zˈiɛ6n t0ˈiɜc t0ˌy2 mˈyə2j ɗˌeɜn hˈaːj mˈyəj mˈɛɜt0 vˈuəŋ , tˈyə2ŋ lˌaː2 vˈe-ɜc ŋˈan ɗˌyə6c sˈəɪ bˈa2ŋ ɣˈe-6c hwˌa6c kˈaɜt0 tˈe-2ɲ ɣˈo5 kˈɛɜp lˈaː6j . |0 diff --git a/val_list.txt b/val_list.txt new file mode 100644 index 0000000000000000000000000000000000000000..d6f6c4058654f66fc650902c932336940481b809 --- /dev/null +++ b/val_list.txt @@ -0,0 +1,68 @@ +dataset/Xanh24h/speaker_0/3000.wav|tʃˈuə2ŋ tʃˈaː6j tʃˌɔ ɣˈaː2 kˈi2 lˈən bˈaːw ɣˈo2m kˌaːɜc xˈu vˈy6c sˈaw . |0 +dataset/Xanh24h/speaker_0/3001.wav|ɗˈo2ŋ tˈəː2j , tʃˈuɜŋ kˈu5ŋ lˌaː2 tˈy6c fˈə4m xˌoŋ bˌi6 lˈə5n kˌaːɜc t0ˈaː6p tʃˈəɜt0 ɲˌy kˈim lwˈaː6j , twˈi4 t0ˈiɲ , kˌaːɜc vˈə6t0 kˈyɜŋ xˈaːɜc . |0 +dataset/Xanh24h/speaker_0/3002.wav|ɗˈo2ŋ tˈəː2j , mˈuə sˈaɜm tʃˈy6c t0wˈiɛɜn kˌɔ2n lwˈaː6j bˈɔ4 ɲˈu kˈə2w zˈi tʃwˈiɛ4n ɗˌeɜn kˈyə4 hˈaː2ŋ vˈə6t0 lˈiɜ , zˈuɜp t0ˈiɛɜt0 kˈiɛ6m tˈəː2j zˈaːn vˌaː2 t0ˈiɛ2n bˈaː6c . |0 +dataset/Xanh24h/speaker_0/3003.wav|kˈɔɜ hˈaːj mˈo hˈi2ɲ vˈyə2n ˈyəm ɗˌyə6c ɲˈiɛ2w ŋˈyə2j lˈyə6 tʃˈɔ6n xˌi xˈəː4j ŋˈiɛ6p lˌaː2 vˈyə2n ˈyəm kˈoɜ ɗˈi6ɲ vˌaː2 vˈyə2n ˈyəm t0ˈaː6m tˈəː2j . |0 +dataset/Xanh24h/speaker_0/3004.wav|hˈɔ6k vˈiɛn kˈɔɜ tˈe4 hˈɔ6k mˌɔ6j lˌuɜc mˌɔ6j nˈəːj , xˌoŋ kˈə2n fˌaː4j ɗˌeɜn lˈəːɜp hˈɔ6k tʃˈy6c t0ˈiɛɜp . |0 +dataset/Xanh24h/speaker_0/3005.wav|xˌi lˈyə6 tʃˈɔ6n mˈa6t0 hˈaː2ŋ kwˈaː4 bˈiɛɜw t0ˈeɜt0 , kˈə2n lˈiw ˈiɜ mˈo6t0 sˈoɜ vˈəɜn ɗˈe2 sˈaw . |0 +dataset/Xanh24h/speaker_0/3006.wav|vˈəɪ6 nˌen , ɲˌy5ŋ ŋˈyə2j kˈɔɜ tˈu ɲˈə6p ˈəː4 mˈyɜc tʃˈuŋ bˈi2ɲ xˈaːɜ kˈu5ŋ sˈa5n sˈaː2ŋ bˈɔ4 zˈaː mˈo6t0 xwˈaː4n t0ˈiɛ2n ɗˌe4 tʃˈi tʃˈaː4 tʃˌɔ kˌaːɜc lwˈaː6j tˈy6c fˈə4m tʃˈyɜc nˈaŋ hˈo5 tʃˈəː6 sˈyɜc xwˈɛ4 tʃˌɔ kˈəː tˈe4 . |0 +dataset/Xanh24h/speaker_0/3007.wav|tʃˈɔŋ tʃˈyə2ŋ hˈəː6p tʃˈɔ6n bˈe-ɜɲ zˈaːɜn mˈa6n , hˈa5j ɗˈaː4m bˈaː4w tʃwˈə4n bˌi6 nˈyəɜc tʃˈəɜm ŋˈɔn mˈiɛ6ŋ . |0 +dataset/Xanh24h/speaker_0/3008.wav|mˈa6c zˌu2 t0ˈen ɣˈɔ6j kˌuə4 nˈɔɜ lˌaː2 bˈe-ɜɲ ɲˈaː5n , ɲˌyŋ tˈy6c t0ˈeɜ xˌoŋ sˈy4 zˈu6ŋ ɲˈaː5n t0ˈyəj lˈaː2m ŋwˈiɛn lˈiɛ6w tʃˈiɜɲ . |0 +dataset/Xanh24h/speaker_0/3009.wav|zˈyəɜj zˈoɜŋ kˈə2n kˈɔɜ tˈən hˈi2ɲ kˈən ɗˈoɜj , lˈo2ŋ mˈyə6t0 , mˈaɜt0 sˈaːɜŋ , mˈu5j sˈe-6c , xˌoŋ bˌi6 tˈyəŋ t0ˈiɜc . |0 +dataset/Xanh24h/speaker_0/3010.wav|bˈe-ɜɲ ŋˈɔ6t0 sˈyɜc xwˈɛ4 vˌaː2 tʃˈeɜ bˈiɛɜn lˈe-2ɲ mˈe-6ɲ . |0 +dataset/Xanh24h/speaker_0/3011.wav|kˈiɲ zwˈe-ɲ kwˈə2n ˈaːɜw sˈɛkənd hˈand ɗˌaːŋ lˌaː2 mˈo6t0 sˈu hˈyəɜŋ ɗˌyə6c ɲˈiɛ2w ŋˈyə2j lˈyə6 tʃˈɔ6n bˌəː4j vˈoɜn ɗˈə2w t0ˈy bˈaːn ɗˈə2w xˌoŋ kwˈaːɜ lˈəːɜn , mˈa6t0 hˈaː2ŋ ɗˈaː zˈaː6ŋ vˌaː2 kˈɔɜ ɲˈiɛ2w t0ˈiɛ2m nˈaŋ fˈaːɜt0 tʃˈiɛ4n . |0 +dataset/Xanh24h/speaker_0/3012.wav|ˈəː4 nˈyəɜc t0ˈaː tˌi2 kˈɔɜ zˈəɜt0 ɲˈiɛ2w zˈoɜŋ ɣˈaː2 ɲˌyŋ ɗˌe4 tʃˈan nˈuəj ɣˈaː2 tˈaː4 vˈyə2n tˈɛw hˈyəɜŋ ˈaːn t0wˈaː2n sˈiɲ hˈɔ6k bˈa2ŋ vˈiɛ6c nˈuəj ɣˈaː2 tˈaː4w zˈyə6c tˌi2 tʃˈuɜŋ t0ˈaː lˈyə6 tʃˈɔ6n zˈoɜŋ ɣˈaː2 zˈi . |0 +dataset/Xanh24h/speaker_0/3013.wav|ŋwˈaː2j tʃˈi fˈiɜ twˈe mˈa6t0 bˈa2ŋ vˌaː2 ɲˈə6p hˈaː2ŋ , bˈaː6n kˈu5ŋ kˈə2n ɗˈə2w t0ˈy vˈaː2w kˌaːɜc tˈiɛɜt0 bˌi6 kˈə2n tˈiɛɜt0 , ɗˌe4 kˈiɲ zwˈe-ɲ kwˈə2n ˈaːɜw tʃˈɛ4 ˈɛm . |0 +dataset/Xanh24h/speaker_0/3014.wav|ˈoŋ ɗwˈaː2n tˈe-ɲ t0ˈu2ŋ , ˈəɜp mˈyə2j t0ˈaːɜm , sˈaː5 fˈɔŋ tˈe-6ɲ ˈaː , tˈi6 sˈaː5 zˈaːɜ zˈaːj tʃˈiə sˈɛ4 , vˈaː2w xwˌaː4ŋ nˈam hˈaːj ŋˈi2n mˈyə2j bˈaː ɗˌeɜn nˈam hˈaːj ŋˈi2n mˈyə2j lˈam , tʃˈyə2ŋ ɗˈaː6j hˈɔ6k kˈə2n tˈəː kˈɔɜ hˈo5 tʃˈəː6 tˈy6c hˈiɛ6n zˈy6 ˈaːɜn mˈo hˈi2ɲ lˈuəɜ t0ˈom tʃˈɔŋ ˈo ɗˈe2 bˈaː2w xˈɛɜp kˈiɜn ˈəː4 tˈi6 sˈaː5 zˈaːɜ zˈaːj . |0 +dataset/Xanh24h/speaker_0/3015.wav|ɗˌe4 tˈy6c hˈiɛ6n ɗˈiɛ2w nˈa2j , tʃˈu4 kˈyə4 hˈaː2ŋ nˌen ɗˈə2w t0ˈy vˈaː2w vˈiɛ6c t0ˈaː6w zˈaː mˈo6t0 tʃˈaːŋ wˈɛb tʃˌɔ kˈyə4 hˈaː2ŋ , tˈiɛɜt0 lˈə6p zˈaːn hˈaː2ŋ tʃˈen kˌaːɜc nˈe2n t0ˈaː4ŋ tˈyəŋ mˈaː6j ɗˈiɛ6n t0ˈy4 ɲˌy ʃˈəʊpiː , lazˈɑːdə , tˈɪk tˈɒk hwˌa6c sˈy4 zˈu6ŋ kˌaːɜc mˈaː6ŋ sˈaː5 hˈo6j ɲˌy fˈeɪsbʊk , ˈɪnstɐɡɹˌam , zˈɑːləʊ . |0 +dataset/Xanh24h/speaker_0/3016.wav|kˈɔɜ tˈe4 bˈaː6n kˈə2n bˈaɜt0 tʃˈa6j lˈen ɲˈaː2 kˈiɜɲ zˈuɜp ŋˈan kˈɔ4 zˈaː6j tʃˌɔ kˈəɪ tʃˈo2ŋ tʃˈɔŋ ɲˈaː2 kˈiɜɲ hwˌa6c ɲˈaː2 zˈyə lˈyəɜj kˌuə4 bˈaː6n . |0 +dataset/Xanh24h/speaker_0/3018.wav|nˈam hˈaːj ŋˈi2n mˈyə2j bˈoɜn , ˈe-ɲ kwˈiɛɜt0 t0ˈəm tˈɛw ɗˈuə4j nˈiɛ2m ɗˈaːm mˈe kˈiɲ zwˈe-ɲ tˈe4 tˈaːw . |0 +dataset/Xanh24h/speaker_0/3019.wav|vˈəɪ6 kˌaːɜc bˈaː6n kˈɔɜ tˈaɜc mˈaɜc , tˈy6c sˈy6 ɲˈaː2 lˈe-5ɲ ɗˈaː6w hˈɔ6 kˈim zˈa2w kˈɔɜ t0ˌəːɜj mˈyɜc nˈaː2w ? |0 +dataset/Xanh24h/speaker_0/3020.wav|tʃwˈiɛn zˈaː tʃˈuɜŋ t0ˈoj sˌɛ5 lˈiɛn hˈe6 vˌaː2 zˈaː4j ɗˈaːɜp tˈaɜc mˈaɜc . |0 +dataset/Xanh24h/speaker_0/3022.wav|ŋwˈaː2j fˈaːɜt0 tʃˈiɛ4n kˈiɲ t0ˈeɜ , zˈaː ɗˈi2ɲ ˈoŋ fˈu2ŋ swˈən hwˈaː6t0 lˈuən ɣˈə2n mˈə5w tʃˈɔŋ vˈiɛ6c tˈy6c hˈiɛ6n tʃˈu4 tʃˈyəŋ kˌuə4 ɗˈaː4ŋ , tʃˈiɜɲ sˈe-ɜc , fˈaːɜp lwˈə6t0 kˌuə4 ɲˈaː2 nˈyəɜc vˌaː2 kˌaːɜc kwˈi ɗˈi6ɲ kˌuə4 ɗˈiə6 fˈyəŋ . |0 +dataset/Xanh24h/speaker_0/3023.wav|t0wˈi ɲˈiɛn , tʃˈɔŋ tˈi6 tʃˈyə2ŋ kˈe-6ɲ tʃˈe-ɲ , ɗˌe4 tˈe-2ɲ kˈoŋ bˈaː6n kˈə2n fˌaː4j kˈɔɜ bˈiɜ kwˈiɛɜt0 kˈiɲ zwˈe-ɲ zˈiɛŋ kˌuə4 mˈi2ɲ . |0 +dataset/Xanh24h/speaker_0/3024.wav|kˈo6ŋ vˌəːɜj t0ˈy zwˈi tʃˈiɛɜn lˈyə6c vˌaː2 sˈy6 tʃˈaː4j ŋˈiɛ6m , ˈe-ɲ ɗˌaː5 tˈe-2ɲ kˈoŋ vˌaː2 ɗˌyə6c ɲˈiɛ2w xˈe-ɜc hˈaː2ŋ ɗˈɔɜn ɲˈə6n , vˌaː2 kˈɔɜ ɗˌyə6c tˈe-2ɲ kˈoŋ sˈyɜŋ ɗˈaːɜŋ . |0 +dataset/Xanh24h/speaker_0/3025.wav|tˈyɜ hˈaːj , ɲˈu kˈə2w t0ˈiɛw tˈu6 sˈiɛn kwˈɛ nˈyəɜŋ zˈəɜt0 lˈəːɜn , ɗˈa6c bˈiɛ6t0 lˌaː2 tʃˈɔŋ kˌaːɜc xˈu vˈy6c ɗˈoŋ zˈən kˈy ɣˈə2n tʃˈyə2ŋ hˈɔ6k , xˈu kˈoŋ ŋˈiɛ6p . |0 +dataset/Xanh24h/speaker_0/3026.wav|bˈaː6n kˈɔɜ tˈe4 bˈaːɜn hwˈaː xˈo tʃˈy6c t0ˈiɛɜp tʃˌɔ xˈe-ɜc hˈaː2ŋ hwˌa6c bˈaːɜn bˈuən tʃˌɔ kˌaːɜc ɲˈaː2 bˈaːɜn lˈɛ4 . |0 +dataset/Xanh24h/speaker_0/3027.wav|kˈɔɜ ɲˌy vˈəɪ6 tˌi2 tʃˈɛw tʃˈɛw mˈəːɜj hˈaː6n tʃˈeɜ ɗˌyə6c bˈe6ɲ t0ˈə6t0 vˌaː2 sˈiɲ tʃˈyə4ŋ xwˈɛ4 mˈe-6ɲ . |0 +dataset/Xanh24h/speaker_0/3028.wav|nˌeɜw lˌaː2 zˈɔ2ŋ kˈaːɜ ɲˈə6p xˈə4w tˌi2 zˈaːɜ tˈe-2ɲ zˈəɜt0 ɗˈaɜt0 ɗˈɔ4 , xˌoŋ fˌaː4j ˈaːj kˈu5ŋ kˈɔɜ ɗˈiɛ2w kˈiɛ6n mˈuə . |0 +dataset/Xanh24h/speaker_0/3029.wav|lˈaɜp ɗˈa6t0 hˈe6 tˈoɜŋ ɗˈiɛ6n , nˈyəɜc , tˈoɜŋ zˈɔɜ , twˈaːɜt0 nˈyəɜc . |0 +dataset/Xanh24h/speaker_0/3032.wav|bˈaː6n kˈɔɜ tˈe4 kˈiɲ zwˈe-ɲ kˌaːɜc sˈaː4n fˈə4m mˈəːɜj zˈaː mˈaɜt0 , sˈaː4n fˈə4m lˈiɛn kwˈaːn ɗˌeɜn kˌaːɜc zˈy6 kˈiɛ6n nˈo4j bˈə6t0 . |0 +dataset/Xanh24h/speaker_0/3033.wav|vˌəːɜj lˈyə6ŋ ŋˈyə2j zˈu2ŋ ɗˈoŋ ɗˈaː4w vˌaː2 ɗˈaː zˈaː6ŋ , tˈɪk tˈɒk lˌaː2 mˈo6t0 kˈeɲ t0ˈiɛɜp tˈi6 hˈiɛ6w kwˈaː4 ɗˌe4 t0ˈiɛɜp kˈə6n vˌəːɜj ɗˈoŋ ɗˈaː4w xˈe-ɜc hˈaː2ŋ t0ˈiɛ2m nˈaŋ . |0 +dataset/Xanh24h/speaker_0/3035.wav|ɗˈaː2w tˈeɜ kˈɔɜ tˈe4 kˈɔɜ zˈaːɜŋ tʃˈy6c , zˈaːɜŋ hwˈe-2ɲ , zˈaːɜŋ t0ˈaːm ɗˈaː , zˈaːɜŋ hˈaː6c mˈaːj . |0 +dataset/Xanh24h/speaker_0/3036.wav|tˈɛw t0ˈəː2 ʒˈɔŋˈaːn ˈɪnbəʊ kˌuə4 hˈaː2n kˈuəɜc tʃˌɔ bˈiɛɜt0 , tʃˈɔŋ sˈoɜ kˌaːɜc mˈa6t0 hˈaː2ŋ sˈaː sˈi4 mˌaː2 tʃˈiɛ2w t0ˈiɛn mˈuə , tˈiɛɜt0 bˌi6 ɗˈiɛ6n t0ˈy4 ɗˈyɜŋ ɗˈə2w vˌaː2 tʃˈiɛɜm t0ˌəːɜj bˈoɜn mˈyəj tʃˈiɜn fˈə2n tʃˈam lˈyə6ŋ t0ˈiɛw tˈu6 hˈaː2ŋ sˈaː sˈi4 kˌuə4 kˈim ʒˈɔŋˈun . |0 +dataset/Xanh24h/speaker_0/3037.wav|tˈəː2j zˈaːn sˈaw ɗˈɔɜ , ˈe-ɲ lˈaː2m tˈem ɲˈiɛ2w ŋˈe2 xˈaːɜc ɲˈaw ɲˌy fˈu6c vˈu6 , lˈe5 t0ˈən , bˈoɜk vˈaːɜc ɗˌe4 lˈəɪɜ vˈoɜn mˈuə tˈem hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/3038.wav|tˈəː2j ɗˈiɛ4m tˈu hwˈe-6c lˌaː2 xˌi tʃˈaː6c tˈyɜ hˈaːj vˈyə2 ɲˈuɜ lˈen . |0 +dataset/Xanh24h/speaker_0/3039.wav|bˈaː6n kˈɔɜ tˈe4 bˈaːɜn ɗˈo2 tʃˈaːŋ tʃˈiɜ t0ˈeɜt0 ŋwˈiɛn ɗˈaːɜn hˈandmeɪd tʃˈy6c t0ˈiɛɜp tʃˌɔ ŋˈyə2j t0ˈiɛw zˈu2ŋ hwˌa6c tˈoŋ kwˈaː kˌaːɜc ɲˈaː2 bˈaːɜn lˈɛ4 . |0 +dataset/Xanh24h/speaker_0/3041.wav|tʃˈɔŋ t0ˈi2ɲ hˈi2ɲ tˈi6 tʃˈyə2ŋ hˈiɛ6n nˈaj , tˈy6c fˈə4m vˌə5n lˌaː2 ŋˈe-2ɲ hˈaː2ŋ ɗˈyɜŋ ɗˈə2w vˈe2 lˈəː6j ɲwˈə6n tʃˌɔ ɲˌy5ŋ ɲˈaː2 ɗˈə2w t0ˈy tˈoŋ tˈaːɜj . |0 +dataset/Xanh24h/speaker_0/3042.wav|tˈyɜc ˈan kˌuə4 tʃˈuɜŋ bˈaːw ɣˈo2m tˈɔɜk vˌaː2 kˌaːɜc lwˈaː6j zˈaw . |0 +dataset/Xanh24h/speaker_0/3043.wav|lwˈaː2j tʃˈɛw tʃˈɛw kˈɔɜ kˈiɜc tˈyəɜc xˈaːɜ xˈiɛm t0ˈoɜn , vˌəːɜj tʃˈiɛ2w zˈaː2j tˈən ɗˌeɜn ɗˈə2w lˌaː2 bˈoɜn mˈyəj hˈaːj ɗˌeɜn bˈoɜn mˈyəj t0ˈaːɜm sˈaŋt0ˈimˈɛɜt0 , tʃˈɔŋ xˌi tʃˈɔ6ŋ lˈyə6ŋ kˌuə4 tʃˈuɜŋ tʃˈi4 t0ˌy2 xˌoŋ fˈəɪ4 bˈa4j ɗˌeɜn hˈaːj kˈilˈoɣˈaːm , lˈoŋ tʃˈen tˈən kˈɔɜ mˈa2w nˈə1w vˌaː2 zˈyəɜj bˈu6ŋ kˈɔɜ mˈa2w tʃˈaɜŋ hwˌa6c vˈaː2ŋ ɲˈaː6t0 . |0 +dataset/Xanh24h/speaker_0/3044.wav|kˌaːɜc bˈyəɜc tˈy6c hˈiɛ6n mˈo6t0 . ŋˈiɛn kˈiɜw tˈi6 tʃˈyə2ŋ . |0 +dataset/Xanh24h/speaker_0/3046.wav|ɗˈiɛ2w kwˈaːn tʃˈɔ6ŋ lˌaː2 fˌaː4j tʃˈɔ6n kˈaːɜ kˈɔɜ tˈi6t0 sˈan tʃˈaɜc . |0 +dataset/Xanh24h/speaker_0/3047.wav|kˌaːɜc mˈa6t0 hˈaː2ŋ ˈəː4 ɗˈəɪ ɗˌyə6c tʃˈɔ6n lˈɔ6k bˌəː4j ɲˌy5ŋ ŋˈyə2j kˈiɲ zwˈe-ɲ kˈɔɜ kˈiɲ ŋˈiɛ6m , ɗˈaː4m bˈaː4w tʃˈəɜt0 lˈyə6ŋ vˌaː2 ɗˈaː zˈaː6ŋ vˈe2 mˈə5w mˈaː5 . |0 +dataset/Xanh24h/speaker_0/3048.wav|t0ˈiɛɜp tˈi6 kwˈaː ˈiːmeɪl lˌaː2 mˈo6t0 kˈe-ɜc hˈiɛ6w kwˈaː4 ɗˌe4 t0ˈiɛɜp kˈə6n xˈe-ɜc hˈaː2ŋ ɗˌaː5 ɗˈaŋ kˈiɜ ɲˈə6n tˈoŋ t0ˈin t0ˌy2 bˈaː6n . |0 +dataset/Xanh24h/speaker_0/3049.wav|zˈaː ɗˈi2ɲ ˈe-ɲ ɗˌaː5 tˈiɛɜt0 lˈə6p mˈo6t0 tʃˈaːŋ tʃˈaː6j nˈuəj tˈɔ4 tˈyəŋ fˈə4m . |0 +dataset/Xanh24h/speaker_0/3050.wav|vˈe2 sˈaw , mˈɔɜn ˈan ɗˌyə6c mˌɔ6j ŋˈyə2j xˈɛn ŋˈɔn , ɲˈiɛ2w ŋˈyə2j ɲˈə6n sˈɛɜt0 fˈu2 hˈəː6p vˌəːɜj sˈu hˈyəɜŋ tˈy6c fˈə4m zˈyə5 mˈuə2 zˈi6c . |0 +dataset/Xanh24h/speaker_0/3051.wav|tˈiɛɜt0 kˈeɜ vˌaː2 tʃˈaːŋ tʃˈiɜ nˈo6j tˈəɜt0 tʃˌɔ kˈyə4 hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/3052.wav|hˈɔ6 ˈyə tʃˈuə6ŋ ɲˌy5ŋ lwˈaː6j hˈaː4j sˈaː4n nˈaː2w vˌaː2 mˈyɜc zˈaːɜ mˌaː2 hˈɔ6 sˈa5n lˈɔ2ŋ tʃˈi tʃˈaː4 lˌaː2 bˈaːw ɲˈiɛw . |0 +dataset/Xanh24h/speaker_0/3053.wav|tˈi6t0 ɣˈaː2 kˈi2 lˈən kˈɔɜ zˈaːɜ tʃˈi6 kˈaːw , ɗˌyə6c ɲˈiɛ2w ŋˈyə2j ˈyə tʃˈuə6ŋ . |0 +dataset/Xanh24h/speaker_0/3054.wav|vˌaː2 vˈu6 tˈu t0ˌy2 tˈaːɜŋ bˈa4j ɗˌeɜn tˈaːɜŋ tʃˈiɜn . |0 +dataset/Xanh24h/speaker_0/3055.wav|ɗˈəɪ kˈu5ŋ lˌaː2 t0ˈiɛ2n ɗˈe2 tˈuɜc ɗˈəɪ4 ɲˈiɛ2w ŋˈyə2j tʃˈɔ6n , ɲˌy lˌaː2 mˈo6t0 kˈoŋ vˈiɛ6c bˈaːɜn hˈaː2ŋ ŋˈaɜn hˈaː6n ɗˌe4 kˈiɛɜm tˈem tˈu ɲˈə6p . |0 +dataset/Xanh24h/speaker_0/3056.wav|bˈaː6n nˌen lˈyə6 tʃˈɔ6n ŋwˈiɛn lˈiɛ6w tʃˈəɜt0 lˈyə6ŋ , ɗˈaː zˈaː6ŋ , ɗˈaː4m bˈaː4w vˈe6 sˈiɲ ˈaːn t0wˈaː2n tˈy6c fˈə4m ɗˌe4 t0ˈaː6w zˈaː ɲˌy5ŋ sˈaː4n fˈə4m tˈəːm ŋˈɔn , hˈəɜp zˈə5n . |0 +dataset/Xanh24h/speaker_0/3057.wav|bˈen kˈe-6ɲ ɗˈɔɜ , kˌɔ2n t0ˈi2m hˈiɛ4w tˈem ɲˌy5ŋ kˈiɛɜn tˈyɜc vˌaː2 kˈi5 twˈə6t0 tʃˈan nˈuəj tʃˈen sˈe-ɜc bˈaːɜw tˌevˈe . |0 +dataset/Xanh24h/speaker_0/3058.wav|ɗˌeɜn vˌəːɜj vˈɪdɪəʊ nˈa2j , t0ˈaː2j tʃˈiɜɲ kˈiɲ zwˈe-ɲ sˈin ɣˈy4j ɗˌeɜn kˌaːɜc bˈaː6n kˈə1w tʃwˈiɛ6n vˈe2 tʃˈaː2ŋ tʃˈaːj bˈɔ4 ŋˈe2 kˈi5 sˈy kˈiɛɜm t0ˈiɛ2n t0ˈi4 mˌo5j nˈam ɲˈəː2 ŋˈe2 nˈuəj kˈaːɜ kˈe-4ɲ ˈiɜt0 vˈoɜn . |0 +dataset/Xanh24h/speaker_0/3059.wav|ɲˈiɛ2w xˌi sˈyɜc xwˈɛ4 kˈiɛ6t0 kwˈe6 t0ˌəːɜj mˈyɜc ˈe-ɲ fˌaː4j ɲˈə6p vˈiɛ6n , ɗˈiɛ2w tʃˈi6 zˈɔ swˈi ɲˈyə6c , lˈaːw lˈy6c ɗˌeɜn ɗˈo6 tˈo4 hwˈiɛɜt0 . |0 +dataset/Xanh24h/speaker_0/3060.wav|kˈiɲ zwˈe-ɲ ɗˈo2ŋ hˈo2 kˈu5 lˌaː2 mˈo hˈi2ɲ kˈiɲ zwˈe-ɲ ɗˌyə6c ɲˈiɛ2w ŋˈyə2j kwˈaːn t0ˈəm , ɗˈa6c bˈiɛ6t0 lˌaː2 ɲˌy5ŋ ŋˈyə2j ˈiɛw tˈiɜc sˈiw t0ˈə2m ɗˈo2ŋ hˈo2 . |0 +dataset/Xanh24h/speaker_0/3061.wav|lˈyə6ŋ t0ˈom nˈuəj tʃˈɔŋ zˈuə6ŋ lˈuəɜ kˈə2n ɗˌyə6c kˈiɛ4m swˈaːɜt0 tʃˈa6t0 tʃˈɛ5 ɗˌe4 tʃˈe-ɜɲ t0ˈi2ɲ tʃˈaː6ŋ t0ˈom ˈan lˈuəɜ . |0 +dataset/Xanh24h/speaker_0/3062.wav|zˈɔ ɗˈɔɜ , lˈəː6j ɲwˈə6n t0ˌy2 kˈiɲ zwˈe-ɲ kˈə1w ɗˈoɜj , tʃˈe-ɲ ˈe-4ɲ t0ˈeɜt0 tˈyə2ŋ zˈəɜt0 kˈaːw . |0 +dataset/Xanh24h/speaker_0/3063.wav|zˈi6c vˈu6 nˈa2j ɗˈaːɜp ˈyɜŋ ɲˈu kˈə2w kˌuə4 kˌaːɜc zwˈe-ɲ ŋˈiɛ6p , hˈo6 kˈiɲ zwˈe-ɲ mˈuəɜn bˈa2j mˈəm kˈuɜŋ tˈə2n t0ˈaː2j tʃˈuɜ ɗˈaːɜw , tʃwˈə4n , fˈɔŋ t0ˈu6c mˌaː2 xˌoŋ kˈə2n t0ˈoɜn tˈəː2j zˈaːn , kˈoŋ sˈyɜc . |0 +dataset/Xanh24h/speaker_0/3064.wav|ŋˈiɛn kˈiɜw tˈi6 tʃˈyə2ŋ ɗˌe4 t0ˈi2m hˈiɛ4w sˈu hˈyəɜŋ vˌaː2 ɲˈu kˈə2w kˌuə4 fˈu6 hwˈiɲ hˈiɛ6n nˈaj . |0 +dataset/Xanh24h/speaker_0/3065.wav|vˌaː2 mˈo6t0 sˈoɜ xˌoŋ ŋˈaː6j tʃˈi t0ˈiɛ2n ɗˌe4 kˈɔɜ ɗˌyə6c ɗˈa6c kwˈiɛ2n nˈa2j . |0 +dataset/Xanh24h/speaker_0/3066.wav|mˈo hˈi2ɲ nˈuəj ɣˈaː2 tˈaː4w zˈyə6c ɗˈaɜt0 ɣˈəɜp bˈaː ɣˈaː2 tˈyə2ŋ vˌə5n tʃˈaɜj hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/3067.wav|ɗˈoɜj vˌəːɜj ɲˌy5ŋ ŋˈyə2j tʃˈɔ6n mˈuə fˈu6 kˈiɛ6n tʃˌɔ tʃˈiɛɜc ɗˈiɛ6n twˈaː6j ˈiɛw kwˈiɜ kˌuə4 mˈi2ɲ , hˈɔ6 tˈyə2ŋ kˈɔɜ xˈaː4 nˈaŋ , lˈyə6 tʃˈɔ6n sˈaː4n fˈə4m tˈɛw kˌaːɜc t0ˈiɛw tʃˈiɜ nˈa2j . |0 +dataset/Xanh24h/speaker_0/3068.wav|ɗˈiɛ2w nˈa2j sˌɛ5 t0ˈaː6w zˈaː mˈo6t0 ŋˈuə2n tˈu ɲˈə6p ˈo4n ɗˈi6ɲ vˌaː2 ɗˈaː zˈaː6ŋ tʃˌɔ kˈyə4 hˈaː2ŋ . |0 +dataset/Xanh24h/speaker_0/3069.wav|nˈam hˈaːj ŋˈi2n xˌoŋ tʃˈam mˈyə2j t0ˈaːɜm , ˈe-ɲ kwˈiɛɜt0 ɗˈi6ɲ vˈaj vˈoɜn ŋˈən hˈaː2ŋ ɗˌe4 ɗˈə2w t0ˈy sˈəɪ zˈy6ŋ hˈe6 tˈoɜŋ bˈe4 nˈuəj t0ˈom hˈu2m bˈoŋ . |0 +dataset/Xanh24h/speaker_0/3070.wav|xˌi tˈyəŋ hˈiɛ6w ɗˌaː5 kˈɔɜ tʃˈo5 ɗˈyɜŋ tʃˈen tˈi6 tʃˈyə2ŋ , tʃˈu4 ʃˈɒp kˈɔɜ tˈe4 bˈaɜt0 ɗˈə2w fˈaːɜt0 tʃˈiɛ4n tˈem ɗˈaː zˈaː6ŋ sˈaː4n fˈə4m . |0 +dataset/Xanh24h/speaker_0/3071.wav|xˌi t0ˈyəɜj bˈa2ŋ t0ˈaj , hˈa5j t0ˈyəɜj vˈaː2w vˈu2ŋ zˈe5 ɗˌe4 nˈyəɜc t0ˌy2 t0ˌy2 ŋˈə2m sˈuəɜŋ ɗˈəɜt0 . |0 +dataset/Xanh24h/speaker_0/3072.wav|kˈɔɜ tˈe4 nˈɔɜj , kˈiɲ zwˈe-ɲ zˈi6c vˈu6 vˈə6n t0ˈaː4j tʃˈɛ4 ˈɛm kˈɔɜ tˈi6 tʃˈyə2ŋ zˈo6ŋ ɲˌyŋ kˈu5ŋ kˈɔɜ zˈəɜt0 ɲˈiɛ2w kˈe-6ɲ tʃˈe-ɲ . |0 +dataset/Xanh24h/speaker_0/3074.wav|tˈəː2j zˈaːn t0ˌy2 xˌoŋ ɗˌeɜn bˈaː mˈyəj lˈam ŋˈa2j . |0 +dataset/Xanh24h/speaker_0/3075.wav|tʃˈuɜŋ zˈuɜp tʃˈɛ4 fˈaːɜt0 tʃˈiɛ4n vˈe2 mˈa6t0 tˈe4 tʃˈəɜt0 , tʃˈiɜ t0wˈe6 , kˈaː4m sˈuɜc vˌaː2 kˈi5 nˈaŋ sˈaː5 hˈo6j , zˈɔ ɗˈɔɜ ɗˈo2 tʃˈəːj tʃˈəː4 tˈe-2ɲ mˈo6t0 mˈa6t0 hˈaː2ŋ tˈiɛɜt0 ˈiɛɜw xˌoŋ tˈe4 tˈiɛɜw tʃˈɔŋ kˈuə6c sˈoɜŋ kˌuə4 tʃˈɛ4 ˈɛm . |0 diff --git a/whisperx/SubtitlesProcessor.py b/whisperx/SubtitlesProcessor.py new file mode 100644 index 0000000000000000000000000000000000000000..5ffd1afa481a0acf5145fd333be353ca594326b7 --- /dev/null +++ b/whisperx/SubtitlesProcessor.py @@ -0,0 +1,227 @@ +import math +from conjunctions import get_conjunctions, get_comma +from typing import TextIO + +def normal_round(n): + if n - math.floor(n) < 0.5: + return math.floor(n) + return math.ceil(n) + + +def format_timestamp(seconds: float, is_vtt: bool = False): + + assert seconds >= 0, "non-negative timestamp expected" + milliseconds = round(seconds * 1000.0) + + hours = milliseconds // 3_600_000 + milliseconds -= hours * 3_600_000 + + minutes = milliseconds // 60_000 + milliseconds -= minutes * 60_000 + + seconds = milliseconds // 1_000 + milliseconds -= seconds * 1_000 + + separator = '.' if is_vtt else ',' + + hours_marker = f"{hours:02d}:" + return ( + f"{hours_marker}{minutes:02d}:{seconds:02d}{separator}{milliseconds:03d}" + ) + + + +class SubtitlesProcessor: + def __init__(self, segments, lang, max_line_length = 45, min_char_length_splitter = 30, is_vtt = False): + self.comma = get_comma(lang) + self.conjunctions = set(get_conjunctions(lang)) + self.segments = segments + self.lang = lang + self.max_line_length = max_line_length + self.min_char_length_splitter = min_char_length_splitter + self.is_vtt = is_vtt + complex_script_languages = ['th', 'lo', 'my', 'km', 'am', 'ko', 'ja', 'zh', 'ti', 'ta', 'te', 'kn', 'ml', 'hi', 'ne', 'mr', 'ar', 'fa', 'ur', 'ka'] + if self.lang in complex_script_languages: + self.max_line_length = 30 + self.min_char_length_splitter = 20 + + def estimate_timestamp_for_word(self, words, i, next_segment_start_time=None): + k = 0.25 + has_prev_end = i > 0 and 'end' in words[i - 1] + has_next_start = i < len(words) - 1 and 'start' in words[i + 1] + + if has_prev_end: + words[i]['start'] = words[i - 1]['end'] + if has_next_start: + words[i]['end'] = words[i + 1]['start'] + else: + if next_segment_start_time: + words[i]['end'] = next_segment_start_time if next_segment_start_time - words[i - 1]['end'] <= 1 else next_segment_start_time - 0.5 + else: + words[i]['end'] = words[i]['start'] + len(words[i]['word']) * k + + elif has_next_start: + words[i]['start'] = words[i + 1]['start'] - len(words[i]['word']) * k + words[i]['end'] = words[i + 1]['start'] + + else: + if next_segment_start_time: + words[i]['start'] = next_segment_start_time - 1 + words[i]['end'] = next_segment_start_time - 0.5 + else: + words[i]['start'] = 0 + words[i]['end'] = 0 + + + + def process_segments(self, advanced_splitting=True): + subtitles = [] + for i, segment in enumerate(self.segments): + next_segment_start_time = self.segments[i + 1]['start'] if i + 1 < len(self.segments) else None + + if advanced_splitting: + + split_points = self.determine_advanced_split_points(segment, next_segment_start_time) + subtitles.extend(self.generate_subtitles_from_split_points(segment, split_points, next_segment_start_time)) + else: + words = segment['words'] + for i, word in enumerate(words): + if 'start' not in word or 'end' not in word: + self.estimate_timestamp_for_word(words, i, next_segment_start_time) + + subtitles.append({ + 'start': segment['start'], + 'end': segment['end'], + 'text': segment['text'] + }) + + return subtitles + + def determine_advanced_split_points(self, segment, next_segment_start_time=None): + split_points = [] + last_split_point = 0 + char_count = 0 + + words = segment.get('words', segment['text'].split()) + add_space = 0 if self.lang in ['zh', 'ja'] else 1 + + total_char_count = sum(len(word['word']) if isinstance(word, dict) else len(word) + add_space for word in words) + char_count_after = total_char_count + + for i, word in enumerate(words): + word_text = word['word'] if isinstance(word, dict) else word + word_length = len(word_text) + add_space + char_count += word_length + char_count_after -= word_length + + char_count_before = char_count - word_length + + if isinstance(word, dict) and ('start' not in word or 'end' not in word): + self.estimate_timestamp_for_word(words, i, next_segment_start_time) + + if char_count >= self.max_line_length: + midpoint = normal_round((last_split_point + i) / 2) + if char_count_before >= self.min_char_length_splitter: + split_points.append(midpoint) + last_split_point = midpoint + 1 + char_count = sum(len(words[j]['word']) if isinstance(words[j], dict) else len(words[j]) + add_space for j in range(last_split_point, i + 1)) + + elif word_text.endswith(self.comma) and char_count_before >= self.min_char_length_splitter and char_count_after >= self.min_char_length_splitter: + split_points.append(i) + last_split_point = i + 1 + char_count = 0 + + elif word_text.lower() in self.conjunctions and char_count_before >= self.min_char_length_splitter and char_count_after >= self.min_char_length_splitter: + split_points.append(i - 1) + last_split_point = i + char_count = word_length + + return split_points + + + def generate_subtitles_from_split_points(self, segment, split_points, next_start_time=None): + subtitles = [] + + words = segment.get('words', segment['text'].split()) + total_word_count = len(words) + total_time = segment['end'] - segment['start'] + elapsed_time = segment['start'] + prefix = ' ' if self.lang not in ['zh', 'ja'] else '' + start_idx = 0 + for split_point in split_points: + + fragment_words = words[start_idx:split_point + 1] + current_word_count = len(fragment_words) + + + if isinstance(fragment_words[0], dict): + start_time = fragment_words[0]['start'] + end_time = fragment_words[-1]['end'] + next_start_time_for_word = words[split_point + 1]['start'] if split_point + 1 < len(words) else None + if next_start_time_for_word and (next_start_time_for_word - end_time) <= 0.8: + end_time = next_start_time_for_word + else: + fragment = prefix.join(fragment_words).strip() + current_duration = (current_word_count / total_word_count) * total_time + start_time = elapsed_time + end_time = elapsed_time + current_duration + elapsed_time += current_duration + + + subtitles.append({ + 'start': start_time, + 'end': end_time, + 'text': fragment if not isinstance(fragment_words[0], dict) else prefix.join(word['word'] for word in fragment_words) + }) + + start_idx = split_point + 1 + + # Handle the last fragment + if start_idx < len(words): + fragment_words = words[start_idx:] + current_word_count = len(fragment_words) + + if isinstance(fragment_words[0], dict): + start_time = fragment_words[0]['start'] + end_time = fragment_words[-1]['end'] + else: + fragment = prefix.join(fragment_words).strip() + current_duration = (current_word_count / total_word_count) * total_time + start_time = elapsed_time + end_time = elapsed_time + current_duration + + if next_start_time and (next_start_time - end_time) <= 0.8: + end_time = next_start_time + + subtitles.append({ + 'start': start_time, + 'end': end_time if end_time is not None else segment['end'], + 'text': fragment if not isinstance(fragment_words[0], dict) else prefix.join(word['word'] for word in fragment_words) + }) + + return subtitles + + + + def save(self, filename="subtitles.srt", advanced_splitting=True): + + subtitles = self.process_segments(advanced_splitting) + + def write_subtitle(file, idx, start_time, end_time, text): + + file.write(f"{idx}\n") + file.write(f"{start_time} --> {end_time}\n") + file.write(text + "\n\n") + + with open(filename, 'w', encoding='utf-8') as file: + if self.is_vtt: + file.write("WEBVTT\n\n") + + if advanced_splitting: + for idx, subtitle in enumerate(subtitles, 1): + start_time = format_timestamp(subtitle['start'], self.is_vtt) + end_time = format_timestamp(subtitle['end'], self.is_vtt) + text = subtitle['text'].strip() + write_subtitle(file, idx, start_time, end_time, text) + + return len(subtitles) \ No newline at end of file diff --git a/whisperx/__init__.py b/whisperx/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6b9d8de55796c3d32a7660a125e1cdf7fd456213 --- /dev/null +++ b/whisperx/__init__.py @@ -0,0 +1,4 @@ +from .transcribe import load_model +from .alignment import load_align_model, align +from .audio import load_audio +from .diarize import assign_word_speakers, DiarizationPipeline \ No newline at end of file diff --git a/whisperx/__main__.py b/whisperx/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..1036dbe52e21ae22a291a5e63bae8c85fb604aab --- /dev/null +++ b/whisperx/__main__.py @@ -0,0 +1,4 @@ +from .transcribe import cli + + +cli() diff --git a/whisperx/__pycache__/__init__.cpython-310.pyc b/whisperx/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ecbd185586dd78da6742dcafdd9a38c22fd2863 Binary files /dev/null and b/whisperx/__pycache__/__init__.cpython-310.pyc differ diff --git a/whisperx/__pycache__/alignment.cpython-310.pyc b/whisperx/__pycache__/alignment.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c0a28dd7bca076084497bbe72ec55dd96e9d3ff Binary files /dev/null and b/whisperx/__pycache__/alignment.cpython-310.pyc differ diff --git a/whisperx/__pycache__/asr.cpython-310.pyc b/whisperx/__pycache__/asr.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a80cd8d5ee9a9cdbf9f82da977dc37040a46520a Binary files /dev/null and b/whisperx/__pycache__/asr.cpython-310.pyc differ diff --git a/whisperx/__pycache__/audio.cpython-310.pyc b/whisperx/__pycache__/audio.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19d625ab806805148a30157b6d57e93ab5bfb774 Binary files /dev/null and b/whisperx/__pycache__/audio.cpython-310.pyc differ diff --git a/whisperx/__pycache__/diarize.cpython-310.pyc b/whisperx/__pycache__/diarize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ceb0cf1971a099e59668809fbd50e449da00941 Binary files /dev/null and b/whisperx/__pycache__/diarize.cpython-310.pyc differ diff --git a/whisperx/__pycache__/transcribe.cpython-310.pyc b/whisperx/__pycache__/transcribe.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f1b107394bf6371f784621b5aae4ebd23c6d91d Binary files /dev/null and b/whisperx/__pycache__/transcribe.cpython-310.pyc differ diff --git a/whisperx/__pycache__/types.cpython-310.pyc b/whisperx/__pycache__/types.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e03d73cbc8f734729bc941c8218a066ad506728 Binary files /dev/null and b/whisperx/__pycache__/types.cpython-310.pyc differ diff --git a/whisperx/__pycache__/utils.cpython-310.pyc b/whisperx/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..482fa17f2444936f6e760dedaad7e9550f9d659b Binary files /dev/null and b/whisperx/__pycache__/utils.cpython-310.pyc differ diff --git a/whisperx/__pycache__/vad.cpython-310.pyc b/whisperx/__pycache__/vad.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9864ee5d1c9418dda1afbcd6ca3e6b1c7241c992 Binary files /dev/null and b/whisperx/__pycache__/vad.cpython-310.pyc differ diff --git a/whisperx/alignment.py b/whisperx/alignment.py new file mode 100644 index 0000000000000000000000000000000000000000..c91125a6fae7e278227ad5e4f172769894918bbe --- /dev/null +++ b/whisperx/alignment.py @@ -0,0 +1,467 @@ +"""" +Forced Alignment with Whisper +C. Max Bain +""" +from dataclasses import dataclass +from typing import Iterable, Union, List + +import numpy as np +import pandas as pd +import torch +import torchaudio +from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor + +from .audio import SAMPLE_RATE, load_audio +from .utils import interpolate_nans +from .types import AlignedTranscriptionResult, SingleSegment, SingleAlignedSegment, SingleWordSegment +import nltk +from nltk.tokenize.punkt import PunktSentenceTokenizer, PunktParameters + +PUNKT_ABBREVIATIONS = ['dr', 'vs', 'mr', 'mrs', 'prof'] + +LANGUAGES_WITHOUT_SPACES = ["ja", "zh"] + +DEFAULT_ALIGN_MODELS_TORCH = { + "en": "WAV2VEC2_ASR_BASE_960H", + "fr": "VOXPOPULI_ASR_BASE_10K_FR", + "de": "VOXPOPULI_ASR_BASE_10K_DE", + "es": "VOXPOPULI_ASR_BASE_10K_ES", + "it": "VOXPOPULI_ASR_BASE_10K_IT", +} + +DEFAULT_ALIGN_MODELS_HF = { + "ja": "jonatasgrosman/wav2vec2-large-xlsr-53-japanese", + "zh": "jonatasgrosman/wav2vec2-large-xlsr-53-chinese-zh-cn", + "nl": "jonatasgrosman/wav2vec2-large-xlsr-53-dutch", + "uk": "Yehor/wav2vec2-xls-r-300m-uk-with-small-lm", + "pt": "jonatasgrosman/wav2vec2-large-xlsr-53-portuguese", + "ar": "jonatasgrosman/wav2vec2-large-xlsr-53-arabic", + "cs": "comodoro/wav2vec2-xls-r-300m-cs-250", + "ru": "jonatasgrosman/wav2vec2-large-xlsr-53-russian", + "pl": "jonatasgrosman/wav2vec2-large-xlsr-53-polish", + "hu": "jonatasgrosman/wav2vec2-large-xlsr-53-hungarian", + "fi": "jonatasgrosman/wav2vec2-large-xlsr-53-finnish", + "fa": "jonatasgrosman/wav2vec2-large-xlsr-53-persian", + "el": "jonatasgrosman/wav2vec2-large-xlsr-53-greek", + "tr": "mpoyraz/wav2vec2-xls-r-300m-cv7-turkish", + "da": "saattrupdan/wav2vec2-xls-r-300m-ftspeech", + "he": "imvladikon/wav2vec2-xls-r-300m-hebrew", + "vi": 'nguyenvulebinh/wav2vec2-base-vi', + "ko": "kresnik/wav2vec2-large-xlsr-korean", + "ur": "kingabzpro/wav2vec2-large-xls-r-300m-Urdu", + "te": "anuragshas/wav2vec2-large-xlsr-53-telugu", + "hi": "theainerd/Wav2Vec2-large-xlsr-hindi", + "ca": "softcatala/wav2vec2-large-xlsr-catala", + "ml": "gvs/wav2vec2-large-xlsr-malayalam", + "no": "NbAiLab/nb-wav2vec2-1b-bokmaal", + "nn": "NbAiLab/nb-wav2vec2-300m-nynorsk", +} + + +def load_align_model(language_code, device, model_name=None, model_dir=None): + if model_name is None: + # use default model + if language_code in DEFAULT_ALIGN_MODELS_TORCH: + model_name = DEFAULT_ALIGN_MODELS_TORCH[language_code] + elif language_code in DEFAULT_ALIGN_MODELS_HF: + model_name = DEFAULT_ALIGN_MODELS_HF[language_code] + else: + print(f"There is no default alignment model set for this language ({language_code}).\ + Please find a wav2vec2.0 model finetuned on this language in https://huggingface.co/models, then pass the model name in --align_model [MODEL_NAME]") + raise ValueError(f"No default align-model for language: {language_code}") + + if model_name in torchaudio.pipelines.__all__: + pipeline_type = "torchaudio" + bundle = torchaudio.pipelines.__dict__[model_name] + align_model = bundle.get_model(dl_kwargs={"model_dir": model_dir}).to(device) + labels = bundle.get_labels() + align_dictionary = {c.lower(): i for i, c in enumerate(labels)} + else: + try: + processor = Wav2Vec2Processor.from_pretrained(model_name) + align_model = Wav2Vec2ForCTC.from_pretrained(model_name) + except Exception as e: + print(e) + print(f"Error loading model from huggingface, check https://huggingface.co/models for finetuned wav2vec2.0 models") + raise ValueError(f'The chosen align_model "{model_name}" could not be found in huggingface (https://huggingface.co/models) or torchaudio (https://pytorch.org/audio/stable/pipelines.html#id14)') + pipeline_type = "huggingface" + align_model = align_model.to(device) + labels = processor.tokenizer.get_vocab() + align_dictionary = {char.lower(): code for char,code in processor.tokenizer.get_vocab().items()} + + align_metadata = {"language": language_code, "dictionary": align_dictionary, "type": pipeline_type} + + return align_model, align_metadata + + +def align( + transcript: Iterable[SingleSegment], + model: torch.nn.Module, + align_model_metadata: dict, + audio: Union[str, np.ndarray, torch.Tensor], + device: str, + interpolate_method: str = "nearest", + return_char_alignments: bool = False, + print_progress: bool = False, + combined_progress: bool = False, +) -> AlignedTranscriptionResult: + """ + Align phoneme recognition predictions to known transcription. + """ + + if not torch.is_tensor(audio): + if isinstance(audio, str): + audio = load_audio(audio) + audio = torch.from_numpy(audio) + if len(audio.shape) == 1: + audio = audio.unsqueeze(0) + + MAX_DURATION = audio.shape[1] / SAMPLE_RATE + + model_dictionary = align_model_metadata["dictionary"] + model_lang = align_model_metadata["language"] + model_type = align_model_metadata["type"] + + # 1. Preprocess to keep only characters in dictionary + total_segments = len(transcript) + for sdx, segment in enumerate(transcript): + # strip spaces at beginning / end, but keep track of the amount. + if print_progress: + base_progress = ((sdx + 1) / total_segments) * 100 + percent_complete = (50 + base_progress / 2) if combined_progress else base_progress + print(f"Progress: {percent_complete:.2f}%...") + + num_leading = len(segment["text"]) - len(segment["text"].lstrip()) + num_trailing = len(segment["text"]) - len(segment["text"].rstrip()) + text = segment["text"] + + # split into words + if model_lang not in LANGUAGES_WITHOUT_SPACES: + per_word = text.split(" ") + else: + per_word = text + + clean_char, clean_cdx = [], [] + for cdx, char in enumerate(text): + char_ = char.lower() + # wav2vec2 models use "|" character to represent spaces + if model_lang not in LANGUAGES_WITHOUT_SPACES: + char_ = char_.replace(" ", "|") + + # ignore whitespace at beginning and end of transcript + if cdx < num_leading: + pass + elif cdx > len(text) - num_trailing - 1: + pass + elif char_ in model_dictionary.keys(): + clean_char.append(char_) + clean_cdx.append(cdx) + + clean_wdx = [] + for wdx, wrd in enumerate(per_word): + if any([c in model_dictionary.keys() for c in wrd]): + clean_wdx.append(wdx) + + + punkt_param = PunktParameters() + punkt_param.abbrev_types = set(PUNKT_ABBREVIATIONS) + sentence_splitter = PunktSentenceTokenizer(punkt_param) + sentence_spans = list(sentence_splitter.span_tokenize(text)) + + segment["clean_char"] = clean_char + segment["clean_cdx"] = clean_cdx + segment["clean_wdx"] = clean_wdx + segment["sentence_spans"] = sentence_spans + + aligned_segments: List[SingleAlignedSegment] = [] + + # 2. Get prediction matrix from alignment model & align + for sdx, segment in enumerate(transcript): + + t1 = segment["start"] + t2 = segment["end"] + text = segment["text"] + + aligned_seg: SingleAlignedSegment = { + "start": t1, + "end": t2, + "text": text, + "words": [], + } + + if return_char_alignments: + aligned_seg["chars"] = [] + + # check we can align + if len(segment["clean_char"]) == 0: + print(f'Failed to align segment ("{segment["text"]}"): no characters in this segment found in model dictionary, resorting to original...') + aligned_segments.append(aligned_seg) + continue + + if t1 >= MAX_DURATION: + print(f'Failed to align segment ("{segment["text"]}"): original start time longer than audio duration, skipping...') + aligned_segments.append(aligned_seg) + continue + + text_clean = "".join(segment["clean_char"]) + tokens = [model_dictionary[c] for c in text_clean] + + f1 = int(t1 * SAMPLE_RATE) + f2 = int(t2 * SAMPLE_RATE) + + # TODO: Probably can get some speedup gain with batched inference here + waveform_segment = audio[:, f1:f2] + # Handle the minimum input length for wav2vec2 models + if waveform_segment.shape[-1] < 400: + lengths = torch.as_tensor([waveform_segment.shape[-1]]).to(device) + waveform_segment = torch.nn.functional.pad( + waveform_segment, (0, 400 - waveform_segment.shape[-1]) + ) + else: + lengths = None + + with torch.inference_mode(): + if model_type == "torchaudio": + emissions, _ = model(waveform_segment.to(device), lengths=lengths) + elif model_type == "huggingface": + emissions = model(waveform_segment.to(device)).logits + else: + raise NotImplementedError(f"Align model of type {model_type} not supported.") + emissions = torch.log_softmax(emissions, dim=-1) + + emission = emissions[0].cpu().detach() + + blank_id = 0 + for char, code in model_dictionary.items(): + if char == '[pad]' or char == '': + blank_id = code + + trellis = get_trellis(emission, tokens, blank_id) + path = backtrack(trellis, emission, tokens, blank_id) + + if path is None: + print(f'Failed to align segment ("{segment["text"]}"): backtrack failed, resorting to original...') + aligned_segments.append(aligned_seg) + continue + + char_segments = merge_repeats(path, text_clean) + + duration = t2 -t1 + ratio = duration * waveform_segment.size(0) / (trellis.size(0) - 1) + + # assign timestamps to aligned characters + char_segments_arr = [] + word_idx = 0 + for cdx, char in enumerate(text): + start, end, score = None, None, None + if cdx in segment["clean_cdx"]: + char_seg = char_segments[segment["clean_cdx"].index(cdx)] + start = round(char_seg.start * ratio + t1, 3) + end = round(char_seg.end * ratio + t1, 3) + score = round(char_seg.score, 3) + + char_segments_arr.append( + { + "char": char, + "start": start, + "end": end, + "score": score, + "word-idx": word_idx, + } + ) + + # increment word_idx, nltk word tokenization would probably be more robust here, but us space for now... + if model_lang in LANGUAGES_WITHOUT_SPACES: + word_idx += 1 + elif cdx == len(text) - 1 or text[cdx+1] == " ": + word_idx += 1 + + char_segments_arr = pd.DataFrame(char_segments_arr) + + aligned_subsegments = [] + # assign sentence_idx to each character index + char_segments_arr["sentence-idx"] = None + for sdx, (sstart, send) in enumerate(segment["sentence_spans"]): + curr_chars = char_segments_arr.loc[(char_segments_arr.index >= sstart) & (char_segments_arr.index <= send)] + char_segments_arr.loc[(char_segments_arr.index >= sstart) & (char_segments_arr.index <= send), "sentence-idx"] = sdx + + sentence_text = text[sstart:send] + sentence_start = curr_chars["start"].min() + end_chars = curr_chars[curr_chars["char"] != ' '] + sentence_end = end_chars["end"].max() + sentence_words = [] + + for word_idx in curr_chars["word-idx"].unique(): + word_chars = curr_chars.loc[curr_chars["word-idx"] == word_idx] + word_text = "".join(word_chars["char"].tolist()).strip() + if len(word_text) == 0: + continue + + # dont use space character for alignment + word_chars = word_chars[word_chars["char"] != " "] + + word_start = word_chars["start"].min() + word_end = word_chars["end"].max() + word_score = round(word_chars["score"].mean(), 3) + + # -1 indicates unalignable + word_segment = {"word": word_text} + + if not np.isnan(word_start): + word_segment["start"] = word_start + if not np.isnan(word_end): + word_segment["end"] = word_end + if not np.isnan(word_score): + word_segment["score"] = word_score + + sentence_words.append(word_segment) + + aligned_subsegments.append({ + "text": sentence_text, + "start": sentence_start, + "end": sentence_end, + "words": sentence_words, + }) + + if return_char_alignments: + curr_chars = curr_chars[["char", "start", "end", "score"]] + curr_chars.fillna(-1, inplace=True) + curr_chars = curr_chars.to_dict("records") + curr_chars = [{key: val for key, val in char.items() if val != -1} for char in curr_chars] + aligned_subsegments[-1]["chars"] = curr_chars + + aligned_subsegments = pd.DataFrame(aligned_subsegments) + aligned_subsegments["start"] = interpolate_nans(aligned_subsegments["start"], method=interpolate_method) + aligned_subsegments["end"] = interpolate_nans(aligned_subsegments["end"], method=interpolate_method) + # concatenate sentences with same timestamps + agg_dict = {"text": " ".join, "words": "sum"} + if model_lang in LANGUAGES_WITHOUT_SPACES: + agg_dict["text"] = "".join + if return_char_alignments: + agg_dict["chars"] = "sum" + aligned_subsegments= aligned_subsegments.groupby(["start", "end"], as_index=False).agg(agg_dict) + aligned_subsegments = aligned_subsegments.to_dict('records') + aligned_segments += aligned_subsegments + + # create word_segments list + word_segments: List[SingleWordSegment] = [] + for segment in aligned_segments: + word_segments += segment["words"] + + return {"segments": aligned_segments, "word_segments": word_segments} + +""" +source: https://pytorch.org/tutorials/intermediate/forced_alignment_with_torchaudio_tutorial.html +""" +def get_trellis(emission, tokens, blank_id=0): + num_frame = emission.size(0) + num_tokens = len(tokens) + + # Trellis has extra diemsions for both time axis and tokens. + # The extra dim for tokens represents (start-of-sentence) + # The extra dim for time axis is for simplification of the code. + trellis = torch.empty((num_frame + 1, num_tokens + 1)) + trellis[0, 0] = 0 + trellis[1:, 0] = torch.cumsum(emission[:, 0], 0) + trellis[0, -num_tokens:] = -float("inf") + trellis[-num_tokens:, 0] = float("inf") + + for t in range(num_frame): + trellis[t + 1, 1:] = torch.maximum( + # Score for staying at the same token + trellis[t, 1:] + emission[t, blank_id], + # Score for changing to the next token + trellis[t, :-1] + emission[t, tokens], + ) + return trellis + +@dataclass +class Point: + token_index: int + time_index: int + score: float + +def backtrack(trellis, emission, tokens, blank_id=0): + # Note: + # j and t are indices for trellis, which has extra dimensions + # for time and tokens at the beginning. + # When referring to time frame index `T` in trellis, + # the corresponding index in emission is `T-1`. + # Similarly, when referring to token index `J` in trellis, + # the corresponding index in transcript is `J-1`. + j = trellis.size(1) - 1 + t_start = torch.argmax(trellis[:, j]).item() + + path = [] + for t in range(t_start, 0, -1): + # 1. Figure out if the current position was stay or change + # Note (again): + # `emission[J-1]` is the emission at time frame `J` of trellis dimension. + # Score for token staying the same from time frame J-1 to T. + stayed = trellis[t - 1, j] + emission[t - 1, blank_id] + # Score for token changing from C-1 at T-1 to J at T. + changed = trellis[t - 1, j - 1] + emission[t - 1, tokens[j - 1]] + + # 2. Store the path with frame-wise probability. + prob = emission[t - 1, tokens[j - 1] if changed > stayed else 0].exp().item() + # Return token index and time index in non-trellis coordinate. + path.append(Point(j - 1, t - 1, prob)) + + # 3. Update the token + if changed > stayed: + j -= 1 + if j == 0: + break + else: + # failed + return None + return path[::-1] + +# Merge the labels +@dataclass +class Segment: + label: str + start: int + end: int + score: float + + def __repr__(self): + return f"{self.label}\t({self.score:4.2f}): [{self.start:5d}, {self.end:5d})" + + @property + def length(self): + return self.end - self.start + +def merge_repeats(path, transcript): + i1, i2 = 0, 0 + segments = [] + while i1 < len(path): + while i2 < len(path) and path[i1].token_index == path[i2].token_index: + i2 += 1 + score = sum(path[k].score for k in range(i1, i2)) / (i2 - i1) + segments.append( + Segment( + transcript[path[i1].token_index], + path[i1].time_index, + path[i2 - 1].time_index + 1, + score, + ) + ) + i1 = i2 + return segments + +def merge_words(segments, separator="|"): + words = [] + i1, i2 = 0, 0 + while i1 < len(segments): + if i2 >= len(segments) or segments[i2].label == separator: + if i1 != i2: + segs = segments[i1:i2] + word = "".join([seg.label for seg in segs]) + score = sum(seg.score * seg.length for seg in segs) / sum(seg.length for seg in segs) + words.append(Segment(word, segments[i1].start, segments[i2 - 1].end, score)) + i1 = i2 + 1 + i2 = i1 + else: + i2 += 1 + return words diff --git a/whisperx/asr.py b/whisperx/asr.py new file mode 100644 index 0000000000000000000000000000000000000000..c221c5b8ca6fde2a503db7b90da9cffac2886941 --- /dev/null +++ b/whisperx/asr.py @@ -0,0 +1,358 @@ +import os +import warnings +from typing import List, Union, Optional, NamedTuple + +import ctranslate2 +import faster_whisper +import numpy as np +import torch +from transformers import Pipeline +from transformers.pipelines.pt_utils import PipelineIterator + +from .audio import N_SAMPLES, SAMPLE_RATE, load_audio, log_mel_spectrogram +from .vad import load_vad_model, merge_chunks +from .types import TranscriptionResult, SingleSegment + +def find_numeral_symbol_tokens(tokenizer): + numeral_symbol_tokens = [] + for i in range(tokenizer.eot): + token = tokenizer.decode([i]).removeprefix(" ") + has_numeral_symbol = any(c in "0123456789%$£" for c in token) + if has_numeral_symbol: + numeral_symbol_tokens.append(i) + return numeral_symbol_tokens + +class WhisperModel(faster_whisper.WhisperModel): + ''' + FasterWhisperModel provides batched inference for faster-whisper. + Currently only works in non-timestamp mode and fixed prompt for all samples in batch. + ''' + + def generate_segment_batched(self, features: np.ndarray, tokenizer: faster_whisper.tokenizer.Tokenizer, options: faster_whisper.transcribe.TranscriptionOptions, encoder_output = None): + batch_size = features.shape[0] + all_tokens = [] + prompt_reset_since = 0 + if options.initial_prompt is not None: + initial_prompt = " " + options.initial_prompt.strip() + initial_prompt_tokens = tokenizer.encode(initial_prompt) + all_tokens.extend(initial_prompt_tokens) + previous_tokens = all_tokens[prompt_reset_since:] + prompt = self.get_prompt( + tokenizer, + previous_tokens, + without_timestamps=options.without_timestamps, + prefix=options.prefix, + ) + + encoder_output = self.encode(features) + + max_initial_timestamp_index = int( + round(options.max_initial_timestamp / self.time_precision) + ) + + result = self.model.generate( + encoder_output, + [prompt] * batch_size, + beam_size=options.beam_size, + patience=options.patience, + length_penalty=options.length_penalty, + max_length=self.max_length, + suppress_blank=options.suppress_blank, + suppress_tokens=options.suppress_tokens, + ) + + tokens_batch = [x.sequences_ids[0] for x in result] + + def decode_batch(tokens: List[List[int]]) -> str: + res = [] + for tk in tokens: + res.append([token for token in tk if token < tokenizer.eot]) + # text_tokens = [token for token in tokens if token < self.eot] + return tokenizer.tokenizer.decode_batch(res) + + text = decode_batch(tokens_batch) + + return text + + def encode(self, features: np.ndarray) -> ctranslate2.StorageView: + # When the model is running on multiple GPUs, the encoder output should be moved + # to the CPU since we don't know which GPU will handle the next job. + to_cpu = self.model.device == "cuda" and len(self.model.device_index) > 1 + # unsqueeze if batch size = 1 + if len(features.shape) == 2: + features = np.expand_dims(features, 0) + features = faster_whisper.transcribe.get_ctranslate2_storage(features) + + return self.model.encode(features, to_cpu=to_cpu) + +class FasterWhisperPipeline(Pipeline): + """ + Huggingface Pipeline wrapper for FasterWhisperModel. + """ + # TODO: + # - add support for timestamp mode + # - add support for custom inference kwargs + + def __init__( + self, + model, + vad, + vad_params: dict, + options : NamedTuple, + tokenizer=None, + device: Union[int, str, "torch.device"] = -1, + framework = "pt", + language : Optional[str] = None, + suppress_numerals: bool = True, + **kwargs + ): + self.model = model + self.tokenizer = tokenizer + self.options = options + self.preset_language = language + self.suppress_numerals = suppress_numerals + self._batch_size = kwargs.pop("batch_size", None) + self._num_workers = 1 + self._preprocess_params, self._forward_params, self._postprocess_params = self._sanitize_parameters(**kwargs) + self.call_count = 0 + self.framework = framework + if self.framework == "pt": + if isinstance(device, torch.device): + self.device = device + elif isinstance(device, str): + self.device = torch.device(device) + elif device < 0: + self.device = torch.device("cpu") + else: + self.device = torch.device(f"cuda:{device}") + else: + self.device = device + + super(Pipeline, self).__init__() + self.vad_model = vad + self._vad_params = vad_params + + def _sanitize_parameters(self, **kwargs): + preprocess_kwargs = {} + if "tokenizer" in kwargs: + preprocess_kwargs["maybe_arg"] = kwargs["maybe_arg"] + return preprocess_kwargs, {}, {} + + def preprocess(self, audio): + audio = audio['inputs'] + model_n_mels = self.model.feat_kwargs.get("feature_size") + features = log_mel_spectrogram( + audio, + n_mels=model_n_mels if model_n_mels is not None else 80, + padding=N_SAMPLES - audio.shape[0], + ) + return {'inputs': features} + + def _forward(self, model_inputs): + outputs = self.model.generate_segment_batched(model_inputs['inputs'], self.tokenizer, self.options) + return {'text': outputs} + + def postprocess(self, model_outputs): + return model_outputs + + def get_iterator( + self, inputs, num_workers: int, batch_size: int, preprocess_params, forward_params, postprocess_params + ): + dataset = PipelineIterator(inputs, self.preprocess, preprocess_params) + if "TOKENIZERS_PARALLELISM" not in os.environ: + os.environ["TOKENIZERS_PARALLELISM"] = "false" + # TODO hack by collating feature_extractor and image_processor + + def stack(items): + return {'inputs': torch.stack([x['inputs'] for x in items])} + dataloader = torch.utils.data.DataLoader(dataset, num_workers=num_workers, batch_size=batch_size, collate_fn=stack) + model_iterator = PipelineIterator(dataloader, self.forward, forward_params, loader_batch_size=batch_size) + final_iterator = PipelineIterator(model_iterator, self.postprocess, postprocess_params) + return final_iterator + + def transcribe( + self, audio: Union[str, np.ndarray], batch_size=None, num_workers=0, language=None, task=None, chunk_size=30, print_progress = False, combined_progress=False + ) -> TranscriptionResult: + if isinstance(audio, str): + audio = load_audio(audio) + + def data(audio, segments): + for seg in segments: + f1 = int(seg['start'] * SAMPLE_RATE) + f2 = int(seg['end'] * SAMPLE_RATE) + # print(f2-f1) + yield {'inputs': audio[f1:f2]} + + vad_segments = self.vad_model({"waveform": torch.from_numpy(audio).unsqueeze(0), "sample_rate": SAMPLE_RATE}) + vad_segments = merge_chunks( + vad_segments, + chunk_size, + onset=self._vad_params["vad_onset"], + offset=self._vad_params["vad_offset"], + ) + if self.tokenizer is None: + language = language or self.detect_language(audio) + task = task or "transcribe" + self.tokenizer = faster_whisper.tokenizer.Tokenizer(self.model.hf_tokenizer, + self.model.model.is_multilingual, task=task, + language=language) + else: + language = language or self.tokenizer.language_code + task = task or self.tokenizer.task + if task != self.tokenizer.task or language != self.tokenizer.language_code: + self.tokenizer = faster_whisper.tokenizer.Tokenizer(self.model.hf_tokenizer, + self.model.model.is_multilingual, task=task, + language=language) + + if self.suppress_numerals: + previous_suppress_tokens = self.options.suppress_tokens + numeral_symbol_tokens = find_numeral_symbol_tokens(self.tokenizer) + print(f"Suppressing numeral and symbol tokens") + new_suppressed_tokens = numeral_symbol_tokens + self.options.suppress_tokens + new_suppressed_tokens = list(set(new_suppressed_tokens)) + self.options = self.options._replace(suppress_tokens=new_suppressed_tokens) + + segments: List[SingleSegment] = [] + batch_size = batch_size or self._batch_size + total_segments = len(vad_segments) + for idx, out in enumerate(self.__call__(data(audio, vad_segments), batch_size=batch_size, num_workers=num_workers)): + if print_progress: + base_progress = ((idx + 1) / total_segments) * 100 + percent_complete = base_progress / 2 if combined_progress else base_progress + print(f"Progress: {percent_complete:.2f}%...") + text = out['text'] + if batch_size in [0, 1, None]: + text = text[0] + segments.append( + { + "text": text, + "start": round(vad_segments[idx]['start'], 3), + "end": round(vad_segments[idx]['end'], 3) + } + ) + + # revert the tokenizer if multilingual inference is enabled + if self.preset_language is None: + self.tokenizer = None + + # revert suppressed tokens if suppress_numerals is enabled + if self.suppress_numerals: + self.options = self.options._replace(suppress_tokens=previous_suppress_tokens) + + return {"segments": segments, "language": language} + + + def detect_language(self, audio: np.ndarray): + if audio.shape[0] < N_SAMPLES: + print("Warning: audio is shorter than 30s, language detection may be inaccurate.") + model_n_mels = self.model.feat_kwargs.get("feature_size") + segment = log_mel_spectrogram(audio[: N_SAMPLES], + n_mels=model_n_mels if model_n_mels is not None else 80, + padding=0 if audio.shape[0] >= N_SAMPLES else N_SAMPLES - audio.shape[0]) + encoder_output = self.model.encode(segment) + results = self.model.model.detect_language(encoder_output) + language_token, language_probability = results[0][0] + language = language_token[2:-2] + print(f"Detected language: {language} ({language_probability:.2f}) in first 30s of audio...") + return language + +def load_model(whisper_arch, + device, + device_index=0, + compute_type="float16", + asr_options=None, + language : Optional[str] = None, + vad_model=None, + vad_options=None, + model : Optional[WhisperModel] = None, + task="transcribe", + download_root=None, + threads=4): + '''Load a Whisper model for inference. + Args: + whisper_arch: str - The name of the Whisper model to load. + device: str - The device to load the model on. + compute_type: str - The compute type to use for the model. + options: dict - A dictionary of options to use for the model. + language: str - The language of the model. (use English for now) + model: Optional[WhisperModel] - The WhisperModel instance to use. + download_root: Optional[str] - The root directory to download the model to. + threads: int - The number of cpu threads to use per worker, e.g. will be multiplied by num workers. + Returns: + A Whisper pipeline. + ''' + + if whisper_arch.endswith(".en"): + language = "en" + + model = model or WhisperModel(whisper_arch, + device=device, + device_index=device_index, + compute_type=compute_type, + download_root=download_root, + cpu_threads=threads) + if language is not None: + tokenizer = faster_whisper.tokenizer.Tokenizer(model.hf_tokenizer, model.model.is_multilingual, task=task, language=language) + else: + print("No language specified, language will be first be detected for each audio file (increases inference time).") + tokenizer = None + + default_asr_options = { + "beam_size": 5, + "best_of": 5, + "patience": 1, + "length_penalty": 1, + "repetition_penalty": 1, + "no_repeat_ngram_size": 0, + "temperatures": [0.0, 0.2, 0.4, 0.6, 0.8, 1.0], + "compression_ratio_threshold": 2.4, + "log_prob_threshold": -1.0, + "no_speech_threshold": 0.6, + "condition_on_previous_text": False, + "prompt_reset_on_temperature": 0.5, + "initial_prompt": None, + "prefix": None, + "suppress_blank": True, + "suppress_tokens": [-1], + "without_timestamps": True, + "max_initial_timestamp": 0.0, + "word_timestamps": False, + "prepend_punctuations": "\"'“¿([{-", + "append_punctuations": "\"'.。,，!！?？:：”)]}、", + "suppress_numerals": False, + "max_new_tokens": None, + "clip_timestamps": None, + "hallucination_silence_threshold": None, + "hotwords" :'' + } + + if asr_options is not None: + default_asr_options.update(asr_options) + + suppress_numerals = default_asr_options["suppress_numerals"] + del default_asr_options["suppress_numerals"] + + default_asr_options = faster_whisper.transcribe.TranscriptionOptions(**default_asr_options) + + default_vad_options = { + "vad_onset": 0.500, + "vad_offset": 0.363 + } + + if vad_options is not None: + default_vad_options.update(vad_options) + + if vad_model is not None: + vad_model = vad_model + else: + vad_model = load_vad_model(torch.device(device), use_auth_token=None, **default_vad_options) + + return FasterWhisperPipeline( + model=model, + vad=vad_model, + options=default_asr_options, + tokenizer=tokenizer, + language=language, + suppress_numerals=suppress_numerals, + vad_params=default_vad_options, + ) diff --git a/whisperx/assets/mel_filters.npz b/whisperx/assets/mel_filters.npz new file mode 100644 index 0000000000000000000000000000000000000000..cc5204d86199d18f715b92afa2c2b644f176c56c --- /dev/null +++ b/whisperx/assets/mel_filters.npz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7450ae70723a5ef9d341e3cee628c7cb0177f36ce42c44b7ed2bf3325f0f6d4c +size 4271 diff --git a/whisperx/audio.py b/whisperx/audio.py new file mode 100644 index 0000000000000000000000000000000000000000..288df12207e9a6f3c5e9ea927a4cc3b60a2d3ae3 --- /dev/null +++ b/whisperx/audio.py @@ -0,0 +1,159 @@ +import os +import subprocess +from functools import lru_cache +from typing import Optional, Union + +import numpy as np +import torch +import torch.nn.functional as F + +from .utils import exact_div + +# hard-coded audio hyperparameters +SAMPLE_RATE = 16000 +N_FFT = 400 +HOP_LENGTH = 160 +CHUNK_LENGTH = 30 +N_SAMPLES = CHUNK_LENGTH * SAMPLE_RATE # 480000 samples in a 30-second chunk +N_FRAMES = exact_div(N_SAMPLES, HOP_LENGTH) # 3000 frames in a mel spectrogram input + +N_SAMPLES_PER_TOKEN = HOP_LENGTH * 2 # the initial convolutions has stride 2 +FRAMES_PER_SECOND = exact_div(SAMPLE_RATE, HOP_LENGTH) # 10ms per audio frame +TOKENS_PER_SECOND = exact_div(SAMPLE_RATE, N_SAMPLES_PER_TOKEN) # 20ms per audio token + + +def load_audio(file: str, sr: int = SAMPLE_RATE): + """ + Open an audio file and read as mono waveform, resampling as necessary + + Parameters + ---------- + file: str + The audio file to open + + sr: int + The sample rate to resample the audio if necessary + + Returns + ------- + A NumPy array containing the audio waveform, in float32 dtype. + """ + try: + # Launches a subprocess to decode audio while down-mixing and resampling as necessary. + # Requires the ffmpeg CLI to be installed. + cmd = [ + "ffmpeg", + "-nostdin", + "-threads", + "0", + "-i", + file, + "-f", + "s16le", + "-ac", + "1", + "-acodec", + "pcm_s16le", + "-ar", + str(sr), + "-", + ] + out = subprocess.run(cmd, capture_output=True, check=True).stdout + except subprocess.CalledProcessError as e: + raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}") from e + + return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0 + + +def pad_or_trim(array, length: int = N_SAMPLES, *, axis: int = -1): + """ + Pad or trim the audio array to N_SAMPLES, as expected by the encoder. + """ + if torch.is_tensor(array): + if array.shape[axis] > length: + array = array.index_select( + dim=axis, index=torch.arange(length, device=array.device) + ) + + if array.shape[axis] < length: + pad_widths = [(0, 0)] * array.ndim + pad_widths[axis] = (0, length - array.shape[axis]) + array = F.pad(array, [pad for sizes in pad_widths[::-1] for pad in sizes]) + else: + if array.shape[axis] > length: + array = array.take(indices=range(length), axis=axis) + + if array.shape[axis] < length: + pad_widths = [(0, 0)] * array.ndim + pad_widths[axis] = (0, length - array.shape[axis]) + array = np.pad(array, pad_widths) + + return array + + +@lru_cache(maxsize=None) +def mel_filters(device, n_mels: int) -> torch.Tensor: + """ + load the mel filterbank matrix for projecting STFT into a Mel spectrogram. + Allows decoupling librosa dependency; saved using: + + np.savez_compressed( + "mel_filters.npz", + mel_80=librosa.filters.mel(sr=16000, n_fft=400, n_mels=80), + ) + """ + assert n_mels in [80, 128], f"Unsupported n_mels: {n_mels}" + with np.load( + os.path.join(os.path.dirname(__file__), "assets", "mel_filters.npz") + ) as f: + return torch.from_numpy(f[f"mel_{n_mels}"]).to(device) + + +def log_mel_spectrogram( + audio: Union[str, np.ndarray, torch.Tensor], + n_mels: int, + padding: int = 0, + device: Optional[Union[str, torch.device]] = None, +): + """ + Compute the log-Mel spectrogram of + + Parameters + ---------- + audio: Union[str, np.ndarray, torch.Tensor], shape = (*) + The path to audio or either a NumPy array or Tensor containing the audio waveform in 16 kHz + + n_mels: int + The number of Mel-frequency filters, only 80 is supported + + padding: int + Number of zero samples to pad to the right + + device: Optional[Union[str, torch.device]] + If given, the audio tensor is moved to this device before STFT + + Returns + ------- + torch.Tensor, shape = (80, n_frames) + A Tensor that contains the Mel spectrogram + """ + if not torch.is_tensor(audio): + if isinstance(audio, str): + audio = load_audio(audio) + audio = torch.from_numpy(audio) + + if device is not None: + audio = audio.to(device) + if padding > 0: + audio = F.pad(audio, (0, padding)) + window = torch.hann_window(N_FFT).to(audio.device) + stft = torch.stft(audio, N_FFT, HOP_LENGTH, window=window, return_complex=True) + magnitudes = stft[..., :-1].abs() ** 2 + + filters = mel_filters(audio.device, n_mels) + mel_spec = filters @ magnitudes + + log_spec = torch.clamp(mel_spec, min=1e-10).log10() + log_spec = torch.maximum(log_spec, log_spec.max() - 8.0) + log_spec = (log_spec + 4.0) / 4.0 + return log_spec diff --git a/whisperx/conjunctions.py b/whisperx/conjunctions.py new file mode 100644 index 0000000000000000000000000000000000000000..a3d35ea631d05d08322ccbfc422cdbab81fbe0ff --- /dev/null +++ b/whisperx/conjunctions.py @@ -0,0 +1,43 @@ +# conjunctions.py + +conjunctions_by_language = { + 'en': {'and', 'whether', 'or', 'as', 'but', 'so', 'for', 'nor', 'which', 'yet', 'although', 'since', 'unless', 'when', 'while', 'because', 'if', 'how', 'that', 'than', 'who', 'where', 'what', 'near', 'before', 'after', 'across', 'through', 'until', 'once', 'whereas', 'even', 'both', 'either', 'neither', 'though'}, + 'fr': {'et', 'ou', 'mais', 'parce', 'bien', 'pendant', 'quand', 'où', 'comme', 'si', 'que', 'avant', 'après', 'aussitôt', 'jusqu’à', 'à', 'malgré', 'donc', 'tant', 'puisque', 'ni', 'soit', 'bien', 'encore', 'dès', 'lorsque'}, + 'de': {'und', 'oder', 'aber', 'weil', 'obwohl', 'während', 'wenn', 'wo', 'wie', 'dass', 'bevor', 'nachdem', 'sobald', 'bis', 'außer', 'trotzdem', 'also', 'sowie', 'indem', 'weder', 'sowohl', 'zwar', 'jedoch'}, + 'es': {'y', 'o', 'pero', 'porque', 'aunque', 'sin', 'mientras', 'cuando', 'donde', 'como', 'si', 'que', 'antes', 'después', 'tan', 'hasta', 'a', 'a', 'por', 'ya', 'ni', 'sino'}, + 'it': {'e', 'o', 'ma', 'perché', 'anche', 'mentre', 'quando', 'dove', 'come', 'se', 'che', 'prima', 'dopo', 'appena', 'fino', 'a', 'nonostante', 'quindi', 'poiché', 'né', 'ossia', 'cioè'}, + 'ja': {'そして', 'または', 'しかし', 'なぜなら', 'もし', 'それとも', 'だから', 'それに', 'なのに', 'そのため', 'かつ', 'それゆえに', 'ならば', 'もしくは', 'ため'}, + 'zh': {'和', '或', '但是', '因为', '任何', '也', '虽然', '而且', '所以', '如果', '除非', '尽管', '既然', '即使', '只要', '直到', '然后', '因此', '不但', '而是', '不过'}, + 'nl': {'en', 'of', 'maar', 'omdat', 'hoewel', 'terwijl', 'wanneer', 'waar', 'zoals', 'als', 'dat', 'voordat', 'nadat', 'zodra', 'totdat', 'tenzij', 'ondanks', 'dus', 'zowel', 'noch', 'echter', 'toch'}, + 'uk': {'та', 'або', 'але', 'тому', 'хоча', 'поки', 'бо', 'коли', 'де', 'як', 'якщо', 'що', 'перш', 'після', 'доки', 'незважаючи', 'тому', 'ані'}, + 'pt': {'e', 'ou', 'mas', 'porque', 'embora', 'enquanto', 'quando', 'onde', 'como', 'se', 'que', 'antes', 'depois', 'assim', 'até', 'a', 'apesar', 'portanto', 'já', 'pois', 'nem', 'senão'}, + 'ar': {'و', 'أو', 'لكن', 'لأن', 'مع', 'بينما', 'عندما', 'حيث', 'كما', 'إذا', 'الذي', 'قبل', 'بعد', 'فور', 'حتى', 'إلا', 'رغم', 'لذلك', 'بما'}, + 'cs': {'a', 'nebo', 'ale', 'protože', 'ačkoli', 'zatímco', 'když', 'kde', 'jako', 'pokud', 'že', 'než', 'poté', 'jakmile', 'dokud', 'pokud ne', 'navzdory', 'tak', 'stejně', 'ani', 'tudíž'}, + 'ru': {'и', 'или', 'но', 'потому', 'хотя', 'пока', 'когда', 'где', 'как', 'если', 'что', 'перед', 'после', 'несмотря', 'таким', 'также', 'ни', 'зато'}, + 'pl': {'i', 'lub', 'ale', 'ponieważ', 'chociaż', 'podczas', 'kiedy', 'gdzie', 'jak', 'jeśli', 'że', 'zanim', 'po', 'jak tylko', 'dopóki', 'chyba', 'pomimo', 'więc', 'tak', 'ani', 'czyli'}, + 'hu': {'és', 'vagy', 'de', 'mert', 'habár', 'míg', 'amikor', 'ahol', 'ahogy', 'ha', 'hogy', 'mielőtt', 'miután', 'amint', 'amíg', 'hacsak', 'ellenére', 'tehát', 'úgy', 'sem', 'vagyis'}, + 'fi': {'ja', 'tai', 'mutta', 'koska', 'vaikka', 'kun', 'missä', 'kuten', 'jos', 'että', 'ennen', 'sen jälkeen', 'heti', 'kunnes', 'ellei', 'huolimatta', 'siis', 'sekä', 'eikä', 'vaan'}, + 'fa': {'و', 'یا', 'اما', 'چون', 'اگرچه', 'در حالی', 'وقتی', 'کجا', 'چگونه', 'اگر', 'که', 'قبل', 'پس', 'به محض', 'تا زمانی', 'مگر', 'با وجود', 'پس', 'همچنین', 'نه'}, + 'el': {'και', 'ή', 'αλλά', 'επειδή', 'αν', 'ενώ', 'όταν', 'όπου', 'όπως', 'αν', 'που', 'προτού', 'αφού', 'μόλις', 'μέχρι', 'εκτός', 'παρά', 'έτσι', 'όπως', 'ούτε', 'δηλαδή'}, + 'tr': {'ve', 'veya', 'ama', 'çünkü', 'her ne', 'iken', 'nerede', 'nasıl', 'eğer', 'ki', 'önce', 'sonra', 'hemen', 'kadar', 'rağmen', 'hem', 'ne', 'yani'}, + 'da': {'og', 'eller', 'men', 'fordi', 'selvom', 'mens', 'når', 'hvor', 'som', 'hvis', 'at', 'før', 'efter', 'indtil', 'medmindre', 'således', 'ligesom', 'hverken', 'altså'}, + 'he': {'ו', 'או', 'אבל', 'כי', 'אף', 'בזמן', 'כאשר', 'היכן', 'כיצד', 'אם', 'ש', 'לפני', 'אחרי', 'ברגע', 'עד', 'אלא', 'למרות', 'לכן', 'כמו', 'לא', 'אז'}, + 'vi': {'và', 'hoặc', 'nhưng', 'bởi', 'mặc', 'trong', 'khi', 'ở', 'như', 'nếu', 'rằng', 'trước', 'sau', 'ngay', 'cho', 'trừ', 'mặc', 'vì', 'giống', 'cũng', 'tức'}, + 'ko': {'그리고', '또는','그런데','그래도', '이나', '결국', '마지막으로', '마찬가지로', '반면에', '아니면', '거나', '또는', '그럼에도', '그렇기', '때문에', '덧붙이자면', '게다가', '그러나', '고', '그래서', '랑', '한다면', '하지만', '무엇', '왜냐하면', '비록', '동안', '언제', '어디서', '어떻게', '만약', '그', '전에', '후에', '즉시', '까지', '아니라면', '불구하고', '따라서', '같은', '도'}, + 'ur': {'اور', 'یا', 'مگر', 'کیونکہ', 'اگرچہ', 'جبکہ', 'جب', 'کہاں', 'کس طرح', 'اگر', 'کہ', 'سے پہلے', 'کے بعد', 'جیسے ہی', 'تک', 'اگر نہیں تو', 'کے باوجود', 'اس لئے', 'جیسے', 'نہ'}, + 'hi': {'और', 'या', 'पर', 'तो', 'न', 'फिर', 'हालांकि', 'चूंकि', 'अगर', 'कैसे', 'वह', 'से', 'जो', 'जहां', 'क्या', 'नजदीक', 'पहले', 'बाद', 'के', 'पार', 'माध्यम', 'तक', 'एक', 'जबकि', 'यहां', 'तक', 'दोनों', 'या', 'न', 'हालांकि'} + +} + +commas_by_language = { + 'ja': '、', + 'zh': '，', + 'fa': '،', + 'ur': '،' +} + +def get_conjunctions(lang_code): + return conjunctions_by_language.get(lang_code, set()) + +def get_comma(lang_code): + return commas_by_language.get(lang_code, ',') \ No newline at end of file diff --git a/whisperx/diarize.py b/whisperx/diarize.py new file mode 100644 index 0000000000000000000000000000000000000000..8febf2f893c9d1eb701fd72a308d959a801f3bc0 --- /dev/null +++ b/whisperx/diarize.py @@ -0,0 +1,74 @@ +import numpy as np +import pandas as pd +from pyannote.audio import Pipeline +from typing import Optional, Union +import torch + +from .audio import load_audio, SAMPLE_RATE + + +class DiarizationPipeline: + def __init__( + self, + model_name="pyannote/speaker-diarization-3.1", + use_auth_token=None, + device: Optional[Union[str, torch.device]] = "cpu", + ): + if isinstance(device, str): + device = torch.device(device) + self.model = Pipeline.from_pretrained(model_name, use_auth_token=use_auth_token).to(device) + + def __call__(self, audio: Union[str, np.ndarray], num_speakers=None, min_speakers=None, max_speakers=None): + if isinstance(audio, str): + audio = load_audio(audio) + audio_data = { + 'waveform': torch.from_numpy(audio[None, :]), + 'sample_rate': SAMPLE_RATE + } + segments = self.model(audio_data, num_speakers = num_speakers, min_speakers=min_speakers, max_speakers=max_speakers) + diarize_df = pd.DataFrame(segments.itertracks(yield_label=True), columns=['segment', 'label', 'speaker']) + diarize_df['start'] = diarize_df['segment'].apply(lambda x: x.start) + diarize_df['end'] = diarize_df['segment'].apply(lambda x: x.end) + return diarize_df + + +def assign_word_speakers(diarize_df, transcript_result, fill_nearest=False): + transcript_segments = transcript_result["segments"] + for seg in transcript_segments: + # assign speaker to segment (if any) + diarize_df['intersection'] = np.minimum(diarize_df['end'], seg['end']) - np.maximum(diarize_df['start'], seg['start']) + diarize_df['union'] = np.maximum(diarize_df['end'], seg['end']) - np.minimum(diarize_df['start'], seg['start']) + # remove no hit, otherwise we look for closest (even negative intersection...) + if not fill_nearest: + dia_tmp = diarize_df[diarize_df['intersection'] > 0] + else: + dia_tmp = diarize_df + if len(dia_tmp) > 0: + # sum over speakers + speaker = dia_tmp.groupby("speaker")["intersection"].sum().sort_values(ascending=False).index[0] + seg["speaker"] = speaker + + # assign speaker to words + if 'words' in seg: + for word in seg['words']: + if 'start' in word: + diarize_df['intersection'] = np.minimum(diarize_df['end'], word['end']) - np.maximum(diarize_df['start'], word['start']) + diarize_df['union'] = np.maximum(diarize_df['end'], word['end']) - np.minimum(diarize_df['start'], word['start']) + # remove no hit + if not fill_nearest: + dia_tmp = diarize_df[diarize_df['intersection'] > 0] + else: + dia_tmp = diarize_df + if len(dia_tmp) > 0: + # sum over speakers + speaker = dia_tmp.groupby("speaker")["intersection"].sum().sort_values(ascending=False).index[0] + word["speaker"] = speaker + + return transcript_result + + +class Segment: + def __init__(self, start, end, speaker=None): + self.start = start + self.end = end + self.speaker = speaker diff --git a/whisperx/transcribe.py b/whisperx/transcribe.py new file mode 100644 index 0000000000000000000000000000000000000000..5810b04119fcfbd7e929f96d8afa6a7abc5391ee --- /dev/null +++ b/whisperx/transcribe.py @@ -0,0 +1,230 @@ +import argparse +import gc +import os +import warnings + +import numpy as np +import torch + +from .alignment import align, load_align_model +from .asr import load_model +from .audio import load_audio +from .diarize import DiarizationPipeline, assign_word_speakers +from .utils import (LANGUAGES, TO_LANGUAGE_CODE, get_writer, optional_float, + optional_int, str2bool) + + +def cli(): + # fmt: off + parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) + parser.add_argument("audio", nargs="+", type=str, help="audio file(s) to transcribe") + parser.add_argument("--model", default="small", help="name of the Whisper model to use") + parser.add_argument("--model_dir", type=str, default=None, help="the path to save model files; uses ~/.cache/whisper by default") + parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu", help="device to use for PyTorch inference") + parser.add_argument("--device_index", default=0, type=int, help="device index to use for FasterWhisper inference") + parser.add_argument("--batch_size", default=8, type=int, help="the preferred batch size for inference") + parser.add_argument("--compute_type", default="float16", type=str, choices=["float16", "float32", "int8"], help="compute type for computation") + + parser.add_argument("--output_dir", "-o", type=str, default=".", help="directory to save the outputs") + parser.add_argument("--output_format", "-f", type=str, default="all", choices=["all", "srt", "vtt", "txt", "tsv", "json", "aud"], help="format of the output file; if not specified, all available formats will be produced") + parser.add_argument("--verbose", type=str2bool, default=True, help="whether to print out the progress and debug messages") + + parser.add_argument("--task", type=str, default="transcribe", choices=["transcribe", "translate"], help="whether to perform X->X speech recognition ('transcribe') or X->English translation ('translate')") + parser.add_argument("--language", type=str, default=None, choices=sorted(LANGUAGES.keys()) + sorted([k.title() for k in TO_LANGUAGE_CODE.keys()]), help="language spoken in the audio, specify None to perform language detection") + + # alignment params + parser.add_argument("--align_model", default=None, help="Name of phoneme-level ASR model to do alignment") + parser.add_argument("--interpolate_method", default="nearest", choices=["nearest", "linear", "ignore"], help="For word .srt, method to assign timestamps to non-aligned words, or merge them into neighbouring.") + parser.add_argument("--no_align", action='store_true', help="Do not perform phoneme alignment") + parser.add_argument("--return_char_alignments", action='store_true', help="Return character-level alignments in the output json file") + + # vad params + parser.add_argument("--vad_onset", type=float, default=0.500, help="Onset threshold for VAD (see pyannote.audio), reduce this if speech is not being detected") + parser.add_argument("--vad_offset", type=float, default=0.363, help="Offset threshold for VAD (see pyannote.audio), reduce this if speech is not being detected.") + parser.add_argument("--chunk_size", type=int, default=30, help="Chunk size for merging VAD segments. Default is 30, reduce this if the chunk is too long.") + + # diarization params + parser.add_argument("--diarize", action="store_true", help="Apply diarization to assign speaker labels to each segment/word") + parser.add_argument("--min_speakers", default=None, type=int, help="Minimum number of speakers to in audio file") + parser.add_argument("--max_speakers", default=None, type=int, help="Maximum number of speakers to in audio file") + + parser.add_argument("--temperature", type=float, default=0, help="temperature to use for sampling") + parser.add_argument("--best_of", type=optional_int, default=5, help="number of candidates when sampling with non-zero temperature") + parser.add_argument("--beam_size", type=optional_int, default=5, help="number of beams in beam search, only applicable when temperature is zero") + parser.add_argument("--patience", type=float, default=1.0, help="optional patience value to use in beam decoding, as in https://arxiv.org/abs/2204.05424, the default (1.0) is equivalent to conventional beam search") + parser.add_argument("--length_penalty", type=float, default=1.0, help="optional token length penalty coefficient (alpha) as in https://arxiv.org/abs/1609.08144, uses simple length normalization by default") + + parser.add_argument("--suppress_tokens", type=str, default="-1", help="comma-separated list of token ids to suppress during sampling; '-1' will suppress most special characters except common punctuations") + parser.add_argument("--suppress_numerals", action="store_true", help="whether to suppress numeric symbols and currency symbols during sampling, since wav2vec2 cannot align them correctly") + + parser.add_argument("--initial_prompt", type=str, default=None, help="optional text to provide as a prompt for the first window.") + parser.add_argument("--condition_on_previous_text", type=str2bool, default=False, help="if True, provide the previous output of the model as a prompt for the next window; disabling may make the text inconsistent across windows, but the model becomes less prone to getting stuck in a failure loop") + parser.add_argument("--fp16", type=str2bool, default=True, help="whether to perform inference in fp16; True by default") + + parser.add_argument("--temperature_increment_on_fallback", type=optional_float, default=0.2, help="temperature to increase when falling back when the decoding fails to meet either of the thresholds below") + parser.add_argument("--compression_ratio_threshold", type=optional_float, default=2.4, help="if the gzip compression ratio is higher than this value, treat the decoding as failed") + parser.add_argument("--logprob_threshold", type=optional_float, default=-1.0, help="if the average log probability is lower than this value, treat the decoding as failed") + parser.add_argument("--no_speech_threshold", type=optional_float, default=0.6, help="if the probability of the <|nospeech|> token is higher than this value AND the decoding has failed due to `logprob_threshold`, consider the segment as silence") + + parser.add_argument("--max_line_width", type=optional_int, default=None, help="(not possible with --no_align) the maximum number of characters in a line before breaking the line") + parser.add_argument("--max_line_count", type=optional_int, default=None, help="(not possible with --no_align) the maximum number of lines in a segment") + parser.add_argument("--highlight_words", type=str2bool, default=False, help="(not possible with --no_align) underline each word as it is spoken in srt and vtt") + parser.add_argument("--segment_resolution", type=str, default="sentence", choices=["sentence", "chunk"], help="(not possible with --no_align) the maximum number of characters in a line before breaking the line") + + parser.add_argument("--threads", type=optional_int, default=0, help="number of threads used by torch for CPU inference; supercedes MKL_NUM_THREADS/OMP_NUM_THREADS") + + parser.add_argument("--hf_token", type=str, default=None, help="Hugging Face Access Token to access PyAnnote gated models") + + parser.add_argument("--print_progress", type=str2bool, default = False, help = "if True, progress will be printed in transcribe() and align() methods.") + # fmt: on + + args = parser.parse_args().__dict__ + model_name: str = args.pop("model") + batch_size: int = args.pop("batch_size") + model_dir: str = args.pop("model_dir") + output_dir: str = args.pop("output_dir") + output_format: str = args.pop("output_format") + device: str = args.pop("device") + device_index: int = args.pop("device_index") + compute_type: str = args.pop("compute_type") + + # model_flush: bool = args.pop("model_flush") + os.makedirs(output_dir, exist_ok=True) + + align_model: str = args.pop("align_model") + interpolate_method: str = args.pop("interpolate_method") + no_align: bool = args.pop("no_align") + task : str = args.pop("task") + if task == "translate": + # translation cannot be aligned + no_align = True + + return_char_alignments: bool = args.pop("return_char_alignments") + + hf_token: str = args.pop("hf_token") + vad_onset: float = args.pop("vad_onset") + vad_offset: float = args.pop("vad_offset") + + chunk_size: int = args.pop("chunk_size") + + diarize: bool = args.pop("diarize") + min_speakers: int = args.pop("min_speakers") + max_speakers: int = args.pop("max_speakers") + print_progress: bool = args.pop("print_progress") + + if args["language"] is not None: + args["language"] = args["language"].lower() + if args["language"] not in LANGUAGES: + if args["language"] in TO_LANGUAGE_CODE: + args["language"] = TO_LANGUAGE_CODE[args["language"]] + else: + raise ValueError(f"Unsupported language: {args['language']}") + + if model_name.endswith(".en") and args["language"] != "en": + if args["language"] is not None: + warnings.warn( + f"{model_name} is an English-only model but received '{args['language']}'; using English instead." + ) + args["language"] = "en" + align_language = args["language"] if args["language"] is not None else "en" # default to loading english if not specified + + temperature = args.pop("temperature") + if (increment := args.pop("temperature_increment_on_fallback")) is not None: + temperature = tuple(np.arange(temperature, 1.0 + 1e-6, increment)) + else: + temperature = [temperature] + + faster_whisper_threads = 4 + if (threads := args.pop("threads")) > 0: + torch.set_num_threads(threads) + faster_whisper_threads = threads + + asr_options = { + "beam_size": args.pop("beam_size"), + "patience": args.pop("patience"), + "length_penalty": args.pop("length_penalty"), + "temperatures": temperature, + "compression_ratio_threshold": args.pop("compression_ratio_threshold"), + "log_prob_threshold": args.pop("logprob_threshold"), + "no_speech_threshold": args.pop("no_speech_threshold"), + "condition_on_previous_text": False, + "initial_prompt": args.pop("initial_prompt"), + "suppress_tokens": [int(x) for x in args.pop("suppress_tokens").split(",")], + "suppress_numerals": args.pop("suppress_numerals"), + } + + writer = get_writer(output_format, output_dir) + word_options = ["highlight_words", "max_line_count", "max_line_width"] + if no_align: + for option in word_options: + if args[option]: + parser.error(f"--{option} not possible with --no_align") + if args["max_line_count"] and not args["max_line_width"]: + warnings.warn("--max_line_count has no effect without --max_line_width") + writer_args = {arg: args.pop(arg) for arg in word_options} + + # Part 1: VAD & ASR Loop + results = [] + tmp_results = [] + # model = load_model(model_name, device=device, download_root=model_dir) + model = load_model(model_name, device=device, device_index=device_index, download_root=model_dir, compute_type=compute_type, language=args['language'], asr_options=asr_options, vad_options={"vad_onset": vad_onset, "vad_offset": vad_offset}, task=task, threads=faster_whisper_threads) + + for audio_path in args.pop("audio"): + audio = load_audio(audio_path) + # >> VAD & ASR + print(">>Performing transcription...") + result = model.transcribe(audio, batch_size=batch_size, chunk_size=chunk_size, print_progress=print_progress) + results.append((result, audio_path)) + + # Unload Whisper and VAD + del model + gc.collect() + torch.cuda.empty_cache() + + # Part 2: Align Loop + if not no_align: + tmp_results = results + results = [] + align_model, align_metadata = load_align_model(align_language, device, model_name=align_model) + for result, audio_path in tmp_results: + # >> Align + if len(tmp_results) > 1: + input_audio = audio_path + else: + # lazily load audio from part 1 + input_audio = audio + + if align_model is not None and len(result["segments"]) > 0: + if result.get("language", "en") != align_metadata["language"]: + # load new language + print(f"New language found ({result['language']})! Previous was ({align_metadata['language']}), loading new alignment model for new language...") + align_model, align_metadata = load_align_model(result["language"], device) + print(">>Performing alignment...") + result = align(result["segments"], align_model, align_metadata, input_audio, device, interpolate_method=interpolate_method, return_char_alignments=return_char_alignments, print_progress=print_progress) + + results.append((result, audio_path)) + + # Unload align model + del align_model + gc.collect() + torch.cuda.empty_cache() + + # >> Diarize + if diarize: + if hf_token is None: + print("Warning, no --hf_token used, needs to be saved in environment variable, otherwise will throw error loading diarization model...") + tmp_results = results + print(">>Performing diarization...") + results = [] + diarize_model = DiarizationPipeline(use_auth_token=hf_token, device=device) + for result, input_audio_path in tmp_results: + diarize_segments = diarize_model(input_audio_path, min_speakers=min_speakers, max_speakers=max_speakers) + result = assign_word_speakers(diarize_segments, result) + results.append((result, input_audio_path)) + # >> Write + for result, audio_path in results: + result["language"] = align_language + writer(result, audio_path, writer_args) + +if __name__ == "__main__": + cli() diff --git a/whisperx/types.py b/whisperx/types.py new file mode 100644 index 0000000000000000000000000000000000000000..f0f0d04750273a898d8a7ddb29e1cb07ba61351f --- /dev/null +++ b/whisperx/types.py @@ -0,0 +1,58 @@ +from typing import TypedDict, Optional, List + + +class SingleWordSegment(TypedDict): + """ + A single word of a speech. + """ + word: str + start: float + end: float + score: float + +class SingleCharSegment(TypedDict): + """ + A single char of a speech. + """ + char: str + start: float + end: float + score: float + + +class SingleSegment(TypedDict): + """ + A single segment (up to multiple sentences) of a speech. + """ + + start: float + end: float + text: str + + +class SingleAlignedSegment(TypedDict): + """ + A single segment (up to multiple sentences) of a speech with word alignment. + """ + + start: float + end: float + text: str + words: List[SingleWordSegment] + chars: Optional[List[SingleCharSegment]] + + +class TranscriptionResult(TypedDict): + """ + A list of segments and word segments of a speech. + """ + segments: List[SingleSegment] + language: str + + +class AlignedTranscriptionResult(TypedDict): + """ + A list of segments and word segments of a speech. + """ + segments: List[SingleAlignedSegment] + word_segments: List[SingleWordSegment] diff --git a/whisperx/utils.py b/whisperx/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..df624b52ed467aaac7986ddc0e916c36fb6991ec --- /dev/null +++ b/whisperx/utils.py @@ -0,0 +1,437 @@ +import json +import os +import re +import sys +import zlib +from typing import Callable, Optional, TextIO + +LANGUAGES = { + "en": "english", + "zh": "chinese", + "de": "german", + "es": "spanish", + "ru": "russian", + "ko": "korean", + "fr": "french", + "ja": "japanese", + "pt": "portuguese", + "tr": "turkish", + "pl": "polish", + "ca": "catalan", + "nl": "dutch", + "ar": "arabic", + "sv": "swedish", + "it": "italian", + "id": "indonesian", + "hi": "hindi", + "fi": "finnish", + "vi": "vietnamese", + "he": "hebrew", + "uk": "ukrainian", + "el": "greek", + "ms": "malay", + "cs": "czech", + "ro": "romanian", + "da": "danish", + "hu": "hungarian", + "ta": "tamil", + "no": "norwegian", + "th": "thai", + "ur": "urdu", + "hr": "croatian", + "bg": "bulgarian", + "lt": "lithuanian", + "la": "latin", + "mi": "maori", + "ml": "malayalam", + "cy": "welsh", + "sk": "slovak", + "te": "telugu", + "fa": "persian", + "lv": "latvian", + "bn": "bengali", + "sr": "serbian", + "az": "azerbaijani", + "sl": "slovenian", + "kn": "kannada", + "et": "estonian", + "mk": "macedonian", + "br": "breton", + "eu": "basque", + "is": "icelandic", + "hy": "armenian", + "ne": "nepali", + "mn": "mongolian", + "bs": "bosnian", + "kk": "kazakh", + "sq": "albanian", + "sw": "swahili", + "gl": "galician", + "mr": "marathi", + "pa": "punjabi", + "si": "sinhala", + "km": "khmer", + "sn": "shona", + "yo": "yoruba", + "so": "somali", + "af": "afrikaans", + "oc": "occitan", + "ka": "georgian", + "be": "belarusian", + "tg": "tajik", + "sd": "sindhi", + "gu": "gujarati", + "am": "amharic", + "yi": "yiddish", + "lo": "lao", + "uz": "uzbek", + "fo": "faroese", + "ht": "haitian creole", + "ps": "pashto", + "tk": "turkmen", + "nn": "nynorsk", + "mt": "maltese", + "sa": "sanskrit", + "lb": "luxembourgish", + "my": "myanmar", + "bo": "tibetan", + "tl": "tagalog", + "mg": "malagasy", + "as": "assamese", + "tt": "tatar", + "haw": "hawaiian", + "ln": "lingala", + "ha": "hausa", + "ba": "bashkir", + "jw": "javanese", + "su": "sundanese", + "yue": "cantonese", +} + +# language code lookup by name, with a few language aliases +TO_LANGUAGE_CODE = { + **{language: code for code, language in LANGUAGES.items()}, + "burmese": "my", + "valencian": "ca", + "flemish": "nl", + "haitian": "ht", + "letzeburgesch": "lb", + "pushto": "ps", + "panjabi": "pa", + "moldavian": "ro", + "moldovan": "ro", + "sinhalese": "si", + "castilian": "es", +} + +LANGUAGES_WITHOUT_SPACES = ["ja", "zh"] + +system_encoding = sys.getdefaultencoding() + +if system_encoding != "utf-8": + + def make_safe(string): + # replaces any character not representable using the system default encoding with an '?', + # avoiding UnicodeEncodeError (https://github.com/openai/whisper/discussions/729). + return string.encode(system_encoding, errors="replace").decode(system_encoding) + +else: + + def make_safe(string): + # utf-8 can encode any Unicode code point, so no need to do the round-trip encoding + return string + + +def exact_div(x, y): + assert x % y == 0 + return x // y + + +def str2bool(string): + str2val = {"True": True, "False": False} + if string in str2val: + return str2val[string] + else: + raise ValueError(f"Expected one of {set(str2val.keys())}, got {string}") + + +def optional_int(string): + return None if string == "None" else int(string) + + +def optional_float(string): + return None if string == "None" else float(string) + + +def compression_ratio(text) -> float: + text_bytes = text.encode("utf-8") + return len(text_bytes) / len(zlib.compress(text_bytes)) + + +def format_timestamp( + seconds: float, always_include_hours: bool = False, decimal_marker: str = "." +): + assert seconds >= 0, "non-negative timestamp expected" + milliseconds = round(seconds * 1000.0) + + hours = milliseconds // 3_600_000 + milliseconds -= hours * 3_600_000 + + minutes = milliseconds // 60_000 + milliseconds -= minutes * 60_000 + + seconds = milliseconds // 1_000 + milliseconds -= seconds * 1_000 + + hours_marker = f"{hours:02d}:" if always_include_hours or hours > 0 else "" + return ( + f"{hours_marker}{minutes:02d}:{seconds:02d}{decimal_marker}{milliseconds:03d}" + ) + + +class ResultWriter: + extension: str + + def __init__(self, output_dir: str): + self.output_dir = output_dir + + def __call__(self, result: dict, audio_path: str, options: dict): + audio_basename = os.path.basename(audio_path) + audio_basename = os.path.splitext(audio_basename)[0] + output_path = os.path.join( + self.output_dir, audio_basename + "." + self.extension + ) + + with open(output_path, "w", encoding="utf-8") as f: + self.write_result(result, file=f, options=options) + + def write_result(self, result: dict, file: TextIO, options: dict): + raise NotImplementedError + + +class WriteTXT(ResultWriter): + extension: str = "txt" + + def write_result(self, result: dict, file: TextIO, options: dict): + for segment in result["segments"]: + print(segment["text"].strip(), file=file, flush=True) + + +class SubtitlesWriter(ResultWriter): + always_include_hours: bool + decimal_marker: str + + def iterate_result(self, result: dict, options: dict): + raw_max_line_width: Optional[int] = options["max_line_width"] + max_line_count: Optional[int] = options["max_line_count"] + highlight_words: bool = options["highlight_words"] + max_line_width = 1000 if raw_max_line_width is None else raw_max_line_width + preserve_segments = max_line_count is None or raw_max_line_width is None + + if len(result["segments"]) == 0: + return + + def iterate_subtitles(): + line_len = 0 + line_count = 1 + # the next subtitle to yield (a list of word timings with whitespace) + subtitle: list[dict] = [] + times = [] + last = result["segments"][0]["start"] + for segment in result["segments"]: + for i, original_timing in enumerate(segment["words"]): + timing = original_timing.copy() + long_pause = not preserve_segments + if "start" in timing: + long_pause = long_pause and timing["start"] - last > 3.0 + else: + long_pause = False + has_room = line_len + len(timing["word"]) <= max_line_width + seg_break = i == 0 and len(subtitle) > 0 and preserve_segments + if line_len > 0 and has_room and not long_pause and not seg_break: + # line continuation + line_len += len(timing["word"]) + else: + # new line + timing["word"] = timing["word"].strip() + if ( + len(subtitle) > 0 + and max_line_count is not None + and (long_pause or line_count >= max_line_count) + or seg_break + ): + # subtitle break + yield subtitle, times + subtitle = [] + times = [] + line_count = 1 + elif line_len > 0: + # line break + line_count += 1 + timing["word"] = "\n" + timing["word"] + line_len = len(timing["word"].strip()) + subtitle.append(timing) + times.append((segment["start"], segment["end"], segment.get("speaker"))) + if "start" in timing: + last = timing["start"] + if len(subtitle) > 0: + yield subtitle, times + + if "words" in result["segments"][0]: + for subtitle, _ in iterate_subtitles(): + sstart, ssend, speaker = _[0] + subtitle_start = self.format_timestamp(sstart) + subtitle_end = self.format_timestamp(ssend) + if result["language"] in LANGUAGES_WITHOUT_SPACES: + subtitle_text = "".join([word["word"] for word in subtitle]) + else: + subtitle_text = " ".join([word["word"] for word in subtitle]) + has_timing = any(["start" in word for word in subtitle]) + + # add [$SPEAKER_ID]: to each subtitle if speaker is available + prefix = "" + if speaker is not None: + prefix = f"[{speaker}]: " + + if highlight_words and has_timing: + last = subtitle_start + all_words = [timing["word"] for timing in subtitle] + for i, this_word in enumerate(subtitle): + if "start" in this_word: + start = self.format_timestamp(this_word["start"]) + end = self.format_timestamp(this_word["end"]) + if last != start: + yield last, start, prefix + subtitle_text + + yield start, end, prefix + " ".join( + [ + re.sub(r"^(\s*)(.*)$", r"\1\2", word) + if j == i + else word + for j, word in enumerate(all_words) + ] + ) + last = end + else: + yield subtitle_start, subtitle_end, prefix + subtitle_text + else: + for segment in result["segments"]: + segment_start = self.format_timestamp(segment["start"]) + segment_end = self.format_timestamp(segment["end"]) + segment_text = segment["text"].strip().replace("-->", "->") + if "speaker" in segment: + segment_text = f"[{segment['speaker']}]: {segment_text}" + yield segment_start, segment_end, segment_text + + def format_timestamp(self, seconds: float): + return format_timestamp( + seconds=seconds, + always_include_hours=self.always_include_hours, + decimal_marker=self.decimal_marker, + ) + + +class WriteVTT(SubtitlesWriter): + extension: str = "vtt" + always_include_hours: bool = False + decimal_marker: str = "." + + def write_result(self, result: dict, file: TextIO, options: dict): + print("WEBVTT\n", file=file) + for start, end, text in self.iterate_result(result, options): + print(f"{start} --> {end}\n{text}\n", file=file, flush=True) + + +class WriteSRT(SubtitlesWriter): + extension: str = "srt" + always_include_hours: bool = True + decimal_marker: str = "," + + def write_result(self, result: dict, file: TextIO, options: dict): + for i, (start, end, text) in enumerate( + self.iterate_result(result, options), start=1 + ): + print(f"{i}\n{start} --> {end}\n{text}\n", file=file, flush=True) + + +class WriteTSV(ResultWriter): + """ + Write a transcript to a file in TSV (tab-separated values) format containing lines like: + \t\t + + Using integer milliseconds as start and end times means there's no chance of interference from + an environment setting a language encoding that causes the decimal in a floating point number + to appear as a comma; also is faster and more efficient to parse & store, e.g., in C++. + """ + + extension: str = "tsv" + + def write_result(self, result: dict, file: TextIO, options: dict): + print("start", "end", "text", sep="\t", file=file) + for segment in result["segments"]: + print(round(1000 * segment["start"]), file=file, end="\t") + print(round(1000 * segment["end"]), file=file, end="\t") + print(segment["text"].strip().replace("\t", " "), file=file, flush=True) + +class WriteAudacity(ResultWriter): + """ + Write a transcript to a text file that audacity can import as labels. + The extension used is "aud" to distinguish it from the txt file produced by WriteTXT. + Yet this is not an audacity project but only a label file! + + Please note : Audacity uses seconds in timestamps not ms! + Also there is no header expected. + + If speaker is provided it is prepended to the text between double square brackets [[]]. + """ + + extension: str = "aud" + + def write_result(self, result: dict, file: TextIO, options: dict): + ARROW = " " + for segment in result["segments"]: + print(segment["start"], file=file, end=ARROW) + print(segment["end"], file=file, end=ARROW) + print( ( ("[[" + segment["speaker"] + "]]") if "speaker" in segment else "") + segment["text"].strip().replace("\t", " "), file=file, flush=True) + + + +class WriteJSON(ResultWriter): + extension: str = "json" + + def write_result(self, result: dict, file: TextIO, options: dict): + json.dump(result, file, ensure_ascii=False) + + +def get_writer( + output_format: str, output_dir: str +) -> Callable[[dict, TextIO, dict], None]: + writers = { + "txt": WriteTXT, + "vtt": WriteVTT, + "srt": WriteSRT, + "tsv": WriteTSV, + "json": WriteJSON, + } + optional_writers = { + "aud": WriteAudacity, + } + + if output_format == "all": + all_writers = [writer(output_dir) for writer in writers.values()] + + def write_all(result: dict, file: TextIO, options: dict): + for writer in all_writers: + writer(result, file, options) + + return write_all + + if output_format in optional_writers: + return optional_writers[output_format](output_dir) + return writers[output_format](output_dir) + +def interpolate_nans(x, method='nearest'): + if x.notnull().sum() > 1: + return x.interpolate(method=method).ffill().bfill() + else: + return x.ffill().bfill() diff --git a/whisperx/vad.py b/whisperx/vad.py new file mode 100644 index 0000000000000000000000000000000000000000..93d6effe1ead6999401fb9c7b9c8e9accc4622b4 --- /dev/null +++ b/whisperx/vad.py @@ -0,0 +1,311 @@ +import hashlib +import os +import urllib +from typing import Callable, Optional, Text, Union + +import numpy as np +import pandas as pd +import torch +from pyannote.audio import Model +from pyannote.audio.core.io import AudioFile +from pyannote.audio.pipelines import VoiceActivityDetection +from pyannote.audio.pipelines.utils import PipelineModel +from pyannote.core import Annotation, Segment, SlidingWindowFeature +from tqdm import tqdm + +from .diarize import Segment as SegmentX + +VAD_SEGMENTATION_URL = "https://whisperx.s3.eu-west-2.amazonaws.com/model_weights/segmentation/0b5b3216d60a2d32fc086b47ea8c67589aaeb26b7e07fcbe620d6d0b83e209ea/pytorch_model.bin" + +def load_vad_model(device, vad_onset=0.500, vad_offset=0.363, use_auth_token=None, model_fp=None): + model_dir = torch.hub._get_torch_home() + os.makedirs(model_dir, exist_ok = True) + if model_fp is None: + model_fp = os.path.join(model_dir, "whisperx-vad-segmentation.bin") + if os.path.exists(model_fp) and not os.path.isfile(model_fp): + raise RuntimeError(f"{model_fp} exists and is not a regular file") + + if not os.path.isfile(model_fp): + with urllib.request.urlopen(VAD_SEGMENTATION_URL) as source, open(model_fp, "wb") as output: + with tqdm( + total=int(source.info().get("Content-Length")), + ncols=80, + unit="iB", + unit_scale=True, + unit_divisor=1024, + ) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + model_bytes = open(model_fp, "rb").read() + if hashlib.sha256(model_bytes).hexdigest() != VAD_SEGMENTATION_URL.split('/')[-2]: + raise RuntimeError( + "Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model." + ) + + vad_model = Model.from_pretrained(model_fp, use_auth_token=use_auth_token) + hyperparameters = {"onset": vad_onset, + "offset": vad_offset, + "min_duration_on": 0.1, + "min_duration_off": 0.1} + vad_pipeline = VoiceActivitySegmentation(segmentation=vad_model, device=torch.device(device)) + vad_pipeline.instantiate(hyperparameters) + + return vad_pipeline + +class Binarize: + """Binarize detection scores using hysteresis thresholding, with min-cut operation + to ensure not segments are longer than max_duration. + + Parameters + ---------- + onset : float, optional + Onset threshold. Defaults to 0.5. + offset : float, optional + Offset threshold. Defaults to `onset`. + min_duration_on : float, optional + Remove active regions shorter than that many seconds. Defaults to 0s. + min_duration_off : float, optional + Fill inactive regions shorter than that many seconds. Defaults to 0s. + pad_onset : float, optional + Extend active regions by moving their start time by that many seconds. + Defaults to 0s. + pad_offset : float, optional + Extend active regions by moving their end time by that many seconds. + Defaults to 0s. + max_duration: float + The maximum length of an active segment, divides segment at timestamp with lowest score. + Reference + --------- + Gregory Gelly and Jean-Luc Gauvain. "Minimum Word Error Training of + RNN-based Voice Activity Detection", InterSpeech 2015. + + Modified by Max Bain to include WhisperX's min-cut operation + https://arxiv.org/abs/2303.00747 + + Pyannote-audio + """ + + def __init__( + self, + onset: float = 0.5, + offset: Optional[float] = None, + min_duration_on: float = 0.0, + min_duration_off: float = 0.0, + pad_onset: float = 0.0, + pad_offset: float = 0.0, + max_duration: float = float('inf') + ): + + super().__init__() + + self.onset = onset + self.offset = offset or onset + + self.pad_onset = pad_onset + self.pad_offset = pad_offset + + self.min_duration_on = min_duration_on + self.min_duration_off = min_duration_off + + self.max_duration = max_duration + + def __call__(self, scores: SlidingWindowFeature) -> Annotation: + """Binarize detection scores + Parameters + ---------- + scores : SlidingWindowFeature + Detection scores. + Returns + ------- + active : Annotation + Binarized scores. + """ + + num_frames, num_classes = scores.data.shape + frames = scores.sliding_window + timestamps = [frames[i].middle for i in range(num_frames)] + + # annotation meant to store 'active' regions + active = Annotation() + for k, k_scores in enumerate(scores.data.T): + + label = k if scores.labels is None else scores.labels[k] + + # initial state + start = timestamps[0] + is_active = k_scores[0] > self.onset + curr_scores = [k_scores[0]] + curr_timestamps = [start] + t = start + for t, y in zip(timestamps[1:], k_scores[1:]): + # currently active + if is_active: + curr_duration = t - start + if curr_duration > self.max_duration: + search_after = len(curr_scores) // 2 + # divide segment + min_score_div_idx = search_after + np.argmin(curr_scores[search_after:]) + min_score_t = curr_timestamps[min_score_div_idx] + region = Segment(start - self.pad_onset, min_score_t + self.pad_offset) + active[region, k] = label + start = curr_timestamps[min_score_div_idx] + curr_scores = curr_scores[min_score_div_idx+1:] + curr_timestamps = curr_timestamps[min_score_div_idx+1:] + # switching from active to inactive + elif y < self.offset: + region = Segment(start - self.pad_onset, t + self.pad_offset) + active[region, k] = label + start = t + is_active = False + curr_scores = [] + curr_timestamps = [] + curr_scores.append(y) + curr_timestamps.append(t) + # currently inactive + else: + # switching from inactive to active + if y > self.onset: + start = t + is_active = True + + # if active at the end, add final region + if is_active: + region = Segment(start - self.pad_onset, t + self.pad_offset) + active[region, k] = label + + # because of padding, some active regions might be overlapping: merge them. + # also: fill same speaker gaps shorter than min_duration_off + if self.pad_offset > 0.0 or self.pad_onset > 0.0 or self.min_duration_off > 0.0: + if self.max_duration < float("inf"): + raise NotImplementedError(f"This would break current max_duration param") + active = active.support(collar=self.min_duration_off) + + # remove tracks shorter than min_duration_on + if self.min_duration_on > 0: + for segment, track in list(active.itertracks()): + if segment.duration < self.min_duration_on: + del active[segment, track] + + return active + + +class VoiceActivitySegmentation(VoiceActivityDetection): + def __init__( + self, + segmentation: PipelineModel = "pyannote/segmentation", + fscore: bool = False, + use_auth_token: Union[Text, None] = None, + **inference_kwargs, + ): + + super().__init__(segmentation=segmentation, fscore=fscore, use_auth_token=use_auth_token, **inference_kwargs) + + def apply(self, file: AudioFile, hook: Optional[Callable] = None) -> Annotation: + """Apply voice activity detection + + Parameters + ---------- + file : AudioFile + Processed file. + hook : callable, optional + Hook called after each major step of the pipeline with the following + signature: hook("step_name", step_artefact, file=file) + + Returns + ------- + speech : Annotation + Speech regions. + """ + + # setup hook (e.g. for debugging purposes) + hook = self.setup_hook(file, hook=hook) + + # apply segmentation model (only if needed) + # output shape is (num_chunks, num_frames, 1) + if self.training: + if self.CACHED_SEGMENTATION in file: + segmentations = file[self.CACHED_SEGMENTATION] + else: + segmentations = self._segmentation(file) + file[self.CACHED_SEGMENTATION] = segmentations + else: + segmentations: SlidingWindowFeature = self._segmentation(file) + + return segmentations + + +def merge_vad(vad_arr, pad_onset=0.0, pad_offset=0.0, min_duration_off=0.0, min_duration_on=0.0): + + active = Annotation() + for k, vad_t in enumerate(vad_arr): + region = Segment(vad_t[0] - pad_onset, vad_t[1] + pad_offset) + active[region, k] = 1 + + + if pad_offset > 0.0 or pad_onset > 0.0 or min_duration_off > 0.0: + active = active.support(collar=min_duration_off) + + # remove tracks shorter than min_duration_on + if min_duration_on > 0: + for segment, track in list(active.itertracks()): + if segment.duration < min_duration_on: + del active[segment, track] + + active = active.for_json() + active_segs = pd.DataFrame([x['segment'] for x in active['content']]) + return active_segs + +def merge_chunks( + segments, + chunk_size, + onset: float = 0.5, + offset: Optional[float] = None, +): + """ + Merge operation described in paper + """ + curr_end = 0 + merged_segments = [] + seg_idxs = [] + speaker_idxs = [] + + assert chunk_size > 0 + binarize = Binarize(max_duration=chunk_size, onset=onset, offset=offset) + segments = binarize(segments) + segments_list = [] + for speech_turn in segments.get_timeline(): + segments_list.append(SegmentX(speech_turn.start, speech_turn.end, "UNKNOWN")) + + if len(segments_list) == 0: + print("No active speech found in audio") + return [] + # assert segments_list, "segments_list is empty." + # Make sur the starting point is the start of the segment. + curr_start = segments_list[0].start + + for seg in segments_list: + if seg.end - curr_start > chunk_size and curr_end-curr_start > 0: + merged_segments.append({ + "start": curr_start, + "end": curr_end, + "segments": seg_idxs, + }) + curr_start = seg.start + seg_idxs = [] + speaker_idxs = [] + curr_end = seg.end + seg_idxs.append((seg.start, seg.end)) + speaker_idxs.append(seg.speaker) + # add final + merged_segments.append({ + "start": curr_start, + "end": curr_end, + "segments": seg_idxs, + }) + return merged_segments