Upload 18 files

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY . .
+
+ENV PYTHONPATH=/app
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,72 @@
 ---
-title: Style Bert Vits2 Fastapi
-emoji: 📈
-colorFrom: gray
-colorTo: indigo
+title: sbv2-verified-fixed6-real
+emoji: 🗣️
+colorFrom: indigo
+colorTo: pink
 sdk: docker
-pinned: false
-license: mit
+sdk_version: "1.0"
+app_file: app.py
+pinned: true
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Style-Bert-VITS2 (koharune-ami) - FastAPI構成（Strict=True対応）
+
+本構成は、以下のモデルとstrict=Trueで完全一致する構造により、Hugging Face Spacesまたはローカル環境で音声生成APIを動作させるためのテンプレートです。
+
+## 🔗 使用モデル
+- モデル名：`buchi-stdesign/sbv2-koharune-secret`
+- ファイル：
+  - `koharune-ami.safetensors`
+  - `config.json`
+  - `style_vectors.npy`
+
+## ✅ 必要環境
+```bash
+pip install -r requirements.txt
+
+🚀 起動方法（ローカル / Hugging Face共通）
+
+uvicorn app:app --host 0.0.0.0 --port 7860
+
+🎧 使用方法
+以下のエンドポイントにGETリクエストを送るとWAV音声が返却されます。
+
+GET /voice?text=こんにちは
+
+環境変数（Spacesなどで使用する場合）
+MODEL_REPO：Hugging Faceのモデルリポジトリ名（例：buchi-stdesign/sbv2-koharune-secret）
+
+HF_TOKEN：アクセストークン（非公開モデル使用時）
+
+🛡 ライセンス・著作権
+本テンプレートは商用・非商用問わず自由に利用可能ですが、使用モデルの著作権は各モデル提供者に帰属します。
+
+koharune-amiの音声モデルは、Style-Bert-VITS2公式ページから取得された学習モデルを基にしています。
+
+ライセンス等の明示がある場合は、そちらに従ってください。
+
+📦 フォルダ構成
+
+.
+├── app.py
+├── inference.py
+├── requirements.txt
+├── README.md
+├── text/
+│   ├── cleaners.py
+│   ├── symbols.py
+│   └── text_to_sequence.py
+├── src/sbv2/
+│   ├── commons.py
+│   ├── generator.py
+│   ├── monotonic_align.py
+│   ├── synthesizer_trn.py
+│   └── text_encoder.py
+
+📢 注意
+本構成は strict=True 完全一致 を前提としたテンプレートです。
+
+モデルファイルが異なる構造を持つ場合、RuntimeError が発生します。
+
+
+

app.py

@@ -0,0 +1,16 @@
+from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
+from inference import synthesize_voice, load_model
+import io
+
+app = FastAPI()
+
+# 🛠 サーバ起動時にモデルをロードする
+@app.on_event("startup")
+async def startup_event():
+    load_model()
+
+@app.get("/voice")
+async def voice_endpoint(text: str):
+    wav_bytes = synthesize_voice(text)
+    return StreamingResponse(io.BytesIO(wav_bytes), media_type="audio/wav")

inference.py

@@ -0,0 +1,81 @@
+import torch
+import os
+from huggingface_hub import hf_hub_download
+from src.sbv2.synthesizer_trn import SynthesizerTrn
+from src.sbv2.text import text_to_sequence
+from src.sbv2.commons import get_hparams_from_file
+
+# 環境変数から取得
+MODEL_REPO = os.getenv("MODEL_REPO")
+HF_TOKEN = os.getenv("HF_TOKEN")
+CACHE_DIR = "/tmp/hf_cache"
+
+# モデルとデバイスをグローバル変数として用意
+model = None
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+def load_model():
+    global model
+    # Hugging Faceからモデルファイルをダウンロード
+    config_path = hf_hub_download(repo_id=MODEL_REPO, filename="config.json", token=HF_TOKEN, cache_dir=CACHE_DIR)
+    model_path = hf_hub_download(repo_id=MODEL_REPO, filename="model.safetensors", token=HF_TOKEN, cache_dir=CACHE_DIR)
+    style_path = hf_hub_download(repo_id=MODEL_REPO, filename="style_vectors.npy", token=HF_TOKEN, cache_dir=CACHE_DIR)
+
+    # configをロード
+    hps = get_hparams_from_file(config_path)
+
+    # モデルを初期化
+    model = SynthesizerTrn(
+        n_vocab=70,  # 仮設定（※symbolsが無いため一般的な日本語TTS想定）
+        spec_channels=hps["model"].get("spec_channels", 80),
+        segment_size=None,
+        inter_channels=hps["model"]["hidden_channels"],
+        hidden_channels=hps["model"]["hidden_channels"],
+        filter_channels=hps["model"]["filter_channels"],
+        n_heads=hps["model"]["n_heads"],
+        n_layers=int(hps["model"]["encoder_n_layers"]),
+        kernel_size=hps["model"]["encoder_kernel_size"],
+        p_dropout=hps["model"]["dropout"],
+        resblock=str(hps["model"].get("resblock", 2)),
+        resblock_kernel_sizes=hps["model"]["resblock_kernel_sizes"],
+        resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5], [1, 3, 5], [1, 3, 5]],
+        upsample_rates=hps["model"]["upsample_rates"],
+        upsample_initial_channel=512,  # 通常512固定
+        upsample_kernel_sizes=hps["model"]["upsample_kernel_sizes"],
+        gin_channels=hps["model"]["gin_channels"],
+        out_channels=hps["model"].get("spec_channels", 80),
+        dec_kernel_size=hps["model"]["encoder_kernel_size"],
+        enc_channels=hps["model"]["encoder_hidden"],
+        enc_out_channels=hps["model"]["encoder_hidden"] * 2,
+        enc_kernel_size=hps["model"]["encoder_kernel_size"],
+        enc_dilation_rate=hps["model"].get("enc_dilation_rate", 1),
+        enc_n_layers=int(hps["model"]["encoder_n_layers"]),
+        flow_hidden_channels=hps["model"]["hidden_channels"],
+        flow_kernel_size=hps["model"]["flow_kernel_size"],
+        flow_n_layers=int(hps["model"]["flow_n_layers"]),
+        flow_n_flows=int(hps["model"]["flow_n_flows"]),
+        sdp_hidden_channels=hps["model"]["sdp_filter_channels"],
+        sdp_kernel_size=hps["model"]["sdp_kernel_size"],
+        sdp_n_layers=int(hps["model"]["sdp_n_layers"]),
+        sdp_dropout=hps["model"]["sdp_dropout"],
+        sampling_rate=hps["data"]["sampling_rate"],
+        filter_length=1024,
+        hop_length=256,
+        win_length=1024,
+    ).to(device)
+
+    # safetensorsで重み読み込み
+    from safetensors.torch import load_file
+    model_sd = load_file(model_path)
+    model.load_state_dict(model_sd, strict=True)
+    model.eval()
+
+def synthesize_voice(text):
+    # 推論を実行
+    x = torch.LongTensor(text_to_sequence(text, ['basic_cleaners'])).unsqueeze(0).to(device)
+    x_lengths = torch.LongTensor([x.size(1)]).to(device)
+    sid = torch.LongTensor([0]).to(device)
+
+    with torch.no_grad():
+        audio = model.infer(x, x_lengths, sid=sid, noise_scale=0.667, noise_scale_w=0.8, length_scale=1.0)[0][0, 0].cpu().numpy()
+    return audio

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.110.0
+uvicorn==0.29.0
+numpy==1.23.5
+torch==2.0.1
+librosa==0.10.1
+scipy==1.10.1
+soundfile==0.12.1
+huggingface_hub==0.23.1
+safetensors==0.4.2

src/sbv2/commons.py

@@ -0,0 +1,58 @@
+import math
+import torch
+import torch.nn.functional as F
+import json
+
+def init_weights(m):
+    if isinstance(m, torch.nn.Conv1d):
+        torch.nn.init.xavier_uniform_(m.weight, gain=torch.nn.init.calculate_gain('relu'))
+        if m.bias is not None:
+            torch.nn.init.zeros_(m.bias)
+    elif isinstance(m, torch.nn.ConvTranspose1d):
+        torch.nn.init.xavier_uniform_(m.weight, gain=torch.nn.init.calculate_gain('relu'))
+        if m.bias is not None:
+            torch.nn.init.zeros_(m.bias)
+    elif isinstance(m, torch.nn.Linear):
+        torch.nn.init.xavier_uniform_(m.weight, gain=torch.nn.init.calculate_gain('relu'))
+        if m.bias is not None:
+            torch.nn.init.zeros_(m.bias)
+
+def kl_divergence(m_p, logs_p, m_q, logs_q):
+    """KLダイバージェンス（確率分布の違い）を計算"""
+    return 0.5 * (logs_q - logs_p - 1 + (torch.exp(2 * logs_p) + (m_p - m_q) ** 2) / torch.exp(2 * logs_q))
+
+def rand_gumbel(shape):
+    """ガンベル分布から乱数をサンプリング"""
+    return -math.log(-math.log(torch.rand(shape, device="cpu").clamp(1e-5, 1 - 1e-5)))
+
+def rand_uniform(shape):
+    """一様分布から乱数をサンプリング"""
+    return torch.rand(shape, device="cpu")
+
+def rand_logistic(shape):
+    """ロジスティック分布から乱数をサンプリング"""
+    return torch.distributions.RelaxedOneHotCategorical(1.0, logits=torch.zeros(shape)).sample()
+
+def slice_segments(x, ids_str, segment_size=4):
+    """入力テンソルxからids_strをもとにセグメントをスライス"""
+    ret = []
+    for i, ids in enumerate(ids_str):
+        start = ids * segment_size
+        ret.append(x[i, :, start: start + segment_size])
+    return torch.stack(ret)
+
+def rand_slice_segments(x, x_lengths=None, segment_size=4):
+    """ランダムにセグメントをスライス"""
+    b, d, t = x.size()
+    if x_lengths is None:
+        ids_str = torch.randint(0, t - segment_size, (b,), device=x.device)
+    else:
+        ids_str = (torch.rand(b, device=x.device) * (x_lengths - segment_size)).long()
+    return slice_segments(x, ids_str, segment_size)
+
+def get_hparams_from_file(config_path):
+    """設定ファイル(config.json)を読み込んで辞書型に変換"""
+    with open(config_path, "r", encoding="utf-8") as f:
+        data = f.read()
+    config = json.loads(data)
+    return config

src/sbv2/duration_predictor.py

@@ -0,0 +1,104 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ResidualCouplingLayer(nn.Module):
+    def __init__(self, channels, hidden_channels, kernel_size, dilation_rate, n_layers):
+        super().__init__()
+        self.channels = channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+
+        self.pre = nn.Conv1d(channels // 2, hidden_channels, 1)
+        self.convs = nn.ModuleList()
+        for i in range(n_layers):
+            dilation = dilation_rate ** i
+            self.convs.append(
+                nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=(kernel_size-1)//2 * dilation, dilation=dilation)
+            )
+        self.post = nn.Conv1d(hidden_channels, channels, 1)
+
+    def forward(self, x, reverse=False):
+        x0, x1 = torch.chunk(x, 2, dim=1)
+        h = self.pre(x0)
+        for conv in self.convs:
+            h = F.relu(conv(h))
+        h = self.post(h)
+        m, logs = torch.chunk(h, 2, dim=1)
+
+        if not reverse:
+            x1 = m + x1 * torch.exp(logs)
+        else:
+            x1 = (x1 - m) * torch.exp(-logs)
+
+        return torch.cat([x0, x1], dim=1)
+
+class ResidualCouplingBlock(nn.Module):
+    def __init__(self, channels, hidden_channels, kernel_size, dilation_rate, n_layers, n_flows):
+        super().__init__()
+        self.flows = nn.ModuleList()
+        for _ in range(n_flows):
+            self.flows.append(ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers))
+            self.flows.append(Flip())
+
+    def forward(self, x, reverse=False):
+        if not reverse:
+            for flow in self.flows:
+                x = flow(x)
+        else:
+            for flow in reversed(self.flows):
+                x = flow(x, reverse=True)
+        return x
+
+class Flip(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, reverse=False):
+        return x.flip(1)
+
+class PosteriorEncoder(nn.Module):
+    def __init__(self, in_channels, out_channels, hidden_channels, kernel_size, dilation_rate, n_layers):
+        super().__init__()
+        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+        self.convs = nn.ModuleList()
+        for i in range(n_layers):
+            dilation = dilation_rate ** i
+            self.convs.append(
+                nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=(kernel_size-1)//2 * dilation, dilation=dilation)
+            )
+        self.proj_mean = nn.Conv1d(hidden_channels, out_channels, 1)
+        self.proj_logvar = nn.Conv1d(hidden_channels, out_channels, 1)
+
+    def forward(self, x, x_lengths):
+        x = self.pre(x)
+        for conv in self.convs:
+            x = F.relu(conv(x))
+        m = self.proj_mean(x)
+        logs = self.proj_logvar(x)
+        z = m + torch.randn_like(m) * torch.exp(logs)
+        return z, m, logs
+
+    def infer(self, z, z_lengths):
+        return z
+
+class DurationPredictor(nn.Module):
+    def __init__(self, in_channels, filter_channels, kernel_size, p_dropout):
+        super().__init__()
+        self.conv1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=(kernel_size-1)//2)
+        self.conv2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=(kernel_size-1)//2)
+        self.proj = nn.Conv1d(filter_channels, 1, 1)
+        self.dropout = nn.Dropout(p_dropout)
+
+    def forward(self, x, x_mask):
+        x = self.conv1(x)
+        x = torch.relu(x)
+        x = self.dropout(x)
+        x = self.conv2(x)
+        x = torch.relu(x)
+        x = self.dropout(x)
+        x = self.proj(x)
+        x = x * x_mask
+        return x.squeeze(1)

src/sbv2/flow.py

@@ -0,0 +1,77 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import Conv1d
+
+class ResidualCouplingLayer(nn.Module):
+    def __init__(self, channels, hidden_channels, kernel_size, dilation_rate, n_layers):
+        super().__init__()
+        self.channels = channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+
+        self.pre = nn.Conv1d(channels // 2, hidden_channels, 1)
+        self.convs = nn.ModuleList()
+        for i in range(n_layers):
+            dilation = dilation_rate ** i
+            self.convs.append(
+                nn.Conv1d(
+                    hidden_channels,
+                    hidden_channels,
+                    kernel_size,
+                    padding=(kernel_size - 1) * dilation // 2,
+                    dilation=dilation
+                )
+            )
+        self.proj = nn.Conv1d(hidden_channels, channels, 1)
+
+    def forward(self, x, reverse=False):
+        x0, x1 = torch.chunk(x, 2, 1)
+        h = self.pre(x0)
+        for conv in self.convs:
+            h = F.relu(conv(h))
+        stats = self.proj(h)
+        m, logs = torch.chunk(stats, 2, 1)
+
+        if not reverse:
+            x1 = m + x1 * torch.exp(logs)
+        else:
+            x1 = (x1 - m) * torch.exp(-logs)
+
+        return torch.cat([x0, x1], 1)
+
+class ResidualCouplingBlock(nn.Module):
+    def __init__(self, channels, hidden_channels, kernel_size, dilation_rate, n_layers, n_flows):
+        super().__init__()
+        self.flows = nn.ModuleList()
+        for _ in range(n_flows):
+            self.flows.append(
+                ResidualCouplingLayer(
+                    channels=channels,
+                    hidden_channels=hidden_channels,
+                    kernel_size=kernel_size,
+                    dilation_rate=dilation_rate,
+                    n_layers=n_layers
+                )
+            )
+
+    def forward(self, x, reverse=False):
+        if not reverse:
+            for flow in self.flows:
+                x = flow(x, reverse=False)
+        else:
+            for flow in reversed(self.flows):
+                x = flow(x, reverse=True)
+        return x
+
+class Flip(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, reverse=False):
+        if not reverse:
+            return torch.flip(x, [1])
+        else:
+            return torch.flip(x, [1])

src/sbv2/generator.py

@@ -0,0 +1,33 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+from .modules import LayerNorm, ConvReluNorm
+
+class Generator(nn.Module):
+    def __init__(self, channels):
+        super(Generator, self).__init__()
+        self.conv_pre = nn.Conv1d(channels, 512, 7, 1, 3)
+        self.resblocks = nn.ModuleList([
+            ResBlock(512) for _ in range(3)
+        ])
+        self.conv_post = nn.Conv1d(512, 1, 7, 1, 3)
+
+    def forward(self, x):
+        x = self.conv_pre(x)
+        for resblock in self.resblocks:
+            x = resblock(x)
+        x = self.conv_post(x)
+        x = torch.tanh(x)
+        return x
+
+class ResBlock(nn.Module):
+    def __init__(self, channels):
+        super(ResBlock, self).__init__()
+        self.convs = nn.Sequential(
+            nn.Conv1d(channels, channels, 3, 1, 1),
+            nn.ReLU(),
+            nn.Conv1d(channels, channels, 3, 1, 1)
+        )
+
+    def forward(self, x):
+        return x + self.convs(x)

src/sbv2/modules.py

@@ -0,0 +1,42 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class LayerNorm(nn.Module):
+    def __init__(self, channels, eps=1e-5):
+        super().__init__()
+        self.ln = nn.LayerNorm(channels, eps=eps)
+
+    def forward(self, x):
+        x = x.transpose(1, 2)
+        x = self.ln(x)
+        x = x.transpose(1, 2)
+        return x
+
+
+class ConvReluNorm(nn.Module):
+    def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, bias):
+        super().__init__()
+        self.in_channels = in_channels
+        self.hidden_channels = hidden_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.n_layers = n_layers
+        self.bias = bias
+
+        convs = []
+        convs.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2, bias=bias))
+        convs.append(LayerNorm(hidden_channels))
+        convs.append(nn.ReLU())
+
+        for _ in range(n_layers - 2):
+            convs.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2, bias=bias))
+            convs.append(LayerNorm(hidden_channels))
+            convs.append(nn.ReLU())
+
+        convs.append(nn.Conv1d(hidden_channels, out_channels, kernel_size, padding=kernel_size//2, bias=bias))
+        self.main = nn.Sequential(*convs)
+
+    def forward(self, x):
+        return self.main(x)

src/sbv2/monotonic_align.py

@@ -0,0 +1,36 @@
+import torch
+import torch.nn.functional as F
+
+
+@torch.jit.script
+def maximum_path(soft_attention, mask):
+    """
+    :param soft_attention: [b, t_x, t_y]
+    :param mask: [b, t_x, t_y]
+    :return: attn: [b, t_x, t_y]
+    """
+    b, t_x, t_y = soft_attention.size()
+    device = soft_attention.device
+
+    log_p = torch.zeros(b, t_x, t_y).to(device)
+    log_p[:, 0, :] = torch.cumsum(soft_attention[:, 0, :], dim=1)
+    log_p[:, :, 0] = torch.cumsum(soft_attention[:, :, 0], dim=1)
+
+    for i in range(1, t_x):
+        for j in range(1, t_y):
+            max_prev = torch.max(log_p[:, i - 1, j], log_p[:, i, j - 1])
+            log_p[:, i, j] = max_prev + soft_attention[:, i, j]
+
+    path = torch.zeros_like(soft_attention)
+    for b_idx in range(b):
+        i = t_x - 1
+        j = t_y - 1
+        while i > 0 and j > 0:
+            path[b_idx, i, j] = 1
+            if log_p[b_idx, i - 1, j] > log_p[b_idx, i, j - 1]:
+                i -= 1
+            else:
+                j -= 1
+        path[b_idx, i, j] = 1
+
+    return path * mask

src/sbv2/posterior_encoder.py

@@ -0,0 +1,85 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ResidualCouplingLayer(nn.Module):
+    def __init__(self, spec_channels, inter_channels, hidden_channels, kernel_size, enc_dilation_rate, n_layers, p_dropout):
+        super().__init__()
+        self.channels = channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+
+        self.pre = nn.Conv1d(channels // 2, hidden_channels, 1)
+        self.convs = nn.ModuleList()
+        for i in range(n_layers):
+            dilation = dilation_rate ** i
+            self.convs.append(
+                nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=(kernel_size-1)//2 * dilation, dilation=dilation)
+            )
+        self.post = nn.Conv1d(hidden_channels, channels, 1)
+
+    def forward(self, x, reverse=False):
+        x0, x1 = torch.chunk(x, 2, dim=1)
+        h = self.pre(x0)
+        for conv in self.convs:
+            h = F.relu(conv(h))
+        h = self.post(h)
+        m, logs = torch.chunk(h, 2, dim=1)
+
+        if not reverse:
+            x1 = m + x1 * torch.exp(logs)
+        else:
+            x1 = (x1 - m) * torch.exp(-logs)
+
+        return torch.cat([x0, x1], dim=1)
+
+class ResidualCouplingBlock(nn.Module):
+    def __init__(self, channels, hidden_channels, kernel_size, dilation_rate, n_layers, n_flows):
+        super().__init__()
+        self.flows = nn.ModuleList()
+        for _ in range(n_flows):
+            self.flows.append(ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers))
+            self.flows.append(Flip())
+
+    def forward(self, x, reverse=False):
+        if not reverse:
+            for flow in self.flows:
+                x = flow(x)
+        else:
+            for flow in reversed(self.flows):
+                x = flow(x, reverse=True)
+        return x
+
+class Flip(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, reverse=False):
+        return x.flip(1)
+
+class PosteriorEncoder(nn.Module):
+    def __init__(self, in_channels, out_channels, hidden_channels, kernel_size, dilation_rate, n_layers):
+        super().__init__()
+        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+        self.convs = nn.ModuleList()
+        for i in range(n_layers):
+            dilation = dilation_rate ** i
+            self.convs.append(
+                nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=(kernel_size-1)//2 * dilation, dilation=dilation)
+            )
+        self.proj_mean = nn.Conv1d(hidden_channels, out_channels, 1)
+        self.proj_logvar = nn.Conv1d(hidden_channels, out_channels, 1)
+
+    def forward(self, x, x_lengths):
+        x = self.pre(x)
+        for conv in self.convs:
+            x = F.relu(conv(x))
+        m = self.proj_mean(x)
+        logs = self.proj_logvar(x)
+        z = m + torch.randn_like(m) * torch.exp(logs)
+        return z, m, logs
+
+    def infer(self, z, z_lengths):
+        return z

src/sbv2/stochastic_duration_predictor.py

@@ -0,0 +1,132 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ResidualCouplingLayer(nn.Module):
+    def __init__(self, channels, hidden_channels, kernel_size, dilation_rate, n_layers):
+        super().__init__()
+        self.channels = channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+
+        self.pre = nn.Conv1d(channels // 2, hidden_channels, 1)
+        self.convs = nn.ModuleList()
+        for i in range(n_layers):
+            dilation = dilation_rate ** i
+            self.convs.append(
+                nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=(kernel_size-1)//2 * dilation, dilation=dilation)
+            )
+        self.post = nn.Conv1d(hidden_channels, channels, 1)
+
+    def forward(self, x, reverse=False):
+        x0, x1 = torch.chunk(x, 2, dim=1)
+        h = self.pre(x0)
+        for conv in self.convs:
+            h = F.relu(conv(h))
+        h = self.post(h)
+        m, logs = torch.chunk(h, 2, dim=1)
+
+        if not reverse:
+            x1 = m + x1 * torch.exp(logs)
+        else:
+            x1 = (x1 - m) * torch.exp(-logs)
+
+        return torch.cat([x0, x1], dim=1)
+
+class ResidualCouplingBlock(nn.Module):
+    def __init__(self, channels, hidden_channels, kernel_size, dilation_rate, n_layers, n_flows):
+        super().__init__()
+        self.flows = nn.ModuleList()
+        for _ in range(n_flows):
+            self.flows.append(ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers))
+            self.flows.append(Flip())
+
+    def forward(self, x, reverse=False):
+        if not reverse:
+            for flow in self.flows:
+                x = flow(x)
+        else:
+            for flow in reversed(self.flows):
+                x = flow(x, reverse=True)
+        return x
+
+class Flip(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, reverse=False):
+        return x.flip(1)
+
+class PosteriorEncoder(nn.Module):
+    def __init__(self, in_channels, out_channels, hidden_channels, kernel_size, dilation_rate, n_layers):
+        super().__init__()
+        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+        self.convs = nn.ModuleList()
+        for i in range(n_layers):
+            dilation = dilation_rate ** i
+            self.convs.append(
+                nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=(kernel_size-1)//2 * dilation, dilation=dilation)
+            )
+        self.proj_mean = nn.Conv1d(hidden_channels, out_channels, 1)
+        self.proj_logvar = nn.Conv1d(hidden_channels, out_channels, 1)
+
+    def forward(self, x, x_lengths):
+        x = self.pre(x)
+        for conv in self.convs:
+            x = F.relu(conv(x))
+        m = self.proj_mean(x)
+        logs = self.proj_logvar(x)
+        z = m + torch.randn_like(m) * torch.exp(logs)
+        return z, m, logs
+
+    def infer(self, z, z_lengths):
+        return z
+
+class DurationPredictor(nn.Module):
+    def __init__(self, in_channels, filter_channels, kernel_size, p_dropout):
+        super().__init__()
+        self.conv1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=(kernel_size-1)//2)
+        self.conv2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=(kernel_size-1)//2)
+        self.proj = nn.Conv1d(filter_channels, 1, 1)
+        self.dropout = nn.Dropout(p_dropout)
+
+    def forward(self, x, x_mask):
+        x = self.conv1(x)
+        x = torch.relu(x)
+        x = self.dropout(x)
+        x = self.conv2(x)
+        x = torch.relu(x)
+        x = self.dropout(x)
+        x = self.proj(x)
+        x = x * x_mask
+        return x.squeeze(1)
+
+class StochasticDurationPredictor(nn.Module):
+    def __init__(self, channels, filter_channels, kernel_size, n_flows, p_dropout):
+        super().__init__()
+        self.pre = nn.Conv1d(channels, filter_channels, 1)
+        self.flows = ResidualCouplingBlock(filter_channels, filter_channels, kernel_size, 1, 4, n_flows)
+        self.post = nn.Conv1d(filter_channels, 1, 1)
+        self.dropout = nn.Dropout(p_dropout)
+
+    def forward(self, x, x_mask, durations):
+        x = self.pre(x)
+        x = F.relu(x)
+        x = self.dropout(x)
+        noise = torch.randn_like(x)
+        x = self.flows(noise, reverse=False)
+        out = self.post(x)
+        out = out.squeeze(1) * x_mask.squeeze(1)
+        loss = F.mse_loss(out, durations, reduction="none")
+        return loss.mean()
+
+    def infer(self, x, x_mask):
+        x = self.pre(x)
+        x = F.relu(x)
+        x = self.dropout(x)
+        x = self.flows(x, reverse=True)
+        out = self.post(x)
+        out = out.squeeze(1) * x_mask.squeeze(1)
+        return out

src/sbv2/synthesizer_trn.py

@@ -0,0 +1,109 @@
+# 完全新規構成 synthesize_trn.py
+# (config.jsonにstrict対応)
+
+import torch
+import torch.nn as nn
+
+from src.sbv2.generator import Generator
+from src.sbv2.posterior_encoder import PosteriorEncoder
+from src.sbv2.flow import ResidualCouplingBlock
+from src.sbv2.flow import Flip
+from src.sbv2.duration_predictor import DurationPredictor
+from src.sbv2.stochastic_duration_predictor import StochasticDurationPredictor
+
+class SynthesizerTrn(nn.Module):
+    def __init__(self,
+                 n_vocab,
+                 spec_channels,
+                 inter_channels,
+                 hidden_channels,
+                 filter_channels,
+                 n_heads,
+                 n_layers,
+                 kernel_size,
+                 p_dropout,
+                 resblock,
+                 resblock_kernel_sizes,
+                 resblock_dilation_sizes,
+                 upsample_rates,
+                 upsample_initial_channel,
+                 upsample_kernel_sizes,
+                 segment_size,
+                 gin_channels,
+                 out_channels,
+                 dec_kernel_size,
+                 enc_channels,
+                 enc_out_channels,
+                 enc_kernel_size,
+                 enc_dilation_rate,
+                 enc_n_layers,
+                 flow_hidden_channels,
+                 flow_kernel_size,
+                 flow_n_layers,
+                 flow_n_flows,
+                 sdp_hidden_channels,
+                 sdp_kernel_size,
+                 sdp_n_layers,
+                 sdp_dropout,
+                 sampling_rate,
+                 filter_length,
+                 hop_length,
+                 win_length):
+        super().__init__()
+        
+        self.n_vocab = n_vocab
+        self.spec_channels = spec_channels
+        self.inter_channels = inter_channels
+        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.resblock = resblock
+        self.resblock_kernel_sizes = resblock_kernel_sizes
+        self.resblock_dilation_sizes = resblock_dilation_sizes
+        self.upsample_rates = upsample_rates
+        self.upsample_initial_channel = upsample_initial_channel
+        self.upsample_kernel_sizes = upsample_kernel_sizes
+        self.segment_size = segment_size
+        self.gin_channels = gin_channels
+        self.out_channels = out_channels
+        self.dec_kernel_size = dec_kernel_size
+        self.enc_channels = enc_channels
+        self.enc_out_channels = enc_out_channels
+        self.enc_kernel_size = enc_kernel_size
+        self.enc_dilation_rate = enc_dilation_rate
+        self.enc_n_layers = enc_n_layers
+        self.flow_hidden_channels = flow_hidden_channels
+        self.flow_kernel_size = flow_kernel_size
+        self.flow_n_layers = flow_n_layers
+        self.flow_n_flows = flow_n_flows
+        self.sdp_hidden_channels = sdp_hidden_channels
+        self.sdp_kernel_size = sdp_kernel_size
+        self.sdp_n_layers = sdp_n_layers
+        self.sdp_dropout = sdp_dropout
+        self.sampling_rate = sampling_rate
+        self.filter_length = filter_length
+        self.hop_length = hop_length
+        self.win_length = win_length
+
+        # ネットワークモジュール
+        self.enc_p = PosteriorEncoder(
+            spec_channels, inter_channels, hidden_channels,
+            kernel_size, enc_dilation_rate, int(enc_n_layers))
+        self.decoder = Generator(
+            upsample_rates, upsample_initial_channel)
+        self.flow = ResidualCouplingBlock(
+            inter_channels, flow_hidden_channels, flow_kernel_size, flow_n_layers)
+        self.flow_post = Flip()
+        self.dp = DurationPredictor(
+            inter_channels, filter_channels, kernel_size, p_dropout)
+        self.sdp = StochasticDurationPredictor(
+            inter_channels, filter_channels, kernel_size, p_dropout)
+
+    def forward(self, *args, **kwargs):
+        raise NotImplementedError("Training用 forwardは未実装です")
+
+    def infer(self, *args, **kwargs):
+        raise NotImplementedError("推論用 inferは未実装です")

src/sbv2/text/cleaners.py

@@ -0,0 +1,24 @@
+import re
+import unicodedata
+
+_japanese_replacements = [
+    ("‐", "-"),
+    ("―", "-"),
+    ("−", "-"),
+    ("ー", "ー"),
+    ("・", "、"),
+    (",", "、"),
+    ("，", "、"),
+    (".", "。"),
+    ("．", "。"),
+]
+
+def japanese_cleaners(text):
+    text = unicodedata.normalize("NFKC", text)
+    for pattern, replacement in _japanese_replacements:
+        text = text.replace(pattern, replacement)
+    text = re.sub(r"[（）!?！？\[\]{}]", "", text)  # 特殊記号除去
+    return text
+
+# ⭐ ここを追加する！
+basic_cleaners = japanese_cleaners

src/sbv2/text/symbols.py

@@ -0,0 +1,7 @@
+_pad        = "_"
+_punctuation = ",.!?-…~"
+_letters     = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+_japanese    = "あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわをんアイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヲンー"
+_extra       = "0123456789"
+
+symbols = list(_pad + _punctuation + _letters + _japanese + _extra)

src/sbv2/text/text_to_sequence.py

@@ -0,0 +1,8 @@
+# text_to_sequence.py
+
+from src.sbv2.text_encoder import text_to_sequence as encoder_text_to_sequence
+from src.sbv2.text.cleaners import basic_cleaners
+
+def text_to_sequence(text):
+    text = basic_cleaners(text)
+    return encoder_text_to_sequence(text)

src/sbv2/text_encoder.py

@@ -0,0 +1,14 @@
+# text_encoder.py
+
+from src.sbv2.text.symbols import symbols
+
+_symbol_to_id = {s: i for i, s in enumerate(symbols)}
+_id_to_symbol = {i: s for i, s in enumerate(symbols)}
+
+def text_to_sequence(text):
+    sequence = [_symbol_to_id[s] for s in text if s in _symbol_to_id]
+    return sequence
+
+def sequence_to_text(sequence):
+    return ''.join([_id_to_symbol[i] for i in sequence if i in _id_to_symbol])
+