Upload 10 files

.gitignore

@@ -0,0 +1,5 @@
+.env
+downloaded_audio/
+figures/
+audio_cut/
+audio_cut.zip

download_audio.py

@@ -0,0 +1,69 @@
+import yt_dlp
+import os
+import subprocess
+import shutil
+from pydub import AudioSegment
+from pydub.playback import play
+import os
+import tempfile
+from pytube  import  Playlist
+def download_and_convert_audio(url, path,idx, sample_rate=24000):
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'wav',
+        }],
+        'outtmpl': '%(title)s.%(ext)s',
+    }
+
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+        filename = ydl.prepare_filename(info)
+        original_filename = os.path.splitext(filename)[0] + '.wav'
+        print("original_filename",original_filename)
+
+
+    # Convert sample rate using FFmpeg
+    # temp_filename = output_filename.split("/")[0]+ 'temp_' + output_filename.split("/")[1]
+    direc = path + original_filename[:30] +"_"
+    if not os.path.exists(direc):
+        os.makedirs(direc)
+
+    output_filename = direc + "/" +str(idx) + ".wav"
+    subprocess.run([
+        'ffmpeg', '-i', original_filename,
+        '-ar', str(sample_rate),
+        output_filename
+    ])
+
+
+    os.remove(original_filename)
+    print(f"Audio downloaded and converted: {output_filename}")
+    return output_filename
+
+from pydub import AudioSegment
+
+def cut_audio(root):
+    total_duration = 0
+    for folder in os.listdir(root):
+        path = root + folder + '/'
+        file =  os.listdir(path)[0]
+        audio = AudioSegment.from_wav(path + file)
+        audio = audio[30 * 1000: 6 * 60 * 1000 + 30 * 1000 ]
+        save_path = "audio_cut/" +file
+        audio.export(save_path, format="wav")
+        total_duration += len(audio)
+        if total_duration > 7*60*60*1000:
+            break
+
+
+if __name__ == '__main__':
+    playlist_url = 'https://www.youtube.com/playlist?list=PLd7oGuDX6k1CD0EaggVT3kV6MjGqbVV9k'
+
+    # Thư mục lưu trữ file âm thanh tải về
+    save_path = 'audio_cut/'
+
+    # Tạo thư mục nếu chưa tồn tại
+    cut_audio("downloaded_audio/")
+

gemini_normalize.py

