Migrasi penuh dari Blue-Archive/MOE-TTS via Colab

.gitattributes

@@ -33,3 +33,14 @@ 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
+chinese_dialect_lexicons/hangzhou.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/jiading.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/jyutjyu.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/ningbo.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/shaoxing.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/suzhou.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/tiantai.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/tongxiang.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/wuxi.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/yixing.ocd2 filter=lfs diff=lfs merge=lfs -text
+chinese_dialect_lexicons/zaonhe.ocd2 filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,227 @@
+import gradio as gr
+import os
+import torch
+import commons
+import utils
+from models import SynthesizerTrn
+import numpy as np
+import json
+import shutil
+import logging
+import random
+import re
+from huggingface_hub import snapshot_download
+
+# --- 1. SETUP LOGGING ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# --- 2. ROMAJI CONVERTER ---
+try:
+    import pykakasi
+    kks = pykakasi.kakasi()
+    def to_romaji(text):
+        if not text or text == "None": return ""
+        try:
+            result = kks.convert(str(text))
+            return "".join([item['hepburn'].capitalize() for item in result])
+        except:
+            return str(text)
+except:
+    def to_romaji(text): return str(text)
+
+# --- 3. CLEAN HARDCODED INFO ---
+CLEAN_INFO = {
+  "0": {"title": "Sanoba Witch & Senren Banka", "example": "こんにちは。", "type": "vits"},
+  "1": {"title": "Hamidashi Creative", "example": "こんにちは。", "type": "vits"},
+  "2": {"title": "Cafe Stella & Shinigami no Chou", "example": "こんにちは。", "type": "vits"},
+  "3": {"title": "Yosuga no Sora", "example": "こんにちは。", "type": "vits"},
+  "4": {"title": "Bishoujo Mangekyou", "example": "こんにちは。", "type": "vits"},
+  "5": {"title": "Nene & Nanami Pack (Multi)", "example": "[JA]こんにちは。[JA]", "type": "vits"},
+  "6": {"title": "The Fox Waiting for You", "example": "안녕하세요.", "type": "vits"},
+  "7": {"title": "Galgame Characters Pack (13)", "example": "こんにちは。", "type": "vits"},
+  "8": {"title": "Zero no Tsukaima", "example": "こんにちは。", "type": "vits"},
+  "9": {"title": "Zero no Tsukaima (VC Mode)", "example": "", "type": "soft-vits-vc"},
+  "10": {"title": "Toaru Majutsu no Index (VC)", "example": "", "type": "soft-vits-vc"},
+  "11": {"title": "Shiki Natsume (VC Mode)", "example": "", "type": "soft-vits-vc"},
+  "12": {"title": "DRACU-RIOT!", "example": "こんにちは。", "type": "vits"},
+  "13": {"title": "To LOVE-Ru Series", "example": "こんにちは。", "type": "vits"},
+  "14": {"title": "CJKS Multi-Language", "example": "[JA]こんにちは。[JA]", "type": "vits"},
+  "15": {"title": "Voistock Mega Pack (2891 Chars)", "example": "[JA]こんにちは。[JA]", "type": "vits"},
+  "16": {"title": "Shanghainese Dialect", "example": "侬好！", "type": "vits"},
+  "17": {"title": "Chinese Dialects Pack", "example": "[SH]侬好！[SH]", "type": "vits"},
+  "18": {"title": "Umamusume: Pretty Derby", "example": "こんにちは。", "type": "vits"},
+  "19": {"title": "Princess Connect! Re:Dive", "example": "[JA]こんにちは。[JA]", "type": "vits"},
+  "20": {"title": "Magia Record (Madoka Magica)", "example": "こんにちは。", "type": "vits"}
+}
+
+# --- 4. DOWNLOAD ASSETS ---
+REPO_ID = "Plana-Archive/Plana-TTS"
+LOCAL_ROOT = "saved_model"
+
+def download_assets():
+    os.makedirs(LOCAL_ROOT, exist_ok=True)
+    if not os.path.exists(os.path.join(LOCAL_ROOT, "0")):
+        try:
+            logger.info("Downloading Assets...")
+            snapshot_download(repo_id=REPO_ID, local_dir="temp_dir", allow_patterns=["MOE-TTS/saved_model/*"])
+            src_path = os.path.join("temp_dir", "MOE-TTS", "saved_model")
+            if os.path.exists(src_path):
+                shutil.copytree(src_path, LOCAL_ROOT, dirs_exist_ok=True)
+                shutil.rmtree("temp_dir")
+        except Exception as e:
+            logger.error(f"Download error: {e}")
+
+download_assets()
+
+# --- 5. ENGINE LOAD MODEL ---
+loaded_models = {}
+
+def clean_config(conf):
+    if isinstance(conf, dict): return {str(k): clean_config(v) for k, v in conf.items()}
+    elif isinstance(conf, list): return [clean_config(i) for i in conf]
+    return conf
+
+def get_vits_model(m_id):
+    mid = str(m_id)
+    if mid in loaded_models: return loaded_models[mid]
+    try:
+        p = os.path.join(LOCAL_ROOT, mid)
+        cfg_p = os.path.join(p, "config.json")
+        if not os.path.exists(cfg_p): return None
+        hps = utils.get_hparams_from_file(cfg_p)
+        m_params = clean_config(hps.model.__dict__ if hasattr(hps.model, '__dict__') else dict(hps.model))
+        net = SynthesizerTrn(len(hps.symbols), hps.data.filter_length // 2 + 1, hps.train.segment_size // hps.data.hop_length, n_speakers=hps.data.n_speakers, **m_params)
+        utils.load_checkpoint(os.path.join(p, "model.pth"), net, None)
+        net.eval()
+        raw_spks = hps.speakers if hasattr(hps, 'speakers') else [f"Character {i}" for i in range(hps.data.n_speakers)]
+        display_spks = []
+        for s in raw_spks:
+            romaji_name = to_romaji(s)
+            if romaji_name and romaji_name.lower() != "none":
+                display_spks.append(romaji_name)
+        loaded_models[mid] = (hps, net, display_spks)
+        return loaded_models[mid]
+    except Exception as e:
+        logger.error(f"Load Error {mid}: {e}")
+        return None
+
+def tts_execute(m_id, text, speaker_romaji, speed):
+    data = get_vits_model(m_id)
+    if not data: return "❌ Model Loading...", None
+    hps, net, display_spks = data
+    if not speaker_romaji: 
+        if display_spks:
+            speaker_romaji = display_spks[0]
+        else:
+            return "❌ No Speaker Selected", None
+    try:
+        sid = display_spks.index(speaker_romaji)
+        from text import text_to_sequence
+        clean_text = re.sub(r'\[[A-Z]{2}\]', '', text)
+        cleaners = hps.data.text_cleaners if hasattr(hps.data, 'text_cleaners') else ['japanese_cleaners']
+        seq = text_to_sequence(clean_text, hps.symbols, cleaners)
+        if hps.data.add_blank: seq = commons.intersperse(seq, 0)
+        with torch.no_grad():
+            audio = net.infer(torch.LongTensor(seq).unsqueeze(0), torch.LongTensor([len(seq)]), sid=torch.LongTensor([sid]), noise_scale=0.667, noise_scale_w=0.8, length_scale=1.0/speed)[0][0,0].data.cpu().float().numpy()
+        return f"✅ Done!", (hps.data.sampling_rate, (audio * 32767).astype(np.int16))
+    except Exception as e: return f"Error: {e}", None
+
+def get_random_jp():
+    return random.choice(["こんにちは！", "お元気ですか？", "先生、お疲れ様です！", "大好きだよ！", "また明日ね。"])
+
+# --- 6. UI STYLE ---
+css = """
+:root { --primary-600: #1299ff !important; --accent-600: #1299ff !important; --loader-color: #A2D2FF !important; }
+.slim-card { max-width: 480px; margin: 0 auto; background: white; border-radius: 20px; padding: 25px; box-shadow: 0 10px 30px rgba(0,0,0,0.05); }
+.ba-header { text-align: center; margin-bottom: 25px; border-bottom: 2px solid #f0f4f8; padding-bottom: 15px; }
+.ba-header h1 { color: #1299ff !important; font-weight: 800; font-size: 26px; margin: 0; }
+.ba-header p { color: #8a99af; font-size: 11px; font-weight: 700; letter-spacing: 2px; margin: 5px 0 0 0; }
+
+/* CSS UNTUK SCROLLABLE TABS */
+.tabs > .tab-nav {
+    display: flex !important;
+    overflow-x: auto !important;
+    white-space: nowrap !important;
+    flex-wrap: nowrap !important;
+    scrollbar-width: thin;
+    scrollbar-color: #1299ff #f0f4f8;
+}
+.tabs > .tab-nav::-webkit-scrollbar { height: 4px; }
+.tabs > .tab-nav::-webkit-scrollbar-thumb { background: #1299ff; border-radius: 10px; }
+.tabs > .tab-nav button { flex: 0 0 auto !important; }
+
+.scroll-box { height: 200px; overflow-y: auto; border: 1px solid #f0f4f8; border-radius: 12px; padding: 10px; background: #fafbfc; margin-bottom: 10px; }
+.char-btn { background: white !important; border: 1px solid #e2e8f0 !important; border-left: 5px solid #1299ff !important; text-align: left !important; padding: 8px !important; font-size: 12px !important; margin-bottom: 4px !important; width: 100%; color: #4a5568 !important; }
+.char-btn:hover { background: #f0f7ff !important; border-color: #1299ff !important; }
+.warning-card { background: #fff9f0; border: 1px solid #ffe4bc; border-radius: 10px; padding: 12px; margin-bottom: 15px; text-align: center; color: #855d1a; font-size: 11px; line-height: 1.5; }
+.jp-btn { background: #f8fafc !important; border: 1px solid #cbd5e1 !important; color: #475569 !important; font-weight: 700 !important; border-radius: 10px !important; margin-bottom: 10px; font-size: 12px !important; width: 100%; }
+.gen-btn { background: #1299ff !important; color: white !important; font-weight: 700 !important; border-radius: 12px !important; height: 45px !important; width: 100%; border: none !important; cursor: pointer; transition: 0.3s; }
+.gen-btn:hover { background: #0084ff !important; transform: translateY(-2px); box-shadow: 0 5px 15px rgba(18, 153, 255, 0.3); }
+.credit-footer { margin-top: 25px; padding: 15px; background: white; border-radius: 12px; text-align: center; border: 1px solid #eef2f6; border-bottom: 4px solid #1299ff; color: #94a3b8; font-weight: 700; font-size: 12px; letter-spacing: 2px; }
+"""
+
+with gr.Blocks(css=css) as demo:
+    with gr.Column(elem_classes="slim-card"):
+        gr.HTML("""
+            <div class="ba-header">
+                <h1>Library Anime TTS</h1>
+                <p>🍂 STYLE-BERT-VITS 🍂</p>
+            </div>
+        """)
+        
+        with gr.Tabs(elem_classes="tabs"):
+            for m_id in sorted(CLEAN_INFO.keys(), key=int):
+                with gr.Tab(f"Model {m_id}"):
+                    gr.Markdown(f"### 📂 {CLEAN_INFO[m_id]['title']}")
+                    
+                    m_data = get_vits_model(m_id)
+                    chars = m_data[2] if m_data else []
+                    
+                    m_p = os.path.join(LOCAL_ROOT, str(m_id))
+                    cov = next((os.path.join(m_p, f"cover.{e}") for e in ['png','jpg','jpeg','webp'] if os.path.exists(os.path.join(m_p, f"cover.{e}"))), None)
+                    if cov: gr.Image(cov, show_label=False, interactive=False, height=140)
+                    
+                    sel_name = gr.State("")
+                    char_display = gr.Markdown("📍 *Silakan pilih karakter...*")
+                    
+                    gr.HTML("<p style='font-weight:800; font-size:11px; color:#8a99af; margin-bottom:8px;'>CHARACTER LIST (ROMAJI)</p>")
+                    
+                    with gr.Column(elem_classes="scroll-box"):
+                        if not chars:
+                            gr.Markdown("⏳ Sedang memuat karakter...")
+                        else:
+                            for name in chars:
+                                btn = gr.Button(f"👤 {name}", elem_classes="char-btn")
+                                btn.click(
+                                    fn=lambda n=name: (n, f"📍 Selected: **{n}**"), 
+                                    outputs=[sel_name, char_display]
+                                )
+                    
+                    gr.HTML("""
+                        <div class="warning-card">
+                            <div style="font-weight:800; margin-bottom:4px;">🔖 PERINGATAN MINNA 🔖</div>
+                            Setelah di klik character nya akan Loading otomatis dan ke Select sendiri dan baru bisa di Gunakan! 
+                        </div>
+                    """)
+                    
+                    ex_text = re.sub(r'\[[A-Z]{2}\]', '', CLEAN_INFO[m_id].get("example", "こんにちは。"))
+                    txt_in = gr.TextArea(label="Input Text", value=ex_text, lines=3)
+                    gr.Button("🎲 INPUTS RANDOM TEXT 🎲", elem_classes="jp-btn").click(get_random_jp, outputs=[txt_in])
+                    
+                    spd = gr.Slider(0.5, 2.0, 1.0, step=0.1, label="Speed Audio")
+                    btn_gen = gr.Button("🎐 GENERATE VOICE 🎐", elem_classes="gen-btn")
+                    aud_out = gr.Audio(label="Voice Output")
+                    
+                    status_log = gr.Textbox(visible=False)
+                    
+                    btn_gen.click(
+                        fn=tts_execute, 
+                        inputs=[gr.State(m_id), txt_in, sel_name, spd], 
+                        outputs=[status_log, aud_out]
+                    )
+
+        gr.HTML("""<div class="credit-footer">🌥️ CREATED BY MUTSUMI 🌥️</div>""")
+
+if __name__ == "__main__":
+    demo.launch()

attentions.py

@@ -0,0 +1,300 @@
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import commons
+from modules import LayerNorm
+   
+
+class Encoder(nn.Module):
+  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **kwargs):
+    super().__init__()
+    self.hidden_channels = hidden_channels
+    self.filter_channels = filter_channels
+    self.n_heads = n_heads
+    self.n_layers = n_layers
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.window_size = window_size
+
+    self.drop = nn.Dropout(p_dropout)
+    self.attn_layers = nn.ModuleList()
+    self.norm_layers_1 = nn.ModuleList()
+    self.ffn_layers = nn.ModuleList()
+    self.norm_layers_2 = nn.ModuleList()
+    for i in range(self.n_layers):
+      self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
+      self.norm_layers_1.append(LayerNorm(hidden_channels))
+      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
+      self.norm_layers_2.append(LayerNorm(hidden_channels))
+
+  def forward(self, x, x_mask):
+    attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+    x = x * x_mask
+    for i in range(self.n_layers):
+      y = self.attn_layers[i](x, x, attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_1[i](x + y)
+
+      y = self.ffn_layers[i](x, x_mask)
+      y = self.drop(y)
+      x = self.norm_layers_2[i](x + y)
+    x = x * x_mask
+    return x
+
+
+class Decoder(nn.Module):
+  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
+    super().__init__()
+    self.hidden_channels = hidden_channels
+    self.filter_channels = filter_channels
+    self.n_heads = n_heads
+    self.n_layers = n_layers
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.proximal_bias = proximal_bias
+    self.proximal_init = proximal_init
+
+    self.drop = nn.Dropout(p_dropout)
+    self.self_attn_layers = nn.ModuleList()
+    self.norm_layers_0 = nn.ModuleList()
+    self.encdec_attn_layers = nn.ModuleList()
+    self.norm_layers_1 = nn.ModuleList()
+    self.ffn_layers = nn.ModuleList()
+    self.norm_layers_2 = nn.ModuleList()
+    for i in range(self.n_layers):
+      self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
+      self.norm_layers_0.append(LayerNorm(hidden_channels))
+      self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
+      self.norm_layers_1.append(LayerNorm(hidden_channels))
+      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
+      self.norm_layers_2.append(LayerNorm(hidden_channels))
+
+  def forward(self, x, x_mask, h, h_mask):
+    """
+    x: decoder input
+    h: encoder output
+    """
+    self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
+    encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+    x = x * x_mask
+    for i in range(self.n_layers):
+      y = self.self_attn_layers[i](x, x, self_attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_0[i](x + y)
+
+      y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_1[i](x + y)
+      
+      y = self.ffn_layers[i](x, x_mask)
+      y = self.drop(y)
+      x = self.norm_layers_2[i](x + y)
+    x = x * x_mask
+    return x
+
+
+class MultiHeadAttention(nn.Module):
+  def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
+    super().__init__()
+    assert channels % n_heads == 0
+
+    self.channels = channels
+    self.out_channels = out_channels
+    self.n_heads = n_heads
+    self.p_dropout = p_dropout
+    self.window_size = window_size
+    self.heads_share = heads_share
+    self.block_length = block_length
+    self.proximal_bias = proximal_bias
+    self.proximal_init = proximal_init
+    self.attn = None
+
+    self.k_channels = channels // n_heads
+    self.conv_q = nn.Conv1d(channels, channels, 1)
+    self.conv_k = nn.Conv1d(channels, channels, 1)
+    self.conv_v = nn.Conv1d(channels, channels, 1)
+    self.conv_o = nn.Conv1d(channels, out_channels, 1)
+    self.drop = nn.Dropout(p_dropout)
+
+    if window_size is not None:
+      n_heads_rel = 1 if heads_share else n_heads
+      rel_stddev = self.k_channels**-0.5
+      self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
+      self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
+
+    nn.init.xavier_uniform_(self.conv_q.weight)
+    nn.init.xavier_uniform_(self.conv_k.weight)
+    nn.init.xavier_uniform_(self.conv_v.weight)
+    if proximal_init:
+      with torch.no_grad():
+        self.conv_k.weight.copy_(self.conv_q.weight)
+        self.conv_k.bias.copy_(self.conv_q.bias)
+      
+  def forward(self, x, c, attn_mask=None):
+    q = self.conv_q(x)
+    k = self.conv_k(c)
+    v = self.conv_v(c)
+    
+    x, self.attn = self.attention(q, k, v, mask=attn_mask)
+
+    x = self.conv_o(x)
+    return x
+
+  def attention(self, query, key, value, mask=None):
+    # reshape [b, d, t] -> [b, n_h, t, d_k]
+    b, d, t_s, t_t = (*key.size(), query.size(2))
+    query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
+    key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+    value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+
+    scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
+    if self.window_size is not None:
+      assert t_s == t_t, "Relative attention is only available for self-attention."
+      key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
+      rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
+      scores_local = self._relative_position_to_absolute_position(rel_logits)
+      scores = scores + scores_local
+    if self.proximal_bias:
+      assert t_s == t_t, "Proximal bias is only available for self-attention."
+      scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
+    if mask is not None:
+      scores = scores.masked_fill(mask == 0, -1e4)
+      if self.block_length is not None:
+        assert t_s == t_t, "Local attention is only available for self-attention."
+        block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
+        scores = scores.masked_fill(block_mask == 0, -1e4)
+    p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
+    p_attn = self.drop(p_attn)
+    output = torch.matmul(p_attn, value)
+    if self.window_size is not None:
+      relative_weights = self._absolute_position_to_relative_position(p_attn)
+      value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
+      output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
+    output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
+    return output, p_attn
+
+  def _matmul_with_relative_values(self, x, y):
+    """
+    x: [b, h, l, m]
+    y: [h or 1, m, d]
+    ret: [b, h, l, d]
+    """
+    ret = torch.matmul(x, y.unsqueeze(0))
+    return ret
+
+  def _matmul_with_relative_keys(self, x, y):
+    """
+    x: [b, h, l, d]
+    y: [h or 1, m, d]
+    ret: [b, h, l, m]
+    """
+    ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
+    return ret
+
+  def _get_relative_embeddings(self, relative_embeddings, length):
+    max_relative_position = 2 * self.window_size + 1
+    # Pad first before slice to avoid using cond ops.
+    pad_length = max(length - (self.window_size + 1), 0)
+    slice_start_position = max((self.window_size + 1) - length, 0)
+    slice_end_position = slice_start_position + 2 * length - 1
+    if pad_length > 0:
+      padded_relative_embeddings = F.pad(
+          relative_embeddings,
+          commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
+    else:
+      padded_relative_embeddings = relative_embeddings
+    used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
+    return used_relative_embeddings
+
+  def _relative_position_to_absolute_position(self, x):
+    """
+    x: [b, h, l, 2*l-1]
+    ret: [b, h, l, l]
+    """
+    batch, heads, length, _ = x.size()
+    # Concat columns of pad to shift from relative to absolute indexing.
+    x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
+
+    # Concat extra elements so to add up to shape (len+1, 2*len-1).
+    x_flat = x.view([batch, heads, length * 2 * length])
+    x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
+
+    # Reshape and slice out the padded elements.
+    x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
+    return x_final
+
+  def _absolute_position_to_relative_position(self, x):
+    """
+    x: [b, h, l, l]
+    ret: [b, h, l, 2*l-1]
+    """
+    batch, heads, length, _ = x.size()
+    # padd along column
+    x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
+    x_flat = x.view([batch, heads, length**2 + length*(length -1)])
+    # add 0's in the beginning that will skew the elements after reshape
+    x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
+    x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
+    return x_final
+
+  def _attention_bias_proximal(self, length):
+    """Bias for self-attention to encourage attention to close positions.
+    Args:
+      length: an integer scalar.
+    Returns:
+      a Tensor with shape [1, 1, length, length]
+    """
+    r = torch.arange(length, dtype=torch.float32)
+    diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
+    return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
+
+
+class FFN(nn.Module):
+  def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
+    super().__init__()
+    self.in_channels = in_channels
+    self.out_channels = out_channels
+    self.filter_channels = filter_channels
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.activation = activation
+    self.causal = causal
+
+    if causal:
+      self.padding = self._causal_padding
+    else:
+      self.padding = self._same_padding
+
+    self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
+    self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
+    self.drop = nn.Dropout(p_dropout)
+
+  def forward(self, x, x_mask):
+    x = self.conv_1(self.padding(x * x_mask))
+    if self.activation == "gelu":
+      x = x * torch.sigmoid(1.702 * x)
+    else:
+      x = torch.relu(x)
+    x = self.drop(x)
+    x = self.conv_2(self.padding(x * x_mask))
+    return x * x_mask
+  
+  def _causal_padding(self, x):
+    if self.kernel_size == 1:
+      return x
+    pad_l = self.kernel_size - 1
+    pad_r = 0
+    padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+    x = F.pad(x, commons.convert_pad_shape(padding))
+    return x
+
+  def _same_padding(self, x):
+    if self.kernel_size == 1:
+      return x
+    pad_l = (self.kernel_size - 1) // 2
+    pad_r = self.kernel_size // 2
+    padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+    x = F.pad(x, commons.convert_pad_shape(padding))
+    return x

chinese_dialect_lexicons/changzhou.json

@@ -0,0 +1,23 @@
+{
+  "name": "Changzhou dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "changzhou.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "changzhou.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/cixi.json

@@ -0,0 +1,23 @@
+{
+  "name": "Cixi dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "cixi.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "cixi.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/fuyang.json

@@ -0,0 +1,23 @@
+{
+  "name": "Fuyang dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "fuyang.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "fuyang.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/hangzhou.json

@@ -0,0 +1,19 @@
+{
+  "name": "Hangzhounese to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "hangzhou.ocd2"
+    }
+  },
+  "conversion_chain": [{
+    "dict": {
+      "type": "group",
+      "dicts": [{
+        "type": "ocd2",
+        "file": "hangzhou.ocd2"
+      }] 
+    }
+  }]
+}

chinese_dialect_lexicons/hangzhou.ocd2

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

chinese_dialect_lexicons/jiading.json

@@ -0,0 +1,23 @@
+{
+  "name": "Jiading dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "jiading.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "jiading.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/jiading.ocd2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f3ac33214e65e7223e8c561bc12ec90a2d87db3cf8d20e87a30bbd8eb788187
+size 111144

chinese_dialect_lexicons/jiashan.json

@@ -0,0 +1,23 @@
+{
+  "name": "Jiashan dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "jiashan.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "jiashan.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/jingjiang.json

@@ -0,0 +1,23 @@
+{
+  "name": "Jingjiang dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "jingjiang.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "jingjiang.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/jyutjyu.json

@@ -0,0 +1,19 @@
+{
+  "name": "Cantonese to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "jyutjyu.ocd2"
+    }
+  },
+  "conversion_chain": [{
+    "dict": {
+      "type": "group",
+      "dicts": [{
+        "type": "ocd2",
+        "file": "jyutjyu.ocd2"
+      }] 
+    }
+  }]
+}

chinese_dialect_lexicons/jyutjyu.ocd2

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

chinese_dialect_lexicons/linping.json

@@ -0,0 +1,23 @@
+{
+  "name": "Linping dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "linping.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "linping.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/ningbo.json

@@ -0,0 +1,19 @@
+{
+  "name": "Ningbonese to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "ningbo.ocd2"
+    }
+  },
+  "conversion_chain": [{
+    "dict": {
+      "type": "group",
+      "dicts": [{
+        "type": "ocd2",
+        "file": "ningbo.ocd2"
+      }] 
+    }
+  }]
+}

chinese_dialect_lexicons/ningbo.ocd2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5876b000f611ea52bf18cda5bcbdd0cfcc55e1c09774d9a24e3b5c7d90002435
+size 386414

chinese_dialect_lexicons/pinghu.json

@@ -0,0 +1,23 @@
+{
+  "name": "Pinghu dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "pinghu.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "pinghu.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/ruao.json

@@ -0,0 +1,23 @@
+{
+  "name": "Ruao dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "ruao.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "ruao.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/sanmen.json

@@ -0,0 +1,23 @@
+{
+  "name": "Sanmen dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "sanmen.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "sanmen.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/shaoxing.json

@@ -0,0 +1,23 @@
+{
+  "name": "Shaoxing dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "shaoxing.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "shaoxing.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/shaoxing.ocd2

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

chinese_dialect_lexicons/suichang.json

@@ -0,0 +1,23 @@
+{
+  "name": "Suichang dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "suichang.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "suichang.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/suzhou.json

@@ -0,0 +1,19 @@
+{
+  "name": "Suzhounese to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "suzhou.ocd2"
+    }
+  },
+  "conversion_chain": [{
+    "dict": {
+      "type": "group",
+      "dicts": [{
+        "type": "ocd2",
+        "file": "suzhou.ocd2"
+      }] 
+    }
+  }]
+}

chinese_dialect_lexicons/suzhou.ocd2

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

chinese_dialect_lexicons/tiantai.json

@@ -0,0 +1,23 @@
+{
+  "name": "Tiantai dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "tiantai.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "tiantai.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/tiantai.ocd2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:339e0ba454444dbf8fbe75de6f49769d11dfe2f2f5ba7dea74ba20fba5d6d343
+size 120951

chinese_dialect_lexicons/tongxiang.json

@@ -0,0 +1,23 @@
+{
+  "name": "Tongxiang dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "tongxiang.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "tongxiang.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/tongxiang.ocd2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7432d85588eb8ba34e7baea9f26af8d332572037ff7d41a6730f96c02e5fd063
+size 137499

chinese_dialect_lexicons/wenzhou.json

@@ -0,0 +1,23 @@
+{
+  "name": "Wenzhou dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "wenzhou.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "wenzhou.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/wuxi.json

@@ -0,0 +1,19 @@
+{
+  "name": "Wuxinese to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "wuxi.ocd2"
+    }
+  },
+  "conversion_chain": [{
+    "dict": {
+      "type": "group",
+      "dicts": [{
+        "type": "ocd2",
+        "file": "wuxi.ocd2"
+      }] 
+    }
+  }]
+}

chinese_dialect_lexicons/wuxi.ocd2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64f27ffaa75e542e4464e53c4acf94607be1526a90922ac8b28870104aaebdff
+size 358666

chinese_dialect_lexicons/xiaoshan.json

@@ -0,0 +1,23 @@
+{
+  "name": "Xiaoshan dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "xiaoshan.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "xiaoshan.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}

chinese_dialect_lexicons/xiashi.json

@@ -0,0 +1,19 @@
+{
+  "name": "Xiashi dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "xiashi.ocd2"
+    }
+  },
+  "conversion_chain": [{
+    "dict": {
+      "type": "group",
+      "dicts": [{
+        "type": "ocd2",
+        "file": "xiashi.ocd2"
+      }] 
+    }
+  }]
+}

chinese_dialect_lexicons/yixing.json

@@ -0,0 +1,19 @@
+{
+  "name": "Yixing dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "yixing.ocd2"
+    }
+  },
+  "conversion_chain": [{
+    "dict": {
+      "type": "group",
+      "dicts": [{
+        "type": "ocd2",
+        "file": "yixing.ocd2"
+      }] 
+    }
+  }]
+}

chinese_dialect_lexicons/yixing.ocd2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c56a73eb531f49f64562bdb714753d37dc015baac943b3264bccba9b2aacf9b
+size 155050

chinese_dialect_lexicons/youbu.json

@@ -0,0 +1,23 @@
+{
+  "name": "Youbu dialect to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "youbu.ocd2"
+    }
+  },
+  "conversion_chain": [
+    {
+      "dict": {
+        "type": "group",
+        "dicts": [
+          {
+            "type": "ocd2",
+            "file": "youbu.ocd2"
+          }
+        ]
+      }
+    }
+  ]
+}