Delete Hololive-Style-Bert-VITS2

Hololive-Style-Bert-VITS2/.gitattributes

@@ -1,76 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz 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
-images/aki.png filter=lfs diff=lfs merge=lfs -text
-images/anya.png filter=lfs diff=lfs merge=lfs -text
-images/aqua.png filter=lfs diff=lfs merge=lfs -text
-images/ayame.png filter=lfs diff=lfs merge=lfs -text
-images/azki.png filter=lfs diff=lfs merge=lfs -text
-images/bae.png filter=lfs diff=lfs merge=lfs -text
-images/bijou.png filter=lfs diff=lfs merge=lfs -text
-images/chloe.png filter=lfs diff=lfs merge=lfs -text
-images/fauna.png filter=lfs diff=lfs merge=lfs -text
-images/flare.png filter=lfs diff=lfs merge=lfs -text
-images/fubuki.png filter=lfs diff=lfs merge=lfs -text
-images/gura.png filter=lfs diff=lfs merge=lfs -text
-images/haato.png filter=lfs diff=lfs merge=lfs -text
-images/irys.png filter=lfs diff=lfs merge=lfs -text
-images/kanata.png filter=lfs diff=lfs merge=lfs -text
-images/kiara.png filter=lfs diff=lfs merge=lfs -text
-images/koyori.png filter=lfs diff=lfs merge=lfs -text
-images/kronii.png filter=lfs diff=lfs merge=lfs -text
-images/lamy.png filter=lfs diff=lfs merge=lfs -text
-images/laplus.png filter=lfs diff=lfs merge=lfs -text
-images/lui.png filter=lfs diff=lfs merge=lfs -text
-images/luna.png filter=lfs diff=lfs merge=lfs -text
-images/matsuri.png filter=lfs diff=lfs merge=lfs -text
-images/mel.png filter=lfs diff=lfs merge=lfs -text
-images/miko.png filter=lfs diff=lfs merge=lfs -text
-images/mumei.png filter=lfs diff=lfs merge=lfs -text
-images/nene.png filter=lfs diff=lfs merge=lfs -text
-images/nerissa.png filter=lfs diff=lfs merge=lfs -text
-images/noel.png filter=lfs diff=lfs merge=lfs -text
-images/okayu.png filter=lfs diff=lfs merge=lfs -text
-images/ollie.png filter=lfs diff=lfs merge=lfs -text
-images/pekora.png filter=lfs diff=lfs merge=lfs -text
-images/polka.png filter=lfs diff=lfs merge=lfs -text
-images/raden.png filter=lfs diff=lfs merge=lfs -text
-images/ririka.png filter=lfs diff=lfs merge=lfs -text
-images/shiori.png filter=lfs diff=lfs merge=lfs -text
-images/subaru.png filter=lfs diff=lfs merge=lfs -text
-images/suisei.png filter=lfs diff=lfs merge=lfs -text
-images/towa.png filter=lfs diff=lfs merge=lfs -text
-images/watame.png filter=lfs diff=lfs merge=lfs -text
-images/zeta.png filter=lfs diff=lfs merge=lfs -text

Hololive-Style-Bert-VITS2/.gitignore

@@ -1 +0,0 @@
-__pycache__/

Hololive-Style-Bert-VITS2/README.md

@@ -1,15 +0,0 @@
----
-title: Hololive Style-Bert-VITS2
-short_description: Generate Voice VTUBER
-emoji: 🚀
-colorFrom: gray
-colorTo: gray
-sdk: gradio
-sdk_version: 4.44.1
-app_file: app.py
-pinned: false
-license: agpl-3.0
-python_version: '3.11'
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Hololive-Style-Bert-VITS2/app.py

