Update parquet files

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Jingyi Li
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -1,12 +0,0 @@
----
-title: Sovits4.0 V2
-emoji: 📚
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,76 +0,0 @@
-import io
-import os
-
-os.system("wget -P hubert/ https://huggingface.co/spaces/innnky/nanami/resolve/main/checkpoint_best_legacy_500.pt")
-import gradio as gr
-import librosa
-import numpy as np
-import soundfile
-from inference.infer_tool import Svc
-import logging
-
-logging.getLogger('numba').setLevel(logging.WARNING)
-logging.getLogger('markdown_it').setLevel(logging.WARNING)
-logging.getLogger('urllib3').setLevel(logging.WARNING)
-logging.getLogger('matplotlib').setLevel(logging.WARNING)
-
-model = Svc("logs/44k/G_0.pth", "configs/config.json", cluster_model_path="logs/44k/kmeans_10000.pt")
-
-
-
-def vc_fn(sid, input_audio, vc_transform, auto_f0,cluster_ratio, noise_scale):
-    if input_audio is None:
-        return "You need to upload an audio", None
-    sampling_rate, audio = input_audio
-    # print(audio.shape,sampling_rate)
-    duration = audio.shape[0] / sampling_rate
-    if duration > 45:
-        return "请上传小于45s的音频，需要转换长音频请本地进行转换", None
-    audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
-    if len(audio.shape) > 1:
-        audio = librosa.to_mono(audio.transpose(1, 0))
-    if sampling_rate != 16000:
-        audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
-    print(audio.shape)
-    out_wav_path = "temp.wav"
-    soundfile.write(out_wav_path, audio, 16000, format="wav")
-    print( cluster_ratio, auto_f0, noise_scale)
-    out_audio, out_sr = model.infer(sid, vc_transform, out_wav_path,
-                                   cluster_infer_ratio=cluster_ratio,
-                                   auto_predict_f0=auto_f0,
-                                   noice_scale=noise_scale
-                                   )
-    audio = out_audio.numpy()
-    rms = librosa.feature.rms(audio, frame_length=2048, hop_length=512)[0]
-    target_rms = 0.1
-    current_rms = np.mean(rms)
-    gain = target_rms / current_rms
-    audio *= gain
-    return "Success", (44100, audio)
-
-
-app = gr.Blocks()
-with app:
-    with gr.Tabs():
-        with gr.TabItem("Basic"):
-            gr.Markdown(value="""
-                sovits4.0 在线demo
-                
-                此demo为预训练底模在线demo，使用数据：云灏 即霜 辉宇·星AI 派蒙 绫地宁宁
-                """)
-            spks = list(model.spk2id.keys())
-            sid = gr.Dropdown(label="音色", choices=["nen", "yunhao","paimon", "huiyu","jishuang"], value="paimon")
-            vc_input3 = gr.Audio(label="上传音频（长度小于45秒）")
-            vc_transform = gr.Number(label="变调（整数，可以正负，半音数量，升高八度就是12）", value=0)
-            cluster_ratio = gr.Number(label="聚类模型混合比例，0-1之间，默认为0不启用聚类，能提升音色相似度，但会导致咬字下降（如果使用建议0.5左右）", value=0)
-            auto_f0 = gr.Checkbox(label="自动f0预测，配合聚类模型f0预测效果更好,会导致变调功能失效（仅限转换语音，歌声不要勾选此项会究极跑调）", value=False)
-            noise_scale = gr.Number(label="noise_scale 建议不要动，会影响音质，玄学参数", value=0.4)
-            vc_submit = gr.Button("转换", variant="primary")
-            vc_output1 = gr.Textbox(label="Output Message")
-            vc_output2 = gr.Audio(label="Output Audio")
-        vc_submit.click(vc_fn, [sid, vc_input3, vc_transform,auto_f0,cluster_ratio, noise_scale], [vc_output1, vc_output2])
-
-    app.launch()
-
-
-

cluster/__init__.py

@@ -1,29 +0,0 @@
-import numpy as np
-import torch
-from sklearn.cluster import KMeans
-
-def get_cluster_model(ckpt_path):
-    checkpoint = torch.load(ckpt_path)
-    kmeans_dict = {}
-    for spk, ckpt in checkpoint.items():
-        km = KMeans(ckpt["n_features_in_"])
-        km.__dict__["n_features_in_"] = ckpt["n_features_in_"]
-        km.__dict__["_n_threads"] = ckpt["_n_threads"]
-        km.__dict__["cluster_centers_"] = ckpt["cluster_centers_"]
-        kmeans_dict[spk] = km
-    return kmeans_dict
-
-def get_cluster_result(model, x, speaker):
-    """
-        x: np.array [t, 256]
-        return cluster class result
-    """
-    return model[speaker].predict(x)
-
-def get_cluster_center_result(model, x,speaker):
-    """x: np.array [t, 256]"""
-    predict = model[speaker].predict(x)
-    return model[speaker].cluster_centers_[predict]
-
-def get_center(model, x,speaker):
-    return model[speaker].cluster_centers_[x]

cluster/train_cluster.py

@@ -1,89 +0,0 @@
-import os
-from glob import glob
-from pathlib import Path
-import torch
-import logging
-import argparse
-import torch
-import numpy as np
-from sklearn.cluster import KMeans, MiniBatchKMeans
-import tqdm
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-import time
-import random
-
-def train_cluster(in_dir, n_clusters, use_minibatch=True, verbose=False):
-
-    logger.info(f"Loading features from {in_dir}")
-    features = []
-    nums = 0
-    for path in tqdm.tqdm(in_dir.glob("*.soft.pt")):
-        features.append(torch.load(path).squeeze(0).numpy().T)
-        # print(features[-1].shape)
-    features = np.concatenate(features, axis=0)
-    print(nums, features.nbytes/ 1024**2, "MB , shape:",features.shape, features.dtype)
-    features = features.astype(np.float32)
-    logger.info(f"Clustering features of shape: {features.shape}")
-    t = time.time()
-    if use_minibatch:
-        kmeans = MiniBatchKMeans(n_clusters=n_clusters,verbose=verbose, batch_size=4096, max_iter=80).fit(features)
-    else:
-        kmeans = KMeans(n_clusters=n_clusters,verbose=verbose).fit(features)
-    print(time.time()-t, "s")
-
-    x = {
-            "n_features_in_": kmeans.n_features_in_,
-            "_n_threads": kmeans._n_threads,
-            "cluster_centers_": kmeans.cluster_centers_,
-    }
-    print("end")
-
-    return x
-
-
-if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--dataset', type=Path, default="./dataset/44k",
-                        help='path of training data directory')
-    parser.add_argument('--output', type=Path, default="logs/44k",
-                        help='path of model output directory')
-
-    args = parser.parse_args()
-
-    checkpoint_dir = args.output
-    dataset = args.dataset
-    n_clusters = 10000
-
-    ckpt = {}
-    for spk in os.listdir(dataset):
-        if os.path.isdir(dataset/spk):
-            print(f"train kmeans for {spk}...")
-            in_dir = dataset/spk
-            x = train_cluster(in_dir, n_clusters, verbose=False)
-            ckpt[spk] = x
-
-    checkpoint_path = checkpoint_dir / f"kmeans_{n_clusters}.pt"
-    checkpoint_path.parent.mkdir(exist_ok=True, parents=True)
-    torch.save(
-        ckpt,
-        checkpoint_path,
-    )
-
-
-    # import cluster
-    # for spk in tqdm.tqdm(os.listdir("dataset")):
-    #     if os.path.isdir(f"dataset/{spk}"):
-    #         print(f"start kmeans inference for {spk}...")
-    #         for feature_path in tqdm.tqdm(glob(f"dataset/{spk}/*.discrete.npy", recursive=True)):
-    #             mel_path = feature_path.replace(".discrete.npy",".mel.npy")
-    #             mel_spectrogram = np.load(mel_path)
-    #             feature_len = mel_spectrogram.shape[-1]
-    #             c = np.load(feature_path)
-    #             c = utils.tools.repeat_expand_2d(torch.FloatTensor(c), feature_len).numpy()
-    #             feature = c.T
-    #             feature_class = cluster.get_cluster_result(feature, spk)
-    #             np.save(feature_path.replace(".discrete.npy", ".discrete_class.npy"), feature_class)
-
-

configs/config.json

@@ -1,106 +0,0 @@
-{
-  "train": {
-    "log_interval": 50,
-    "eval_interval": 1000,
-    "seed": 1234,
-    "port": 8001,
-    "epochs": 10000,
-    "learning_rate": 0.0002,
-    "betas": [
-      0.8,
-      0.99
-    ],
-    "eps": 1e-09,
-    "batch_size": 6,
-    "accumulation_steps": 1,
-    "fp16_run": false,
-    "lr_decay": 0.998,
-    "segment_size": 10240,
-    "init_lr_ratio": 1,
-    "warmup_epochs": 0,
-    "c_mel": 45,
-    "keep_ckpts":4
-  },
-  "data": {
-    "data_dir": "dataset",
-    "dataset_type": "SingDataset",
-    "collate_type": "SingCollate",
-    "training_filelist": "filelists/train-Copy1.txt",
-    "validation_filelist": "filelists/val-Copy1.txt",
-    "max_wav_value": 32768.0,
-    "sampling_rate": 44100,
-    "n_fft": 2048,
-    "fmin": 0,
-    "fmax": 22050,
-    "hop_length": 512,
-    "win_size": 2048,
-    "acoustic_dim": 80,
-    "c_dim": 256,
-    "min_level_db": -115,
-    "ref_level_db": 20,
-    "min_db": -115,
-    "max_abs_value": 4.0,
-    "n_speakers": 200
-  },
-  "model": {
-    "hidden_channels": 192,
-    "spk_channels": 192,
-    "filter_channels": 768,
-    "n_heads": 2,
-    "n_layers": 4,
-    "kernel_size": 3,
-    "p_dropout": 0.1,
-    "prior_hidden_channels": 192,
-    "prior_filter_channels": 768,
-    "prior_n_heads": 2,
-    "prior_n_layers": 4,
-    "prior_kernel_size": 3,
-    "prior_p_dropout": 0.1,
-    "resblock": "1",
-    "use_spectral_norm": false,
-    "resblock_kernel_sizes": [
-      3,
-      7,
-      11
-    ],
-    "resblock_dilation_sizes": [
-      [
-        1,
-        3,
-        5
-      ],
-      [
-        1,
-        3,
-        5
-      ],
-      [
-        1,
-        3,
-        5
-      ]
-    ],
-    "upsample_rates": [
-      8,
-      8,
-      4,
-      2
-    ],
-    "upsample_initial_channel": 256,
-    "upsample_kernel_sizes": [
-      16,
-      16,
-      8,
-      4
-    ],
-    "n_harmonic": 64,
-    "n_bands": 65
-  },
-  "spk": {
-    "jishuang": 0,
-    "huiyu": 1,
-    "nen": 2,
-    "paimon": 3,
-    "yunhao": 4
-  }
-}

data_utils.py

@@ -1,329 +0,0 @@
-import os
-import sys
-import string
-import random
-import numpy as np
-import math
-import json
-from torch.utils.data import DataLoader
-import torch
-
-import utils
-from modules import audio
-
-sys.path.append('../..')
-from utils import load_wav
-
-
-class BaseDataset(torch.utils.data.Dataset):
-
-    def __init__(self, hparams, fileid_list_path):
-        self.hparams = hparams
-        self.fileid_list = self.get_fileid_list(fileid_list_path)
-        random.seed(hparams.train.seed)
-        random.shuffle(self.fileid_list)
-        if (hparams.data.n_speakers > 0):
-            self.spk2id = hparams.spk
-
-    def get_fileid_list(self, fileid_list_path):
-        fileid_list = []
-        with open(fileid_list_path, 'r') as f:
-            for line in f.readlines():
-                fileid_list.append(line.strip())
-
-        return fileid_list
-
-    def __len__(self):
-        return len(self.fileid_list)
-
-
-class SingDataset(BaseDataset):
-    def __init__(self, hparams, data_dir, fileid_list_path):
-        BaseDataset.__init__(self, hparams, fileid_list_path)
-        self.hps = hparams
-        self.data_dir = data_dir
-        # self.__filter__()
-
-    def __filter__(self):
-        new_fileid_list= []
-        for wav_path in self.fileid_list:
-            # mel_path = wav_path + ".mel.npy"
-            # mel = np.load(mel_path)
-            # if mel.shape[0] < 60:
-            #     print("skip short audio:", wav_path)
-            #     continue
-            # if mel.shape[0] > 800:
-            #     print("skip long audio:", wav_path)
-            #     continue
-            # assert mel.shape[1] == 80
-            new_fileid_list.append(wav_path)
-        print("original length:", len(self.fileid_list))
-        print("filtered length:", len(new_fileid_list))
-        self.fileid_list = new_fileid_list
-
-    def interpolate_f0(self, data):
-        '''
-        对F0进行插值处理
-        '''
-        data = np.reshape(data, (data.size, 1))
-
-        vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
-        vuv_vector[data > 0.0] = 1.0
-        vuv_vector[data <= 0.0] = 0.0
-
-        ip_data = data
-
-        frame_number = data.size
-        last_value = 0.0
-        for i in range(frame_number):
-            if data[i] <= 0.0:
-                j = i + 1
-                for j in range(i + 1, frame_number):
-                    if data[j] > 0.0:
-                        break
-                if j < frame_number - 1:
-                    if last_value > 0.0:
-                        step = (data[j] - data[i - 1]) / float(j - i)
-                        for k in range(i, j):
-                            ip_data[k] = data[i - 1] + step * (k - i + 1)
-                    else:
-                        for k in range(i, j):
-                            ip_data[k] = data[j]
-                else:
-                    for k in range(i, frame_number):
-                        ip_data[k] = last_value
-            else:
-                ip_data[i] = data[i]
-                last_value = data[i]
-
-        return ip_data, vuv_vector
-
-    def parse_label(self, pho, pitchid, dur, slur, gtdur):
-        phos = []
-        pitchs = []
-        durs = []
-        slurs = []
-        gtdurs = []
-
-        for index in range(len(pho.split())):
-            phos.append(npu.symbol_converter.ttsing_phone_to_int[pho.strip().split()[index]])
-            pitchs.append(0)
-            durs.append(0)
-            slurs.append(0)
-            gtdurs.append(float(gtdur.strip().split()[index]))
-
-        phos = np.asarray(phos, dtype=np.int32)
-        pitchs = np.asarray(pitchs, dtype=np.int32)
-        durs = np.asarray(durs, dtype=np.float32)
-        slurs = np.asarray(slurs, dtype=np.int32)
-        gtdurs = np.asarray(gtdurs, dtype=np.float32)
-
-        acc_duration = np.cumsum(gtdurs)
-        acc_duration = np.pad(acc_duration, (1, 0), 'constant', constant_values=(0,))
-        acc_duration_frames = np.ceil(acc_duration / (self.hps.data.hop_length / self.hps.data.sampling_rate))
-        gtdurs = acc_duration_frames[1:] - acc_duration_frames[:-1]
-
-        # new_phos = []
-        # new_gtdurs=[]
-        # for ph, dur in zip(phos, gtdurs):
-        #     for i in range(int(dur)):
-        #         new_phos.append(ph)
-        #         new_gtdurs.append(1)
-
-        phos = torch.LongTensor(phos)
-        pitchs = torch.LongTensor(pitchs)
-        durs = torch.FloatTensor(durs)
-        slurs = torch.LongTensor(slurs)
-        gtdurs = torch.LongTensor(gtdurs)
-        return phos, pitchs, durs, slurs, gtdurs
-
-    def __getitem__(self, index):
-        wav_path = self.fileid_list[index]
-
-        spk = wav_path.split('/')[-2]
-        spkid = self.spk2id[spk]
-
-        wav = load_wav(wav_path,
-                       raw_sr=self.hparams.data.sampling_rate,
-                       target_sr=self.hparams.data.sampling_rate,
-                       win_size=self.hparams.data.win_size,
-                       hop_size=self.hparams.data.hop_length)
-
-        mel_path = wav_path + ".mel.npy"
-        if not os.path.exists(mel_path):
-            mel = audio.melspectrogram(wav, self.hparams.data).astype(np.float32).T
-            np.save(mel_path, mel)
-        else:
-            mel = np.load(mel_path)
-
-        if mel.shape[0] < 30:
-            print("skip short audio:", self.fileid_list[index])
-            return None
-        assert mel.shape[1] == 80
-        mel = torch.FloatTensor(mel).transpose(0, 1)
-
-        f0_path = wav_path + ".f0.npy"
-        f0 = np.load(f0_path)
-        assert abs(f0.shape[0]-mel.shape[1]) < 2, (f0.shape ,mel.shape)
-        sum_dur = min(f0.shape[0], mel.shape[1])
-        f0 = f0[:sum_dur]
-        mel = mel[:, :sum_dur]
-
-        f0, uv = self.interpolate_f0(f0)
-        f0 = f0.reshape([-1])
-        f0 = torch.FloatTensor(f0).reshape([1, -1])
-
-        uv = uv.reshape([-1])
-        uv = torch.FloatTensor(uv).reshape([1, -1])
-
-        wav = wav.reshape(-1)
-        if (wav.shape[0] != sum_dur * self.hparams.data.hop_length):
-            if (abs(wav.shape[0] - sum_dur * self.hparams.data.hop_length) > 3 * self.hparams.data.hop_length):
-                print("dataset error wav : ", wav.shape, sum_dur)
-                return None
-            if (wav.shape[0] > sum_dur * self.hparams.data.hop_length):
-                wav = wav[:sum_dur * self.hparams.data.hop_length]
-            else:
-                wav = np.concatenate([wav, np.zeros([sum_dur * self.hparams.data.hop_length - wav.shape[0]])], axis=0)
-        wav = torch.FloatTensor(wav).reshape([1, -1])
-
-        c_path = wav_path + ".soft.pt"
-        c = torch.load(c_path)
-        c = utils.repeat_expand_2d(c.squeeze(0), sum_dur)
-
-        assert f0.shape[1] == mel.shape[1]
-
-        if mel.shape[1] > 800:
-            start = random.randint(0, mel.shape[1]-800)
-            end = start + 790
-            mel = mel[:, start:end]
-            f0 = f0[:, start:end]
-            uv = uv[:, start:end]
-            c = c[:, start:end]
-            wav = wav[:, start*self.hparams.data.hop_length:end*self.hparams.data.hop_length]
-        return c, mel, f0, wav, spkid, uv
-
-
-class SingCollate():
-
-    def __init__(self, hparams):
-        self.hparams = hparams
-        self.mel_dim = self.hparams.data.acoustic_dim
-
-    def __call__(self, batch):
-        batch = [b for b in batch if b is not None]
-
-        input_lengths, ids_sorted_decreasing = torch.sort(
-            torch.LongTensor([len(x[0]) for x in batch]),
-            dim=0, descending=True)
-
-        max_c_len = max([x[0].size(1) for x in batch])
-        max_mel_len = max([x[1].size(1) for x in batch])
-        max_f0_len = max([x[2].size(1) for x in batch])
-        max_wav_len = max([x[3].size(1) for x in batch])
-
-        c_lengths = torch.LongTensor(len(batch))
-        mel_lengths = torch.LongTensor(len(batch))
-        f0_lengths = torch.LongTensor(len(batch))
-        wav_lengths = torch.LongTensor(len(batch))
-
-        c_padded = torch.FloatTensor(len(batch), self.hparams.data.c_dim, max_mel_len)
-        mel_padded = torch.FloatTensor(len(batch), self.hparams.data.acoustic_dim, max_mel_len)
-        f0_padded = torch.FloatTensor(len(batch), 1, max_f0_len)
-        uv_padded = torch.FloatTensor(len(batch), 1, max_f0_len)
-        wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
-        spkids = torch.LongTensor(len(batch))
-
-        c_padded.zero_()
-        mel_padded.zero_()
-        f0_padded.zero_()
-        uv_padded.zero_()
-        wav_padded.zero_()
-
-        for i in range(len(ids_sorted_decreasing)):
-            row = batch[ids_sorted_decreasing[i]]
-
-            c = row[0]
-            c_padded[i, :, :c.size(1)] = c
-            c_lengths[i] = c.size(1)
-
-            mel = row[1]
-            mel_padded[i, :, :mel.size(1)] = mel
-            mel_lengths[i] = mel.size(1)
-
-            f0 = row[2]
-            f0_padded[i, :, :f0.size(1)] = f0
-            f0_lengths[i] = f0.size(1)
-
-            wav = row[3]
-            wav_padded[i, :, :wav.size(1)] = wav
-            wav_lengths[i] = wav.size(1)
-
-            spkids[i] = row[4]
-
-            uv = row[5]
-            uv_padded[i, :, :uv.size(1)] = uv
-
-
-        data_dict = {}
-
-        data_dict["c"] = c_padded
-        data_dict["mel"] = mel_padded
-        data_dict["f0"] = f0_padded
-        data_dict["uv"] = uv_padded
-        data_dict["wav"] = wav_padded
-
-        data_dict["c_lengths"] = c_lengths
-        data_dict["mel_lengths"] = mel_lengths
-        data_dict["f0_lengths"] = f0_lengths
-        data_dict["wav_lengths"] = wav_lengths
-        data_dict["spkid"] = spkids
-
-        return data_dict
-
-
-class DatasetConstructor():
-
-    def __init__(self, hparams, num_replicas=1, rank=1):
-        self.hparams = hparams
-        self.num_replicas = num_replicas
-        self.rank = rank
-        self.dataset_function = {"SingDataset": SingDataset}
-        self.collate_function = {"SingCollate": SingCollate}
-        self._get_components()
-
-    def _get_components(self):
-        self._init_datasets()
-        self._init_collate()
-        self._init_data_loaders()
-
-    def _init_datasets(self):
-        self._train_dataset = self.dataset_function[self.hparams.data.dataset_type](self.hparams,
-                                                                                    self.hparams.data.data_dir,
-                                                                                    self.hparams.data.training_filelist)
-        self._valid_dataset = self.dataset_function[self.hparams.data.dataset_type](self.hparams,
-                                                                                    self.hparams.data.data_dir,
-                                                                                    self.hparams.data.validation_filelist)
-
-    def _init_collate(self):
-        self._collate_fn = self.collate_function[self.hparams.data.collate_type](self.hparams)
-
-    def _init_data_loaders(self):
-        train_sampler = torch.utils.data.distributed.DistributedSampler(self._train_dataset,
-                                                                        num_replicas=self.num_replicas, rank=self.rank,
-                                                                        shuffle=True)
-
-        self.train_loader = DataLoader(self._train_dataset, num_workers=4, shuffle=False,
-                                       batch_size=self.hparams.train.batch_size, pin_memory=True,
-                                       drop_last=True, collate_fn=self._collate_fn, sampler=train_sampler)
-
-        self.valid_loader = DataLoader(self._valid_dataset, num_workers=1, shuffle=False,
-                                       batch_size=1, pin_memory=True,
-                                       drop_last=True, collate_fn=self._collate_fn)
-
-    def get_train_loader(self):
-        return self.train_loader
-
-    def get_valid_loader(self):
-        return self.valid_loader
-

filelists/test.txt

@@ -1,4 +0,0 @@
-./dataset/44k/taffy/000562.wav
-./dataset/44k/nyaru/000011.wav
-./dataset/44k/nyaru/000008.wav
-./dataset/44k/taffy/000563.wav

filelists/train.txt

@@ -1,15 +0,0 @@
-./dataset/44k/taffy/000549.wav
-./dataset/44k/nyaru/000004.wav
-./dataset/44k/nyaru/000006.wav
-./dataset/44k/taffy/000551.wav
-./dataset/44k/nyaru/000009.wav
-./dataset/44k/taffy/000561.wav
-./dataset/44k/nyaru/000001.wav
-./dataset/44k/taffy/000553.wav
-./dataset/44k/nyaru/000002.wav
-./dataset/44k/taffy/000560.wav
-./dataset/44k/taffy/000557.wav
-./dataset/44k/nyaru/000005.wav
-./dataset/44k/taffy/000554.wav
-./dataset/44k/taffy/000550.wav
-./dataset/44k/taffy/000559.wav

filelists/val.txt

@@ -1,4 +0,0 @@
-./dataset/44k/nyaru/000003.wav
-./dataset/44k/nyaru/000007.wav
-./dataset/44k/taffy/000558.wav
-./dataset/44k/taffy/000556.wav

hubert/hubert_model.py

