feat: add app.py

app.py

@@ -0,0 +1,349 @@
+import tempfile
+
+import gradio as gr
+import soundfile as sf
+import torchaudio
+from cached_path import cached_path
+from f5_tts.infer.utils_infer import (
+    infer_process,
+    load_model,
+    load_vocoder,
+    preprocess_ref_audio_text,
+    remove_silence_for_generated_wav,
+    save_spectrogram,
+)
+from f5_tts.model import DiT
+from omegaconf import OmegaConf
+
+from ipa.ipa import get_ipa, parse_ipa
+
+try:
+    import spaces
+
+    USING_SPACES = True
+except ImportError:
+    USING_SPACES = False
+
+
+def gpu_decorator(func):
+    if USING_SPACES:
+        return spaces.GPU(func)
+    else:
+        return func
+
+
+vocoder = load_vocoder()
+
+
+def load_f5tts(ckpt_path, vocab_path):
+    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)
+
+
+OmegaConf.register_new_resolver("load_f5tts", load_f5tts)
+
+models_config = OmegaConf.to_object(OmegaConf.load("configs/models.yaml"))
+dialects = OmegaConf.to_object(OmegaConf.load("configs/dialects.yaml"))
+
+
+DEFAULT_MODEL_ID = list(models_config.keys())[0]
+DEFAULT_DIALECT = list(dialects.values())[0]
+
+
+@gpu_decorator
+def infer(
+    ref_audio_orig,
+    ref_text,
+    gen_text,
+    model,
+    remove_silence,
+    cross_fade_duration=0.15,
+    nfe_step=32,
+    fix_duration=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
+    )
+
+    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,
+        fix_duration=fix_duration,
+        show_info=show_info,
+        progress=gr.Progress(),
+    )
+
+    # 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, _ = torchaudio.load(f.name)
+        final_wave = final_wave.squeeze().cpu().numpy()
+
+    print(f"Final wave duration: {final_wave.shape[0] / final_sample_rate:.2f}s")
+    # 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
+
+
+demo = gr.Blocks(
+    title="臺灣客語語音生成系統",
+    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",
+        )
+    ),
+)
+
+with demo:
+    gr.Markdown(
+        """
+        # 臺灣客語語音合成系統
+        ### Taiwanese Hakka Text-to-Speech System
+        ### 研發團隊
+        - **[李鴻欣 Hung-Shin Lee](mailto:hungshinlee@gmail.com)（[聯和科創](https://www.104.com.tw/company/1a2x6bmu75)）**
+        - **[陳力瑋 Li-Wei Chen](mailto:wayne900619@gmail.com)（[聯和科創](https://www.104.com.tw/company/1a2x6bmu75)）**
+        ### 合作單位
+        - **[國立聯合大學智慧客家實驗室](https://www.gohakka.org)**
+        """
+    )
+    with gr.Row():
+        with gr.Column():
+            model_drop_down = gr.Dropdown(
+                models_config.keys(),
+                value=DEFAULT_MODEL_ID,
+                label="模型",
+            )
+
+            ref_audio_input = gr.Audio(
+                type="filepath",
+                waveform_options=gr.WaveformOptions(
+                    sample_rate=24000,
+                ),
+                label="Reference Audio",
+            )
+            ref_text_input = gr.Textbox(
+                value="",
+                label="Reference Text",
+            )
+
+            ref_dialect_radio = gr.Radio(
+                choices=[(k, v) for k, v in dialects.items()],
+                value=DEFAULT_DIALECT,
+                label="ref 腔調",
+                interactive=len(dialects.keys()) > 1,
+            )
+
+            gen_text_input = gr.Textbox(
+                label="Text to Generate",
+                value="",
+            )
+
+            dialect_radio = gr.Radio(
+                choices=[(k, v) for k, v in dialects.items()],
+                value=DEFAULT_DIALECT,
+                label="腔調",
+                interactive=len(dialects.keys()) > 1,
+            )
+
+            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_audio_input: str,
+        ref_text_input: str,
+        ref_dialect_radio: str,
+        gen_text_input: str,
+        dialect_radio: str,
+        remove_silence: bool,
+        cross_fade_duration_slider: float,
+        nfe_slider: int,
+        speed_slider: float,
+    ):
+        ref_audio_info = torchaudio.info(ref_audio_input)
+        ref_duration = ref_audio_info.num_frames / ref_audio_info.sample_rate
+        target_duration = (
+            ref_duration
+            * len(gen_text_input.replace(" ", ""))
+            / len(ref_text_input.replace(" ", ""))
+            / speed_slider
+        )
+        print(f"Reference duration: {ref_duration}")
+        print(f"Target duration: {target_duration}")
+        if len(ref_text_input) == 0:
+            raise gr.Error("請勿輸入空字串。")
+        words, ipa, pinyin, missing_words = get_ipa(
+            ref_text_input, dialect=ref_dialect_radio
+        )
+        if len(missing_words) > 0:
+            raise gr.Error(
+                f"參考句子中的[{','.join(missing_words)}]目前無法轉成 ipa。請嘗試其他句子。"
+            )
+        ref_text_input = parse_ipa(ipa)
+
+        if len(gen_text_input) == 0:
+            raise gr.Error("請勿輸入空字串。")
+        words, ipa, pinyin, missing_words = get_ipa(
+            gen_text_input, dialect=dialect_radio
+        )
+        if len(missing_words) > 0:
+            raise gr.Error(
+                f"生成句子中的[{','.join(missing_words)}]目前無法轉成 ipa。請嘗試其他句子。"
+            )
+        gen_text_input = parse_ipa(ipa)
+
+        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,
+            fix_duration=ref_duration + target_duration,
+        )
+        return audio_out, spectrogram_path
+
+    generate_btn.click(
+        basic_tts,
+        inputs=[
+            model_drop_down,
+            ref_audio_input,
+            ref_text_input,
+            ref_dialect_radio,
+            gen_text_input,
+            dialect_radio,
+            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",
+            ],
+            # [
+            #     "預設語者",
+            #     "戴君儒",
+            #     "hailu",
+            #     "男女平等个時代，平平做得受教育",
+            # ],
+            # [
+            #     "預設語者",
+            #     "宋涵葳",
+            #     "dapu",
+            #     "客家山城乜跈緊鬧熱䟘來咧",
+            # ],
+            # [
+            #     "預設語者",
+            #     "江芮敏",
+            #     "raoping",
+            #     "頭擺匱人，戴个毋係菅草屋，个創商品哦",
+            # ],
+            # [
+            #     "預設語者",
+            #     "洪藝晅",
+            #     "zhaoan",
+            #     "歇熱个時務，阿松歸屋下轉去在客莊个老屋",
+            # ],
+            # [
+            #     "預設語者",
+            #     "江芮敏",
+            #     "nansixian",
+            #     "在𠊎讀小學一年生个時節，阿爸輒常用自轉車載𠊎去學校讀書",
+            # ],
+        ],
+        label="範例",
+        inputs=[
+            ref_audio_input,
+            ref_text_input,
+            ref_dialect_radio,
+            gen_text_input,
+            dialect_radio,
+        ],
+    )
+
+demo.launch()