@@ -1,386 +0,0 @@
-print("Starting up. Please be patient...")
-
-import argparse
-import datetime
-import os
-import sys
-from typing import Optional
-import json
-import utils
-import shutil
-
-import gradio as gr
-import torch
-import yaml
-
-from common.constants import (
-    DEFAULT_ASSIST_TEXT_WEIGHT,
-    DEFAULT_LENGTH,
-    DEFAULT_LINE_SPLIT,
-    DEFAULT_NOISE,
-    DEFAULT_NOISEW,
-    DEFAULT_SDP_RATIO,
-    DEFAULT_SPLIT_INTERVAL,
-    DEFAULT_STYLE,
-    DEFAULT_STYLE_WEIGHT,
-    Languages,
-)
-from common.log import logger
-
-# --- BAGIAN DOWNLOAD OTOMATIS & FIX STRUKTUR FOLDER ---
-from huggingface_hub import snapshot_download
-
-HF_TOKEN = os.getenv("HF_TOKEN")
-REPO_ID = "Plana-Archive/Premium-Model"
-SUBFOLDER = "Hololive-Style-Bert-VITS2"
-TEMP_DIR = "temp_download"
-
-def download_assets():
-    print("Checking and downloading assets from private repo...")
-
-    # 1. Download folder bert/ dari repo private
-    bert_dir = "./bert"
-    if not os.path.exists(bert_dir):
-        print(f"Downloading bert/ from {REPO_ID}/{SUBFOLDER}/bert ...")
-        try:
-            snapshot_download(
-                repo_id=REPO_ID,
-                repo_type="model",
-                allow_patterns=[f"{SUBFOLDER}/bert/**/*"],
-                local_dir=TEMP_DIR,
-                token=HF_TOKEN,
-            )
-            src_bert = os.path.join(TEMP_DIR, SUBFOLDER, "bert")
-            if os.path.exists(src_bert):
-                shutil.move(src_bert, "./bert")
-                print("✅ bert/ downloaded and moved successfully.")
-            else:
-                print("⚠️ bert/ folder not found in downloaded files.")
-        except Exception as e:
-            print(f"❌ bert/ download failed: {e}")
-    else:
-        print("✅ bert/ already exists, skipping.")
-
-    # 2. Download folder model_assets/ dari repo private
-    model_assets_dir = "./model_assets"
-    if not os.path.exists(model_assets_dir):
-        print(f"Downloading model_assets/ from {REPO_ID}/{SUBFOLDER}/model_assets ...")
-        try:
-            snapshot_download(
-                repo_id=REPO_ID,
-                repo_type="model",
-                allow_patterns=[f"{SUBFOLDER}/model_assets/**/*"],
-                local_dir=TEMP_DIR,
-                token=HF_TOKEN,
-            )
-            src_assets = os.path.join(TEMP_DIR, SUBFOLDER, "model_assets")
-            if os.path.exists(src_assets):
-                shutil.move(src_assets, "./model_assets")
-                print("✅ model_assets/ downloaded and moved successfully.")
-            else:
-                print("⚠️ model_assets/ folder not found in downloaded files.")
-        except Exception as e:
-            print(f"❌ model_assets/ download failed: {e}")
-    else:
-        print("✅ model_assets/ already exists, skipping.")
-
-    # Cleanup temp dir jika masih ada
-    if os.path.exists(TEMP_DIR):
-        shutil.rmtree(TEMP_DIR)
-        print("🧹 Temp directory cleaned up.")
-
-download_assets()
-
-from common.tts_model import ModelHolder
-from infer import InvalidToneError
-from text.japanese import g2kata_tone, kata_tone2phone_tone, text_normalize
-
-import nltk
-nltk.download('averaged_perceptron_tagger_eng')
-
-is_hf_spaces = os.getenv("SYSTEM") == "spaces"
-limit = 150
-
-with open(os.path.join("configs", "paths.yml"), "r", encoding="utf-8") as f:
-    path_config: dict[str, str] = yaml.safe_load(f.read())
-    assets_root = path_config["assets_root"]
-
-def tts_fn(
-    model_name,
-    model_path,
-    text,
-    language,
-    reference_audio_path,
-    sdp_ratio,
-    noise_scale,
-    noise_scale_w,
-    speed_rate,
-    line_split,
-    split_interval,
-    assist_text,
-    assist_text_weight,
-    use_assist_text,
-    style,
-    style_weight,
-    kata_tone_json_str,
-    use_tone,
-    speaker,
-):
-    if len(text) < 2:
-        return "Please enter some text.", None, kata_tone_json_str
-
-    if is_hf_spaces and len(text) > limit:
-        return f"Too long! There is a character limit of {limit} characters.", None, kata_tone_json_str
-
-    if not model_holder.current_model:
-        model_holder.load_model_gr(model_name, model_path)
-        logger.info(f"Loaded model '{model_name}'")
-    if model_holder.current_model.model_path != model_path:
-        model_holder.load_model_gr(model_name, model_path)
-        logger.info(f"Swapped to model '{model_name}'")
-
-    speaker_id = model_holder.current_model.spk2id[speaker]
-    start_time = datetime.datetime.now()
-
-    # Logika Kecepatan: Angka lebih besar = Suara lebih cepat
-    length_scale = 1.0 / speed_rate
-
-    wrong_tone_message = ""
-    kata_tone: Optional[list[tuple[str, int]]] = None
-    if use_tone and kata_tone_json_str != "":
-        if language != "JP":
-            wrong_tone_message = "アクセント指定は現在日本語のみ対応しています。"
-        if line_split:
-            wrong_tone_message = (
-                "アクセント指定は改行で分けて生成を使わない場合のみ対応しています。"
-            )
-        try:
-            kata_tone = []
-            json_data = json.loads(kata_tone_json_str)
-            for kana, tone in json_data:
-                assert isinstance(kana, str) and tone in (0, 1), f"{kana}, {tone}"
-                kata_tone.append((kana, tone))
-        except Exception as e:
-            logger.warning(f"Error occurred when parsing kana_tone_json: {e}")
-            wrong_tone_message = f"アクセント指定が不正です: {e}"
-            kata_tone = None
-
-    tone: Optional[list[int]] = None
-    if kata_tone is not None:
-        phone_tone = kata_tone2phone_tone(kata_tone)
-        tone = [t for _, t in phone_tone]
-
-    try:
-        sr, audio = model_holder.current_model.infer(
-            text=text,
-            language=language,
-            reference_audio_path=reference_audio_path,
-            sdp_ratio=sdp_ratio,
-            noise=noise_scale,
-            noisew=noise_scale_w,
-            length=length_scale,
-            line_split=line_split,
-            split_interval=split_interval,
-            assist_text=assist_text,
-            assist_text_weight=assist_text_weight,
-            use_assist_text=use_assist_text,
-            style=style,
-            style_weight=style_weight,
-            given_tone=tone,
-            sid=speaker_id,
-        )
-    except InvalidToneError as e:
-        logger.error(f"Tone error: {e}")
-        return f"Error: アクセント指定が不正です:\n{e}", None, kata_tone_json_str
-    except ValueError as e:
-        logger.error(f"Value error: {e}")
-        return f"Error: {e}", None, kata_tone_json_str
-
-    end_time = datetime.datetime.now()
-    duration = (end_time - start_time).total_seconds()
-
-    if tone is None and language == "JP":
-        norm_text = text_normalize(text)
-        kata_tone = g2kata_tone(norm_text)
-        kata_tone_json_str = json.dumps(kata_tone, ensure_ascii=False)
-    elif tone is None:
-        kata_tone_json_str = ""
-
-    if reference_audio_path:
-        style = "External Audio"
-    logger.info(
-        f"Successful inference, took {duration}s | {speaker} | "
-        f"{language}/{sdp_ratio}/{noise_scale}/{noise_scale_w}/{length_scale}/{style}/{style_weight} | {text}"
-    )
-    message = f"Success, time: {duration} seconds."
-    if wrong_tone_message != "":
-        message = wrong_tone_message + "\n" + message
-    return message, (sr, audio), kata_tone_json_str
-
-
-def load_voicedata():
-    print("Loading voice data...")
-    envoices = []
-    jpvoices = []
-    styledict = {}
-    with open("voicelist.json", "r", encoding="utf-8") as f:
-        voc_info = json.load(f)
-    for name, info in voc_info.items():
-        if not info['enable']:
-            continue
-        model_path = info['model_path']
-        model_path_full = f"{model_dir}/{model_path}/{model_path}.safetensors"
-        if not os.path.exists(model_path_full):
-            model_path_full = f"{model_dir}\\{model_path}\\{model_path}.safetensors"
-        voice_name = info['title']
-        speakerid = info['speakerid']
-        datasetauthor = info['datasetauthor']
-        image = info['cover']
-        if not os.path.exists(f"images/{image}"):
-            image = "none.png"
-        nospace = False
-        if 'disableonspace' in info:
-            nospace = info['disableonspace']
-        if model_path not in styledict.keys():
-            conf = f"{model_dir}/{model_path}/config.json"
-            hps = utils.get_hparams_from_file(conf)
-            s2id = hps.data.style2id
-            styledict[model_path] = s2id.keys()
-            print(f"Set up hyperparameters for model {model_path}")
-        if info['primarylang'] == "JP":
-            jpvoices.append((name, model_path, model_path_full, voice_name, speakerid, datasetauthor, image, nospace))
-        else:
-            envoices.append((name, model_path, model_path_full, voice_name, speakerid, datasetauthor, image, nospace))
-    return [envoices, jpvoices], styledict
-
-
-initial_text = "Hello there! This is test audio of a new Hololive text to speech tool."
-initial_md = """"""
-style_md = """
-- You can control things like voice tone, emotion, and reading style through presets or through voice files.
-- Neutral acts as an average across all speakers. Styling options act as an override to Neutral.
-- Setting the intensity too high will likely break the output.
-"""
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--cpu", action="store_true", help="Use CPU instead of GPU")
-    parser.add_argument("--dir", "-d", type=str, help="Model directory", default=assets_root)
-    parser.add_argument("--share", action="store_true", help="Share this app publicly", default=False)
-    parser.add_argument("--server-name", type=str, default=None, help="Server name for Gradio app")
-    parser.add_argument("--no-autolaunch", action="store_true", default=False, help="Do not launch app automatically")
-    args = parser.parse_args()
-    model_dir = args.dir
-
-    if args.cpu:
-        device = "cpu"
-    else:
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-
-    model_holder = ModelHolder(model_dir, device)
-    languages = ["EN", "JP", "ZH"]
-    langnames = ["English", "Japanese"]
-
-    model_names = model_holder.model_names
-    if len(model_names) == 0:
-        logger.error(f"No models found. Please place the model in {model_dir}.")
-        sys.exit(1)
-
-    voicedata, styledict = load_voicedata()
-    total_characters = sum(len(lang) for lang in voicedata)
-
-    text_input = gr.TextArea(label="Text", value=initial_text)
-    line_split = gr.Checkbox(label="Divide text seperately by line breaks", value=True)
-    split_interval = gr.Slider(minimum=0.0, maximum=2, value=0.5, step=0.1, label="Length of division seperation time (in seconds)")
-    language = gr.Dropdown(choices=languages, value="EN", label="Language")
-    sdp_ratio = gr.Slider(minimum=0, maximum=1, value=0.2, step=0.1, label="SDP Ratio")
-    noise_scale = gr.Slider(minimum=0.1, maximum=2, value=0.6, step=0.1, label="Noise")
-    noise_scale_w = gr.Slider(minimum=0.1, maximum=2, value=0.8, step=0.1, label="Noise_W")
-    speed_rate = gr.Slider(minimum=0.5, maximum=2.0, value=1.0, step=0.1, label="Kecepatan Suara")
-    use_style_text = gr.Checkbox(label="Use stylization text", value=False)
-    style_text = gr.Textbox(label="Style text", placeholder="Check the box to use this option!", visible=True)
-    style_text_weight = gr.Slider(minimum=0, maximum=1, value=0.7, step=0.1, label="Text stylization strength", visible=True)
-
-    # Theme menggunakan warna Slate (Abu-abu Baby) dan Zinc (Putih Bersih)
-    with gr.Blocks(theme=gr.themes.Soft(primary_hue="slate", secondary_hue="zinc"), title="Hololive Style-Bert-VITS2") as app:
-        # --- HEADER ---
-        gr.HTML(f"""
-        <div style="font-family: 'Arial', sans-serif; max-width: 800px; margin: 20px auto 10px auto; border: 1px solid #e2e8f0; border-radius: 12px; padding: 15px; background-color: #ffffff; text-align: center; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.05);">
-            <h1 style="color: #475569; margin: 0; font-weight: 800;">HOLOLIVE VTUBER</h1>
-            <p style="color: #94a3b8; font-size: 14px; margin-top: 5px; font-weight: 500;">VTUBER TTS • CODE by Mutsumi</p>
-        </div>
-
-        <div style="font-family: 'Arial', sans-serif; max-width: 800px; margin: 0 auto 20px auto; border: 1px solid #e2e8f0; border-radius: 10px; padding: 15px; background-color: white; display: flex; justify-content: space-around; align-items: center; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
-            <div style="text-align: center;">
-                <p style="color: #94a3b8; font-size: 11px; font-weight: 700; margin: 0; text-transform: uppercase; letter-spacing: 1px;">System Status</p>
-                <p style="color: #64748b; font-size: 14px; font-weight: 700; margin: 0;">● ONLINE</p>
-            </div>
-            <div style="height: 30px; border-left: 1px solid #f1f5f9;"></div>
-            <div style="text-align: center;">
-                <p style="color: #94a3b8; font-size: 11px; font-weight: 700; margin: 0; text-transform: uppercase; letter-spacing: 1px;">TOTAL VTUBER</p>
-                <p style="color: #475569; font-size: 14px; font-weight: 700; margin: 0;">{total_characters} Models</p>
-            </div>
-        </div>
-        """)
-
-        gr.Markdown(initial_md)
-        tone = gr.Textbox(label="Accent adjustment", visible=False)
-        use_tone = gr.Checkbox(label="Use accent adjustment", value=False, visible=False)
-
-        for vi in range(len(voicedata)):
-            with gr.TabItem(langnames[vi]):
-                for (name, model_path, model_path_full, voice_name, speakerid, datasetauthor, image, nospace) in voicedata[vi]:
-                    if nospace and is_hf_spaces:
-                        continue
-                    with gr.TabItem(name):
-                        mn = gr.Textbox(value=model_path, visible=False, interactive=False)
-                        mp = gr.Textbox(value=model_path_full, visible=False, interactive=False)
-                        spk = gr.Textbox(value=speakerid, visible=False, interactive=False)
-                        with gr.Row():
-                            with gr.Column():
-                                gr.Markdown(f"### {voice_name}")
-                                gr.Image(f"images/{image}", label=None, show_label=False, width=300, show_download_button=False, container=False, show_share_button=False)
-                            with gr.Column():
-                                with gr.TabItem("Style using a preset"):
-                                    style = gr.Dropdown(label="Current style", choices=styledict[model_path], value="Neutral")
-                                with gr.TabItem("Style using existing audio"):
-                                    ref_audio_path = gr.Audio(label="Reference Audio", type="filepath", sources=["upload"])
-                                style_weight = gr.Slider(minimum=0, maximum=20, value=3, step=0.1, label="Style strength")
-                            with gr.Column():
-                                tts_button = gr.Button("Generate Voice", variant="primary", interactive=True)
-                                text_output = gr.Textbox(label="Info")
-                                audio_output = gr.Audio(label="Result")
-
-                            tts_button.click(
-                                tts_fn,
-                                inputs=[mn, mp, text_input, language, ref_audio_path, sdp_ratio, noise_scale, noise_scale_w, speed_rate, line_split, split_interval, style_text, style_text_weight, use_style_text, style, style_weight, tone, use_tone, spk],
-                                outputs=[text_output, audio_output, tone],
-                            )
-
-        with gr.Row():
-            with gr.Column():
-                text_input.render()
-                line_split.render()
-                split_interval.render()
-                language.render()
-            with gr.Column():
-                sdp_ratio.render()
-                noise_scale.render()
-                noise_scale_w.render()
-                speed_rate.render()
-                use_style_text.render()
-                style_text.render()
-                style_text_weight.render()
-
-        with gr.Accordion("Styling Guide", open=False):
-            gr.Markdown(style_md)
-
-        # --- FOOTER ---
-        gr.HTML("""
-        <div style="font-family: 'Arial', sans-serif; max-width: 800px; margin: 30px auto 20px auto; border: 1px solid #e2e8f0; border-radius: 12px; padding: 20px; background-color: white; text-align: center; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.05);">
-            <h3 style="color: #475569; font-size: 16px; margin: 0; font-weight: 700; letter-spacing: 1px;">DESIGNED BY MUTSUMI</h3>
-            <p style="color: #94a3b8; font-size: 13px; margin-top: 4px; font-weight: 500;">Hololive TTS Implementation</p>
-        </div>
-        """)
-
-    app.launch(allowed_paths=['/file/images/'])

