Merge pull request #118 from tsukumijima/dev

音声合成時に読み上げテキストの読みを表す音素列を指定する機能を追加 + 様々な改善
2024-05-15 07:37:46 +09:00
parent ae7c4ea72b 44693e7d6b
commit 837c4397db
14 changed files with 567 additions and 200 deletions
--- a/style_bert_vits2/nlp/chinese/normalizer.py
+++ b/style_bert_vits2/nlp/chinese/normalizer.py
@@ -5,6 +5,41 @@ import cn2an
 from style_bert_vits2.nlp.symbols import PUNCTUATIONS


+__REPLACE_MAP = {
+    "：": ",",
+    "；": ",",
+    "，": ",",
+    "。": ".",
+    "！": "!",
+    "？": "?",
+    "\n": ".",
+    "·": ",",
+    "、": ",",
+    "...": "…",
+    "$": ".",
+    "“": "'",
+    "”": "'",
+    '"': "'",
+    "‘": "'",
+    "’": "'",
+    "（": "'",
+    "）": "'",
+    "(": "'",
+    ")": "'",
+    "《": "'",
+    "》": "'",
+    "【": "'",
+    "】": "'",
+    "[": "'",
+    "]": "'",
+    "—": "-",
+    "～": "-",
+    "~": "-",
+    "「": "'",
+    "」": "'",
+}
+
+
 def normalize_text(text: str) -> str:
    numbers = re.findall(r"\d+(?:\.?\d+)?", text)
    for number in numbers:
@@ -15,44 +50,10 @@ def normalize_text(text: str) -> str:

 def replace_punctuation(text: str) -> str:

-    REPLACE_MAP = {
-        "：": ",",
-        "；": ",",
-        "，": ",",
-        "。": ".",
-        "！": "!",
-        "？": "?",
-        "\n": ".",
-        "·": ",",
-        "、": ",",
-        "...": "…",
-        "$": ".",
-        "“": "'",
-        "”": "'",
-        '"': "'",
-        "‘": "'",
-        "’": "'",
-        "（": "'",
-        "）": "'",
-        "(": "'",
-        ")": "'",
-        "《": "'",
-        "》": "'",
-        "【": "'",
-        "】": "'",
-        "[": "'",
-        "]": "'",
-        "—": "-",
-        "～": "-",
-        "~": "-",
-        "「": "'",
-        "」": "'",
-    }
-
    text = text.replace("嗯", "恩").replace("呣", "母")
-    pattern = re.compile("|".join(re.escape(p) for p in REPLACE_MAP.keys()))
+    pattern = re.compile("|".join(re.escape(p) for p in __REPLACE_MAP.keys()))