@@ -1,222 +0,0 @@
-import copy
-import random
-from typing import Optional, Tuple
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as t_func
-from torch.nn.modules.utils import consume_prefix_in_state_dict_if_present
-
-
-class Hubert(nn.Module):
-    def __init__(self, num_label_embeddings: int = 100, mask: bool = True):
-        super().__init__()
-        self._mask = mask
-        self.feature_extractor = FeatureExtractor()
-        self.feature_projection = FeatureProjection()
-        self.positional_embedding = PositionalConvEmbedding()
-        self.norm = nn.LayerNorm(768)
-        self.dropout = nn.Dropout(0.1)
-        self.encoder = TransformerEncoder(
-            nn.TransformerEncoderLayer(
-                768, 12, 3072, activation="gelu", batch_first=True
-            ),
-            12,
-        )
-        self.proj = nn.Linear(768, 256)
-
-        self.masked_spec_embed = nn.Parameter(torch.FloatTensor(768).uniform_())
-        self.label_embedding = nn.Embedding(num_label_embeddings, 256)
-
-    def mask(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
-        mask = None
-        if self.training and self._mask:
-            mask = _compute_mask((x.size(0), x.size(1)), 0.8, 10, x.device, 2)
-            x[mask] = self.masked_spec_embed.to(x.dtype)
-        return x, mask
-
-    def encode(
-            self, x: torch.Tensor, layer: Optional[int] = None
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        x = self.feature_extractor(x)
-        x = self.feature_projection(x.transpose(1, 2))
-        x, mask = self.mask(x)
-        x = x + self.positional_embedding(x)
-        x = self.dropout(self.norm(x))
-        x = self.encoder(x, output_layer=layer)
-        return x, mask
-
-    def logits(self, x: torch.Tensor) -> torch.Tensor:
-        logits = torch.cosine_similarity(
-            x.unsqueeze(2),
-            self.label_embedding.weight.unsqueeze(0).unsqueeze(0),
-            dim=-1,
-        )
-        return logits / 0.1
-
-    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
-        x, mask = self.encode(x)
-        x = self.proj(x)
-        logits = self.logits(x)
-        return logits, mask
-
-
-class HubertSoft(Hubert):
-    def __init__(self):
-        super().__init__()
-
-    @torch.inference_mode()
-    def units(self, wav: torch.Tensor) -> torch.Tensor:
-        wav = t_func.pad(wav, ((400 - 320) // 2, (400 - 320) // 2))
-        x, _ = self.encode(wav)
-        return self.proj(x)
-
-
-class FeatureExtractor(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.conv0 = nn.Conv1d(1, 512, 10, 5, bias=False)
-        self.norm0 = nn.GroupNorm(512, 512)
-        self.conv1 = nn.Conv1d(512, 512, 3, 2, bias=False)
-        self.conv2 = nn.Conv1d(512, 512, 3, 2, bias=False)
-        self.conv3 = nn.Conv1d(512, 512, 3, 2, bias=False)
-        self.conv4 = nn.Conv1d(512, 512, 3, 2, bias=False)
-        self.conv5 = nn.Conv1d(512, 512, 2, 2, bias=False)
-        self.conv6 = nn.Conv1d(512, 512, 2, 2, bias=False)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = t_func.gelu(self.norm0(self.conv0(x)))
-        x = t_func.gelu(self.conv1(x))
-        x = t_func.gelu(self.conv2(x))
-        x = t_func.gelu(self.conv3(x))
-        x = t_func.gelu(self.conv4(x))
-        x = t_func.gelu(self.conv5(x))
-        x = t_func.gelu(self.conv6(x))
-        return x
-
-
-class FeatureProjection(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.norm = nn.LayerNorm(512)
-        self.projection = nn.Linear(512, 768)
-        self.dropout = nn.Dropout(0.1)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.norm(x)
-        x = self.projection(x)
-        x = self.dropout(x)
-        return x
-
-
-class PositionalConvEmbedding(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.conv = nn.Conv1d(
-            768,
-            768,
-            kernel_size=128,
-            padding=128 // 2,
-            groups=16,
-        )
-        self.conv = nn.utils.weight_norm(self.conv, name="weight", dim=2)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.conv(x.transpose(1, 2))
-        x = t_func.gelu(x[:, :, :-1])
-        return x.transpose(1, 2)
-
-
-class TransformerEncoder(nn.Module):
-    def __init__(
-            self, encoder_layer: nn.TransformerEncoderLayer, num_layers: int
-    ) -> None:
-        super(TransformerEncoder, self).__init__()
-        self.layers = nn.ModuleList(
-            [copy.deepcopy(encoder_layer) for _ in range(num_layers)]
-        )
-        self.num_layers = num_layers
-
-    def forward(
-            self,
-            src: torch.Tensor,
-            mask: torch.Tensor = None,
-            src_key_padding_mask: torch.Tensor = None,
-            output_layer: Optional[int] = None,
-    ) -> torch.Tensor:
-        output = src
-        for layer in self.layers[:output_layer]:
-            output = layer(
-                output, src_mask=mask, src_key_padding_mask=src_key_padding_mask
-            )
-        return output
-
-
-def _compute_mask(
-        shape: Tuple[int, int],
-        mask_prob: float,
-        mask_length: int,
-        device: torch.device,
-        min_masks: int = 0,
-) -> torch.Tensor:
-    batch_size, sequence_length = shape
-
-    if mask_length < 1:
-        raise ValueError("`mask_length` has to be bigger than 0.")
-
-    if mask_length > sequence_length:
-        raise ValueError(
-            f"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`"
-        )
-
-    # compute number of masked spans in batch
-    num_masked_spans = int(mask_prob * sequence_length / mask_length + random.random())
-    num_masked_spans = max(num_masked_spans, min_masks)
-
-    # make sure num masked indices <= sequence_length
-    if num_masked_spans * mask_length > sequence_length:
-        num_masked_spans = sequence_length // mask_length
-
-    # SpecAugment mask to fill
-    mask = torch.zeros((batch_size, sequence_length), device=device, dtype=torch.bool)
-
-    # uniform distribution to sample from, make sure that offset samples are < sequence_length
-    uniform_dist = torch.ones(
-        (batch_size, sequence_length - (mask_length - 1)), device=device
-    )
-
-    # get random indices to mask
-    mask_indices = torch.multinomial(uniform_dist, num_masked_spans)
-
-    # expand masked indices to masked spans
-    mask_indices = (
-        mask_indices.unsqueeze(dim=-1)
-        .expand((batch_size, num_masked_spans, mask_length))
-        .reshape(batch_size, num_masked_spans * mask_length)
-    )
-    offsets = (
-        torch.arange(mask_length, device=device)[None, None, :]
-        .expand((batch_size, num_masked_spans, mask_length))
-        .reshape(batch_size, num_masked_spans * mask_length)
-    )
-    mask_idxs = mask_indices + offsets
-
-    # scatter indices to mask
-    mask = mask.scatter(1, mask_idxs, True)
-
-    return mask
-
-
-def hubert_soft(
-        path: str,
-) -> HubertSoft:
-    r"""HuBERT-Soft from `"A Comparison of Discrete and Soft Speech Units for Improved Voice Conversion"`.
-    Args:
-        path (str): path of a pretrained model
-    """
-    hubert = HubertSoft()
-    checkpoint = torch.load(path)
-    consume_prefix_in_state_dict_if_present(checkpoint, "module.")
-    hubert.load_state_dict(checkpoint)
-    hubert.eval()
-    return hubert

hubert/hubert_model_onnx.py

@@ -1,217 +0,0 @@
-import copy
-import random
-from typing import Optional, Tuple
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as t_func
-from torch.nn.modules.utils import consume_prefix_in_state_dict_if_present
-
-
-class Hubert(nn.Module):
-    def __init__(self, num_label_embeddings: int = 100, mask: bool = True):
-        super().__init__()
-        self._mask = mask
-        self.feature_extractor = FeatureExtractor()
-        self.feature_projection = FeatureProjection()
-        self.positional_embedding = PositionalConvEmbedding()
-        self.norm = nn.LayerNorm(768)
-        self.dropout = nn.Dropout(0.1)
-        self.encoder = TransformerEncoder(
-            nn.TransformerEncoderLayer(
-                768, 12, 3072, activation="gelu", batch_first=True
-            ),
-            12,
-        )
-        self.proj = nn.Linear(768, 256)
-
-        self.masked_spec_embed = nn.Parameter(torch.FloatTensor(768).uniform_())
-        self.label_embedding = nn.Embedding(num_label_embeddings, 256)
-
-    def mask(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
-        mask = None
-        if self.training and self._mask:
-            mask = _compute_mask((x.size(0), x.size(1)), 0.8, 10, x.device, 2)
-            x[mask] = self.masked_spec_embed.to(x.dtype)
-        return x, mask
-
-    def encode(
-            self, x: torch.Tensor, layer: Optional[int] = None
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        x = self.feature_extractor(x)
-        x = self.feature_projection(x.transpose(1, 2))
-        x, mask = self.mask(x)
-        x = x + self.positional_embedding(x)
-        x = self.dropout(self.norm(x))
-        x = self.encoder(x, output_layer=layer)
-        return x, mask
-
-    def logits(self, x: torch.Tensor) -> torch.Tensor:
-        logits = torch.cosine_similarity(
-            x.unsqueeze(2),
-            self.label_embedding.weight.unsqueeze(0).unsqueeze(0),
-            dim=-1,
-        )
-        return logits / 0.1
-
-
-class HubertSoft(Hubert):
-    def __init__(self):
-        super().__init__()
-
-    def units(self, wav: torch.Tensor) -> torch.Tensor:
-        wav = t_func.pad(wav, ((400 - 320) // 2, (400 - 320) // 2))
-        x, _ = self.encode(wav)
-        return self.proj(x)
-
-    def forward(self, x):
-        return self.units(x)
-
-class FeatureExtractor(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.conv0 = nn.Conv1d(1, 512, 10, 5, bias=False)
-        self.norm0 = nn.GroupNorm(512, 512)
-        self.conv1 = nn.Conv1d(512, 512, 3, 2, bias=False)
-        self.conv2 = nn.Conv1d(512, 512, 3, 2, bias=False)
-        self.conv3 = nn.Conv1d(512, 512, 3, 2, bias=False)
-        self.conv4 = nn.Conv1d(512, 512, 3, 2, bias=False)
-        self.conv5 = nn.Conv1d(512, 512, 2, 2, bias=False)
-        self.conv6 = nn.Conv1d(512, 512, 2, 2, bias=False)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = t_func.gelu(self.norm0(self.conv0(x)))
-        x = t_func.gelu(self.conv1(x))
-        x = t_func.gelu(self.conv2(x))
-        x = t_func.gelu(self.conv3(x))
-        x = t_func.gelu(self.conv4(x))
-        x = t_func.gelu(self.conv5(x))
-        x = t_func.gelu(self.conv6(x))
-        return x
-
-
-class FeatureProjection(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.norm = nn.LayerNorm(512)
-        self.projection = nn.Linear(512, 768)
-        self.dropout = nn.Dropout(0.1)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.norm(x)
-        x = self.projection(x)
-        x = self.dropout(x)
-        return x
-
-
-class PositionalConvEmbedding(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.conv = nn.Conv1d(
-            768,
-            768,
-            kernel_size=128,
-            padding=128 // 2,
-            groups=16,
-        )
-        self.conv = nn.utils.weight_norm(self.conv, name="weight", dim=2)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        x = self.conv(x.transpose(1, 2))
-        x = t_func.gelu(x[:, :, :-1])
-        return x.transpose(1, 2)
-
-
-class TransformerEncoder(nn.Module):
-    def __init__(
-            self, encoder_layer: nn.TransformerEncoderLayer, num_layers: int
-    ) -> None:
-        super(TransformerEncoder, self).__init__()
-        self.layers = nn.ModuleList(
-            [copy.deepcopy(encoder_layer) for _ in range(num_layers)]
-        )
-        self.num_layers = num_layers
-
-    def forward(
-            self,
-            src: torch.Tensor,
-            mask: torch.Tensor = None,
-            src_key_padding_mask: torch.Tensor = None,
-            output_layer: Optional[int] = None,
-    ) -> torch.Tensor:
-        output = src
-        for layer in self.layers[:output_layer]:
-            output = layer(
-                output, src_mask=mask, src_key_padding_mask=src_key_padding_mask
-            )
-        return output
-
-
-def _compute_mask(
-        shape: Tuple[int, int],
-        mask_prob: float,
-        mask_length: int,
-        device: torch.device,
-        min_masks: int = 0,
-) -> torch.Tensor:
-    batch_size, sequence_length = shape
-
-    if mask_length < 1:
-        raise ValueError("`mask_length` has to be bigger than 0.")
-
-    if mask_length > sequence_length:
-        raise ValueError(
-            f"`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: {mask_length} and `sequence_length`: {sequence_length}`"
-        )
-
-    # compute number of masked spans in batch
-    num_masked_spans = int(mask_prob * sequence_length / mask_length + random.random())
-    num_masked_spans = max(num_masked_spans, min_masks)
-
-    # make sure num masked indices <= sequence_length
-    if num_masked_spans * mask_length > sequence_length:
-        num_masked_spans = sequence_length // mask_length
-
-    # SpecAugment mask to fill
-    mask = torch.zeros((batch_size, sequence_length), device=device, dtype=torch.bool)
-
-    # uniform distribution to sample from, make sure that offset samples are < sequence_length
-    uniform_dist = torch.ones(
-        (batch_size, sequence_length - (mask_length - 1)), device=device
-    )
-
-    # get random indices to mask
-    mask_indices = torch.multinomial(uniform_dist, num_masked_spans)
-
-    # expand masked indices to masked spans
-    mask_indices = (
-        mask_indices.unsqueeze(dim=-1)
-        .expand((batch_size, num_masked_spans, mask_length))
-        .reshape(batch_size, num_masked_spans * mask_length)
-    )
-    offsets = (
-        torch.arange(mask_length, device=device)[None, None, :]
-        .expand((batch_size, num_masked_spans, mask_length))
-        .reshape(batch_size, num_masked_spans * mask_length)
-    )
-    mask_idxs = mask_indices + offsets
-
-    # scatter indices to mask
-    mask = mask.scatter(1, mask_idxs, True)
-
-    return mask
-
-
-def hubert_soft(
-        path: str,
-) -> HubertSoft:
-    r"""HuBERT-Soft from `"A Comparison of Discrete and Soft Speech Units for Improved Voice Conversion"`.
-    Args:
-        path (str): path of a pretrained model
-    """
-    hubert = HubertSoft()
-    checkpoint = torch.load(path)
-    consume_prefix_in_state_dict_if_present(checkpoint, "module.")
-    hubert.load_state_dict(checkpoint)
-    hubert.eval()
-    return hubert

inference/chunks_temp.json

@@ -1 +0,0 @@
-{"info": "temp_dict"}

inference/infer_tool.py

@@ -1,243 +0,0 @@
-import hashlib
-import io
-import json
-import logging
-import os
-import time
-from pathlib import Path
-from inference import slicer
-
-import librosa
-import numpy as np
-# import onnxruntime
-import parselmouth
-import soundfile
-import torch
-import torchaudio
-
-import cluster
-from hubert import hubert_model
-import utils
-from models import SynthesizerTrn
-
-logging.getLogger('matplotlib').setLevel(logging.WARNING)
-
-
-def read_temp(file_name):
-    if not os.path.exists(file_name):
-        with open(file_name, "w") as f:
-            f.write(json.dumps({"info": "temp_dict"}))
-        return {}
-    else:
-        try:
-            with open(file_name, "r") as f:
-                data = f.read()
-            data_dict = json.loads(data)
-            if os.path.getsize(file_name) > 50 * 1024 * 1024:
-                f_name = file_name.replace("\\", "/").split("/")[-1]
-                print(f"clean {f_name}")
-                for wav_hash in list(data_dict.keys()):
-                    if int(time.time()) - int(data_dict[wav_hash]["time"]) > 14 * 24 * 3600:
-                        del data_dict[wav_hash]
-        except Exception as e:
-            print(e)
-            print(f"{file_name} error,auto rebuild file")
-            data_dict = {"info": "temp_dict"}
-        return data_dict
-
-
-def write_temp(file_name, data):
-    with open(file_name, "w") as f:
-        f.write(json.dumps(data))
-
-
-def timeit(func):
-    def run(*args, **kwargs):
-        t = time.time()
-        res = func(*args, **kwargs)
-        print('executing \'%s\' costed %.3fs' % (func.__name__, time.time() - t))
-        return res
-
-    return run
-
-
-def format_wav(audio_path):
-    if Path(audio_path).suffix == '.wav':
-        return
-    raw_audio, raw_sample_rate = librosa.load(audio_path, mono=True, sr=None)
-    soundfile.write(Path(audio_path).with_suffix(".wav"), raw_audio, raw_sample_rate)
-
-
-def get_end_file(dir_path, end):
-    file_lists = []
-    for root, dirs, files in os.walk(dir_path):
-        files = [f for f in files if f[0] != '.']
-        dirs[:] = [d for d in dirs if d[0] != '.']
-        for f_file in files:
-            if f_file.endswith(end):
-                file_lists.append(os.path.join(root, f_file).replace("\\", "/"))
-    return file_lists
-
-
-def get_md5(content):
-    return hashlib.new("md5", content).hexdigest()
-
-def fill_a_to_b(a, b):
-    if len(a) < len(b):
-        for _ in range(0, len(b) - len(a)):
-            a.append(a[0])
-
-def mkdir(paths: list):
-    for path in paths:
-        if not os.path.exists(path):
-            os.mkdir(path)
-
-def pad_array(arr, target_length):
-    current_length = arr.shape[0]
-    if current_length >= target_length:
-        return arr
-    else:
-        pad_width = target_length - current_length
-        pad_left = pad_width // 2
-        pad_right = pad_width - pad_left
-        padded_arr = np.pad(arr, (pad_left, pad_right), 'constant', constant_values=(0, 0))
-        return padded_arr
-
-
-class Svc(object):
-    def __init__(self, net_g_path, config_path,
-                 device=None,
-                 cluster_model_path="logs/44k/kmeans_10000.pt"):
-        self.net_g_path = net_g_path
-        if device is None:
-            self.dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        else:
-            self.dev = torch.device(device)
-        self.net_g_ms = None
-        self.hps_ms = utils.get_hparams_from_file(config_path)
-        self.target_sample = self.hps_ms.data.sampling_rate
-        self.hop_size = self.hps_ms.data.hop_length
-        self.spk2id = self.hps_ms.spk
-        # 加载hubert
-        self.hubert_model = utils.get_hubert_model().to(self.dev)
-        self.load_model()
-        if os.path.exists(cluster_model_path):
-            self.cluster_model = cluster.get_cluster_model(cluster_model_path)
-
-    def load_model(self):
-        # 获取模型配置
-        self.net_g_ms = SynthesizerTrn(
-            self.hps_ms
-        )
-        _ = utils.load_checkpoint(self.net_g_path, self.net_g_ms, None)
-        if "half" in self.net_g_path and torch.cuda.is_available():
-            _ = self.net_g_ms.half().eval().to(self.dev)
-        else:
-            _ = self.net_g_ms.eval().to(self.dev)
-
-
-
-    def get_unit_f0(self, in_path, tran, cluster_infer_ratio, speaker):
-
-        wav, sr = librosa.load(in_path, sr=self.target_sample)
-
-        f0 = utils.compute_f0_parselmouth(wav, sampling_rate=self.target_sample, hop_length=self.hop_size)
-        f0, uv = utils.interpolate_f0(f0)
-        f0 = torch.FloatTensor(f0)
-        uv = torch.FloatTensor(uv)
-        f0 = f0 * 2 ** (tran / 12)
-        f0 = f0.unsqueeze(0).to(self.dev)
-        uv = uv.unsqueeze(0).to(self.dev)
-
-        wav16k = librosa.resample(wav, orig_sr=self.target_sample, target_sr=16000)
-        wav16k = torch.from_numpy(wav16k).to(self.dev)
-        c = utils.get_hubert_content(self.hubert_model, wav_16k_tensor=wav16k)
-        c = utils.repeat_expand_2d(c.squeeze(0), f0.shape[1])
-
-        if cluster_infer_ratio !=0:
-            cluster_c = cluster.get_cluster_center_result(self.cluster_model, c.cpu().numpy().T, speaker).T
-            cluster_c = torch.FloatTensor(cluster_c).to(self.dev)
-            c = cluster_infer_ratio * cluster_c + (1 - cluster_infer_ratio) * c
-
-        c = c.unsqueeze(0)
-        return c, f0, uv
-
-    def infer(self, speaker, tran, raw_path,
-              cluster_infer_ratio=0,
-              auto_predict_f0=False,
-              noice_scale=0.4):
-        speaker_id = self.spk2id[speaker]
-        sid = torch.LongTensor([int(speaker_id)]).to(self.dev).unsqueeze(0)
-        c, f0, uv = self.get_unit_f0(raw_path, tran, cluster_infer_ratio, speaker)
-        if "half" in self.net_g_path and torch.cuda.is_available():
-            c = c.half()
-        with torch.no_grad():
-            start = time.time()
-            audio = self.net_g_ms.infer(c, f0=f0, g=sid, uv=uv, predict_f0=auto_predict_f0, noice_scale=noice_scale)[0][0,0].data.float()
-            use_time = time.time() - start
-            print("vits use time:{}".format(use_time))
-        return audio, audio.shape[-1]
-
-    def slice_inference(self,raw_audio_path, spk, tran, slice_db,cluster_infer_ratio, auto_predict_f0,noice_scale, pad_seconds=0.5):
-        wav_path = raw_audio_path
-        chunks = slicer.cut(wav_path, db_thresh=slice_db)
-        audio_data, audio_sr = slicer.chunks2audio(wav_path, chunks)
-
-        audio = []
-        for (slice_tag, data) in audio_data:
-            print(f'#=====segment start, {round(len(data) / audio_sr, 3)}s======')
-            # padd
-            pad_len = int(audio_sr * pad_seconds)
-            data = np.concatenate([np.zeros([pad_len]), data, np.zeros([pad_len])])
-            length = int(np.ceil(len(data) / audio_sr * self.target_sample))
-            raw_path = io.BytesIO()
-            soundfile.write(raw_path, data, audio_sr, format="wav")
-            raw_path.seek(0)
-            if slice_tag:
-                print('jump empty segment')
-                _audio = np.zeros(length)
-            else:
-                out_audio, out_sr = self.infer(spk, tran, raw_path,
-                                                    cluster_infer_ratio=cluster_infer_ratio,
-                                                    auto_predict_f0=auto_predict_f0,
-                                                    noice_scale=noice_scale
-                                                    )
-                _audio = out_audio.cpu().numpy()
-
-            pad_len = int(self.target_sample * pad_seconds)
-            _audio = _audio[pad_len:-pad_len]
-            audio.extend(list(_audio))
-        return np.array(audio)
-
-
-class RealTimeVC:
-    def __init__(self):
-        self.last_chunk = None
-        self.last_o = None
-        self.chunk_len = 16000  # 区块长度
-        self.pre_len = 3840  # 交叉淡化长度，640的倍数
-
-    """输入输出都是1维numpy 音频波形数组"""
-
-    def process(self, svc_model, speaker_id, f_pitch_change, input_wav_path):
-        import maad
-        audio, sr = torchaudio.load(input_wav_path)
-        audio = audio.cpu().numpy()[0]
-        temp_wav = io.BytesIO()
-        if self.last_chunk is None:
-            input_wav_path.seek(0)
-            audio, sr = svc_model.infer(speaker_id, f_pitch_change, input_wav_path)
-            audio = audio.cpu().numpy()
-            self.last_chunk = audio[-self.pre_len:]
-            self.last_o = audio
-            return audio[-self.chunk_len:]
-        else:
-            audio = np.concatenate([self.last_chunk, audio])
-            soundfile.write(temp_wav, audio, sr, format="wav")
-            temp_wav.seek(0)
-            audio, sr = svc_model.infer(speaker_id, f_pitch_change, temp_wav)
-            audio = audio.cpu().numpy()
-            ret = maad.util.crossfade(self.last_o, audio, self.pre_len)
-            self.last_chunk = audio[-self.pre_len:]
-            self.last_o = audio
-            return ret[self.chunk_len:2 * self.chunk_len]

inference/infer_tool_grad.py

@@ -1,160 +0,0 @@
-import hashlib
-import json
-import logging
-import os
-import time
-from pathlib import Path
-import io
-import librosa
-import maad
-import numpy as np
-from inference import slicer
-import parselmouth
-import soundfile
-import torch
-import torchaudio
-
-from hubert import hubert_model
-import utils
-from models import SynthesizerTrn
-logging.getLogger('numba').setLevel(logging.WARNING)
-logging.getLogger('matplotlib').setLevel(logging.WARNING)
-
-def resize2d_f0(x, target_len):
-    source = np.array(x)
-    source[source < 0.001] = np.nan
-    target = np.interp(np.arange(0, len(source) * target_len, len(source)) / target_len, np.arange(0, len(source)),
-                       source)
-    res = np.nan_to_num(target)
-    return res
-
-def get_f0(x, p_len,f0_up_key=0):
-
-    time_step = 160 / 16000 * 1000
-    f0_min = 50
-    f0_max = 1100
-    f0_mel_min = 1127 * np.log(1 + f0_min / 700)
-    f0_mel_max = 1127 * np.log(1 + f0_max / 700)
-
-    f0 = parselmouth.Sound(x, 16000).to_pitch_ac(
-        time_step=time_step / 1000, voicing_threshold=0.6,
-        pitch_floor=f0_min, pitch_ceiling=f0_max).selected_array['frequency']
-
-    pad_size=(p_len - len(f0) + 1) // 2
-    if(pad_size>0 or p_len - len(f0) - pad_size>0):
-        f0 = np.pad(f0,[[pad_size,p_len - len(f0) - pad_size]], mode='constant')
-
-    f0 *= pow(2, f0_up_key / 12)
-    f0_mel = 1127 * np.log(1 + f0 / 700)
-    f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (f0_mel_max - f0_mel_min) + 1
-    f0_mel[f0_mel <= 1] = 1
-    f0_mel[f0_mel > 255] = 255
-    f0_coarse = np.rint(f0_mel).astype(np.int)
-    return f0_coarse, f0
-
-def clean_pitch(input_pitch):
-    num_nan = np.sum(input_pitch == 1)
-    if num_nan / len(input_pitch) > 0.9:
-        input_pitch[input_pitch != 1] = 1
-    return input_pitch
-
-
-def plt_pitch(input_pitch):
-    input_pitch = input_pitch.astype(float)
-    input_pitch[input_pitch == 1] = np.nan
-    return input_pitch
-
-
-def f0_to_pitch(ff):
-    f0_pitch = 69 + 12 * np.log2(ff / 440)
-    return f0_pitch
-
-
-def fill_a_to_b(a, b):
-    if len(a) < len(b):
-        for _ in range(0, len(b) - len(a)):
-            a.append(a[0])
-
-
-def mkdir(paths: list):
-    for path in paths:
-        if not os.path.exists(path):
-            os.mkdir(path)
-
-
-class VitsSvc(object):
-    def __init__(self):
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        self.SVCVITS = None
-        self.hps = None
-        self.speakers = None
-        self.hubert_soft = utils.get_hubert_model()
-
-    def set_device(self, device):
-        self.device = torch.device(device)
-        self.hubert_soft.to(self.device)
-        if self.SVCVITS != None:
-            self.SVCVITS.to(self.device)
-
-    def loadCheckpoint(self, path):
-        self.hps = utils.get_hparams_from_file(f"checkpoints/{path}/config.json")
-        self.SVCVITS = SynthesizerTrn(
-            self.hps.data.filter_length // 2 + 1,
-            self.hps.train.segment_size // self.hps.data.hop_length,
-            **self.hps.model)
-        _ = utils.load_checkpoint(f"checkpoints/{path}/model.pth", self.SVCVITS, None)
-        _ = self.SVCVITS.eval().to(self.device)
-        self.speakers = self.hps.spk
-
-    def get_units(self, source, sr):
-        source = source.unsqueeze(0).to(self.device)
-        with torch.inference_mode():
-            units = self.hubert_soft.units(source)
-            return units
-
-
-    def get_unit_pitch(self, in_path, tran):
-        source, sr = torchaudio.load(in_path)
-        source = torchaudio.functional.resample(source, sr, 16000)
-        if len(source.shape) == 2 and source.shape[1] >= 2:
-            source = torch.mean(source, dim=0).unsqueeze(0)
-        soft = self.get_units(source, sr).squeeze(0).cpu().numpy()
-        f0_coarse, f0 = get_f0(source.cpu().numpy()[0], soft.shape[0]*2, tran)
-        return soft, f0
-
-    def infer(self, speaker_id, tran, raw_path):
-        speaker_id = self.speakers[speaker_id]
-        sid = torch.LongTensor([int(speaker_id)]).to(self.device).unsqueeze(0)
-        soft, pitch = self.get_unit_pitch(raw_path, tran)
-        f0 = torch.FloatTensor(clean_pitch(pitch)).unsqueeze(0).to(self.device)
-        stn_tst = torch.FloatTensor(soft)
-        with torch.no_grad():
-            x_tst = stn_tst.unsqueeze(0).to(self.device)
-            x_tst = torch.repeat_interleave(x_tst, repeats=2, dim=1).transpose(1, 2)
-            audio = self.SVCVITS.infer(x_tst, f0=f0, g=sid)[0,0].data.float()
-        return audio, audio.shape[-1]
-
-    def inference(self,srcaudio,chara,tran,slice_db):
-        sampling_rate, audio = srcaudio
-        audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
-        if len(audio.shape) > 1:
-            audio = librosa.to_mono(audio.transpose(1, 0))
-        if sampling_rate != 16000:
-            audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
-        soundfile.write("tmpwav.wav", audio, 16000, format="wav")
-        chunks = slicer.cut("tmpwav.wav", db_thresh=slice_db)
-        audio_data, audio_sr = slicer.chunks2audio("tmpwav.wav", chunks)
-        audio = []
-        for (slice_tag, data) in audio_data:
-            length = int(np.ceil(len(data) / audio_sr * self.hps.data.sampling_rate))
-            raw_path = io.BytesIO()
-            soundfile.write(raw_path, data, audio_sr, format="wav")
-            raw_path.seek(0)
-            if slice_tag:
-                _audio = np.zeros(length)
-            else:
-                out_audio, out_sr = self.infer(chara, tran, raw_path)
-                _audio = out_audio.cpu().numpy()
-            audio.extend(list(_audio))
-        audio = (np.array(audio) * 32768.0).astype('int16')
-        return (self.hps.data.sampling_rate,audio)

inference/slicer.py

@@ -1,142 +0,0 @@
-import librosa
-import torch
-import torchaudio
-
-
-class Slicer:
-    def __init__(self,
-                 sr: int,
-                 threshold: float = -40.,
-                 min_length: int = 5000,
-                 min_interval: int = 300,
-                 hop_size: int = 20,
-                 max_sil_kept: int = 5000):
-        if not min_length >= min_interval >= hop_size:
-            raise ValueError('The following condition must be satisfied: min_length >= min_interval >= hop_size')
-        if not max_sil_kept >= hop_size:
-            raise ValueError('The following condition must be satisfied: max_sil_kept >= hop_size')
-        min_interval = sr * min_interval / 1000
-        self.threshold = 10 ** (threshold / 20.)
-        self.hop_size = round(sr * hop_size / 1000)
-        self.win_size = min(round(min_interval), 4 * self.hop_size)
-        self.min_length = round(sr * min_length / 1000 / self.hop_size)
-        self.min_interval = round(min_interval / self.hop_size)
-        self.max_sil_kept = round(sr * max_sil_kept / 1000 / self.hop_size)
-
-    def _apply_slice(self, waveform, begin, end):
-        if len(waveform.shape) > 1:
-            return waveform[:, begin * self.hop_size: min(waveform.shape[1], end * self.hop_size)]
-        else:
-            return waveform[begin * self.hop_size: min(waveform.shape[0], end * self.hop_size)]
-
-    # @timeit
-    def slice(self, waveform):
-        if len(waveform.shape) > 1:
-            samples = librosa.to_mono(waveform)
-        else:
-            samples = waveform
-        if samples.shape[0] <= self.min_length:
-            return {"0": {"slice": False, "split_time": f"0,{len(waveform)}"}}
-        rms_list = librosa.feature.rms(y=samples, frame_length=self.win_size, hop_length=self.hop_size).squeeze(0)
-        sil_tags = []
-        silence_start = None
-        clip_start = 0
-        for i, rms in enumerate(rms_list):
-            # Keep looping while frame is silent.
-            if rms < self.threshold:
-                # Record start of silent frames.
-                if silence_start is None:
-                    silence_start = i
-                continue
-            # Keep looping while frame is not silent and silence start has not been recorded.
-            if silence_start is None:
-                continue
-            # Clear recorded silence start if interval is not enough or clip is too short
-            is_leading_silence = silence_start == 0 and i > self.max_sil_kept
-            need_slice_middle = i - silence_start >= self.min_interval and i - clip_start >= self.min_length
-            if not is_leading_silence and not need_slice_middle:
-                silence_start = None
-                continue
-            # Need slicing. Record the range of silent frames to be removed.
-            if i - silence_start <= self.max_sil_kept:
-                pos = rms_list[silence_start: i + 1].argmin() + silence_start
-                if silence_start == 0:
-                    sil_tags.append((0, pos))
-                else:
-                    sil_tags.append((pos, pos))
-                clip_start = pos
-            elif i - silence_start <= self.max_sil_kept * 2:
-                pos = rms_list[i - self.max_sil_kept: silence_start + self.max_sil_kept + 1].argmin()
-                pos += i - self.max_sil_kept
-                pos_l = rms_list[silence_start: silence_start + self.max_sil_kept + 1].argmin() + silence_start
-                pos_r = rms_list[i - self.max_sil_kept: i + 1].argmin() + i - self.max_sil_kept
-                if silence_start == 0:
-                    sil_tags.append((0, pos_r))
-                    clip_start = pos_r
-                else:
-                    sil_tags.append((min(pos_l, pos), max(pos_r, pos)))
-                    clip_start = max(pos_r, pos)
-            else:
-                pos_l = rms_list[silence_start: silence_start + self.max_sil_kept + 1].argmin() + silence_start
-                pos_r = rms_list[i - self.max_sil_kept: i + 1].argmin() + i - self.max_sil_kept
-                if silence_start == 0:
-                    sil_tags.append((0, pos_r))
-                else:
-                    sil_tags.append((pos_l, pos_r))
-                clip_start = pos_r
-            silence_start = None
-        # Deal with trailing silence.
-        total_frames = rms_list.shape[0]
-        if silence_start is not None and total_frames - silence_start >= self.min_interval:
-            silence_end = min(total_frames, silence_start + self.max_sil_kept)
-            pos = rms_list[silence_start: silence_end + 1].argmin() + silence_start
-            sil_tags.append((pos, total_frames + 1))
-        # Apply and return slices.
-        if len(sil_tags) == 0:
-            return {"0": {"slice": False, "split_time": f"0,{len(waveform)}"}}
-        else:
-            chunks = []
-            # 第一段静音并非从头开始，补上有声片段
-            if sil_tags[0][0]:
-                chunks.append(
-                    {"slice": False, "split_time": f"0,{min(waveform.shape[0], sil_tags[0][0] * self.hop_size)}"})
-            for i in range(0, len(sil_tags)):
-                # 标识有声片段（跳过第一段）
-                if i:
-                    chunks.append({"slice": False,
-                                   "split_time": f"{sil_tags[i - 1][1] * self.hop_size},{min(waveform.shape[0], sil_tags[i][0] * self.hop_size)}"})
-                # 标识所有静音片段
-                chunks.append({"slice": True,
-                               "split_time": f"{sil_tags[i][0] * self.hop_size},{min(waveform.shape[0], sil_tags[i][1] * self.hop_size)}"})
-            # 最后一段静音并非结尾，补上结尾片段
-            if sil_tags[-1][1] * self.hop_size < len(waveform):
-                chunks.append({"slice": False, "split_time": f"{sil_tags[-1][1] * self.hop_size},{len(waveform)}"})
-            chunk_dict = {}
-            for i in range(len(chunks)):
-                chunk_dict[str(i)] = chunks[i]
-            return chunk_dict
-
-
-def cut(audio_path, db_thresh=-30, min_len=5000):
-    audio, sr = librosa.load(audio_path, sr=None)
-    slicer = Slicer(
-        sr=sr,
-        threshold=db_thresh,
-        min_length=min_len
-    )
-    chunks = slicer.slice(audio)
-    return chunks
-
-
-def chunks2audio(audio_path, chunks):
-    chunks = dict(chunks)
-    audio, sr = torchaudio.load(audio_path)
-    if len(audio.shape) == 2 and audio.shape[1] >= 2:
-        audio = torch.mean(audio, dim=0).unsqueeze(0)
-    audio = audio.cpu().numpy()[0]
-    result = []
-    for k, v in chunks.items():
-        tag = v["split_time"].split(",")
-        if tag[0] != tag[1]:
-            result.append((v["slice"], audio[int(tag[0]):int(tag[1])]))
-    return result, sr

inference_main.py

@@ -1,101 +0,0 @@
-import io
-import logging
-import time
-from pathlib import Path
-
-import librosa
-import matplotlib.pyplot as plt
-import numpy as np
-import soundfile
-
-from inference import infer_tool
-from inference import slicer
-from inference.infer_tool import Svc
-
-logging.getLogger('numba').setLevel(logging.WARNING)
-chunks_dict = infer_tool.read_temp("inference/chunks_temp.json")
-
-
-
-def main():
-    import argparse
-
-    parser = argparse.ArgumentParser(description='sovits4 inference')
-
-    # 一定要设置的部分
-    parser.add_argument('-m', '--model_path', type=str, default="/Volumes/Extend/下载/cvecG_23000.pth", help='模型路径')
-    parser.add_argument('-c', '--config_path', type=str, default="configs/config.json", help='配置文件路径')
-    parser.add_argument('-n', '--clean_names', type=str, nargs='+', default=["君の知らない物語-src.wav"], help='wav文件名列表，放在raw文件夹下')
-    parser.add_argument('-t', '--trans', type=int, nargs='+', default=[-5], help='音高调整，支持正负（半音）')
-    parser.add_argument('-s', '--spk_list', type=str, nargs='+', default=['yunhao'], help='合成目标说话人名称')
-
-    # 可选项部分
-    parser.add_argument('-a', '--auto_predict_f0', action='store_true', default=False,
-                        help='语音转换自动预测音高，转换歌声时不要打开这个会严重跑调')
-    parser.add_argument('-cm', '--cluster_model_path', type=str, default="logs/44k/kmeans_10000.pt", help='聚类模型路径，如果没有训练聚类则随便填')
-    parser.add_argument('-cr', '--cluster_infer_ratio', type=float, default=0, help='聚类方案占比，范围0-1，若没有训练聚类模型则填0即可')
-
-    # 不用动的部分
-    parser.add_argument('-sd', '--slice_db', type=int, default=-40, help='默认-40，嘈杂的音频可以-30，干声保留呼吸可以-50')
-    parser.add_argument('-d', '--device', type=str, default=None, help='推理设备，None则为自动选择cpu和gpu')
-    parser.add_argument('-ns', '--noice_scale', type=float, default=0.4, help='噪音级别，会影响咬字和音质，较为玄学')
-    parser.add_argument('-p', '--pad_seconds', type=float, default=0.5, help='推理音频pad秒数，由于未知原因开头结尾会有异响，pad一小段静音段后就不会出现')
-    parser.add_argument('-wf', '--wav_format', type=str, default='flac', help='音频输出格式')
-
-    args = parser.parse_args()
-
-    svc_model = Svc(args.model_path, args.config_path, args.device, args.cluster_model_path)
-    infer_tool.mkdir(["raw", "results"])
-    clean_names = args.clean_names
-    trans = args.trans
-    spk_list = args.spk_list
-    slice_db = args.slice_db
-    wav_format = args.wav_format
-    auto_predict_f0 = args.auto_predict_f0
-    cluster_infer_ratio = args.cluster_infer_ratio
-    noice_scale = args.noice_scale
-    pad_seconds = args.pad_seconds
-
-    infer_tool.fill_a_to_b(trans, clean_names)
-    for clean_name, tran in zip(clean_names, trans):
-        raw_audio_path = f"raw/{clean_name}"
-        if "." not in raw_audio_path:
-            raw_audio_path += ".wav"
-        infer_tool.format_wav(raw_audio_path)
-        wav_path = Path(raw_audio_path).with_suffix('.wav')
-        chunks = slicer.cut(wav_path, db_thresh=slice_db)
-        audio_data, audio_sr = slicer.chunks2audio(wav_path, chunks)
-
-        for spk in spk_list:
-            audio = []
-            for (slice_tag, data) in audio_data:
-                print(f'#=====segment start, {round(len(data) / audio_sr, 3)}s======')
-
-                length = int(np.ceil(len(data) / audio_sr * svc_model.target_sample))
-                if slice_tag:
-                    print('jump empty segment')
-                    _audio = np.zeros(length)
-                else:
-                    # padd
-                    pad_len = int(audio_sr * pad_seconds)
-                    data = np.concatenate([np.zeros([pad_len]), data, np.zeros([pad_len])])
-                    raw_path = io.BytesIO()
-                    soundfile.write(raw_path, data, audio_sr, format="wav")
-                    raw_path.seek(0)
-                    out_audio, out_sr = svc_model.infer(spk, tran, raw_path,
-                                                        cluster_infer_ratio=cluster_infer_ratio,
-                                                        auto_predict_f0=auto_predict_f0,
-                                                        noice_scale=noice_scale
-                                                        )
-                    _audio = out_audio.cpu().numpy()
-                    pad_len = int(svc_model.target_sample * pad_seconds)
-                    _audio = _audio[pad_len:-pad_len]
-
-                audio.extend(list(infer_tool.pad_array(_audio, length)))
-            key = "auto" if auto_predict_f0 else f"{tran}key"
-            cluster_name = "" if cluster_infer_ratio == 0 else f"_{cluster_infer_ratio}"
-            res_path = f'./results/{clean_name}_{key}_{spk}{cluster_name}.{wav_format}'
-            soundfile.write(res_path, audio, svc_model.target_sample, format=wav_format)
-
-if __name__ == '__main__':
-    main()

hubert/whisper_phone_asr.pth → ioritree--so-vits-svc/text-test.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7f1d742befacdd04c7d6037ea8ac70c256c5971912289b0bce328684643a3036
-size 17406081
+oid sha256:28dd48962d9b619f08007fdcadfaca690f681de63214df88162519d0561cdda6
+size 964

ioritree--so-vits-svc/text-train.parquet

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

ioritree--so-vits-svc/text-validation.parquet

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

models.py

@@ -1,1060 +0,0 @@
-import sys
-import copy
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-
-
-sys.path.append('../..')
-import modules.commons as commons
-import modules.modules as modules
-import modules.attentions as attentions
-
-from modules.commons import init_weights, get_padding
-
-from modules.ddsp import mlp, gru, scale_function, remove_above_nyquist, upsample
-from modules.ddsp import harmonic_synth, amp_to_impulse_response, fft_convolve
-from modules.ddsp import resample
-import utils
-
-from modules.stft import TorchSTFT
-
-import torch.distributions as D
-
-from modules.losses import (
-    generator_loss,
-    discriminator_loss,
-    feature_loss,
-    kl_loss
-)
-
-LRELU_SLOPE = 0.1
-
-
-class PostF0Decoder(nn.Module):
-    def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, spk_channels=0):
-        super().__init__()
-
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.gin_channels = spk_channels
-
-        self.drop = nn.Dropout(p_dropout)
-        self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size // 2)
-        self.norm_1 = modules.LayerNorm(filter_channels)
-        self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size // 2)
-        self.norm_2 = modules.LayerNorm(filter_channels)
-        self.proj = nn.Conv1d(filter_channels, 1, 1)
-
-        if spk_channels != 0:
-            self.cond = nn.Conv1d(spk_channels, in_channels, 1)
-
-    def forward(self, x, x_mask, g=None):
-        x = torch.detach(x)
-        if g is not None:
-            g = torch.detach(g)
-            x = x + self.cond(g)
-        x = self.conv_1(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_1(x)
-        x = self.drop(x)
-        x = self.conv_2(x * x_mask)
-        x = torch.relu(x)
-        x = self.norm_2(x)
-        x = self.drop(x)
-        x = self.proj(x * x_mask)
-        return x * x_mask
-
-
-class TextEncoder(nn.Module):
-    def __init__(self,
-                 c_dim,
-                 out_channels,
-                 hidden_channels,
-                 filter_channels,
-                 n_heads,
-                 n_layers,
-                 kernel_size,
-                 p_dropout):
-        super().__init__()
-        self.out_channels = out_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.pre_net = torch.nn.Linear(c_dim, hidden_channels)
-
-        self.encoder = attentions.Encoder(
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout)
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-
-    def forward(self, x, x_lengths):
-        x = x.transpose(1,-1)
-        x = self.pre_net(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-        x = self.encoder(x * x_mask, x_mask)
-        x = self.proj(x) * x_mask
-        return x, x_mask
-
-
-def pad_v2(input_ele, mel_max_length=None):
-    if mel_max_length:
-        max_len = mel_max_length
-    else:
-        max_len = max([input_ele[i].size(0) for i in range(len(input_ele))])
-
-    out_list = list()
-    for i, batch in enumerate(input_ele):
-        if len(batch.shape) == 1:
-            one_batch_padded = F.pad(
-                batch, (0, max_len - batch.size(0)), "constant", 0.0
-            )
-        elif len(batch.shape) == 2:
-            one_batch_padded = F.pad(
-                batch, (0, 0, 0, max_len - batch.size(0)), "constant", 0.0
-            )
-        out_list.append(one_batch_padded)
-    out_padded = torch.stack(out_list)
-    return out_padded
-
-
-class LengthRegulator(nn.Module):
-    """ Length Regulator """
-
-    def __init__(self):
-        super(LengthRegulator, self).__init__()
-
-    def LR(self, x, duration, max_len):
-        x = torch.transpose(x, 1, 2)
-        output = list()
-        mel_len = list()
-        for batch, expand_target in zip(x, duration):
-            expanded = self.expand(batch, expand_target)
-            output.append(expanded)
-            mel_len.append(expanded.shape[0])
-
-        if max_len is not None:
-            output = pad_v2(output, max_len)
-        else:
-            output = pad_v2(output)
-        output = torch.transpose(output, 1, 2)
-        return output, torch.LongTensor(mel_len)
-
-    def expand(self, batch, predicted):
-        predicted = torch.squeeze(predicted)
-        out = list()
-
-        for i, vec in enumerate(batch):
-            expand_size = predicted[i].item()
-            state_info_index = torch.unsqueeze(torch.arange(0, expand_size), 1).float()
-            state_info_length = torch.unsqueeze(torch.Tensor([expand_size] * expand_size), 1).float()
-            state_info = torch.cat([state_info_index, state_info_length], 1).to(vec.device)
-            new_vec = vec.expand(max(int(expand_size), 0), -1)
-            new_vec = torch.cat([new_vec, state_info], 1)
-            out.append(new_vec)
-        out = torch.cat(out, 0)
-        return out
-
-    def forward(self, x, duration, max_len):
-        output, mel_len = self.LR(x, duration, max_len)
-        return output, mel_len
-
-
-class PriorDecoder(nn.Module):
-    def __init__(self,
-                 out_bn_channels,
-                 hidden_channels,
-                 filter_channels,
-                 n_heads,
-                 n_layers,
-                 kernel_size,
-                 p_dropout,
-                 n_speakers=0,
-                 spk_channels=0):
-        super().__init__()
-        self.out_bn_channels = out_bn_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.spk_channels = spk_channels
-
-        self.prenet = nn.Conv1d(hidden_channels , hidden_channels, 3, padding=1)
-        self.decoder = attentions.FFT(
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout)
-        self.proj = nn.Conv1d(hidden_channels, out_bn_channels, 1)
-
-        if n_speakers != 0:
-            self.cond = nn.Conv1d(spk_channels, hidden_channels, 1)
-
-    def forward(self, x, x_lengths, spk_emb=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
-        x = self.prenet(x) * x_mask
-
-        if (spk_emb is not None):
-            x = x + self.cond(spk_emb)
-
-        x = self.decoder(x * x_mask, x_mask)
-
-        bn = self.proj(x) * x_mask
-
-        return bn, x_mask
-
-
-class Decoder(nn.Module):
-    def __init__(self,
-                 out_channels,
-                 hidden_channels,
-                 filter_channels,
-                 n_heads,
-                 n_layers,
-                 kernel_size,
-                 p_dropout,
-                 n_speakers=0,
-                 spk_channels=0,
-                 in_channels=None):
-        super().__init__()
-        self.out_channels = out_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.spk_channels = spk_channels
-
-        self.prenet = nn.Conv1d(in_channels if in_channels is not None else hidden_channels, hidden_channels, 3, padding=1)
-        self.decoder = attentions.FFT(
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout)
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-
-        if n_speakers != 0:
-            self.cond = nn.Conv1d(spk_channels, hidden_channels, 1)
-
-    def forward(self, x, x_lengths, spk_emb=None):
-        x = torch.detach(x)
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
-        x = self.prenet(x) * x_mask
-
-        if (spk_emb is not None):
-            x = x + self.cond(spk_emb)
-
-        x = self.decoder(x * x_mask, x_mask)
-
-        x = self.proj(x) * x_mask
-
-        return x, x_mask
-
-class F0Decoder(nn.Module):
-    def __init__(self,
-                 out_channels,
-                 hidden_channels,
-                 filter_channels,
-                 n_heads,
-                 n_layers,
-                 kernel_size,
-                 p_dropout,
-                 n_speakers=0,
-                 spk_channels=0,
-                 in_channels=None):
-        super().__init__()
-        self.out_channels = out_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.spk_channels = spk_channels
-
-        self.prenet = nn.Conv1d(in_channels if in_channels is not None else hidden_channels, hidden_channels, 3, padding=1)
-        self.decoder = attentions.FFT(
-            hidden_channels,
-            filter_channels,
-            n_heads,
-            n_layers,
-            kernel_size,
-            p_dropout)
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-        self.f0_prenet = nn.Conv1d(1, hidden_channels , 3, padding=1)
-
-        if n_speakers != 0:
-            self.cond = nn.Conv1d(spk_channels, hidden_channels, 1)
-
-    def forward(self, x, norm_f0, x_lengths, spk_emb=None):
-        x = torch.detach(x)
-        x += self.f0_prenet(norm_f0)
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
-        x = self.prenet(x) * x_mask
-
-        if (spk_emb is not None):
-            x = x + self.cond(spk_emb)
-
-        x = self.decoder(x * x_mask, x_mask)
-
-        x = self.proj(x) * x_mask
-
-        return x, x_mask
-
-
-class ConvReluNorm(nn.Module):
-    def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
-        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.p_dropout = p_dropout
-        assert n_layers > 1, "Number of layers should be larger than 0."
-
-        self.conv_layers = nn.ModuleList()
-        self.norm_layers = nn.ModuleList()
-        self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size // 2))
-        self.norm_layers.append(LayerNorm(hidden_channels))
-        self.relu_drop = nn.Sequential(
-            nn.ReLU(),
-            nn.Dropout(p_dropout))
-        for _ in range(n_layers - 1):
-            self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size // 2))
-            self.norm_layers.append(LayerNorm(hidden_channels))
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x):
-        x = self.conv_layers[0](x)
-        x = self.norm_layers[0](x)
-        x = self.relu_drop(x)
-
-        for i in range(1, self.n_layers):
-            x_ = self.conv_layers[i](x)
-            x_ = self.norm_layers[i](x_)
-            x_ = self.relu_drop(x_)
-            x = (x + x_) / 2
-        x = self.proj(x)
-        return x
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(self,
-                 hps,
-                 in_channels,
-                 out_channels,
-                 hidden_channels,
-                 kernel_size,
-                 dilation_rate,
-                 n_layers):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_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(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, n_speakers=hps.data.n_speakers, spk_channels=hps.model.spk_channels)
-        # self.enc = ConvReluNorm(hidden_channels,
-        #                         hidden_channels,
-        #                         hidden_channels,
-        #                         kernel_size,
-        #                         n_layers,
-        #                         0.1)
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        return stats, x_mask
-
-
-class ResBlock3(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
-        super(ResBlock3, self).__init__()
-        self.convs = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0])))
-        ])
-        self.convs.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c in self.convs:
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class Generator_Harm(torch.nn.Module):
-    def __init__(self, hps):
-        super(Generator_Harm, self).__init__()
-        self.hps = hps
-
-        self.prenet = Conv1d(hps.model.hidden_channels, hps.model.hidden_channels, 3, padding=1)
-
-        self.net = ConvReluNorm(hps.model.hidden_channels,
-                                hps.model.hidden_channels,
-                                hps.model.hidden_channels,
-                                hps.model.kernel_size,
-                                8,
-                                hps.model.p_dropout)
-
-        # self.rnn = nn.LSTM(input_size=hps.model.hidden_channels,
-        #    hidden_size=hps.model.hidden_channels,
-        #    num_layers=1,
-        #    bias=True,
-        #    batch_first=True,
-        #    dropout=0.5,
-        #    bidirectional=True)
-        self.postnet = Conv1d(hps.model.hidden_channels, hps.model.n_harmonic + 1, 3, padding=1)
-
-    def forward(self, f0, harm, mask):
-        pitch = f0.transpose(1, 2)
-        harm = self.prenet(harm)
-
-        harm = self.net(harm) * mask
-        # harm = harm.transpose(1, 2)
-        # harm, (hs, hc) = self.rnn(harm)
-        # harm = harm.transpose(1, 2)
-
-        harm = self.postnet(harm)
-        harm = harm.transpose(1, 2)
-        param = harm
-
-        param = scale_function(param)
-        total_amp = param[..., :1]
-        amplitudes = param[..., 1:]
-        amplitudes = remove_above_nyquist(
-            amplitudes,
-            pitch,
-            self.hps.data.sampling_rate,
-        )
-        amplitudes /= amplitudes.sum(-1, keepdim=True)
-        amplitudes *= total_amp
-
-        amplitudes = upsample(amplitudes, self.hps.data.hop_length)
-        pitch = upsample(pitch, self.hps.data.hop_length)
-
-        n_harmonic = amplitudes.shape[-1]
-        omega = torch.cumsum(2 * math.pi * pitch / self.hps.data.sampling_rate, 1)
-        omegas = omega * torch.arange(1, n_harmonic + 1).to(omega)
-        signal_harmonics = (torch.sin(omegas) * amplitudes)
-        signal_harmonics = signal_harmonics.transpose(1, 2)
-        return signal_harmonics
-
-
-class Generator(torch.nn.Module):
-    def __init__(self, hps, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates,
-                 upsample_initial_channel, upsample_kernel_sizes, n_speakers=0, spk_channels=0):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
-        self.upsample_rates = upsample_rates
-        self.n_speakers = n_speakers
-
-        resblock = modules.ResBlock1 if resblock == '1' else modules.R
-
-        self.downs = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            i = len(upsample_rates) - 1 - i
-            u = upsample_rates[i]
-            k = upsample_kernel_sizes[i]
-            # print("down: ",upsample_initial_channel//(2**(i+1))," -> ", upsample_initial_channel//(2**i))
-            self.downs.append(weight_norm(
-                Conv1d(hps.model.n_harmonic + 2, hps.model.n_harmonic + 2,
-                       k, u, padding=k // 2)))
-
-        self.resblocks_downs = nn.ModuleList()
-        for i in range(len(self.downs)):
-            j = len(upsample_rates) - 1 - i
-            self.resblocks_downs.append(ResBlock3(hps.model.n_harmonic + 2, 3, (1, 3)))
-
-        self.concat_pre = Conv1d(upsample_initial_channel + hps.model.n_harmonic + 2, upsample_initial_channel, 3, 1,
-                                 padding=1)
-        self.concat_conv = nn.ModuleList()
-        for i in range(len(upsample_rates)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            self.concat_conv.append(Conv1d(ch + hps.model.n_harmonic + 2, ch, 3, 1, padding=1, bias=False))
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(weight_norm(
-                ConvTranspose1d(upsample_initial_channel // (2 ** i), upsample_initial_channel // (2 ** (i + 1)),
-                                k, u, padding=(k - u) // 2)))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if self.n_speakers != 0:
-            self.cond = nn.Conv1d(spk_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, ddsp, g=None):
-
-        x = self.conv_pre(x)
-
-        if g is not None:
-            x = x + self.cond(g)
-
-        se = ddsp
-        res_features = [se]
-        for i in range(self.num_upsamples):
-            in_size = se.size(2)
-            se = self.downs[i](se)
-            se = self.resblocks_downs[i](se)
-            up_rate = self.upsample_rates[self.num_upsamples - 1 - i]
-            se = se[:, :, : in_size // up_rate]
-            res_features.append(se)
-
-        x = torch.cat([x, se], 1)
-        x = self.concat_pre(x)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            in_size = x.size(2)
-            x = self.ups[i](x)
-            # 保证维度正确，丢掉多余通道
-            x = x[:, :, : in_size * self.upsample_rates[i]]
-
-            x = torch.cat([x, res_features[self.num_upsamples - 1 - i]], 1)
-            x = self.concat_conv[i](x)
-
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        print('Removing weight norm...')
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class Generator_Noise(torch.nn.Module):
-    def __init__(self, hps):
-        super(Generator_Noise, self).__init__()
-        self.hps = hps
-        self.win_size = hps.data.win_size
-        self.hop_size = hps.data.hop_length
-        self.fft_size = hps.data.n_fft
-        self.istft_pre = Conv1d(hps.model.hidden_channels, hps.model.hidden_channels, 3, padding=1)
-
-        self.net = ConvReluNorm(hps.model.hidden_channels,
-                                hps.model.hidden_channels,
-                                hps.model.hidden_channels,
-                                hps.model.kernel_size,
-                                8,
-                                hps.model.p_dropout)
-
-        self.istft_amplitude = torch.nn.Conv1d(hps.model.hidden_channels, self.fft_size // 2 + 1, 1, 1)
-        self.window = torch.hann_window(self.win_size)
-
-    def forward(self, x, mask):
-        istft_x = x
-        istft_x = self.istft_pre(istft_x)
-
-        istft_x = self.net(istft_x) * mask
-
-        amp = self.istft_amplitude(istft_x).unsqueeze(-1)
-        phase = (torch.rand(amp.shape) * 2 * 3.14 - 3.14).to(amp)
-
-        real = amp * torch.cos(phase)
-        imag = amp * torch.sin(phase)
-        spec = torch.cat([real, imag], 3)
-        istft_x = torch.istft(spec, self.fft_size, self.hop_size, self.win_size, self.window.to(amp), True,
-                              length=x.shape[2] * self.hop_size, return_complex=False)
-
-        return istft_x.unsqueeze(1)
-
-
-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)
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList([
-            norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
-        ])
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList([
-            norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-            norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-            norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-            norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-            norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-            norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-        ])
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class MultiFrequencyDiscriminator(nn.Module):
-    def __init__(self,
-                 hop_lengths=[128, 256, 512],
-                 hidden_channels=[256, 512, 512],
-                 domain='double', mel_scale=True):
-        super(MultiFrequencyDiscriminator, self).__init__()
-
-        self.stfts = nn.ModuleList([
-            TorchSTFT(fft_size=x * 4, hop_size=x, win_size=x * 4,
-                      normalized=True, domain=domain, mel_scale=mel_scale)
-            for x in hop_lengths])
-
-        self.domain = domain
-        if domain == 'double':
-            self.discriminators = nn.ModuleList([
-                BaseFrequenceDiscriminator(2, c)
-                for x, c in zip(hop_lengths, hidden_channels)])
-        else:
-            self.discriminators = nn.ModuleList([
-                BaseFrequenceDiscriminator(1, c)
-                for x, c in zip(hop_lengths, hidden_channels)])
-
-    def forward(self, x):
-        scores, feats = list(), list()
-        for stft, layer in zip(self.stfts, self.discriminators):
-            # print(stft)
-            mag, phase = stft.transform(x.squeeze())
-            if self.domain == 'double':
-                mag = torch.stack(torch.chunk(mag, 2, dim=1), dim=1)
-            else:
-                mag = mag.unsqueeze(1)
-
-            score, feat = layer(mag)
-            scores.append(score)
-            feats.append(feat)
-        return scores, feats
-
-
-class BaseFrequenceDiscriminator(nn.Module):
-    def __init__(self, in_channels, hidden_channels=512):
-        super(BaseFrequenceDiscriminator, self).__init__()
-
-        self.discriminator = nn.ModuleList()
-        self.discriminator += [
-            nn.Sequential(
-                nn.ReflectionPad2d((1, 1, 1, 1)),
-                nn.utils.weight_norm(nn.Conv2d(
-                    in_channels, hidden_channels // 32,
-                    kernel_size=(3, 3), stride=(1, 1)))
-            ),
-            nn.Sequential(
-                nn.LeakyReLU(0.2, True),
-                nn.ReflectionPad2d((1, 1, 1, 1)),
-                nn.utils.weight_norm(nn.Conv2d(
-                    hidden_channels // 32, hidden_channels // 16,
-                    kernel_size=(3, 3), stride=(2, 2)))
-            ),
-            nn.Sequential(
-                nn.LeakyReLU(0.2, True),
-                nn.ReflectionPad2d((1, 1, 1, 1)),
-                nn.utils.weight_norm(nn.Conv2d(
-                    hidden_channels // 16, hidden_channels // 8,
-                    kernel_size=(3, 3), stride=(1, 1)))
-            ),
-            nn.Sequential(
-                nn.LeakyReLU(0.2, True),
-                nn.ReflectionPad2d((1, 1, 1, 1)),
-                nn.utils.weight_norm(nn.Conv2d(
-                    hidden_channels // 8, hidden_channels // 4,
-                    kernel_size=(3, 3), stride=(2, 2)))
-            ),
-            nn.Sequential(
-                nn.LeakyReLU(0.2, True),
-                nn.ReflectionPad2d((1, 1, 1, 1)),
-                nn.utils.weight_norm(nn.Conv2d(
-                    hidden_channels // 4, hidden_channels // 2,
-                    kernel_size=(3, 3), stride=(1, 1)))
-            ),
-            nn.Sequential(
-                nn.LeakyReLU(0.2, True),
-                nn.ReflectionPad2d((1, 1, 1, 1)),
-                nn.utils.weight_norm(nn.Conv2d(
-                    hidden_channels // 2, hidden_channels,
-                    kernel_size=(3, 3), stride=(2, 2)))
-            ),
-            nn.Sequential(
-                nn.LeakyReLU(0.2, True),
-                nn.ReflectionPad2d((1, 1, 1, 1)),
-                nn.utils.weight_norm(nn.Conv2d(
-                    hidden_channels, 1,
-                    kernel_size=(3, 3), stride=(1, 1)))
-            )
-        ]
-
-    def forward(self, x):
-        hiddens = []
-        for layer in self.discriminator:
-            x = layer(x)
-            hiddens.append(x)
-        return x, hiddens[-1]
-
-
-class Discriminator(torch.nn.Module):
-    def __init__(self, hps, use_spectral_norm=False):
-        super(Discriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
-        self.discriminators = nn.ModuleList(discs)
-        # self.disc_multfrequency = MultiFrequencyDiscriminator(hop_lengths=[int(hps.data.sampling_rate * 2.5 / 1000),
-        #                                                                    int(hps.data.sampling_rate * 5 / 1000),
-        #                                                                    int(hps.data.sampling_rate * 7.5 / 1000),
-        #                                                                    int(hps.data.sampling_rate * 10 / 1000),
-        #                                                                    int(hps.data.sampling_rate * 12.5 / 1000),
-        #                                                                    int(hps.data.sampling_rate * 15 / 1000)],
-        #                                                       hidden_channels=[256, 256, 256, 256, 256])
-
-    def forward(self, y, y_hat):
-        y_d_rs = []
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-        # scores_r, fmaps_r = self.disc_multfrequency(y)
-        # scores_g, fmaps_g = self.disc_multfrequency(y_hat)
-        # for i in range(len(scores_r)):
-        #     y_d_rs.append(scores_r[i])
-        #     y_d_gs.append(scores_g[i])
-        #     fmap_rs.append(fmaps_r[i])
-        #     fmap_gs.append(fmaps_g[i])
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class SynthesizerTrn(nn.Module):
-    """
-    Model
-    """
-
-    def __init__(self, hps):
-        super().__init__()
-        self.hps = hps
-
-        self.text_encoder = TextEncoder(
-            hps.data.c_dim,
-            hps.model.prior_hidden_channels,
-            hps.model.prior_hidden_channels,
-            hps.model.prior_filter_channels,
-            hps.model.prior_n_heads,
-            hps.model.prior_n_layers,
-            hps.model.prior_kernel_size,
-            hps.model.prior_p_dropout)
-
-        self.decoder = PriorDecoder(
-            hps.model.hidden_channels * 2,
-            hps.model.prior_hidden_channels,
-            hps.model.prior_filter_channels,
-            hps.model.prior_n_heads,
-            hps.model.prior_n_layers,
-            hps.model.prior_kernel_size,
-            hps.model.prior_p_dropout,
-            n_speakers=hps.data.n_speakers,
-            spk_channels=hps.model.spk_channels
-        )
-
-        self.f0_decoder = F0Decoder(
-            1,
-            hps.model.prior_hidden_channels,
-            hps.model.prior_filter_channels,
-            hps.model.prior_n_heads,
-            hps.model.prior_n_layers,
-            hps.model.prior_kernel_size,
-            hps.model.prior_p_dropout,
-            n_speakers=hps.data.n_speakers,
-            spk_channels=hps.model.spk_channels
-        )
-
-        self.mel_decoder = Decoder(
-            hps.data.acoustic_dim,
-            hps.model.prior_hidden_channels,
-            hps.model.prior_filter_channels,
-            hps.model.prior_n_heads,
-            hps.model.prior_n_layers,
-            hps.model.prior_kernel_size,
-            hps.model.prior_p_dropout,
-            n_speakers=hps.data.n_speakers,
-            spk_channels=hps.model.spk_channels
-        )
-
-        self.posterior_encoder = PosteriorEncoder(
-            hps,
-            hps.data.acoustic_dim,
-            hps.model.hidden_channels,
-            hps.model.hidden_channels, 3, 1, 8)
-
-        self.dropout = nn.Dropout(0.2)
-
-        self.LR = LengthRegulator()
-
-        self.dec = Generator(hps,
-                             hps.model.hidden_channels,
-                             hps.model.resblock,
-                             hps.model.resblock_kernel_sizes,
-                             hps.model.resblock_dilation_sizes,
-                             hps.model.upsample_rates,
-                             hps.model.upsample_initial_channel,
-                             hps.model.upsample_kernel_sizes,
-                             n_speakers=hps.data.n_speakers,
-                             spk_channels=hps.model.spk_channels)
-
-        self.dec_harm = Generator_Harm(hps)
-
-        self.dec_noise = Generator_Noise(hps)
-
-        self.f0_prenet = nn.Conv1d(1, hps.model.prior_hidden_channels , 3, padding=1)
-        self.energy_prenet = nn.Conv1d(1, hps.model.prior_hidden_channels , 3, padding=1)
-        self.mel_prenet = nn.Conv1d(hps.data.acoustic_dim, hps.model.prior_hidden_channels , 3, padding=1)
-
-        if hps.data.n_speakers > 1:
-            self.emb_spk = nn.Embedding(hps.data.n_speakers, hps.model.spk_channels)
-        self.flow = modules.ResidualCouplingBlock(hps.model.prior_hidden_channels, hps.model.hidden_channels, 5, 1, 4,n_speakers=hps.data.n_speakers, gin_channels=hps.model.spk_channels)
-
-    def forward(self, c, c_lengths, F0, uv, mel, bn_lengths, spk_id=None):
-        if self.hps.data.n_speakers > 0:
-            g = self.emb_spk(spk_id).unsqueeze(-1)  # [b, h, 1]
-        else:
-            g = None
-
-        # Encoder
-        decoder_input, x_mask = self.text_encoder(c, c_lengths)
-
-        LF0 = 2595. * torch.log10(1. + F0 / 700.)
-        LF0 = LF0 / 500
-        norm_f0 = utils.normalize_f0(LF0,x_mask, uv.squeeze(1),random_scale=True)
-        pred_lf0, predict_bn_mask = self.f0_decoder(decoder_input, norm_f0, bn_lengths, spk_emb=g)
-        # print(pred_lf0)
-        loss_f0 = F.mse_loss(pred_lf0, LF0)
-
-        # aam
-        predict_mel, predict_bn_mask = self.mel_decoder(decoder_input + self.f0_prenet(LF0), bn_lengths, spk_emb=g)
-
-        predict_energy = predict_mel.detach().sum(1).unsqueeze(1) / self.hps.data.acoustic_dim
-
-        decoder_input = decoder_input + \
-                        self.f0_prenet(LF0) + \
-                        self.energy_prenet(predict_energy) + \
-                        self.mel_prenet(predict_mel.detach())
-        decoder_output, predict_bn_mask = self.decoder(decoder_input, bn_lengths, spk_emb=g)
-
-        prior_info = decoder_output
-        m_p = prior_info[:, :self.hps.model.hidden_channels, :]
-        logs_p = prior_info[:, self.hps.model.hidden_channels:, :]
-
-        # posterior
-        posterior, y_mask = self.posterior_encoder(mel, bn_lengths,g=g)
-
-        m_q = posterior[:, :self.hps.model.hidden_channels, :]
-        logs_q = posterior[:, self.hps.model.hidden_channels:, :]
-        z = (m_q + torch.randn_like(m_q) * torch.exp(logs_q)) * y_mask
-        z_p = self.flow(z, y_mask, g=g)
-
-        # kl loss
-        loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, y_mask)
-
-        p_z = z
-        p_z = self.dropout(p_z)
-
-        pitch = upsample(F0.transpose(1, 2), self.hps.data.hop_length)
-        omega = torch.cumsum(2 * math.pi * pitch / self.hps.data.sampling_rate, 1)
-        sin = torch.sin(omega).transpose(1, 2)
-
-        # dsp synthesize
-        noise_x = self.dec_noise(p_z, y_mask)
-        harm_x = self.dec_harm(F0, p_z, y_mask)
-
-        # dsp waveform
-        dsp_o = torch.cat([harm_x, noise_x], axis=1)
-
-        decoder_condition = torch.cat([harm_x, noise_x, sin], axis=1)
-
-        # dsp based HiFiGAN vocoder
-        x_slice, ids_slice = commons.rand_slice_segments(p_z, bn_lengths,
-                                                         self.hps.train.segment_size // self.hps.data.hop_length)
-        F0_slice = commons.slice_segments(F0, ids_slice, self.hps.train.segment_size // self.hps.data.hop_length)
-        dsp_slice = commons.slice_segments(dsp_o, ids_slice * self.hps.data.hop_length, self.hps.train.segment_size)
-        condition_slice = commons.slice_segments(decoder_condition, ids_slice * self.hps.data.hop_length,
-                                                 self.hps.train.segment_size)
-        o = self.dec(x_slice, condition_slice.detach(), g=g)
-
-        return o, ids_slice, LF0 * predict_bn_mask, dsp_slice.sum(1), loss_kl, \
-               predict_mel, predict_bn_mask, pred_lf0, loss_f0, norm_f0
-
-    def infer(self, c, g=None, f0=None,uv=None, predict_f0=False, noice_scale=0.3):
-        if len(g.shape) == 2:
-            g = g.squeeze(0)
-        if len(f0.shape) == 2:
-            f0 = f0.unsqueeze(0)
-        g = self.emb_spk(g).unsqueeze(-1)  # [b, h, 1]
-
-        c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
-
-        # Encoder
-        decoder_input, x_mask = self.text_encoder(c, c_lengths)
-        y_lengths = c_lengths
-
-        LF0 = 2595. * torch.log10(1. + f0 / 700.)
-        LF0 = LF0 / 500
-
-        if predict_f0:
-            norm_f0 = utils.normalize_f0(LF0, x_mask, uv.squeeze(1))
-            pred_lf0, predict_bn_mask = self.f0_decoder(decoder_input, norm_f0, y_lengths, spk_emb=g)
-            pred_f0 = 700 * ( torch.pow(10, pred_lf0 * 500 / 2595) - 1)
-            f0 = pred_f0
-            LF0 = pred_lf0
-
-        # aam
-        predict_mel, predict_bn_mask = self.mel_decoder(decoder_input + self.f0_prenet(LF0), y_lengths, spk_emb=g)
-        predict_energy = predict_mel.sum(1).unsqueeze(1) / self.hps.data.acoustic_dim
-
-        decoder_input = decoder_input + \
-                        self.f0_prenet(LF0) + \
-                        self.energy_prenet(predict_energy) + \
-                        self.mel_prenet(predict_mel)
-        decoder_output, y_mask = self.decoder(decoder_input, y_lengths, spk_emb=g)
-
-        prior_info = decoder_output
-
-        m_p = prior_info[:, :self.hps.model.hidden_channels, :]
-        logs_p = prior_info[:, self.hps.model.hidden_channels:, :]
-        z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noice_scale
-        z = self.flow(z_p, y_mask, g=g, reverse=True)
-
-        prior_z = z
-
-        noise_x = self.dec_noise(prior_z, y_mask)
-
-        harm_x = self.dec_harm(f0, prior_z, y_mask)
-
-        pitch = upsample(f0.transpose(1, 2), self.hps.data.hop_length)
-        omega = torch.cumsum(2 * math.pi * pitch / self.hps.data.sampling_rate, 1)
-        sin = torch.sin(omega).transpose(1, 2)
-
-        decoder_condition = torch.cat([harm_x, noise_x, sin], axis=1)
-
-        # dsp based HiFiGAN vocoder
-        o = self.dec(prior_z, decoder_condition, g=g)
-
-        return o, harm_x.sum(1).unsqueeze(1), noise_x, f0

modules/attentions.py

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

modules/audio.py

@@ -1,99 +0,0 @@
-import numpy as np
-from numpy import linalg as LA
-import librosa
-from scipy.io import wavfile
-import soundfile as sf
-import librosa.filters
-
-
-def load_wav(wav_path, raw_sr, target_sr=16000, win_size=800, hop_size=200):
-    audio = librosa.core.load(wav_path, sr=raw_sr)[0]
-    if raw_sr != target_sr:
-        audio = librosa.core.resample(audio,
-                                      raw_sr,
-                                      target_sr,
-                                      res_type='kaiser_best')
-        target_length = (audio.size // hop_size +
-                         win_size // hop_size) * hop_size
-        pad_len = (target_length - audio.size) // 2
-        if audio.size % 2 == 0:
-            audio = np.pad(audio, (pad_len, pad_len), mode='reflect')
-        else:
-            audio = np.pad(audio, (pad_len, pad_len + 1), mode='reflect')
-    return audio
-
-
-def save_wav(wav, path, sample_rate, norm=False):
-    if norm:
-        wav *= 32767 / max(0.01, np.max(np.abs(wav)))
-        wavfile.write(path, sample_rate, wav.astype(np.int16))
-    else:
-        sf.write(path, wav, sample_rate)
-
-
-_mel_basis = None
-_inv_mel_basis = None
-
-
-def _build_mel_basis(hparams):
-    assert hparams.fmax <= hparams.sampling_rate // 2
-    return librosa.filters.mel(hparams.sampling_rate,
-                               hparams.n_fft,
-                               n_mels=hparams.acoustic_dim,
-                               fmin=hparams.fmin,
-                               fmax=hparams.fmax)
-
-
-def _linear_to_mel(spectogram, hparams):
-    global _mel_basis
-    if _mel_basis is None:
-        _mel_basis = _build_mel_basis(hparams)
-    return np.dot(_mel_basis, spectogram)
-
-
-def _mel_to_linear(mel_spectrogram, hparams):
-    global _inv_mel_basis
-    if _inv_mel_basis is None:
-        _inv_mel_basis = np.linalg.pinv(_build_mel_basis(hparams))
-    return np.maximum(1e-10, np.dot(_inv_mel_basis, mel_spectrogram))
-
-
-def _stft(y, hparams):
-    return librosa.stft(y=y,
-                        n_fft=hparams.n_fft,
-                        hop_length=hparams.hop_length,
-                        win_length=hparams.win_size)
-
-
-def _amp_to_db(x, hparams):
-    min_level = np.exp(hparams.min_level_db / 20 * np.log(10))
-    return 20 * np.log10(np.maximum(min_level, x))
-
-def _normalize(S, hparams):
-    return hparams.max_abs_value * np.clip(((S - hparams.min_db) /
-                                         (-hparams.min_db)), 0, 1)
-
-def _db_to_amp(x):
-    return np.power(10.0, (x) * 0.05)
-
-
-def _stft(y, hparams):
-    return librosa.stft(y=y,
-                        n_fft=hparams.n_fft,
-                        hop_length=hparams.hop_length,
-                        win_length=hparams.win_size)
-
-
-def _istft(y, hparams):
-    return librosa.istft(y,
-                         hop_length=hparams.hop_length,
-                         win_length=hparams.win_size)
-
-
-def melspectrogram(wav, hparams):
-    D = _stft(wav, hparams)
-    S = _amp_to_db(_linear_to_mel(np.abs(D), hparams),
-                   hparams) - hparams.ref_level_db
-    return _normalize(S, hparams)
-
-

modules/commons.py

@@ -1,188 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-def slice_pitch_segments(x, ids_str, segment_size=4):
-  ret = torch.zeros_like(x[:, :segment_size])
-  for i in range(x.size(0)):
-    idx_str = ids_str[i]
-    idx_end = idx_str + segment_size
-    ret[i] = x[i, idx_str:idx_end]
-  return ret
-
-def rand_slice_segments_with_pitch(x, pitch, x_lengths=None, segment_size=4):
-  b, d, t = x.size()
-  if x_lengths is None:
-    x_lengths = t
-  ids_str_max = x_lengths - segment_size + 1
-  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-  ret = slice_segments(x, ids_str, segment_size)
-  ret_pitch = slice_pitch_segments(pitch, ids_str, segment_size)
-  return ret, ret_pitch, ids_str
-
-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):
-  l = pad_shape[::-1]
-  pad_shape = [item for sublist in l 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. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * 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):
-  ret = torch.zeros_like(x[:, :, :segment_size])
-  for i in range(x.size(0)):
-    idx_str = ids_str[i]
-    idx_end = idx_str + segment_size
-    ret[i] = x[i, :, idx_str:idx_end]
-  return ret
-
-
-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 = x_lengths - segment_size + 1
-  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
-  ret = slice_segments(x, ids_str, segment_size)
-  return ret, ids_str
-
-
-def rand_spec_segments(x, x_lengths=None, segment_size=4):
-  b, d, t = x.size()
-  if x_lengths is None:
-    x_lengths = t
-  ids_str_max = x_lengths - segment_size
-  ids_str = (torch.rand([b]).to(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 convert_pad_shape(pad_shape):
-  l = pad_shape[::-1]
-  pad_shape = [item for sublist in l for item in sublist]
-  return pad_shape
-
-
-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]
-  """
-  device = duration.device
-  
-  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. / norm_type)
-  return total_norm

modules/ddsp.py

@@ -1,189 +0,0 @@
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-import torch.fft as fft
-import numpy as np
-import librosa as li
-import math
-from scipy.signal import get_window
-
-def safe_log(x):
-    return torch.log(x + 1e-7)
-
-
-@torch.no_grad()
-def mean_std_loudness(dataset):
-    mean = 0
-    std = 0
-    n = 0
-    for _, _, l in dataset:
-        n += 1
-        mean += (l.mean().item() - mean) / n
-        std += (l.std().item() - std) / n
-    return mean, std
-
-
-def multiscale_fft(signal, scales, overlap):
-    stfts = []
-    for s in scales:
-        S = torch.stft(
-            signal,
-            s,
-            int(s * (1 - overlap)),
-            s,
-            torch.hann_window(s).to(signal),
-            True,
-            normalized=True,
-            return_complex=True,
-        ).abs()
-        stfts.append(S)
-    return stfts
-
-
-def resample(x, factor: int):
-    batch, frame, channel = x.shape
-    x = x.permute(0, 2, 1).reshape(batch * channel, 1, frame)
-
-    window = torch.hann_window(
-        factor * 2,
-        dtype=x.dtype,
-        device=x.device,
-    ).reshape(1, 1, -1)
-    y = torch.zeros(x.shape[0], x.shape[1], factor * x.shape[2]).to(x)
-    y[..., ::factor] = x
-    y[..., -1:] = x[..., -1:]
-    y = torch.nn.functional.pad(y, [factor, factor])
-    y = torch.nn.functional.conv1d(y, window)[..., :-1]
-
-    y = y.reshape(batch, channel, factor * frame).permute(0, 2, 1)
-
-    return y
-
-
-def upsample(signal, factor):
-    signal = signal.permute(0, 2, 1)
-    signal = nn.functional.interpolate(signal, size=signal.shape[-1] * factor)
-    return signal.permute(0, 2, 1)
-
-
-def remove_above_nyquist(amplitudes, pitch, sampling_rate):
-    n_harm = amplitudes.shape[-1]
-    pitches = pitch * torch.arange(1, n_harm + 1).to(pitch)
-    aa = (pitches < sampling_rate / 2).float() + 1e-4
-    return amplitudes * aa
-
-
-def scale_function(x):
-    return 2 * torch.sigmoid(x)**(math.log(10)) + 1e-7
-
-
-def extract_loudness(signal, sampling_rate, block_size, n_fft=2048):
-    S = li.stft(
-        signal,
-        n_fft=n_fft,
-        hop_length=block_size,
-        win_length=n_fft,
-        center=True,
-    )
-    S = np.log(abs(S) + 1e-7)
-    f = li.fft_frequencies(sampling_rate, n_fft)
-    a_weight = li.A_weighting(f)
-
-    S = S + a_weight.reshape(-1, 1)
-
-    S = np.mean(S, 0)[..., :-1]
-
-    return S
-
-
-def extract_pitch(signal, sampling_rate, block_size):
-    length = signal.shape[-1] // block_size
-    f0 = crepe.predict(
-        signal,
-        sampling_rate,
-        step_size=int(1000 * block_size / sampling_rate),
-        verbose=1,
-        center=True,
-        viterbi=True,
-    )
-    f0 = f0[1].reshape(-1)[:-1]
-
-    if f0.shape[-1] != length:
-        f0 = np.interp(
-            np.linspace(0, 1, length, endpoint=False),
-            np.linspace(0, 1, f0.shape[-1], endpoint=False),
-            f0,
-        )
-
-    return f0
-
-
-def mlp(in_size, hidden_size, n_layers):
-    channels = [in_size] + (n_layers) * [hidden_size]
-    net = []
-    for i in range(n_layers):
-        net.append(nn.Linear(channels[i], channels[i + 1]))
-        net.append(nn.LayerNorm(channels[i + 1]))
-        net.append(nn.LeakyReLU())
-    return nn.Sequential(*net)
-
-
-def gru(n_input, hidden_size):
-    return nn.GRU(n_input * hidden_size, hidden_size, batch_first=True)
-
-
-def harmonic_synth(pitch, amplitudes, sampling_rate):
-    n_harmonic = amplitudes.shape[-1]
-    omega = torch.cumsum(2 * math.pi * pitch / sampling_rate, 1)
-    omegas = omega * torch.arange(1, n_harmonic + 1).to(omega)
-    signal = (torch.sin(omegas) * amplitudes).sum(-1, keepdim=True)
-    return signal
-
-
-def amp_to_impulse_response(amp, target_size):
-    amp = torch.stack([amp, torch.zeros_like(amp)], -1)
-    amp = torch.view_as_complex(amp)
-    amp = fft.irfft(amp)
-
-    filter_size = amp.shape[-1]
-
-    amp = torch.roll(amp, filter_size // 2, -1)
-    win = torch.hann_window(filter_size, dtype=amp.dtype, device=amp.device)
-
-    amp = amp * win
-
-    amp = nn.functional.pad(amp, (0, int(target_size) - int(filter_size)))
-    amp = torch.roll(amp, -filter_size // 2, -1)
-
-    return amp
-
-
-def fft_convolve(signal, kernel):
-    signal = nn.functional.pad(signal, (0, signal.shape[-1]))
-    kernel = nn.functional.pad(kernel, (kernel.shape[-1], 0))
-
-    output = fft.irfft(fft.rfft(signal) * fft.rfft(kernel))
-    output = output[..., output.shape[-1] // 2:]
-
-    return output
-
-
-def init_kernels(win_len, win_inc, fft_len, win_type=None, invers=False):
-    if win_type == 'None' or win_type is None:
-        window = np.ones(win_len)
-    else:
-        window = get_window(win_type, win_len, fftbins=True)#**0.5
-    
-    N = fft_len
-    fourier_basis = np.fft.rfft(np.eye(N))[:win_len]
-    real_kernel = np.real(fourier_basis)
-    imag_kernel = np.imag(fourier_basis)
-    kernel = np.concatenate([real_kernel, imag_kernel], 1).T
-    
-    if invers :
-        kernel = np.linalg.pinv(kernel).T 
-
-    kernel = kernel*window
-    kernel = kernel[:, None, :]
-    return torch.from_numpy(kernel.astype(np.float32)), torch.from_numpy(window[None,:,None].astype(np.float32))
-

modules/losses.py

@@ -1,61 +0,0 @@
-import torch 
-from torch.nn import functional as F
-
-import modules.commons as commons
-
-
-def feature_loss(fmap_r, fmap_g):
-  loss = 0
-  for dr, dg in zip(fmap_r, fmap_g):
-    for rl, gl in zip(dr, dg):
-      rl = rl.float().detach()
-      gl = gl.float()
-      loss += torch.mean(torch.abs(rl - gl))
-
-  return loss * 2 
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
-  loss = 0
-  r_losses = []
-  g_losses = []
-  for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
-    dr = dr.float()
-    dg = dg.float()
-    r_loss = torch.mean((1-dr)**2)
-    g_loss = torch.mean(dg**2)
-    loss += (r_loss + g_loss)
-    r_losses.append(r_loss.item())
-    g_losses.append(g_loss.item())
-
-  return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
-  loss = 0
-  gen_losses = []
-  for dg in disc_outputs:
-    dg = dg.float()
-    l = torch.mean((1-dg)**2)
-    gen_losses.append(l)
-    loss += l
-
-  return loss, gen_losses
-
-
-def kl_loss(z_p, logs_q, m_p, logs_p, z_mask):
-  """
-  z_p, logs_q: [b, h, t_t]
-  m_p, logs_p: [b, h, t_t]
-  """
-  z_p = z_p.float()
-  logs_q = logs_q.float()
-  m_p = m_p.float()
-  logs_p = logs_p.float()
-  z_mask = z_mask.float()
-  #print(logs_p)
-  kl = logs_p - logs_q - 0.5
-  kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p)
-  kl = torch.sum(kl * z_mask)
-  l = kl / torch.sum(z_mask)
-  return l

modules/mel_processing.py

@@ -1,112 +0,0 @@
-import math
-import os
-import random
-import torch
-from torch import nn
-import torch.nn.functional as F
-import torch.utils.data
-import numpy as np
-import librosa
-import librosa.util as librosa_util
-from librosa.util import normalize, pad_center, tiny
-from scipy.signal import get_window
-from scipy.io.wavfile import read
-from librosa.filters import mel as librosa_mel_fn
-
-MAX_WAV_VALUE = 32768.0
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
-    """
-    PARAMS
-    ------
-    C: compression factor
-    """
-    return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
-    """
-    PARAMS
-    ------
-    C: compression factor used to compress
-    """
-    return torch.exp(x) / C
-
-
-def spectral_normalize_torch(magnitudes):
-    output = dynamic_range_compression_torch(magnitudes)
-    return output
-
-
-def spectral_de_normalize_torch(magnitudes):
-    output = dynamic_range_decompression_torch(magnitudes)
-    return output
-
-
-mel_basis = {}
-hann_window = {}
-
-
-def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
-    if torch.min(y) < -1.:
-        print('min value is ', torch.min(y))
-    if torch.max(y) > 1.:
-        print('max value is ', torch.max(y))
-
-    global hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    y = y.squeeze(1)
-
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-    return spec
-
-
-def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
-    global mel_basis
-    dtype_device = str(spec.dtype) + '_' + str(spec.device)
-    fmax_dtype_device = str(fmax) + '_' + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sr=sampling_rate, n_fft=n_fft, n_mels=num_mels, fmin=fmin, fmax=fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device)
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-    return spec
-
-
-def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False):
-    if torch.min(y) < -1.:
-        print('min value is ', torch.min(y))
-    if torch.max(y) > 1.:
-        print('max value is ', torch.max(y))
-
-    global mel_basis, hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    fmax_dtype_device = str(fmax) + '_' + dtype_device
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sr=sampling_rate, n_fft=n_fft, n_mels=num_mels, fmin=fmin, fmax=fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device)
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    y = y.squeeze(1)
-
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-
-    return spec

modules/modules.py

@@ -1,453 +0,0 @@
-import copy
-import math
-import numpy as np
-import scipy
-import torch
-from torch import nn
-from torch.nn import functional as F
-from torch.autograd import Function
-from typing import Any, Optional, Tuple
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-import modules.commons as commons
-from modules.commons import init_weights, get_padding
-from modules.transforms import piecewise_rational_quadratic_transform
-
-LRELU_SLOPE = 0.1
-
-
-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)
-
-
-class ConvReluNorm(nn.Module):
-    def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
-        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.p_dropout = p_dropout
-        assert n_layers > 1, "Number of layers should be larger than 0."
-
-        self.conv_layers = nn.ModuleList()
-        self.norm_layers = nn.ModuleList()
-        self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size // 2))
-        self.norm_layers.append(LayerNorm(hidden_channels))
-        self.relu_drop = nn.Sequential(
-            nn.ReLU(),
-            nn.Dropout(p_dropout))
-        for _ in range(n_layers - 1):
-            self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size // 2))
-            self.norm_layers.append(LayerNorm(hidden_channels))
-        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x, x_mask):
-        x_org = x
-        for i in range(self.n_layers):
-            x = self.conv_layers[i](x * x_mask)
-            x = self.norm_layers[i](x)
-            x = self.relu_drop(x)
-        x = x_org + self.proj(x)
-        return x * x_mask
-
-
-class DDSConv(nn.Module):
-    """
-    Dialted and Depth-Separable Convolution
-    """
-
-    def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
-        super().__init__()
-        self.channels = channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.p_dropout = p_dropout
-
-        self.drop = nn.Dropout(p_dropout)
-        self.convs_sep = nn.ModuleList()
-        self.convs_1x1 = nn.ModuleList()
-        self.norms_1 = nn.ModuleList()
-        self.norms_2 = nn.ModuleList()
-        for i in range(n_layers):
-            dilation = kernel_size ** i
-            padding = (kernel_size * dilation - dilation) // 2
-            self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size,
-                                            groups=channels, dilation=dilation, padding=padding
-                                            ))
-            self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
-            self.norms_1.append(LayerNorm(channels))
-            self.norms_2.append(LayerNorm(channels))
-
-    def forward(self, x, x_mask, g=None):
-        if g is not None:
-            x = x + g
-        for i in range(self.n_layers):
-            y = self.convs_sep[i](x * x_mask)
-            y = self.norms_1[i](y)
-            y = F.gelu(y)
-            y = self.convs_1x1[i](y)
-            y = self.norms_2[i](y)
-            y = F.gelu(y)
-            y = self.drop(y)
-            x = x + y
-        return x * x_mask
-
-
-class WN(torch.nn.Module):
-    def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, n_speakers=0, spk_channels=0,
-                 p_dropout=0):
-        super(WN, self).__init__()
-        assert (kernel_size % 2 == 1)
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size,
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.n_speakers = n_speakers
-        self.spk_channels = spk_channels
-        self.p_dropout = p_dropout
-
-        self.in_layers = torch.nn.ModuleList()
-        self.res_skip_layers = torch.nn.ModuleList()
-        self.drop = nn.Dropout(p_dropout)
-
-        if n_speakers > 0:
-            cond_layer = torch.nn.Conv1d(spk_channels, 2 * hidden_channels * n_layers, 1)
-            self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
-
-        for i in range(n_layers):
-            dilation = dilation_rate ** i
-            padding = int((kernel_size * dilation - dilation) / 2)
-            in_layer = torch.nn.Conv1d(hidden_channels, 2 * hidden_channels, kernel_size,
-                                       dilation=dilation, padding=padding)
-            in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
-            self.in_layers.append(in_layer)
-
-            # last one is not necessary
-            if i < n_layers - 1:
-                res_skip_channels = 2 * hidden_channels
-            else:
-                res_skip_channels = hidden_channels
-
-            res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
-            res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
-            self.res_skip_layers.append(res_skip_layer)
-
-    def forward(self, x, x_mask, g=None, **kwargs):
-        output = torch.zeros_like(x)
-        n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
-        if g is not None:
-            g = self.cond_layer(g)
-
-        for i in range(self.n_layers):
-            x_in = self.in_layers[i](x)
-            if g is not None:
-                cond_offset = i * 2 * self.hidden_channels
-                g_l = g[:, cond_offset:cond_offset + 2 * self.hidden_channels, :]
-            else:
-                g_l = torch.zeros_like(x_in)
-
-            acts = commons.fused_add_tanh_sigmoid_multiply(
-                x_in,
-                g_l,
-                n_channels_tensor)
-            acts = self.drop(acts)
-
-            res_skip_acts = self.res_skip_layers[i](acts)
-            if i < self.n_layers - 1:
-                res_acts = res_skip_acts[:, :self.hidden_channels, :]
-                x = (x + res_acts) * x_mask
-                output = output + res_skip_acts[:, self.hidden_channels:, :]
-            else:
-                output = output + res_skip_acts
-        return output * x_mask
-
-    def remove_weight_norm(self):
-        if self.n_speakers > 0:
-            torch.nn.utils.remove_weight_norm(self.cond_layer)
-        for l in self.in_layers:
-            torch.nn.utils.remove_weight_norm(l)
-        for l in self.res_skip_layers:
-            torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
-        super(ResBlock1, self).__init__()
-        self.convs1 = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                               padding=get_padding(kernel_size, dilation[1]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
-                               padding=get_padding(kernel_size, dilation[2])))
-        ])
-        self.convs1.apply(init_weights)
-
-        self.convs2 = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1)))
-        ])
-        self.convs2.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c1, c2 in zip(self.convs1, self.convs2):
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c1(xt)
-            xt = F.leaky_relu(xt, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c2(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs1:
-            remove_weight_norm(l)
-        for l in self.convs2:
-            remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
-        super(ResBlock2, self).__init__()
-        self.convs = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                               padding=get_padding(kernel_size, dilation[1])))
-        ])
-        self.convs.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c in self.convs:
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class Log(nn.Module):
-    def forward(self, x, x_mask, reverse=False, **kwargs):
-        if not reverse:
-            y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
-            logdet = torch.sum(-y, [1, 2])
-            return y, logdet
-        else:
-            x = torch.exp(x) * x_mask
-            return x
-
-
-class Flip(nn.Module):
-    def forward(self, x, *args, reverse=False, **kwargs):
-        x = torch.flip(x, [1])
-        if not reverse:
-            logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
-            return x, logdet
-        else:
-            return x
-
-
-class ElementwiseAffine(nn.Module):
-    def __init__(self, channels):
-        super().__init__()
-        self.channels = channels
-        self.m = nn.Parameter(torch.zeros(channels, 1))
-        self.logs = nn.Parameter(torch.zeros(channels, 1))
-
-    def forward(self, x, x_mask, reverse=False, **kwargs):
-        if not reverse:
-            y = self.m + torch.exp(self.logs) * x
-            y = y * x_mask
-            logdet = torch.sum(self.logs * x_mask, [1, 2])
-            return y, logdet
-        else:
-            x = (x - self.m) * torch.exp(-self.logs) * x_mask
-            return x
-
-
-class ResidualCouplingLayer(nn.Module):
-    def __init__(self,
-                 channels,
-                 hidden_channels,
-                 kernel_size,
-                 dilation_rate,
-                 n_layers,
-                 p_dropout=0,
-                 n_speakers=0,
-                 spk_channels=0,
-                 mean_only=False):
-        assert channels % 2 == 0, "channels should be divisible by 2"
-        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.half_channels = channels // 2
-        self.mean_only = mean_only
-
-        self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
-        self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, n_speakers=n_speakers,
-                      spk_channels=spk_channels)
-        self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
-        self.post.weight.data.zero_()
-        self.post.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0) * x_mask
-        h = self.enc(h, x_mask, g=g)
-        stats = self.post(h) * x_mask
-        if not self.mean_only:
-            m, logs = torch.split(stats, [self.half_channels] * 2, 1)
-        else:
-            m = stats
-            logs = torch.zeros_like(m)
-
-        if not reverse:
-            x1 = m + x1 * torch.exp(logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            logdet = torch.sum(logs, [1, 2])
-            return x, logdet
-        else:
-            x1 = (x1 - m) * torch.exp(-logs) * x_mask
-            x = torch.cat([x0, x1], 1)
-            return x
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(self,
-                 channels,
-                 hidden_channels,
-                 kernel_size,
-                 dilation_rate,
-                 n_layers,
-                 n_flows=4,
-                 n_speakers=0,
-                 gin_channels=0):
-        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.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers,
-                                                    n_speakers=n_speakers, spk_channels=gin_channels, mean_only=True))
-            self.flows.append(Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-
-class ConvFlow(nn.Module):
-    def __init__(self, in_channels, filter_channels, kernel_size, n_layers, num_bins=10, tail_bound=5.0):
-        super().__init__()
-        self.in_channels = in_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.num_bins = num_bins
-        self.tail_bound = tail_bound
-        self.half_channels = in_channels // 2
-
-        self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
-        self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.)
-        self.proj = nn.Conv1d(filter_channels, self.half_channels * (num_bins * 3 - 1), 1)
-        self.proj.weight.data.zero_()
-        self.proj.bias.data.zero_()
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
-        h = self.pre(x0)
-        h = self.convs(h, x_mask, g=g)
-        h = self.proj(h) * x_mask
-
-        b, c, t = x0.shape
-        h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2)  # [b, cx?, t] -> [b, c, t, ?]
-
-        unnormalized_widths = h[..., :self.num_bins] / math.sqrt(self.filter_channels)
-        unnormalized_heights = h[..., self.num_bins:2 * self.num_bins] / math.sqrt(self.filter_channels)
-        unnormalized_derivatives = h[..., 2 * self.num_bins:]
-
-        x1, logabsdet = piecewise_rational_quadratic_transform(x1,
-                                                               unnormalized_widths,
-                                                               unnormalized_heights,
-                                                               unnormalized_derivatives,
-                                                               inverse=reverse,
-                                                               tails='linear',
-                                                               tail_bound=self.tail_bound
-                                                               )
-
-        x = torch.cat([x0, x1], 1) * x_mask
-        logdet = torch.sum(logabsdet * x_mask, [1, 2])
-        if not reverse:
-            return x, logdet
-        else:
-            return x
-
-
-class ResStack(nn.Module):
-    def __init__(self, channel, kernel_size=3, base=3, nums=4):
-        super(ResStack, self).__init__()
-
-        self.layers = nn.ModuleList([
-            nn.Sequential(
-                nn.LeakyReLU(),
-                nn.utils.weight_norm(nn.Conv1d(channel, channel,
-                                               kernel_size=kernel_size, dilation=base ** i, padding=base ** i)),
-                nn.LeakyReLU(),
-                nn.utils.weight_norm(nn.Conv1d(channel, channel,
-                                               kernel_size=kernel_size, dilation=1, padding=1)),
-            )
-            for i in range(nums)
-        ])
-
-    def forward(self, x):
-        for layer in self.layers:
-            x = x + layer(x)
-        return x

modules/stft.py

@@ -1,512 +0,0 @@
-from librosa.util import pad_center, tiny
-from scipy.signal import get_window
-from torch import Tensor
-from torch.autograd import Variable
-from typing import Optional, Tuple
-
-import librosa
-import librosa.util as librosa_util
-import math
-import numpy as np
-import scipy
-import torch
-import torch.nn.functional as F
-import warnings
-
-
-def create_fb_matrix(
-        n_freqs: int,
-        f_min: float,
-        f_max: float,
-        n_mels: int,
-        sample_rate: int,
-        norm: Optional[str] = None
-) -> Tensor:
-    r"""Create a frequency bin conversion matrix.
-
-    Args:
-        n_freqs (int): Number of frequencies to highlight/apply
-        f_min (float): Minimum frequency (Hz)
-        f_max (float): Maximum frequency (Hz)
-        n_mels (int): Number of mel filterbanks
-        sample_rate (int): Sample rate of the audio waveform
-        norm (Optional[str]): If 'slaney', divide the triangular mel weights by the width of the mel band
-        (area normalization). (Default: ``None``)
-
-    Returns:
-        Tensor: Triangular filter banks (fb matrix) of size (``n_freqs``, ``n_mels``)
-        meaning number of frequencies to highlight/apply to x the number of filterbanks.
-        Each column is a filterbank so that assuming there is a matrix A of
-        size (..., ``n_freqs``), the applied result would be
-        ``A * create_fb_matrix(A.size(-1), ...)``.
-    """
-
-    if norm is not None and norm != "slaney":
-        raise ValueError("norm must be one of None or 'slaney'")
-
-    # freq bins
-    # Equivalent filterbank construction by Librosa
-    all_freqs = torch.linspace(0, sample_rate // 2, n_freqs)
-
-    # calculate mel freq bins
-    # hertz to mel(f) is 2595. * math.log10(1. + (f / 700.))
-    m_min = 2595.0 * math.log10(1.0 + (f_min / 700.0))
-    m_max = 2595.0 * math.log10(1.0 + (f_max / 700.0))
-    m_pts = torch.linspace(m_min, m_max, n_mels + 2)
-    # mel to hertz(mel) is 700. * (10**(mel / 2595.) - 1.)
-    f_pts = 700.0 * (10 ** (m_pts / 2595.0) - 1.0)
-    # calculate the difference between each mel point and each stft freq point in hertz
-    f_diff = f_pts[1:] - f_pts[:-1]  # (n_mels + 1)
-    slopes = f_pts.unsqueeze(0) - all_freqs.unsqueeze(1)  # (n_freqs, n_mels + 2)
-    # create overlapping triangles
-    down_slopes = (-1.0 * slopes[:, :-2]) / f_diff[:-1]  # (n_freqs, n_mels)
-    up_slopes = slopes[:, 2:] / f_diff[1:]  # (n_freqs, n_mels)
-    fb = torch.min(down_slopes, up_slopes)
-    fb = torch.clamp(fb, 1e-6, 1)
-
-    if norm is not None and norm == "slaney":
-        # Slaney-style mel is scaled to be approx constant energy per channel
-        enorm = 2.0 / (f_pts[2:n_mels + 2] - f_pts[:n_mels])
-        fb *= enorm.unsqueeze(0)
-    return fb
-
-
-def lfilter(
-        waveform: Tensor,
-        a_coeffs: Tensor,
-        b_coeffs: Tensor,
-        clamp: bool = True,
-) -> Tensor:
-    r"""Perform an IIR filter by evaluating difference equation.
-
-    Args:
-        waveform (Tensor): audio waveform of dimension of ``(..., time)``.  Must be normalized to -1 to 1.
-        a_coeffs (Tensor): denominator coefficients of difference equation of dimension of ``(n_order + 1)``.
-                                Lower delays coefficients are first, e.g. ``[a0, a1, a2, ...]``.
-                                Must be same size as b_coeffs (pad with 0's as necessary).
-        b_coeffs (Tensor): numerator coefficients of difference equation of dimension of ``(n_order + 1)``.
-                                 Lower delays coefficients are first, e.g. ``[b0, b1, b2, ...]``.
-                                 Must be same size as a_coeffs (pad with 0's as necessary).
-        clamp (bool, optional): If ``True``, clamp the output signal to be in the range [-1, 1] (Default: ``True``)
-
-    Returns:
-        Tensor: Waveform with dimension of ``(..., time)``.
-    """
-    # pack batch
-    shape = waveform.size()
-    waveform = waveform.reshape(-1, shape[-1])
-
-    assert (a_coeffs.size(0) == b_coeffs.size(0))
-    assert (len(waveform.size()) == 2)
-    assert (waveform.device == a_coeffs.device)
-    assert (b_coeffs.device == a_coeffs.device)
-
-    device = waveform.device
-    dtype = waveform.dtype
-    n_channel, n_sample = waveform.size()
-    n_order = a_coeffs.size(0)
-    n_sample_padded = n_sample + n_order - 1
-    assert (n_order > 0)
-
-    # Pad the input and create output
-    padded_waveform = torch.zeros(n_channel, n_sample_padded, dtype=dtype, device=device)
-    padded_waveform[:, (n_order - 1):] = waveform
-    padded_output_waveform = torch.zeros(n_channel, n_sample_padded, dtype=dtype, device=device)
-
-    # Set up the coefficients matrix
-    # Flip coefficients' order
-    a_coeffs_flipped = a_coeffs.flip(0)
-    b_coeffs_flipped = b_coeffs.flip(0)
-
-    # calculate windowed_input_signal in parallel
-    # create indices of original with shape (n_channel, n_order, n_sample)
-    window_idxs = torch.arange(n_sample, device=device).unsqueeze(0) + torch.arange(n_order, device=device).unsqueeze(1)
-    window_idxs = window_idxs.repeat(n_channel, 1, 1)
-    window_idxs += (torch.arange(n_channel, device=device).unsqueeze(-1).unsqueeze(-1) * n_sample_padded)
-    window_idxs = window_idxs.long()
-    # (n_order, ) matmul (n_channel, n_order, n_sample) -> (n_channel, n_sample)
-    input_signal_windows = torch.matmul(b_coeffs_flipped, torch.take(padded_waveform, window_idxs))
-
-    input_signal_windows.div_(a_coeffs[0])
-    a_coeffs_flipped.div_(a_coeffs[0])
-    for i_sample, o0 in enumerate(input_signal_windows.t()):
-        windowed_output_signal = padded_output_waveform[:, i_sample:(i_sample + n_order)]
-        o0.addmv_(windowed_output_signal, a_coeffs_flipped, alpha=-1)
-        padded_output_waveform[:, i_sample + n_order - 1] = o0
-
-    output = padded_output_waveform[:, (n_order - 1):]
-
-    if clamp:
-        output = torch.clamp(output, min=-1., max=1.)
-
-    # unpack batch
-    output = output.reshape(shape[:-1] + output.shape[-1:])
-
-    return output
-
-
-
-def biquad(
-        waveform: Tensor,
-        b0: float,
-        b1: float,
-        b2: float,
-        a0: float,
-        a1: float,
-        a2: float
-) -> Tensor:
-    r"""Perform a biquad filter of input tensor.  Initial conditions set to 0.
-    https://en.wikipedia.org/wiki/Digital_biquad_filter
-
-    Args:
-        waveform (Tensor): audio waveform of dimension of `(..., time)`
-        b0 (float): numerator coefficient of current input, x[n]
-        b1 (float): numerator coefficient of input one time step ago x[n-1]
-        b2 (float): numerator coefficient of input two time steps ago x[n-2]
-        a0 (float): denominator coefficient of current output y[n], typically 1
-        a1 (float): denominator coefficient of current output y[n-1]
-        a2 (float): denominator coefficient of current output y[n-2]
-
-    Returns:
-        Tensor: Waveform with dimension of `(..., time)`
-    """
-
-    device = waveform.device
-    dtype = waveform.dtype
-
-    output_waveform = lfilter(
-        waveform,
-        torch.tensor([a0, a1, a2], dtype=dtype, device=device),
-        torch.tensor([b0, b1, b2], dtype=dtype, device=device)
-    )
-    return output_waveform
-
-
-
-def _dB2Linear(x: float) -> float:
-    return math.exp(x * math.log(10) / 20.0)
-
-
-def highpass_biquad(
-        waveform: Tensor,
-        sample_rate: int,
-        cutoff_freq: float,
-        Q: float = 0.707
-) -> Tensor:
-    r"""Design biquad highpass filter and perform filtering.  Similar to SoX implementation.
-
-    Args:
-        waveform (Tensor): audio waveform of dimension of `(..., time)`
-        sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
-        cutoff_freq (float): filter cutoff frequency
-        Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``)
-
-    Returns:
-        Tensor: Waveform dimension of `(..., time)`
-    """
-    w0 = 2 * math.pi * cutoff_freq / sample_rate
-    alpha = math.sin(w0) / 2. / Q
-
-    b0 = (1 + math.cos(w0)) / 2
-    b1 = -1 - math.cos(w0)
-    b2 = b0
-    a0 = 1 + alpha
-    a1 = -2 * math.cos(w0)
-    a2 = 1 - alpha
-    return biquad(waveform, b0, b1, b2, a0, a1, a2)
-
-
-
-def lowpass_biquad(
-        waveform: Tensor,
-        sample_rate: int,
-        cutoff_freq: float,
-        Q: float = 0.707
-) -> Tensor:
-    r"""Design biquad lowpass filter and perform filtering.  Similar to SoX implementation.
-
-    Args:
-        waveform (torch.Tensor): audio waveform of dimension of `(..., time)`
-        sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
-        cutoff_freq (float): filter cutoff frequency
-        Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``)
-
-    Returns:
-        Tensor: Waveform of dimension of `(..., time)`
-    """
-    w0 = 2 * math.pi * cutoff_freq / sample_rate
-    alpha = math.sin(w0) / 2 / Q
-
-    b0 = (1 - math.cos(w0)) / 2
-    b1 = 1 - math.cos(w0)
-    b2 = b0
-    a0 = 1 + alpha
-    a1 = -2 * math.cos(w0)
-    a2 = 1 - alpha
-    return biquad(waveform, b0, b1, b2, a0, a1, a2)
-
-
-def window_sumsquare(window, n_frames, hop_length=200, win_length=800,
-                     n_fft=800, dtype=np.float32, norm=None):
-    """
-    # from librosa 0.6
-    Compute the sum-square envelope of a window function at a given hop length.
-
-    This is used to estimate modulation effects induced by windowing
-    observations in short-time fourier transforms.
-
-    Parameters
-    ----------
-    window : string, tuple, number, callable, or list-like
-        Window specification, as in `get_window`
-
-    n_frames : int > 0
-        The number of analysis frames
-
-    hop_length : int > 0
-        The number of samples to advance between frames
-
-    win_length : [optional]
-        The length of the window function.  By default, this matches `n_fft`.
-
-    n_fft : int > 0
-        The length of each analysis frame.
-
-    dtype : np.dtype
-        The data type of the output
-
-    Returns
-    -------
-    wss : np.ndarray, shape=`(n_fft + hop_length * (n_frames - 1))`
-        The sum-squared envelope of the window function
-    """
-    if win_length is None:
-        win_length = n_fft
-
-    n = n_fft + hop_length * (n_frames - 1)
-    x = np.zeros(n, dtype=dtype)
-
-    # Compute the squared window at the desired length
-    win_sq = get_window(window, win_length, fftbins=True)
-    win_sq = librosa_util.normalize(win_sq, norm=norm)**2
-    win_sq = librosa_util.pad_center(win_sq, n_fft)
-
-    # Fill the envelope
-    for i in range(n_frames):
-        sample = i * hop_length
-        x[sample:min(n, sample + n_fft)] += win_sq[:max(0, min(n_fft, n - sample))]
-    return x
-
-
-class MelScale(torch.nn.Module):
-    r"""Turn a normal STFT into a mel frequency STFT, using a conversion
-    matrix.  This uses triangular filter banks.
-
-    User can control which device the filter bank (`fb`) is (e.g. fb.to(spec_f.device)).
-
-    Args:
-        n_mels (int, optional): Number of mel filterbanks. (Default: ``128``)
-        sample_rate (int, optional): Sample rate of audio signal. (Default: ``16000``)
-        f_min (float, optional): Minimum frequency. (Default: ``0.``)
-        f_max (float or None, optional): Maximum frequency. (Default: ``sample_rate // 2``)
-        n_stft (int, optional): Number of bins in STFT. Calculated from first input
-            if None is given.  See ``n_fft`` in :class:`Spectrogram`. (Default: ``None``)
-    """
-    __constants__ = ['n_mels', 'sample_rate', 'f_min', 'f_max']
-
-    def __init__(self,
-                 n_mels: int = 128,
-                 sample_rate: int = 24000,
-                 f_min: float = 0.,
-                 f_max: Optional[float] = None,
-                 n_stft: Optional[int] = None) -> None:
-        super(MelScale, self).__init__()
-        self.n_mels = n_mels
-        self.sample_rate = sample_rate
-        self.f_max = f_max if f_max is not None else float(sample_rate // 2)
-        self.f_min = f_min
-
-        assert f_min <= self.f_max, 'Require f_min: %f < f_max: %f' % (f_min, self.f_max)
-
-        fb = torch.empty(0) if n_stft is None else create_fb_matrix(
-            n_stft, self.f_min, self.f_max, self.n_mels, self.sample_rate)
-        self.register_buffer('fb', fb)
-
-    def forward(self, specgram: Tensor) -> Tensor:
-        r"""
-        Args:
-            specgram (Tensor): A spectrogram STFT of dimension (..., freq, time).
-
-        Returns:
-            Tensor: Mel frequency spectrogram of size (..., ``n_mels``, time).
-        """
-
-        # pack batch
-        shape = specgram.size()
-        specgram = specgram.reshape(-1, shape[-2], shape[-1])
-
-        if self.fb.numel() == 0:
-            tmp_fb = create_fb_matrix(specgram.size(1), self.f_min, self.f_max, self.n_mels, self.sample_rate)
-            # Attributes cannot be reassigned outside __init__ so workaround
-            self.fb.resize_(tmp_fb.size())
-            self.fb.copy_(tmp_fb)
-
-        # (channel, frequency, time).transpose(...) dot (frequency, n_mels)
-        # -> (channel, time, n_mels).transpose(...)
-        mel_specgram = torch.matmul(specgram.transpose(1, 2), self.fb).transpose(1, 2)
-
-        # unpack batch
-        mel_specgram = mel_specgram.reshape(shape[:-2] + mel_specgram.shape[-2:])
-
-        return mel_specgram
-
-
-class TorchSTFT(torch.nn.Module):
-    def __init__(self, fft_size, hop_size, win_size,
-                 normalized=False, domain='linear',
-                 mel_scale=False, ref_level_db=20, min_level_db=-100):
-        super().__init__()
-        self.fft_size = fft_size
-        self.hop_size = hop_size
-        self.win_size = win_size
-        self.ref_level_db = ref_level_db
-        self.min_level_db = min_level_db
-        self.window = torch.hann_window(win_size)
-        self.normalized = normalized
-        self.domain = domain
-        self.mel_scale = MelScale(n_mels=(fft_size // 2 + 1),
-            n_stft=(fft_size // 2 + 1)) if mel_scale else None
-        
-    def transform(self, x):
-        x_stft = torch.stft(x.to(torch.float32), self.fft_size, self.hop_size, self.win_size,
-                            self.window.type_as(x), normalized=self.normalized)
-        real = x_stft[..., 0]
-        imag = x_stft[..., 1]
-        mag = torch.clamp(real ** 2 + imag ** 2, min=1e-7)
-        mag = torch.sqrt(mag)
-        phase = torch.atan2(imag, real)
-
-        if self.mel_scale is not None:
-            mag = self.mel_scale(mag)
-
-        if self.domain == 'log':
-            mag = 20 * torch.log10(mag) - self.ref_level_db
-            mag = torch.clamp((mag - self.min_level_db) / -self.min_level_db, 0, 1)
-            return mag, phase
-        elif self.domain == 'linear':
-            return mag, phase
-        elif self.domain == 'double':
-            log_mag = 20 * torch.log10(mag) - self.ref_level_db
-            log_mag = torch.clamp((log_mag - self.min_level_db) / -self.min_level_db, 0, 1)
-            return torch.cat((mag, log_mag), dim=1), phase
-
-    def complex(self, x):
-        x_stft = torch.stft(x, self.fft_size, self.hop_size, self.win_size,
-                            self.window.type_as(x), normalized=self.normalized)
-        real = x_stft[..., 0]
-        imag = x_stft[..., 1]
-        return real, imag
-
-
-
-class STFT(torch.nn.Module):
-    """adapted from Prem Seetharaman's https://github.com/pseeth/pytorch-stft"""
-    def __init__(self, filter_length=800, hop_length=200, win_length=800,
-                 window='hann'):
-        super(STFT, self).__init__()
-        self.filter_length = filter_length
-        self.hop_length = hop_length
-        self.win_length = win_length
-        self.window = window
-        self.forward_transform = None
-        scale = self.filter_length / self.hop_length
-        fourier_basis = np.fft.fft(np.eye(self.filter_length))
-
-        cutoff = int((self.filter_length / 2 + 1))
-        fourier_basis = np.vstack([np.real(fourier_basis[:cutoff, :]),
-                                   np.imag(fourier_basis[:cutoff, :])])
-
-        forward_basis = torch.FloatTensor(fourier_basis[:, None, :])
-        inverse_basis = torch.FloatTensor(
-            np.linalg.pinv(scale * fourier_basis).T[:, None, :])
-
-        if window is not None:
-            assert(filter_length >= win_length)
-            # get window and zero center pad it to filter_length
-            fft_window = get_window(window, win_length, fftbins=True)
-            fft_window = pad_center(fft_window, filter_length)
-            fft_window = torch.from_numpy(fft_window).float()
-
-            # window the bases
-            forward_basis *= fft_window
-            inverse_basis *= fft_window
-
-        self.register_buffer('forward_basis', forward_basis.float())
-        self.register_buffer('inverse_basis', inverse_basis.float())
-
-    def transform(self, input_data):
-        num_batches = input_data.size(0)
-        num_samples = input_data.size(1)
-
-        self.num_samples = num_samples
-
-        # similar to librosa, reflect-pad the input
-        input_data = input_data.view(num_batches, 1, num_samples)
-        input_data = F.pad(
-            input_data.unsqueeze(1),
-            (int(self.filter_length / 2), int(self.filter_length / 2), 0, 0),
-            mode='reflect')
-        input_data = input_data.squeeze(1)
-
-        forward_transform = F.conv1d(
-            input_data,
-            Variable(self.forward_basis, requires_grad=False),
-            stride=self.hop_length,
-            padding=0)
-
-        cutoff = int((self.filter_length / 2) + 1)
-        real_part = forward_transform[:, :cutoff, :]
-        imag_part = forward_transform[:, cutoff:, :]
-
-        magnitude = torch.sqrt(real_part**2 + imag_part**2)
-        phase = torch.autograd.Variable(
-            torch.atan2(imag_part.data, real_part.data))
-
-        return magnitude, phase
-
-    def inverse(self, magnitude, phase):
-        recombine_magnitude_phase = torch.cat(
-            [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1)
-
-        inverse_transform = F.conv_transpose1d(
-            recombine_magnitude_phase,
-            Variable(self.inverse_basis, requires_grad=False),
-            stride=self.hop_length,
-            padding=0)
-
-        if self.window is not None:
-            window_sum = window_sumsquare(
-                self.window, magnitude.size(-1), hop_length=self.hop_length,
-                win_length=self.win_length, n_fft=self.filter_length,
-                dtype=np.float32)
-            # remove modulation effects
-            approx_nonzero_indices = torch.from_numpy(
-                np.where(window_sum > tiny(window_sum))[0])
-            window_sum = torch.autograd.Variable(
-                torch.from_numpy(window_sum), requires_grad=False)
-            window_sum = window_sum.cuda() if magnitude.is_cuda else window_sum
-            inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices]
-
-            # scale by hop ratio
-            inverse_transform *= float(self.filter_length) / self.hop_length
-
-        inverse_transform = inverse_transform[:, :, int(self.filter_length/2):]
-        inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):]
-
-        return inverse_transform
-
-    def forward(self, input_data):
-        self.magnitude, self.phase = self.transform(input_data)
-        reconstruction = self.inverse(self.magnitude, self.phase)
-        return reconstruction
-

modules/transforms.py

@@ -1,193 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import numpy as np
-
-
-DEFAULT_MIN_BIN_WIDTH = 1e-3
-DEFAULT_MIN_BIN_HEIGHT = 1e-3
-DEFAULT_MIN_DERIVATIVE = 1e-3
-
-
-def piecewise_rational_quadratic_transform(inputs, 
-                                           unnormalized_widths,
-                                           unnormalized_heights,
-                                           unnormalized_derivatives,
-                                           inverse=False,
-                                           tails=None, 
-                                           tail_bound=1.,
-                                           min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                                           min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                                           min_derivative=DEFAULT_MIN_DERIVATIVE):
-
-    if tails is None:
-        spline_fn = rational_quadratic_spline
-        spline_kwargs = {}
-    else:
-        spline_fn = unconstrained_rational_quadratic_spline
-        spline_kwargs = {
-            'tails': tails,
-            'tail_bound': tail_bound
-        }
-
-    outputs, logabsdet = spline_fn(
-            inputs=inputs,
-            unnormalized_widths=unnormalized_widths,
-            unnormalized_heights=unnormalized_heights,
-            unnormalized_derivatives=unnormalized_derivatives,
-            inverse=inverse,
-            min_bin_width=min_bin_width,
-            min_bin_height=min_bin_height,
-            min_derivative=min_derivative,
-            **spline_kwargs
-    )
-    return outputs, logabsdet
-
-
-def searchsorted(bin_locations, inputs, eps=1e-6):
-    bin_locations[..., -1] += eps
-    return torch.sum(
-        inputs[..., None] >= bin_locations,
-        dim=-1
-    ) - 1
-
-
-def unconstrained_rational_quadratic_spline(inputs,
-                                            unnormalized_widths,
-                                            unnormalized_heights,
-                                            unnormalized_derivatives,
-                                            inverse=False,
-                                            tails='linear',
-                                            tail_bound=1.,
-                                            min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                                            min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                                            min_derivative=DEFAULT_MIN_DERIVATIVE):
-    inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
-    outside_interval_mask = ~inside_interval_mask
-
-    outputs = torch.zeros_like(inputs)
-    logabsdet = torch.zeros_like(inputs)
-
-    if tails == 'linear':
-        unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
-        constant = np.log(np.exp(1 - min_derivative) - 1)
-        unnormalized_derivatives[..., 0] = constant
-        unnormalized_derivatives[..., -1] = constant
-
-        outputs[outside_interval_mask] = inputs[outside_interval_mask]
-        logabsdet[outside_interval_mask] = 0
-    else:
-        raise RuntimeError('{} tails are not implemented.'.format(tails))
-
-    outputs[inside_interval_mask], logabsdet[inside_interval_mask] = rational_quadratic_spline(
-        inputs=inputs[inside_interval_mask],
-        unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
-        unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
-        unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
-        inverse=inverse,
-        left=-tail_bound, right=tail_bound, bottom=-tail_bound, top=tail_bound,
-        min_bin_width=min_bin_width,
-        min_bin_height=min_bin_height,
-        min_derivative=min_derivative
-    )
-
-    return outputs, logabsdet
-
-def rational_quadratic_spline(inputs,
-                              unnormalized_widths,
-                              unnormalized_heights,
-                              unnormalized_derivatives,
-                              inverse=False,
-                              left=0., right=1., bottom=0., top=1.,
-                              min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                              min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                              min_derivative=DEFAULT_MIN_DERIVATIVE):
-    if torch.min(inputs) < left or torch.max(inputs) > right:
-        raise ValueError('Input to a transform is not within its domain')
-
-    num_bins = unnormalized_widths.shape[-1]
-
-    if min_bin_width * num_bins > 1.0:
-        raise ValueError('Minimal bin width too large for the number of bins')
-    if min_bin_height * num_bins > 1.0:
-        raise ValueError('Minimal bin height too large for the number of bins')
-
-    widths = F.softmax(unnormalized_widths, dim=-1)
-    widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
-    cumwidths = torch.cumsum(widths, dim=-1)
-    cumwidths = F.pad(cumwidths, pad=(1, 0), mode='constant', value=0.0)
-    cumwidths = (right - left) * cumwidths + left
-    cumwidths[..., 0] = left
-    cumwidths[..., -1] = right
-    widths = cumwidths[..., 1:] - cumwidths[..., :-1]
-
-    derivatives = min_derivative + F.softplus(unnormalized_derivatives)
-
-    heights = F.softmax(unnormalized_heights, dim=-1)
-    heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
-    cumheights = torch.cumsum(heights, dim=-1)
-    cumheights = F.pad(cumheights, pad=(1, 0), mode='constant', value=0.0)
-    cumheights = (top - bottom) * cumheights + bottom
-    cumheights[..., 0] = bottom
-    cumheights[..., -1] = top
-    heights = cumheights[..., 1:] - cumheights[..., :-1]
-
-    if inverse:
-        bin_idx = searchsorted(cumheights, inputs)[..., None]
-    else:
-        bin_idx = searchsorted(cumwidths, inputs)[..., None]
-
-    input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]
-    input_bin_widths = widths.gather(-1, bin_idx)[..., 0]
-
-    input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]
-    delta = heights / widths
-    input_delta = delta.gather(-1, bin_idx)[..., 0]
-
-    input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]
-    input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]
-
-    input_heights = heights.gather(-1, bin_idx)[..., 0]
-
-    if inverse:
-        a = (((inputs - input_cumheights) * (input_derivatives
-                                             + input_derivatives_plus_one
-                                             - 2 * input_delta)
-              + input_heights * (input_delta - input_derivatives)))
-        b = (input_heights * input_derivatives
-             - (inputs - input_cumheights) * (input_derivatives
-                                              + input_derivatives_plus_one
-                                              - 2 * input_delta))
-        c = - input_delta * (inputs - input_cumheights)
-
-        discriminant = b.pow(2) - 4 * a * c
-        assert (discriminant >= 0).all()
-
-        root = (2 * c) / (-b - torch.sqrt(discriminant))
-        outputs = root * input_bin_widths + input_cumwidths
-
-        theta_one_minus_theta = root * (1 - root)
-        denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-                                     * theta_one_minus_theta)
-        derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * root.pow(2)
-                                                     + 2 * input_delta * theta_one_minus_theta
-                                                     + input_derivatives * (1 - root).pow(2))
-        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
-        return outputs, -logabsdet
-    else:
-        theta = (inputs - input_cumwidths) / input_bin_widths
-        theta_one_minus_theta = theta * (1 - theta)
-
-        numerator = input_heights * (input_delta * theta.pow(2)
-                                     + input_derivatives * theta_one_minus_theta)
-        denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-                                     * theta_one_minus_theta)
-        outputs = input_cumheights + numerator / denominator
-
-        derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * theta.pow(2)
-                                                     + 2 * input_delta * theta_one_minus_theta
-                                                     + input_derivatives * (1 - theta).pow(2))
-        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
-        return outputs, logabsdet

onnx_export.py

@@ -1,94 +0,0 @@
-import torch
-from torchaudio.models.wav2vec2.utils import import_fairseq_model
-from fairseq import checkpoint_utils
-from onnxexport.model_onnx import SynthesizerTrn
-import utils
-
-def get_hubert_model():
-    vec_path = "hubert/checkpoint_best_legacy_500.pt"
-    print("load model(s) from {}".format(vec_path))
-    models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
-        [vec_path],
-        suffix="",
-    )
-    model = models[0]
-    model.eval()
-    return model
-
-
-def main(HubertExport, NetExport):
-    path = "SoVits4.0"
-
-    '''if HubertExport:
-        device = torch.device("cpu")
-        vec_path = "hubert/checkpoint_best_legacy_500.pt"
-        models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
-            [vec_path],
-            suffix="",
-        )
-        original = models[0]
-        original.eval()
-        model = original
-        test_input = torch.rand(1, 1, 16000)
-        model(test_input)
-        torch.onnx.export(model,
-                          test_input,
-                          "hubert4.0.onnx",
-                          export_params=True,
-                          opset_version=16,
-                          do_constant_folding=True,
-                          input_names=['source'],
-                          output_names=['embed'],
-                          dynamic_axes={
-                              'source':
-                                  {
-                                      2: "sample_length"
-                                  },
-                          }
-                          )'''
-    if NetExport:
-        device = torch.device("cpu")
-        hps = utils.get_hparams_from_file(f"checkpoints/{path}/config.json")
-        SVCVITS = SynthesizerTrn(
-            hps.data.filter_length // 2 + 1,
-            hps.train.segment_size // hps.data.hop_length,
-            **hps.model)
-        _ = utils.load_checkpoint(f"checkpoints/{path}/model.pth", SVCVITS, None)
-        _ = SVCVITS.eval().to(device)
-        for i in SVCVITS.parameters():
-            i.requires_grad = False
-        test_hidden_unit = torch.rand(1, 10, 256)
-        test_pitch = torch.rand(1, 10)
-        test_mel2ph = torch.LongTensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).unsqueeze(0)
-        test_uv = torch.ones(1, 10, dtype=torch.float32)
-        test_noise = torch.randn(1, 192, 10)
-        test_sid = torch.LongTensor([0])
-        input_names = ["c", "f0", "mel2ph", "uv", "noise", "sid"]
-        output_names = ["audio", ]
-        SVCVITS.eval()
-        torch.onnx.export(SVCVITS,
-                          (
-                              test_hidden_unit.to(device),
-                              test_pitch.to(device),
-                              test_mel2ph.to(device),
-                              test_uv.to(device),
-                              test_noise.to(device),
-                              test_sid.to(device)
-                          ),
-                          f"checkpoints/{path}/model.onnx",
-                          dynamic_axes={
-                              "c": [0, 1],
-                              "f0": [1],
-                              "mel2ph": [1],
-                              "uv": [1],
-                              "noise": [2],
-                          },
-                          do_constant_folding=False,
-                          opset_version=16,
-                          verbose=False,
-                          input_names=input_names,
-                          output_names=output_names)
-
-
-if __name__ == '__main__':
-    main(False, True)

preprocess_flist_config.py

@@ -1,83 +0,0 @@
-import os
-import argparse
-import re
-
-from tqdm import tqdm
-from random import shuffle
-import json
-import wave
-
-config_template = json.load(open("configs/config.json"))
-
-pattern = re.compile(r'^[\.a-zA-Z0-9_\/]+$')
-
-def get_wav_duration(file_path):
-    with wave.open(file_path, 'rb') as wav_file:
-        # 获取音频帧数
-        n_frames = wav_file.getnframes()
-        # 获取采样率
-        framerate = wav_file.getframerate()
-        # 计算时长（秒）
-        duration = n_frames / float(framerate)
-    return duration
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--train_list", type=str, default="./filelists/train.txt", help="path to train list")
-    parser.add_argument("--val_list", type=str, default="./filelists/val.txt", help="path to val list")
-    parser.add_argument("--test_list", type=str, default="./filelists/test.txt", help="path to test list")
-    parser.add_argument("--source_dir", type=str, default="./dataset/44k", help="path to source dir")
-    args = parser.parse_args()
-    
-    train = []
-    val = []
-    test = []
-    idx = 0
-    spk_dict = {}
-    spk_id = 0
-    for speaker in tqdm(os.listdir(args.source_dir)):
-        spk_dict[speaker] = spk_id
-        spk_id += 1
-        wavs = ["/".join([args.source_dir, speaker, i]) for i in os.listdir(os.path.join(args.source_dir, speaker))]
-        new_wavs = []
-        for file in wavs:
-            if not file.endswith("wav"):
-                continue
-            if not pattern.match(file):
-                print(f"warning：文件名{file}中包含非字母数字下划线，可能会导致错误。（也可能不会）")
-            if get_wav_duration(file) < 0.3:
-                print("skip too short audio:", file)
-                continue
-            new_wavs.append(file)
-        wavs = new_wavs
-        shuffle(wavs)
-        train += wavs[2:-2]
-        val += wavs[:2]
-        test += wavs[-2:]
-
-    shuffle(train)
-    shuffle(val)
-    shuffle(test)
-            
-    print("Writing", args.train_list)
-    with open(args.train_list, "w") as f:
-        for fname in tqdm(train):
-            wavpath = fname
-            f.write(wavpath + "\n")
-        
-    print("Writing", args.val_list)
-    with open(args.val_list, "w") as f:
-        for fname in tqdm(val):
-            wavpath = fname
-            f.write(wavpath + "\n")
-            
-    print("Writing", args.test_list)
-    with open(args.test_list, "w") as f:
-        for fname in tqdm(test):
-            wavpath = fname
-            f.write(wavpath + "\n")
-
-    config_template["spk"] = spk_dict
-    print("Writing configs/config.json")
-    with open("configs/config.json", "w") as f:
-        json.dump(config_template, f, indent=2)

preprocess_hubert_f0.py

@@ -1,62 +0,0 @@
-import math
-import multiprocessing
-import os
-import argparse
-from random import shuffle
-
-import torch
-from glob import glob
-from tqdm import tqdm
-
-import utils
-import logging
-logging.getLogger('numba').setLevel(logging.WARNING)
-import librosa
-import numpy as np
-
-hps = utils.get_hparams_from_file("configs/config.json")
-sampling_rate = hps.data.sampling_rate
-hop_length = hps.data.hop_length
-
-
-def process_one(filename, hmodel):
-    # print(filename)
-    wav, sr = librosa.load(filename, sr=sampling_rate)
-    soft_path = filename + ".soft.pt"
-    if not os.path.exists(soft_path):
-        devive = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        wav16k = librosa.resample(wav, orig_sr=sampling_rate, target_sr=16000)
-        wav16k = torch.from_numpy(wav16k).to(devive)
-        c = utils.get_hubert_content(hmodel, wav_16k_tensor=wav16k)
-        torch.save(c.cpu(), soft_path)
-    f0_path = filename + ".f0.npy"
-    if not os.path.exists(f0_path):
-        f0 = utils.compute_f0_dio(wav, sampling_rate=sampling_rate, hop_length=hop_length)
-        np.save(f0_path, f0)
-
-
-def process_batch(filenames):
-    print("Loading hubert for content...")
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    hmodel = utils.get_hubert_model().to(device)
-    print("Loaded hubert.")
-    for filename in tqdm(filenames):
-        process_one(filename, hmodel)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--in_dir", type=str, default="dataset/44k", help="path to input dir")
-
-    args = parser.parse_args()
-    filenames = glob(f'{args.in_dir}/*/*.wav', recursive=True)  # [:10]
-    shuffle(filenames)
-    multiprocessing.set_start_method('spawn',force=True)
-
-    num_processes = 1
-    chunk_size = int(math.ceil(len(filenames) / num_processes))
-    chunks = [filenames[i:i + chunk_size] for i in range(0, len(filenames), chunk_size)]
-    print([len(c) for c in chunks])
-    processes = [multiprocessing.Process(target=process_batch, args=(chunk,)) for chunk in chunks]
-    for p in processes:
-        p.start()

requirements.txt

@@ -1,17 +0,0 @@
-Flask
-Flask_Cors
-gradio
-numpy==1.22.4
-pyworld==0.3.2
-scipy==1.7.3
-SoundFile==0.12.1
-torch==1.13.1
-torchaudio==0.13.1
-tqdm
-scikit-maad
-praat-parselmouth
-onnx
-onnxsim
-onnxoptimizer
-fairseq==0.12.2
-librosa==0.8.1

resample.py

@@ -1,48 +0,0 @@
-import os
-import argparse
-import librosa
-import numpy as np
-from multiprocessing import Pool, cpu_count
-from scipy.io import wavfile
-from tqdm import tqdm
-
-
-def process(item):
-    spkdir, wav_name, args = item
-    # speaker 's5', 'p280', 'p315' are excluded,
-    speaker = spkdir.replace("\\", "/").split("/")[-1]
-    wav_path = os.path.join(args.in_dir, speaker, wav_name)
-    if os.path.exists(wav_path) and '.wav' in wav_path:
-        os.makedirs(os.path.join(args.out_dir2, speaker), exist_ok=True)
-        wav, sr = librosa.load(wav_path, sr=None)
-        wav, _ = librosa.effects.trim(wav, top_db=20)
-        peak = np.abs(wav).max()
-        if peak > 1.0:
-            wav = 0.98 * wav / peak
-        wav2 = librosa.resample(wav, orig_sr=sr, target_sr=args.sr2)
-        wav2 /= max(wav2.max(), -wav2.min())
-        save_name = wav_name
-        save_path2 = os.path.join(args.out_dir2, speaker, save_name)
-        wavfile.write(
-            save_path2,
-            args.sr2,
-            (wav2 * np.iinfo(np.int16).max).astype(np.int16)
-        )
-
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--sr2", type=int, default=44100, help="sampling rate")
-    parser.add_argument("--in_dir", type=str, default="./dataset_raw", help="path to source dir")
-    parser.add_argument("--out_dir2", type=str, default="./dataset/44k", help="path to target dir")
-    args = parser.parse_args()
-    processs = cpu_count()-2 if cpu_count() >4 else 1
-    pool = Pool(processes=processs)
-
-    for speaker in os.listdir(args.in_dir):
-        spk_dir = os.path.join(args.in_dir, speaker)
-        if os.path.isdir(spk_dir):
-            print(spk_dir)
-            for _ in tqdm(pool.imap_unordered(process, [(spk_dir, i, args) for i in os.listdir(spk_dir) if i.endswith("wav")])):
-                pass

spec_gen.py

@@ -1,22 +0,0 @@
-from data_utils import TextAudioSpeakerLoader
-import json
-from tqdm import tqdm
-
-from utils import HParams
-
-config_path = 'configs/config.json'
-with open(config_path, "r") as f:
-    data = f.read()
-config = json.loads(data)
-hps = HParams(**config)
-
-train_dataset = TextAudioSpeakerLoader("filelists/train.txt", hps)
-test_dataset = TextAudioSpeakerLoader("filelists/test.txt", hps)
-eval_dataset = TextAudioSpeakerLoader("filelists/val.txt", hps)
-
-for _ in tqdm(train_dataset):
-    pass
-for _ in tqdm(eval_dataset):
-    pass
-for _ in tqdm(test_dataset):
-    pass

train.py

@@ -1,435 +0,0 @@
-import os
-import sys
-import json
-import argparse
-import itertools
-import math
-import time
-import logging
-
-import torch
-from torch import nn, optim
-from torch.nn import functional as F
-from torch.utils.data import DataLoader
-from torch.utils.tensorboard import SummaryWriter
-import torch.multiprocessing as mp
-import torch.distributed as dist
-from torch.nn.parallel import DistributedDataParallel as DDP
-from torch.cuda.amp import autocast, GradScaler
-
-sys.path.append('../..')
-import modules.commons as commons
-import utils
-
-from data_utils import DatasetConstructor
-
-from models import (
-    SynthesizerTrn,
-    Discriminator
-)
-
-from modules.losses import (
-    generator_loss,
-    discriminator_loss,
-    feature_loss,
-    kl_loss,
-)
-from modules.mel_processing import mel_spectrogram_torch, spec_to_mel_torch, spectrogram_torch
-
-torch.backends.cudnn.benchmark = True
-global_step = 0
-use_cuda = torch.cuda.is_available()
-print("use_cuda, ", use_cuda)
-
-numba_logger = logging.getLogger('numba')
-numba_logger.setLevel(logging.WARNING)
-
-
-def main():
-    """Assume Single Node Multi GPUs Training Only"""
-
-    hps = utils.get_hparams()
-    os.environ['MASTER_ADDR'] = 'localhost'
-    os.environ['MASTER_PORT'] = str(hps.train.port)
-
-    if (torch.cuda.is_available()):
-        n_gpus = torch.cuda.device_count()
-        mp.spawn(run, nprocs=n_gpus, args=(n_gpus, hps,))
-    else:
-        cpurun(0, 1, hps)
-
-
-def run(rank, n_gpus, hps):
-    global global_step
-    if rank == 0:
-        logger = utils.get_logger(hps.model_dir)
-        logger.info(hps.train)
-        logger.info(hps.data)
-        logger.info(hps.model)
-        utils.check_git_hash(hps.model_dir)
-        writer = SummaryWriter(log_dir=hps.model_dir)
-        writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval"))
-
-    dist.init_process_group(backend='nccl', init_method='env://', world_size=n_gpus, rank=rank)
-    torch.manual_seed(hps.train.seed)
-    torch.cuda.set_device(rank)
-    dataset_constructor = DatasetConstructor(hps, num_replicas=n_gpus, rank=rank)
-
-    train_loader = dataset_constructor.get_train_loader()
-    if rank == 0:
-        valid_loader = dataset_constructor.get_valid_loader()
-
-    net_g = SynthesizerTrn(hps).cuda(rank)
-    net_d = Discriminator(hps, hps.model.use_spectral_norm).cuda(rank)
-
-    optim_g = torch.optim.AdamW(
-        net_g.parameters(),
-        hps.train.learning_rate,
-        betas=hps.train.betas,
-        eps=hps.train.eps)
-    optim_d = torch.optim.AdamW(
-        net_d.parameters(),
-        hps.train.learning_rate,
-        betas=hps.train.betas,
-        eps=hps.train.eps)
-    net_g = DDP(net_g, device_ids=[rank], find_unused_parameters=True)
-    net_d = DDP(net_d, device_ids=[rank], find_unused_parameters=True)
-    skip_optimizer = True
-    try:
-        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g,
-                                                   optim_g, skip_optimizer)
-        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d,
-                                                   optim_d, skip_optimizer)
-        global_step = (epoch_str - 1) * len(train_loader)
-    except:
-        print("load old checkpoint failed...")
-        epoch_str = 1
-        global_step = 0
-    if skip_optimizer:
-        epoch_str = 1
-        global_step = 0
-
-    scheduler_g = torch.optim.lr_scheduler.ExponentialLR(optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
-    scheduler_d = torch.optim.lr_scheduler.ExponentialLR(optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
-
-    for epoch in range(epoch_str, hps.train.epochs + 1):
-        if rank == 0:
-            train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d],
-                               [train_loader, valid_loader], logger, [writer, writer_eval])
-        else:
-            train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d],
-                               [train_loader, None], None, None)
-        scheduler_g.step()
-        scheduler_d.step()
-
-
-def cpurun(rank, n_gpus, hps):
-    global global_step
-    if rank == 0:
-        logger = utils.get_logger(hps.model_dir)
-        logger.info(hps.train)
-        logger.info(hps.data)
-        logger.info(hps.model)
-        utils.check_git_hash(hps.model_dir)
-        writer = SummaryWriter(log_dir=hps.model_dir)
-        writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval"))
-    torch.manual_seed(hps.train.seed)
-    dataset_constructor = DatasetConstructor(hps, num_replicas=n_gpus, rank=rank)
-
-    train_loader = dataset_constructor.get_train_loader()
-    if rank == 0:
-        valid_loader = dataset_constructor.get_valid_loader()
-
-    net_g = SynthesizerTrn(hps)
-    net_d = Discriminator(hps, hps.model.use_spectral_norm)
-
-    optim_g = torch.optim.AdamW(
-        net_g.parameters(),
-        hps.train.learning_rate,
-        betas=hps.train.betas,
-        eps=hps.train.eps)
-    optim_d = torch.optim.AdamW(
-        net_d.parameters(),
-        hps.train.learning_rate,
-        betas=hps.train.betas,
-        eps=hps.train.eps)
-    skip_optimizer = True
-    try:
-        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g,
-                                                   optim_g, skip_optimizer)
-        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d,
-                                                   optim_d, skip_optimizer)
-        global_step = (epoch_str - 1) * len(train_loader)
-    except:
-        print("load old checkpoint failed...")
-        epoch_str = 1
-        global_step = 0
-    if skip_optimizer:
-        epoch_str = 1
-        global_step = 0
-    scheduler_g = torch.optim.lr_scheduler.ExponentialLR(optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
-    scheduler_d = torch.optim.lr_scheduler.ExponentialLR(optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
-
-    for epoch in range(epoch_str, hps.train.epochs + 1):
-        train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d],
-                           [train_loader, valid_loader], logger, [writer, writer_eval])
-
-        scheduler_g.step()
-        scheduler_d.step()
-
-
-def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, loaders, logger, writers):
-    net_g, net_d = nets
-    optim_g, optim_d = optims
-    scheduler_g, scheduler_d = schedulers
-    train_loader, eval_loader = loaders
-    if writers is not None:
-        writer, writer_eval = writers
-
-    train_loader.sampler.set_epoch(epoch)
-    global global_step
-
-    net_g.train()
-    net_d.train()
-    for batch_idx, data_dict in enumerate(train_loader):
-
-        c = data_dict["c"]
-        mel = data_dict["mel"]
-        f0 = data_dict["f0"]
-        uv = data_dict["uv"]
-        wav = data_dict["wav"]
-        spkid = data_dict["spkid"]
-
-        c_lengths = data_dict["c_lengths"]
-        mel_lengths = data_dict["mel_lengths"]
-        wav_lengths = data_dict["wav_lengths"]
-        f0_lengths = data_dict["f0_lengths"]
-
-        # data
-        if (use_cuda):
-            c, c_lengths = c.cuda(rank, non_blocking=True), c_lengths.cuda(rank, non_blocking=True)
-            mel, mel_lengths = mel.cuda(rank, non_blocking=True), mel_lengths.cuda(rank, non_blocking=True)
-            wav, wav_lengths = wav.cuda(rank, non_blocking=True), wav_lengths.cuda(rank, non_blocking=True)
-            f0, f0_lengths = f0.cuda(rank, non_blocking=True), f0_lengths.cuda(rank, non_blocking=True)
-            spkid = spkid.cuda(rank, non_blocking=True)
-            uv = uv.cuda(rank, non_blocking=True)
-
-        # forward
-        y_hat, ids_slice, LF0, y_ddsp, kl_div, predict_mel, mask, \
-                pred_lf0, loss_f0, norm_f0 = net_g(c, c_lengths, f0,uv, mel, mel_lengths, spk_id=spkid)
-        y_ddsp = y_ddsp.unsqueeze(1)
-
-        # Discriminator
-        y = commons.slice_segments(wav, ids_slice * hps.data.hop_length, hps.train.segment_size)  # slice
-        y_ddsp_mel = mel_spectrogram_torch(
-            y_ddsp.squeeze(1),
-            hps.data.n_fft,
-            hps.data.acoustic_dim,
-            hps.data.sampling_rate,
-            hps.data.hop_length,
-            hps.data.win_size,
-            hps.data.fmin,
-            hps.data.fmax
-        )
-
-        y_logspec = torch.log(spectrogram_torch(
-            y.squeeze(1),
-            hps.data.n_fft,
-            hps.data.sampling_rate,
-            hps.data.hop_length,
-            hps.data.win_size
-        ) + 1e-7)
-
-        y_ddsp_logspec = torch.log(spectrogram_torch(
-            y_ddsp.squeeze(1),
-            hps.data.n_fft,
-            hps.data.sampling_rate,
-            hps.data.hop_length,
-            hps.data.win_size
-        ) + 1e-7)
-
-        y_mel = mel_spectrogram_torch(
-            y.squeeze(1),
-            hps.data.n_fft,
-            hps.data.acoustic_dim,
-            hps.data.sampling_rate,
-            hps.data.hop_length,
-            hps.data.win_size,
-            hps.data.fmin,
-            hps.data.fmax
-        )
-        y_hat_mel = mel_spectrogram_torch(
-            y_hat.squeeze(1),
-            hps.data.n_fft,
-            hps.data.acoustic_dim,
-            hps.data.sampling_rate,
-            hps.data.hop_length,
-            hps.data.win_size,
-            hps.data.fmin,
-            hps.data.fmax
-        )
-
-        y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach())
-        loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g)
-        loss_disc_all = loss_disc
-
-        optim_d.zero_grad()
-        loss_disc_all.backward()
-        grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None)
-        optim_d.step()
-
-        # loss
-        y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y, y_hat)
-
-        loss_mel = F.l1_loss(y_mel, y_hat_mel) * 45
-        loss_mel_dsp = F.l1_loss(y_mel, y_ddsp_mel) * 45
-        loss_spec_dsp = F.l1_loss(y_logspec, y_ddsp_logspec) * 45
-
-        loss_mel_am = F.mse_loss(mel * mask, predict_mel * mask)  # * 10
-
-        loss_fm = feature_loss(fmap_r, fmap_g)
-        loss_gen, losses_gen = generator_loss(y_d_hat_g)
-
-        loss_fm = loss_fm / 2
-        loss_gen = loss_gen / 2
-        loss_gen_all = loss_gen + loss_fm + loss_mel + loss_mel_dsp + kl_div + loss_mel_am + loss_spec_dsp +\
-                       loss_f0
-
-        loss_gen_all = loss_gen_all / hps.train.accumulation_steps
-
-        loss_gen_all.backward()
-        if ((global_step + 1) % hps.train.accumulation_steps == 0):
-            grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None)
-            optim_g.step()
-            optim_g.zero_grad()
-
-        if rank == 0:
-            if (global_step + 1) % (hps.train.accumulation_steps * 10) == 0:
-                print(["step&time&loss", global_step, time.asctime(time.localtime(time.time())), loss_gen_all])
-
-            if global_step % hps.train.log_interval == 0:
-                lr = optim_g.param_groups[0]['lr']
-                losses = [loss_gen_all, loss_mel]
-                logger.info('Train Epoch: {} [{:.0f}%]'.format(
-                    epoch,
-                    100. * batch_idx / len(train_loader)))
-                logger.info([x.item() for x in losses] + [global_step, lr])
-
-                scalar_dict = {"loss/total": loss_gen_all,
-                               "loss/mel": loss_mel,
-                               "loss/adv": loss_gen,
-                               "loss/fm": loss_fm,
-                               "loss/mel_ddsp": loss_mel_dsp,
-                               "loss/spec_ddsp": loss_spec_dsp,
-                               "loss/mel_am": loss_mel_am,
-                               "loss/kl_div": kl_div,
-                               "loss/lf0": loss_f0,
-                               "learning_rate": lr}
-                image_dict = {
-                    "train/lf0": utils.plot_data_to_numpy(LF0[0,0, :].cpu().numpy(), pred_lf0[0,0,  :].detach().cpu().numpy()),
-                    "train/norm_lf0": utils.plot_data_to_numpy(LF0[0,0, :].cpu().numpy(), norm_f0[0,0,  :].detach().cpu().numpy()),
-                }
-                utils.summarize(
-                    writer=writer,
-                    global_step=global_step,
-                    scalars=scalar_dict,
-                    images=image_dict)
-
-            if global_step % hps.train.eval_interval == 0:
-                # logger.info(['All training params(G): ', utils.count_parameters(net_g), ' M'])
-                # print('Sub training params(G): ', \
-                #      'text_encoder: ', utils.count_parameters(net_g.module.text_encoder), ' M, ', \
-                #      'decoder: ', utils.count_parameters(net_g.module.decoder), ' M, ', \
-                #      'mel_decoder: ', utils.count_parameters(net_g.module.mel_decoder), ' M, ', \
-                #      'dec: ', utils.count_parameters(net_g.module.dec), ' M, ', \
-                #      'dec_harm: ', utils.count_parameters(net_g.module.dec_harm), ' M, ', \
-                #      'dec_noise: ', utils.count_parameters(net_g.module.dec_noise), ' M, ', \
-                #      'posterior: ', utils.count_parameters(net_g.module.posterior_encoder), ' M, ', \
-                #     )
-
-                evaluate(hps, net_g, eval_loader, writer_eval)
-                utils.save_checkpoint(net_g, optim_g, hps.train.learning_rate, epoch,
-                                      os.path.join(hps.model_dir, "G_{}.pth".format(global_step)))
-                utils.save_checkpoint(net_d, optim_d, hps.train.learning_rate, epoch,
-                                      os.path.join(hps.model_dir, "D_{}.pth".format(global_step)))
-                keep_ckpts = getattr(hps.train, 'keep_ckpts', 0)
-                if keep_ckpts > 0:
-                    utils.clean_checkpoints(path_to_models=hps.model_dir, n_ckpts_to_keep=keep_ckpts, sort_by_time=True)
-
-                net_g.train()
-        global_step += 1
-
-    if rank == 0:
-        logger.info('====> Epoch: {}'.format(epoch))
-
-
-def evaluate(hps, generator, eval_loader, writer_eval):
-    generator.eval()
-    image_dict = {}
-    audio_dict = {}
-    with torch.no_grad():
-        for batch_idx, data_dict in enumerate(eval_loader):
-            if batch_idx == 8:
-                break
-            c = data_dict["c"]
-            mel = data_dict["mel"]
-            f0 = data_dict["f0"]
-            uv = data_dict["uv"]
-            wav = data_dict["wav"]
-            spkid = data_dict["spkid"]
-
-            wav_lengths = data_dict["wav_lengths"]
-
-            # data
-            if (use_cuda):
-                c = c.cuda(0)
-                wav = wav.cuda(0)
-                mel = mel.cuda(0)
-                f0 = f0.cuda(0)
-                uv = uv.cuda(0)
-                spkid = spkid.cuda(0)
-            # remove else
-            c = c[:1]
-            wav = wav[:1]
-            mel = mel[:1]
-            f0 = f0[:1]
-            spkid = spkid[:1]
-            if use_cuda:
-                y_hat, y_harm, y_noise, _ = generator.module.infer(c, f0=f0,uv=uv, g=spkid)
-            else:
-                y_hat, y_harm, y_noise, _ = generator.infer(c, f0=f0,uv=uv, g=spkid)
-
-            y_hat_mel = mel_spectrogram_torch(
-                y_hat.squeeze(1),
-                hps.data.n_fft,
-                hps.data.acoustic_dim,
-                hps.data.sampling_rate,
-                hps.data.hop_length,
-                hps.data.win_size,
-                hps.data.fmin,
-                hps.data.fmax
-            )
-            image_dict.update({
-                f"gen/mel_{batch_idx}": utils.plot_spectrogram_to_numpy(y_hat_mel[0].cpu().numpy()),
-            })
-            audio_dict.update( {
-                f"gen/audio_{batch_idx}": y_hat[0, :, :],
-                f"gen/harm": y_harm[0, :, :],
-                "gen/noise": y_noise[0, :, :]
-            })
-            # if global_step == 0:
-            image_dict.update({f"gt/mel_{batch_idx}": utils.plot_spectrogram_to_numpy(mel[0].cpu().numpy())})
-            audio_dict.update({f"gt/audio_{batch_idx}": wav[0, :, :wav_lengths[0]]})
-
-    utils.summarize(
-        writer=writer_eval,
-        global_step=global_step,
-        images=image_dict,
-        audios=audio_dict,
-        audio_sampling_rate=hps.data.sampling_rate
-    )
-    generator.train()
-
-
-if __name__ == "__main__":
-    main()