Hololive-Style-Bert-VITS2/attentions.py

@@ -1,462 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-from common.log import logger as logging
-
-
-class LayerNorm(nn.Module):
-    def __init__(self, channels, eps=1e-5):
-        super().__init__()
-        self.channels = channels
-        self.eps = eps
-
-        self.gamma = nn.Parameter(torch.ones(channels))
-        self.beta = nn.Parameter(torch.zeros(channels))
-
-    def forward(self, x):
-        x = x.transpose(1, -1)
-        x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-        return x.transpose(1, -1)
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-
-
-class Encoder(nn.Module):
-    def __init__(
-        self,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size=1,
-        p_dropout=0.0,
-        window_size=4,
-        isflow=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.window_size = window_size
-        # if isflow:
-        #  cond_layer = torch.nn.Conv1d(256, 2*hidden_channels*n_layers, 1)
-        #  self.cond_pre = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, 1)
-        #  self.cond_layer = weight_norm(cond_layer, name='weight')
-        #  self.gin_channels = 256
-        self.cond_layer_idx = self.n_layers
-        if "gin_channels" in kwargs:
-            self.gin_channels = kwargs["gin_channels"]
-            if self.gin_channels != 0:
-                self.spk_emb_linear = nn.Linear(self.gin_channels, self.hidden_channels)
-                # vits2 says 3rd block, so idx is 2 by default
-                self.cond_layer_idx = (
-                    kwargs["cond_layer_idx"] if "cond_layer_idx" in kwargs else 2
-                )
-                # logging.debug(self.gin_channels, self.cond_layer_idx)
-                assert (
-                    self.cond_layer_idx < self.n_layers
-                ), "cond_layer_idx should be less than n_layers"
-        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, g=None):
-        attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-        x = x * x_mask
-        for i in range(self.n_layers):
-            if i == self.cond_layer_idx and g is not None:
-                g = self.spk_emb_linear(g.transpose(1, 2))
-                g = g.transpose(1, 2)
-                x = x + g
-                x = x * x_mask
-            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.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.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):
-        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()
-        # pad 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.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

Hololive-Style-Bert-VITS2/bert_gen.py

@@ -1,84 +0,0 @@
-import argparse
-import sys
-from multiprocessing import Pool
-
-import torch
-import torch.multiprocessing as mp
-from tqdm import tqdm
-
-import commons
-import utils
-from config import config
-from text import cleaned_text_to_sequence, get_bert
-
-
-def process_line(x):
-    line, add_blank = x
-    device = config.bert_gen_config.device
-    if config.bert_gen_config.use_multi_device:
-        rank = mp.current_process()._identity
-        rank = rank[0] if len(rank) > 0 else 0
-        if torch.cuda.is_available():
-            gpu_id = rank % torch.cuda.device_count()
-            device = torch.device(f"cuda:{gpu_id}")
-        else:
-            device = torch.device("cpu")
-    wav_path, _, language_str, text, phones, tone, word2ph = line.strip().split("|")
-    phone = phones.split(" ")
-    tone = [int(i) for i in tone.split(" ")]
-    word2ph = [int(i) for i in word2ph.split(" ")]
-    word2ph = [i for i in word2ph]
-    phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
-
-    if add_blank:
-        phone = commons.intersperse(phone, 0)
-        tone = commons.intersperse(tone, 0)
-        language = commons.intersperse(language, 0)
-        for i in range(len(word2ph)):
-            word2ph[i] = word2ph[i] * 2
-        word2ph[0] += 1
-
-    bert_path = wav_path.replace(".WAV", ".wav").replace(".wav", ".bert.pt")
-
-    try:
-        bert = torch.load(bert_path)
-        assert bert.shape[-1] == len(phone)
-    except Exception:
-        bert = get_bert(text, word2ph, language_str, device)
-        assert bert.shape[-1] == len(phone)
-        torch.save(bert, bert_path)
-
-
-preprocess_text_config = config.preprocess_text_config
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-c", "--config", type=str, default=config.bert_gen_config.config_path
-    )
-    parser.add_argument(
-        "--num_processes", type=int, default=config.bert_gen_config.num_processes
-    )
-    args, _ = parser.parse_known_args()
-    config_path = args.config
-    hps = utils.get_hparams_from_file(config_path)
-    lines = []
-    with open(hps.data.training_files, encoding="utf-8") as f:
-        lines.extend(f.readlines())
-
-    with open(hps.data.validation_files, encoding="utf-8") as f:
-        lines.extend(f.readlines())
-    add_blank = [hps.data.add_blank] * len(lines)
-
-    if len(lines) != 0:
-        num_processes = args.num_processes
-        with Pool(processes=num_processes) as pool:
-            for _ in tqdm(
-                pool.imap_unordered(process_line, zip(lines, add_blank)),
-                total=len(lines),
-                file=sys.stdout,
-            ):
-                # 这里是缩进的代码块，表示循环体
-                pass  # 使用pass语句作为占位符
-
-    print(f"bert.pt is generated! total: {len(lines)} bert.pt files.")

Hololive-Style-Bert-VITS2/common/constants.py

@@ -1,20 +0,0 @@
-import enum
-
-DEFAULT_STYLE: str = "Neutral"
-DEFAULT_STYLE_WEIGHT: float = 5.0
-
-
-class Languages(str, enum.Enum):
-    JP = "JP"
-    EN = "EN"
-    ZH = "ZH"
-
-
-DEFAULT_SDP_RATIO: float = 0.2
-DEFAULT_NOISE: float = 0.6
-DEFAULT_NOISEW: float = 0.8
-DEFAULT_LENGTH: float = 1.0
-DEFAULT_LINE_SPLIT: bool = True
-DEFAULT_SPLIT_INTERVAL: float = 0.5
-DEFAULT_ASSIST_TEXT_WEIGHT: float = 0.7
-DEFAULT_ASSIST_TEXT_WEIGHT: float = 1.0

Hololive-Style-Bert-VITS2/common/log.py

@@ -1,16 +0,0 @@
-"""
-logger封装
-"""
-from loguru import logger
-
-from .stdout_wrapper import SAFE_STDOUT
-
-# 移除所有默认的处理器
-logger.remove()
-
-# 自定义格式并添加到标准输出
-log_format = (
-    "<g>{time:MM-DD HH:mm:ss}</g> |<lvl>{level:^8}</lvl>| {file}:{line} | {message}"
-)
-
-logger.add(SAFE_STDOUT, format=log_format, backtrace=True, diagnose=True)

Hololive-Style-Bert-VITS2/common/stdout_wrapper.py

@@ -1,34 +0,0 @@
-import sys
-import tempfile
-
-
-class StdoutWrapper:
-    def __init__(self):
-        self.temp_file = tempfile.NamedTemporaryFile(mode="w+", delete=False)
-        self.original_stdout = sys.stdout
-
-    def write(self, message: str):
-        self.temp_file.write(message)
-        self.temp_file.flush()
-        print(message, end="", file=self.original_stdout)
-
-    def flush(self):
-        self.temp_file.flush()
-
-    def read(self):
-        self.temp_file.seek(0)
-        return self.temp_file.read()
-
-    def close(self):
-        self.temp_file.close()
-
-    def fileno(self):
-        return self.temp_file.fileno()
-
-
-try:
-    import google.colab
-
-    SAFE_STDOUT = StdoutWrapper()
-except ImportError:
-    SAFE_STDOUT = sys.stdout

Hololive-Style-Bert-VITS2/common/subprocess_utils.py