@@ -0,0 +1,53 @@
+"""
+Install the Google AI Python SDK
+
+$ pip install google-generativeai
+"""
+
+import os
+import google.generativeai as genai
+
+from dotenv import load_dotenv
+load_dotenv()
+api_key = os.getenv('GEMINI_API_KEY')
+
+genai.configure(api_key=api_key)
+
+# Create the model
+generation_config = {
+  "temperature": 0,
+  "top_p": 0.95,
+  "top_k": 64,
+  "max_output_tokens": 8192,
+  "response_mime_type": "text/plain",
+}
+
+model = genai.GenerativeModel(
+  model_name="gemini-1.5-pro-exp-0827",
+  generation_config=generation_config,
+  # safety_settings = Adjust safety settings
+  # See https://ai.google.dev/gemini-api/docs/safety-settings
+)
+
+
+def call_api(text):
+  chat_session = model.start_chat(
+    history=[
+      {
+        "role": "user",
+        "parts": [
+          "# Prompt:\n\"You are an expert in Vietnamese language normalization, specializing in transforming informal, professional, and complex text into clear, well-structured Vietnamese. Your task is to normalize a list of Vietnamese sentences to ensure they are grammatically correct, accurately convey the intended meaning, and are consistent with the writing conventions of formal Vietnamese.\n\n# Rules:\nI will give you a list of sentences to normalize.\nYour task is to transform the sentences into their most formal and correct form while maintaining the original meaning. This includes handling numbers, dates, measurements, abbreviations, names, and any polysemic words appropriately.\nEnsure that numbers (including decimals, fractions), time, currency, and units are expressed in full written form.\nIf there are informal expressions, rewrite them into formal, clear language.\nMaintain proper noun names, abbreviations, or technical terms as is when necessary.\nAbsolutely do not change the original content or remove any part of the text.\nDo not add any new words unless they are necessary for the process of normalization. Only add words if they are essential for formalizing or clarifying the original text (e.g., converting abbreviations or numeric forms into written language).\nFor words that have become commonly used in Vietnamese, such as \"nét\" (referring to \"internet\"), keep them as they are in the original text. Do not attempt to translate these words into their English equivalents. Focus on maintaining the natural usage of these words in the context of the sentence.\nFor all instances where numbers are used (e.g., U17, COVID-19, F12,G9), convert the numbers to their full written form in Vietnamese. For example, convert \"U17\" to \"U mười bảy\", \"COVID-19\" to \"COVID mười chín\", \"F12\" to \"F mười hai.\", \"G9\" to \"G chín\".\nFor sentences that do not require any normalization, keep them exactly as they are. Do not make any changes to such sentences.\nAvoid unnecessary rephrasing unless absolutely required to maintain clarity and fluency.\nReply with the normalized sentences only, without any explanation.\nIf a sentence is very complex or informal, aim to restructure it for maximum clarity and readability.\nAlways prioritize accuracy and fluency in your normalization.\"\n# Example\n- Input1:\n[\n    \"TS Nguyễn Văn A mua 5kg gạo với giá 12.500 VND/kg từ 8h30 đến 10h30 ngày 12/03/2023. SĐT: 0909 123 456.\",\n    \"Chị H thuê 3 căn hộ, mỗi căn rộng 120m2 với giá 8.000.000 VND/tháng từ tháng 01 đến tháng 03.\",\n    \"V. là giai đoạn 2/3 của dự án với chi phí 1.500.000 VND và thời gian thực hiện từ 09:00 đến 17:00.\"\n]\n\n- Output1:\n[\n    \"Tiến sĩ Nguyễn Văn A mua năm kilogram gạo với giá mười hai nghìn năm trăm đồng một kilogram từ tám giờ ba mươi phút đến mười giờ ba mươi phút ngày mười hai tháng ba năm hai nghìn không trăm hai mươi ba. Số điện thoại: không chín không chín một hai ba bốn năm sáu.\",\n    \"Chị H thuê ba căn hộ, mỗi căn rộng một trăm hai mươi mét vuông với giá tám triệu đồng một tháng từ tháng một đến tháng ba.\",\n    \"Năm là giai đoạn hai phần ba của dự án với chi phí một triệu năm trăm nghìn đồng và thời gian thực hiện từ chín giờ đến mười bảy giờ.\"\n]\n- Input 2:\n[\n    \"Anh T dùng 1/4 giờ để chạy quãng đường 5km với vận tốc 20,25 km/h. Chi phí là 100.000 VND.\",\n    \"Cô B đã hoàn thành cuộc thi trong 1/3 thời gian dự kiến và giành vị trí thứ 2. ROMAN III là đối thủ xếp sau.\",\n    \"Số tiền 2.000.000 VND đã được gửi vào tài khoản lúc 15:45.\"\n]\n- Output2:\n[\n    \"Anh T dùng một phần tư giờ để chạy quãng đường năm kilomet với vận tốc hai mươi phẩy hai lăm kilomet một giờ. Chi phí là một trăm nghìn đồng.\",\n    \"Cô B đã hoàn thành cuộc thi trong một phần ba thời gian dự kiến và giành vị trí thứ hai. Ba theo La Mã là đối thủ xếp sau.\",\n    \"Số tiền hai triệu đồng đã đ��ợc gửi vào tài khoản lúc mười lăm giờ bốn mươi lăm phút.\"\n]\n- Input3:\n[\n\"Anh ấy dành 2 tiếng để lướt nét mỗi ngày.\",\n\"Cô ấy thường xuyên đăng ảnh lên phây.\",\n\"Họ gu gồ thông tin về chuyến du lịch sắp tới.\"\n]\n- Output3:\n[\n\"Anh ấy dành hai tiếng để lướt nét mỗi ngày.\",\n\"Cô ấy thường xuyên đăng ảnh lên phây.\",\n\"Họ gu gồ thông tin về chuyến du lịch sắp tới.\"\n]\n- Input 4 :\n[\"với những thông tin trên mà tài chính kinh doanh chia sẻ, hy vọng các bạn sinh viên sẽ tìm được một công việc phù hợp để kiếm thêm thu nhập nhé.\"]\n- Output 4:\n[\"với những thông tin trên mà tài chính kinh doanh chia sẻ, hy vọng các bạn sinh viên sẽ tìm được một công việc phù hợp để kiếm thêm thu nhập nhé.\"]\n- Input 5 :\n[\"Tuy nhiên, bạn cần chú ý đến mặt cạnh tranh và khả năng quảng cáo, marketing đặc biệt để tối ưu hóa khả năng kinh doanh.\",\"đầu tiên, bạn có thể xây dựng chuồng trại, nuôi các loại da súc, da cầm, sau đó có thể tận dụng chất thải từ chăn nuôi làm phân bón cho các loại cây.\" , \"Tuy nhiên, nếu mua con giống sinh sản, thiết nghĩ quý vị và các bạn nên chọn vùng đất dễ xây dựng chuồng vì giống dê này nhân đàn rất nhanh.\"]\n- Output 5 :\n[\"Tuy nhiên, bạn cần chú ý đến mặt cạnh tranh và khả năng quảng cáo, marketing đặc biệt để tối ưu hóa khả năng kinh doanh.\",\"đầu tiên, bạn có thể xây dựng chuồng trại, nuôi các loại da súc, da cầm, sau đó có thể tận dụng chất thải từ chăn nuôi làm phân bón cho các loại cây.\" , \"Tuy nhiên, nếu mua con giống sinh sản, thiết nghĩ quý vị và các bạn nên chọn vùng đất dễ xây dựng chuồng vì giống dê này nhân đàn rất nhanh.\"]\n- input 6 :\n[\"Trong khu chuồng nuôi, bà con cần chia thành ô chuồng nhỏ với diện tích từ 10 đến 20 m2, thường là vách ngăn được xây bằng gạch hoặc cắt thành gỗ kép lại.\"]\n- output 6 :\n[\"Trong khu chuồng nuôi, bà con cần chia thành ô chuồng nhỏ với diện tích từ mười đến hai mươi mét vuông, thường là vách ngăn được xây bằng gạch hoặc cắt thành gỗ kép lại.\"]\n- input 7 : \n['Nguyên Phong, Ninh Thuận, U17 Khánh Hòa, Star Kids, hay các trang truyền lửa cho bóng đá trên mạng xã hội.','Trên cánh đồng ngô nếp ở thôn 1, xã Tường Sơn, ngay từ sáng sớm người dân đã nhộn nhịp ra đồng thu hoạch để bán cho thương lái.', 'Tuy nhiên, trong giai đoạn dịch COVID-19 bùng phát, câu chuyện kêu gọi giải cứu thanh long đỏ gây sốt giới truyền thông cả trong và ngoài nước.',\"top 4 người tôi luôn tin tưởng nhất\"]\n- output 7 :\n['Nguyên Phong, Ninh Thuận, U mười bảy Khánh Hòa, Star Kids, hay các trang truyền lửa cho bóng đá trên mạng xã hội.', Trên cánh đồng ngô nếp ở thôn một, xã Tường Sơn, ngay từ sáng sớm người dân đã nhộn nhịp ra đồng thu hoạch để bán cho thương lái.','Tuy nhiên, trong giai đoạn dịch COVID mười chín bùng phát, câu chuyện kêu gọi giải cứu thanh long đỏ gây sốt giới truyền thông cả trong và ngoài nước.',\"top bốn người tôi luôn tin tưởng nhất\"]\n",
+        ],
+      },
+      {
+        "role": "model",
+        "parts": [
+          "- Output 7 :\n['Nguyên Phong, Ninh Thuận, U mười bảy Khánh Hòa, Star Kids, hay các trang truyền lửa cho bóng đá trên mạng xã hội.', 'Trên cánh đồng ngô nếp ở thôn một, xã Tường Sơn, ngay từ sáng sớm người dân đã nhộn nhịp ra đồng thu hoạch để bán cho thương lái.', 'Tuy nhiên, trong giai đoạn dịch COVID mười chín bùng phát, câu chuyện kêu gọi giải cứu thanh long đỏ gây sốt giới truyền thông cả trong và ngoài nước.', 'top bốn người tôi luôn tin tưởng nhất']",
+        ],
+      },
+    ]
+  )
+
+  response = chat_session.send_message(text)
+  print(response.text)
+  return eval(response.text)

