feat: init hakka f5 tts

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,384 @@
+import re
+import tempfile
+from importlib.resources import files
+
+import gradio as gr
+import soundfile as sf
+import torch
+import torchcodec
+from cached_path import cached_path
+from omegaconf import OmegaConf
+from torchcodec.decoders import AudioDecoder
+
+from pinyin.pinyin import get_pinyin, pinyin_configs
+
+try:
+    import spaces
+
+    USING_SPACES = True
+except ImportError:
+    USING_SPACES = False
+
+from f5_tts.infer.utils_infer import (
+    device,
+    hop_length,
+    infer_process,
+    load_checkpoint,
+    load_vocoder,
+    mel_spec_type,
+    n_fft,
+    n_mel_channels,
+    ode_method,
+    preprocess_ref_audio_text,
+    remove_silence_for_generated_wav,
+    save_spectrogram,
+    target_sample_rate,
+    win_length,
+)
+from f5_tts.model import CFM, DiT
+from f5_tts.model.utils import get_tokenizer
+
+
+def gpu_decorator(func):
+    if USING_SPACES:
+        return spaces.GPU(func)
+    else:
+        return func
+
+
+vocoder = load_vocoder()
+
+
+def load_model(
+    model_cls,
+    model_cfg,
+    ckpt_path,
+    mel_spec_type=mel_spec_type,
+    vocab_file="",
+    ode_method=ode_method,
+    use_ema=True,
+    device=device,
+    fp16=False,
+):
+    if vocab_file == "":
+        vocab_file = str(files("f5_tts").joinpath("infer/examples/vocab.txt"))
+    tokenizer = "custom"
+
+    print("\nvocab : ", vocab_file)
+    print("token : ", tokenizer)
+    print("model : ", ckpt_path, "\n")
+
+    vocab_char_map, vocab_size = get_tokenizer(vocab_file, tokenizer)
+    model = CFM(
+        transformer=model_cls(
+            **model_cfg, text_num_embeds=vocab_size, mel_dim=n_mel_channels
+        ),
+        mel_spec_kwargs=dict(
+            n_fft=n_fft,
+            hop_length=hop_length,
+            win_length=win_length,
+            n_mel_channels=n_mel_channels,
+            target_sample_rate=target_sample_rate,
+            mel_spec_type=mel_spec_type,
+        ),
+        odeint_kwargs=dict(
+            method=ode_method,
+        ),
+        vocab_char_map=vocab_char_map,
+    ).to(device)
+
+    dtype = torch.float32 if mel_spec_type == "bigvgan" or not fp16 else None
+    model = load_checkpoint(model, ckpt_path, device, dtype=dtype, use_ema=use_ema)
+
+    return model
+
+
+def load_f5tts(ckpt_path, vocab_path, fp16=False):
+    ckpt_path = str(cached_path(ckpt_path))
+    F5TTS_model_cfg = dict(
+        dim=1024, depth=22, heads=16, ff_mult=2, text_dim=512, conv_layers=4
+    )
+    vocab_path = str(cached_path(vocab_path))
+    return load_model(
+        DiT,
+        F5TTS_model_cfg,
+        ckpt_path,
+        vocab_file=vocab_path,
+        use_ema=False,
+        fp16=fp16,
+    )
+
+
+OmegaConf.register_new_resolver("load_f5tts", load_f5tts)
+
+models_config = OmegaConf.to_object(OmegaConf.load("configs/models.yaml"))
+
+DEFAULT_MODEL_ID = list(models_config.keys())[0]
+DEFAULT_DIALECT = list(pinyin_configs["lexicon"].keys())[0]
+
+
+@gpu_decorator
+def infer(
+    ref_audio_orig,
+    ref_text,
+    gen_text,
+    model,
+    remove_silence=False,
+    cross_fade_duration=0.15,
+    nfe_step=32,
+    speed=1,
+    show_info=gr.Info,
+):
+    if not ref_audio_orig:
+        gr.Warning("Please provide reference audio.")
+        return gr.update(), gr.update(), ref_text
+
+    if not gen_text.strip():
+        gr.Warning("Please enter text to generate.")
+        return gr.update(), gr.update(), ref_text
+
+    ref_audio, ref_text = preprocess_ref_audio_text(
+        ref_audio_orig, ref_text, show_info=show_info
+    )
+
+    ref_duration = AudioDecoder(ref_audio).metadata.duration_seconds_from_header
+    ref_text_len = len(re.split(r"[， ]", ref_text)) + ref_text.count("，")
+    gen_text_len = len(re.split(r"[， ]", gen_text)) + gen_text.count("，")
+    target_duration = ref_duration + ref_duration * gen_text_len / ref_text_len / speed
+    print(target_duration)
+
+    final_wave, final_sample_rate, combined_spectrogram = infer_process(
+        ref_audio,
+        ref_text,
+        gen_text,
+        model,
+        vocoder,
+        cross_fade_duration=cross_fade_duration,
+        nfe_step=nfe_step,
+        speed=speed,
+        show_info=show_info,
+        progress=gr.Progress(),
+        fix_duration=target_duration,
+    )
+
+    # Remove silence
+    if remove_silence:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as f:
+            sf.write(f.name, final_wave, final_sample_rate)
+            remove_silence_for_generated_wav(f.name)
+            final_wave = torchcodec.decoders.AudioDecoder(f.name).get_all_samples().data
+        final_wave = final_wave.squeeze().cpu().numpy()
+
+    # Save the spectrogram
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_spectrogram:
+        spectrogram_path = tmp_spectrogram.name
+        save_spectrogram(combined_spectrogram, spectrogram_path)
+
+    return (final_sample_rate, final_wave), spectrogram_path
+
+
+def get_title():
+    with open("DEMO.md", encoding="utf-8") as tong:
+        return tong.readline().strip("# ")
+
+
+with gr.Blocks(
+    title="臺灣客語語音生成系統",
+) as demo:
+    gr.Markdown(
+        """
+        # 臺灣客語語音合成系統
+        ### Taiwanese Hakka Text-to-Speech System
+        ### 研發團隊
+        - **[李鴻欣 Hung-Shin Lee](mailto:hungshinlee@gmail.com)**
+        - **[陳力瑋 Li-Wei Chen](mailto:wayne900619@gmail.com)**
+        ### 合作單位
+        - **[國立聯合大學智慧客家實驗室](https://www.gohakka.org)**
+        """
+    )
+
+    with gr.Row():
+        with gr.Column():
+            model_drop_down = gr.Dropdown(
+                models_config.keys(),
+                value=DEFAULT_MODEL_ID,
+                label="模型",
+            )
+
+            ref_dialect_radio = gr.Radio(
+                choices=pinyin_configs["lexicon"].keys(),
+                value=DEFAULT_DIALECT,
+                label="ref 腔調",
+            )
+
+            ref_text_input = gr.Textbox(
+                value="",
+                label="Reference Text",
+            )
+
+            ref_audio_input = gr.Audio(
+                type="filepath",
+                waveform_options=gr.WaveformOptions(
+                    sample_rate=24000,
+                ),
+                label="Reference Audio",
+            )
+
+            gen_dialect_radio = gr.Radio(
+                choices=pinyin_configs["lexicon"].keys(),
+                value=DEFAULT_DIALECT,
+                label="gen 腔調",
+            )
+
+            gen_text_input = gr.Textbox(
+                label="Text to Generate",
+                value="",
+            )
+
+            generate_btn = gr.Button("Synthesize", variant="primary")
+
+            with gr.Accordion("Advanced Settings", open=False):
+                remove_silence = gr.Checkbox(
+                    label="Remove Silences",
+                    info="The model tends to produce silences, especially on longer audio. We can manually remove silences if needed. Note that this is an experimental feature and may produce strange results. This will also increase generation time.",
+                    value=False,
+                )
+                speed_slider = gr.Slider(
+                    label="Speed",
+                    minimum=0.3,
+                    maximum=2.0,
+                    value=1.0,
+                    step=0.1,
+                    info="語速（越小越慢）",
+                )
+                nfe_slider = gr.Slider(
+                    label="NFE Steps",
+                    minimum=4,
+                    maximum=64,
+                    value=32,
+                    step=2,
+                    info="Set the number of denoising steps.",
+                )
+                cross_fade_duration_slider = gr.Slider(
+                    label="Cross-Fade Duration (s)",
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.15,
+                    step=0.01,
+                    info="Set the duration of the cross-fade between audio clips.",
+                )
+        with gr.Column():
+            audio_output = gr.Audio(label="Synthesized Audio")
+            spectrogram_output = gr.Image(label="Spectrogram")
+
+    @gpu_decorator
+    def basic_tts(
+        model_drop_down: str,
+        ref_dialect_radio: str,
+        ref_audio_input: str,
+        ref_text_input: str,
+        gen_dialect_radio: str,
+        gen_text_input: str,
+        remove_silence: bool,
+        cross_fade_duration_slider: float,
+        nfe_slider: int,
+        speed_slider: float,
+    ):
+        ref_text_input = ref_text_input.strip()
+        if len(ref_text_input) == 0:
+            raise gr.Error("請勿輸入空字串。")
+
+        gen_text_input = gen_text_input.strip()
+        if len(gen_text_input) == 0:
+            raise gr.Error("請勿輸入空字串。")
+
+        words, pinyin, missing_words = get_pinyin(ref_text_input, ref_dialect_radio)
+        if len(missing_words) > 0:
+            raise gr.Error(
+                f"參考句子中的[{','.join(missing_words)}]目前無法轉成 pinyin。請嘗試其他句子。"
+            )
+        ref_text_input = pinyin
+
+        words, pinyin, missing_words = get_pinyin(gen_text_input, gen_dialect_radio)
+        if len(missing_words) > 0:
+            raise gr.Error(
+                f"生成句子中的[{','.join(missing_words)}]目前無法轉成 pinyin。請嘗試其他句子。"
+            )
+        gen_text_input = pinyin
+
+        audio_out, spectrogram_path = infer(
+            ref_audio_input,
+            ref_text_input,
+            gen_text_input,
+            models_config[model_drop_down],
+            remove_silence,
+            cross_fade_duration=cross_fade_duration_slider,
+            nfe_step=nfe_slider,
+            speed=speed_slider,
+        )
+        return audio_out, spectrogram_path
+
+    generate_btn.click(
+        basic_tts,
+        inputs=[
+            model_drop_down,
+            ref_dialect_radio,
+            ref_audio_input,
+            ref_text_input,
+            gen_dialect_radio,
+            gen_text_input,
+            remove_silence,
+            cross_fade_duration_slider,
+            nfe_slider,
+            speed_slider,
+        ],
+        outputs=[audio_output, spectrogram_output],
+    )
+
+    gr.Examples(
+        [
+            [
+                "./ref_wav/0000001_0.15-0.93.wav",
+                "恁早",
+                "sixian",
+                "食飯愛正經食，正毋會食到半出半入",
+                "sixian",
+            ],
+            [
+                "./ref_wav/0000002_0.15-2.73.wav",
+                "你今晡日著到恁派頭",
+                "sixian",
+                "食飯愛正經食，正毋會食到半出半入",
+                "sixian",
+            ],
+            [
+                "./ref_wav/0000002_0.15-2.73.wav",
+                "你今晡日著到恁派頭",
+                "sixian",
+                "歸條路吊等長長个花燈，祈求風調雨順，歸屋下人个心願，親像花燈下燒暖个光華",
+                "sixian",
+            ],
+        ],
+        label="範例",
+        inputs=[
+            ref_audio_input,
+            ref_text_input,
+            ref_dialect_radio,
+            gen_text_input,
+            gen_dialect_radio,
+        ],
+    )
+
+
+demo.launch(
+    css="@import url(https://tauhu.tw/tauhu-oo.css);",
+    theme=gr.themes.Default(
+        font=(
+            "tauhu-oo",
+            gr.themes.GoogleFont("Source Sans Pro"),
+            "ui-sans-serif",
+            "system-ui",
+            "sans-serif",
+        )
+    ),
+)