@@ -1,32 +0,0 @@
-import subprocess
-import sys
-
-from .log import logger
-from .stdout_wrapper import SAFE_STDOUT
-
-python = sys.executable
-
-
-def run_script_with_log(cmd: list[str], ignore_warning=False) -> tuple[bool, str]:
-    logger.info(f"Running: {' '.join(cmd)}")
-    result = subprocess.run(
-        [python] + cmd,
-        stdout=SAFE_STDOUT,  # type: ignore
-        stderr=subprocess.PIPE,
-        text=True,
-    )
-    if result.returncode != 0:
-        logger.error(f"Error: {' '.join(cmd)}\n{result.stderr}")
-        return False, result.stderr
-    elif result.stderr and not ignore_warning:
-        logger.warning(f"Warning: {' '.join(cmd)}\n{result.stderr}")
-        return True, result.stderr
-    logger.success(f"Success: {' '.join(cmd)}")
-    return True, ""
-
-
-def second_elem_of(original_function):
-    def inner_function(*args, **kwargs):
-        return original_function(*args, **kwargs)[1]
-
-    return inner_function

Hololive-Style-Bert-VITS2/common/tts_model.py

@@ -1,250 +0,0 @@
-import numpy as np
-import gradio as gr
-import torch
-import os
-import warnings
-from gradio.processing_utils import convert_to_16_bit_wav
-from typing import Dict, List, Optional, Union
-
-import utils
-from infer import get_net_g, infer
-from models import SynthesizerTrn
-from models_jp_extra import SynthesizerTrn as SynthesizerTrnJPExtra
-
-from .log import logger
-from .constants import (
-    DEFAULT_ASSIST_TEXT_WEIGHT,
-    DEFAULT_LENGTH,
-    DEFAULT_LINE_SPLIT,
-    DEFAULT_NOISE,
-    DEFAULT_NOISEW,
-    DEFAULT_SDP_RATIO,
-    DEFAULT_SPLIT_INTERVAL,
-    DEFAULT_STYLE,
-    DEFAULT_STYLE_WEIGHT,
-)
-
-
-class Model:
-    def __init__(
-        self, model_path: str, config_path: str, style_vec_path: str, device: str
-    ):
-        self.model_path: str = model_path
-        self.config_path: str = config_path
-        self.device: str = device
-        self.style_vec_path: str = style_vec_path
-        self.hps: utils.HParams = utils.get_hparams_from_file(self.config_path)
-        self.spk2id: Dict[str, int] = self.hps.data.spk2id
-        self.id2spk: Dict[int, str] = {v: k for k, v in self.spk2id.items()}
-
-        self.num_styles: int = self.hps.data.num_styles
-        if hasattr(self.hps.data, "style2id"):
-            self.style2id: Dict[str, int] = self.hps.data.style2id
-        else:
-            self.style2id: Dict[str, int] = {str(i): i for i in range(self.num_styles)}
-        if len(self.style2id) != self.num_styles:
-            raise ValueError(
-                f"Number of styles ({self.num_styles}) does not match the number of style2id ({len(self.style2id)})"
-            )
-
-        self.style_vectors: np.ndarray = np.load(self.style_vec_path)
-        if self.style_vectors.shape[0] != self.num_styles:
-            raise ValueError(
-                f"The number of styles ({self.num_styles}) does not match the number of style vectors ({self.style_vectors.shape[0]})"
-            )
-
-        self.net_g: Union[SynthesizerTrn, SynthesizerTrnJPExtra, None] = None
-
-    def load_net_g(self):
-        self.net_g = get_net_g(
-            model_path=self.model_path,
-            version=self.hps.version,
-            device=self.device,
-            hps=self.hps,
-        )
-
-    def get_style_vector(self, style_id: int, weight: float = 1.0) -> np.ndarray:
-        mean = self.style_vectors[0]
-        style_vec = self.style_vectors[style_id]
-        style_vec = mean + (style_vec - mean) * weight
-        return style_vec
-
-    def get_style_vector_from_audio(
-        self, audio_path: str, weight: float = 1.0
-    ) -> np.ndarray:
-        from style_gen import get_style_vector
-
-        xvec = get_style_vector(audio_path)
-        mean = self.style_vectors[0]
-        xvec = mean + (xvec - mean) * weight
-        return xvec
-
-    def infer(
-        self,
-        text: str,
-        language: str = "JP",
-        sid: int = 0,
-        reference_audio_path: Optional[str] = None,
-        sdp_ratio: float = DEFAULT_SDP_RATIO,
-        noise: float = DEFAULT_NOISE,
-        noisew: float = DEFAULT_NOISEW,
-        length: float = DEFAULT_LENGTH,
-        line_split: bool = DEFAULT_LINE_SPLIT,
-        split_interval: float = DEFAULT_SPLIT_INTERVAL,
-        assist_text: Optional[str] = None,
-        assist_text_weight: float = DEFAULT_ASSIST_TEXT_WEIGHT,
-        use_assist_text: bool = False,
-        style: str = DEFAULT_STYLE,
-        style_weight: float = DEFAULT_STYLE_WEIGHT,
-        given_tone: Optional[list[int]] = None,
-    ) -> tuple[int, np.ndarray]:
-        #logger.info(f"Start generating audio data from text:\n{text}")
-        if language != "JP" and self.hps.version.endswith("JP-Extra"):
-            raise ValueError(
-                "The model is trained with JP-Extra, but the language is not JP"
-            )
-        if reference_audio_path == "":
-            reference_audio_path = None
-        if assist_text == "" or not use_assist_text:
-            assist_text = None
-
-        if self.net_g is None:
-            self.load_net_g()
-        if reference_audio_path is None:
-            style_id = self.style2id[style]
-            style_vector = self.get_style_vector(style_id, style_weight)
-        else:
-            style_vector = self.get_style_vector_from_audio(
-                reference_audio_path, style_weight
-            )
-        if not line_split:
-            with torch.no_grad():
-                audio = infer(
-                    text=text,
-                    sdp_ratio=sdp_ratio,
-                    noise_scale=noise,
-                    noise_scale_w=noisew,
-                    length_scale=length,
-                    sid=sid,
-                    language=language,
-                    hps=self.hps,
-                    net_g=self.net_g,
-                    device=self.device,
-                    assist_text=assist_text,
-                    assist_text_weight=assist_text_weight,
-                    style_vec=style_vector,
-                    given_tone=given_tone,
-                )
-        else:
-            texts = text.split("\n")
-            texts = [t for t in texts if t != ""]
-            audios = []
-            with torch.no_grad():
-                for i, t in enumerate(texts):
-                    audios.append(
-                        infer(
-                            text=t,
-                            sdp_ratio=sdp_ratio,
-                            noise_scale=noise,
-                            noise_scale_w=noisew,
-                            length_scale=length,
-                            sid=sid,
-                            language=language,
-                            hps=self.hps,
-                            net_g=self.net_g,
-                            device=self.device,
-                            assist_text=assist_text,
-                            assist_text_weight=assist_text_weight,
-                            style_vec=style_vector,
-                        )
-                    )
-                    if i != len(texts) - 1:
-                        audios.append(np.zeros(int(44100 * split_interval)))
-                audio = np.concatenate(audios)
-            with warnings.catch_warnings():
-                warnings.simplefilter("ignore")
-                audio = convert_to_16_bit_wav(audio)
-        #logger.info("Audio data generated successfully")
-        return (self.hps.data.sampling_rate, audio)
-
-
-class ModelHolder:
-    def __init__(self, root_dir: str, device: str):
-        self.root_dir: str = root_dir
-        self.device: str = device
-        self.model_files_dict: Dict[str, List[str]] = {}
-        self.current_model: Optional[Model] = None
-        self.model_names: List[str] = []
-        self.models: List[Model] = []
-        self.refresh()
-
-    def refresh(self):
-        self.model_files_dict = {}
-        self.model_names = []
-        self.current_model = None
-        model_dirs = [
-            d
-            for d in os.listdir(self.root_dir)
-            if os.path.isdir(os.path.join(self.root_dir, d))
-        ]
-        for model_name in model_dirs:
-            model_dir = os.path.join(self.root_dir, model_name)
-            model_files = [
-                os.path.join(model_dir, f)
-                for f in os.listdir(model_dir)
-                if f.endswith(".pth") or f.endswith(".pt") or f.endswith(".safetensors")
-            ]
-            if len(model_files) == 0:
-                logger.warning(
-                    f"No model files found in {self.root_dir}/{model_name}, so skip it"
-                )
-                continue
-            self.model_files_dict[model_name] = model_files
-            self.model_names.append(model_name)
-
-    def load_model_gr(
-        self, model_name: str, model_path: str
-    ) -> tuple[gr.Dropdown, gr.Button, gr.Dropdown]:
-        if model_name not in self.model_files_dict:
-            raise ValueError(f"Model `{model_name}` is not found")
-        #if model_path not in self.model_files_dict[model_name]:
-        #    raise ValueError(f"Model file `{model_path}` is not found")
-        if (
-            self.current_model is not None
-            and self.current_model.model_path == model_path
-        ):
-            # Already loaded
-            speakers = list(self.current_model.spk2id.keys())
-            styles = list(self.current_model.style2id.keys())
-            return (
-                gr.Dropdown(choices=styles, value=styles[0]),
-                gr.Button(interactive=True, value="音声合成"),
-                gr.Dropdown(choices=speakers, value=speakers[0]),
-            )
-        self.current_model = Model(
-            model_path=model_path,
-            config_path=os.path.join(self.root_dir, model_name, "config.json"),
-            style_vec_path=os.path.join(self.root_dir, model_name, "style_vectors.npy"),
-            device=self.device,
-        )
-        speakers = list(self.current_model.spk2id.keys())
-        styles = list(self.current_model.style2id.keys())
-        return (
-            gr.Dropdown(choices=styles, value=styles[0]),
-            gr.Button(interactive=True, value="音声合成"),
-            gr.Dropdown(choices=speakers, value=speakers[0]),
-        )
-
-    def update_model_files_gr(self, model_name: str) -> gr.Dropdown:
-        model_files = self.model_files_dict[model_name]
-        return gr.Dropdown(choices=model_files, value=model_files[0])
-
-    def update_model_names_gr(self) -> tuple[gr.Dropdown, gr.Dropdown, gr.Button]:
-        self.refresh()
-        initial_model_name = self.model_names[0]
-        initial_model_files = self.model_files_dict[initial_model_name]
-        return (
-            gr.Dropdown(choices=self.model_names, value=initial_model_name),
-            gr.Dropdown(choices=initial_model_files, value=initial_model_files[0]),
-            gr.Button(interactive=False),  # For tts_button
-        )