gen_dataset.py

@@ -0,0 +1,19 @@
+import whisperx
+
+audio_path = "audio_cut/4.wav"
+device = "cuda"
+batch_size = 4 # reduce if low on GPU mem
+compute_type = "float32" # change to "int8" if low on GPU mem (may reduce accuracy)
+
+# 1. Transcribe with original whisper (batched)
+model_dir = "figures/"
+model = whisperx.load_model("medium", device, compute_type=compute_type, download_root=model_dir,language="vi")
+audio = whisperx.load_audio(audio_path)
+result = model.transcribe(audio, batch_size=batch_size,chunk_size=10
+                          )
+print(result)
+
+import  json
+
+# with open('data.json', 'w', encoding='utf-8') as json_file:
+#     json.dump(data, json_file, ensure_ascii=False, indent=4)

main.py

@@ -0,0 +1,136 @@
+from pydub import AudioSegment
+import pandas as pd
+import nltk
+from nltk.tokenize import TweetTokenizer
+word_tokenize = TweetTokenizer().tokenize
+from text_nomalize import normalize_single
+
+from gemini_normalize import call_api
+def replace_t(word):
+    x = "t̪"
+    return word.replace(x, 't0')
+
+def replace_special_char(word):
+    special_chars_to_ignore = "̪̃/^"
+    for char in special_chars_to_ignore:
+        word= word.replace(char, '')
+    return word
+def clean_word(input_string):
+    special_chars = "{<[)}>(]"
+    for char in special_chars:
+        input_string = input_string.replace(char, '"')
+    return input_string
+
+import phonemizer
+global_phonemizer = phonemizer.backend.EspeakBackend(language='vi', preserve_punctuation=True,  with_stress=True,language_switch='remove-flags',words_mismatch='ignore')
+def has_numbers(inputString):
+    return any(char.isdigit() for char in inputString)
+
+def word_process(parquet_path):
+    df = pd.read_parquet(parquet_path, engine='fastparquet')
+    for index, row in df.iterrows():
+        text = df.loc[index, 'normal_text']
+
+        text = word_tokenize(text)
+        text = [clean_word(word) for word in text]
+
+        text = ' '.join(text)
+
+        ps = global_phonemizer.phonemize([text])
+        print(ps)
+        ps = [replace_t(p) for p in ps]
+        print(ps)
+        ps = [replace_special_char(p) for p in ps]
+        df.loc[index, 'phonemes'] = ps[0]
+
+    df.to_parquet(parquet_path, engine='fastparquet')
+
+
+
+
+
+def generate(root_path,parquet_file):
+    total_duration = 0
+
+    df = pd.read_parquet(root_path+"/"+parquet_file, engine='fastparquet')
+    new_df = pd.DataFrame(columns=['audio.path', 'text','speaker_id'])
+    for index, row in df.iterrows():
+
+        file= df.loc[index, 'audio.path']
+        text = df.loc[index, 'text']
+
+        audio = AudioSegment.from_wav(file)
+        if len(audio)/1000.0>6 and len(audio)/1000.0<9:
+            total_duration += len(audio)
+            new_df = new_df.append({'audio.path':file,'text':text,'speaker_id':0},ignore_index=True)
+
+
+        if total_duration/(1000*60*60)>=1:
+            print(new_df.head())
+            new_df =new_df.reset_index(drop=True)
+            new_df.to_parquet(root_path+"/"+"Xanh24h_1h.parquet", engine='fastparquet')
+            break
+
+def normalize_text(parquet_file):
+    df = pd.read_parquet(parquet_file, engine='fastparquet')
+    req = []
+    print(df.shape[0]-1)
+    dem = 0
+    for index, row in df.iterrows():
+        text = df.loc[index, 'text']
+        req.append(text)
+        # print(index)
+        if len(req)==50 or index == df.shape[0]-1:
+            res = call_api(str(req))
+
+            for idx,r in enumerate(res):
+                df.loc[50*dem+idx, 'normal_text'] = r
+            dem+=1
+            req = []
+    for index, row in df.iterrows():
+        if has_numbers(df.loc[index, 'normal_text']):
+            print("has number",df.loc[index, 'normal_text'])
+        elif df.loc[index, 'normal_text'] != df.loc[index, 'text'] and  not has_numbers(df.loc[index, 'text']):
+            print(df.loc[index, 'normal_text'])
+            print(df.loc[index, 'text'])
+
+    df.to_parquet(parquet_file, engine='fastparquet')
+
+
+def read(parquet_file):
+    df = pd.read_parquet(parquet_file, engine='fastparquet')
+    for index, row in df.iterrows():
+        if has_numbers(df.loc[index, 'normal_text']):
+            print("has number",df.loc[index, 'normal_text'])
+        elif df.loc[index, 'normal_text'] != df.loc[index, 'text'] and  not has_numbers(df.loc[index, 'text']):
+            print(df.loc[index, 'normal_text'])
+            print(df.loc[index, 'text'])
+            print(df.loc[index, 'audio.path'])
+            df.loc[index, 'normal_text'] =df.loc[index, 'text']
+    # df.to_parquet(parquet_file, engine='fastparquet')
+
+def copy_audio(parquet_file):
+    import shutil
+    df = pd.read_parquet(parquet_file, engine='fastparquet')
+    for index, row in df.iterrows():
+        file= df.loc[index, 'audio.path']
+        shutil.copy2(file, file.replace("dataset","data"))
+
+def export(parquet_file,output_file):
+    df = pd.read_parquet(parquet_file, engine='fastparquet')
+    data =[]
+    for index, row in df.iterrows():
+        data.append(f"{df.loc[index, 'audio.path']}|{df.loc[index, 'phonemes']}|0")
+
+    with open(output_file, 'w',encoding="utf-8") as f:
+        for item in data:
+            f.write("%s\n" % item)
+
+
+if __name__ == "__main__":
+    # generate("dataset","Xanh24h.parquet")
+    # normalize_text("dataset/Xanh24h_1h.parquet")
+    # read("dataset/Xanh24h_1h.parquet")
+    word_process("dataset/Xanh24h_1h_test.parquet")
+    # copy_audio("dataset/Xanh24h_1h.parquet")
+    export("dataset/Xanh24h_1h_test.parquet","val_list.txt")