configs/dialects.yaml

@@ -0,0 +1,2 @@
+四縣: sixian
+海陸: hailu

configs/ipa.yaml

@@ -0,0 +1,12 @@
+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}
+pinyin_to_ipa_dict: ${gh_download:FormoSpeech/FormoG2P, hakka/normalize/pinyin_to_ipa_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}

configs/models.yaml

@@ -0,0 +1,2 @@
+step-97614: ${load_f5tts:hf://formospeech/f5-tts-hakka-finetune/model_97614.safetensors,hf://formospeech/f5-tts-hakka-finetune/vocab.txt}
+step-195228: ${load_f5tts:hf://formospeech/f5-tts-hakka-finetune/model_195228.safetensors,hf://formospeech/f5-tts-hakka-finetune/vocab.txt}

ipa/__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)

ipa/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("[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("[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("([0-9]{4})[到至]([0-9]{4})年", num4year, text)
+    text = re.sub("([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)}")

ipa/ipa.py

@@ -0,0 +1,133 @@
+import os
+import re
+from pathlib import Path
+
+import jieba
+from omegaconf import OmegaConf
+
+from ipa.convert_digits import parse_num
+from ipa.proc_text import (
+    apply_v2f,
+    normalize_text,
+    prep_regex,
+    run_jieba,
+    update_jieba_dict,
+)
+
+ipa_configs = OmegaConf.to_object(OmegaConf.load("configs/ipa.yaml"))
+for key in ipa_configs["preserved_list"]:
+    ipa_configs["v2f_dict"].pop(key, None)
+delimiter_regex, replace_regex, v2f_regex = prep_regex(
+    ipa_configs["delimiter_list"], ipa_configs["replace_dict"], ipa_configs["v2f_dict"]
+)
+
+
+def get_ipa(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_ipa = []
+    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)
+            pinyin, tone = re.match(r"([a-z]+)(\d+)?", hanzi_or_pinyin).groups()
+            tone = f"_{tone}" if tone else ""
+
+            ipa = parse_pinyin_to_ipa(pinyin)
+            if ipa is None:
+                final_missing_words.append(pinyin)
+                continue
+
+            final_ipa.append(ipa + tone)
+        else:
+            words, ipa, pinyin, missing_words = parse_hanzi_to_ipa(
+                hanzi_or_pinyin, dialect
+            )
+            final_words.extend(words)
+            final_ipa.extend(ipa)
+            final_pinyin.extend(pinyin)
+            final_missing_words.extend(missing_words)
+
+    if len(final_ipa) == 0 or len(final_missing_words) > 0:
+        return final_words, final_ipa, final_pinyin, final_missing_words
+
+    final_words = " ".join(final_words).replace(" ， ", "，")
+    final_ipa = " ".join(final_ipa)
+    final_pinyin = " ".join(final_pinyin).replace(" ， ", "，")
+
+    return final_words, final_ipa, final_pinyin, final_missing_words
+
+
+def parse_ipa(ipa: str, delete_chars="\+\|", as_space="") -> list[str]:
+    text = []
+
+    ipa_list = re.split(r"(?<![\d])(?=[\d])|(?<=[\d])(?![\d])", ipa)
+    for word in ipa_list:
+        if word.isdigit():
+            phrases = text[-1].split("-")
+            for i, phrase in enumerate(phrases):
+                phrases[i] += word
+            text[-1] = "-".join(phrases)
+
+        else:
+            text.append(word)
+
+    text = "".join(text)
+    text = re.sub(f"[{delete_chars}]", "-", text)
+    text = text.replace("_", "")
+
+    return text
+
+
+def parse_pinyin_to_ipa(pinyin: str) -> str | None:
+    if pinyin not in ipa_configs["pinyin_to_ipa_dict"]:
+        return None
+
+    ipa_dict_result = ipa_configs["pinyin_to_ipa_dict"][pinyin]
+    ipa = "+".join(ipa_dict_result).replace(" ", "-")
+    return ipa
+
+
+def parse_hanzi_to_ipa(
+    hanzi: str, dialect: str
+) -> tuple[list[str], list[str], list[str], list[str]]:
+    lexicon = ipa_configs["lexicon"][dialect]
+    update_jieba_dict(
+        list(lexicon.keys()), Path(os.path.dirname(jieba.__file__)) / "dict.txt"
+    )
+
+    text = normalize_text(hanzi, ipa_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, ipa_configs["v2f_dict"], v2f_regex)
+    word_list = run_jieba("".join(word_list))
+
+    final_words = []
+    final_pinyin = []
+    final_ipa = []
+    missing_words = []
+    for word in word_list:
+        if not bool(word.strip()):
+            continue
+        if word == "，":
+            final_words.append("，")
+            final_pinyin.append("，")
+            final_ipa.append("，")
+        elif word not in lexicon:
+            final_words.append(word)
+            missing_words.append(word)
+        else:
+            final_words.append(f"{word}")
+            final_pinyin.append(lexicon[word]["pinyin"][0])
+            # NOTE 只有 lexicon[word] 中的第一個 ipa 才被考慮
+            final_ipa.append(lexicon[word]["ipa"][0])
+
+    return final_words, final_ipa, final_pinyin, missing_words

ipa/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("([\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("\x08", "", text)
+    text = re.sub("\ufeff", "", text)
+    text = re.sub("\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

requirements.txt

@@ -0,0 +1,3 @@
+omegaconf
+opencc
+git+https://github.com/SWivid/F5-TTS.git