Hololive-Style-Bert-VITS2/commons.py

@@ -1,152 +0,0 @@
-import math
-import torch
-from torch.nn import functional as F
-
-
-def init_weights(m, mean=0.0, std=0.01):
-    classname = m.__class__.__name__
-    if classname.find("Conv") != -1:
-        m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
-    return int((kernel_size * dilation - dilation) / 2)
-
-
-def convert_pad_shape(pad_shape):
-    layer = pad_shape[::-1]
-    pad_shape = [item for sublist in layer for item in sublist]
-    return pad_shape
-
-
-def intersperse(lst, item):
-    result = [item] * (len(lst) * 2 + 1)
-    result[1::2] = lst
-    return result
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
-    """KL(P||Q)"""
-    kl = (logs_q - logs_p) - 0.5
-    kl += (
-        0.5 * (torch.exp(2.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * logs_q)
-    )
-    return kl
-
-
-def rand_gumbel(shape):
-    """Sample from the Gumbel distribution, protect from overflows."""
-    uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
-    return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
-    g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
-    return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
-    gather_indices = ids_str.view(x.size(0), 1, 1).repeat(
-        1, x.size(1), 1
-    ) + torch.arange(segment_size, device=x.device)
-    return torch.gather(x, 2, gather_indices)
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
-    b, d, t = x.size()
-    if x_lengths is None:
-        x_lengths = t
-    ids_str_max = torch.clamp(x_lengths - segment_size + 1, min=0)
-    ids_str = (torch.rand([b], device=x.device) * ids_str_max).to(dtype=torch.long)
-    ret = slice_segments(x, ids_str, segment_size)
-    return ret, ids_str
-
-
-def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):
-    position = torch.arange(length, dtype=torch.float)
-    num_timescales = channels // 2
-    log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / (
-        num_timescales - 1
-    )
-    inv_timescales = min_timescale * torch.exp(
-        torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment
-    )
-    scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
-    signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
-    signal = F.pad(signal, [0, 0, 0, channels % 2])
-    signal = signal.view(1, channels, length)
-    return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
-    b, channels, length = x.size()
-    signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
-    return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
-    mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
-    return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-
-
-def shift_1d(x):
-    x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
-    return x
-
-
-def sequence_mask(length, max_length=None):
-    if max_length is None:
-        max_length = length.max()
-    x = torch.arange(max_length, dtype=length.dtype, device=length.device)
-    return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
-    """
-    duration: [b, 1, t_x]
-    mask: [b, 1, t_y, t_x]
-    """
-
-    b, _, t_y, t_x = mask.shape
-    cum_duration = torch.cumsum(duration, -1)
-
-    cum_duration_flat = cum_duration.view(b * t_x)
-    path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
-    path = path.view(b, t_x, t_y)
-    path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
-    path = path.unsqueeze(1).transpose(2, 3) * mask
-    return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
-    if isinstance(parameters, torch.Tensor):
-        parameters = [parameters]
-    parameters = list(filter(lambda p: p.grad is not None, parameters))
-    norm_type = float(norm_type)
-    if clip_value is not None:
-        clip_value = float(clip_value)
-
-    total_norm = 0
-    for p in parameters:
-        param_norm = p.grad.data.norm(norm_type)
-        total_norm += param_norm.item() ** norm_type
-        if clip_value is not None:
-            p.grad.data.clamp_(min=-clip_value, max=clip_value)
-    total_norm = total_norm ** (1.0 / norm_type)
-    return total_norm

Hololive-Style-Bert-VITS2/config.py

@@ -1,269 +0,0 @@
-"""
-@Desc: 全局配置文件读取
-"""
-import argparse
-import os
-import shutil
-from typing import Dict, List
-
-import yaml
-
-from common.log import logger
-
-
-class Resample_config:
-    """重采样配置"""
-
-    def __init__(self, in_dir: str, out_dir: str, sampling_rate: int = 44100):
-        self.sampling_rate: int = sampling_rate  # 目标采样率
-        self.in_dir: str = in_dir  # 待处理音频目录路径
-        self.out_dir: str = out_dir  # 重采样输出路径
-
-    @classmethod
-    def from_dict(cls, dataset_path: str, data: Dict[str, any]):
-        """从字典中生成实例"""
-
-        # 不检查路径是否有效，此逻辑在resample.py中处理
-        data["in_dir"] = os.path.join(dataset_path, data["in_dir"])
-        data["out_dir"] = os.path.join(dataset_path, data["out_dir"])
-
-        return cls(**data)
-
-
-class Preprocess_text_config:
-    """数据预处理配置"""
-
-    def __init__(
-        self,
-        transcription_path: str,
-        cleaned_path: str,
-        train_path: str,
-        val_path: str,
-        config_path: str,
-        val_per_lang: int = 5,
-        max_val_total: int = 10000,
-        clean: bool = True,
-    ):
-        self.transcription_path: str = transcription_path  # 原始文本文件路径，文本格式应为{wav_path}|{speaker_name}|{language}|{text}。
-        self.cleaned_path: str = cleaned_path  # 数据清洗后文本路径，可以不填。不填则将在原始文本目录生成
-        self.train_path: str = train_path  # 训练集路径，可以不填。不填则将在原始文本目录生成
-        self.val_path: str = val_path  # 验证集路径，可以不填。不填则将在原始文本目录生成
-        self.config_path: str = config_path  # 配置文件路径
-        self.val_per_lang: int = val_per_lang  # 每个speaker的验证集条数
-        self.max_val_total: int = max_val_total  # 验证集最大条数，多于的会被截断并放到训练集中
-        self.clean: bool = clean  # 是否进行数据清洗
-
-    @classmethod
-    def from_dict(cls, dataset_path: str, data: Dict[str, any]):
-        """从字典中生成实例"""
-
-        data["transcription_path"] = os.path.join(
-            dataset_path, data["transcription_path"]
-        )
-        if data["cleaned_path"] == "" or data["cleaned_path"] is None:
-            data["cleaned_path"] = None
-        else:
-            data["cleaned_path"] = os.path.join(dataset_path, data["cleaned_path"])
-        data["train_path"] = os.path.join(dataset_path, data["train_path"])
-        data["val_path"] = os.path.join(dataset_path, data["val_path"])
-        data["config_path"] = os.path.join(dataset_path, data["config_path"])
-
-        return cls(**data)
-
-
-class Bert_gen_config:
-    """bert_gen 配置"""
-
-    def __init__(
-        self,
-        config_path: str,
-        num_processes: int = 2,
-        device: str = "cuda",
-        use_multi_device: bool = False,
-    ):
-        self.config_path = config_path
-        self.num_processes = num_processes
-        self.device = device
-        self.use_multi_device = use_multi_device
-
-    @classmethod
-    def from_dict(cls, dataset_path: str, data: Dict[str, any]):
-        data["config_path"] = os.path.join(dataset_path, data["config_path"])
-
-        return cls(**data)
-
-
-class Style_gen_config:
-    """style_gen 配置"""
-
-    def __init__(
-        self,
-        config_path: str,
-        num_processes: int = 4,
-        device: str = "cuda",
-    ):
-        self.config_path = config_path
-        self.num_processes = num_processes
-        self.device = device
-
-    @classmethod
-    def from_dict(cls, dataset_path: str, data: Dict[str, any]):
-        data["config_path"] = os.path.join(dataset_path, data["config_path"])
-
-        return cls(**data)
-
-
-class Train_ms_config:
-    """训练配置"""
-
-    def __init__(
-        self,
-        config_path: str,
-        env: Dict[str, any],
-        # base: Dict[str, any],
-        model_dir: str,
-        num_workers: int,
-        spec_cache: bool,
-        keep_ckpts: int,
-    ):
-        self.env = env  # 需要加载的环境变量
-        # self.base = base  # 底模配置
-        self.model_dir = model_dir  # 训练模型存储目录，该路径为相对于dataset_path的路径，而非项目根目录
-        self.config_path = config_path  # 配置文件路径
-        self.num_workers = num_workers  # worker数量
-        self.spec_cache = spec_cache  # 是否启用spec缓存
-        self.keep_ckpts = keep_ckpts  # ckpt数量
-
-    @classmethod
-    def from_dict(cls, dataset_path: str, data: Dict[str, any]):
-        # data["model"] = os.path.join(dataset_path, data["model"])
-        data["config_path"] = os.path.join(dataset_path, data["config_path"])
-
-        return cls(**data)
-
-
-class Webui_config:
-    """webui 配置"""
-
-    def __init__(
-        self,
-        device: str,
-        model: str,
-        config_path: str,
-        language_identification_library: str,
-        port: int = 7860,
-        share: bool = False,
-        debug: bool = False,
-    ):
-        self.device: str = device
-        self.model: str = model  # 端口号
-        self.config_path: str = config_path  # 是否公开部署，对外网开放
-        self.port: int = port  # 是否开启debug模式
-        self.share: bool = share  # 模型路径
-        self.debug: bool = debug  # 配置文件路径
-        self.language_identification_library: str = (
-            language_identification_library  # 语种识别库
-        )
-
-    @classmethod
-    def from_dict(cls, dataset_path: str, data: Dict[str, any]):
-        data["config_path"] = os.path.join(dataset_path, data["config_path"])
-        data["model"] = os.path.join(dataset_path, data["model"])
-        return cls(**data)
-
-
-class Server_config:
-    def __init__(
-        self,
-        port: int = 5000,
-        device: str = "cuda",
-        limit: int = 100,
-        language: str = "JP",
-        origins: List[str] = None,
-    ):
-        self.port: int = port
-        self.device: str = device
-        self.language: str = language
-        self.limit: int = limit
-        self.origins: List[str] = origins
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, any]):
-        return cls(**data)
-
-
-class Translate_config:
-    """翻译api配置"""
-
-    def __init__(self, app_key: str, secret_key: str):
-        self.app_key = app_key
-        self.secret_key = secret_key
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, any]):
-        return cls(**data)
-
-
-class Config:
-    def __init__(self, config_path: str, path_config: dict[str, str]):
-        if not os.path.isfile(config_path) and os.path.isfile("default_config.yml"):
-            shutil.copy(src="default_config.yml", dst=config_path)
-            logger.info(
-                f"A configuration file {config_path} has been generated based on the default configuration file default_config.yml."
-            )
-            logger.info(
-                "If you have no special needs, please do not modify default_config.yml."
-            )
-            # sys.exit(0)
-        with open(file=config_path, mode="r", encoding="utf-8") as file:
-            yaml_config: Dict[str, any] = yaml.safe_load(file.read())
-            model_name: str = yaml_config["model_name"]
-            self.model_name: str = model_name
-            if "dataset_path" in yaml_config:
-                dataset_path = yaml_config["dataset_path"]
-            else:
-                dataset_path = os.path.join(path_config["dataset_root"], model_name)
-            self.dataset_path: str = dataset_path
-            self.assets_root: str = path_config["assets_root"]
-            self.out_dir = os.path.join(self.assets_root, model_name)
-            self.resample_config: Resample_config = Resample_config.from_dict(
-                dataset_path, yaml_config["resample"]
-            )
-            self.preprocess_text_config: Preprocess_text_config = (
-                Preprocess_text_config.from_dict(
-                    dataset_path, yaml_config["preprocess_text"]
-                )
-            )
-            self.bert_gen_config: Bert_gen_config = Bert_gen_config.from_dict(
-                dataset_path, yaml_config["bert_gen"]
-            )
-            self.style_gen_config: Style_gen_config = Style_gen_config.from_dict(
-                dataset_path, yaml_config["style_gen"]
-            )
-            self.train_ms_config: Train_ms_config = Train_ms_config.from_dict(
-                dataset_path, yaml_config["train_ms"]
-            )
-            self.webui_config: Webui_config = Webui_config.from_dict(
-                dataset_path, yaml_config["webui"]
-            )
-            self.server_config: Server_config = Server_config.from_dict(
-                yaml_config["server"]
-            )
-            # self.translate_config: Translate_config = Translate_config.from_dict(
-            #     yaml_config["translate"]
-            # )
-
-
-with open(os.path.join("configs", "paths.yml"), "r", encoding="utf-8") as f:
-    path_config: dict[str, str] = yaml.safe_load(f.read())
-    # Should contain the following keys:
-    # - dataset_root: the root directory of the dataset, default to "Data"
-    # - assets_root: the root directory of the assets, default to "model_assets"
-
-
-try:
-    config = Config("config.yml", path_config)
-except (TypeError, KeyError):
-    logger.warning("Old config.yml found. Replace it with default_config.yml.")
-    shutil.copy(src="default_config.yml", dst="config.yml")
-    config = Config("config.yml", path_config)