separate.py

@@ -0,0 +1,108 @@
+import os,sys,torch,warnings,pdb
+warnings.filterwarnings("ignore")
+import librosa
+import importlib
+import  numpy as np
+import hashlib , math
+from tqdm import tqdm
+from uvr5_pack.lib_v5 import spec_utils
+from uvr5_pack.utils import _get_name_params,inference
+from uvr5_pack.lib_v5.model_param_init import ModelParameters
+from scipy.io import wavfile
+
+class  _audio_pre_():
+    def __init__(self, model_path,device,is_half):
+        self.model_path = model_path
+        self.device = device
+        self.data = {
+            # Processing Options
+            'postprocess': False,
+            'tta': False,
+            # Constants
+            'window_size': 512,
+            'agg': 10,
+            'high_end_process': 'mirroring',
+        }
+        nn_arch_sizes = [
+            31191, # default
+            33966,61968, 123821, 123812, 537238 # custom
+        ]
+        self.nn_architecture = list('{}KB'.format(s) for s in nn_arch_sizes)
+        model_size = math.ceil(os.stat(model_path ).st_size / 1024)
+        nn_architecture = '{}KB'.format(min(nn_arch_sizes, key=lambda x:abs(x-model_size)))
+        nets = importlib.import_module('uvr5_pack.lib_v5.nets' + f'_{nn_architecture}'.replace('_{}KB'.format(nn_arch_sizes[0]), ''), package=None)
+        model_hash = hashlib.md5(open(model_path,'rb').read()).hexdigest()
+        param_name ,model_params_d = _get_name_params(model_path , model_hash)
+
+        mp = ModelParameters(model_params_d)
+        model = nets.CascadedASPPNet(mp.param['bins'] * 2)
+        cpk = torch.load( model_path , map_location='cpu')  
+        model.load_state_dict(cpk)
+        model.eval()
+        if(is_half==True):model = model.half().to(device)
+        else:model = model.to(device)
+
+        self.mp = mp
+        self.model = model
+
+    def _path_audio_(self, music_file ,ins_root=None,vocal_root=None):
+        if(ins_root is None and vocal_root is None):return "No save root."
+        name=os.path.basename(music_file)
+        if(ins_root is not None):os.makedirs(ins_root, exist_ok=True)
+        if(vocal_root is not None):os.makedirs(vocal_root , exist_ok=True)
+        X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
+        bands_n = len(self.mp.param['band'])
+        # print(bands_n)
+        for d in range(bands_n, 0, -1): 
+            bp = self.mp.param['band'][d]
+            if d == bands_n: # high-end band
+                X_wave[d], _ = librosa.core.load(
+                    music_file, bp['sr'], False, dtype=np.float32, res_type=bp['res_type'])
+                if X_wave[d].ndim == 1:
+                    X_wave[d] = np.asfortranarray([X_wave[d], X_wave[d]])
+            else: # lower bands
+                X_wave[d] = librosa.core.resample(X_wave[d+1], self.mp.param['band'][d+1]['sr'], bp['sr'], res_type=bp['res_type'])
+            # Stft of wave source
+            X_spec_s[d] = spec_utils.wave_to_spectrogram_mt(X_wave[d], bp['hl'], bp['n_fft'], self.mp.param['mid_side'], self.mp.param['mid_side_b2'], self.mp.param['reverse'])
+            # pdb.set_trace()
+            if d == bands_n and self.data['high_end_process'] != 'none':
+                input_high_end_h = (bp['n_fft']//2 - bp['crop_stop']) + ( self.mp.param['pre_filter_stop'] - self.mp.param['pre_filter_start'])
+                input_high_end = X_spec_s[d][:, bp['n_fft']//2-input_high_end_h:bp['n_fft']//2, :]
+
+        X_spec_m = spec_utils.combine_spectrograms(X_spec_s, self.mp)
+        aggresive_set = float(self.data['agg']/100)
+        aggressiveness = {'value': aggresive_set, 'split_bin': self.mp.param['band'][1]['crop_stop']}
+        with torch.no_grad():
+            pred, X_mag, X_phase = inference(X_spec_m,self.device,self.model, aggressiveness,self.data)
+        # Postprocess
+        if self.data['postprocess']:
+            pred_inv = np.clip(X_mag - pred, 0, np.inf)
+            pred = spec_utils.mask_silence(pred, pred_inv)
+        y_spec_m = pred * X_phase
+        v_spec_m = X_spec_m - y_spec_m
+
+        if (ins_root is not None):
+            if self.data['high_end_process'].startswith('mirroring'):
+                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'], y_spec_m, input_high_end, self.mp)
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp,input_high_end_h, input_high_end_)
+            else:
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp)
+            print ('%s instruments done'%name)
+            wavfile.write(os.path.join(ins_root, 'instrument_{}.wav'.format(name) ), self.mp.param['sr'], (np.array(wav_instrument)*32768).astype("int16"))  #
+        if (vocal_root is not None):
+            if self.data['high_end_process'].startswith('mirroring'):
+                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'],  v_spec_m, input_high_end, self.mp)
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp, input_high_end_h, input_high_end_)
+            else:
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp)
+            print ('%s vocals done'%name)
+            wavfile.write(os.path.join(vocal_root , 'vocal_{}.wav'.format(name) ), self.mp.param['sr'], (np.array(wav_vocals)*32768).astype("int16"))
+
+if __name__ == '__main__':
+    device = 'cuda'
+    is_half=True
+    model_path='uvr5_weights/2_HP-UVR.pth'
+    pre_fun = _audio_pre_(model_path=model_path,device=device,is_half=True)
+    audio_path = 'audio.aac'
+    save_path = 'opt'
+    pre_fun._path_audio_(audio_path , save_path,save_path)