-    replaced_text = pattern.sub(lambda x: REPLACE_MAP[x.group()], text)
+    replaced_text = pattern.sub(lambda x: __REPLACE_MAP[x.group()], text)

    replaced_text = re.sub(
        r"[^\u4e00-\u9fa5" + "".join(PUNCTUATIONS) + r"]+", "", replaced_text
--- a/style_bert_vits2/nlp/japanese/g2p.py
+++ b/style_bert_vits2/nlp/japanese/g2p.py
@@ -1,10 +1,11 @@
 import re
+from typing import TypedDict

 from style_bert_vits2.constants import Languages
 from style_bert_vits2.logging import logger
 from style_bert_vits2.nlp import bert_models
 from style_bert_vits2.nlp.japanese import pyopenjtalk_worker as pyopenjtalk
-from style_bert_vits2.nlp.japanese.mora_list import MORA_KATA_TO_MORA_PHONEMES
+from style_bert_vits2.nlp.japanese.mora_list import MORA_KATA_TO_MORA_PHONEMES, VOWELS
 from style_bert_vits2.nlp.japanese.normalizer import replace_punctuation
 from style_bert_vits2.nlp.symbols import PUNCTUATIONS

@@ -23,7 +24,7 @@ def g2p(
    Args:
        norm_text (str): 正規化されたテキスト
        use_jp_extra (bool, optional): False の場合、「ん」の音素を「N」ではなく「n」とする。Defaults to True.
-        raise_yomi_error (bool, optional): False の場合、読めない文字が消えたような扱いとして処理される。Defaults to False.
+        raise_yomi_error (bool, optional): False の場合、読めない文字が「'」として発音される。Defaults to False.

    Returns:
        tuple[list[str], list[int], list[int]]: 音素のリスト、アクセントのリスト、word2ph のリスト
@@ -38,8 +39,8 @@ def g2p(
    # punctuation がすべて消えた、音素とアクセントのタプルのリスト（「ん」は「N」）
    phone_tone_list_wo_punct = __g2phone_tone_wo_punct(norm_text)

-    # sep_text: 単語単位の単語のリスト、読めない文字があったら raise_yomi_error なら例外、そうでないなら読めない文字が消えて返ってくる
-    # sep_kata: 単語単位の単語のカタカナ読みのリスト
+    # sep_text: 単語単位の単語のリスト
+    # sep_kata: 単語単位の単語のカタカナ読みのリスト、読めない文字は raise_yomi_error=True なら例外、False なら読めない文字を「'」として返ってくる
    sep_text, sep_kata = text_to_sep_kata(norm_text, raise_yomi_error=raise_yomi_error)

    # sep_phonemes: 各単語ごとの音素のリストのリスト
@@ -103,7 +104,7 @@ def text_to_sep_kata(

    Args:
        norm_text (str): 正規化されたテキスト
-        raise_yomi_error (bool, optional): False の場合、読めない文字が消えたような扱いとして処理される。Defaults to False.
+        raise_yomi_error (bool, optional): False の場合、読めない文字が「'」として発音される。Defaults to False.

    Returns:
        tuple[list[str], list[str]]: 分割された単語リストと、その読み（カタカナ or 記号1文字）のリスト
@@ -137,12 +138,19 @@ def text_to_sep_kata(
            # word は正規化されているので、`.`, `,`, `!`, `'`, `-`, `--` のいずれか
            if not set(word).issubset(set(PUNCTUATIONS)):  # 記号繰り返しか判定
                # ここは pyopenjtalk が読めない文字等のときに起こる
+                ## 例外を送出する場合
                if raise_yomi_error:
                    raise YomiError(f"Cannot read: {word} in:\n{norm_text}")
-                logger.warning(f"Ignoring unknown: {word} in:\n{norm_text}")
-                continue
-            # yomi は元の記号のままに変更
-            yomi = word
+                ## 例外を送出しない場合
+                ## 読めない文字は「'」として扱う
+                logger.warning(
+                    f'Cannot read: {word} in:\n{norm_text}, replaced with "\'"'
+                )
+                # word の文字数分「'」を追加
+                yomi = "'" * len(word)
+            else:
+                # yomi は元の記号のままに変更
+                yomi = word
        elif yomi == "？":
            assert word == "?", f"yomi `？` comes from: {word}"
            yomi = "?"
@@ -152,6 +160,217 @@ def text_to_sep_kata(
    return sep_text, sep_kata


+def adjust_word2ph(
+    word2ph: list[int],
+    generated_phone: list[str],
+    given_phone: list[str],
+) -> list[int]:
+    """
+    `g2p()` で得られた `word2ph` を、generated_phone と given_phone の差分情報を使っていい感じに調整する。
+    generated_phone は正規化された読み上げテキストから生成された読みの情報だが、
+    given_phone で 同じ読み上げテキストに異なる読みが与えられた場合、正規化された読み上げテキストの各文字に
+    音素が何文字割り当てられるかを示す word2ph の合計値が given_phone の長さ (音素数) と一致しなくなりうる
+    そこで generated_phone と given_phone の差分を取り変更箇所に対応する word2ph の要素の値だけを増減させ、
+    アクセントへの影響を最低限に抑えつつ word2ph の合計値を given_phone の長さ (音素数) に一致させる。
+
+    Args:
+        word2ph (list[int]): 単語ごとの音素の数のリスト
+        generated_phone (list[str]): 生成された音素のリスト
+        given_phone (list[str]): 与えられた音素のリスト
+
+    Returns:
+        list[int]: 修正された word2ph のリスト
+    """
+
+    # word2ph・generated_phone・given_phone 全ての先頭と末尾にダミー要素が入っているので、処理の都合上それらを削除
+    # word2ph は先頭と末尾に 1 が入っている (返す際に再度追加する)
+    word2ph = word2ph[1:-1]
+    generated_phone = generated_phone[1:-1]
+    given_phone = given_phone[1:-1]
+
+    class DiffDetail(TypedDict):
+        begin_index: int
+        end_index: int
+        value: list[str]
+
+    class Diff(TypedDict):
+        generated: DiffDetail
+        given: DiffDetail
+
+    def extract_differences(
+        generated_phone: list[str], given_phone: list[str]
+    ) -> list[Diff]:
+        """
+        最長共通部分列を基にして、二つのリストの異なる部分を抽出する。
+        """
+
+        def longest_common_subsequence(
+            X: list[str], Y: list[str]
+        ) -> list[tuple[int, int]]:
+            """
+            二つのリストの最長共通部分列のインデックスのペアを返す。
+            """
+            m, n = len(X), len(Y)
+            L = [[0] * (n + 1) for _ in range(m + 1)]
+            # LCSの長さを構築
+            for i in range(1, m + 1):
+                for j in range(1, n + 1):
+                    if X[i - 1] == Y[j - 1]:
+                        L[i][j] = L[i - 1][j - 1] + 1
+                    else:
+                        L[i][j] = max(L[i - 1][j], L[i][j - 1])
+            # LCSを逆方向にトレースしてインデックスのペアを取得
+            index_pairs = []
+            i, j = m, n
+            while i > 0 and j > 0:
+                if X[i - 1] == Y[j - 1]:
+                    index_pairs.append((i - 1, j - 1))
+                    i -= 1
+                    j -= 1
+                elif L[i - 1][j] >= L[i][j - 1]:
+                    i -= 1
+                else:
+                    j -= 1
+            index_pairs.reverse()
+            return index_pairs
+
+        differences = []
+        common_indices = longest_common_subsequence(generated_phone, given_phone)
+        prev_x, prev_y = -1, -1
+
+        # 共通部分のインデックスを基にして差分を抽出
+        for x, y in common_indices:
+            diff_X = {
+                "begin_index": prev_x + 1,
+                "end_index": x,
+                "value": generated_phone[prev_x + 1 : x],
+            }
+            diff_Y = {
+                "begin_index": prev_y + 1,
+                "end_index": y,
+                "value": given_phone[prev_y + 1 : y],
+            }
+            if diff_X or diff_Y:
+                differences.append({"generated": diff_X, "given": diff_Y})
+            prev_x, prev_y = x, y
+        # 最後の非共通部分を追加
+        if prev_x < len(generated_phone) - 1 or prev_y < len(given_phone) - 1:
+            differences.append(
+                {
+                    "generated": {
+                        "begin_index": prev_x + 1,
+                        "end_index": len(generated_phone) - 1,
+                        "value": generated_phone[prev_x + 1 : len(generated_phone) - 1],
+                    },
+                    "given": {
+                        "begin_index": prev_y + 1,
+                        "end_index": len(given_phone) - 1,
+                        "value": given_phone[prev_y + 1 : len(given_phone) - 1],
+                    },
+                }
+            )
+        # generated.value と given.value の両方が空の要素を diffrences から削除
+        for diff in differences[:]:
+            if (
+                len(diff["generated"]["value"]) == 0
+                and len(diff["given"]["value"]) == 0
+            ):
+                differences.remove(diff)
+
+        return differences
+
+    # 二つのリストの差分を抽出
+    differences = extract_differences(generated_phone, given_phone)
+
+    # word2ph をもとにして新しく作る word2ph のリスト
+    ## 長さは word2ph と同じだが、中身は 0 で初期化されている
+    adjusted_word2ph: list[int] = [0] * len(word2ph)
+    # 現在処理中の generated_phone のインデックス
+    current_generated_index = 0
+
+    # word2ph の要素数 (=正規化された読み上げテキストの文字数) を維持しながら、差分情報を使って word2ph を修正
+    ## 音素数が generated_phone と given_phone で異なる場合にこの align_word2ph() が呼び出される
+    ## word2ph は正規化された読み上げテキストの文字数に対応しているので、要素数はそのまま given_phone で増減した音素数に合わせて各要素の値を増減する
+    for word2ph_element_index, word2ph_element in enumerate(word2ph):
+        # ここの word2ph_element は、正規化された読み上げテキストの各文字に割り当てられる音素の数を示す
+        # 例えば word2ph_element が 2 ならば、その文字には 2 つの音素 (例: "k", "a") が割り当てられる
+        # 音素の数だけループを回す
+        for _ in range(word2ph_element):
+            # difference の中に 処理中の generated_phone から始まる差分があるかどうかを確認
+            current_diff: Diff | None = None
+            for diff in differences:
+                if diff["generated"]["begin_index"] == current_generated_index:
+                    current_diff = diff
+                    break
+            # current_diff が None でない場合、generated_phone から始まる差分がある
+            if current_diff is not None:
+                # generated から given で変わった音素数の差分を取得 (2増えた場合は +2 だし、2減った場合は -2)
+                diff_in_phonemes = \
+                    len(current_diff["given"]["value"]) - len(current_diff["generated"]["value"])  # fmt: skip
+                # adjusted_word2ph[(読み上げテキストの各文字のインデックス)] に上記差分を反映
+                adjusted_word2ph[word2ph_element_index] += diff_in_phonemes
+            # adjusted_word2ph[(読み上げテキストの各文字のインデックス)] に処理が完了した分の音素として 1 を加える
+            adjusted_word2ph[word2ph_element_index] += 1
+            # 処理中の generated_phone のインデックスを進める
+            current_generated_index += 1
+
+    # この時点で given_phone の長さと adjusted_word2ph に記録されている音素数の合計が一致しているはず
+    assert len(given_phone) == sum(adjusted_word2ph), f"{len(given_phone)} != {sum(adjusted_word2ph)}"  # fmt: skip
+
+    # generated_phone から given_phone の間で音素が減った場合 (例: a, sh, i, t, a -> a, s, u) 、
+    # adjusted_word2ph の要素の値が 1 未満になることがあるので、1 になるように値を増やす
+    ## この時、adjusted_word2ph に記録されている音素数の合計を変えないために、
+    ## 値を 1 にした分だけ右隣の要素から増やした分の差分を差し引く
+    for adjusted_word2ph_element_index, adjusted_word2ph_element in enumerate(adjusted_word2ph):  # fmt: skip
+        # もし現在の要素が 1 未満ならば
+        if adjusted_word2ph_element < 1:
+            # 値を 1 にするためにどれだけ足せばいいかを計算
+            diff = 1 - adjusted_word2ph_element
+            # adjusted_word2ph[(読み上げテキストの各文字のインデックス)] を 1 にする
+            # これにより、当該文字に最低ラインとして 1 つの音素が割り当てられる
+            adjusted_word2ph[adjusted_word2ph_element_index] = 1
+            # 次の要素のうち、一番近くてかつ 1 以上の要素から diff を引く
+            # この時、diff を引いた結果引いた要素が 1 未満になる場合は、その要素の次の要素の中から一番近くてかつ 1 以上の要素から引く
+            # 上記を繰り返していって、diff が 0 になるまで続ける
+            for i in range(1, len(adjusted_word2ph)):
+                if adjusted_word2ph_element_index + i >= len(adjusted_word2ph):
+                    break  # adjusted_word2ph の最後に達した場合は諦める
+                if adjusted_word2ph[adjusted_word2ph_element_index + i] - diff >= 1:
+                    adjusted_word2ph[adjusted_word2ph_element_index + i] -= diff
+                    break
+                else:
+                    diff -= adjusted_word2ph[adjusted_word2ph_element_index + i] - 1
+                    adjusted_word2ph[adjusted_word2ph_element_index + i] = 1
+                    if diff == 0:
+                        break
+
+    # 逆に、generated_phone から given_phone の間で音素が増えた場合 (例: a, s, u -> a, sh, i, t, a) 、
+    # 1文字あたり7音素以上も割り当てられてしまう場合があるので、最大6音素にした上で削った分の差分を次の要素に加える
+    # 次の要素に差分を加えた結果7音素以上になってしまう場合は、その差分をさらに次の要素に加える
+    for adjusted_word2ph_element_index, adjusted_word2ph_element in enumerate(adjusted_word2ph):  # fmt: skip
+        if adjusted_word2ph_element > 6:
+            diff = adjusted_word2ph_element - 6
+            adjusted_word2ph[adjusted_word2ph_element_index] = 6
+            for i in range(1, len(adjusted_word2ph)):
+                if adjusted_word2ph_element_index + i >= len(adjusted_word2ph):
+                    break  # adjusted_word2ph の最後に達した場合は諦める
+                if adjusted_word2ph[adjusted_word2ph_element_index + i] + diff <= 6:
+                    adjusted_word2ph[adjusted_word2ph_element_index + i] += diff
+                    break
+                else:
+                    diff -= 6 - adjusted_word2ph[adjusted_word2ph_element_index + i]
+                    adjusted_word2ph[adjusted_word2ph_element_index + i] = 6
+                    if diff == 0:
+                        break
+
+    # この時点で given_phone の長さと adjusted_word2ph に記録されている音素数の合計が一致していない場合、
+    # 正規化された読み上げテキストと given_phone が著しく乖離していることを示す
+    # このとき、この関数の呼び出し元の get_text() にて InvalidPhoneError が送出される
+
+    # 最初に削除した前後のダミー要素を追加して返す
+    return [1] + adjusted_word2ph + [1]
+
+
 def __g2phone_tone_wo_punct(text: str) -> list[tuple[str, int]]:
    """
    テキストに対して、音素とアクセント（0か1）のペアのリストを返す。
@@ -209,15 +428,23 @@ def __g2phone_tone_wo_punct(text: str) -> list[tuple[str, int]]:
    return result


+__PYOPENJTALK_G2P_PROSODY_A1_PATTERN = re.compile(r"/A:([0-9\-]+)\+")
+__PYOPENJTALK_G2P_PROSODY_A2_PATTERN = re.compile(r"\+(\d+)\+")
+__PYOPENJTALK_G2P_PROSODY_A3_PATTERN = re.compile(r"\+(\d+)/")
+__PYOPENJTALK_G2P_PROSODY_E3_PATTERN = re.compile(r"!(\d+)_")
+__PYOPENJTALK_G2P_PROSODY_F1_PATTERN = re.compile(r"/F:(\d+)_")
+__PYOPENJTALK_G2P_PROSODY_P3_PATTERN = re.compile(r"\-(.*?)\+")
+
+
 def __pyopenjtalk_g2p_prosody(
    text: str, drop_unvoiced_vowels: bool = True
 ) -> list[str]:
    """
-    ESPnet の実装から引用、変更点無し。「ん」は「N」なことに注意。
+    ESPnet の実装から引用、概ね変更点無し。「ん」は「N」なことに注意。
    ref: https://github.com/espnet/espnet/blob/master/espnet2/text/phoneme_tokenizer.py
    ------------------------------------------------------------------------------------------

-    Extract phoneme + prosoody symbol sequence from input full-context labels.
+    Extract phoneme + prosody symbol sequence from input full-context labels.

    The algorithm is based on `Prosodic features control by symbols as input of
    sequence-to-sequence acoustic modeling for neural TTS`_ with some r9y9's tweaks.
@@ -238,8 +465,8 @@ def __pyopenjtalk_g2p_prosody(
        modeling for neural TTS`: https://doi.org/10.1587/transinf.2020EDP7104
    """

-    def _numeric_feature_by_regex(regex: str, s: str) -> int:
-        match = re.search(regex, s)
+    def _numeric_feature_by_regex(pattern: re.Pattern[str], s: str) -> int:
+        match = pattern.search(s)
        if match is None:
            return -50
        return int(match.group(1))
@@ -252,7 +479,7 @@ def __pyopenjtalk_g2p_prosody(
        lab_curr = labels[n]

        # current phoneme
-        p3 = re.search(r"\-(.*?)\+", lab_curr).group(1)  # type: ignore
+        p3 = __PYOPENJTALK_G2P_PROSODY_P3_PATTERN.search(lab_curr).group(1)  # type: ignore
        # deal unvoiced vowels as normal vowels
        if drop_unvoiced_vowels and p3 in "AEIOU":
            p3 = p3.lower()
@@ -264,7 +491,9 @@ def __pyopenjtalk_g2p_prosody(
                phones.append("^")
            elif n == N - 1:
                # check question form or not
-                e3 = _numeric_feature_by_regex(r"!(\d+)_", lab_curr)
+                e3 = _numeric_feature_by_regex(
+                    __PYOPENJTALK_G2P_PROSODY_E3_PATTERN, lab_curr
+                )
                if e3 == 0:
                    phones.append("$")
                elif e3 == 1:
@@ -277,14 +506,16 @@ def __pyopenjtalk_g2p_prosody(
            phones.append(p3)

        # accent type and position info (forward or backward)
-        a1 = _numeric_feature_by_regex(r"/A:([0-9\-]+)\+", lab_curr)
-        a2 = _numeric_feature_by_regex(r"\+(\d+)\+", lab_curr)
-        a3 = _numeric_feature_by_regex(r"\+(\d+)/", lab_curr)
+        a1 = _numeric_feature_by_regex(__PYOPENJTALK_G2P_PROSODY_A1_PATTERN, lab_curr)
+        a2 = _numeric_feature_by_regex(__PYOPENJTALK_G2P_PROSODY_A2_PATTERN, lab_curr)
+        a3 = _numeric_feature_by_regex(__PYOPENJTALK_G2P_PROSODY_A3_PATTERN, lab_curr)

        # number of mora in accent phrase
-        f1 = _numeric_feature_by_regex(r"/F:(\d+)_", lab_curr)
+        f1 = _numeric_feature_by_regex(__PYOPENJTALK_G2P_PROSODY_F1_PATTERN, lab_curr)

-        a2_next = _numeric_feature_by_regex(r"\+(\d+)\+", labels[n + 1])
+        a2_next = _numeric_feature_by_regex(
+            __PYOPENJTALK_G2P_PROSODY_A2_PATTERN, labels[n + 1]
+        )
        # accent phrase border
        if a3 == 1 and a2_next == 1 and p3 in "aeiouAEIOUNcl":
            phones.append("#")
@@ -341,9 +572,6 @@ def __handle_long(sep_phonemes: list[list[str]]) -> list[list[str]]:
        list[list[str]]: 長音記号を処理した音素のリストのリスト
    """

-    # 母音の集合 (便宜上「ん」を含める)
-    VOWELS = {"a", "i", "u", "e", "o", "N"}
-
    for i in range(len(sep_phonemes)):
        if len(sep_phonemes[i]) == 0:
            # 空白文字等でリストが空の場合
@@ -369,6 +597,15 @@ def __handle_long(sep_phonemes: list[list[str]]) -> list[list[str]]:
    return sep_phonemes


+__KATAKANA_PATTERN = re.compile(r"[\u30A0-\u30FF]+")
+__MORA_PATTERN = re.compile(
+    "|".join(
+        map(re.escape, sorted(MORA_KATA_TO_MORA_PHONEMES.keys(), key=len, reverse=True))
+    )
+)
+__LONG_PATTERN = re.compile(r"(\w)(ー*)")
+
+
 def __kata_to_phoneme_list(text: str) -> list[str]:
    """
    原則カタカナの `text` を受け取り、それをそのままいじらずに音素記号のリストに変換。
@@ -391,23 +628,20 @@ def __kata_to_phoneme_list(text: str) -> list[str]:
    if set(text).issubset(set(PUNCTUATIONS)):
        return list(text)
    # `text` がカタカナ（`ー`含む）のみからなるかどうかをチェック
-    if re.fullmatch(r"[\u30A0-\u30FF]+", text) is None:
+    if __KATAKANA_PATTERN.fullmatch(text) is None:
        raise ValueError(f"Input must be katakana only: {text}")
-    sorted_keys = sorted(MORA_KATA_TO_MORA_PHONEMES.keys(), key=len, reverse=True)
-    pattern = "|".join(map(re.escape, sorted_keys))

    def mora2phonemes(mora: str) -> str:
-        cosonant, vowel = MORA_KATA_TO_MORA_PHONEMES[mora]
-        if cosonant is None:
+        consonant, vowel = MORA_KATA_TO_MORA_PHONEMES[mora]
+        if consonant is None:
            return f" {vowel}"
-        return f" {cosonant} {vowel}"
+        return f" {consonant} {vowel}"

-    spaced_phonemes = re.sub(pattern, lambda m: mora2phonemes(m.group()), text)
+    spaced_phonemes = __MORA_PATTERN.sub(lambda m: mora2phonemes(m.group()), text)

    # 長音記号「ー」の処理
-    long_pattern = r"(\w)(ー*)"
    long_replacement = lambda m: m.group(1) + (" " + m.group(1)) * len(m.group(2))  # type: ignore
-    spaced_phonemes = re.sub(long_pattern, long_replacement, spaced_phonemes)
+    spaced_phonemes = __LONG_PATTERN.sub(long_replacement, spaced_phonemes)

    return spaced_phonemes.strip().split(" ")

--- a/style_bert_vits2/nlp/japanese/g2p_utils.py
+++ b/style_bert_vits2/nlp/japanese/g2p_utils.py
@@ -1,5 +1,6 @@
 from style_bert_vits2.nlp.japanese.g2p import g2p
 from style_bert_vits2.nlp.japanese.mora_list import (
+    CONSONANTS,
    MORA_KATA_TO_MORA_PHONEMES,
    MORA_PHONEMES_TO_MORA_KATA,
 )
@@ -33,15 +34,6 @@ def phone_tone2kata_tone(phone_tone: list[tuple[str, int]]) -> list[tuple[str, i
        カタカナと音高のリスト。
    """

-    # 子音の集合
-    CONSONANTS = set(
-        [
-            consonant
-            for consonant, _ in MORA_KATA_TO_MORA_PHONEMES.values()
-            if consonant is not None
-        ]
-    )
-
    phone_tone = phone_tone[1:]  # 最初の("_", 0)を無視
    phones = [phone for phone, _ in phone_tone]
    tones = [tone for _, tone in phone_tone]
--- a/style_bert_vits2/nlp/japanese/mora_list.py
+++ b/style_bert_vits2/nlp/japanese/mora_list.py
@@ -234,3 +234,15 @@ MORA_KATA_TO_MORA_PHONEMES: dict[str, tuple[Optional[str], str]] = {
    kana: (consonant, vowel)
    for [kana, consonant, vowel] in __MORA_LIST_MINIMUM + __MORA_LIST_ADDITIONAL
 }
+
+# 子音の集合
+CONSONANTS = set(
+    [
+        consonant
+        for consonant, _ in MORA_KATA_TO_MORA_PHONEMES.values()
+        if consonant is not None
+    ]
+)
+
+# 母音の集合 (便宜上「ん」を含める)
+VOWELS = {"a", "i", "u", "e", "o", "N"}
--- a/style_bert_vits2/nlp/japanese/normalizer.py
+++ b/style_bert_vits2/nlp/japanese/normalizer.py
@@ -6,6 +6,81 @@ from num2words import num2words
 from style_bert_vits2.nlp.symbols import PUNCTUATIONS


+# 記号類の正規化マップ
+__REPLACE_MAP = {
+    "：": ",",
+    "；": ",",
+    "，": ",",
+    "。": ".",
+    "！": "!",
+    "？": "?",
+    "\n": ".",
+    "．": ".",
+    "…": "...",
+    "···": "...",
+    "・・・": "...",
+    "·": ",",
+    "・": ",",
+    "、": ",",
+    "$": ".",
+    "“": "'",
+    "”": "'",
+    '"': "'",
+    "‘": "'",
+    "’": "'",
+    "（": "'",
+    "）": "'",
+    "(": "'",
+    ")": "'",
+    "《": "'",
+    "》": "'",
+    "【": "'",
+    "】": "'",
+    "[": "'",
+    "]": "'",
+    # NFKC 正規化後のハイフン・ダッシュの変種を全て通常半角ハイフン - \u002d に変換
+    "\u02d7": "\u002d",  # ˗, Modifier Letter Minus Sign
+    "\u2010": "\u002d",  # ‐, Hyphen,
+    # "\u2011": "\u002d",  # ‑, Non-Breaking Hyphen, NFKC により \u2010 に変換される
+    "\u2012": "\u002d",  # ‒, Figure Dash
+    "\u2013": "\u002d",  # –, En Dash
+    "\u2014": "\u002d",  # —, Em Dash
+    "\u2015": "\u002d",  # ―, Horizontal Bar
+    "\u2043": "\u002d",  # ⁃, Hyphen Bullet
+    "\u2212": "\u002d",  # −, Minus Sign
+    "\u23af": "\u002d",  # ⎯, Horizontal Line Extension
+    "\u23e4": "\u002d",  # ⏤, Straightness
+    "\u2500": "\u002d",  # ─, Box Drawings Light Horizontal
+    "\u2501": "\u002d",  # ━, Box Drawings Heavy Horizontal
+    "\u2e3a": "\u002d",  # ⸺, Two-Em Dash
+    "\u2e3b": "\u002d",  # ⸻, Three-Em Dash
+    # "～": "-",  # これは長音記号「ー」として扱うよう変更
+    # "~": "-",  # これも長音記号「ー」として扱うよう変更
+    "「": "'",
+    "」": "'",
+}
+# 記号類の正規化パターン
+__REPLACE_PATTERN = re.compile("|".join(re.escape(p) for p in __REPLACE_MAP.keys()))
+# 句読点等の正規化パターン
+__PUNCTUATION_CLEANUP_PATTERN = re.compile(
+    # ↓ ひらがな、カタカナ、漢字
+    r"[^\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF\u3400-\u4DBF\u3005"
+    # ↓ 半角アルファベット（大文字と小文字）
+    + r"\u0041-\u005A\u0061-\u007A"
+    # ↓ 全角アルファベット（大文字と小文字）
+    + r"\uFF21-\uFF3A\uFF41-\uFF5A"
+    # ↓ ギリシャ文字
+    + r"\u0370-\u03FF\u1F00-\u1FFF"
+    # ↓ "!", "?", "…", ",", ".", "'", "-", 但し`…`はすでに`...`に変換されている
+    + "".join(PUNCTUATIONS) + r"]+",  # fmt: skip
+)
+# 数字・通貨記号の正規化パターン
+__CURRENCY_MAP = {"$": "ドル", "¥": "円", "£": "ポンド", "€": "ユーロ"}
+__CURRENCY_PATTERN = re.compile(r"([$¥£€])([0-9.]*[0-9])")
+__NUMBER_PATTERN = re.compile(r"[0-9]+(\.[0-9]+)?")
+__NUMBER_WITH_SEPARATOR_PATTERN = re.compile("[0-9]{1,3}(,[0-9]{3})+")
+
+
 def normalize_text(text: str) -> str:
    """
    日本語のテキストを正規化する。
@@ -62,80 +137,11 @@ def replace_punctuation(text: str) -> str:
        str: 正規化されたテキスト
    """

-    # 記号類の正規化変換マップ
-    REPLACE_MAP = {
-        "：": ",",
-        "；": ",",
-        "，": ",",
-        "。": ".",
-        "！": "!",
-        "？": "?",
-        "\n": ".",
-        "．": ".",
-        "…": "...",
-        "···": "...",
-        "・・・": "...",
-        "·": ",",
-        "・": ",",
-        "、": ",",
-        "$": ".",
-        "“": "'",
-        "”": "'",
-        '"': "'",
-        "‘": "'",
-        "’": "'",
-        "（": "'",
-        "）": "'",
-        "(": "'",
-        ")": "'",
-        "《": "'",
-        "》": "'",
-        "【": "'",
-        "】": "'",
-        "[": "'",
-        "]": "'",
-        # NFKC 正規化後のハイフン・ダッシュの変種を全て通常半角ハイフン - \u002d に変換
-        "\u02d7": "\u002d",  # ˗, Modifier Letter Minus Sign
-        "\u2010": "\u002d",  # ‐, Hyphen,
-        # "\u2011": "\u002d",  # ‑, Non-Breaking Hyphen, NFKC により \u2010 に変換される
-        "\u2012": "\u002d",  # ‒, Figure Dash
-        "\u2013": "\u002d",  # –, En Dash
-        "\u2014": "\u002d",  # —, Em Dash
-        "\u2015": "\u002d",  # ―, Horizontal Bar
-        "\u2043": "\u002d",  # ⁃, Hyphen Bullet
-        "\u2212": "\u002d",  # −, Minus Sign
-        "\u23af": "\u002d",  # ⎯, Horizontal Line Extension
-        "\u23e4": "\u002d",  # ⏤, Straightness
-        "\u2500": "\u002d",  # ─, Box Drawings Light Horizontal
-        "\u2501": "\u002d",  # ━, Box Drawings Heavy Horizontal
-        "\u2e3a": "\u002d",  # ⸺, Two-Em Dash
-        "\u2e3b": "\u002d",  # ⸻, Three-Em Dash
-        # "～": "-",  # これは長音記号「ー」として扱うよう変更
-        # "~": "-",  # これも長音記号「ー」として扱うよう変更
-        "「": "'",
-        "」": "'",
-    }
-
-    pattern = re.compile("|".join(re.escape(p) for p in REPLACE_MAP.keys()))
-
    # 句読点を辞書で置換
-    replaced_text = pattern.sub(lambda x: REPLACE_MAP[x.group()], text)
+    replaced_text = __REPLACE_PATTERN.sub(lambda x: __REPLACE_MAP[x.group()], text)

-    replaced_text = re.sub(
-        # ↓ ひらがな、カタカナ、漢字
-        r"[^\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF\u3400-\u4DBF\u3005"
-        # ↓ 半角アルファベット（大文字と小文字）
-        + r"\u0041-\u005A\u0061-\u007A"
-        # ↓ 全角アルファベット（大文字と小文字）
-        + r"\uFF21-\uFF3A\uFF41-\uFF5A"
-        # ↓ ギリシャ文字
-        + r"\u0370-\u03FF\u1F00-\u1FFF"
-        # ↓ "!", "?", "…", ",", ".", "'", "-", 但し`…`はすでに`...`に変換されている
-        + "".join(PUNCTUATIONS) + r"]+",
-        # 上述以外の文字を削除
-        "",
-        replaced_text,
-    )
+    # 上述以外の文字を削除
+    replaced_text = __PUNCTUATION_CLEANUP_PATTERN.sub("", replaced_text)

    return replaced_text

@@ -151,13 +157,8 @@ def __convert_numbers_to_words(text: str) -> str:
        str: 変換されたテキスト
    """

-    NUMBER_WITH_SEPARATOR_PATTERN = re.compile("[0-9]{1,3}(,[0-9]{3})+")
-    CURRENCY_MAP = {"$": "ドル", "¥": "円", "£": "ポンド", "€": "ユーロ"}
-    CURRENCY_PATTERN = re.compile(r"([$¥£€])([0-9.]*[0-9])")
-    NUMBER_PATTERN = re.compile(r"[0-9]+(\.[0-9]+)?")
-
-    res = NUMBER_WITH_SEPARATOR_PATTERN.sub(lambda m: m[0].replace(",", ""), text)
-    res = CURRENCY_PATTERN.sub(lambda m: m[2] + CURRENCY_MAP.get(m[1], m[1]), res)
-    res = NUMBER_PATTERN.sub(lambda m: num2words(m[0], lang="ja"), res)
+    res = __NUMBER_WITH_SEPARATOR_PATTERN.sub(lambda m: m[0].replace(",", ""), text)
+    res = __CURRENCY_PATTERN.sub(lambda m: m[2] + __CURRENCY_MAP.get(m[1], m[1]), res)
+    res = __NUMBER_PATTERN.sub(lambda m: num2words(m[0], lang="ja"), res)

    return res