Hololive-Style-Bert-VITS2/config.yml

@@ -1,51 +0,0 @@
-bert_gen:
-  config_path: config.json
-  device: cpu
-  num_processes: 2
-  use_multi_device: false
-dataset_path: Data\model_name
-model_name: model_name
-preprocess_text:
-  clean: true
-  cleaned_path: ''
-  config_path: config.json
-  max_val_total: 12
-  train_path: train.list
-  transcription_path: esd.list
-  val_path: val.list
-  val_per_lang: 4
-resample:
-  in_dir: raw
-  out_dir: wavs
-  sampling_rate: 44100
-server:
-  device: cuda
-  language: JP
-  limit: 100
-  origins:
-  - '*'
-  port: 5000
-style_gen:
-  config_path: config.json
-  device: cpu
-  num_processes: 4
-train_ms:
-  config_path: config.json
-  env:
-    LOCAL_RANK: 0
-    MASTER_ADDR: localhost
-    MASTER_PORT: 10086
-    RANK: 0
-    WORLD_SIZE: 1
-  keep_ckpts: 1
-  model_dir: models
-  num_workers: 16
-  spec_cache: true
-webui:
-  config_path: config.json
-  debug: false
-  device: cuda
-  language_identification_library: langid
-  model: models/G_8000.pth
-  port: 7860
-  share: false

Hololive-Style-Bert-VITS2/configs/config.json

@@ -1,71 +0,0 @@
-{
-  "model_name": "your_model_name",
-  "train": {
-    "log_interval": 200,
-    "eval_interval": 1000,
-    "seed": 42,
-    "epochs": 1000,
-    "learning_rate": 0.0002,
-    "betas": [0.8, 0.99],
-    "eps": 1e-9,
-    "batch_size": 4,
-    "bf16_run": true,
-    "lr_decay": 0.99995,
-    "segment_size": 16384,
-    "init_lr_ratio": 1,
-    "warmup_epochs": 0,
-    "c_mel": 45,
-    "c_kl": 1.0,
-    "skip_optimizer": false,
-    "freeze_ZH_bert": false,
-    "freeze_JP_bert": false,
-    "freeze_EN_bert": false,
-    "freeze_style": false
-  },
-  "data": {
-    "training_files": "Data/your_model_name/filelists/train.list",
-    "validation_files": "Data/your_model_name/filelists/val.list",
-    "max_wav_value": 32768.0,
-    "sampling_rate": 44100,
-    "filter_length": 2048,
-    "hop_length": 512,
-    "win_length": 2048,
-    "n_mel_channels": 128,
-    "mel_fmin": 0.0,
-    "mel_fmax": null,
-    "add_blank": true,
-    "n_speakers": 1,
-    "cleaned_text": true,
-    "num_styles": 1,
-    "style2id": {
-      "Neutral": 0
-    }
-  },
-  "model": {
-    "use_spk_conditioned_encoder": true,
-    "use_noise_scaled_mas": true,
-    "use_mel_posterior_encoder": false,
-    "use_duration_discriminator": true,
-    "inter_channels": 192,
-    "hidden_channels": 192,
-    "filter_channels": 768,
-    "n_heads": 2,
-    "n_layers": 6,
-    "kernel_size": 3,
-    "p_dropout": 0.1,
-    "resblock": "1",
-    "resblock_kernel_sizes": [3, 7, 11],
-    "resblock_dilation_sizes": [
-      [1, 3, 5],
-      [1, 3, 5],
-      [1, 3, 5]
-    ],
-    "upsample_rates": [8, 8, 2, 2, 2],
-    "upsample_initial_channel": 512,
-    "upsample_kernel_sizes": [16, 16, 8, 2, 2],
-    "n_layers_q": 3,
-    "use_spectral_norm": false,
-    "gin_channels": 256
-  },
-  "version": "2.0.1"
-}

Hololive-Style-Bert-VITS2/configs/configs_jp_extra.json