test_dataset.py

@@ -0,0 +1,90 @@
+import pandas as pd
+import os
+from pydub import AudioSegment
+
+from nltk.tokenize import TweetTokenizer
+word_tokenize = TweetTokenizer().tokenize
+
+from gemini_normalize import call_api
+
+import phonemizer
+global_phonemizer = phonemizer.backend.EspeakBackend(language='vi', preserve_punctuation=True,  with_stress=True,language_switch='remove-flags',words_mismatch='ignore')
+
+def has_numbers(inputString):
+    return any(char.isdigit() for char in inputString)
+def generate(root_path,parquet_file):
+    total_duration = 0
+
+    df = pd.read_parquet(root_path+"/"+parquet_file, engine='fastparquet')
+    new_df = pd.DataFrame(columns=['audio.path', 'text','speaker_id'])
+    for index, row in df.iterrows():
+        if index < 3000:
+            continue
+        file= df.loc[index, 'audio.path']
+        text = df.loc[index, 'text']
+
+        audio = AudioSegment.from_wav(file)
+        if len(audio)/1000.0>2:
+            total_duration += len(audio)
+            new_df = new_df.append({'audio.path':file,'text':text,'speaker_id':0},ignore_index=True)
+
+
+        if total_duration/(1000*60*6)>=1:
+            print(new_df.head())
+            new_df =new_df.reset_index(drop=True)
+            new_df.to_parquet(root_path+"/"+"Xanh24h_1h_test.parquet", engine='fastparquet')
+            break
+
+
+def normalize_text(parquet_file):
+    df = pd.read_parquet(parquet_file, engine='fastparquet')
+    req = []
+    print(df.shape[0]-1)
+    dem = 0
+    for index, row in df.iterrows():
+        text = df.loc[index, 'text']
+        req.append(text)
+        # print(index)
+        if len(req)==50 or index == df.shape[0]-1:
+            res = call_api(str(req))
+
+            for idx,r in enumerate(res):
+                df.loc[50*dem+idx, 'normal_text'] = r
+            dem+=1
+            req = []
+    for index, row in df.iterrows():
+        if has_numbers(df.loc[index, 'normal_text']):
+            print("has number",df.loc[index, 'normal_text'])
+        elif df.loc[index, 'normal_text'] != df.loc[index, 'text'] and  not has_numbers(df.loc[index, 'text']):
+            print(df.loc[index, 'normal_text'])
+            print(df.loc[index, 'text'])
+            df.loc[index, 'normal_text'] = df.loc[index, 'text']
+    df.to_parquet(parquet_file, engine='fastparquet')
+
+def word_process(parquet_path):
+    df = pd.read_parquet(parquet_path, engine='fastparquet')
+    for index, row in df.iterrows():
+        text = df.loc[index, 'normal_text']
+
+        text = word_tokenize(text)
+        text = ' '.join(text)
+
+        ps = global_phonemizer.phonemize([text])
+
+        df.loc[index, 'phonemes'] = ps[0]
+
+    df.to_parquet(parquet_path, engine='fastparquet')
+
+def copy_audio(parquet_file):
+    import shutil
+    df = pd.read_parquet(parquet_file, engine='fastparquet')
+    for index, row in df.iterrows():
+        file= df.loc[index, 'audio.path']
+        shutil.copy2(file, file.replace("dataset","data"))
+if __name__ == "__main__":
+    # generate("dataset","Xanh24h.parquet")
+    # normalize_text("dataset/Xanh24h_1h_test.parquet")
+    # read("dataset/Xanh24h_1h.parquet")
+    # word_process("dataset/Xanh24h_1h_test.parquet")
+    # copy_audio("dataset/Xanh24h_1h_test.parquet")
+    pass