configs/models.yaml

@@ -0,0 +1 @@
+step-488070: ${load_f5tts:hf://formospeech/f5-tts-hita-finetune-v1/model_481032.safetensors,hf://formospeech/f5-tts-hita-finetune-v1/vocab.txt}

configs/pinyin.yaml

@@ -0,0 +1,11 @@
+delimiter_list: ${gh_download:FormoSpeech/FormoG2P, hakka/normalize/delimiters.json}
+replace_dict: ${gh_download:FormoSpeech/FormoG2P, hakka/normalize/replaced_words_htia.json}
+v2f_dict: ${gh_download:FormoSpeech/FormoG2P, [hakka/normalize/v2f_goyu.json, hakka/normalize/v2f_htia.json]}
+preserved_list: ${gh_download:FormoSpeech/FormoG2P, hakka/normalize/preserved_words_htia.json}
+lexicon:
+  sixian: ${gh_download:FormoSpeech/FormoG2P, hakka/sixian.json}
+  hailu: ${gh_download:FormoSpeech/FormoG2P, hakka/hailu.json}
+  dapu: ${gh_download:FormoSpeech/FormoG2P, hakka/dapu.json}
+  nansixian: ${gh_download:FormoSpeech/FormoG2P, hakka/nansixian.json}
+  raoping: ${gh_download:FormoSpeech/FormoG2P, hakka/raoping.json}
+  zhaoan: ${gh_download:FormoSpeech/FormoG2P, hakka/zhaoan.json}

pinyin/__init__.py

@@ -0,0 +1,27 @@
+import time
+
+import requests
+from omegaconf import OmegaConf
+
+
+def gh_download(repo, path):
+    paths = [path] if isinstance(path, str) else path
+    result = None
+    for path in paths:
+        url = f"https://raw.githubusercontent.com/{repo}/refs/heads/main/{path}"
+        response = requests.get(url)
+        if response.status_code != 200:
+            print(f"Status code: {response.status_code}")
+            raise Exception(f"Failed to download {path} from {repo}")
+
+        if result is None:
+            result = response.json()
+        elif isinstance(result, list):
+            result.extend(response.json())
+        elif isinstance(result, dict):
+            result.update(response.json())
+    time.sleep(0.5)
+    return result
+
+
+OmegaConf.register_new_resolver("gh_download", gh_download)

pinyin/convert_digits.py

@@ -0,0 +1,180 @@
+# Copyright 2024    Hung-Shin Lee (hungshinlee@gmail.com)
+# Apache 2.0
+
+import itertools
+import re
+
+c_basic = "零一二三四五六七八九"
+d2c = {str(d): c for d, c in enumerate(c_basic)}
+d2c["."] = "點"
+
+
+def num4year(matched):
+    def _num4year(num):
+        return "{}".format("".join([c_basic[int(i)] for i in num]))
+
+    matched_str = matched.group(0)
+    for m in matched.groups():
+        matched_str = matched_str.replace(m, _num4year(m))
+    return matched_str
+
+
+def num2chines_simple(matched):
+    return "{}".format("".join([d2c[i] for i in matched]))
+
+
+def num4percent(matched):
+    matched = matched.group(1)
+    return "百分之{}".format(num2chinese(matched[:-1]))
+
+
+def num4cellphone(matched):
+    matched = matched.group(1)
+    matched = matched.replace(" ", "").replace("-", "")
+    return "".join([c_basic[int(i)] for i in matched])
+
+
+def num4er(matched):  # 2 to 二
+    matched = matched.group(1)
+    return matched.replace("2", "二")
+
+
+def num4liang(matched):  # 2 to 兩
+    matched = matched.group(1)
+    return matched.replace("2", "兩")
+
+
+def num4general(matched):
+    num = matched.group(1)
+    if re.match(r"[A-Za-z-─]", num[0]):
+        if len(num[1:]) < 3:
+            # MP3 or F-16
+            return "{}{}".format(num[0], num2chinese(num[1:]))
+        else:
+            # AM104
+            return "{}{}".format(num[0], num2chines_simple(num[1:]))
+
+    else:
+        if re.match(r"[0-9]", num[0]):
+            return "{}".format(num2chinese(num))
+        else:
+            return "{}{}".format(num[0], num2chinese(num[1:]))
+
+
+def parse_num(text: str) -> str:
+    # year
+    text = re.sub(r"([0-9]{4})[到至]([0-9]{4})年", num4year, text)
+    text = re.sub(r"([0-9]{4})年", num4year, text)
+
+    # percentage
+    text = re.sub(r"([0-9]+\.?[0-9]?%)", num4percent, text)
+
+    # cellphone
+    text = re.sub(r"([0-9]{4}\s?-\s?[0-9]{6})", num4cellphone, text)
+
+    # single 2 to 二
+    text = re.sub(r"([^\d]2[診樓月號])", num4er, text)
+    text = re.sub(r"([初]2[^\d])", num4er, text)
+
+    # single 2 to 兩
+    text = re.sub(r"([^\d]2[^\d])", num4liang, text)
+
+    # general number
+    text = re.sub(r"([^0-9]?[0-9]+\.?[0-9]?)", num4general, text)
+
+    return text
+
+
+def num2chinese(num, big=False, simp=False, o=False, twoalt=True) -> str:
+    """
+    Converts numbers to Chinese representations.
+    https://gist.github.com/gumblex/0d65cad2ba607fd14de7
+    `big`   : use financial characters.
+    `simp`  : use simplified characters instead of traditional characters.
+    `o`     : use 〇 for zero.
+    `twoalt`: use 两/兩 for two when appropriate.
+    Note that `o` and `twoalt` is ignored when `big` is used,
+    and `twoalt` is ignored when `o` is used for formal representations.
+    """
+    # check num first
+    nd = str(num)
+    if abs(float(nd)) >= 1e48:
+        raise ValueError("number out of range")
+    elif "e" in nd:
+        raise ValueError("scientific notation is not supported")
+    c_symbol = "正负点" if simp else "正負點"
+    if o:  # formal
+        twoalt = False
+    if big:
+        c_basic = "零壹贰叁肆伍陆柒捌玖" if simp else "零壹貳參肆伍陸柒捌玖"
+        c_unit1 = "拾佰仟"
+        c_twoalt = "贰" if simp else "貳"
+    else:
+        c_basic = "〇一二三四五六七八九" if o else "零一二三四五六七八九"
+        c_unit1 = "十百千"
+        if twoalt:
+            c_twoalt = "两" if simp else "兩"
+        else:
+            c_twoalt = "二"
+    c_unit2 = "万亿兆京垓秭穰沟涧正载" if simp else "萬億兆京垓秭穰溝澗正載"
+
+    def revuniq(l):
+        return "".join(k for k, g in itertools.groupby(reversed(l)))
+
+    nd = str(num)
+    result = []
+    if nd[0] == "+":
+        result.append(c_symbol[0])
+    elif nd[0] == "-":
+        result.append(c_symbol[1])
+    if "." in nd:
+        integer, remainder = nd.lstrip("+-").split(".")
+    else:
+        integer, remainder = nd.lstrip("+-"), None
+    if int(integer):
+        splitted = [integer[max(i - 4, 0) : i] for i in range(len(integer), 0, -4)]
+        intresult = []
+        for nu, unit in enumerate(splitted):
+            # special cases
+            if int(unit) == 0:  # 0000
+                intresult.append(c_basic[0])
+                continue
+            elif nu > 0 and int(unit) == 2:  # 0002
+                intresult.append(c_twoalt + c_unit2[nu - 1])
+                continue
+            ulist = []
+            unit = unit.zfill(4)
+            for nc, ch in enumerate(reversed(unit)):
+                if ch == "0":
+                    if ulist:  # ???0
+                        ulist.append(c_basic[0])
+                elif nc == 0:
+                    ulist.append(c_basic[int(ch)])
+                elif nc == 1 and ch == "1" and all([i == "0" for i in unit[: nc + 1]]):
+                    # special case for tens
+                    # edit the 'elif' if you don't like
+                    # 十四, 三千零十四, 三千三百一十四
+                    ulist.append(c_unit1[0])
+                elif nc > 1 and ch == "2":
+                    ulist.append(c_twoalt + c_unit1[nc - 1])
+                else:
+                    ulist.append(c_basic[int(ch)] + c_unit1[nc - 1])
+            # print(ulist)
+            ustr = revuniq(ulist)
+            if nu == 0:
+                intresult.append(ustr)
+            else:
+                intresult.append(ustr + c_unit2[nu - 1])
+        result.append(revuniq(intresult).strip(c_basic[0]))
+    else:
+        result.append(c_basic[0])
+    if remainder:
+        result.append(c_symbol[2])
+        result.append("".join(c_basic[int(ch)] for ch in remainder))
+    return "".join(result)
+
+
+if __name__ == "__main__":
+    text = "若手機仔幾多號？吾手機仔係0964-498042。"
+
+    print(f"{text} -> {parse_num(text)}")

pinyin/pinyin.py

@@ -0,0 +1,90 @@
+import os
+import re
+from pathlib import Path
+
+import jieba
+from omegaconf import OmegaConf
+
+from pinyin.convert_digits import parse_num
+from pinyin.proc_text import (
+    apply_v2f,
+    normalize_text,
+    prep_regex,
+    run_jieba,
+    update_jieba_dict,
+)
+
+pinyin_configs = OmegaConf.to_object(OmegaConf.load("configs/pinyin.yaml"))
+for key in pinyin_configs["preserved_list"]:
+    pinyin_configs["v2f_dict"].pop(key, None)
+delimiter_regex, replace_regex, v2f_regex = prep_regex(
+    pinyin_configs["delimiter_list"],
+    pinyin_configs["replace_dict"],
+    pinyin_configs["v2f_dict"],
+)
+
+
+def get_pinyin(raw_text: str, dialect: str) -> tuple[str, str, str, list[str]]:
+    pinyin_split = re.split(r"([a-z]+\d+)", raw_text)
+
+    final_words = []
+    final_pinyin = []
+    final_missing_words = []
+    for hanzi_or_pinyin in pinyin_split:
+        if len(hanzi_or_pinyin.strip()) == 0:
+            continue
+
+        if re.search(r"[a-z]+\d+", hanzi_or_pinyin):
+            final_words.append(hanzi_or_pinyin)
+            final_pinyin.append(hanzi_or_pinyin)
+        else:
+            words, pinyin, missing_words = parse_hanzi_to_pinyin(
+                hanzi_or_pinyin, dialect
+            )
+            final_words.extend(words)
+            final_pinyin.extend(pinyin)
+            final_missing_words.extend(missing_words)
+
+    if len(final_pinyin) == 0 or len(final_missing_words) > 0:
+        return final_words, final_pinyin, final_missing_words
+
+    final_words = " ".join(final_words).replace(" ， ", "，")
+    final_pinyin = " ".join(final_pinyin).replace(" ， ", "，")
+
+    return final_words, final_pinyin, final_missing_words
+
+
+def parse_hanzi_to_pinyin(
+    hanzi: str, dialect: str
+) -> tuple[list[str], list[str], list[str], list[str]]:
+    lexicon = pinyin_configs["lexicon"][dialect]
+    update_jieba_dict(
+        list(lexicon.keys()), Path(os.path.dirname(jieba.__file__)) / "dict.txt"
+    )
+
+    text = normalize_text(hanzi, pinyin_configs["replace_dict"], replace_regex)
+    text = parse_num(text)
+    text_parts = [s.strip() for s in re.split(delimiter_regex, text) if s.strip()]
+    text = "，".join(text_parts)
+    word_list = run_jieba(text)
+    word_list = apply_v2f(word_list, pinyin_configs["v2f_dict"], v2f_regex)
+    word_list = run_jieba("".join(word_list))
+
+    final_words = []
+    final_pinyin = []
+    missing_words = []
+    for word in word_list:
+        if not bool(word.strip()):
+            continue
+        if word == "，":
+            final_words.append("，")
+            final_pinyin.append("，")
+        elif word not in lexicon:
+            final_words.append(word)
+            missing_words.append(word)
+        else:
+            final_words.append(f"{word}")
+            # NOTE 只有 lexicon[word] 中的第一個才被考慮
+            final_pinyin.append(lexicon[word]["pinyin"][0])
+
+    return final_words, final_pinyin, missing_words

pinyin/proc_text.py

@@ -0,0 +1,84 @@
+# Copyright 2024    Hung-Shin Lee (hungshinlee@gmail.com)
+# Apache 2.0
+
+import re
+from pathlib import Path
+from unicodedata import normalize
+
+import jieba
+import opencc
+
+jieba.setLogLevel(20)
+jieba.re_han_default = re.compile(r"([\u2e80-\U000e01efa-zA-Z0-9+#&\._%\-']+)", re.U)
+
+s2tw_converter = opencc.OpenCC("s2tw.json")
+
+
+def update_jieba_dict(
+    lexicon: list,
+    jieba_dict_path: Path,
+    high_freq_words: list = [],
+    high_freq_words_weight: int = 10,
+) -> list:
+    lexicon = sorted(set(lexicon))
+
+    jieba_dict_path.unlink(missing_ok=True)
+    Path("/tmp/jieba.cache").unlink(missing_ok=True)
+
+    with jieba_dict_path.open("w", encoding="utf-8") as file:
+        for word in lexicon:
+            if word in high_freq_words:
+                file.write(f"{word} {len(word) * high_freq_words_weight}\n")
+            else:
+                file.write(f"{word} {len(word)}\n")
+
+    jieba.dt.initialized = False
+
+    return lexicon
+
+
+def run_jieba(line: str) -> list:
+    # NOTE JIEBA 處理多行文本的結果會失去原本的行結構
+
+    seg_list = list(jieba.cut(line, cut_all=False, HMM=False))
+
+    return seg_list
+
+
+def normalize_text(text: str, replace_dict: dict, replace_regex: str) -> str:
+    def replace_match(match):
+        return replace_dict[match.group(0)]
+
+    text = re.sub(r"\x08", "", text)
+    text = re.sub(r"\ufeff", "", text)
+    text = re.sub(r"\u0010", "", text)
+    text = normalize("NFKC", text)
+    text = re.sub(replace_regex, replace_match, text)
+    text = " ".join(text.split()).upper()
+
+    return text
+
+
+def apply_v2f(word_list: list, v2f_dict: dict, v2f_regex: str) -> list:
+    result = []
+    for word in word_list:
+        result.append(re.sub(v2f_regex, lambda x: v2f_dict[x.group(0)], word))
+
+    return result
+
+
+def prep_regex(
+    delimiter_list: list, replace_dict: dict = {}, v2f_dict: dict = {}
+) -> tuple[str, str, str]:
+    delimiter_regex = "|".join(map(re.escape, delimiter_list))
+
+    replace_regex = ""
+    if len(replace_dict):
+        sorted_keys = sorted(replace_dict.keys(), key=len, reverse=True)
+        replace_regex = "|".join(map(re.escape, sorted_keys))
+
+    v2f_regex = ""
+    if len(v2f_dict):
+        v2f_regex = "|".join(map(re.escape, v2f_dict.keys()))
+
+    return delimiter_regex, replace_regex, v2f_regex

ref_wav/0000001_0.15-0.93.wav

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

ref_wav/0000002_0.15-2.73.wav

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

requirements.txt

@@ -0,0 +1,3 @@
+omegaconf
+opencc
+f5-tts