@@ -1,78 +0,0 @@
-{
-  "train": {
-    "log_interval": 200,
-    "eval_interval": 1000,
-    "seed": 42,
-    "epochs": 1000,
-    "learning_rate": 0.0001,
-    "betas": [0.8, 0.99],
-    "eps": 1e-9,
-    "batch_size": 24,
-    "bf16_run": false,
-    "fp16_run": false,
-    "lr_decay": 0.99996,
-    "segment_size": 16384,
-    "init_lr_ratio": 1,
-    "warmup_epochs": 0,
-    "c_mel": 45,
-    "c_kl": 1.0,
-    "c_commit": 100,
-    "skip_optimizer": true,
-    "freeze_ZH_bert": false,
-    "freeze_JP_bert": false,
-    "freeze_EN_bert": false,
-    "freeze_emo": false,
-    "freeze_style": false
-  },
-  "data": {
-    "use_jp_extra": true,
-    "training_files": "filelists/train.list",
-    "validation_files": "filelists/val.list",
-    "max_wav_value": 32768.0,
-    "sampling_rate": 44100,
-    "filter_length": 2048,
-    "hop_length": 512,
-    "win_length": 2048,
-    "n_mel_channels": 128,
-    "mel_fmin": 0.0,
-    "mel_fmax": null,
-    "add_blank": true,
-    "n_speakers": 512,
-    "cleaned_text": true
-  },
-  "model": {
-    "use_spk_conditioned_encoder": true,
-    "use_noise_scaled_mas": true,
-    "use_mel_posterior_encoder": false,
-    "use_duration_discriminator": false,
-    "use_wavlm_discriminator": true,
-    "inter_channels": 192,
-    "hidden_channels": 192,
-    "filter_channels": 768,
-    "n_heads": 2,
-    "n_layers": 6,
-    "kernel_size": 3,
-    "p_dropout": 0.1,
-    "resblock": "1",
-    "resblock_kernel_sizes": [3, 7, 11],
-    "resblock_dilation_sizes": [
-      [1, 3, 5],
-      [1, 3, 5],
-      [1, 3, 5]
-    ],
-    "upsample_rates": [8, 8, 2, 2, 2],
-    "upsample_initial_channel": 512,
-    "upsample_kernel_sizes": [16, 16, 8, 2, 2],
-    "n_layers_q": 3,
-    "use_spectral_norm": false,
-    "gin_channels": 512,
-    "slm": {
-      "model": "./slm/wavlm-base-plus",
-      "sr": 16000,
-      "hidden": 768,
-      "nlayers": 13,
-      "initial_channel": 64
-    }
-  },
-  "version": "2.0.1-JP-Extra"
-}

Hololive-Style-Bert-VITS2/configs/paths.yml

@@ -1,8 +0,0 @@
-# Root directory of the training dataset.
-# The training dataset of {model_name} should be placed in {dataset_root}/{model_name}.
-dataset_root: Data
-
-# Root directory of the model assets (for inference).
-# In training, the model assets will be saved to {assets_root}/{model_name},
-# and in inference, we load all the models from {assets_root}.
-assets_root: model_assets

Hololive-Style-Bert-VITS2/data_utils.py