utils.py

@@ -1,517 +0,0 @@
-import os
-import glob
-import re
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import random
-
-import librosa
-import numpy as np
-from scipy.io.wavfile import read
-import torch
-from torch.nn import functional as F
-from modules.commons import sequence_mask
-from hubert import hubert_model
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
-logger = logging
-
-f0_bin = 256
-f0_max = 1100.0
-f0_min = 50.0
-f0_mel_min = 1127 * np.log(1 + f0_min / 700)
-f0_mel_max = 1127 * np.log(1 + f0_max / 700)
-
-
-# def normalize_f0(f0, random_scale=True):
-#     f0_norm = f0.clone()  # create a copy of the input Tensor
-#     batch_size, _, frame_length = f0_norm.shape
-#     for i in range(batch_size):
-#         means = torch.mean(f0_norm[i, 0, :])
-#         if random_scale:
-#             factor = random.uniform(0.8, 1.2)
-#         else:
-#             factor = 1
-#         f0_norm[i, 0, :] = (f0_norm[i, 0, :] - means) * factor
-#     return f0_norm
-# def normalize_f0(f0, random_scale=True):
-#     means = torch.mean(f0[:, 0, :], dim=1, keepdim=True)
-#     if random_scale:
-#         factor = torch.Tensor(f0.shape[0],1).uniform_(0.8, 1.2).to(f0.device)
-#     else:
-#         factor = torch.ones(f0.shape[0], 1, 1).to(f0.device)
-#     f0_norm = (f0 - means.unsqueeze(-1)) * factor.unsqueeze(-1)
-#     return f0_norm
-def normalize_f0(f0, x_mask, uv, random_scale=True):
-    # calculate means based on x_mask
-    uv_sum = torch.sum(uv, dim=1, keepdim=True)
-    uv_sum[uv_sum == 0] = 9999
-    means = torch.sum(f0[:, 0, :] * uv, dim=1, keepdim=True) / uv_sum
-
-    if random_scale:
-        factor = torch.Tensor(f0.shape[0], 1).uniform_(0.8, 1.2).to(f0.device)
-    else:
-        factor = torch.ones(f0.shape[0], 1).to(f0.device)
-    # normalize f0 based on means and factor
-    f0_norm = (f0 - means.unsqueeze(-1)) * factor.unsqueeze(-1)
-    if torch.isnan(f0_norm).any():
-        exit(0)
-    return f0_norm * x_mask
-
-
-def plot_data_to_numpy(x, y):
-    global MATPLOTLIB_FLAG
-    if not MATPLOTLIB_FLAG:
-        import matplotlib
-        matplotlib.use("Agg")
-        MATPLOTLIB_FLAG = True
-        mpl_logger = logging.getLogger('matplotlib')
-        mpl_logger.setLevel(logging.WARNING)
-    import matplotlib.pylab as plt
-    import numpy as np
-
-    fig, ax = plt.subplots(figsize=(10, 2))
-    plt.plot(x)
-    plt.plot(y)
-    plt.tight_layout()
-
-    fig.canvas.draw()
-    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-    plt.close()
-    return data
-
-
-
-def interpolate_f0(f0):
-    '''
-    对F0进行插值处理
-    '''
-
-    data = np.reshape(f0, (f0.size, 1))
-
-    vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
-    vuv_vector[data > 0.0] = 1.0
-    vuv_vector[data <= 0.0] = 0.0
-
-    ip_data = data
-
-    frame_number = data.size
-    last_value = 0.0
-    for i in range(frame_number):
-        if data[i] <= 0.0:
-            j = i + 1
-            for j in range(i + 1, frame_number):
-                if data[j] > 0.0:
-                    break
-            if j < frame_number - 1:
-                if last_value > 0.0:
-                    step = (data[j] - data[i - 1]) / float(j - i)
-                    for k in range(i, j):
-                        ip_data[k] = data[i - 1] + step * (k - i + 1)
-                else:
-                    for k in range(i, j):
-                        ip_data[k] = data[j]
-            else:
-                for k in range(i, frame_number):
-                    ip_data[k] = last_value
-        else:
-            ip_data[i] = data[i]
-            last_value = data[i]
-
-    return ip_data[:,0], vuv_vector[:,0]
-
-
-def compute_f0_parselmouth(wav_numpy, p_len=None, sampling_rate=44100, hop_length=512):
-    import parselmouth
-    x = wav_numpy
-    if p_len is None:
-        p_len = x.shape[0]//hop_length
-    else:
-        assert abs(p_len-x.shape[0]//hop_length) < 4, "pad length error"
-    time_step = hop_length / sampling_rate * 1000
-    f0_min = 50
-    f0_max = 1100
-    f0 = parselmouth.Sound(x, sampling_rate).to_pitch_ac(
-        time_step=time_step / 1000, voicing_threshold=0.6,
-        pitch_floor=f0_min, pitch_ceiling=f0_max).selected_array['frequency']
-
-    pad_size=(p_len - len(f0) + 1) // 2
-    if(pad_size>0 or p_len - len(f0) - pad_size>0):
-        f0 = np.pad(f0,[[pad_size,p_len - len(f0) - pad_size]], mode='constant')
-    return f0
-
-def resize_f0(x, target_len):
-    source = np.array(x)
-    source[source<0.001] = np.nan
-    target = np.interp(np.arange(0, len(source)*target_len, len(source))/ target_len, np.arange(0, len(source)), source)
-    res = np.nan_to_num(target)
-    return res
-
-def compute_f0_dio(wav_numpy, p_len=None, sampling_rate=44100, hop_length=512):
-    import pyworld
-    if p_len is None:
-        p_len = wav_numpy.shape[0]//hop_length
-    f0, t = pyworld.dio(
-        wav_numpy.astype(np.double),
-        fs=sampling_rate,
-        f0_ceil=800,
-        frame_period=1000 * hop_length / sampling_rate,
-    )
-    f0 = pyworld.stonemask(wav_numpy.astype(np.double), f0, t, sampling_rate)
-    for index, pitch in enumerate(f0):
-        f0[index] = round(pitch, 1)
-    return resize_f0(f0, p_len)
-
-def f0_to_coarse(f0):
-  is_torch = isinstance(f0, torch.Tensor)
-  f0_mel = 1127 * (1 + f0 / 700).log() if is_torch else 1127 * np.log(1 + f0 / 700)
-  f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * (f0_bin - 2) / (f0_mel_max - f0_mel_min) + 1
-
-  f0_mel[f0_mel <= 1] = 1
-  f0_mel[f0_mel > f0_bin - 1] = f0_bin - 1
-  f0_coarse = (f0_mel + 0.5).long() if is_torch else np.rint(f0_mel).astype(np.int)
-  assert f0_coarse.max() <= 255 and f0_coarse.min() >= 1, (f0_coarse.max(), f0_coarse.min())
-  return f0_coarse
-
-
-def get_hubert_model():
-  vec_path = "hubert/checkpoint_best_legacy_500.pt"
-  print("load model(s) from {}".format(vec_path))
-  from fairseq import checkpoint_utils
-  models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
-    [vec_path],
-    suffix="",
-  )
-  model = models[0]
-  model.eval()
-  return model
-
-def get_hubert_content(hmodel, wav_16k_tensor):
-  feats = wav_16k_tensor
-  if feats.dim() == 2:  # double channels
-    feats = feats.mean(-1)
-  assert feats.dim() == 1, feats.dim()
-  feats = feats.view(1, -1)
-  padding_mask = torch.BoolTensor(feats.shape).fill_(False)
-  inputs = {
-    "source": feats.to(wav_16k_tensor.device),
-    "padding_mask": padding_mask.to(wav_16k_tensor.device),
-    "output_layer": 9,  # layer 9
-  }
-  with torch.no_grad():
-    logits = hmodel.extract_features(**inputs)
-    feats = hmodel.final_proj(logits[0])
-  return feats.transpose(1, 2)
-
-
-def get_content(cmodel, y):
-    with torch.no_grad():
-        c = cmodel.extract_features(y.squeeze(1))[0]
-    c = c.transpose(1, 2)
-    return c
-
-
-
-def load_checkpoint(checkpoint_path, model, optimizer=None, skip_optimizer=False):
-    assert os.path.isfile(checkpoint_path)
-    checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
-    iteration = checkpoint_dict['iteration']
-    learning_rate = checkpoint_dict['learning_rate']
-    if optimizer is not None and not skip_optimizer and checkpoint_dict['optimizer'] is not None:
-        optimizer.load_state_dict(checkpoint_dict['optimizer'])
-    saved_state_dict = checkpoint_dict['model']
-    if hasattr(model, 'module'):
-        state_dict = model.module.state_dict()
-    else:
-        state_dict = model.state_dict()
-    new_state_dict = {}
-    for k, v in state_dict.items():
-        try:
-            # assert "dec" in k or "disc" in k
-            # print("load", k)
-            new_state_dict[k] = saved_state_dict[k]
-            assert saved_state_dict[k].shape == v.shape, (saved_state_dict[k].shape, v.shape)
-        except:
-            print("error, %s is not in the checkpoint" % k)
-            logger.info("%s is not in the checkpoint" % k)
-            new_state_dict[k] = v
-    if hasattr(model, 'module'):
-        model.module.load_state_dict(new_state_dict)
-    else:
-        model.load_state_dict(new_state_dict)
-    print("load ")
-    logger.info("Loaded checkpoint '{}' (iteration {})".format(
-        checkpoint_path, iteration))
-    return model, optimizer, learning_rate, iteration
-
-
-def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path):
-  logger.info("Saving model and optimizer state at iteration {} to {}".format(
-    iteration, checkpoint_path))
-  if hasattr(model, 'module'):
-    state_dict = model.module.state_dict()
-  else:
-    state_dict = model.state_dict()
-  torch.save({'model': state_dict,
-              'iteration': iteration,
-              'optimizer': optimizer.state_dict(),
-              'learning_rate': learning_rate}, checkpoint_path)
-
-def clean_checkpoints(path_to_models='logs/44k/', n_ckpts_to_keep=2, sort_by_time=True):
-  """Freeing up space by deleting saved ckpts
-
-  Arguments:
-  path_to_models    --  Path to the model directory
-  n_ckpts_to_keep   --  Number of ckpts to keep, excluding G_0.pth and D_0.pth
-  sort_by_time      --  True -> chronologically delete ckpts
-                        False -> lexicographically delete ckpts
-  """
-  ckpts_files = [f for f in os.listdir(path_to_models) if os.path.isfile(os.path.join(path_to_models, f))]
-  name_key = (lambda _f: int(re.compile('._(\d+)\.pth').match(_f).group(1)))
-  time_key = (lambda _f: os.path.getmtime(os.path.join(path_to_models, _f)))
-  sort_key = time_key if sort_by_time else name_key
-  x_sorted = lambda _x: sorted([f for f in ckpts_files if f.startswith(_x) and not f.endswith('_0.pth')], key=sort_key)
-  to_del = [os.path.join(path_to_models, fn) for fn in
-            (x_sorted('G')[:-n_ckpts_to_keep] + x_sorted('D')[:-n_ckpts_to_keep])]
-  del_info = lambda fn: logger.info(f".. Free up space by deleting ckpt {fn}")
-  del_routine = lambda x: [os.remove(x), del_info(x)]
-  rs = [del_routine(fn) for fn in to_del]
-
-def summarize(writer, global_step, scalars={}, histograms={}, images={}, audios={}, audio_sampling_rate=22050):
-  for k, v in scalars.items():
-    writer.add_scalar(k, v, global_step)
-  for k, v in histograms.items():
-    writer.add_histogram(k, v, global_step)
-  for k, v in images.items():
-    writer.add_image(k, v, global_step, dataformats='HWC')
-  for k, v in audios.items():
-    writer.add_audio(k, v, global_step, audio_sampling_rate)
-
-
-def latest_checkpoint_path(dir_path, regex="G_*.pth"):
-  f_list = glob.glob(os.path.join(dir_path, regex))
-  f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
-  x = f_list[-1]
-  print(x)
-  return x
-
-
-def plot_spectrogram_to_numpy(spectrogram):
-  global MATPLOTLIB_FLAG
-  if not MATPLOTLIB_FLAG:
-    import matplotlib
-    matplotlib.use("Agg")
-    MATPLOTLIB_FLAG = True
-    mpl_logger = logging.getLogger('matplotlib')
-    mpl_logger.setLevel(logging.WARNING)
-  import matplotlib.pylab as plt
-  import numpy as np
-
-  fig, ax = plt.subplots(figsize=(10,2))
-  im = ax.imshow(spectrogram, aspect="auto", origin="lower",
-                  interpolation='none')
-  plt.colorbar(im, ax=ax)
-  plt.xlabel("Frames")
-  plt.ylabel("Channels")
-  plt.tight_layout()
-
-  fig.canvas.draw()
-  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-  plt.close()
-  return data
-
-
-def plot_alignment_to_numpy(alignment, info=None):
-  global MATPLOTLIB_FLAG
-  if not MATPLOTLIB_FLAG:
-    import matplotlib
-    matplotlib.use("Agg")
-    MATPLOTLIB_FLAG = True
-    mpl_logger = logging.getLogger('matplotlib')
-    mpl_logger.setLevel(logging.WARNING)
-  import matplotlib.pylab as plt
-  import numpy as np
-
-  fig, ax = plt.subplots(figsize=(6, 4))
-  im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
-                  interpolation='none')
-  fig.colorbar(im, ax=ax)
-  xlabel = 'Decoder timestep'
-  if info is not None:
-      xlabel += '\n\n' + info
-  plt.xlabel(xlabel)
-  plt.ylabel('Encoder timestep')
-  plt.tight_layout()
-
-  fig.canvas.draw()
-  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-  plt.close()
-  return data
-
-
-def load_wav_to_torch(full_path):
-  sampling_rate, data = read(full_path)
-  return torch.FloatTensor(data.astype(np.float32)), sampling_rate
-
-
-def load_filepaths_and_text(filename, split="|"):
-  with open(filename, encoding='utf-8') as f:
-    filepaths_and_text = [line.strip().split(split) for line in f]
-  return filepaths_and_text
-
-
-def get_hparams(init=True):
-  parser = argparse.ArgumentParser()
-  parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
-                      help='JSON file for configuration')
-  parser.add_argument('-m', '--model', type=str, required=True,
-                      help='Model name')
-
-  args = parser.parse_args()
-  model_dir = os.path.join("./logs", args.model)
-
-  if not os.path.exists(model_dir):
-    os.makedirs(model_dir)
-
-  config_path = args.config
-  config_save_path = os.path.join(model_dir, "config.json")
-  if init:
-    with open(config_path, "r") as f:
-      data = f.read()
-    with open(config_save_path, "w") as f:
-      f.write(data)
-  else:
-    with open(config_save_path, "r") as f:
-      data = f.read()
-  config = json.loads(data)
-
-  hparams = HParams(**config)
-  hparams.model_dir = model_dir
-  return hparams
-
-
-def get_hparams_from_dir(model_dir):
-  config_save_path = os.path.join(model_dir, "config.json")
-  with open(config_save_path, "r") as f:
-    data = f.read()
-  config = json.loads(data)
-
-  hparams =HParams(**config)
-  hparams.model_dir = model_dir
-  return hparams
-
-
-def get_hparams_from_file(config_path):
-  with open(config_path, "r") as f:
-    data = f.read()
-  config = json.loads(data)
-
-  hparams =HParams(**config)
-  return hparams
-
-
-def check_git_hash(model_dir):
-  source_dir = os.path.dirname(os.path.realpath(__file__))
-  if not os.path.exists(os.path.join(source_dir, ".git")):
-    logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
-      source_dir
-    ))
-    return
-
-  cur_hash = subprocess.getoutput("git rev-parse HEAD")
-
-  path = os.path.join(model_dir, "githash")
-  if os.path.exists(path):
-    saved_hash = open(path).read()
-    if saved_hash != cur_hash:
-      logger.warn("git hash values are different. {}(saved) != {}(current)".format(
-        saved_hash[:8], cur_hash[:8]))
-  else:
-    open(path, "w").write(cur_hash)
-
-
-def get_logger(model_dir, filename="train.log"):
-  global logger
-  logger = logging.getLogger(os.path.basename(model_dir))
-  logger.setLevel(logging.DEBUG)
-
-  formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
-  if not os.path.exists(model_dir):
-    os.makedirs(model_dir)
-  h = logging.FileHandler(os.path.join(model_dir, filename))
-  h.setLevel(logging.DEBUG)
-  h.setFormatter(formatter)
-  logger.addHandler(h)
-  return logger
-
-
-def repeat_expand_2d(content, target_len):
-    # content : [h, t]
-
-    src_len = content.shape[-1]
-    target = torch.zeros([content.shape[0], target_len], dtype=torch.float).to(content.device)
-    temp = torch.arange(src_len+1) * target_len / src_len
-    current_pos = 0
-    for i in range(target_len):
-        if i < temp[current_pos+1]:
-            target[:, i] = content[:, current_pos]
-        else:
-            current_pos += 1
-            target[:, i] = content[:, current_pos]
-
-    return target
-
-def load_wav(wav_path, raw_sr, target_sr=16000, win_size=800, hop_size=200):
-    audio = librosa.core.load(wav_path, sr=raw_sr)[0]
-    if raw_sr != target_sr:
-        audio = librosa.core.resample(audio,
-                                      raw_sr,
-                                      target_sr,
-                                      res_type='kaiser_best')
-        target_length = (audio.size // hop_size +
-                         win_size // hop_size) * hop_size
-        pad_len = (target_length - audio.size) // 2
-        if audio.size % 2 == 0:
-            audio = np.pad(audio, (pad_len, pad_len), mode='reflect')
-        else:
-            audio = np.pad(audio, (pad_len, pad_len + 1), mode='reflect')
-    return audio
-
-class HParams():
-  def __init__(self, **kwargs):
-    for k, v in kwargs.items():
-      if type(v) == dict:
-        v = HParams(**v)
-      self[k] = v
-
-  def keys(self):
-    return self.__dict__.keys()
-
-  def items(self):
-    return self.__dict__.items()
-
-  def values(self):
-    return self.__dict__.values()
-
-  def __len__(self):
-    return len(self.__dict__)
-
-  def __getitem__(self, key):
-    return getattr(self, key)
-
-  def __setitem__(self, key, value):
-    return setattr(self, key, value)
-
-  def __contains__(self, key):
-    return key in self.__dict__
-
-  def __repr__(self):
-    return self.__dict__.__repr__()
-