text_nomalize.py

@@ -0,0 +1,128 @@
+import pandas as pd
+
+from nltk.tokenize import TweetTokenizer
+from nltk.tokenize.treebank import TreebankWordDetokenizer
+word_tokenize = TweetTokenizer().tokenize
+
+from converters.Date import DateVietnamese
+from converters.Time import Time
+from converters.Money import Money
+from converters.Fraction import Fraction
+from converters.Telephone import TelephoneVietnamese
+from converters.Cardinal import CardinalVietnamese
+from converters.Decimal import Decimal
+from converters.Range import Range
+from converters.Meansure import Measure
+
+labels ={
+    'DATE': DateVietnamese(),
+    'TIME':Time(),
+    'MONEY':Money(),
+    'FRACTION':Fraction(),
+    'TELEPHONE':TelephoneVietnamese(),
+    'CARDINAL':CardinalVietnamese(),
+    'DECIMAL':Decimal(),
+    'RANGE' :Range(),
+    'MEANSURE': Measure()
+}
+def has_numbers(inputString):
+    return any(char.isdigit() for char in inputString)
+def has_date(inputString):
+    if "/" not in inputString:
+        return False
+    splt = inputString.split("/")
+    for i in splt:
+        if not i.isdigit():
+            return False
+    if len(splt) >3 :
+        return False
+    if len(splt) == 2:
+        month = int(splt[0])
+        year = int(splt[1])
+        if month >12 or year > 2200 or month <1:
+            return False
+    if len(splt)==3:
+        day =int(splt[0])
+        month = int(splt[1])
+        year =int(splt[2])
+        if day >31 or month > 12 or year >2200 or day < 1 or month <1:
+            return False
+    return True
+
+def is_time(text):
+    if ":" not in text:
+        return False
+    if "-" in text:
+        text = text[:-1]
+    splt = text.split(":")
+    if len(splt)>3 or '' in splt:
+        return False
+    elif len(splt)==2:
+        HH,MM = int(splt[0]),int(splt[1])
+        if HH >24 or MM >60:
+            return False
+    elif len(splt) ==3:
+        HH,MM,SS = int(splt[0]),int(splt[1]),int(splt[2])
+        if HH>24 or MM>60 or SS>100:
+            return False
+
+    return True
+def is_money(inputString):
+    return inputString.startswith(('$', '€', '£', '¥'))
+def is_fraction(inputString):
+    return "/" in inputString
+def is_decimal(inputString):
+    return "." in inputString
+def is_cardinal(inputString):
+    return "," in inputString or len(inputString) <= 3
+def is_range(inputString) :
+    return "-" in inputString
+def is_telephone(inputString):
+    if inputString.startswith(("19", "18", "0")) and len(inputString)>4:
+        return True
+def is_meansure(text):
+    if text in labels['MEANSURE'].custom_dict:
+        return True
+def normalize_single(text,previous=""):
+
+    if has_numbers(text):
+
+        if has_date(text):
+            text = labels["DATE"].convert_date(text)
+
+        elif is_time(text):
+            if text.endswith("-"):
+                kq = labels['TIME'].convert(text[:-1])
+                kq += " đến"
+            else:
+                kq = labels['TIME'].convert(text)
+            text =kq
+
+        elif is_money(text):
+            text = labels['MONEY'].convert(text)
+
+        elif is_decimal(text):
+            text = labels['DECIMAL'].convert(text)
+        elif is_telephone(text):
+            text =labels['TELEPHONE'].convert(text)
+        elif is_cardinal(text):
+            text = labels['CARDINAL'].convert(text)
+        elif is_range(text):
+            text = labels['RANGE'].convert(text)
+
+        if is_fraction(text):
+            text = labels['FRACTION'].convert(text)
+        if has_numbers(text):
+            text = labels['CARDINAL'].convert(text)
+
+    text = text.replace("%", " phần trăm ")
+    text = text.replace("&", " và ")
+    text = text.replace("°"," độ ")
+    return text
+if __name__ == "__main__":
+    v ="90000"
+    v =word_tokenize(v)
+    print(v)
+    for i in v:
+        te =normalize_single(i)
+        print(i, te)

upload_huggingface.py

@@ -0,0 +1,16 @@
+from huggingface_hub import HfApi
+from dotenv import load_dotenv
+load_dotenv()
+
+import os
+# Lấy giá trị token
+a =input()
+api = HfApi(token=a)
+print("load")
+
+api.upload_folder(
+    folder_path="",
+    repo_id="namkuner/Generate_Audio",
+    repo_type="model",
+
+)