@@ -1,425 +0,0 @@
-import os
-import random
-import torch
-import torch.utils.data
-from tqdm import tqdm
-import numpy as np
-from tools.log import logger
-import commons
-from mel_processing import spectrogram_torch, mel_spectrogram_torch
-from utils import load_wav_to_torch, load_filepaths_and_text
-from text import cleaned_text_to_sequence
-from config import config
-
-"""Multi speaker version"""
-
-
-class TextAudioSpeakerLoader(torch.utils.data.Dataset):
-    """
-    1) loads audio, speaker_id, text pairs
-    2) normalizes text and converts them to sequences of integers
-    3) computes spectrograms from audio files.
-    """
-
-    def __init__(self, audiopaths_sid_text, hparams):
-        self.audiopaths_sid_text = load_filepaths_and_text(audiopaths_sid_text)
-        self.max_wav_value = hparams.max_wav_value
-        self.sampling_rate = hparams.sampling_rate
-        self.filter_length = hparams.filter_length
-        self.hop_length = hparams.hop_length
-        self.win_length = hparams.win_length
-        self.sampling_rate = hparams.sampling_rate
-        self.spk_map = hparams.spk2id
-        self.hparams = hparams
-
-        self.use_mel_spec_posterior = getattr(
-            hparams, "use_mel_posterior_encoder", False
-        )
-        if self.use_mel_spec_posterior:
-            self.n_mel_channels = getattr(hparams, "n_mel_channels", 80)
-
-        self.cleaned_text = getattr(hparams, "cleaned_text", False)
-
-        self.add_blank = hparams.add_blank
-        self.min_text_len = getattr(hparams, "min_text_len", 1)
-        self.max_text_len = getattr(hparams, "max_text_len", 384)
-
-        random.seed(1234)
-        random.shuffle(self.audiopaths_sid_text)
-        self._filter()
-
-    def _filter(self):
-        """
-        Filter text & store spec lengths
-        """
-        # Store spectrogram lengths for Bucketing
-        # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
-        # spec_length = wav_length // hop_length
-
-        audiopaths_sid_text_new = []
-        lengths = []
-        skipped = 0
-        logger.info("Init dataset...")
-        for _id, spk, language, text, phones, tone, word2ph in tqdm(
-            self.audiopaths_sid_text
-        ):
-            audiopath = f"{_id}"
-            if self.min_text_len <= len(phones) and len(phones) <= self.max_text_len:
-                phones = phones.split(" ")
-                tone = [int(i) for i in tone.split(" ")]
-                word2ph = [int(i) for i in word2ph.split(" ")]
-                audiopaths_sid_text_new.append(
-                    [audiopath, spk, language, text, phones, tone, word2ph]
-                )
-                lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
-            else:
-                skipped += 1
-        logger.info(
-            "skipped: "
-            + str(skipped)
-            + ", total: "
-            + str(len(self.audiopaths_sid_text))
-        )
-        self.audiopaths_sid_text = audiopaths_sid_text_new
-        self.lengths = lengths
-
-    def get_audio_text_speaker_pair(self, audiopath_sid_text):
-        # separate filename, speaker_id and text
-        audiopath, sid, language, text, phones, tone, word2ph = audiopath_sid_text
-
-        bert, ja_bert, en_bert, phones, tone, language = self.get_text(
-            text, word2ph, phones, tone, language, audiopath
-        )
-
-        spec, wav = self.get_audio(audiopath)
-        sid = torch.LongTensor([int(self.spk_map[sid])])
-        style_vec = torch.FloatTensor(np.load(f"{audiopath}.npy"))
-        return (
-            phones,
-            spec,
-            wav,
-            sid,
-            tone,
-            language,
-            bert,
-            ja_bert,
-            en_bert,
-            style_vec,
-        )
-
-    def get_audio(self, filename):
-        audio, sampling_rate = load_wav_to_torch(filename)
-        if sampling_rate != self.sampling_rate:
-            raise ValueError(
-                "{} {} SR doesn't match target {} SR".format(
-                    filename, sampling_rate, self.sampling_rate
-                )
-            )
-        audio_norm = audio / self.max_wav_value
-        audio_norm = audio_norm.unsqueeze(0)
-        spec_filename = filename.replace(".wav", ".spec.pt")
-        if self.use_mel_spec_posterior:
-            spec_filename = spec_filename.replace(".spec.pt", ".mel.pt")
-        try:
-            spec = torch.load(spec_filename)
-        except:
-            if self.use_mel_spec_posterior:
-                spec = mel_spectrogram_torch(
-                    audio_norm,
-                    self.filter_length,
-                    self.n_mel_channels,
-                    self.sampling_rate,
-                    self.hop_length,
-                    self.win_length,
-                    self.hparams.mel_fmin,
-                    self.hparams.mel_fmax,
-                    center=False,
-                )
-            else:
-                spec = spectrogram_torch(
-                    audio_norm,
-                    self.filter_length,
-                    self.sampling_rate,
-                    self.hop_length,
-                    self.win_length,
-                    center=False,
-                )
-            spec = torch.squeeze(spec, 0)
-            if config.train_ms_config.spec_cache:
-                torch.save(spec, spec_filename)
-        return spec, audio_norm
-
-    def get_text(self, text, word2ph, phone, tone, language_str, wav_path):
-        phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
-        if self.add_blank:
-            phone = commons.intersperse(phone, 0)
-            tone = commons.intersperse(tone, 0)
-            language = commons.intersperse(language, 0)
-            for i in range(len(word2ph)):
-                word2ph[i] = word2ph[i] * 2
-            word2ph[0] += 1
-        bert_path = wav_path.replace(".wav", ".bert.pt")
-        try:
-            bert_ori = torch.load(bert_path)
-            assert bert_ori.shape[-1] == len(phone)
-        except Exception as e:
-            logger.warning("Bert load Failed")
-            logger.warning(e)
-
-        if language_str == "ZH":
-            bert = bert_ori
-            ja_bert = torch.zeros(1024, len(phone))
-            en_bert = torch.zeros(1024, len(phone))
-        elif language_str == "JP":
-            bert = torch.zeros(1024, len(phone))
-            ja_bert = bert_ori
-            en_bert = torch.zeros(1024, len(phone))
-        elif language_str == "EN":
-            bert = torch.zeros(1024, len(phone))
-            ja_bert = torch.zeros(1024, len(phone))
-            en_bert = bert_ori
-        phone = torch.LongTensor(phone)
-        tone = torch.LongTensor(tone)
-        language = torch.LongTensor(language)
-        return bert, ja_bert, en_bert, phone, tone, language
-
-    def get_sid(self, sid):
-        sid = torch.LongTensor([int(sid)])
-        return sid
-
-    def __getitem__(self, index):
-        return self.get_audio_text_speaker_pair(self.audiopaths_sid_text[index])
-
-    def __len__(self):
-        return len(self.audiopaths_sid_text)
-
-
-class TextAudioSpeakerCollate:
-    """Zero-pads model inputs and targets"""
-
-    def __init__(self, return_ids=False):
-        self.return_ids = return_ids
-
-    def __call__(self, batch):
-        """Collate's training batch from normalized text, audio and speaker identities
-        PARAMS
-        ------
-        batch: [text_normalized, spec_normalized, wav_normalized, sid]
-        """
-        # Right zero-pad all one-hot text sequences to max input length
-        _, ids_sorted_decreasing = torch.sort(
-            torch.LongTensor([x[1].size(1) for x in batch]), dim=0, descending=True
-        )
-
-        max_text_len = max([len(x[0]) for x in batch])
-        max_spec_len = max([x[1].size(1) for x in batch])
-        max_wav_len = max([x[2].size(1) for x in batch])
-
-        text_lengths = torch.LongTensor(len(batch))
-        spec_lengths = torch.LongTensor(len(batch))
-        wav_lengths = torch.LongTensor(len(batch))
-        sid = torch.LongTensor(len(batch))
-
-        text_padded = torch.LongTensor(len(batch), max_text_len)
-        tone_padded = torch.LongTensor(len(batch), max_text_len)
-        language_padded = torch.LongTensor(len(batch), max_text_len)
-        bert_padded = torch.FloatTensor(len(batch), 1024, max_text_len)
-        ja_bert_padded = torch.FloatTensor(len(batch), 1024, max_text_len)
-        en_bert_padded = torch.FloatTensor(len(batch), 1024, max_text_len)
-        style_vec = torch.FloatTensor(len(batch), 256)
-
-        spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len)
-        wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
-        text_padded.zero_()
-        tone_padded.zero_()
-        language_padded.zero_()
-        spec_padded.zero_()
-        wav_padded.zero_()
-        bert_padded.zero_()
-        ja_bert_padded.zero_()
-        en_bert_padded.zero_()
-        style_vec.zero_()
-
-        for i in range(len(ids_sorted_decreasing)):
-            row = batch[ids_sorted_decreasing[i]]
-
-            text = row[0]
-            text_padded[i, : text.size(0)] = text
-            text_lengths[i] = text.size(0)
-
-            spec = row[1]
-            spec_padded[i, :, : spec.size(1)] = spec
-            spec_lengths[i] = spec.size(1)
-
-            wav = row[2]
-            wav_padded[i, :, : wav.size(1)] = wav
-            wav_lengths[i] = wav.size(1)
-
-            sid[i] = row[3]
-
-            tone = row[4]
-            tone_padded[i, : tone.size(0)] = tone
-
-            language = row[5]
-            language_padded[i, : language.size(0)] = language
-
-            bert = row[6]
-            bert_padded[i, :, : bert.size(1)] = bert
-
-            ja_bert = row[7]
-            ja_bert_padded[i, :, : ja_bert.size(1)] = ja_bert
-
-            en_bert = row[8]
-            en_bert_padded[i, :, : en_bert.size(1)] = en_bert
-
-            style_vec[i, :] = row[9]
-
-        return (
-            text_padded,
-            text_lengths,
-            spec_padded,
-            spec_lengths,
-            wav_padded,
-            wav_lengths,
-            sid,
-            tone_padded,
-            language_padded,
-            bert_padded,
-            ja_bert_padded,
-            en_bert_padded,
-            style_vec,
-        )
-
-
-class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
-    """
-    Maintain similar input lengths in a batch.
-    Length groups are specified by boundaries.
-    Ex) boundaries = [b1, b2, b3] -> any batch is included either {x | b1 < length(x) <=b2} or {x | b2 < length(x) <= b3}.
-
-    It removes samples which are not included in the boundaries.
-    Ex) boundaries = [b1, b2, b3] -> any x s.t. length(x) <= b1 or length(x) > b3 are discarded.
-    """
-
-    def __init__(
-        self,
-        dataset,
-        batch_size,
-        boundaries,
-        num_replicas=None,
-        rank=None,
-        shuffle=True,
-    ):
-        super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle)
-        self.lengths = dataset.lengths
-        self.batch_size = batch_size
-        self.boundaries = boundaries
-
-        self.buckets, self.num_samples_per_bucket = self._create_buckets()
-        logger.info(f"Bucket info: {self.num_samples_per_bucket}")
-        logger.info(
-            f"Unused samples: {len(self.lengths) - sum(self.num_samples_per_bucket)}"
-        )
-        self.total_size = sum(self.num_samples_per_bucket)
-        self.num_samples = self.total_size // self.num_replicas
-
-    def _create_buckets(self):
-        buckets = [[] for _ in range(len(self.boundaries) - 1)]
-        for i in range(len(self.lengths)):
-            length = self.lengths[i]
-            idx_bucket = self._bisect(length)
-            if idx_bucket != -1:
-                buckets[idx_bucket].append(i)
-
-        try:
-            for i in range(len(buckets) - 1, 0, -1):
-                if len(buckets[i]) == 0:
-                    buckets.pop(i)
-                    self.boundaries.pop(i + 1)
-            assert all(len(bucket) > 0 for bucket in buckets)
-        # When one bucket is not traversed
-        except Exception as e:
-            print("Bucket warning ", e)
-            for i in range(len(buckets) - 1, -1, -1):
-                if len(buckets[i]) == 0:
-                    buckets.pop(i)
-                    self.boundaries.pop(i + 1)
-
-        num_samples_per_bucket = []
-        for i in range(len(buckets)):
-            len_bucket = len(buckets[i])
-            total_batch_size = self.num_replicas * self.batch_size
-            rem = (
-                total_batch_size - (len_bucket % total_batch_size)
-            ) % total_batch_size
-            num_samples_per_bucket.append(len_bucket + rem)
-        return buckets, num_samples_per_bucket
-
-    def __iter__(self):
-        # deterministically shuffle based on epoch
-        g = torch.Generator()
-        g.manual_seed(self.epoch)
-
-        indices = []
-        if self.shuffle:
-            for bucket in self.buckets:
-                indices.append(torch.randperm(len(bucket), generator=g).tolist())
-        else:
-            for bucket in self.buckets:
-                indices.append(list(range(len(bucket))))
-
-        batches = []
-        for i in range(len(self.buckets)):
-            bucket = self.buckets[i]
-            len_bucket = len(bucket)
-            if len_bucket == 0:
-                continue
-            ids_bucket = indices[i]
-            num_samples_bucket = self.num_samples_per_bucket[i]
-
-            # add extra samples to make it evenly divisible
-            rem = num_samples_bucket - len_bucket
-            ids_bucket = (
-                ids_bucket
-                + ids_bucket * (rem // len_bucket)
-                + ids_bucket[: (rem % len_bucket)]
-            )
-
-            # subsample
-            ids_bucket = ids_bucket[self.rank :: self.num_replicas]
-
-            # batching
-            for j in range(len(ids_bucket) // self.batch_size):
-                batch = [
-                    bucket[idx]
-                    for idx in ids_bucket[
-                        j * self.batch_size : (j + 1) * self.batch_size
-                    ]
-                ]
-                batches.append(batch)
-
-        if self.shuffle:
-            batch_ids = torch.randperm(len(batches), generator=g).tolist()
-            batches = [batches[i] for i in batch_ids]
-        self.batches = batches
-
-        assert len(self.batches) * self.batch_size == self.num_samples
-        return iter(self.batches)
-
-    def _bisect(self, x, lo=0, hi=None):
-        if hi is None:
-            hi = len(self.boundaries) - 1
-
-        if hi > lo:
-            mid = (hi + lo) // 2
-            if self.boundaries[mid] < x and x <= self.boundaries[mid + 1]:
-                return mid
-            elif x <= self.boundaries[mid]:
-                return self._bisect(x, lo, mid)
-            else:
-                return self._bisect(x, mid + 1, hi)
-        else:
-            return -1
-
-    def __len__(self):
-        return self.num_samples // self.batch_size

Hololive-Style-Bert-VITS2/default_config.yml

@@ -1,81 +0,0 @@
-# Global configuration file for Bert-VITS2
-
-model_name: "model_name"
-
-out_dir: "model_assets"
-
-# If you want to use a specific dataset path, uncomment the following line.
-# Otherwise, the dataset path is `Data/{model_name}`.
-
-# dataset_path: "your/dataset/path"
-
-resample:
-  sampling_rate: 44100
-  in_dir: "audios/raw"
-  out_dir: "audios/wavs"
-
-preprocess_text:
-  transcription_path: "filelists/esd.list"
-  cleaned_path: ""
-  train_path: "filelists/train.list"
-  val_path: "filelists/val.list"
-  config_path: "config.json"
-  val_per_lang: 4
-  max_val_total: 12
-  clean: true
-
-bert_gen:
-  config_path: "config.json"
-  num_processes: 4
-  device: "cuda"
-  use_multi_device: false
-
-style_gen:
-  config_path: "config.json"
-  num_processes: 4
-  device: "cuda"
-
-train_ms:
-  env:
-    MASTER_ADDR: "localhost"
-    MASTER_PORT: 10086
-    WORLD_SIZE: 1
-    LOCAL_RANK: 0
-    RANK: 0
-  model: "models"
-  config_path: "config.json"
-  num_workers: 16
-  spec_cache: True
-  keep_ckpts: 1 # Set this to 0 to keep all checkpoints
-
-webui:
-  # 推理设备
-  device: "cuda"
-  # 模型路径
-  model: "models/G_8000.pth"
-  # 配置文件路径
-  config_path: "config.json"
-  # 端口号
-  port: 7860
-  # 是否公开部署，对外网开放
-  share: false
-  # 是否开启debug模式
-  debug: false
-  # 语种识别库，可选langid, fastlid
-  language_identification_library: "langid"
-
-# server_fastapi's config
-# TODO: `server_fastapi.py` is not implemented yet for this version
-server:
-  port: 5000
-  device: "cuda"
-  models:
-    - model: ""
-      config: ""
-      device: "cuda"
-      language: "ZH"
-    - model: ""
-      config: ""
-      device: "cpu"
-      language: "JP"
-      speakers: []