initial upload attempt
initial upload attempt
This commit is contained in:
erew123 committed
1 parent
84c19ed5a9
commit
9fd928f6e7
527 files changed
+37359
No files matched your search
@@ -0,0 +1,170 @@
|
||||
import torch
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
version_config_list = [
|
||||
"v1/32000.json",
|
||||
"v1/40000.json",
|
||||
"v1/48000.json",
|
||||
"v2/48000.json",
|
||||
"v2/32000.json",
|
||||
]
|
||||
|
||||
|
||||
def singleton_variable(func):
|
||||
def wrapper(*args, **kwargs):
|
||||
if not wrapper.instance:
|
||||
wrapper.instance = func(*args, **kwargs)
|
||||
return wrapper.instance
|
||||
|
||||
wrapper.instance = None
|
||||
return wrapper
|
||||
|
||||
|
||||
@singleton_variable
|
||||
class Config:
|
||||
def __init__(self):
|
||||
self.device = "cuda:0"
|
||||
self.is_half = True
|
||||
self.use_jit = False
|
||||
self.n_cpu = 0
|
||||
self.gpu_name = None
|
||||
self.json_config = self.load_config_json()
|
||||
self.gpu_mem = None
|
||||
self.instead = ""
|
||||
self.x_pad, self.x_query, self.x_center, self.x_max = self.device_config()
|
||||
|
||||
@staticmethod
|
||||
def load_config_json() -> dict:
|
||||
d = {}
|
||||
base_path = Path(__file__).resolve().parent
|
||||
for config_file in version_config_list:
|
||||
config_path = base_path / config_file
|
||||
with open(config_path, "r") as f:
|
||||
d[config_file] = json.load(f)
|
||||
return d
|
||||
|
||||
@staticmethod
|
||||
def has_mps() -> bool:
|
||||
if not torch.backends.mps.is_available():
|
||||
return False
|
||||
try:
|
||||
torch.zeros(1).to(torch.device("mps"))
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def has_xpu() -> bool:
|
||||
if hasattr(torch, "xpu") and torch.xpu.is_available():
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def use_fp32_config(self):
|
||||
print(
|
||||
f"Using FP32 config instead of FP16 due to GPU compatibility ({self.gpu_name})"
|
||||
)
|
||||
for config_file in version_config_list:
|
||||
config_path = os.path.join(os.getcwd(), "system", "tts_engines", "rvc", "configs", config_file)
|
||||
with open(config_path, "r") as f:
|
||||
config_data = f.read().replace("true", "false")
|
||||
with open(config_path, "w") as f:
|
||||
f.write(config_data)
|
||||
|
||||
preprocess_path = os.path.join(os.getcwd(), "system", "tts_engines", "rvc", "train", "preprocess", "preprocess.py")
|
||||
with open(preprocess_path, "r") as f:
|
||||
preprocess_data = f.read().replace("3.7", "3.0")
|
||||
with open(preprocess_path, "w") as f:
|
||||
f.write(preprocess_data)
|
||||
|
||||
def device_config(self) -> tuple:
|
||||
if torch.cuda.is_available():
|
||||
if self.has_xpu():
|
||||
self.device = self.instead = "xpu:0"
|
||||
self.is_half = True
|
||||
i_device = int(self.device.split(":")[-1])
|
||||
self.gpu_name = torch.cuda.get_device_name(i_device)
|
||||
if (
|
||||
("16" in self.gpu_name and "V100" not in self.gpu_name.upper())
|
||||
or "P40" in self.gpu_name.upper()
|
||||
or "P10" in self.gpu_name.upper()
|
||||
or "1060" in self.gpu_name
|
||||
or "1070" in self.gpu_name
|
||||
or "1080" in self.gpu_name
|
||||
):
|
||||
self.is_half = False
|
||||
self.use_fp32_config()
|
||||
self.gpu_mem = int(
|
||||
torch.cuda.get_device_properties(i_device).total_memory
|
||||
/ 1024
|
||||
/ 1024
|
||||
/ 1024
|
||||
+ 0.4
|
||||
)
|
||||
if self.gpu_mem <= 4:
|
||||
preprocess_path = os.path.join(os.getcwd(), "system", "tts_engines", "rvc", "train", "preprocess", "preprocess.py")
|
||||
with open(preprocess_path, "r") as f:
|
||||
strr = f.read().replace("3.7", "3.0")
|
||||
with open(preprocess_path, "w") as f:
|
||||
f.write(strr)
|
||||
elif self.has_mps():
|
||||
print("No supported Nvidia GPU found")
|
||||
self.device = self.instead = "mps"
|
||||
self.is_half = False
|
||||
self.use_fp32_config()
|
||||
else:
|
||||
print("No supported Nvidia GPU found")
|
||||
self.device = self.instead = "cpu"
|
||||
self.is_half = False
|
||||
self.use_fp32_config()
|
||||
|
||||
if self.n_cpu == 0:
|
||||
self.n_cpu = os.cpu_count()
|
||||
|
||||
if self.is_half:
|
||||
x_pad = 3
|
||||
x_query = 10
|
||||
x_center = 60
|
||||
x_max = 65
|
||||
else:
|
||||
x_pad = 1
|
||||
x_query = 6
|
||||
x_center = 38
|
||||
x_max = 41
|
||||
|
||||
if self.gpu_mem is not None and self.gpu_mem <= 4:
|
||||
x_pad = 1
|
||||
x_query = 5
|
||||
x_center = 30
|
||||
x_max = 32
|
||||
|
||||
return x_pad, x_query, x_center, x_max
|
||||
|
||||
|
||||
def max_vram_gpu(gpu):
|
||||
if torch.cuda.is_available():
|
||||
gpu_properties = torch.cuda.get_device_properties(gpu)
|
||||
total_memory_gb = round(gpu_properties.total_memory / 1024 / 1024 / 1024)
|
||||
return total_memory_gb
|
||||
else:
|
||||
return "0"
|
||||
|
||||
|
||||
def get_gpu_info():
|
||||
ngpu = torch.cuda.device_count()
|
||||
gpu_infos = []
|
||||
if torch.cuda.is_available() or ngpu != 0:
|
||||
for i in range(ngpu):
|
||||
gpu_name = torch.cuda.get_device_name(i)
|
||||
mem = int(
|
||||
torch.cuda.get_device_properties(i).total_memory / 1024 / 1024 / 1024
|
||||
+ 0.4
|
||||
)
|
||||
gpu_infos.append("%s: %s %s GB" % (i, gpu_name, mem))
|
||||
if len(gpu_infos) > 0:
|
||||
gpu_info = "\n".join(gpu_infos)
|
||||
else:
|
||||
gpu_info = "Unfortunately, there is no compatible GPU available to support your training."
|
||||
return gpu_info
|
||||
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"train": {
|
||||
"log_interval": 200,
|
||||
"seed": 1234,
|
||||
"epochs": 20000,
|
||||
"learning_rate": 1e-4,
|
||||
"betas": [0.8, 0.99],
|
||||
"eps": 1e-9,
|
||||
"batch_size": 4,
|
||||
"fp16_run": true,
|
||||
"lr_decay": 0.999875,
|
||||
"segment_size": 12800,
|
||||
"init_lr_ratio": 1,
|
||||
"warmup_epochs": 0,
|
||||
"c_mel": 45,
|
||||
"c_kl": 1.0
|
||||
},
|
||||
"data": {
|
||||
"max_wav_value": 32768.0,
|
||||
"sampling_rate": 32000,
|
||||
"filter_length": 1024,
|
||||
"hop_length": 320,
|
||||
"win_length": 1024,
|
||||
"n_mel_channels": 80,
|
||||
"mel_fmin": 0.0,
|
||||
"mel_fmax": null
|
||||
},
|
||||
"model": {
|
||||
"inter_channels": 192,
|
||||
"hidden_channels": 192,
|
||||
"filter_channels": 768,
|
||||
"n_heads": 2,
|
||||
"n_layers": 6,
|
||||
"kernel_size": 3,
|
||||
"p_dropout": 0,
|
||||
"resblock": "1",
|
||||
"resblock_kernel_sizes": [3,7,11],
|
||||
"resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
|
||||
"upsample_rates": [10,4,2,2,2],
|
||||
"upsample_initial_channel": 512,
|
||||
"upsample_kernel_sizes": [16,16,4,4,4],
|
||||
"use_spectral_norm": false,
|
||||
"gin_channels": 256,
|
||||
"spk_embed_dim": 109
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"train": {
|
||||
"log_interval": 200,
|
||||
"seed": 1234,
|
||||
"epochs": 20000,
|
||||
"learning_rate": 1e-4,
|
||||
"betas": [0.8, 0.99],
|
||||
"eps": 1e-9,
|
||||
"batch_size": 4,
|
||||
"fp16_run": true,
|
||||
"lr_decay": 0.999875,
|
||||
"segment_size": 12800,
|
||||
"init_lr_ratio": 1,
|
||||
"warmup_epochs": 0,
|
||||
"c_mel": 45,
|
||||
"c_kl": 1.0
|
||||
},
|
||||
"data": {
|
||||
"max_wav_value": 32768.0,
|
||||
"sampling_rate": 40000,
|
||||
"filter_length": 2048,
|
||||
"hop_length": 400,
|
||||
"win_length": 2048,
|
||||
"n_mel_channels": 125,
|
||||
"mel_fmin": 0.0,
|
||||
"mel_fmax": null
|
||||
},
|
||||
"model": {
|
||||
"inter_channels": 192,
|
||||
"hidden_channels": 192,
|
||||
"filter_channels": 768,
|
||||
"n_heads": 2,
|
||||
"n_layers": 6,
|
||||
"kernel_size": 3,
|
||||
"p_dropout": 0,
|
||||
"resblock": "1",
|
||||
"resblock_kernel_sizes": [3,7,11],
|
||||
"resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
|
||||
"upsample_rates": [10,10,2,2],
|
||||
"upsample_initial_channel": 512,
|
||||
"upsample_kernel_sizes": [16,16,4,4],
|
||||
"use_spectral_norm": false,
|
||||
"gin_channels": 256,
|
||||
"spk_embed_dim": 109
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"train": {
|
||||
"log_interval": 200,
|
||||
"seed": 1234,
|
||||
"epochs": 20000,
|
||||
"learning_rate": 1e-4,
|
||||
"betas": [0.8, 0.99],
|
||||
"eps": 1e-9,
|
||||
"batch_size": 4,
|
||||
"fp16_run": true,
|
||||
"lr_decay": 0.999875,
|
||||
"segment_size": 11520,
|
||||
"init_lr_ratio": 1,
|
||||
"warmup_epochs": 0,
|
||||
"c_mel": 45,
|
||||
"c_kl": 1.0
|
||||
},
|
||||
"data": {
|
||||
"max_wav_value": 32768.0,
|
||||
"sampling_rate": 48000,
|
||||
"filter_length": 2048,
|
||||
"hop_length": 480,
|
||||
"win_length": 2048,
|
||||
"n_mel_channels": 128,
|
||||
"mel_fmin": 0.0,
|
||||
"mel_fmax": null
|
||||
},
|
||||
"model": {
|
||||
"inter_channels": 192,
|
||||
"hidden_channels": 192,
|
||||
"filter_channels": 768,
|
||||
"n_heads": 2,
|
||||
"n_layers": 6,
|
||||
"kernel_size": 3,
|
||||
"p_dropout": 0,
|
||||
"resblock": "1",
|
||||
"resblock_kernel_sizes": [3,7,11],
|
||||
"resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
|
||||
"upsample_rates": [10,6,2,2,2],
|
||||
"upsample_initial_channel": 512,
|
||||
"upsample_kernel_sizes": [16,16,4,4,4],
|
||||
"use_spectral_norm": false,
|
||||
"gin_channels": 256,
|
||||
"spk_embed_dim": 109
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"train": {
|
||||
"log_interval": 200,
|
||||
"seed": 1234,
|
||||
"epochs": 20000,
|
||||
"learning_rate": 1e-4,
|
||||
"betas": [0.8, 0.99],
|
||||
"eps": 1e-9,
|
||||
"batch_size": 4,
|
||||
"fp16_run": true,
|
||||
"lr_decay": 0.999875,
|
||||
"segment_size": 12800,
|
||||
"init_lr_ratio": 1,
|
||||
"warmup_epochs": 0,
|
||||
"c_mel": 45,
|
||||
"c_kl": 1.0
|
||||
},
|
||||
"data": {
|
||||
"max_wav_value": 32768.0,
|
||||
"sampling_rate": 32000,
|
||||
"filter_length": 1024,
|
||||
"hop_length": 320,
|
||||
"win_length": 1024,
|
||||
"n_mel_channels": 80,
|
||||
"mel_fmin": 0.0,
|
||||
"mel_fmax": null
|
||||
},
|
||||
"model": {
|
||||
"inter_channels": 192,
|
||||
"hidden_channels": 192,
|
||||
"filter_channels": 768,
|
||||
"n_heads": 2,
|
||||
"n_layers": 6,
|
||||
"kernel_size": 3,
|
||||
"p_dropout": 0,
|
||||
"resblock": "1",
|
||||
"resblock_kernel_sizes": [3,7,11],
|
||||
"resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
|
||||
"upsample_rates": [10,8,2,2],
|
||||
"upsample_initial_channel": 512,
|
||||
"upsample_kernel_sizes": [20,16,4,4],
|
||||
"use_spectral_norm": false,
|
||||
"gin_channels": 256,
|
||||
"spk_embed_dim": 109
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"train": {
|
||||
"log_interval": 200,
|
||||
"seed": 1234,
|
||||
"epochs": 20000,
|
||||
"learning_rate": 1e-4,
|
||||
"betas": [0.8, 0.99],
|
||||
"eps": 1e-9,
|
||||
"batch_size": 4,
|
||||
"fp16_run": true,
|
||||
"lr_decay": 0.999875,
|
||||
"segment_size": 17280,
|
||||
"init_lr_ratio": 1,
|
||||
"warmup_epochs": 0,
|
||||
"c_mel": 45,
|
||||
"c_kl": 1.0
|
||||
},
|
||||
"data": {
|
||||
"max_wav_value": 32768.0,
|
||||
"sampling_rate": 48000,
|
||||
"filter_length": 2048,
|
||||
"hop_length": 480,
|
||||
"win_length": 2048,
|
||||
"n_mel_channels": 128,
|
||||
"mel_fmin": 0.0,
|
||||
"mel_fmax": null
|
||||
},
|
||||
"model": {
|
||||
"inter_channels": 192,
|
||||
"hidden_channels": 192,
|
||||
"filter_channels": 768,
|
||||
"n_heads": 2,
|
||||
"n_layers": 6,
|
||||
"kernel_size": 3,
|
||||
"p_dropout": 0,
|
||||
"resblock": "1",
|
||||
"resblock_kernel_sizes": [3,7,11],
|
||||
"resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
|
||||
"upsample_rates": [12,10,2,2],
|
||||
"upsample_initial_channel": 512,
|
||||
"upsample_kernel_sizes": [24,20,4,4],
|
||||
"use_spectral_norm": false,
|
||||
"gin_channels": 256,
|
||||
"spk_embed_dim": 109
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,350 @@
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import torch
|
||||
import logging
|
||||
import faiss
|
||||
import numpy as np
|
||||
import soundfile as sf
|
||||
import librosa
|
||||
|
||||
now_dir = os.getcwd()
|
||||
sys.path.append(now_dir)
|
||||
|
||||
from ..infer.pipeline import VC
|
||||
from ..lib.utils import load_audio
|
||||
from ..lib.tools.split_audio import process_audio, merge_audio
|
||||
from ..lib.infer_pack.models import (
|
||||
SynthesizerTrnMs256NSFsid,
|
||||
SynthesizerTrnMs256NSFsid_nono,
|
||||
SynthesizerTrnMs768NSFsid,
|
||||
SynthesizerTrnMs768NSFsid_nono,
|
||||
)
|
||||
from ..configs.config import Config
|
||||
from ..lib.utils import load_embedding
|
||||
|
||||
logging.getLogger("httpx").setLevel(logging.WARNING)
|
||||
logging.getLogger("httpcore").setLevel(logging.WARNING)
|
||||
|
||||
config = Config()
|
||||
hubert_model = None
|
||||
tgt_sr = None
|
||||
net_g = None
|
||||
vc = None
|
||||
cpt = None
|
||||
version = None
|
||||
n_spk = None
|
||||
debug_rvc = False
|
||||
|
||||
def load_hubert(embedder_model):
|
||||
global hubert_model
|
||||
models, _, _ = load_embedding(embedder_model)
|
||||
hubert_model = models[0]
|
||||
hubert_model = hubert_model.to(config.device)
|
||||
if config.is_half:
|
||||
hubert_model = hubert_model.half()
|
||||
else:
|
||||
hubert_model = hubert_model.float()
|
||||
hubert_model.eval()
|
||||
|
||||
def voice_conversion(
|
||||
sid=0,
|
||||
input_audio_path=None,
|
||||
f0_up_key=None,
|
||||
f0_file=None,
|
||||
f0_method=None,
|
||||
file_index=None,
|
||||
index_rate=None,
|
||||
resample_sr=0,
|
||||
rms_mix_rate=None,
|
||||
protect=None,
|
||||
hop_length=None,
|
||||
output_path=None,
|
||||
split_audio=False,
|
||||
f0autotune=False,
|
||||
filter_radius=None,
|
||||
embedder_model=None,
|
||||
):
|
||||
global tgt_sr, net_g, vc, hubert_model, version
|
||||
|
||||
f0_up_key = int(f0_up_key)
|
||||
try:
|
||||
print(f"Loading audio from {input_audio_path}") if debug_rvc else None
|
||||
audio = load_audio(input_audio_path, 16000)
|
||||
audio_max = np.abs(audio).max() / 0.95
|
||||
|
||||
if audio_max > 1:
|
||||
audio /= audio_max
|
||||
|
||||
if not hubert_model:
|
||||
print(f"Loading hubert model with {embedder_model}") if debug_rvc else None
|
||||
load_hubert(embedder_model)
|
||||
if_f0 = cpt.get("f0", 1)
|
||||
|
||||
file_index = (
|
||||
file_index.strip(" ")
|
||||
.strip('"')
|
||||
.strip("\n")
|
||||
.strip('"')
|
||||
.strip(" ")
|
||||
.replace("trained", "added")
|
||||
)
|
||||
if tgt_sr != resample_sr >= 16000:
|
||||
tgt_sr = resample_sr
|
||||
if split_audio == "True":
|
||||
print("Splitting audio") if debug_rvc else None
|
||||
result, new_dir_path = process_audio(input_audio_path)
|
||||
if result == "Error":
|
||||
return "Error with Split Audio", None
|
||||
dir_path = (
|
||||
new_dir_path.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
|
||||
)
|
||||
if dir_path != "":
|
||||
paths = [
|
||||
os.path.join(root, name)
|
||||
for root, _, files in os.walk(dir_path, topdown=False)
|
||||
for name in files
|
||||
if name.endswith(".wav") and root == dir_path
|
||||
]
|
||||
try:
|
||||
for path in paths:
|
||||
voice_conversion(
|
||||
sid,
|
||||
path,
|
||||
f0_up_key,
|
||||
None,
|
||||
f0_method,
|
||||
file_index,
|
||||
index_rate,
|
||||
resample_sr,
|
||||
rms_mix_rate,
|
||||
protect,
|
||||
hop_length,
|
||||
path,
|
||||
False,
|
||||
f0autotune,
|
||||
embedder_model,
|
||||
)
|
||||
except Exception as error:
|
||||
print(f"Error processing segmented audio: {error}")
|
||||
return f"Error {error}"
|
||||
print("Finished processing segmented audio, now merging audio...") if debug_rvc else None
|
||||
merge_timestamps_file = os.path.join(
|
||||
os.path.dirname(new_dir_path),
|
||||
f"{os.path.basename(input_audio_path).split('.')[0]}_timestamps.txt",
|
||||
)
|
||||
tgt_sr, audio_opt = merge_audio(merge_timestamps_file)
|
||||
os.remove(merge_timestamps_file)
|
||||
|
||||
else:
|
||||
print("Processing audio with VC pipeline") if debug_rvc else None
|
||||
audio_opt = vc.pipeline(
|
||||
hubert_model,
|
||||
net_g,
|
||||
sid,
|
||||
audio,
|
||||
input_audio_path,
|
||||
f0_up_key,
|
||||
f0_method,
|
||||
file_index,
|
||||
index_rate,
|
||||
if_f0,
|
||||
filter_radius,
|
||||
tgt_sr,
|
||||
resample_sr,
|
||||
rms_mix_rate,
|
||||
version,
|
||||
protect,
|
||||
hop_length,
|
||||
f0autotune,
|
||||
f0_file=f0_file,
|
||||
)
|
||||
|
||||
# Resample the audio to the target sample rate before saving
|
||||
if tgt_sr != resample_sr and resample_sr >= 16000:
|
||||
print(f"Resampling audio from {tgt_sr} to {resample_sr}") if debug_rvc else None
|
||||
audio_opt = librosa.resample(audio_opt, tgt_sr, resample_sr)
|
||||
tgt_sr = resample_sr
|
||||
|
||||
if output_path is not None:
|
||||
print(f"Saving file to {output_path}") if debug_rvc else None
|
||||
sf.write(output_path, audio_opt, tgt_sr, format="WAV")
|
||||
print(f"File saved to {output_path}") if debug_rvc else None
|
||||
|
||||
return (tgt_sr, audio_opt)
|
||||
|
||||
except Exception as error:
|
||||
print(f"Error during voice conversion: {error}")
|
||||
return None, None
|
||||
|
||||
|
||||
|
||||
def get_vc(weight_root, sid, file_index=None, training_data_size=10000, debug_rvc=False):
|
||||
global n_spk, tgt_sr, net_g, vc, cpt, version
|
||||
branding="AllTalk "
|
||||
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Entering get_vc function")
|
||||
print(f"[{branding}Debug] weight_root: {weight_root}")
|
||||
print(f"[{branding}Debug] sid: {sid}")
|
||||
print(f"[{branding}Debug] file_index: {file_index}")
|
||||
print(f"[{branding}Debug] training_data_size: {training_data_size}")
|
||||
|
||||
if sid == "" or sid == []:
|
||||
global hubert_model
|
||||
if hubert_model is not None:
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Cleaning empty cache")
|
||||
del net_g, n_spk, vc, hubert_model, tgt_sr
|
||||
hubert_model = net_g = n_spk = vc = hubert_model = tgt_sr = None
|
||||
if torch.cuda.is_available():
|
||||
torch.cuda.empty_cache()
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] sid is empty or an empty list")
|
||||
|
||||
if_f0 = cpt.get("f0", 1)
|
||||
version = cpt.get("version", "v1")
|
||||
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Model version: {version}")
|
||||
print(f"[{branding}Debug] f0: {if_f0}")
|
||||
|
||||
if version == "v1":
|
||||
if if_f0 == 1:
|
||||
net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
|
||||
else:
|
||||
net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
|
||||
elif version == "v2":
|
||||
if if_f0 == 1:
|
||||
net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
|
||||
else:
|
||||
net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
|
||||
del net_g, cpt
|
||||
if torch.cuda.is_available():
|
||||
torch.cuda.empty_cache()
|
||||
cpt = None
|
||||
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Loading model checkpoint")
|
||||
|
||||
person = weight_root
|
||||
cpt = torch.load(person, map_location="cpu")
|
||||
tgt_sr = cpt["config"][-1]
|
||||
cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0]
|
||||
if_f0 = cpt.get("f0", 1)
|
||||
version = cpt.get("version", "v1")
|
||||
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Model version: {version}")
|
||||
|
||||
if version == "v1":
|
||||
if if_f0 == 1:
|
||||
net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
|
||||
else:
|
||||
net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
|
||||
elif version == "v2":
|
||||
if if_f0 == 1:
|
||||
net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
|
||||
else:
|
||||
net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
|
||||
net_g.load_state_dict(cpt["weight"], strict=False)
|
||||
net_g.eval().to(config.device)
|
||||
if config.is_half:
|
||||
net_g = net_g.half()
|
||||
else:
|
||||
net_g = net_g.float()
|
||||
|
||||
if file_index is not None:
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Loading index file: {file_index}")
|
||||
index_file = file_index
|
||||
index = faiss.read_index(index_file)
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Extracting data from index")
|
||||
data = index.reconstruct_n(0, index.ntotal)
|
||||
d = index.d
|
||||
nlist = index.nlist
|
||||
|
||||
training_data_size = min(training_data_size, len(data))
|
||||
train_data = data[:training_data_size]
|
||||
|
||||
else:
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] No index file provided")
|
||||
data = None
|
||||
d = None
|
||||
nlist = None
|
||||
train_data = None
|
||||
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Creating VC instance")
|
||||
|
||||
if data is not None and d is not None and nlist is not None and train_data is not None:
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Data: {data}")
|
||||
print(f"[{branding}Debug] Dimensionality: {d}")
|
||||
print(f"[{branding}Debug] Number of centroids: {nlist}")
|
||||
print(f"[{branding}Debug] Training data size: {len(train_data)}")
|
||||
vc = VC(tgt_sr, config, data, d, train_data, debug_rvc)
|
||||
else:
|
||||
vc = VC(tgt_sr, config)
|
||||
|
||||
n_spk = cpt["config"][-3]
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Leaving get_vc function")
|
||||
return vc
|
||||
|
||||
|
||||
def infer_pipeline(
|
||||
f0up_key,
|
||||
filter_radius,
|
||||
index_rate,
|
||||
rms_mix_rate,
|
||||
protect,
|
||||
hop_length,
|
||||
f0method,
|
||||
audio_input_path,
|
||||
audio_output_path,
|
||||
model_path,
|
||||
index_path,
|
||||
split_audio,
|
||||
f0autotune,
|
||||
embedder_model,
|
||||
training_data_size,
|
||||
debug_rvc,
|
||||
):
|
||||
global tgt_sr, net_g, vc, cpt
|
||||
debug_rvc = debug_rvc
|
||||
if index_path is None or index_path.strip() == "":
|
||||
file_index = None
|
||||
else:
|
||||
file_index = index_path
|
||||
get_vc(model_path, 0, file_index, training_data_size, debug_rvc)
|
||||
|
||||
try:
|
||||
start_time = time.time()
|
||||
voice_conversion(
|
||||
sid=0,
|
||||
input_audio_path=audio_input_path,
|
||||
f0_up_key=f0up_key,
|
||||
f0_file=None,
|
||||
f0_method=f0method,
|
||||
file_index=index_path,
|
||||
index_rate=float(index_rate),
|
||||
rms_mix_rate=float(rms_mix_rate),
|
||||
protect=float(protect),
|
||||
hop_length=hop_length,
|
||||
output_path=audio_output_path,
|
||||
split_audio=split_audio,
|
||||
f0autotune=f0autotune,
|
||||
filter_radius=filter_radius,
|
||||
embedder_model=embedder_model,
|
||||
)
|
||||
|
||||
end_time = time.time()
|
||||
elapsed_time = end_time - start_time
|
||||
print(f"Conversion completed. Output file: '{audio_output_path}' in {elapsed_time:.2f} seconds.") if debug_rvc else None
|
||||
|
||||
except Exception as error:
|
||||
print(f"Voice conversion failed: {error}")
|
||||
|
||||
@@ -0,0 +1,740 @@
|
||||
import numpy as np
|
||||
import torch
|
||||
import sys
|
||||
import os
|
||||
import pdb
|
||||
import parselmouth
|
||||
from time import time as ttime
|
||||
import torch.nn.functional as F
|
||||
import torchcrepe
|
||||
from torch import Tensor
|
||||
import scipy.signal as signal
|
||||
import pyworld, os, faiss, librosa, torchcrepe
|
||||
from scipy import signal
|
||||
from functools import lru_cache
|
||||
import random
|
||||
import gc
|
||||
import re
|
||||
import traceback
|
||||
from pathlib import Path
|
||||
# Get the current working directory
|
||||
script_dir = Path(__file__).resolve().parent
|
||||
now_dir = script_dir.parents[3]
|
||||
|
||||
sys.path.append(now_dir)
|
||||
from ..lib.FCPEF0Predictor import FCPEF0Predictor
|
||||
|
||||
bh, ah = signal.butter(N=5, Wn=48, btype="high", fs=16000)
|
||||
|
||||
input_audio_path2wav = {}
|
||||
|
||||
|
||||
@lru_cache
|
||||
def cache_harvest_f0(input_audio_path, fs, f0max, f0min, frame_period):
|
||||
audio = input_audio_path2wav[input_audio_path]
|
||||
f0, t = pyworld.harvest(
|
||||
audio,
|
||||
fs=fs,
|
||||
f0_ceil=f0max,
|
||||
f0_floor=f0min,
|
||||
frame_period=frame_period,
|
||||
)
|
||||
f0 = pyworld.stonemask(audio, f0, t, fs)
|
||||
return f0
|
||||
|
||||
|
||||
def change_rms(data1, sr1, data2, sr2, rate):
|
||||
# print(data1.max(),data2.max())
|
||||
rms1 = librosa.feature.rms(y=data1, frame_length=sr1 // 2 * 2, hop_length=sr1 // 2)
|
||||
rms2 = librosa.feature.rms(y=data2, frame_length=sr2 // 2 * 2, hop_length=sr2 // 2)
|
||||
|
||||
rms1 = torch.from_numpy(rms1)
|
||||
rms1 = F.interpolate(
|
||||
rms1.unsqueeze(0), size=data2.shape[0], mode="linear"
|
||||
).squeeze()
|
||||
|
||||
rms2 = torch.from_numpy(rms2)
|
||||
rms2 = F.interpolate(
|
||||
rms2.unsqueeze(0), size=data2.shape[0], mode="linear"
|
||||
).squeeze()
|
||||
rms2 = torch.max(rms2, torch.zeros_like(rms2) + 1e-6)
|
||||
|
||||
data2 *= (
|
||||
torch.pow(rms1, torch.tensor(1 - rate))
|
||||
* torch.pow(rms2, torch.tensor(rate - 1))
|
||||
).numpy()
|
||||
return data2
|
||||
|
||||
from sklearn.metrics import (
|
||||
silhouette_score,
|
||||
calinski_harabasz_score,
|
||||
davies_bouldin_score,
|
||||
fowlkes_mallows_score,
|
||||
adjusted_rand_score,
|
||||
adjusted_mutual_info_score
|
||||
)
|
||||
|
||||
class VC(object):
|
||||
def __init__(self, tgt_sr, config, data=None, d=None, train_data=None, debug_rvc=False):
|
||||
branding = "AllTalk "
|
||||
self.x_pad, self.x_query, self.x_center, self.x_max, self.is_half = (
|
||||
config.x_pad,
|
||||
config.x_query,
|
||||
config.x_center,
|
||||
config.x_max,
|
||||
config.is_half,
|
||||
)
|
||||
self.sr = 16000
|
||||
self.window = 160
|
||||
self.t_pad = self.sr * self.x_pad
|
||||
self.t_pad_tgt = tgt_sr * self.x_pad
|
||||
self.t_pad2 = self.t_pad * 2
|
||||
self.t_query = self.sr * self.x_query
|
||||
self.t_center = self.sr * self.x_center
|
||||
self.t_max = self.sr * self.x_max
|
||||
self.device = config.device
|
||||
self.ref_freqs = [
|
||||
65.41,
|
||||
82.41,
|
||||
110.00,
|
||||
146.83,
|
||||
196.00,
|
||||
246.94,
|
||||
329.63,
|
||||
440.00,
|
||||
587.33,
|
||||
783.99,
|
||||
1046.50,
|
||||
]
|
||||
self.note_dict = self.generate_interpolated_frequencies()
|
||||
|
||||
if data is not None and d is not None and train_data is not None:
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Initializing FAISS quantizer with dimensionality: {d}")
|
||||
self.quantizer = faiss.IndexFlatL2(d)
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] FAISS quantizer initialized: {self.quantizer}")
|
||||
|
||||
# Dynamic adjustment of new_nlist
|
||||
new_nlist = max(1, len(train_data) // 39) # Ensure at least 1
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Using nlist: {new_nlist}")
|
||||
self.index = faiss.IndexIVFFlat(self.quantizer, d, new_nlist)
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] FAISS IndexIVFFlat initialized: {self.index}")
|
||||
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Training FAISS index with {len(train_data)} training points and {new_nlist} centroids")
|
||||
self.index.train(train_data)
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] FAISS index trained")
|
||||
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Adding {len(data)} data points to FAISS index")
|
||||
self.index.add(data)
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] Data added to FAISS index")
|
||||
|
||||
else:
|
||||
self.quantizer = None
|
||||
self.index = None
|
||||
if debug_rvc:
|
||||
print(f"[{branding}Debug] FAISS index not initialized due to missing data.")
|
||||
|
||||
|
||||
def generate_interpolated_frequencies(self):
|
||||
note_dict = []
|
||||
for i in range(len(self.ref_freqs) - 1):
|
||||
freq_low = self.ref_freqs[i]
|
||||
freq_high = self.ref_freqs[i + 1]
|
||||
interpolated_freqs = np.linspace(freq_low, freq_high, num=10, endpoint=False)
|
||||
note_dict.extend(interpolated_freqs)
|
||||
note_dict.append(self.ref_freqs[-1])
|
||||
return note_dict
|
||||
|
||||
|
||||
def autotune_f0(self, f0):
|
||||
# Autotunes the given fundamental frequency (f0) to the nearest musical note.
|
||||
autotuned_f0 = np.zeros_like(f0)
|
||||
for i, freq in enumerate(f0):
|
||||
# Find the closest note
|
||||
closest_note = min(self.note_dict, key=lambda x: abs(x - freq))
|
||||
autotuned_f0[i] = closest_note
|
||||
return autotuned_f0
|
||||
|
||||
def get_optimal_torch_device(self, index: int = 0) -> torch.device:
|
||||
#print("GETTING OPTIMAL DEVICE")
|
||||
if torch.cuda.is_available():
|
||||
#print("GETTING OPTIMAL DEVICE CUDA")
|
||||
return torch.device(f"cuda:{index % torch.cuda.device_count()}")
|
||||
elif torch.backends.mps.is_available():
|
||||
#print("GETTING OPTIMAL DEVICE MPS")
|
||||
return torch.device("mps")
|
||||
#print("GETTING OPTIMAL DEVICE CPU")
|
||||
return torch.device("cpu")
|
||||
|
||||
def get_f0_crepe_computation(
|
||||
self,
|
||||
x,
|
||||
f0_min,
|
||||
f0_max,
|
||||
p_len,
|
||||
hop_length,
|
||||
model="full",
|
||||
):
|
||||
x = x.astype(np.float32)
|
||||
x /= np.quantile(np.abs(x), 0.999)
|
||||
torch_device = self.get_optimal_torch_device()
|
||||
audio = torch.from_numpy(x).to(torch_device, copy=True)
|
||||
audio = torch.unsqueeze(audio, dim=0)
|
||||
if audio.ndim == 2 and audio.shape[0] > 1:
|
||||
audio = torch.mean(audio, dim=0, keepdim=True).detach()
|
||||
audio = audio.detach()
|
||||
pitch: Tensor = torchcrepe.predict(
|
||||
audio,
|
||||
self.sr,
|
||||
hop_length,
|
||||
f0_min,
|
||||
f0_max,
|
||||
model,
|
||||
batch_size=hop_length * 2,
|
||||
device=torch_device,
|
||||
pad=True,
|
||||
)
|
||||
p_len = p_len or x.shape[0] // hop_length
|
||||
source = np.array(pitch.squeeze(0).cpu().float().numpy())
|
||||
source[source < 0.001] = np.nan
|
||||
target = np.interp(
|
||||
np.arange(0, len(source) * p_len, len(source)) / p_len,
|
||||
np.arange(0, len(source)),
|
||||
source,
|
||||
)
|
||||
f0 = np.nan_to_num(target)
|
||||
#print("LEAVING get_f0_crepe_computation")
|
||||
return f0
|
||||
|
||||
def get_f0_official_crepe_computation(
|
||||
self,
|
||||
x,
|
||||
f0_min,
|
||||
f0_max,
|
||||
model="full",
|
||||
):
|
||||
batch_size = 512
|
||||
audio = torch.tensor(np.copy(x))[None].float()
|
||||
f0, pd = torchcrepe.predict(
|
||||
audio,
|
||||
self.sr,
|
||||
self.window,
|
||||
f0_min,
|
||||
f0_max,
|
||||
model,
|
||||
batch_size=batch_size,
|
||||
device=self.device,
|
||||
return_periodicity=True,
|
||||
)
|
||||
pd = torchcrepe.filter.median(pd, 3)
|
||||
f0 = torchcrepe.filter.mean(f0, 3)
|
||||
f0[pd < 0.1] = 0
|
||||
f0 = f0[0].cpu().numpy()
|
||||
#print("LEAVING get_f0_official_crepe_computation")
|
||||
return f0
|
||||
|
||||
def get_f0_hybrid_computation(
|
||||
self,
|
||||
methods_str,
|
||||
x,
|
||||
f0_min,
|
||||
f0_max,
|
||||
p_len,
|
||||
hop_length,
|
||||
):
|
||||
methods_str = re.search("hybrid\[(.+)\]", methods_str)
|
||||
if methods_str:
|
||||
methods = [method.strip() for method in methods_str.group(1).split("+")]
|
||||
f0_computation_stack = []
|
||||
#print(f"Calculating f0 pitch estimations for methods {str(methods)}")
|
||||
x = x.astype(np.float32)
|
||||
x /= np.quantile(np.abs(x), 0.999)
|
||||
for method in methods:
|
||||
f0 = None
|
||||
if method == "crepe":
|
||||
f0 = self.get_f0_crepe_computation(
|
||||
x, f0_min, f0_max, p_len, int(hop_length)
|
||||
)
|
||||
elif method == "rmvpe":
|
||||
if hasattr(self, "model_rmvpe") == False:
|
||||
from ..lib.rmvpe import RMVPE
|
||||
model_path = os.path.join(now_dir, "models", "rvc_base", "rmvpe.pt")
|
||||
self.model_rmvpe = RMVPE(
|
||||
model_path, is_half=self.is_half, device=self.device
|
||||
)
|
||||
f0 = self.model_rmvpe.infer_from_audio(x, thred=0.03)
|
||||
f0 = f0[1:]
|
||||
elif method == "fcpe":
|
||||
model_path = os.path.join(now_dir, "models", "rvc_base", "fcpe.pt")
|
||||
self.model_fcpe = FCPEF0Predictor(
|
||||
model_path,
|
||||
f0_min=int(f0_min),
|
||||
f0_max=int(f0_max),
|
||||
dtype=torch.float32,
|
||||
device=self.device,
|
||||
sampling_rate=self.sr,
|
||||
threshold=0.03,
|
||||
)
|
||||
f0 = self.model_fcpe.compute_f0(x, p_len=p_len)
|
||||
del self.model_fcpe
|
||||
gc.collect()
|
||||
f0_computation_stack.append(f0)
|
||||
|
||||
#print(f"Calculating hybrid median f0 from the stack of {str(methods)}")
|
||||
f0_computation_stack = [fc for fc in f0_computation_stack if fc is not None]
|
||||
f0_median_hybrid = None
|
||||
if len(f0_computation_stack) == 1:
|
||||
f0_median_hybrid = f0_computation_stack[0]
|
||||
else:
|
||||
f0_median_hybrid = np.nanmedian(f0_computation_stack, axis=0)
|
||||
#print("LEAVING get_f0_hybrid_computation")
|
||||
return f0_median_hybrid
|
||||
|
||||
def get_f0(
|
||||
self,
|
||||
input_audio_path,
|
||||
x,
|
||||
p_len,
|
||||
f0_up_key,
|
||||
f0_method,
|
||||
filter_radius,
|
||||
hop_length,
|
||||
f0autotune,
|
||||
inp_f0=None,
|
||||
):
|
||||
global input_audio_path2wav
|
||||
time_step = self.window / self.sr * 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)
|
||||
if f0_method == "pm":
|
||||
f0 = (
|
||||
parselmouth.Sound(x, self.sr)
|
||||
.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"
|
||||
)
|
||||
elif f0_method == "harvest":
|
||||
input_audio_path2wav[input_audio_path] = x.astype(np.double)
|
||||
f0 = cache_harvest_f0(input_audio_path, self.sr, f0_max, f0_min, 10)
|
||||
if int(filter_radius) > 2:
|
||||
f0 = signal.medfilt(f0, 3)
|
||||
elif f0_method == "dio":
|
||||
f0, t = pyworld.dio(
|
||||
x.astype(np.double),
|
||||
fs=self.sr,
|
||||
f0_ceil=f0_max,
|
||||
f0_floor=f0_min,
|
||||
frame_period=10,
|
||||
)
|
||||
f0 = pyworld.stonemask(x.astype(np.double), f0, t, self.sr)
|
||||
f0 = signal.medfilt(f0, 3)
|
||||
elif f0_method == "crepe":
|
||||
f0 = self.get_f0_crepe_computation(
|
||||
x, f0_min, f0_max, p_len, int(hop_length)
|
||||
)
|
||||
elif f0_method == "crepe-tiny":
|
||||
f0 = self.get_f0_crepe_computation(
|
||||
x, f0_min, f0_max, p_len, int(hop_length), "tiny"
|
||||
)
|
||||
elif f0_method == "rmvpe":
|
||||
if hasattr(self, "model_rmvpe") == False:
|
||||
from ..lib.rmvpe import RMVPE
|
||||
model_path = os.path.join(now_dir, "models", "rvc_base", "rmvpe.pt")
|
||||
self.model_rmvpe = RMVPE(
|
||||
model_path, is_half=self.is_half, device=self.device
|
||||
)
|
||||
f0 = self.model_rmvpe.infer_from_audio(x, thred=0.03)
|
||||
elif f0_method == "fcpe":
|
||||
model_path = os.path.join(now_dir, "models", "rvc_base", "fcpe.pt")
|
||||
self.model_fcpe = FCPEF0Predictor(
|
||||
model_path,
|
||||
f0_min=int(f0_min),
|
||||
f0_max=int(f0_max),
|
||||
dtype=torch.float32,
|
||||
device=self.device,
|
||||
sampling_rate=self.sr,
|
||||
threshold=0.03,
|
||||
)
|
||||
f0 = self.model_fcpe.compute_f0(x, p_len=p_len)
|
||||
del self.model_fcpe
|
||||
gc.collect()
|
||||
elif "hybrid" in f0_method:
|
||||
input_audio_path2wav[input_audio_path] = x.astype(np.double)
|
||||
f0 = self.get_f0_hybrid_computation(
|
||||
f0_method,
|
||||
x,
|
||||
f0_min,
|
||||
f0_max,
|
||||
p_len,
|
||||
hop_length,
|
||||
)
|
||||
|
||||
if f0autotune == "True":
|
||||
f0 = self.autotune_f0(f0)
|
||||
|
||||
f0 *= pow(2, f0_up_key / 12)
|
||||
tf0 = self.sr // self.window
|
||||
if inp_f0 is not None:
|
||||
delta_t = np.round(
|
||||
(inp_f0[:, 0].max() - inp_f0[:, 0].min()) * tf0 + 1
|
||||
).astype("int16")
|
||||
replace_f0 = np.interp(
|
||||
list(range(delta_t)), inp_f0[:, 0] * 100, inp_f0[:, 1]
|
||||
)
|
||||
shape = f0[self.x_pad * tf0 : self.x_pad * tf0 + len(replace_f0)].shape[0]
|
||||
f0[self.x_pad * tf0 : self.x_pad * tf0 + len(replace_f0)] = replace_f0[
|
||||
:shape
|
||||
]
|
||||
f0bak = f0.copy()
|
||||
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(int)
|
||||
#print("LEAVING get_f0")
|
||||
return f0_coarse, f0bak
|
||||
|
||||
def vc(
|
||||
self,
|
||||
model,
|
||||
net_g,
|
||||
sid,
|
||||
audio0,
|
||||
pitch,
|
||||
pitchf,
|
||||
index,
|
||||
big_npy,
|
||||
index_rate,
|
||||
version,
|
||||
protect,
|
||||
):
|
||||
#print("ENTERING pipeline vc")
|
||||
#print(f"audio0 shape: {audio0.shape}")
|
||||
feats = torch.from_numpy(audio0)
|
||||
#print(f"feats initial dtype: {feats.dtype}")
|
||||
if self.is_half:
|
||||
feats = feats.half()
|
||||
#print("Converting feats to half precision")
|
||||
else:
|
||||
feats = feats.float()
|
||||
#print("Converting feats to float precision")
|
||||
#print(f"feats dtype after conversion: {feats.dtype}")
|
||||
if feats.dim() == 2:
|
||||
#print("feats has 2 dimensions, taking mean along last dimension")
|
||||
feats = feats.mean(-1)
|
||||
assert feats.dim() == 1, feats.dim()
|
||||
#print(f"feats shape after mean: {feats.shape}")
|
||||
feats = feats.view(1, -1)
|
||||
#print(f"feats shape after view: {feats.shape}")
|
||||
padding_mask = torch.BoolTensor(feats.shape).to(self.device).fill_(False)
|
||||
#print(f"padding_mask shape: {padding_mask.shape}")
|
||||
#print(f"padding_mask device: {padding_mask.device}")
|
||||
|
||||
inputs = {
|
||||
"source": feats.to(self.device),
|
||||
"padding_mask": padding_mask,
|
||||
"output_layer": 9 if version == "v1" else 12,
|
||||
}
|
||||
#print(f"inputs source shape: {inputs['source'].shape}")
|
||||
#print(f"inputs source device: {inputs['source'].device}")
|
||||
#print(f"output_layer: {inputs['output_layer']}")
|
||||
t0 = ttime()
|
||||
#print("Pipeline vc STEP 1:")
|
||||
with torch.no_grad():
|
||||
logits = model.extract_features(**inputs)
|
||||
#print(f"logits type: {type(logits)}")
|
||||
#print(f"logits length: {len(logits)}")
|
||||
#print(f"logits[0] shape: {logits[0].shape}")
|
||||
feats = model.final_proj(logits[0]) if version == "v1" else logits[0]
|
||||
#print(f"feats shape after final_proj or logits[0]: {feats.shape}")
|
||||
#print("Pipeline vc STEP 1a:")
|
||||
if protect < 0.5 and pitch is not None and pitchf is not None:
|
||||
#print("Cloning feats to feats0")
|
||||
feats0 = feats.clone()
|
||||
#print(f"feats0 shape: {feats0.shape}")
|
||||
#print("Pipeline vc STEP 1b:")
|
||||
if (
|
||||
isinstance(index, type(None)) == False
|
||||
and isinstance(big_npy, type(None)) == False
|
||||
and index_rate != 0
|
||||
):
|
||||
#print("Pipeline vc STEP 1c:")
|
||||
#print(f"feats shape: {feats.shape}")
|
||||
npy = feats[0, :feats.shape[1], :].cpu().numpy()
|
||||
#print(f"npy shape: {npy.shape}")
|
||||
#print("Pipeline vc STEP 1c1:")
|
||||
if self.is_half:
|
||||
#print("Pipeline vc STEP 1c2:")
|
||||
npy = npy.astype("float32")
|
||||
#print(f"Converted npy to float32. npy dtype: {npy.dtype}")
|
||||
#print("Pipeline vc STEP 1c3:")
|
||||
#print(f"npy size: {npy.size}")
|
||||
|
||||
score, ix = self.index.search(npy, k=4)
|
||||
|
||||
#print(f"score shape: {score.shape}")
|
||||
#print(f"ix shape: {ix.shape}")
|
||||
#print("Pipeline vc STEP 1c4:")
|
||||
weight = np.square(1 / score)
|
||||
#print(f"weight shape: {weight.shape}")
|
||||
#print("Pipeline vc STEP 1c5:")
|
||||
weight /= weight.sum(axis=1, keepdims=True)
|
||||
#print(f"weight shape after normalization: {weight.shape}")
|
||||
#print("Pipeline vc STEP 1d:")
|
||||
npy = np.sum(big_npy[ix] * np.expand_dims(weight, axis=2), axis=1)
|
||||
#print(f"npy shape after weighted sum: {npy.shape}")
|
||||
#print("Pipeline vc STEP 1e:")
|
||||
if self.is_half:
|
||||
npy = npy.astype("float16")
|
||||
#print(f"Converted npy to float16. npy dtype: {npy.dtype}")
|
||||
#print("Pipeline vc STEP 1f:")
|
||||
feats = (
|
||||
torch.from_numpy(npy).unsqueeze(0).to(self.device) * index_rate
|
||||
+ (1 - index_rate) * feats
|
||||
)
|
||||
#print(f"feats shape after updating with npy: {feats.shape}")
|
||||
#print("Pipeline vc STEP 2:")
|
||||
feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
|
||||
#print(f"feats shape after interpolation: {feats.shape}")
|
||||
if protect < 0.5 and pitch is not None and pitchf is not None:
|
||||
feats0 = F.interpolate(feats0.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
|
||||
#print(f"feats0 shape after interpolation: {feats0.shape}")
|
||||
t1 = ttime()
|
||||
p_len = audio0.shape[0] // self.window
|
||||
#print(f"Initial p_len: {p_len}")
|
||||
if feats.shape[1] < p_len:
|
||||
p_len = feats.shape[1]
|
||||
#print(f"Updated p_len to match feats shape: {p_len}")
|
||||
if pitch is not None and pitchf is not None:
|
||||
pitch = pitch[:, :p_len]
|
||||
pitchf = pitchf[:, :p_len]
|
||||
#print(f"Updated pitch shape: {pitch.shape}")
|
||||
#print(f"Updated pitchf shape: {pitchf.shape}")
|
||||
#print("Pipeline vc STEP 3:")
|
||||
if protect < 0.5 and pitch is not None and pitchf is not None:
|
||||
pitchff = pitchf.clone()
|
||||
#print(f"pitchff shape: {pitchff.shape}")
|
||||
pitchff[pitchf > 0] = 1
|
||||
pitchff[pitchf < 1] = protect
|
||||
pitchff = pitchff.unsqueeze(-1)
|
||||
#print(f"pitchff shape after unsqueeze: {pitchff.shape}")
|
||||
feats = feats * pitchff + feats0 * (1 - pitchff)
|
||||
#print(f"feats shape after updating with pitchff: {feats.shape}")
|
||||
feats = feats.to(feats0.dtype)
|
||||
#print(f"feats dtype after conversion: {feats.dtype}")
|
||||
p_len = torch.tensor([p_len], device=self.device).long()
|
||||
#print(f"p_len tensor: {p_len}")
|
||||
#print(f"p_len device: {p_len.device}")
|
||||
#print("Pipeline vc p_len is:", p_len)
|
||||
with torch.no_grad():
|
||||
if pitch is not None and pitchf is not None:
|
||||
audio1 = (
|
||||
(net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0])
|
||||
.data.cpu()
|
||||
.float()
|
||||
.numpy()
|
||||
)
|
||||
else:
|
||||
audio1 = (
|
||||
(net_g.infer(feats, p_len, sid)[0][0, 0]).data.cpu().float().numpy()
|
||||
)
|
||||
#print(f"audio1 shape: {audio1.shape}")
|
||||
del feats, p_len, padding_mask
|
||||
if torch.cuda.is_available():
|
||||
torch.cuda.empty_cache()
|
||||
t2 = ttime()
|
||||
#print(f"Pipeline vc time breakdown:")
|
||||
#print(f" Step 1: {t1 - t0:.3f}s")
|
||||
#print(f" Step 2: {t2 - t1:.3f}s")
|
||||
#print(f" Total: {t2 - t0:.3f}s")
|
||||
#print("Leaving pipeline vc")
|
||||
return audio1
|
||||
|
||||
def pipeline(
|
||||
self,
|
||||
model,
|
||||
net_g,
|
||||
sid,
|
||||
audio,
|
||||
input_audio_path,
|
||||
f0_up_key,
|
||||
f0_method,
|
||||
file_index,
|
||||
index_rate,
|
||||
if_f0,
|
||||
filter_radius,
|
||||
tgt_sr,
|
||||
resample_sr,
|
||||
rms_mix_rate,
|
||||
version,
|
||||
protect,
|
||||
hop_length,
|
||||
f0autotune,
|
||||
f0_file=None,
|
||||
):
|
||||
if file_index != "" and os.path.exists(file_index) == True and index_rate != 0:
|
||||
try:
|
||||
index = faiss.read_index(file_index)
|
||||
big_npy = index.reconstruct_n(0, index.ntotal)
|
||||
except Exception as error:
|
||||
print(error)
|
||||
index = big_npy = None
|
||||
else:
|
||||
index = big_npy = None
|
||||
audio = signal.filtfilt(bh, ah, audio)
|
||||
audio_pad = np.pad(audio, (self.window // 2, self.window // 2), mode="reflect")
|
||||
opt_ts = []
|
||||
if audio_pad.shape[0] > self.t_max:
|
||||
audio_sum = np.zeros_like(audio)
|
||||
for i in range(self.window):
|
||||
audio_sum += audio_pad[i : i - self.window]
|
||||
for t in range(self.t_center, audio.shape[0], self.t_center):
|
||||
opt_ts.append(
|
||||
t
|
||||
- self.t_query
|
||||
+ np.where(
|
||||
np.abs(audio_sum[t - self.t_query : t + self.t_query])
|
||||
== np.abs(audio_sum[t - self.t_query : t + self.t_query]).min()
|
||||
)[0][0]
|
||||
)
|
||||
s = 0
|
||||
audio_opt = []
|
||||
t = None
|
||||
t1 = ttime()
|
||||
audio_pad = np.pad(audio, (self.t_pad, self.t_pad), mode="reflect")
|
||||
p_len = audio_pad.shape[0] // self.window
|
||||
inp_f0 = None
|
||||
if hasattr(f0_file, "name") == True:
|
||||
try:
|
||||
with open(f0_file.name, "r") as f:
|
||||
lines = f.read().strip("\n").split("\n")
|
||||
inp_f0 = []
|
||||
for line in lines:
|
||||
inp_f0.append([float(i) for i in line.split(",")])
|
||||
inp_f0 = np.array(inp_f0, dtype="float32")
|
||||
except Exception as error:
|
||||
print(error)
|
||||
sid = torch.tensor(sid, device=self.device).unsqueeze(0).long()
|
||||
pitch, pitchf = None, None
|
||||
if if_f0 == 1:
|
||||
pitch, pitchf = self.get_f0(
|
||||
input_audio_path,
|
||||
audio_pad,
|
||||
p_len,
|
||||
f0_up_key,
|
||||
f0_method,
|
||||
filter_radius,
|
||||
hop_length,
|
||||
f0autotune,
|
||||
inp_f0,
|
||||
)
|
||||
pitch = pitch[:p_len]
|
||||
pitchf = pitchf[:p_len]
|
||||
if self.device == "mps":
|
||||
pitchf = pitchf.astype(np.float32)
|
||||
pitch = torch.tensor(pitch, device=self.device).unsqueeze(0).long()
|
||||
pitchf = torch.tensor(pitchf, device=self.device).unsqueeze(0).float()
|
||||
t2 = ttime()
|
||||
for t in opt_ts:
|
||||
t = t // self.window * self.window
|
||||
if if_f0 == 1:
|
||||
audio_opt.append(
|
||||
self.vc(
|
||||
model,
|
||||
net_g,
|
||||
sid,
|
||||
audio_pad[s : t + self.t_pad2 + self.window],
|
||||
pitch[:, s // self.window : (t + self.t_pad2) // self.window],
|
||||
pitchf[:, s // self.window : (t + self.t_pad2) // self.window],
|
||||
index,
|
||||
big_npy,
|
||||
index_rate,
|
||||
version,
|
||||
protect,
|
||||
)[self.t_pad_tgt : -self.t_pad_tgt]
|
||||
)
|
||||
else:
|
||||
audio_opt.append(
|
||||
self.vc(
|
||||
model,
|
||||
net_g,
|
||||
sid,
|
||||
audio_pad[s : t + self.t_pad2 + self.window],
|
||||
None,
|
||||
None,
|
||||
index,
|
||||
big_npy,
|
||||
index_rate,
|
||||
version,
|
||||
protect,
|
||||
)[self.t_pad_tgt : -self.t_pad_tgt]
|
||||
)
|
||||
s = t
|
||||
if if_f0 == 1:
|
||||
audio_opt.append(
|
||||
self.vc(
|
||||
model,
|
||||
net_g,
|
||||
sid,
|
||||
audio_pad[t:],
|
||||
pitch[:, t // self.window :] if t is not None else pitch,
|
||||
pitchf[:, t // self.window :] if t is not None else pitchf,
|
||||
index,
|
||||
big_npy,
|
||||
index_rate,
|
||||
version,
|
||||
protect,
|
||||
)[self.t_pad_tgt : -self.t_pad_tgt]
|
||||
)
|
||||
else:
|
||||
audio_opt.append(
|
||||
self.vc(
|
||||
model,
|
||||
net_g,
|
||||
sid,
|
||||
audio_pad[t:],
|
||||
None,
|
||||
None,
|
||||
index,
|
||||
big_npy,
|
||||
index_rate,
|
||||
version,
|
||||
protect,
|
||||
)[self.t_pad_tgt : -self.t_pad_tgt]
|
||||
)
|
||||
audio_opt = np.concatenate(audio_opt)
|
||||
if rms_mix_rate != 1:
|
||||
audio_opt = change_rms(audio, 16000, audio_opt, tgt_sr, rms_mix_rate)
|
||||
if resample_sr >= 16000 and tgt_sr != resample_sr:
|
||||
audio_opt = librosa.resample(
|
||||
audio_opt, orig_sr=tgt_sr, target_sr=resample_sr
|
||||
)
|
||||
audio_max = np.abs(audio_opt).max() / 0.99
|
||||
max_int16 = 32768
|
||||
if audio_max > 1:
|
||||
max_int16 /= audio_max
|
||||
audio_opt = (audio_opt * max_int16).astype(np.int16)
|
||||
del pitch, pitchf, sid
|
||||
if torch.cuda.is_available():
|
||||
torch.cuda.empty_cache()
|
||||
return audio_opt
|
||||
File diff suppressed because it is too large.
Load diff
Whitespace-only changes.
@@ -0,0 +1,398 @@
|
||||
import math
|
||||
import torch
|
||||
from torch import nn
|
||||
from torch.nn import functional as F
|
||||
|
||||
from . import commons
|
||||
from .modules import LayerNorm
|
||||
|
||||
|
||||
class Encoder(nn.Module):
|
||||
def __init__(
|
||||
self,
|
||||
hidden_channels,
|
||||
filter_channels,
|
||||
n_heads,
|
||||
n_layers,
|
||||
kernel_size=1,
|
||||
p_dropout=0.0,
|
||||
window_size=10,
|
||||
**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.0,
|
||||
proximal_bias=False,
|
||||
proximal_init=True,
|
||||
**kwargs
|
||||
):
|
||||
super().__init__()
|
||||
self.hidden_channels = hidden_channels
|
||||
self.filter_channels = filter_channels
|
||||
self.n_heads = n_heads
|
||||
self.n_layers = n_layers
|
||||
self.kernel_size = kernel_size
|
||||
self.p_dropout = p_dropout
|
||||
self.proximal_bias = proximal_bias
|
||||
self.proximal_init = proximal_init
|
||||
|
||||
self.drop = nn.Dropout(p_dropout)
|
||||
self.self_attn_layers = nn.ModuleList()
|
||||
self.norm_layers_0 = nn.ModuleList()
|
||||
self.encdec_attn_layers = nn.ModuleList()
|
||||
self.norm_layers_1 = nn.ModuleList()
|
||||
self.ffn_layers = nn.ModuleList()
|
||||
self.norm_layers_2 = nn.ModuleList()
|
||||
for i in range(self.n_layers):
|
||||
self.self_attn_layers.append(
|
||||
MultiHeadAttention(
|
||||
hidden_channels,
|
||||
hidden_channels,
|
||||
n_heads,
|
||||
p_dropout=p_dropout,
|
||||
proximal_bias=proximal_bias,
|
||||
proximal_init=proximal_init,
|
||||
)
|
||||
)
|
||||
self.norm_layers_0.append(LayerNorm(hidden_channels))
|
||||
self.encdec_attn_layers.append(
|
||||
MultiHeadAttention(
|
||||
hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout
|
||||
)
|
||||
)
|
||||
self.norm_layers_1.append(LayerNorm(hidden_channels))
|
||||
self.ffn_layers.append(
|
||||
FFN(
|
||||
hidden_channels,
|
||||
hidden_channels,
|
||||
filter_channels,
|
||||
kernel_size,
|
||||
p_dropout=p_dropout,
|
||||
causal=True,
|
||||
)
|
||||
)
|
||||
self.norm_layers_2.append(LayerNorm(hidden_channels))
|
||||
|
||||
def forward(self, x, x_mask, h, h_mask):
|
||||
"""
|
||||
x: decoder input
|
||||
h: encoder output
|
||||
"""
|
||||
self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(
|
||||
device=x.device, dtype=x.dtype
|
||||
)
|
||||
encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
|
||||
x = x * x_mask
|
||||
for i in range(self.n_layers):
|
||||
y = self.self_attn_layers[i](x, x, self_attn_mask)
|
||||
y = self.drop(y)
|
||||
x = self.norm_layers_0[i](x + y)
|
||||
|
||||
y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
|
||||
y = self.drop(y)
|
||||
x = self.norm_layers_1[i](x + y)
|
||||
|
||||
y = self.ffn_layers[i](x, x_mask)
|
||||
y = self.drop(y)
|
||||
x = self.norm_layers_2[i](x + y)
|
||||
x = x * x_mask
|
||||
return x
|
||||
|
||||
|
||||
class MultiHeadAttention(nn.Module):
|
||||
def __init__(
|
||||
self,
|
||||
channels,
|
||||
out_channels,
|
||||
n_heads,
|
||||
p_dropout=0.0,
|
||||
window_size=None,
|
||||
heads_share=True,
|
||||
block_length=None,
|
||||
proximal_bias=False,
|
||||
proximal_init=False,
|
||||
):
|
||||
super().__init__()
|
||||
assert channels % n_heads == 0
|
||||
|
||||
self.channels = channels
|
||||
self.out_channels = out_channels
|
||||
self.n_heads = n_heads
|
||||
self.p_dropout = p_dropout
|
||||
self.window_size = window_size
|
||||
self.heads_share = heads_share
|
||||
self.block_length = block_length
|
||||
self.proximal_bias = proximal_bias
|
||||
self.proximal_init = proximal_init
|
||||
self.attn = None
|
||||
|
||||
self.k_channels = channels // n_heads
|
||||
self.conv_q = nn.Conv1d(channels, channels, 1)
|
||||
self.conv_k = nn.Conv1d(channels, channels, 1)
|
||||
self.conv_v = nn.Conv1d(channels, channels, 1)
|
||||
self.conv_o = nn.Conv1d(channels, out_channels, 1)
|
||||
self.drop = nn.Dropout(p_dropout)
|
||||
|
||||
if window_size is not None:
|
||||
n_heads_rel = 1 if heads_share else n_heads
|
||||
rel_stddev = self.k_channels**-0.5
|
||||
self.emb_rel_k = nn.Parameter(
|
||||
torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
|
||||
* rel_stddev
|
||||
)
|
||||
self.emb_rel_v = nn.Parameter(
|
||||
torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
|
||||
* rel_stddev
|
||||
)
|
||||
|
||||
nn.init.xavier_uniform_(self.conv_q.weight)
|
||||
nn.init.xavier_uniform_(self.conv_k.weight)
|
||||
nn.init.xavier_uniform_(self.conv_v.weight)
|
||||
if proximal_init:
|
||||
with torch.no_grad():
|
||||
self.conv_k.weight.copy_(self.conv_q.weight)
|
||||
self.conv_k.bias.copy_(self.conv_q.bias)
|
||||
|
||||
def forward(self, x, c, attn_mask=None):
|
||||
q = self.conv_q(x)
|
||||
k = self.conv_k(c)
|
||||
v = self.conv_v(c)
|
||||
|
||||
x, self.attn = self.attention(q, k, v, mask=attn_mask)
|
||||
|
||||
x = self.conv_o(x)
|
||||
return x
|
||||
|
||||
def attention(self, query, key, value, mask=None):
|
||||
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)
|
||||
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)
|
||||
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):
|
||||
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()
|
||||
|
||||
x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, 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]])
|
||||
)
|
||||
|
||||
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()
|
||||
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)])
|
||||
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):
|
||||
r = torch.arange(length, dtype=torch.float32)
|
||||
diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
|
||||
return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
|
||||
|
||||
|
||||
class FFN(nn.Module):
|
||||
def __init__(
|
||||
self,
|
||||
in_channels,
|
||||
out_channels,
|
||||
filter_channels,
|
||||
kernel_size,
|
||||
p_dropout=0.0,
|
||||
activation=None,
|
||||
causal=False,
|
||||
):
|
||||
super().__init__()
|
||||
self.in_channels = in_channels
|
||||
self.out_channels = out_channels
|
||||
self.filter_channels = filter_channels
|
||||
self.kernel_size = kernel_size
|
||||
self.p_dropout = p_dropout
|
||||
self.activation = activation
|
||||
self.causal = causal
|
||||
|
||||
if causal:
|
||||
self.padding = self._causal_padding
|
||||
else:
|
||||
self.padding = self._same_padding
|
||||
|
||||
self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
|
||||
self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
|
||||
self.drop = nn.Dropout(p_dropout)
|
||||
|
||||
def forward(self, x, x_mask):
|
||||
x = self.conv_1(self.padding(x * x_mask))
|
||||
if self.activation == "gelu":
|
||||
x = x * torch.sigmoid(1.702 * x)
|
||||
else:
|
||||
x = torch.relu(x)
|
||||
x = self.drop(x)
|
||||
x = self.conv_2(self.padding(x * x_mask))
|
||||
return x * x_mask
|
||||
|
||||
def _causal_padding(self, x):
|
||||
if self.kernel_size == 1:
|
||||
return x
|
||||
pad_l = self.kernel_size - 1
|
||||
pad_r = 0
|
||||
padding = [[0, 0], [0, 0], [pad_l, pad_r]]
|
||||
x = F.pad(x, commons.convert_pad_shape(padding))
|
||||
return x
|
||||
|
||||
def _same_padding(self, x):
|
||||
if self.kernel_size == 1:
|
||||
return x
|
||||
pad_l = (self.kernel_size - 1) // 2
|
||||
pad_r = self.kernel_size // 2
|
||||
padding = [[0, 0], [0, 0], [pad_l, pad_r]]
|
||||
x = F.pad(x, commons.convert_pad_shape(padding))
|
||||
return x
|
||||
@@ -0,0 +1,166 @@
|
||||
import math
|
||||
import numpy as np
|
||||
import torch
|
||||
from torch import nn
|
||||
from torch.nn import functional as F
|
||||
|
||||
|
||||
def init_weights(m, mean=0.0, std=0.01):
|
||||
classname = m.__class__.__name__
|
||||
if classname.find("Conv") != -1:
|
||||
m.weight.data.normal_(mean, std)
|
||||
|
||||
|
||||
def get_padding(kernel_size, dilation=1):
|
||||
return int((kernel_size * dilation - dilation) / 2)
|
||||
|
||||
|
||||
def convert_pad_shape(pad_shape):
|
||||
l = pad_shape[::-1]
|
||||
pad_shape = [item for sublist in l for item in sublist]
|
||||
return pad_shape
|
||||
|
||||
|
||||
def kl_divergence(m_p, logs_p, m_q, logs_q):
|
||||
"""KL(P||Q)"""
|
||||
kl = (logs_q - logs_p) - 0.5
|
||||
kl += (
|
||||
0.5 * (torch.exp(2.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * logs_q)
|
||||
)
|
||||
return kl
|
||||
|
||||
|
||||
def rand_gumbel(shape):
|
||||
"""Sample from the Gumbel distribution, protect from overflows."""
|
||||
uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
|
||||
return -torch.log(-torch.log(uniform_samples))
|
||||
|
||||
|
||||
def rand_gumbel_like(x):
|
||||
g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
|
||||
return g
|
||||
|
||||
|
||||
def slice_segments(x, ids_str, segment_size=4):
|
||||
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 slice_segments2(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 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.0 / norm_type)
|
||||
return total_norm
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,517 @@
|
||||
import math
|
||||
import torch
|
||||
from torch import nn
|
||||
from torch.nn import functional as F
|
||||
|
||||
from torch.nn import Conv1d
|
||||
from torch.nn.utils import remove_weight_norm
|
||||
from torch.nn.utils.parametrizations import weight_norm # Updated import
|
||||
|
||||
from . import commons
|
||||
from .commons import init_weights, get_padding
|
||||
from .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):
|
||||
def __init__(self, channels, kernel_size, n_layers, p_dropout=0.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,
|
||||
gin_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.gin_channels = gin_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 gin_channels != 0:
|
||||
cond_layer = torch.nn.Conv1d(
|
||||
gin_channels, 2 * hidden_channels * n_layers, 1
|
||||
)
|
||||
#self.cond_layer = torch.nn.utils.parametrizations.weight_norm(cond_layer, name="weight")
|
||||
self.cond_layer = weight_norm(cond_layer, name="weight") # Updated to use the new import
|
||||
|
||||
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.parametrizations.weight_norm(in_layer, name="weight")
|
||||
in_layer = weight_norm(in_layer, name="weight") # Updated to use the new impor
|
||||
self.in_layers.append(in_layer)
|
||||
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.parametrizations.weight_norm(res_skip_layer, name="weight")
|
||||
res_skip_layer = weight_norm(res_skip_layer, name="weight") # Updated to use the new import
|
||||
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.gin_channels != 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,
|
||||
gin_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,
|
||||
gin_channels=gin_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
|
||||
|
||||
def remove_weight_norm(self):
|
||||
self.enc.remove_weight_norm()
|
||||
|
||||
|
||||
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.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)
|
||||
|
||||
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
|
||||
@@ -0,0 +1,86 @@
|
||||
from infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
|
||||
import pyworld
|
||||
import numpy as np
|
||||
|
||||
|
||||
class DioF0Predictor(F0Predictor):
|
||||
def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
|
||||
self.hop_length = hop_length
|
||||
self.f0_min = f0_min
|
||||
self.f0_max = f0_max
|
||||
self.sampling_rate = sampling_rate
|
||||
|
||||
def interpolate_f0(self, 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 resize_f0(self, 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(self, wav, p_len=None):
|
||||
if p_len is None:
|
||||
p_len = wav.shape[0] // self.hop_length
|
||||
f0, t = pyworld.dio(
|
||||
wav.astype(np.double),
|
||||
fs=self.sampling_rate,
|
||||
f0_floor=self.f0_min,
|
||||
f0_ceil=self.f0_max,
|
||||
frame_period=1000 * self.hop_length / self.sampling_rate,
|
||||
)
|
||||
f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
|
||||
for index, pitch in enumerate(f0):
|
||||
f0[index] = round(pitch, 1)
|
||||
return self.interpolate_f0(self.resize_f0(f0, p_len))[0]
|
||||
|
||||
def compute_f0_uv(self, wav, p_len=None):
|
||||
if p_len is None:
|
||||
p_len = wav.shape[0] // self.hop_length
|
||||
f0, t = pyworld.dio(
|
||||
wav.astype(np.double),
|
||||
fs=self.sampling_rate,
|
||||
f0_floor=self.f0_min,
|
||||
f0_ceil=self.f0_max,
|
||||
frame_period=1000 * self.hop_length / self.sampling_rate,
|
||||
)
|
||||
f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
|
||||
for index, pitch in enumerate(f0):
|
||||
f0[index] = round(pitch, 1)
|
||||
return self.interpolate_f0(self.resize_f0(f0, p_len))
|
||||
@@ -0,0 +1,6 @@
|
||||
class F0Predictor(object):
|
||||
def compute_f0(self, wav, p_len):
|
||||
pass
|
||||
|
||||
def compute_f0_uv(self, wav, p_len):
|
||||
pass
|
||||
@@ -0,0 +1,82 @@
|
||||
from infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
|
||||
import pyworld
|
||||
import numpy as np
|
||||
|
||||
|
||||
class HarvestF0Predictor(F0Predictor):
|
||||
def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
|
||||
self.hop_length = hop_length
|
||||
self.f0_min = f0_min
|
||||
self.f0_max = f0_max
|
||||
self.sampling_rate = sampling_rate
|
||||
|
||||
def interpolate_f0(self, 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 resize_f0(self, 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(self, wav, p_len=None):
|
||||
if p_len is None:
|
||||
p_len = wav.shape[0] // self.hop_length
|
||||
f0, t = pyworld.harvest(
|
||||
wav.astype(np.double),
|
||||
fs=self.sampling_rate,
|
||||
f0_ceil=self.f0_max,
|
||||
f0_floor=self.f0_min,
|
||||
frame_period=1000 * self.hop_length / self.sampling_rate,
|
||||
)
|
||||
f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.fs)
|
||||
return self.interpolate_f0(self.resize_f0(f0, p_len))[0]
|
||||
|
||||
def compute_f0_uv(self, wav, p_len=None):
|
||||
if p_len is None:
|
||||
p_len = wav.shape[0] // self.hop_length
|
||||
f0, t = pyworld.harvest(
|
||||
wav.astype(np.double),
|
||||
fs=self.sampling_rate,
|
||||
f0_floor=self.f0_min,
|
||||
f0_ceil=self.f0_max,
|
||||
frame_period=1000 * self.hop_length / self.sampling_rate,
|
||||
)
|
||||
f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
|
||||
return self.interpolate_f0(self.resize_f0(f0, p_len))
|
||||
@@ -0,0 +1,93 @@
|
||||
from infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
|
||||
import parselmouth
|
||||
import numpy as np
|
||||
|
||||
|
||||
class PMF0Predictor(F0Predictor):
|
||||
def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
|
||||
self.hop_length = hop_length
|
||||
self.f0_min = f0_min
|
||||
self.f0_max = f0_max
|
||||
self.sampling_rate = sampling_rate
|
||||
|
||||
def interpolate_f0(self, 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(self, wav, p_len=None):
|
||||
x = wav
|
||||
if p_len is None:
|
||||
p_len = x.shape[0] // self.hop_length
|
||||
else:
|
||||
assert abs(p_len - x.shape[0] // self.hop_length) < 4, "pad length error"
|
||||
time_step = self.hop_length / self.sampling_rate * 1000
|
||||
f0 = (
|
||||
parselmouth.Sound(x, self.sampling_rate)
|
||||
.to_pitch_ac(
|
||||
time_step=time_step / 1000,
|
||||
voicing_threshold=0.6,
|
||||
pitch_floor=self.f0_min,
|
||||
pitch_ceiling=self.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, uv = self.interpolate_f0(f0)
|
||||
return f0
|
||||
|
||||
def compute_f0_uv(self, wav, p_len=None):
|
||||
x = wav
|
||||
if p_len is None:
|
||||
p_len = x.shape[0] // self.hop_length
|
||||
else:
|
||||
assert abs(p_len - x.shape[0] // self.hop_length) < 4, "pad length error"
|
||||
time_step = self.hop_length / self.sampling_rate * 1000
|
||||
f0 = (
|
||||
parselmouth.Sound(x, self.sampling_rate)
|
||||
.to_pitch_ac(
|
||||
time_step=time_step / 1000,
|
||||
voicing_threshold=0.6,
|
||||
pitch_floor=self.f0_min,
|
||||
pitch_ceiling=self.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, uv = self.interpolate_f0(f0)
|
||||
return f0, uv
|
||||
Whitespace-only changes.
@@ -0,0 +1,209 @@
|
||||
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.0,
|
||||
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.0,
|
||||
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.0,
|
||||
right=1.0,
|
||||
bottom=0.0,
|
||||
top=1.0,
|
||||
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
|
||||
@@ -0,0 +1,390 @@
|
||||
import torch.nn as nn
|
||||
import torch, numpy as np
|
||||
import torch.nn.functional as F
|
||||
from librosa.filters import mel
|
||||
|
||||
|
||||
class BiGRU(nn.Module):
|
||||
def __init__(self, input_features, hidden_features, num_layers):
|
||||
super(BiGRU, self).__init__()
|
||||
self.gru = nn.GRU(
|
||||
input_features,
|
||||
hidden_features,
|
||||
num_layers=num_layers,
|
||||
batch_first=True,
|
||||
bidirectional=True,
|
||||
)
|
||||
|
||||
def forward(self, x):
|
||||
return self.gru(x)[0]
|
||||
|
||||
|
||||
class ConvBlockRes(nn.Module):
|
||||
def __init__(self, in_channels, out_channels, momentum=0.01):
|
||||
super(ConvBlockRes, self).__init__()
|
||||
self.conv = nn.Sequential(
|
||||
nn.Conv2d(
|
||||
in_channels=in_channels,
|
||||
out_channels=out_channels,
|
||||
kernel_size=(3, 3),
|
||||
stride=(1, 1),
|
||||
padding=(1, 1),
|
||||
bias=False,
|
||||
),
|
||||
nn.BatchNorm2d(out_channels, momentum=momentum),
|
||||
nn.ReLU(),
|
||||
nn.Conv2d(
|
||||
in_channels=out_channels,
|
||||
out_channels=out_channels,
|
||||
kernel_size=(3, 3),
|
||||
stride=(1, 1),
|
||||
padding=(1, 1),
|
||||
bias=False,
|
||||
),
|
||||
nn.BatchNorm2d(out_channels, momentum=momentum),
|
||||
nn.ReLU(),
|
||||
)
|
||||
if in_channels != out_channels:
|
||||
self.shortcut = nn.Conv2d(in_channels, out_channels, (1, 1))
|
||||
self.is_shortcut = True
|
||||
else:
|
||||
self.is_shortcut = False
|
||||
|
||||
def forward(self, x):
|
||||
if self.is_shortcut:
|
||||
return self.conv(x) + self.shortcut(x)
|
||||
else:
|
||||
return self.conv(x) + x
|
||||
|
||||
|
||||
class Encoder(nn.Module):
|
||||
def __init__(
|
||||
self,
|
||||
in_channels,
|
||||
in_size,
|
||||
n_encoders,
|
||||
kernel_size,
|
||||
n_blocks,
|
||||
out_channels=16,
|
||||
momentum=0.01,
|
||||
):
|
||||
super(Encoder, self).__init__()
|
||||
self.n_encoders = n_encoders
|
||||
self.bn = nn.BatchNorm2d(in_channels, momentum=momentum)
|
||||
self.layers = nn.ModuleList()
|
||||
self.latent_channels = []
|
||||
for i in range(self.n_encoders):
|
||||
self.layers.append(
|
||||
ResEncoderBlock(
|
||||
in_channels, out_channels, kernel_size, n_blocks, momentum=momentum
|
||||
)
|
||||
)
|
||||
self.latent_channels.append([out_channels, in_size])
|
||||
in_channels = out_channels
|
||||
out_channels *= 2
|
||||
in_size //= 2
|
||||
self.out_size = in_size
|
||||
self.out_channel = out_channels
|
||||
|
||||
def forward(self, x):
|
||||
concat_tensors = []
|
||||
x = self.bn(x)
|
||||
for i in range(self.n_encoders):
|
||||
_, x = self.layers[i](x)
|
||||
concat_tensors.append(_)
|
||||
return x, concat_tensors
|
||||
|
||||
|
||||
class ResEncoderBlock(nn.Module):
|
||||
def __init__(
|
||||
self, in_channels, out_channels, kernel_size, n_blocks=1, momentum=0.01
|
||||
):
|
||||
super(ResEncoderBlock, self).__init__()
|
||||
self.n_blocks = n_blocks
|
||||
self.conv = nn.ModuleList()
|
||||
self.conv.append(ConvBlockRes(in_channels, out_channels, momentum))
|
||||
for i in range(n_blocks - 1):
|
||||
self.conv.append(ConvBlockRes(out_channels, out_channels, momentum))
|
||||
self.kernel_size = kernel_size
|
||||
if self.kernel_size is not None:
|
||||
self.pool = nn.AvgPool2d(kernel_size=kernel_size)
|
||||
|
||||
def forward(self, x):
|
||||
for i in range(self.n_blocks):
|
||||
x = self.conv[i](x)
|
||||
if self.kernel_size is not None:
|
||||
return x, self.pool(x)
|
||||
else:
|
||||
return x
|
||||
|
||||
|
||||
class Intermediate(nn.Module): #
|
||||
def __init__(self, in_channels, out_channels, n_inters, n_blocks, momentum=0.01):
|
||||
super(Intermediate, self).__init__()
|
||||
self.n_inters = n_inters
|
||||
self.layers = nn.ModuleList()
|
||||
self.layers.append(
|
||||
ResEncoderBlock(in_channels, out_channels, None, n_blocks, momentum)
|
||||
)
|
||||
for i in range(self.n_inters - 1):
|
||||
self.layers.append(
|
||||
ResEncoderBlock(out_channels, out_channels, None, n_blocks, momentum)
|
||||
)
|
||||
|
||||
def forward(self, x):
|
||||
for i in range(self.n_inters):
|
||||
x = self.layers[i](x)
|
||||
return x
|
||||
|
||||
|
||||
class ResDecoderBlock(nn.Module):
|
||||
def __init__(self, in_channels, out_channels, stride, n_blocks=1, momentum=0.01):
|
||||
super(ResDecoderBlock, self).__init__()
|
||||
out_padding = (0, 1) if stride == (1, 2) else (1, 1)
|
||||
self.n_blocks = n_blocks
|
||||
self.conv1 = nn.Sequential(
|
||||
nn.ConvTranspose2d(
|
||||
in_channels=in_channels,
|
||||
out_channels=out_channels,
|
||||
kernel_size=(3, 3),
|
||||
stride=stride,
|
||||
padding=(1, 1),
|
||||
output_padding=out_padding,
|
||||
bias=False,
|
||||
),
|
||||
nn.BatchNorm2d(out_channels, momentum=momentum),
|
||||
nn.ReLU(),
|
||||
)
|
||||
self.conv2 = nn.ModuleList()
|
||||
self.conv2.append(ConvBlockRes(out_channels * 2, out_channels, momentum))
|
||||
for i in range(n_blocks - 1):
|
||||
self.conv2.append(ConvBlockRes(out_channels, out_channels, momentum))
|
||||
|
||||
def forward(self, x, concat_tensor):
|
||||
x = self.conv1(x)
|
||||
x = torch.cat((x, concat_tensor), dim=1)
|
||||
for i in range(self.n_blocks):
|
||||
x = self.conv2[i](x)
|
||||
return x
|
||||
|
||||
|
||||
class Decoder(nn.Module):
|
||||
def __init__(self, in_channels, n_decoders, stride, n_blocks, momentum=0.01):
|
||||
super(Decoder, self).__init__()
|
||||
self.layers = nn.ModuleList()
|
||||
self.n_decoders = n_decoders
|
||||
for i in range(self.n_decoders):
|
||||
out_channels = in_channels // 2
|
||||
self.layers.append(
|
||||
ResDecoderBlock(in_channels, out_channels, stride, n_blocks, momentum)
|
||||
)
|
||||
in_channels = out_channels
|
||||
|
||||
def forward(self, x, concat_tensors):
|
||||
for i in range(self.n_decoders):
|
||||
x = self.layers[i](x, concat_tensors[-1 - i])
|
||||
return x
|
||||
|
||||
|
||||
class DeepUnet(nn.Module):
|
||||
def __init__(
|
||||
self,
|
||||
kernel_size,
|
||||
n_blocks,
|
||||
en_de_layers=5,
|
||||
inter_layers=4,
|
||||
in_channels=1,
|
||||
en_out_channels=16,
|
||||
):
|
||||
super(DeepUnet, self).__init__()
|
||||
self.encoder = Encoder(
|
||||
in_channels, 128, en_de_layers, kernel_size, n_blocks, en_out_channels
|
||||
)
|
||||
self.intermediate = Intermediate(
|
||||
self.encoder.out_channel // 2,
|
||||
self.encoder.out_channel,
|
||||
inter_layers,
|
||||
n_blocks,
|
||||
)
|
||||
self.decoder = Decoder(
|
||||
self.encoder.out_channel, en_de_layers, kernel_size, n_blocks
|
||||
)
|
||||
|
||||
def forward(self, x):
|
||||
x, concat_tensors = self.encoder(x)
|
||||
x = self.intermediate(x)
|
||||
x = self.decoder(x, concat_tensors)
|
||||
return x
|
||||
|
||||
|
||||
class E2E(nn.Module):
|
||||
def __init__(
|
||||
self,
|
||||
n_blocks,
|
||||
n_gru,
|
||||
kernel_size,
|
||||
en_de_layers=5,
|
||||
inter_layers=4,
|
||||
in_channels=1,
|
||||
en_out_channels=16,
|
||||
):
|
||||
super(E2E, self).__init__()
|
||||
self.unet = DeepUnet(
|
||||
kernel_size,
|
||||
n_blocks,
|
||||
en_de_layers,
|
||||
inter_layers,
|
||||
in_channels,
|
||||
en_out_channels,
|
||||
)
|
||||
self.cnn = nn.Conv2d(en_out_channels, 3, (3, 3), padding=(1, 1))
|
||||
if n_gru:
|
||||
self.fc = nn.Sequential(
|
||||
BiGRU(3 * 128, 256, n_gru),
|
||||
nn.Linear(512, 360),
|
||||
nn.Dropout(0.25),
|
||||
nn.Sigmoid(),
|
||||
)
|
||||
|
||||
def forward(self, mel):
|
||||
mel = mel.transpose(-1, -2).unsqueeze(1)
|
||||
x = self.cnn(self.unet(mel)).transpose(1, 2).flatten(-2)
|
||||
x = self.fc(x)
|
||||
return x
|
||||
|
||||
|
||||
class MelSpectrogram(torch.nn.Module):
|
||||
def __init__(
|
||||
self,
|
||||
is_half,
|
||||
n_mel_channels,
|
||||
sampling_rate,
|
||||
win_length,
|
||||
hop_length,
|
||||
n_fft=None,
|
||||
mel_fmin=0,
|
||||
mel_fmax=None,
|
||||
clamp=1e-5,
|
||||
):
|
||||
super().__init__()
|
||||
n_fft = win_length if n_fft is None else n_fft
|
||||
self.hann_window = {}
|
||||
mel_basis = mel(
|
||||
sr=sampling_rate,
|
||||
n_fft=n_fft,
|
||||
n_mels=n_mel_channels,
|
||||
fmin=mel_fmin,
|
||||
fmax=mel_fmax,
|
||||
htk=True,
|
||||
)
|
||||
mel_basis = torch.from_numpy(mel_basis).float()
|
||||
self.register_buffer("mel_basis", mel_basis)
|
||||
self.n_fft = win_length if n_fft is None else n_fft
|
||||
self.hop_length = hop_length
|
||||
self.win_length = win_length
|
||||
self.sampling_rate = sampling_rate
|
||||
self.n_mel_channels = n_mel_channels
|
||||
self.clamp = clamp
|
||||
self.is_half = is_half
|
||||
|
||||
def forward(self, audio, keyshift=0, speed=1, center=True):
|
||||
factor = 2 ** (keyshift / 12)
|
||||
n_fft_new = int(np.round(self.n_fft * factor))
|
||||
win_length_new = int(np.round(self.win_length * factor))
|
||||
hop_length_new = int(np.round(self.hop_length * speed))
|
||||
keyshift_key = str(keyshift) + "_" + str(audio.device)
|
||||
if keyshift_key not in self.hann_window:
|
||||
self.hann_window[keyshift_key] = torch.hann_window(win_length_new).to(
|
||||
audio.device
|
||||
)
|
||||
fft = torch.stft(
|
||||
audio,
|
||||
n_fft=n_fft_new,
|
||||
hop_length=hop_length_new,
|
||||
win_length=win_length_new,
|
||||
window=self.hann_window[keyshift_key],
|
||||
center=center,
|
||||
return_complex=True,
|
||||
)
|
||||
magnitude = torch.sqrt(fft.real.pow(2) + fft.imag.pow(2))
|
||||
if keyshift != 0:
|
||||
size = self.n_fft // 2 + 1
|
||||
resize = magnitude.size(1)
|
||||
if resize < size:
|
||||
magnitude = F.pad(magnitude, (0, 0, 0, size - resize))
|
||||
magnitude = magnitude[:, :size, :] * self.win_length / win_length_new
|
||||
mel_output = torch.matmul(self.mel_basis, magnitude)
|
||||
if self.is_half == True:
|
||||
mel_output = mel_output.half()
|
||||
log_mel_spec = torch.log(torch.clamp(mel_output, min=self.clamp))
|
||||
return log_mel_spec
|
||||
|
||||
|
||||
class RMVPE:
|
||||
def __init__(self, model_path, is_half, device=None):
|
||||
#print("RMVPE - model_path is:", model_path)
|
||||
#print("RMVPE - is_half is:", is_half)
|
||||
self.resample_kernel = {}
|
||||
model = E2E(4, 1, (2, 2))
|
||||
ckpt = torch.load(model_path, map_location="cpu")
|
||||
model.load_state_dict(ckpt)
|
||||
model.eval()
|
||||
if is_half == True:
|
||||
model = model.half()
|
||||
self.model = model
|
||||
self.resample_kernel = {}
|
||||
self.is_half = is_half
|
||||
if device is None:
|
||||
device = "cuda" if torch.cuda.is_available() else "cpu"
|
||||
self.device = device
|
||||
self.mel_extractor = MelSpectrogram(
|
||||
is_half, 128, 16000, 1024, 160, None, 30, 8000
|
||||
).to(device)
|
||||
self.model = self.model.to(device)
|
||||
cents_mapping = 20 * np.arange(360) + 1997.3794084376191
|
||||
self.cents_mapping = np.pad(cents_mapping, (4, 4)) # 368
|
||||
|
||||
def mel2hidden(self, mel):
|
||||
with torch.no_grad():
|
||||
n_frames = mel.shape[-1]
|
||||
mel = F.pad(
|
||||
mel, (0, 32 * ((n_frames - 1) // 32 + 1) - n_frames), mode="reflect"
|
||||
)
|
||||
hidden = self.model(mel)
|
||||
return hidden[:, :n_frames]
|
||||
|
||||
def decode(self, hidden, thred=0.03):
|
||||
cents_pred = self.to_local_average_cents(hidden, thred=thred)
|
||||
f0 = 10 * (2 ** (cents_pred / 1200))
|
||||
f0[f0 == 10] = 0
|
||||
return f0
|
||||
|
||||
def infer_from_audio(self, audio, thred=0.03):
|
||||
audio = torch.from_numpy(audio).float().to(self.device).unsqueeze(0)
|
||||
mel = self.mel_extractor(audio, center=True)
|
||||
hidden = self.mel2hidden(mel)
|
||||
hidden = hidden.squeeze(0).cpu().numpy()
|
||||
if self.is_half == True:
|
||||
hidden = hidden.astype("float32")
|
||||
f0 = self.decode(hidden, thred=thred)
|
||||
return f0
|
||||
|
||||
def to_local_average_cents(self, salience, thred=0.05):
|
||||
center = np.argmax(salience, axis=1)
|
||||
salience = np.pad(salience, ((0, 0), (4, 4)))
|
||||
center += 4
|
||||
todo_salience = []
|
||||
todo_cents_mapping = []
|
||||
starts = center - 4
|
||||
ends = center + 5
|
||||
for idx in range(salience.shape[0]):
|
||||
todo_salience.append(salience[:, starts[idx] : ends[idx]][idx])
|
||||
todo_cents_mapping.append(self.cents_mapping[starts[idx] : ends[idx]])
|
||||
todo_salience = np.array(todo_salience)
|
||||
todo_cents_mapping = np.array(todo_cents_mapping)
|
||||
product_sum = np.sum(todo_salience * todo_cents_mapping, 1)
|
||||
weight_sum = np.sum(todo_salience, 1)
|
||||
devided = product_sum / weight_sum
|
||||
maxx = np.max(salience, axis=1)
|
||||
devided[maxx <= thred] = 0
|
||||
return devided
|
||||
@@ -0,0 +1,76 @@
|
||||
import numpy as np
|
||||
import matplotlib.pyplot as plt
|
||||
import librosa.display
|
||||
import librosa
|
||||
|
||||
|
||||
def calculate_features(y, sr):
|
||||
stft = np.abs(librosa.stft(y))
|
||||
duration = librosa.get_duration(y=y, sr=sr)
|
||||
cent = librosa.feature.spectral_centroid(S=stft, sr=sr)[0]
|
||||
bw = librosa.feature.spectral_bandwidth(S=stft, sr=sr)[0]
|
||||
rolloff = librosa.feature.spectral_rolloff(S=stft, sr=sr)[0]
|
||||
return stft, duration, cent, bw, rolloff
|
||||
|
||||
|
||||
def plot_title(title):
|
||||
plt.suptitle(title, fontsize=16, fontweight="bold")
|
||||
|
||||
|
||||
def plot_spectrogram(y, sr, stft, duration, cmap="inferno"):
|
||||
plt.subplot(3, 1, 1)
|
||||
plt.imshow(
|
||||
librosa.amplitude_to_db(stft, ref=np.max),
|
||||
origin="lower",
|
||||
extent=[0, duration, 0, sr / 1000],
|
||||
aspect="auto",
|
||||
cmap=cmap, # Change the colormap here
|
||||
)
|
||||
plt.colorbar(format="%+2.0f dB")
|
||||
plt.xlabel("Time (s)")
|
||||
plt.ylabel("Frequency (kHz)")
|
||||
plt.title("Spectrogram")
|
||||
|
||||
|
||||
def plot_waveform(y, sr, duration):
|
||||
plt.subplot(3, 1, 2)
|
||||
librosa.display.waveshow(y, sr=sr)
|
||||
plt.xlabel("Time (s)")
|
||||
plt.ylabel("Amplitude")
|
||||
plt.title("Waveform")
|
||||
|
||||
|
||||
def plot_features(times, cent, bw, rolloff, duration):
|
||||
plt.subplot(3, 1, 3)
|
||||
plt.plot(times, cent, label="Spectral Centroid (kHz)", color="b")
|
||||
plt.plot(times, bw, label="Spectral Bandwidth (kHz)", color="g")
|
||||
plt.plot(times, rolloff, label="Spectral Rolloff (kHz)", color="r")
|
||||
plt.xlabel("Time (s)")
|
||||
plt.title("Spectral Features")
|
||||
plt.legend()
|
||||
|
||||
|
||||
def analyze_audio(audio_file, save_plot_path="logs/audio_analysis.png"):
|
||||
y, sr = librosa.load(audio_file)
|
||||
stft, duration, cent, bw, rolloff = calculate_features(y, sr)
|
||||
|
||||
plt.figure(figsize=(12, 10))
|
||||
|
||||
plot_title("Audio Analysis" + " - " + audio_file.split("/")[-1])
|
||||
plot_spectrogram(y, sr, stft, duration)
|
||||
plot_waveform(y, sr, duration)
|
||||
plot_features(librosa.times_like(cent), cent, bw, rolloff, duration)
|
||||
|
||||
plt.tight_layout()
|
||||
|
||||
if save_plot_path:
|
||||
plt.savefig(save_plot_path, bbox_inches="tight", dpi=300)
|
||||
plt.close()
|
||||
|
||||
audio_info = f"""Sample Rate: {sr}\nDuration: {(
|
||||
str(round(duration, 2)) + " seconds"
|
||||
if duration < 60
|
||||
else str(round(duration / 60, 2)) + " minutes"
|
||||
)}\nNumber of Samples: {len(y)}\nBits per Sample: {librosa.get_samplerate(audio_file)}\nChannels: {"Mono (1)" if y.ndim == 1 else "Stereo (2)"}"""
|
||||
|
||||
return audio_info, save_plot_path
|
||||
@@ -0,0 +1,409 @@
|
||||
from __future__ import print_function
|
||||
|
||||
import json
|
||||
import os
|
||||
import os.path as osp
|
||||
import re
|
||||
import warnings
|
||||
from six.moves import urllib_parse
|
||||
import shutil
|
||||
import sys
|
||||
import tempfile
|
||||
import textwrap
|
||||
import time
|
||||
|
||||
import requests
|
||||
import six
|
||||
import tqdm
|
||||
|
||||
|
||||
def indent(text, prefix):
|
||||
def prefixed_lines():
|
||||
for line in text.splitlines(True):
|
||||
yield (prefix + line if line.strip() else line)
|
||||
|
||||
return "".join(prefixed_lines())
|
||||
|
||||
|
||||
class FileURLRetrievalError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class FolderContentsMaximumLimitError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def parse_url(url, warning=True):
|
||||
"""Parse URLs especially for Google Drive links.
|
||||
|
||||
file_id: ID of file on Google Drive.
|
||||
is_download_link: Flag if it is download link of Google Drive.
|
||||
"""
|
||||
parsed = urllib_parse.urlparse(url)
|
||||
query = urllib_parse.parse_qs(parsed.query)
|
||||
is_gdrive = parsed.hostname in ["drive.google.com", "docs.google.com"]
|
||||
is_download_link = parsed.path.endswith("/uc")
|
||||
|
||||
if not is_gdrive:
|
||||
return is_gdrive, is_download_link
|
||||
|
||||
file_id = None
|
||||
if "id" in query:
|
||||
file_ids = query["id"]
|
||||
if len(file_ids) == 1:
|
||||
file_id = file_ids[0]
|
||||
else:
|
||||
patterns = [
|
||||
r"^/file/d/(.*?)/(edit|view)$",
|
||||
r"^/file/u/[0-9]+/d/(.*?)/(edit|view)$",
|
||||
r"^/document/d/(.*?)/(edit|htmlview|view)$",
|
||||
r"^/document/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
|
||||
r"^/presentation/d/(.*?)/(edit|htmlview|view)$",
|
||||
r"^/presentation/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
|
||||
r"^/spreadsheets/d/(.*?)/(edit|htmlview|view)$",
|
||||
r"^/spreadsheets/u/[0-9]+/d/(.*?)/(edit|htmlview|view)$",
|
||||
]
|
||||
for pattern in patterns:
|
||||
match = re.match(pattern, parsed.path)
|
||||
if match:
|
||||
file_id = match.groups()[0]
|
||||
break
|
||||
|
||||
if warning and not is_download_link:
|
||||
warnings.warn(
|
||||
"You specified a Google Drive link that is not the correct link "
|
||||
"to download a file. You might want to try `--fuzzy` option "
|
||||
"or the following url: {url}".format(
|
||||
url="https://drive.google.com/uc?id={}".format(file_id)
|
||||
)
|
||||
)
|
||||
|
||||
return file_id, is_download_link
|
||||
|
||||
|
||||
CHUNK_SIZE = 512 * 1024 # 512KB
|
||||
home = osp.expanduser("~")
|
||||
|
||||
|
||||
def get_url_from_gdrive_confirmation(contents):
|
||||
url = ""
|
||||
m = re.search(r'href="(\/uc\?export=download[^"]+)', contents)
|
||||
if m:
|
||||
url = "https://docs.google.com" + m.groups()[0]
|
||||
url = url.replace("&", "&")
|
||||
return url
|
||||
|
||||
m = re.search(r'href="/open\?id=([^"]+)"', contents)
|
||||
if m:
|
||||
url = m.groups()[0]
|
||||
uuid = re.search(
|
||||
r'<input\s+type="hidden"\s+name="uuid"\s+value="([^"]+)"', contents
|
||||
)
|
||||
uuid = uuid.groups()[0]
|
||||
url = (
|
||||
"https://drive.usercontent.google.com/download?id="
|
||||
+ url
|
||||
+ "&confirm=t&uuid="
|
||||
+ uuid
|
||||
)
|
||||
return url
|
||||
|
||||
m = re.search(r'"downloadUrl":"([^"]+)', contents)
|
||||
if m:
|
||||
url = m.groups()[0]
|
||||
url = url.replace("\\u003d", "=")
|
||||
url = url.replace("\\u0026", "&")
|
||||
return url
|
||||
|
||||
m = re.search(r'<p class="uc-error-subcaption">(.*)</p>', contents)
|
||||
if m:
|
||||
error = m.groups()[0]
|
||||
raise FileURLRetrievalError(error)
|
||||
|
||||
raise FileURLRetrievalError(
|
||||
"Cannot retrieve the public link of the file. "
|
||||
"You may need to change the permission to "
|
||||
"'Anyone with the link', or have had many accesses."
|
||||
)
|
||||
|
||||
|
||||
def _get_session(proxy, use_cookies, return_cookies_file=False):
|
||||
sess = requests.session()
|
||||
|
||||
sess.headers.update(
|
||||
{"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6)"}
|
||||
)
|
||||
|
||||
if proxy is not None:
|
||||
sess.proxies = {"http": proxy, "https": proxy}
|
||||
print("Using proxy:", proxy, file=sys.stderr)
|
||||
|
||||
# Load cookies if exists
|
||||
cookies_file = osp.join(home, ".cache/gdown/cookies.json")
|
||||
if osp.exists(cookies_file) and use_cookies:
|
||||
with open(cookies_file) as f:
|
||||
cookies = json.load(f)
|
||||
for k, v in cookies:
|
||||
sess.cookies[k] = v
|
||||
|
||||
if return_cookies_file:
|
||||
return sess, cookies_file
|
||||
else:
|
||||
return sess
|
||||
|
||||
|
||||
def download(
|
||||
url=None,
|
||||
output=None,
|
||||
quiet=False,
|
||||
proxy=None,
|
||||
speed=None,
|
||||
use_cookies=True,
|
||||
verify=True,
|
||||
id=None,
|
||||
fuzzy=True,
|
||||
resume=False,
|
||||
format=None,
|
||||
):
|
||||
"""Download file from URL.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
url: str
|
||||
URL. Google Drive URL is also supported.
|
||||
output: str
|
||||
Output filename. Default is basename of URL.
|
||||
quiet: bool
|
||||
Suppress terminal output. Default is False.
|
||||
proxy: str
|
||||
Proxy.
|
||||
speed: float
|
||||
Download byte size per second (e.g., 256KB/s = 256 * 1024).
|
||||
use_cookies: bool
|
||||
Flag to use cookies. Default is True.
|
||||
verify: bool or string
|
||||
Either a bool, in which case it controls whether the server's TLS
|
||||
certificate is verified, or a string, in which case it must be a path
|
||||
to a CA bundle to use. Default is True.
|
||||
id: str
|
||||
Google Drive's file ID.
|
||||
fuzzy: bool
|
||||
Fuzzy extraction of Google Drive's file Id. Default is False.
|
||||
resume: bool
|
||||
Resume the download from existing tmp file if possible.
|
||||
Default is False.
|
||||
format: str, optional
|
||||
Format of Google Docs, Spreadsheets and Slides. Default is:
|
||||
- Google Docs: 'docx'
|
||||
- Google Spreadsheet: 'xlsx'
|
||||
- Google Slides: 'pptx'
|
||||
|
||||
Returns
|
||||
-------
|
||||
output: str
|
||||
Output filename.
|
||||
"""
|
||||
if not (id is None) ^ (url is None):
|
||||
raise ValueError("Either url or id has to be specified")
|
||||
if id is not None:
|
||||
url = "https://drive.google.com/uc?id={id}".format(id=id)
|
||||
|
||||
url_origin = url
|
||||
|
||||
sess, cookies_file = _get_session(
|
||||
proxy=proxy, use_cookies=use_cookies, return_cookies_file=True
|
||||
)
|
||||
|
||||
gdrive_file_id, is_gdrive_download_link = parse_url(url, warning=not fuzzy)
|
||||
|
||||
if fuzzy and gdrive_file_id:
|
||||
# overwrite the url with fuzzy match of a file id
|
||||
url = "https://drive.google.com/uc?id={id}".format(id=gdrive_file_id)
|
||||
url_origin = url
|
||||
is_gdrive_download_link = True
|
||||
|
||||
while True:
|
||||
res = sess.get(url, stream=True, verify=verify)
|
||||
|
||||
if url == url_origin and res.status_code == 500:
|
||||
# The file could be Google Docs or Spreadsheets.
|
||||
url = "https://drive.google.com/open?id={id}".format(id=gdrive_file_id)
|
||||
continue
|
||||
|
||||
if res.headers["Content-Type"].startswith("text/html"):
|
||||
m = re.search("<title>(.+)</title>", res.text)
|
||||
if m and m.groups()[0].endswith(" - Google Docs"):
|
||||
url = (
|
||||
"https://docs.google.com/document/d/{id}/export"
|
||||
"?format={format}".format(
|
||||
id=gdrive_file_id,
|
||||
format="docx" if format is None else format,
|
||||
)
|
||||
)
|
||||
continue
|
||||
elif m and m.groups()[0].endswith(" - Google Sheets"):
|
||||
url = (
|
||||
"https://docs.google.com/spreadsheets/d/{id}/export"
|
||||
"?format={format}".format(
|
||||
id=gdrive_file_id,
|
||||
format="xlsx" if format is None else format,
|
||||
)
|
||||
)
|
||||
continue
|
||||
elif m and m.groups()[0].endswith(" - Google Slides"):
|
||||
url = (
|
||||
"https://docs.google.com/presentation/d/{id}/export"
|
||||
"?format={format}".format(
|
||||
id=gdrive_file_id,
|
||||
format="pptx" if format is None else format,
|
||||
)
|
||||
)
|
||||
continue
|
||||
elif (
|
||||
"Content-Disposition" in res.headers
|
||||
and res.headers["Content-Disposition"].endswith("pptx")
|
||||
and format not in {None, "pptx"}
|
||||
):
|
||||
url = (
|
||||
"https://docs.google.com/presentation/d/{id}/export"
|
||||
"?format={format}".format(
|
||||
id=gdrive_file_id,
|
||||
format="pptx" if format is None else format,
|
||||
)
|
||||
)
|
||||
continue
|
||||
|
||||
if use_cookies:
|
||||
if not osp.exists(osp.dirname(cookies_file)):
|
||||
os.makedirs(osp.dirname(cookies_file))
|
||||
# Save cookies
|
||||
with open(cookies_file, "w") as f:
|
||||
cookies = [
|
||||
(k, v)
|
||||
for k, v in sess.cookies.items()
|
||||
if not k.startswith("download_warning_")
|
||||
]
|
||||
json.dump(cookies, f, indent=2)
|
||||
|
||||
if "Content-Disposition" in res.headers:
|
||||
# This is the file
|
||||
break
|
||||
if not (gdrive_file_id and is_gdrive_download_link):
|
||||
break
|
||||
|
||||
# Need to redirect with confirmation
|
||||
try:
|
||||
url = get_url_from_gdrive_confirmation(res.text)
|
||||
except FileURLRetrievalError as e:
|
||||
message = (
|
||||
"Failed to retrieve file url:\n\n{}\n\n"
|
||||
"You may still be able to access the file from the browser:"
|
||||
"\n\n\t{}\n\n"
|
||||
"but Gdown can't. Please check connections and permissions."
|
||||
).format(
|
||||
indent("\n".join(textwrap.wrap(str(e))), prefix="\t"),
|
||||
url_origin,
|
||||
)
|
||||
raise FileURLRetrievalError(message)
|
||||
|
||||
if gdrive_file_id and is_gdrive_download_link:
|
||||
content_disposition = six.moves.urllib_parse.unquote(
|
||||
res.headers["Content-Disposition"]
|
||||
)
|
||||
|
||||
m = re.search(r"filename\*=UTF-8''(.*)", content_disposition)
|
||||
if not m:
|
||||
m = re.search(r'filename=["\']?(.*?)["\']?$', content_disposition)
|
||||
filename_from_url = m.groups()[0]
|
||||
filename_from_url = filename_from_url.replace(osp.sep, "_")
|
||||
else:
|
||||
filename_from_url = osp.basename(url)
|
||||
|
||||
if output is None:
|
||||
output = filename_from_url
|
||||
|
||||
output_is_path = isinstance(output, six.string_types)
|
||||
if output_is_path and output.endswith(osp.sep):
|
||||
if not osp.exists(output):
|
||||
os.makedirs(output)
|
||||
output = osp.join(output, filename_from_url)
|
||||
|
||||
if output_is_path:
|
||||
existing_tmp_files = []
|
||||
for file in os.listdir(osp.dirname(output) or "."):
|
||||
if file.startswith(osp.basename(output)):
|
||||
existing_tmp_files.append(osp.join(osp.dirname(output), file))
|
||||
if resume and existing_tmp_files:
|
||||
if len(existing_tmp_files) != 1:
|
||||
print(
|
||||
"There are multiple temporary files to resume:",
|
||||
file=sys.stderr,
|
||||
)
|
||||
print("\n")
|
||||
for file in existing_tmp_files:
|
||||
print("\t", file, file=sys.stderr)
|
||||
print("\n")
|
||||
print(
|
||||
"Please remove them except one to resume downloading.",
|
||||
file=sys.stderr,
|
||||
)
|
||||
return
|
||||
tmp_file = existing_tmp_files[0]
|
||||
else:
|
||||
resume = False
|
||||
# mkstemp is preferred, but does not work on Windows
|
||||
# https://github.com/wkentaro/gdown/issues/153
|
||||
tmp_file = tempfile.mktemp(
|
||||
suffix=tempfile.template,
|
||||
prefix=osp.basename(output),
|
||||
dir=osp.dirname(output),
|
||||
)
|
||||
f = open(tmp_file, "ab")
|
||||
else:
|
||||
tmp_file = None
|
||||
f = output
|
||||
|
||||
if tmp_file is not None and f.tell() != 0:
|
||||
headers = {"Range": "bytes={}-".format(f.tell())}
|
||||
res = sess.get(url, headers=headers, stream=True, verify=verify)
|
||||
|
||||
if not quiet:
|
||||
# print("Downloading...", file=sys.stderr)
|
||||
if resume:
|
||||
print("Resume:", tmp_file, file=sys.stderr)
|
||||
# if url_origin != url:
|
||||
# print("From (original):", url_origin, file=sys.stderr)
|
||||
# print("From (redirected):", url, file=sys.stderr)
|
||||
# else:
|
||||
# print("From:", url, file=sys.stderr)
|
||||
print(
|
||||
"To:",
|
||||
osp.abspath(output) if output_is_path else output,
|
||||
file=sys.stderr,
|
||||
)
|
||||
|
||||
try:
|
||||
total = res.headers.get("Content-Length")
|
||||
if total is not None:
|
||||
total = int(total)
|
||||
if not quiet:
|
||||
pbar = tqdm.tqdm(total=total, unit="B", unit_scale=True)
|
||||
t_start = time.time()
|
||||
for chunk in res.iter_content(chunk_size=CHUNK_SIZE):
|
||||
f.write(chunk)
|
||||
if not quiet:
|
||||
pbar.update(len(chunk))
|
||||
if speed is not None:
|
||||
elapsed_time_expected = 1.0 * pbar.n / speed
|
||||
elapsed_time = time.time() - t_start
|
||||
if elapsed_time < elapsed_time_expected:
|
||||
time.sleep(elapsed_time_expected - elapsed_time)
|
||||
if not quiet:
|
||||
pbar.close()
|
||||
if tmp_file:
|
||||
f.close()
|
||||
shutil.move(tmp_file, output)
|
||||
finally:
|
||||
sess.close()
|
||||
|
||||
return output
|
||||
@@ -0,0 +1,16 @@
|
||||
import time
|
||||
from tensorboard import program
|
||||
|
||||
log_path = "logs"
|
||||
|
||||
|
||||
def launch_tensorboard_pipeline():
|
||||
tb = program.TensorBoard()
|
||||
tb.configure(argv=[None, "--logdir", log_path])
|
||||
url = tb.launch()
|
||||
print(
|
||||
f"Access the tensorboard using the following link:\n{url}?pinnedCards=%5B%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Ftotal%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fd%2Ftotal%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Fkl%22%7D%2C%7B%22plugin%22%3A%22scalars%22%2C%22tag%22%3A%22loss%2Fg%2Fmel%22%7D%5D"
|
||||
)
|
||||
|
||||
while True:
|
||||
time.sleep(600)
|
||||
@@ -0,0 +1,353 @@
|
||||
import os
|
||||
import sys
|
||||
import wget
|
||||
import zipfile
|
||||
from bs4 import BeautifulSoup
|
||||
import requests
|
||||
from urllib.parse import unquote, urlencode, parse_qs, urlparse
|
||||
import re
|
||||
import shutil
|
||||
import six
|
||||
|
||||
|
||||
def find_folder_parent(search_dir, folder_name):
|
||||
for dirpath, dirnames, _ in os.walk(search_dir):
|
||||
if folder_name in dirnames:
|
||||
return os.path.abspath(dirpath)
|
||||
return None
|
||||
|
||||
|
||||
now_dir = os.getcwd()
|
||||
sys.path.append(now_dir)
|
||||
|
||||
from rvc.lib.utils import format_title
|
||||
|
||||
from rvc.lib.tools import gdown
|
||||
|
||||
file_path = find_folder_parent(now_dir, "logs")
|
||||
|
||||
zips_path = os.getcwd() + "/logs/zips"
|
||||
|
||||
|
||||
def search_pth_index(folder):
|
||||
pth_paths = [
|
||||
os.path.join(folder, file)
|
||||
for file in os.listdir(folder)
|
||||
if os.path.isfile(os.path.join(folder, file)) and file.endswith(".pth")
|
||||
]
|
||||
index_paths = [
|
||||
os.path.join(folder, file)
|
||||
for file in os.listdir(folder)
|
||||
if os.path.isfile(os.path.join(folder, file)) and file.endswith(".index")
|
||||
]
|
||||
|
||||
return pth_paths, index_paths
|
||||
|
||||
|
||||
def get_mediafire_download_link(url):
|
||||
response = requests.get(url)
|
||||
response.raise_for_status()
|
||||
soup = BeautifulSoup(response.text, "html.parser")
|
||||
download_button = soup.find(
|
||||
"a", {"class": "input popsok", "aria-label": "Download file"}
|
||||
)
|
||||
if download_button:
|
||||
download_link = download_button.get("href")
|
||||
return download_link
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def download_from_url(url):
|
||||
os.makedirs(zips_path, exist_ok=True)
|
||||
if url != "":
|
||||
if "drive.google.com" in url:
|
||||
if "file/d/" in url:
|
||||
file_id = url.split("file/d/")[1].split("/")[0]
|
||||
elif "id=" in url:
|
||||
file_id = url.split("id=")[1].split("&")[0]
|
||||
else:
|
||||
return None
|
||||
|
||||
if file_id:
|
||||
os.chdir(zips_path)
|
||||
try:
|
||||
gdown.download(
|
||||
f"https://drive.google.com/uc?id={file_id}",
|
||||
quiet=True,
|
||||
fuzzy=True,
|
||||
)
|
||||
except Exception as error:
|
||||
error_message = str(error)
|
||||
if (
|
||||
"Too many users have viewed or downloaded this file recently"
|
||||
in error_message
|
||||
):
|
||||
os.chdir(now_dir)
|
||||
return "too much use"
|
||||
elif (
|
||||
"Cannot retrieve the public link of the file." in error_message
|
||||
):
|
||||
os.chdir(now_dir)
|
||||
return "private link"
|
||||
else:
|
||||
print(error_message)
|
||||
os.chdir(now_dir)
|
||||
return None
|
||||
elif "disk.yandex.ru" in url:
|
||||
base_url = "https://cloud-api.yandex.net/v1/disk/public/resources/download?"
|
||||
public_key = url
|
||||
final_url = base_url + urlencode(dict(public_key=public_key))
|
||||
response = requests.get(final_url)
|
||||
download_url = response.json()["href"]
|
||||
download_response = requests.get(download_url)
|
||||
|
||||
if download_response.status_code == 200:
|
||||
filename = parse_qs(urlparse(unquote(download_url)).query).get(
|
||||
"filename", [""]
|
||||
)[0]
|
||||
if filename:
|
||||
os.chdir(zips_path)
|
||||
with open(filename, "wb") as f:
|
||||
f.write(download_response.content)
|
||||
else:
|
||||
print("Failed to get filename from URL.")
|
||||
return None
|
||||
|
||||
elif "pixeldrain.com" in url:
|
||||
try:
|
||||
file_id = url.split("pixeldrain.com/u/")[1]
|
||||
os.chdir(zips_path)
|
||||
print(file_id)
|
||||
response = requests.get(f"https://pixeldrain.com/api/file/{file_id}")
|
||||
if response.status_code == 200:
|
||||
file_name = (
|
||||
response.headers.get("Content-Disposition")
|
||||
.split("filename=")[-1]
|
||||
.strip('";')
|
||||
)
|
||||
os.makedirs(zips_path, exist_ok=True)
|
||||
with open(os.path.join(zips_path, file_name), "wb") as newfile:
|
||||
newfile.write(response.content)
|
||||
os.chdir(file_path)
|
||||
return "downloaded"
|
||||
else:
|
||||
os.chdir(file_path)
|
||||
return None
|
||||
except Exception as e:
|
||||
print(e)
|
||||
os.chdir(file_path)
|
||||
return None
|
||||
|
||||
elif "cdn.discordapp.com" in url:
|
||||
file = requests.get(url)
|
||||
os.chdir(zips_path)
|
||||
if file.status_code == 200:
|
||||
name = url.split("/")
|
||||
with open(os.path.join(name[-1]), "wb") as newfile:
|
||||
newfile.write(file.content)
|
||||
else:
|
||||
return None
|
||||
elif "/blob/" in url or "/resolve/" in url:
|
||||
os.chdir(zips_path)
|
||||
if "/blob/" in url:
|
||||
url = url.replace("/blob/", "/resolve/")
|
||||
|
||||
response = requests.get(url, stream=True)
|
||||
if response.status_code == 200:
|
||||
content_disposition = six.moves.urllib_parse.unquote(
|
||||
response.headers["Content-Disposition"]
|
||||
)
|
||||
m = re.search(r'filename="([^"]+)"', content_disposition)
|
||||
file_name = m.groups()[0]
|
||||
file_name = file_name.replace(os.path.sep, "_")
|
||||
total_size_in_bytes = int(response.headers.get("content-length", 0))
|
||||
block_size = 1024
|
||||
progress_bar_length = 50
|
||||
progress = 0
|
||||
|
||||
with open(os.path.join(zips_path, file_name), "wb") as file:
|
||||
for data in response.iter_content(block_size):
|
||||
file.write(data)
|
||||
progress += len(data)
|
||||
progress_percent = int((progress / total_size_in_bytes) * 100)
|
||||
num_dots = int(
|
||||
(progress / total_size_in_bytes) * progress_bar_length
|
||||
)
|
||||
progress_bar = (
|
||||
"["
|
||||
+ "." * num_dots
|
||||
+ " " * (progress_bar_length - num_dots)
|
||||
+ "]"
|
||||
)
|
||||
print(
|
||||
f"{progress_percent}% {progress_bar} {progress}/{total_size_in_bytes} ",
|
||||
end="\r",
|
||||
)
|
||||
if progress_percent == 100:
|
||||
print("\n")
|
||||
|
||||
else:
|
||||
os.chdir(now_dir)
|
||||
return None
|
||||
elif "/tree/main" in url:
|
||||
os.chdir(zips_path)
|
||||
response = requests.get(url)
|
||||
soup = BeautifulSoup(response.content, "html.parser")
|
||||
temp_url = ""
|
||||
for link in soup.find_all("a", href=True):
|
||||
if link["href"].endswith(".zip"):
|
||||
temp_url = link["href"]
|
||||
break
|
||||
if temp_url:
|
||||
url = temp_url
|
||||
url = url.replace("blob", "resolve")
|
||||
if "huggingface.co" not in url:
|
||||
url = "https://huggingface.co" + url
|
||||
|
||||
wget.download(url)
|
||||
else:
|
||||
os.chdir(now_dir)
|
||||
return None
|
||||
|
||||
params = {"id": f"eq.{id_number}"}
|
||||
response = requests.get(url, headers=headers, params=params)
|
||||
if response.status_code == 200:
|
||||
json_response = response.json()
|
||||
print(json_response)
|
||||
if json_response:
|
||||
link = json_response[0]["link"]
|
||||
verify = download_from_url(link)
|
||||
if verify == "downloaded":
|
||||
return "downloaded"
|
||||
else:
|
||||
return None
|
||||
else:
|
||||
return None
|
||||
else:
|
||||
try:
|
||||
os.chdir(zips_path)
|
||||
wget.download(url)
|
||||
except Exception as error:
|
||||
os.chdir(now_dir)
|
||||
print(error)
|
||||
return None
|
||||
|
||||
for currentPath, _, zipFiles in os.walk(zips_path):
|
||||
for Files in zipFiles:
|
||||
filePart = Files.split(".")
|
||||
extensionFile = filePart[len(filePart) - 1]
|
||||
filePart.pop()
|
||||
nameFile = "_".join(filePart)
|
||||
realPath = os.path.join(currentPath, Files)
|
||||
os.rename(realPath, nameFile + "." + extensionFile)
|
||||
|
||||
os.chdir(now_dir)
|
||||
return "downloaded"
|
||||
|
||||
os.chdir(now_dir)
|
||||
return None
|
||||
|
||||
|
||||
def extract_and_show_progress(zipfile_path, unzips_path):
|
||||
try:
|
||||
with zipfile.ZipFile(zipfile_path, "r") as zip_ref:
|
||||
for file_info in zip_ref.infolist():
|
||||
zip_ref.extract(file_info, unzips_path)
|
||||
os.remove(zipfile_path)
|
||||
return True
|
||||
except Exception as error:
|
||||
print(error)
|
||||
return False
|
||||
|
||||
|
||||
def unzip_file(zip_path, zip_file_name):
|
||||
zip_file_path = os.path.join(zip_path, zip_file_name + ".zip")
|
||||
extract_path = os.path.join(file_path, zip_file_name)
|
||||
with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
|
||||
zip_ref.extractall(extract_path)
|
||||
os.remove(zip_file_path)
|
||||
|
||||
|
||||
def model_download_pipeline(url):
|
||||
verify = download_from_url(url)
|
||||
if verify == "downloaded":
|
||||
extract_folder_path = ""
|
||||
for filename in os.listdir(zips_path):
|
||||
if filename.endswith(".zip"):
|
||||
zipfile_path = os.path.join(zips_path, filename)
|
||||
print("Proceeding with the extraction...")
|
||||
|
||||
model_zip = os.path.basename(zipfile_path)
|
||||
model_name = format_title(model_zip.split(".zip")[0])
|
||||
extract_folder_path = os.path.join(
|
||||
"logs",
|
||||
os.path.normpath(model_name),
|
||||
)
|
||||
|
||||
success = extract_and_show_progress(zipfile_path, extract_folder_path)
|
||||
|
||||
subfolders = [
|
||||
f
|
||||
for f in os.listdir(extract_folder_path)
|
||||
if os.path.isdir(os.path.join(extract_folder_path, f))
|
||||
]
|
||||
if len(subfolders) == 1:
|
||||
subfolder_path = os.path.join(extract_folder_path, subfolders[0])
|
||||
for item in os.listdir(subfolder_path):
|
||||
s = os.path.join(subfolder_path, item)
|
||||
d = os.path.join(extract_folder_path, item)
|
||||
shutil.move(s, d)
|
||||
os.rmdir(subfolder_path)
|
||||
|
||||
for item in os.listdir(extract_folder_path):
|
||||
if ".pth" in item:
|
||||
file_name = item.split(".pth")[0]
|
||||
if file_name != model_name:
|
||||
os.rename(
|
||||
os.path.join(extract_folder_path, item),
|
||||
os.path.join(extract_folder_path, model_name + ".pth"),
|
||||
)
|
||||
else:
|
||||
if "v2" not in item:
|
||||
file_name = item.split("_nprobe_1_")[1].split("_v1")[0]
|
||||
if file_name != model_name:
|
||||
new_file_name = (
|
||||
item.split("_nprobe_1_")[0]
|
||||
+ "_nprobe_1_"
|
||||
+ model_name
|
||||
+ "_v1"
|
||||
)
|
||||
os.rename(
|
||||
os.path.join(extract_folder_path, item),
|
||||
os.path.join(
|
||||
extract_folder_path, new_file_name + ".index"
|
||||
),
|
||||
)
|
||||
else:
|
||||
file_name = item.split("_nprobe_1_")[1].split("_v2")[0]
|
||||
if file_name != model_name:
|
||||
new_file_name = (
|
||||
item.split("_nprobe_1_")[0]
|
||||
+ "_nprobe_1_"
|
||||
+ model_name
|
||||
+ "_v2"
|
||||
)
|
||||
os.rename(
|
||||
os.path.join(extract_folder_path, item),
|
||||
os.path.join(
|
||||
extract_folder_path, new_file_name + ".index"
|
||||
),
|
||||
)
|
||||
|
||||
if success:
|
||||
print(f"Model {model_name} downloaded!")
|
||||
else:
|
||||
print(f"Error downloading {model_name}")
|
||||
sys.exit()
|
||||
if extract_folder_path == "":
|
||||
print("Zip file was not found.")
|
||||
sys.exit()
|
||||
result = search_pth_index(extract_folder_path)
|
||||
else:
|
||||
message = "Error"
|
||||
@@ -0,0 +1,96 @@
|
||||
import os
|
||||
import wget
|
||||
|
||||
url_base = "https://huggingface.co/nolinkhere"
|
||||
pretraineds_v1_list = [
|
||||
(
|
||||
"pretrained_v1/",
|
||||
[
|
||||
"D32k.pth",
|
||||
"D40k.pth",
|
||||
"D48k.pth",
|
||||
"G32k.pth",
|
||||
"G40k.pth",
|
||||
"G48k.pth",
|
||||
"f0D32k.pth",
|
||||
"f0D40k.pth",
|
||||
"f0D48k.pth",
|
||||
"f0G32k.pth",
|
||||
"f0G40k.pth",
|
||||
"f0G48k.pth",
|
||||
],
|
||||
),
|
||||
]
|
||||
pretraineds_v2_list = [
|
||||
(
|
||||
"pretrained_v2/",
|
||||
[
|
||||
"D32k.pth",
|
||||
"D40k.pth",
|
||||
"D48k.pth",
|
||||
"G32k.pth",
|
||||
"G40k.pth",
|
||||
"G48k.pth",
|
||||
"f0D32k.pth",
|
||||
"f0D40k.pth",
|
||||
"f0D48k.pth",
|
||||
"f0G32k.pth",
|
||||
"f0G40k.pth",
|
||||
"f0G48k.pth",
|
||||
],
|
||||
),
|
||||
]
|
||||
|
||||
models_list = [
|
||||
"hubert_base.pt",
|
||||
"contentvec_base.pt",
|
||||
"rmvpe.pt",
|
||||
"fcpe.pt",
|
||||
# "rmvpe.onnx"
|
||||
]
|
||||
|
||||
executables_list = ["ffmpeg.exe", "ffprobe.exe"]
|
||||
|
||||
folder_mapping_list = {
|
||||
"pretrained_v1/": "rvc/pretraineds/pretrained_v1/",
|
||||
"pretrained_v2/": "rvc/pretraineds/pretrained_v2/",
|
||||
}
|
||||
|
||||
|
||||
def prequisites_download_pipeline(pretraineds_v1, pretraineds_v2, models, exe):
|
||||
def download_files(file_list):
|
||||
for file_name in file_list:
|
||||
destination_path = os.path.join(file_name)
|
||||
url = f"{url_base}/{file_name}"
|
||||
if not os.path.exists(destination_path):
|
||||
os.makedirs(os.path.dirname(destination_path) or ".", exist_ok=True)
|
||||
print(f"\nDownloading {url} to {destination_path}...")
|
||||
wget.download(url, out=destination_path)
|
||||
|
||||
if models == "True":
|
||||
download_files(models_list)
|
||||
|
||||
if exe == "True" and os.name == "nt":
|
||||
download_files(executables_list)
|
||||
|
||||
if pretraineds_v1 == "True":
|
||||
for remote_folder, file_list in pretraineds_v1_list:
|
||||
local_folder = folder_mapping_list.get(remote_folder, "")
|
||||
for file in file_list:
|
||||
destination_path = os.path.join(local_folder, file)
|
||||
url = f"{url_base}/{remote_folder}{file}"
|
||||
if not os.path.exists(destination_path):
|
||||
os.makedirs(os.path.dirname(destination_path) or ".", exist_ok=True)
|
||||
print(f"\nDownloading {url} to {destination_path}...")
|
||||
wget.download(url, out=destination_path)
|
||||
|
||||
if pretraineds_v2 == "True":
|
||||
for remote_folder, file_list in pretraineds_v2_list:
|
||||
local_folder = folder_mapping_list.get(remote_folder, "")
|
||||
for file in file_list:
|
||||
destination_path = os.path.join(local_folder, file)
|
||||
url = f"{url_base}/{remote_folder}{file}"
|
||||
if not os.path.exists(destination_path):
|
||||
os.makedirs(os.path.dirname(destination_path) or ".", exist_ok=True)
|
||||
print(f"\nDownloading {url} to {destination_path}...")
|
||||
wget.download(url, out=destination_path)
|
||||
@@ -0,0 +1,63 @@
|
||||
def pretrained_selector(pitch_guidance):
|
||||
if pitch_guidance:
|
||||
return {
|
||||
"v1": {
|
||||
"32000": (
|
||||
"rvc/pretraineds/pretrained_v1/f0G32k.pth",
|
||||
"rvc/pretraineds/pretrained_v1/f0D32k.pth",
|
||||
),
|
||||
"40000": (
|
||||
"rvc/pretraineds/pretrained_v1/f0G40k.pth",
|
||||
"rvc/pretraineds/pretrained_v1/f0D40k.pth",
|
||||
),
|
||||
"48000": (
|
||||
"rvc/pretraineds/pretrained_v1/f0G48k.pth",
|
||||
"rvc/pretraineds/pretrained_v1/f0D48k.pth",
|
||||
),
|
||||
},
|
||||
"v2": {
|
||||
"32000": (
|
||||
"rvc/pretraineds/pretrained_v2/f0G32k.pth",
|
||||
"rvc/pretraineds/pretrained_v2/f0D32k.pth",
|
||||
),
|
||||
"40000": (
|
||||
"rvc/pretraineds/pretrained_v2/f0G40k.pth",
|
||||
"rvc/pretraineds/pretrained_v2/f0D40k.pth",
|
||||
),
|
||||
"48000": (
|
||||
"rvc/pretraineds/pretrained_v2/f0G48k.pth",
|
||||
"rvc/pretraineds/pretrained_v2/f0D48k.pth",
|
||||
),
|
||||
},
|
||||
}
|
||||
else:
|
||||
return {
|
||||
"v1": {
|
||||
"32000": (
|
||||
"rvc/pretraineds/pretrained_v1/G32k.pth",
|
||||
"rvc/pretraineds/pretrained_v1/D32k.pth",
|
||||
),
|
||||
"40000": (
|
||||
"rvc/pretraineds/pretrained_v1/G40k.pth",
|
||||
"rvc/pretraineds/pretrained_v1/D40k.pth",
|
||||
),
|
||||
"48000": (
|
||||
"rvc/pretraineds/pretrained_v1/G48k.pth",
|
||||
"rvc/pretraineds/pretrained_v1/D48k.pth",
|
||||
),
|
||||
},
|
||||
"v2": {
|
||||
"32000": (
|
||||
"rvc/pretraineds/pretrained_v2/G32k.pth",
|
||||
"rvc/pretraineds/pretrained_v2/D32k.pth",
|
||||
),
|
||||
"40000": (
|
||||
"rvc/pretraineds/pretrained_v2/G40k.pth",
|
||||
"rvc/pretraineds/pretrained_v2/D40k.pth",
|
||||
),
|
||||
"48000": (
|
||||
"rvc/pretraineds/pretrained_v2/G48k.pth",
|
||||
"rvc/pretraineds/pretrained_v2/D48k.pth",
|
||||
),
|
||||
},
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
from pydub.silence import detect_nonsilent
|
||||
from pydub import AudioSegment
|
||||
import numpy as np
|
||||
import re
|
||||
import os
|
||||
|
||||
from ...lib.utils import format_title
|
||||
|
||||
|
||||
def process_audio(file_path):
|
||||
try:
|
||||
# load audio file
|
||||
song = AudioSegment.from_file(file_path)
|
||||
|
||||
# set silence threshold and duration
|
||||
silence_thresh = -70 # dB
|
||||
min_silence_len = 750 # ms, adjust as needed
|
||||
|
||||
# detect nonsilent parts
|
||||
nonsilent_parts = detect_nonsilent(
|
||||
song, min_silence_len=min_silence_len, silence_thresh=silence_thresh
|
||||
)
|
||||
|
||||
# Create a new directory to store chunks
|
||||
file_dir = os.path.dirname(file_path)
|
||||
file_name = os.path.basename(file_path).split(".")[0]
|
||||
file_name = format_title(file_name)
|
||||
new_dir_path = os.path.join(file_dir, file_name)
|
||||
os.makedirs(new_dir_path, exist_ok=True)
|
||||
|
||||
# Check if timestamps file exists, if so delete it
|
||||
timestamps_file = os.path.join(file_dir, f"{file_name}_timestamps.txt")
|
||||
if os.path.isfile(timestamps_file):
|
||||
os.remove(timestamps_file)
|
||||
|
||||
# export chunks and save start times
|
||||
segment_count = 0
|
||||
for i, (start_i, end_i) in enumerate(nonsilent_parts):
|
||||
chunk = song[start_i:end_i]
|
||||
chunk_file_path = os.path.join(new_dir_path, f"chunk{i}.wav")
|
||||
chunk.export(chunk_file_path, format="wav")
|
||||
|
||||
print(f"Segment {i} created!")
|
||||
segment_count += 1
|
||||
|
||||
# write start times to file
|
||||
with open(timestamps_file, "a", encoding="utf-8") as f:
|
||||
f.write(f"{chunk_file_path} starts at {start_i} ms\n")
|
||||
|
||||
print(f"Total segments created: {segment_count}")
|
||||
print(f"Split all chunks for {file_path} successfully!")
|
||||
|
||||
return "Finish", new_dir_path
|
||||
|
||||
except Exception as e:
|
||||
print(f"An error occurred: {e}")
|
||||
return "Error", None
|
||||
|
||||
|
||||
def merge_audio(timestamps_file):
|
||||
try:
|
||||
# Extract prefix from the timestamps filename
|
||||
prefix = os.path.basename(timestamps_file).replace("_timestamps.txt", "")
|
||||
timestamps_dir = os.path.dirname(timestamps_file)
|
||||
|
||||
# Open the timestamps file
|
||||
with open(timestamps_file, "r", encoding="utf-8") as f:
|
||||
lines = f.readlines()
|
||||
|
||||
# Initialize empty list to hold audio segments
|
||||
audio_segments = []
|
||||
last_end_time = 0
|
||||
|
||||
print(f"Processing file: {timestamps_file}")
|
||||
|
||||
for line in lines:
|
||||
# Extract filename and start time from line
|
||||
match = re.search(r"(chunk\d+.wav) starts at (\d+) ms", line)
|
||||
if match:
|
||||
filename, start_time = match.groups()
|
||||
start_time = int(start_time)
|
||||
|
||||
# Construct the complete path to the chunk file
|
||||
chunk_file = os.path.join(timestamps_dir, prefix, filename)
|
||||
|
||||
# Add silence from last_end_time to start_time
|
||||
silence_duration = max(start_time - last_end_time, 0)
|
||||
silence = AudioSegment.silent(duration=silence_duration)
|
||||
audio_segments.append(silence)
|
||||
|
||||
# Load audio file and append to list
|
||||
audio = AudioSegment.from_wav(chunk_file)
|
||||
audio_segments.append(audio)
|
||||
|
||||
# Update last_end_time
|
||||
last_end_time = start_time + len(audio)
|
||||
|
||||
print(f"Processed chunk: {chunk_file}")
|
||||
|
||||
# Concatenate all audio_segments and export
|
||||
merged_audio = sum(audio_segments)
|
||||
merged_audio_np = np.array(merged_audio.get_array_of_samples())
|
||||
# print(f"Exported merged file: {merged_filename}\n")
|
||||
return merged_audio.frame_rate, merged_audio_np
|
||||
|
||||
except Exception as e:
|
||||
print(f"An error occurred: {e}")
|
||||
@@ -0,0 +1,19 @@
|
||||
import sys
|
||||
import asyncio
|
||||
import edge_tts
|
||||
|
||||
|
||||
async def main():
|
||||
text = sys.argv[1]
|
||||
voice = sys.argv[2]
|
||||
rate = int(sys.argv[3])
|
||||
output_file = sys.argv[4]
|
||||
|
||||
rates = f"+{rate}%" if rate >= 0 else f"{rate}%"
|
||||
|
||||
await edge_tts.Communicate(text, voice, rate=rates).save(output_file)
|
||||
print(f"TTS with {voice} completed. Output TTS file: '{output_file}'")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,87 @@
|
||||
import numpy as np
|
||||
import re
|
||||
import unicodedata
|
||||
from fairseq import checkpoint_utils
|
||||
|
||||
import logging
|
||||
|
||||
logging.getLogger("fairseq").setLevel(logging.WARNING)
|
||||
import sys
|
||||
import os
|
||||
import numpy as np
|
||||
import asyncio
|
||||
from ffmpeg.asyncio import FFmpeg
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
|
||||
# Get the parent directory of the current file
|
||||
this_dir = Path(__file__).resolve().parent.parent.parent.parent.parent
|
||||
|
||||
def load_audio(file, sampling_rate):
|
||||
try:
|
||||
# Get the parent directory of the current file
|
||||
this_dir = Path(__file__).resolve().parent.parent.parent.parent.parent
|
||||
file = file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
|
||||
|
||||
# Set the ffmpeg_path variable based on the operating system
|
||||
if sys.platform == "win32":
|
||||
ffmpeg_path = os.path.join(this_dir, "system", "win_ffmpeg", "ffmpeg.exe")
|
||||
else:
|
||||
ffmpeg_path = "ffmpeg" # Default path for Linux and macOS
|
||||
|
||||
# Initialize the process variable
|
||||
process = subprocess.Popen(
|
||||
[ffmpeg_path, "-y", "-i", file, "-f", "f32le", "-acodec", "pcm_f32le", "-ac", "1", "-ar", str(sampling_rate), "pipe:1"],
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE
|
||||
)
|
||||
|
||||
out, err = process.communicate()
|
||||
if process.returncode != 0:
|
||||
print(f"FFmpeg error: {err.decode('utf-8')}") # Debug statement
|
||||
raise RuntimeError(f"FFmpeg error: {err.decode('utf-8')}")
|
||||
#print("Audio loaded successfully") # Debug statement
|
||||
except Exception as error:
|
||||
print(f"Error loading audio: {error}") # Debug statement
|
||||
raise RuntimeError(f"Failed to load audio: {error}")
|
||||
|
||||
return np.frombuffer(out, np.float32).flatten()
|
||||
|
||||
|
||||
|
||||
def format_title(title):
|
||||
formatted_title = (
|
||||
unicodedata.normalize("NFKD", title).encode("ascii", "ignore").decode("utf-8")
|
||||
)
|
||||
formatted_title = re.sub(r"[\u2500-\u257F]+", "", formatted_title)
|
||||
formatted_title = re.sub(r"[^\w\s.-]", "", formatted_title)
|
||||
formatted_title = re.sub(r"\s+", "_", formatted_title)
|
||||
return formatted_title
|
||||
|
||||
|
||||
def load_embedding(embedder_model):
|
||||
#print("EMBEDDER MODEL IS", embedder_model)
|
||||
embedding_list = {
|
||||
"contentvec": "contentvec_base.pt",
|
||||
"hubert": "hubert_base.pt",
|
||||
}
|
||||
|
||||
try:
|
||||
this_dir = Path(__file__).resolve().parent.parent.parent.parent.parent
|
||||
model_path = this_dir / "models" / "rvc_base" / embedding_list[embedder_model]
|
||||
#print("MODEL PATH IS", model_path)
|
||||
|
||||
# Load model ensemble and task
|
||||
models = checkpoint_utils.load_model_ensemble_and_task(
|
||||
[f"{model_path}"],
|
||||
suffix="",
|
||||
)
|
||||
|
||||
#print(f"Embedding model {embedder_model} loaded successfully.")
|
||||
return models
|
||||
except KeyError as e:
|
||||
logging.error(f"Invalid embedder model name: {embedder_model}")
|
||||
raise ValueError(f"Invalid embedder model name: {embedder_model}") from e
|
||||
except Exception as e:
|
||||
logging.error(f"Error loading embedding model: {e}")
|
||||
raise RuntimeError(f"Error loading embedding model: {e}") from e
|
||||
Whitespace-only changes.
Whitespace-only changes.
Whitespace-only changes.
@@ -0,0 +1,452 @@
|
||||
import os
|
||||
import numpy as np
|
||||
import torch
|
||||
import torch.utils.data
|
||||
|
||||
from mel_processing import spectrogram_torch
|
||||
from utils import load_filepaths_and_text, load_wav_to_torch
|
||||
|
||||
|
||||
class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
|
||||
def __init__(self, hparams):
|
||||
self.audiopaths_and_text = load_filepaths_and_text(hparams.training_files)
|
||||
self.max_wav_value = hparams.max_wav_value
|
||||
self.sampling_rate = hparams.sampling_rate
|
||||
self.filter_length = hparams.filter_length
|
||||
self.hop_length = hparams.hop_length
|
||||
self.win_length = hparams.win_length
|
||||
self.sampling_rate = hparams.sampling_rate
|
||||
self.min_text_len = getattr(hparams, "min_text_len", 1)
|
||||
self.max_text_len = getattr(hparams, "max_text_len", 5000)
|
||||
self._filter()
|
||||
|
||||
def _filter(self):
|
||||
audiopaths_and_text_new = []
|
||||
lengths = []
|
||||
for audiopath, text, pitch, pitchf, dv in self.audiopaths_and_text:
|
||||
if self.min_text_len <= len(text) and len(text) <= self.max_text_len:
|
||||
audiopaths_and_text_new.append([audiopath, text, pitch, pitchf, dv])
|
||||
lengths.append(os.path.getsize(audiopath) // (3 * self.hop_length))
|
||||
self.audiopaths_and_text = audiopaths_and_text_new
|
||||
self.lengths = lengths
|
||||
|
||||
def get_sid(self, sid):
|
||||
sid = torch.LongTensor([int(sid)])
|
||||
return sid
|
||||
|
||||
def get_audio_text_pair(self, audiopath_and_text):
|
||||
file = audiopath_and_text[0]
|
||||
phone = audiopath_and_text[1]
|
||||
pitch = audiopath_and_text[2]
|
||||
pitchf = audiopath_and_text[3]
|
||||
dv = audiopath_and_text[4]
|
||||
|
||||
phone, pitch, pitchf = self.get_labels(phone, pitch, pitchf)
|
||||
spec, wav = self.get_audio(file)
|
||||
dv = self.get_sid(dv)
|
||||
|
||||
len_phone = phone.size()[0]
|
||||
len_spec = spec.size()[-1]
|
||||
if len_phone != len_spec:
|
||||
len_min = min(len_phone, len_spec)
|
||||
len_wav = len_min * self.hop_length
|
||||
|
||||
spec = spec[:, :len_min]
|
||||
wav = wav[:, :len_wav]
|
||||
|
||||
phone = phone[:len_min, :]
|
||||
pitch = pitch[:len_min]
|
||||
pitchf = pitchf[:len_min]
|
||||
|
||||
return (spec, wav, phone, pitch, pitchf, dv)
|
||||
|
||||
def get_labels(self, phone, pitch, pitchf):
|
||||
phone = np.load(phone)
|
||||
phone = np.repeat(phone, 2, axis=0)
|
||||
pitch = np.load(pitch)
|
||||
pitchf = np.load(pitchf)
|
||||
n_num = min(phone.shape[0], 900)
|
||||
phone = phone[:n_num, :]
|
||||
pitch = pitch[:n_num]
|
||||
pitchf = pitchf[:n_num]
|
||||
phone = torch.FloatTensor(phone)
|
||||
pitch = torch.LongTensor(pitch)
|
||||
pitchf = torch.FloatTensor(pitchf)
|
||||
return phone, pitch, pitchf
|
||||
|
||||
def get_audio(self, filename):
|
||||
audio, sampling_rate = load_wav_to_torch(filename)
|
||||
if sampling_rate != self.sampling_rate:
|
||||
raise ValueError(
|
||||
"{} SR doesn't match target {} SR".format(
|
||||
sampling_rate, self.sampling_rate
|
||||
)
|
||||
)
|
||||
audio_norm = audio
|
||||
audio_norm = audio_norm.unsqueeze(0)
|
||||
spec_filename = filename.replace(".wav", ".spec.pt")
|
||||
if os.path.exists(spec_filename):
|
||||
try:
|
||||
spec = torch.load(spec_filename)
|
||||
except Exception as error:
|
||||
print(f"{spec_filename}: {error}")
|
||||
spec = spectrogram_torch(
|
||||
audio_norm,
|
||||
self.filter_length,
|
||||
self.hop_length,
|
||||
self.win_length,
|
||||
center=False,
|
||||
)
|
||||
spec = torch.squeeze(spec, 0)
|
||||
torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
|
||||
else:
|
||||
spec = spectrogram_torch(
|
||||
audio_norm,
|
||||
self.filter_length,
|
||||
self.hop_length,
|
||||
self.win_length,
|
||||
center=False,
|
||||
)
|
||||
spec = torch.squeeze(spec, 0)
|
||||
torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
|
||||
return spec, audio_norm
|
||||
|
||||
def __getitem__(self, index):
|
||||
return self.get_audio_text_pair(self.audiopaths_and_text[index])
|
||||
|
||||
def __len__(self):
|
||||
return len(self.audiopaths_and_text)
|
||||
|
||||
|
||||
class TextAudioCollateMultiNSFsid:
|
||||
def __init__(self, return_ids=False):
|
||||
self.return_ids = return_ids
|
||||
|
||||
def __call__(self, batch):
|
||||
_, ids_sorted_decreasing = torch.sort(
|
||||
torch.LongTensor([x[0].size(1) for x in batch]), dim=0, descending=True
|
||||
)
|
||||
|
||||
max_spec_len = max([x[0].size(1) for x in batch])
|
||||
max_wave_len = max([x[1].size(1) for x in batch])
|
||||
spec_lengths = torch.LongTensor(len(batch))
|
||||
wave_lengths = torch.LongTensor(len(batch))
|
||||
spec_padded = torch.FloatTensor(len(batch), batch[0][0].size(0), max_spec_len)
|
||||
wave_padded = torch.FloatTensor(len(batch), 1, max_wave_len)
|
||||
spec_padded.zero_()
|
||||
wave_padded.zero_()
|
||||
|
||||
max_phone_len = max([x[2].size(0) for x in batch])
|
||||
phone_lengths = torch.LongTensor(len(batch))
|
||||
phone_padded = torch.FloatTensor(
|
||||
len(batch), max_phone_len, batch[0][2].shape[1]
|
||||
)
|
||||
pitch_padded = torch.LongTensor(len(batch), max_phone_len)
|
||||
pitchf_padded = torch.FloatTensor(len(batch), max_phone_len)
|
||||
phone_padded.zero_()
|
||||
pitch_padded.zero_()
|
||||
pitchf_padded.zero_()
|
||||
sid = torch.LongTensor(len(batch))
|
||||
|
||||
for i in range(len(ids_sorted_decreasing)):
|
||||
row = batch[ids_sorted_decreasing[i]]
|
||||
|
||||
spec = row[0]
|
||||
spec_padded[i, :, : spec.size(1)] = spec
|
||||
spec_lengths[i] = spec.size(1)
|
||||
|
||||
wave = row[1]
|
||||
wave_padded[i, :, : wave.size(1)] = wave
|
||||
wave_lengths[i] = wave.size(1)
|
||||
|
||||
phone = row[2]
|
||||
phone_padded[i, : phone.size(0), :] = phone
|
||||
phone_lengths[i] = phone.size(0)
|
||||
|
||||
pitch = row[3]
|
||||
pitch_padded[i, : pitch.size(0)] = pitch
|
||||
pitchf = row[4]
|
||||
pitchf_padded[i, : pitchf.size(0)] = pitchf
|
||||
|
||||
sid[i] = row[5]
|
||||
|
||||
return (
|
||||
phone_padded,
|
||||
phone_lengths,
|
||||
pitch_padded,
|
||||
pitchf_padded,
|
||||
spec_padded,
|
||||
spec_lengths,
|
||||
wave_padded,
|
||||
wave_lengths,
|
||||
sid,
|
||||
)
|
||||
|
||||
|
||||
class TextAudioLoader(torch.utils.data.Dataset):
|
||||
def __init__(self, hparams):
|
||||
self.audiopaths_and_text = load_filepaths_and_text(hparams.training_files)
|
||||
self.max_wav_value = hparams.max_wav_value
|
||||
self.sampling_rate = hparams.sampling_rate
|
||||
self.filter_length = hparams.filter_length
|
||||
self.hop_length = hparams.hop_length
|
||||
self.win_length = hparams.win_length
|
||||
self.sampling_rate = hparams.sampling_rate
|
||||
self.min_text_len = getattr(hparams, "min_text_len", 1)
|
||||
self.max_text_len = getattr(hparams, "max_text_len", 5000)
|
||||
self._filter()
|
||||
|
||||
def _filter(self):
|
||||
audiopaths_and_text_new = []
|
||||
lengths = []
|
||||
for entry in self.audiopaths_and_text:
|
||||
if len(entry) >= 3:
|
||||
audiopath, text, dv = entry[:3]
|
||||
if self.min_text_len <= len(text) and len(text) <= self.max_text_len:
|
||||
audiopaths_and_text_new.append([audiopath, text, dv])
|
||||
lengths.append(os.path.getsize(audiopath) // (3 * self.hop_length))
|
||||
|
||||
self.audiopaths_and_text = audiopaths_and_text_new
|
||||
self.lengths = lengths
|
||||
|
||||
def get_sid(self, sid):
|
||||
sid = os.path.basename(os.path.dirname(sid))
|
||||
|
||||
try:
|
||||
sid = torch.LongTensor([int("".join(filter(str.isdigit, sid)))])
|
||||
except ValueError as error:
|
||||
print(f"Error converting speaker ID '{sid}' to integer. Exception: {error}")
|
||||
sid = torch.LongTensor([0])
|
||||
|
||||
return sid
|
||||
|
||||
def get_audio_text_pair(self, audiopath_and_text):
|
||||
file = audiopath_and_text[0]
|
||||
phone = audiopath_and_text[1]
|
||||
dv = audiopath_and_text[2]
|
||||
|
||||
phone = self.get_labels(phone)
|
||||
spec, wav = self.get_audio(file)
|
||||
dv = self.get_sid(dv)
|
||||
|
||||
len_phone = phone.size()[0]
|
||||
len_spec = spec.size()[-1]
|
||||
if len_phone != len_spec:
|
||||
len_min = min(len_phone, len_spec)
|
||||
len_wav = len_min * self.hop_length
|
||||
spec = spec[:, :len_min]
|
||||
wav = wav[:, :len_wav]
|
||||
phone = phone[:len_min, :]
|
||||
return (spec, wav, phone, dv)
|
||||
|
||||
def get_labels(self, phone):
|
||||
phone = np.load(phone)
|
||||
phone = np.repeat(phone, 2, axis=0)
|
||||
n_num = min(phone.shape[0], 900)
|
||||
phone = phone[:n_num, :]
|
||||
phone = torch.FloatTensor(phone)
|
||||
return phone
|
||||
|
||||
def get_audio(self, filename):
|
||||
audio, sampling_rate = load_wav_to_torch(filename)
|
||||
if sampling_rate != self.sampling_rate:
|
||||
raise ValueError(
|
||||
"{} SR doesn't match target {} SR".format(
|
||||
sampling_rate, self.sampling_rate
|
||||
)
|
||||
)
|
||||
audio_norm = audio
|
||||
audio_norm = audio_norm.unsqueeze(0)
|
||||
spec_filename = filename.replace(".wav", ".spec.pt")
|
||||
if os.path.exists(spec_filename):
|
||||
try:
|
||||
spec = torch.load(spec_filename)
|
||||
except Exception as error:
|
||||
print(f"{spec_filename}: {error}")
|
||||
spec = spectrogram_torch(
|
||||
audio_norm,
|
||||
self.filter_length,
|
||||
self.hop_length,
|
||||
self.win_length,
|
||||
center=False,
|
||||
)
|
||||
spec = torch.squeeze(spec, 0)
|
||||
torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
|
||||
else:
|
||||
spec = spectrogram_torch(
|
||||
audio_norm,
|
||||
self.filter_length,
|
||||
self.hop_length,
|
||||
self.win_length,
|
||||
center=False,
|
||||
)
|
||||
spec = torch.squeeze(spec, 0)
|
||||
torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
|
||||
return spec, audio_norm
|
||||
|
||||
def __getitem__(self, index):
|
||||
return self.get_audio_text_pair(self.audiopaths_and_text[index])
|
||||
|
||||
def __len__(self):
|
||||
return len(self.audiopaths_and_text)
|
||||
|
||||
|
||||
class TextAudioCollate:
|
||||
def __init__(self, return_ids=False):
|
||||
self.return_ids = return_ids
|
||||
|
||||
def __call__(self, batch):
|
||||
_, ids_sorted_decreasing = torch.sort(
|
||||
torch.LongTensor([x[0].size(1) for x in batch]), dim=0, descending=True
|
||||
)
|
||||
|
||||
max_spec_len = max([x[0].size(1) for x in batch])
|
||||
max_wave_len = max([x[1].size(1) for x in batch])
|
||||
spec_lengths = torch.LongTensor(len(batch))
|
||||
wave_lengths = torch.LongTensor(len(batch))
|
||||
spec_padded = torch.FloatTensor(len(batch), batch[0][0].size(0), max_spec_len)
|
||||
wave_padded = torch.FloatTensor(len(batch), 1, max_wave_len)
|
||||
spec_padded.zero_()
|
||||
wave_padded.zero_()
|
||||
|
||||
max_phone_len = max([x[2].size(0) for x in batch])
|
||||
phone_lengths = torch.LongTensor(len(batch))
|
||||
phone_padded = torch.FloatTensor(
|
||||
len(batch), max_phone_len, batch[0][2].shape[1]
|
||||
)
|
||||
phone_padded.zero_()
|
||||
sid = torch.LongTensor(len(batch))
|
||||
|
||||
for i in range(len(ids_sorted_decreasing)):
|
||||
row = batch[ids_sorted_decreasing[i]]
|
||||
|
||||
spec = row[0]
|
||||
spec_padded[i, :, : spec.size(1)] = spec
|
||||
spec_lengths[i] = spec.size(1)
|
||||
|
||||
wave = row[1]
|
||||
wave_padded[i, :, : wave.size(1)] = wave
|
||||
wave_lengths[i] = wave.size(1)
|
||||
|
||||
phone = row[2]
|
||||
phone_padded[i, : phone.size(0), :] = phone
|
||||
phone_lengths[i] = phone.size(0)
|
||||
|
||||
sid[i] = row[3]
|
||||
|
||||
return (
|
||||
phone_padded,
|
||||
phone_lengths,
|
||||
spec_padded,
|
||||
spec_lengths,
|
||||
wave_padded,
|
||||
wave_lengths,
|
||||
sid,
|
||||
)
|
||||
|
||||
|
||||
class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
|
||||
def __init__(
|
||||
self,
|
||||
dataset,
|
||||
batch_size,
|
||||
boundaries,
|
||||
num_replicas=None,
|
||||
rank=None,
|
||||
shuffle=True,
|
||||
):
|
||||
super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle)
|
||||
self.lengths = dataset.lengths
|
||||
self.batch_size = batch_size
|
||||
self.boundaries = boundaries
|
||||
|
||||
self.buckets, self.num_samples_per_bucket = self._create_buckets()
|
||||
self.total_size = sum(self.num_samples_per_bucket)
|
||||
self.num_samples = self.total_size // self.num_replicas
|
||||
|
||||
def _create_buckets(self):
|
||||
buckets = [[] for _ in range(len(self.boundaries) - 1)]
|
||||
for i in range(len(self.lengths)):
|
||||
length = self.lengths[i]
|
||||
idx_bucket = self._bisect(length)
|
||||
if idx_bucket != -1:
|
||||
buckets[idx_bucket].append(i)
|
||||
|
||||
for i in range(len(buckets) - 1, -1, -1): #
|
||||
if len(buckets[i]) == 0:
|
||||
buckets.pop(i)
|
||||
self.boundaries.pop(i + 1)
|
||||
|
||||
num_samples_per_bucket = []
|
||||
for i in range(len(buckets)):
|
||||
len_bucket = len(buckets[i])
|
||||
total_batch_size = self.num_replicas * self.batch_size
|
||||
rem = (
|
||||
total_batch_size - (len_bucket % total_batch_size)
|
||||
) % total_batch_size
|
||||
num_samples_per_bucket.append(len_bucket + rem)
|
||||
return buckets, num_samples_per_bucket
|
||||
|
||||
def __iter__(self):
|
||||
g = torch.Generator()
|
||||
g.manual_seed(self.epoch)
|
||||
|
||||
indices = []
|
||||
if self.shuffle:
|
||||
for bucket in self.buckets:
|
||||
indices.append(torch.randperm(len(bucket), generator=g).tolist())
|
||||
else:
|
||||
for bucket in self.buckets:
|
||||
indices.append(list(range(len(bucket))))
|
||||
|
||||
batches = []
|
||||
for i in range(len(self.buckets)):
|
||||
bucket = self.buckets[i]
|
||||
len_bucket = len(bucket)
|
||||
ids_bucket = indices[i]
|
||||
num_samples_bucket = self.num_samples_per_bucket[i]
|
||||
|
||||
rem = num_samples_bucket - len_bucket
|
||||
ids_bucket = (
|
||||
ids_bucket
|
||||
+ ids_bucket * (rem // len_bucket)
|
||||
+ ids_bucket[: (rem % len_bucket)]
|
||||
)
|
||||
|
||||
ids_bucket = ids_bucket[self.rank :: self.num_replicas]
|
||||
|
||||
# batching
|
||||
for j in range(len(ids_bucket) // self.batch_size):
|
||||
batch = [
|
||||
bucket[idx]
|
||||
for idx in ids_bucket[
|
||||
j * self.batch_size : (j + 1) * self.batch_size
|
||||
]
|
||||
]
|
||||
batches.append(batch)
|
||||
|
||||
if self.shuffle:
|
||||
batch_ids = torch.randperm(len(batches), generator=g).tolist()
|
||||
batches = [batches[i] for i in batch_ids]
|
||||
self.batches = batches
|
||||
|
||||
assert len(self.batches) * self.batch_size == self.num_samples
|
||||
return iter(self.batches)
|
||||
|
||||
def _bisect(self, x, lo=0, hi=None):
|
||||
if hi is None:
|
||||
hi = len(self.boundaries) - 1
|
||||
|
||||
if hi > lo:
|
||||
mid = (hi + lo) // 2
|
||||
if self.boundaries[mid] < x and x <= self.boundaries[mid + 1]:
|
||||
return mid
|
||||
elif x <= self.boundaries[mid]:
|
||||
return self._bisect(x, lo, mid)
|
||||
else:
|
||||
return self._bisect(x, mid + 1, hi)
|
||||
else:
|
||||
return -1
|
||||
|
||||
def __len__(self):
|
||||
return self.num_samples // self.batch_size
|
||||
@@ -0,0 +1,237 @@
|
||||
import os
|
||||
import sys
|
||||
import numpy as np
|
||||
import pyworld
|
||||
import torchcrepe
|
||||
import torch
|
||||
import parselmouth
|
||||
import tqdm
|
||||
from multiprocessing import Process, cpu_count
|
||||
|
||||
current_directory = os.getcwd()
|
||||
sys.path.append(current_directory)
|
||||
|
||||
|
||||
from rvc.lib.utils import load_audio
|
||||
|
||||
|
||||
exp_dir = sys.argv[1]
|
||||
f0_method = sys.argv[2]
|
||||
num_processes = cpu_count()
|
||||
|
||||
try:
|
||||
hop_length = int(sys.argv[3])
|
||||
except ValueError:
|
||||
hop_length = 128
|
||||
|
||||
DoFormant = False
|
||||
Quefrency = 1.0
|
||||
Timbre = 1.0
|
||||
|
||||
|
||||
class FeatureInput:
|
||||
def __init__(self, sample_rate=16000, hop_size=160):
|
||||
self.fs = sample_rate
|
||||
self.hop = hop_size
|
||||
|
||||
self.f0_method_dict = self.get_f0_method_dict()
|
||||
|
||||
self.f0_bin = 256
|
||||
self.f0_max = 1100.0
|
||||
self.f0_min = 50.0
|
||||
self.f0_mel_min = 1127 * np.log(1 + self.f0_min / 700)
|
||||
self.f0_mel_max = 1127 * np.log(1 + self.f0_max / 700)
|
||||
|
||||
def mncrepe(self, method, x, p_len, hop_length):
|
||||
f0 = None
|
||||
torch_device_index = 0
|
||||
torch_device = (
|
||||
torch.device(f"cuda:{torch_device_index % torch.cuda.device_count()}")
|
||||
if torch.cuda.is_available()
|
||||
else (
|
||||
torch.device("mps")
|
||||
if torch.backends.mps.is_available()
|
||||
else torch.device("cpu")
|
||||
)
|
||||
)
|
||||
|
||||
audio = torch.from_numpy(x.astype(np.float32)).to(torch_device, copy=True)
|
||||
audio /= torch.quantile(torch.abs(audio), 0.999)
|
||||
audio = torch.unsqueeze(audio, dim=0)
|
||||
if audio.ndim == 2 and audio.shape[0] > 1:
|
||||
audio = torch.mean(audio, dim=0, keepdim=True).detach()
|
||||
audio = audio.detach()
|
||||
|
||||
if method == "crepe":
|
||||
pitch = torchcrepe.predict(
|
||||
audio,
|
||||
self.fs,
|
||||
hop_length,
|
||||
self.f0_min,
|
||||
self.f0_max,
|
||||
"full",
|
||||
batch_size=hop_length * 2,
|
||||
device=torch_device,
|
||||
pad=True,
|
||||
)
|
||||
p_len = p_len or x.shape[0] // hop_length
|
||||
source = np.array(pitch.squeeze(0).cpu().float().numpy())
|
||||
source[source < 0.001] = np.nan
|
||||
target = np.interp(
|
||||
np.arange(0, len(source) * p_len, len(source)) / p_len,
|
||||
np.arange(0, len(source)),
|
||||
source,
|
||||
)
|
||||
f0 = np.nan_to_num(target)
|
||||
|
||||
return f0
|
||||
|
||||
def get_pm(self, x, p_len):
|
||||
f0 = (
|
||||
parselmouth.Sound(x, self.fs)
|
||||
.to_pitch_ac(
|
||||
time_step=160 / 16000,
|
||||
voicing_threshold=0.6,
|
||||
pitch_floor=self.f0_min,
|
||||
pitch_ceiling=self.f0_max,
|
||||
)
|
||||
.selected_array["frequency"]
|
||||
)
|
||||
|
||||
return np.pad(
|
||||
f0,
|
||||
[
|
||||
[
|
||||
max(0, (p_len - len(f0) + 1) // 2),
|
||||
max(0, p_len - len(f0) - (p_len - len(f0) + 1) // 2),
|
||||
]
|
||||
],
|
||||
mode="constant",
|
||||
)
|
||||
|
||||
def get_harvest(self, x):
|
||||
f0_spectral = pyworld.harvest(
|
||||
x.astype(np.double),
|
||||
fs=self.fs,
|
||||
f0_ceil=self.f0_max,
|
||||
f0_floor=self.f0_min,
|
||||
frame_period=1000 * self.hop / self.fs,
|
||||
)
|
||||
return pyworld.stonemask(x.astype(np.double), *f0_spectral, self.fs)
|
||||
|
||||
def get_dio(self, x):
|
||||
f0_spectral = pyworld.dio(
|
||||
x.astype(np.double),
|
||||
fs=self.fs,
|
||||
f0_ceil=self.f0_max,
|
||||
f0_floor=self.f0_min,
|
||||
frame_period=1000 * self.hop / self.fs,
|
||||
)
|
||||
return pyworld.stonemask(x.astype(np.double), *f0_spectral, self.fs)
|
||||
|
||||
def get_rmvpe(self, x):
|
||||
if not hasattr(self, "model_rmvpe"):
|
||||
from rvc.lib.rmvpe import RMVPE
|
||||
|
||||
self.model_rmvpe = RMVPE(current_directory / "models" / "rvc_base" / "rmvpe.pt", is_half=False, device="cpu")
|
||||
return self.model_rmvpe.infer_from_audio(x, thred=0.03)
|
||||
|
||||
def get_f0_method_dict(self):
|
||||
return {
|
||||
"pm": self.get_pm,
|
||||
"harvest": self.get_harvest,
|
||||
"dio": self.get_dio,
|
||||
"rmvpe": self.get_rmvpe,
|
||||
}
|
||||
|
||||
def compute_f0(self, path, f0_method, hop_length):
|
||||
x = load_audio(path, self.fs)
|
||||
p_len = x.shape[0] // self.hop
|
||||
|
||||
if f0_method in self.f0_method_dict:
|
||||
f0 = (
|
||||
self.f0_method_dict[f0_method](x, p_len)
|
||||
if f0_method == "pm"
|
||||
else self.f0_method_dict[f0_method](x)
|
||||
)
|
||||
elif f0_method == "crepe":
|
||||
f0 = self.mncrepe(f0_method, x, p_len, hop_length)
|
||||
return f0
|
||||
|
||||
def coarse_f0(self, f0):
|
||||
f0_mel = 1127 * np.log(1 + f0 / 700)
|
||||
f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - self.f0_mel_min) * (
|
||||
self.f0_bin - 2
|
||||
) / (self.f0_mel_max - self.f0_mel_min) + 1
|
||||
|
||||
# use 0 or 1
|
||||
f0_mel[f0_mel <= 1] = 1
|
||||
f0_mel[f0_mel > self.f0_bin - 1] = self.f0_bin - 1
|
||||
f0_coarse = np.rint(f0_mel).astype(int)
|
||||
assert f0_coarse.max() <= 255 and f0_coarse.min() >= 1, (
|
||||
f0_coarse.max(),
|
||||
f0_coarse.min(),
|
||||
)
|
||||
return f0_coarse
|
||||
|
||||
def process_paths(self, paths, f0_method, hop_length, thread_n):
|
||||
if len(paths) == 0:
|
||||
print("There are no paths to process.")
|
||||
return
|
||||
with tqdm.tqdm(total=len(paths), leave=True, position=thread_n) as pbar:
|
||||
description = f"Thread {thread_n} | Hop-Length {hop_length}"
|
||||
pbar.set_description(description)
|
||||
|
||||
for idx, (inp_path, opt_path1, opt_path2) in enumerate(paths):
|
||||
try:
|
||||
if os.path.exists(opt_path1 + ".npy") and os.path.exists(
|
||||
opt_path2 + ".npy"
|
||||
):
|
||||
pbar.update(1)
|
||||
continue
|
||||
|
||||
feature_pit = self.compute_f0(inp_path, f0_method, hop_length)
|
||||
np.save(
|
||||
opt_path2,
|
||||
feature_pit,
|
||||
allow_pickle=False,
|
||||
) # nsf
|
||||
coarse_pit = self.coarse_f0(feature_pit)
|
||||
np.save(
|
||||
opt_path1,
|
||||
coarse_pit,
|
||||
allow_pickle=False,
|
||||
) # ori
|
||||
pbar.update(1)
|
||||
except Exception as error:
|
||||
print(f"f0fail-{idx}-{inp_path}-{error}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
feature_input = FeatureInput()
|
||||
paths = []
|
||||
input_root = f"{exp_dir}/1_16k_wavs"
|
||||
output_root1 = f"{exp_dir}/2a_f0"
|
||||
output_root2 = f"{exp_dir}/2b-f0nsf"
|
||||
|
||||
os.makedirs(output_root1, exist_ok=True)
|
||||
os.makedirs(output_root2, exist_ok=True)
|
||||
for name in sorted(list(os.listdir(input_root))):
|
||||
input_path = f"{input_root}/{name}"
|
||||
if "spec" in input_path:
|
||||
continue
|
||||
output_path1 = f"{output_root1}/{name}"
|
||||
output_path2 = f"{output_root2}/{name}"
|
||||
paths.append([input_path, output_path1, output_path2])
|
||||
|
||||
processes = []
|
||||
print("Using f0 method: " + f0_method)
|
||||
for i in range(num_processes):
|
||||
p = Process(
|
||||
target=feature_input.process_paths,
|
||||
args=(paths[i::num_processes], f0_method, hop_length, i),
|
||||
)
|
||||
processes.append(p)
|
||||
p.start()
|
||||
for i in range(num_processes):
|
||||
processes[i].join()
|
||||
@@ -0,0 +1,94 @@
|
||||
import os
|
||||
import sys
|
||||
import tqdm
|
||||
import torch
|
||||
import torch.nn.functional as F
|
||||
import soundfile as sf
|
||||
import numpy as np
|
||||
|
||||
now_dir = os.getcwd()
|
||||
sys.path.append(now_dir)
|
||||
from rvc.lib.utils import load_embedding
|
||||
|
||||
device = sys.argv[1]
|
||||
n_parts = int(sys.argv[2])
|
||||
i_part = int(sys.argv[3])
|
||||
i_gpu = sys.argv[4]
|
||||
exp_dir = sys.argv[5]
|
||||
os.environ["CUDA_VISIBLE_DEVICES"] = str(i_gpu)
|
||||
version = sys.argv[6]
|
||||
is_half = bool(sys.argv[7])
|
||||
embedder_model = sys.argv[8]
|
||||
|
||||
|
||||
wav_path = f"{exp_dir}/1_16k_wavs"
|
||||
out_path = f"{exp_dir}/3_feature256" if version == "v1" else f"{exp_dir}/3_feature768"
|
||||
os.makedirs(out_path, exist_ok=True)
|
||||
|
||||
|
||||
def read_wave(wav_path, normalize=False):
|
||||
wav, sr = sf.read(wav_path)
|
||||
assert sr == 16000
|
||||
feats = torch.from_numpy(wav)
|
||||
feats = feats.half() if is_half else feats.float()
|
||||
feats = feats.mean(-1) if feats.dim() == 2 else feats
|
||||
feats = feats.view(1, -1)
|
||||
if normalize:
|
||||
with torch.no_grad():
|
||||
feats = F.layer_norm(feats, feats.shape)
|
||||
return feats
|
||||
|
||||
|
||||
print("Starting feature extraction...")
|
||||
models, saved_cfg, task = load_embedding(embedder_model)
|
||||
model = models[0]
|
||||
model = model.to(device)
|
||||
if device not in ["mps", "cpu"]:
|
||||
model = model.half()
|
||||
model.eval()
|
||||
|
||||
todo = sorted(os.listdir(wav_path))[i_part::n_parts]
|
||||
n = max(1, len(todo) // 10)
|
||||
|
||||
if len(todo) == 0:
|
||||
print(
|
||||
"An error occurred in the feature extraction, make sure you have provided the audios correctly."
|
||||
)
|
||||
else:
|
||||
print(f"{len(todo)}")
|
||||
with tqdm.tqdm(total=len(todo)) as pbar:
|
||||
for idx, file in enumerate(todo):
|
||||
try:
|
||||
if file.endswith(".wav"):
|
||||
wav_file_path = os.path.join(wav_path, file)
|
||||
out_file_path = os.path.join(out_path, file.replace("wav", "npy"))
|
||||
|
||||
if os.path.exists(out_file_path):
|
||||
continue
|
||||
|
||||
feats = read_wave(wav_file_path, normalize=saved_cfg.task.normalize)
|
||||
padding_mask = torch.BoolTensor(feats.shape).fill_(False)
|
||||
inputs = {
|
||||
"source": feats.to(device),
|
||||
"padding_mask": padding_mask.to(device),
|
||||
"output_layer": 9 if version == "v1" else 12,
|
||||
}
|
||||
with torch.no_grad():
|
||||
logits = model.extract_features(**inputs)
|
||||
feats = (
|
||||
model.final_proj(logits[0])
|
||||
if version == "v1"
|
||||
else logits[0]
|
||||
)
|
||||
|
||||
feats = feats.squeeze(0).float().cpu().numpy()
|
||||
if np.isnan(feats).sum() == 0:
|
||||
np.save(out_file_path, feats, allow_pickle=False)
|
||||
else:
|
||||
print(f"{file} - contains nan")
|
||||
pbar.set_description(f"Processing {file} {feats.shape}")
|
||||
except Exception as error:
|
||||
print(error)
|
||||
pbar.update(1)
|
||||
|
||||
print("Feature extraction completed successfully!")
|
||||
@@ -0,0 +1,71 @@
|
||||
import os
|
||||
import json
|
||||
import pathlib
|
||||
from random import shuffle
|
||||
|
||||
from rvc.configs.config import Config
|
||||
|
||||
config = Config()
|
||||
current_directory = os.getcwd()
|
||||
|
||||
|
||||
def generate_config(rvc_version, sampling_rate, model_path):
|
||||
if rvc_version == "v1" or sampling_rate == "40000":
|
||||
config_path = f"v1/{sampling_rate}.json"
|
||||
else:
|
||||
config_path = f"v2/{sampling_rate}.json"
|
||||
config_save_path = os.path.join(model_path, "config.json")
|
||||
if not pathlib.Path(config_save_path).exists():
|
||||
with open(config_save_path, "w", encoding="utf-8") as f:
|
||||
json.dump(
|
||||
config.json_config[config_path],
|
||||
f,
|
||||
ensure_ascii=False,
|
||||
indent=4,
|
||||
sort_keys=True,
|
||||
)
|
||||
f.write("\n")
|
||||
|
||||
|
||||
def generate_filelist(f0_method, model_path, rvc_version, sampling_rate):
|
||||
gt_wavs_dir = f"{model_path}/0_gt_wavs"
|
||||
feature_dir = (
|
||||
f"{model_path}/3_feature256"
|
||||
if rvc_version == "v1"
|
||||
else f"{model_path}/3_feature768"
|
||||
)
|
||||
if f0_method:
|
||||
f0_dir = f"{model_path}/2a_f0"
|
||||
f0nsf_dir = f"{model_path}/2b-f0nsf"
|
||||
names = (
|
||||
set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)])
|
||||
& set([name.split(".")[0] for name in os.listdir(feature_dir)])
|
||||
& set([name.split(".")[0] for name in os.listdir(f0_dir)])
|
||||
& set([name.split(".")[0] for name in os.listdir(f0nsf_dir)])
|
||||
)
|
||||
else:
|
||||
names = set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)]) & set(
|
||||
[name.split(".")[0] for name in os.listdir(feature_dir)]
|
||||
)
|
||||
options = []
|
||||
for name in names:
|
||||
if f0_method:
|
||||
options.append(
|
||||
f"{gt_wavs_dir}/{name}.wav|{feature_dir}/{name}.npy|{f0_dir}/{name}.wav.npy|{f0nsf_dir}/{name}.wav.npy|0"
|
||||
)
|
||||
else:
|
||||
options.append(f"{gt_wavs_dir}/{name}.wav|{feature_dir}/{name}.npy|0")
|
||||
fea_dim = 256 if rvc_version == "v1" else 768
|
||||
if f0_method:
|
||||
for _ in range(2):
|
||||
options.append(
|
||||
f"{current_directory}/logs/mute/0_gt_wavs/mute{sampling_rate}.wav|{current_directory}/logs/mute/3_feature{fea_dim}/mute.npy|{current_directory}/logs/mute/2a_f0/mute.wav.npy|{current_directory}/logs/mute/2b-f0nsf/mute.wav.npy|0"
|
||||
)
|
||||
else:
|
||||
for _ in range(2):
|
||||
options.append(
|
||||
f"{current_directory}/logs/mute/0_gt_wavs/mute{sampling_rate}.wav|{current_directory}/logs/mute/3_feature{fea_dim}/mute.npy|0"
|
||||
)
|
||||
shuffle(options)
|
||||
with open(f"{model_path}/filelist.txt", "w") as f:
|
||||
f.write("\n".join(options))
|
||||
@@ -0,0 +1,58 @@
|
||||
import torch
|
||||
|
||||
|
||||
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()
|
||||
|
||||
kl = logs_p - logs_q - 0.5
|
||||
kl += 0.5 * ((z_p - m_p) ** 2) * torch.exp(-2.0 * logs_p)
|
||||
kl = torch.sum(kl * z_mask)
|
||||
l = kl / torch.sum(z_mask)
|
||||
return l
|
||||
@@ -0,0 +1,84 @@
|
||||
import torch
|
||||
import torch.utils.data
|
||||
from librosa.filters import mel as librosa_mel_fn
|
||||
|
||||
|
||||
def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
|
||||
return torch.log(torch.clamp(x, min=clip_val) * C)
|
||||
|
||||
|
||||
def dynamic_range_decompression_torch(x, C=1):
|
||||
return torch.exp(x) / C
|
||||
|
||||
|
||||
def spectral_normalize_torch(magnitudes):
|
||||
return dynamic_range_compression_torch(magnitudes)
|
||||
|
||||
|
||||
def spectral_de_normalize_torch(magnitudes):
|
||||
return dynamic_range_decompression_torch(magnitudes)
|
||||
|
||||
|
||||
mel_basis = {}
|
||||
hann_window = {}
|
||||
|
||||
|
||||
def spectrogram_torch(y, n_fft, hop_size, win_size, center=False):
|
||||
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=True,
|
||||
)
|
||||
|
||||
spec = torch.sqrt(spec.real.pow(2) + spec.imag.pow(2) + 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
|
||||
)
|
||||
|
||||
melspec = torch.matmul(mel_basis[fmax_dtype_device], spec)
|
||||
melspec = spectral_normalize_torch(melspec)
|
||||
return melspec
|
||||
|
||||
|
||||
def mel_spectrogram_torch(
|
||||
y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False
|
||||
):
|
||||
spec = spectrogram_torch(y, n_fft, hop_size, win_size, center)
|
||||
|
||||
melspec = spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax)
|
||||
|
||||
return melspec
|
||||
@@ -0,0 +1,130 @@
|
||||
from multiprocessing import cpu_count
|
||||
import os
|
||||
import sys
|
||||
|
||||
from scipy import signal
|
||||
from scipy.io import wavfile
|
||||
import librosa
|
||||
import numpy as np
|
||||
|
||||
now_directory = os.getcwd()
|
||||
sys.path.append(now_directory)
|
||||
|
||||
from rvc.lib.utils import load_audio
|
||||
from rvc.train.slicer import Slicer
|
||||
|
||||
experiment_directory = sys.argv[1]
|
||||
input_root = sys.argv[2]
|
||||
sampling_rate = int(sys.argv[3])
|
||||
percentage = float(sys.argv[4])
|
||||
num_processes = cpu_count()
|
||||
|
||||
import multiprocessing
|
||||
|
||||
|
||||
class PreProcess:
|
||||
def __init__(self, sr, exp_dir, per=3.0):
|
||||
self.slicer = Slicer(
|
||||
sr=sr,
|
||||
threshold=-42,
|
||||
min_length=1500,
|
||||
min_interval=400,
|
||||
hop_size=15,
|
||||
max_sil_kept=500,
|
||||
)
|
||||
self.sr = sr
|
||||
self.b_high, self.a_high = signal.butter(N=5, Wn=48, btype="high", fs=self.sr)
|
||||
self.per = per
|
||||
self.overlap = 0.3
|
||||
self.tail = self.per + self.overlap
|
||||
self.max_amplitude = 0.9
|
||||
self.alpha = 0.75
|
||||
self.exp_dir = exp_dir
|
||||
self.gt_wavs_dir = f"{exp_dir}/0_gt_wavs"
|
||||
self.wavs16k_dir = f"{exp_dir}/1_16k_wavs"
|
||||
os.makedirs(self.exp_dir, exist_ok=True)
|
||||
os.makedirs(self.gt_wavs_dir, exist_ok=True)
|
||||
os.makedirs(self.wavs16k_dir, exist_ok=True)
|
||||
|
||||
def normalize_and_write(self, tmp_audio, idx0, idx1):
|
||||
tmp_max = np.abs(tmp_audio).max()
|
||||
if tmp_max > 2.5:
|
||||
print(f"{idx0}-{idx1}-{tmp_max}-filtered")
|
||||
return
|
||||
tmp_audio = (tmp_audio / tmp_max * (self.max_amplitude * self.alpha)) + (
|
||||
1 - self.alpha
|
||||
) * tmp_audio
|
||||
wavfile.write(
|
||||
f"{self.gt_wavs_dir}/{idx0}_{idx1}.wav",
|
||||
self.sr,
|
||||
tmp_audio.astype(np.float32),
|
||||
)
|
||||
tmp_audio = librosa.resample(
|
||||
tmp_audio, orig_sr=self.sr, target_sr=16000
|
||||
) # , res_type="soxr_vhq"
|
||||
wavfile.write(
|
||||
f"{self.wavs16k_dir}/{idx0}_{idx1}.wav",
|
||||
16000,
|
||||
tmp_audio.astype(np.float32),
|
||||
)
|
||||
|
||||
def process_audio(self, path, idx0):
|
||||
try:
|
||||
audio = load_audio(path, self.sr)
|
||||
audio = signal.lfilter(self.b_high, self.a_high, audio)
|
||||
|
||||
idx1 = 0
|
||||
for audio_segment in self.slicer.slice(audio):
|
||||
i = 0
|
||||
while 1:
|
||||
start = int(self.sr * (self.per - self.overlap) * i)
|
||||
i += 1
|
||||
if len(audio_segment[start:]) > self.tail * self.sr:
|
||||
tmp_audio = audio_segment[
|
||||
start : start + int(self.per * self.sr)
|
||||
]
|
||||
self.normalize_and_write(tmp_audio, idx0, idx1)
|
||||
idx1 += 1
|
||||
else:
|
||||
tmp_audio = audio_segment[start:]
|
||||
idx1 += 1
|
||||
break
|
||||
self.normalize_and_write(tmp_audio, idx0, idx1)
|
||||
except Exception as error:
|
||||
print(f"{path}: {error}")
|
||||
|
||||
def process_audio_multiprocessing(self, infos):
|
||||
for path, idx0 in infos:
|
||||
self.process_audio(path, idx0)
|
||||
|
||||
def process_audio_multiprocessing_input_directory(self, input_root, num_processes):
|
||||
try:
|
||||
infos = [
|
||||
(f"{input_root}/{name}", idx)
|
||||
for idx, name in enumerate(sorted(list(os.listdir(input_root))))
|
||||
]
|
||||
processes = []
|
||||
for i in range(num_processes):
|
||||
p = multiprocessing.Process(
|
||||
target=self.process_audio_multiprocessing,
|
||||
args=(infos[i::num_processes],),
|
||||
)
|
||||
processes.append(p)
|
||||
p.start()
|
||||
for i in range(num_processes):
|
||||
processes[i].join()
|
||||
except Exception as error:
|
||||
print(error)
|
||||
|
||||
|
||||
def preprocess_training_set(input_root, sr, num_processes, exp_dir, per):
|
||||
pp = PreProcess(sr, exp_dir, per)
|
||||
print("Starting preprocessing...")
|
||||
pp.process_audio_multiprocessing_input_directory(input_root, num_processes)
|
||||
print("Preprocessing completed!")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
preprocess_training_set(
|
||||
input_root, sampling_rate, num_processes, experiment_directory, percentage
|
||||
)
|
||||
@@ -0,0 +1,14 @@
|
||||
import os
|
||||
import torch
|
||||
|
||||
|
||||
def change_info(path, info, name):
|
||||
try:
|
||||
ckpt = torch.load(path, map_location="cpu")
|
||||
ckpt["info"] = info
|
||||
if name == "":
|
||||
name = os.path.basename(path)
|
||||
torch.save(ckpt, f"logs/{name}/{name}")
|
||||
return "Success."
|
||||
except Exception as error:
|
||||
print(error)
|
||||
@@ -0,0 +1,88 @@
|
||||
import os
|
||||
import sys
|
||||
import faiss
|
||||
import numpy as np
|
||||
from sklearn.cluster import MiniBatchKMeans
|
||||
from multiprocessing import cpu_count
|
||||
|
||||
exp_dir = sys.argv[1]
|
||||
version = sys.argv[2]
|
||||
|
||||
try:
|
||||
if version == "v1":
|
||||
feature_dir = os.path.join(exp_dir, "3_feature256")
|
||||
elif version == "v2":
|
||||
feature_dir = os.path.join(exp_dir, "3_feature768")
|
||||
|
||||
npys = []
|
||||
listdir_res = sorted(os.listdir(feature_dir))
|
||||
|
||||
for name in listdir_res:
|
||||
file_path = os.path.join(feature_dir, name)
|
||||
phone = np.load(file_path)
|
||||
npys.append(phone)
|
||||
|
||||
big_npy = np.concatenate(npys, axis=0)
|
||||
|
||||
big_npy_idx = np.arange(big_npy.shape[0])
|
||||
np.random.shuffle(big_npy_idx)
|
||||
big_npy = big_npy[big_npy_idx]
|
||||
|
||||
if big_npy.shape[0] > 2e5:
|
||||
big_npy = (
|
||||
MiniBatchKMeans(
|
||||
n_clusters=10000,
|
||||
verbose=True,
|
||||
batch_size=256 * cpu_count(),
|
||||
compute_labels=False,
|
||||
init="random",
|
||||
)
|
||||
.fit(big_npy)
|
||||
.cluster_centers_
|
||||
)
|
||||
|
||||
np.save(os.path.join(exp_dir, "total_fea.npy"), big_npy)
|
||||
|
||||
n_ivf = min(int(16 * np.sqrt(big_npy.shape[0])), big_npy.shape[0] // 39)
|
||||
|
||||
# index_trained
|
||||
index_trained = faiss.index_factory(
|
||||
256 if version == "v1" else 768, f"IVF{n_ivf},Flat"
|
||||
)
|
||||
index_ivf_trained = faiss.extract_index_ivf(index_trained)
|
||||
index_ivf_trained.nprobe = 1
|
||||
index_trained.train(big_npy)
|
||||
|
||||
index_filename_trained = (
|
||||
f"trained_IVF{n_ivf}_Flat_nprobe_{index_ivf_trained.nprobe}_{version}.index"
|
||||
)
|
||||
index_filepath_trained = os.path.join(exp_dir, index_filename_trained)
|
||||
|
||||
faiss.write_index(index_trained, index_filepath_trained)
|
||||
|
||||
# index_added
|
||||
index_added = faiss.index_factory(
|
||||
256 if version == "v1" else 768, f"IVF{n_ivf},Flat"
|
||||
)
|
||||
index_ivf_added = faiss.extract_index_ivf(index_added)
|
||||
index_ivf_added.nprobe = 1
|
||||
index_added.train(big_npy)
|
||||
|
||||
index_filename_added = (
|
||||
f"added_IVF{n_ivf}_Flat_nprobe_{index_ivf_added.nprobe}_{version}.index"
|
||||
)
|
||||
index_filepath_added = os.path.join(exp_dir, index_filename_added)
|
||||
|
||||
batch_size_add = 8192
|
||||
for i in range(0, big_npy.shape[0], batch_size_add):
|
||||
index_added.add(big_npy[i : i + batch_size_add])
|
||||
|
||||
faiss.write_index(index_added, index_filepath_added)
|
||||
print(f"Saved index file '{index_filepath_added}'")
|
||||
|
||||
except Exception as error:
|
||||
print(f"Failed to train index: {error}")
|
||||
if "one array to concatenate" in str(error):
|
||||
print(
|
||||
"If you are running this code in a virtual environment, make sure you have enough GPU available to generate the Index file."
|
||||
)
|
||||
@@ -0,0 +1,82 @@
|
||||
import os
|
||||
import torch
|
||||
import hashlib
|
||||
import datetime
|
||||
from collections import OrderedDict
|
||||
|
||||
|
||||
def replace_keys_in_dict(d, old_key_part, new_key_part):
|
||||
if isinstance(d, OrderedDict):
|
||||
updated_dict = OrderedDict()
|
||||
else:
|
||||
updated_dict = {}
|
||||
for key, value in d.items():
|
||||
new_key = key.replace(old_key_part, new_key_part)
|
||||
if isinstance(value, dict):
|
||||
value = replace_keys_in_dict(value, old_key_part, new_key_part)
|
||||
updated_dict[new_key] = value
|
||||
return updated_dict
|
||||
|
||||
|
||||
def extract_model(ckpt, sr, if_f0, name, model_dir, epoch, step, version, hps):
|
||||
try:
|
||||
print(f"Saved model '{model_dir}' (epoch {epoch} and step {step})")
|
||||
pth_file = f"{name}_{epoch}e_{step}s.pth"
|
||||
pth_file_old_version_path = os.path.join(
|
||||
model_dir, f"{pth_file}_old_version.pth"
|
||||
)
|
||||
opt = OrderedDict(
|
||||
weight={
|
||||
key: value.half() for key, value in ckpt.items() if "enc_q" not in key
|
||||
}
|
||||
)
|
||||
opt["config"] = [
|
||||
hps.data.filter_length // 2 + 1,
|
||||
32,
|
||||
hps.model.inter_channels,
|
||||
hps.model.hidden_channels,
|
||||
hps.model.filter_channels,
|
||||
hps.model.n_heads,
|
||||
hps.model.n_layers,
|
||||
hps.model.kernel_size,
|
||||
hps.model.p_dropout,
|
||||
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,
|
||||
hps.model.spk_embed_dim,
|
||||
hps.model.gin_channels,
|
||||
hps.data.sampling_rate,
|
||||
]
|
||||
|
||||
opt["epoch"] = epoch
|
||||
opt["step"] = step
|
||||
opt["sr"] = sr
|
||||
opt["f0"] = if_f0
|
||||
opt["version"] = version
|
||||
opt["creation_date"] = datetime.datetime.now().isoformat()
|
||||
|
||||
hash_input = f"{str(ckpt)} {epoch} {step} {datetime.datetime.now().isoformat()}"
|
||||
model_hash = hashlib.sha256(hash_input.encode()).hexdigest()
|
||||
opt["model_hash"] = model_hash
|
||||
|
||||
torch.save(opt, model_dir)
|
||||
|
||||
model = torch.load(model_dir, map_location=torch.device("cpu"))
|
||||
torch.save(
|
||||
replace_keys_in_dict(
|
||||
replace_keys_in_dict(
|
||||
model, ".parametrizations.weight.original1", ".weight_v"
|
||||
),
|
||||
".parametrizations.weight.original0",
|
||||
".weight_g",
|
||||
),
|
||||
pth_file_old_version_path,
|
||||
)
|
||||
os.remove(model_dir)
|
||||
os.rename(pth_file_old_version_path, model_dir)
|
||||
|
||||
except Exception as error:
|
||||
print(error)
|
||||
@@ -0,0 +1,175 @@
|
||||
import os
|
||||
import torch
|
||||
import hashlib
|
||||
import datetime
|
||||
from collections import OrderedDict
|
||||
|
||||
|
||||
def replace_keys_in_dict(d, old_key_part, new_key_part):
|
||||
# Use OrderedDict if the original is an OrderedDict
|
||||
if isinstance(d, OrderedDict):
|
||||
updated_dict = OrderedDict()
|
||||
else:
|
||||
updated_dict = {}
|
||||
for key, value in d.items():
|
||||
# Replace the key part if found
|
||||
new_key = key.replace(old_key_part, new_key_part)
|
||||
# If the value is a dictionary, apply the function recursively
|
||||
if isinstance(value, dict):
|
||||
value = replace_keys_in_dict(value, old_key_part, new_key_part)
|
||||
updated_dict[new_key] = value
|
||||
return updated_dict
|
||||
|
||||
|
||||
def extract_small_model(path, name, sr, if_f0, version, epoch, step):
|
||||
try:
|
||||
ckpt = torch.load(path, map_location="cpu")
|
||||
pth_file = f"{name}.pth"
|
||||
pth_file_old_version_path = os.path.join("logs", f"{pth_file}_old_version.pth")
|
||||
opt = OrderedDict(
|
||||
weight={
|
||||
key: value.half() for key, value in ckpt.items() if "enc_q" not in key
|
||||
}
|
||||
)
|
||||
if "model" in ckpt:
|
||||
ckpt = ckpt["model"]
|
||||
opt = OrderedDict()
|
||||
opt["weight"] = {}
|
||||
for key in ckpt.keys():
|
||||
if "enc_q" in key:
|
||||
continue
|
||||
opt["weight"][key] = ckpt[key].half()
|
||||
if sr == "40000":
|
||||
opt["config"] = [
|
||||
1025,
|
||||
32,
|
||||
192,
|
||||
192,
|
||||
768,
|
||||
2,
|
||||
6,
|
||||
3,
|
||||
0,
|
||||
"1",
|
||||
[3, 7, 11],
|
||||
[[1, 3, 5], [1, 3, 5], [1, 3, 5]],
|
||||
[10, 10, 2, 2],
|
||||
512,
|
||||
[16, 16, 4, 4],
|
||||
109,
|
||||
256,
|
||||
40000,
|
||||
]
|
||||
elif sr == "48000":
|
||||
if version == "v1":
|
||||
opt["config"] = [
|
||||
1025,
|
||||
32,
|
||||
192,
|
||||
192,
|
||||
768,
|
||||
2,
|
||||
6,
|
||||
3,
|
||||
0,
|
||||
"1",
|
||||
[3, 7, 11],
|
||||
[[1, 3, 5], [1, 3, 5], [1, 3, 5]],
|
||||
[10, 6, 2, 2, 2],
|
||||
512,
|
||||
[16, 16, 4, 4, 4],
|
||||
109,
|
||||
256,
|
||||
48000,
|
||||
]
|
||||
else:
|
||||
opt["config"] = [
|
||||
1025,
|
||||
32,
|
||||
192,
|
||||
192,
|
||||
768,
|
||||
2,
|
||||
6,
|
||||
3,
|
||||
0,
|
||||
"1",
|
||||
[3, 7, 11],
|
||||
[[1, 3, 5], [1, 3, 5], [1, 3, 5]],
|
||||
[12, 10, 2, 2],
|
||||
512,
|
||||
[24, 20, 4, 4],
|
||||
109,
|
||||
256,
|
||||
48000,
|
||||
]
|
||||
elif sr == "32000":
|
||||
if version == "v1":
|
||||
opt["config"] = [
|
||||
513,
|
||||
32,
|
||||
192,
|
||||
192,
|
||||
768,
|
||||
2,
|
||||
6,
|
||||
3,
|
||||
0,
|
||||
"1",
|
||||
[3, 7, 11],
|
||||
[[1, 3, 5], [1, 3, 5], [1, 3, 5]],
|
||||
[10, 4, 2, 2, 2],
|
||||
512,
|
||||
[16, 16, 4, 4, 4],
|
||||
109,
|
||||
256,
|
||||
32000,
|
||||
]
|
||||
else:
|
||||
opt["config"] = [
|
||||
513,
|
||||
32,
|
||||
192,
|
||||
192,
|
||||
768,
|
||||
2,
|
||||
6,
|
||||
3,
|
||||
0,
|
||||
"1",
|
||||
[3, 7, 11],
|
||||
[[1, 3, 5], [1, 3, 5], [1, 3, 5]],
|
||||
[10, 8, 2, 2],
|
||||
512,
|
||||
[20, 16, 4, 4],
|
||||
109,
|
||||
256,
|
||||
32000,
|
||||
]
|
||||
|
||||
opt["epoch"] = epoch
|
||||
opt["step"] = step
|
||||
opt["sr"] = sr
|
||||
opt["f0"] = int(if_f0)
|
||||
opt["version"] = version
|
||||
opt["creation_date"] = datetime.datetime.now().isoformat()
|
||||
|
||||
hash_input = f"{str(ckpt)} {epoch} {step} {datetime.datetime.now().isoformat()}"
|
||||
model_hash = hashlib.sha256(hash_input.encode()).hexdigest()
|
||||
opt["model_hash"] = model_hash
|
||||
|
||||
model = torch.load(pth_file_old_version_path, map_location=torch.device("cpu"))
|
||||
torch.save(
|
||||
replace_keys_in_dict(
|
||||
replace_keys_in_dict(
|
||||
model, ".parametrizations.weight.original1", ".weight_v"
|
||||
),
|
||||
".parametrizations.weight.original0",
|
||||
".weight_g",
|
||||
),
|
||||
pth_file_old_version_path,
|
||||
)
|
||||
os.remove(pth_file_old_version_path)
|
||||
os.rename(pth_file_old_version_path, pth_file)
|
||||
except Exception as error:
|
||||
print(error)
|
||||
@@ -0,0 +1,63 @@
|
||||
import os
|
||||
import torch
|
||||
from collections import OrderedDict
|
||||
|
||||
|
||||
def extract(ckpt):
|
||||
a = ckpt["model"]
|
||||
opt = OrderedDict()
|
||||
opt["weight"] = {}
|
||||
for key in a.keys():
|
||||
if "enc_q" in key:
|
||||
continue
|
||||
opt["weight"][key] = a[key]
|
||||
return opt
|
||||
|
||||
|
||||
def model_blender(name, path1, path2, ratio):
|
||||
try:
|
||||
message = f"Model {path1} and {path2} are merged with alpha {ratio}."
|
||||
ckpt1 = torch.load(path1, map_location="cpu")
|
||||
ckpt2 = torch.load(path2, map_location="cpu")
|
||||
cfg = ckpt1["config"]
|
||||
cfg_f0 = ckpt1["f0"]
|
||||
cfg_version = ckpt1["version"]
|
||||
|
||||
if "model" in ckpt1:
|
||||
ckpt1 = extract(ckpt1)
|
||||
else:
|
||||
ckpt1 = ckpt1["weight"]
|
||||
if "model" in ckpt2:
|
||||
ckpt2 = extract(ckpt2)
|
||||
else:
|
||||
ckpt2 = ckpt2["weight"]
|
||||
|
||||
if sorted(list(ckpt1.keys())) != sorted(list(ckpt2.keys())):
|
||||
return "Fail to merge the models. The model architectures are not the same."
|
||||
|
||||
opt = OrderedDict()
|
||||
opt["weight"] = {}
|
||||
for key in ckpt1.keys():
|
||||
if key == "emb_g.weight" and ckpt1[key].shape != ckpt2[key].shape:
|
||||
min_shape0 = min(ckpt1[key].shape[0], ckpt2[key].shape[0])
|
||||
opt["weight"][key] = (
|
||||
ratio * (ckpt1[key][:min_shape0].float())
|
||||
+ (1 - ratio) * (ckpt2[key][:min_shape0].float())
|
||||
).half()
|
||||
else:
|
||||
opt["weight"][key] = (
|
||||
ratio * (ckpt1[key].float()) + (1 - ratio) * (ckpt2[key].float())
|
||||
).half()
|
||||
|
||||
opt["config"] = cfg
|
||||
opt["sr"] = message
|
||||
opt["f0"] = cfg_f0
|
||||
opt["version"] = cfg_version
|
||||
opt["info"] = message
|
||||
|
||||
torch.save(opt, os.path.join("logs", "%s.pth" % name))
|
||||
print(message)
|
||||
return message, os.path.join("logs", "%s.pth" % name)
|
||||
except Exception as error:
|
||||
print(error)
|
||||
return error
|
||||
@@ -0,0 +1,40 @@
|
||||
import torch
|
||||
from datetime import datetime
|
||||
|
||||
|
||||
def prettify_date(date_str):
|
||||
if date_str is None:
|
||||
return "None"
|
||||
try:
|
||||
date_time_obj = datetime.strptime(date_str, "%Y-%m-%dT%H:%M:%S.%f")
|
||||
return date_time_obj.strftime("%Y-%m-%d %H:%M:%S")
|
||||
except ValueError:
|
||||
return "Invalid date format"
|
||||
|
||||
|
||||
def model_information(path):
|
||||
model_data = torch.load(path, map_location="cpu")
|
||||
|
||||
print(f"Loaded model from {path}")
|
||||
|
||||
epochs = model_data.get("epoch", "None")
|
||||
steps = model_data.get("step", "None")
|
||||
sr = model_data.get("sr", "None")
|
||||
f0 = model_data.get("f0", "None")
|
||||
version = model_data.get("version", "None")
|
||||
creation_date = model_data.get("creation_date", "None")
|
||||
model_hash = model_data.get("model_hash", None)
|
||||
|
||||
pitch_guidance = "True" if f0 == 1 else "False"
|
||||
|
||||
creation_date_str = prettify_date(creation_date) if creation_date else "None"
|
||||
|
||||
return (
|
||||
f"Epochs: {epochs}\n"
|
||||
f"Steps: {steps}\n"
|
||||
f"RVC Version: {version}\n"
|
||||
f"Sampling Rate: {sr}\n"
|
||||
f"Pitch Guidance: {pitch_guidance}\n"
|
||||
f"Creation Date: {creation_date_str}\n"
|
||||
f"Hash (ID): {model_hash}"
|
||||
)
|
||||
@@ -0,0 +1,171 @@
|
||||
import numpy as np
|
||||
|
||||
|
||||
class Slicer:
|
||||
def __init__(
|
||||
self,
|
||||
sr: int,
|
||||
threshold: float = -40.0,
|
||||
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("min_length >= min_interval >= hop_size is required")
|
||||
if not max_sil_kept >= hop_size:
|
||||
raise ValueError("max_sil_kept >= hop_size is required")
|
||||
|
||||
min_interval = sr * min_interval / 1000
|
||||
self.threshold = 10 ** (threshold / 20.0)
|
||||
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):
|
||||
start_idx = begin * self.hop_size
|
||||
if len(waveform.shape) > 1:
|
||||
end_idx = min(waveform.shape[1], end * self.hop_size)
|
||||
return waveform[:, start_idx:end_idx]
|
||||
else:
|
||||
end_idx = min(waveform.shape[0], end * self.hop_size)
|
||||
return waveform[start_idx:end_idx]
|
||||
|
||||
def slice(self, waveform):
|
||||
samples = waveform.mean(axis=0) if len(waveform.shape) > 1 else waveform
|
||||
if samples.shape[0] <= self.min_length:
|
||||
return [waveform]
|
||||
|
||||
rms_list = get_rms(
|
||||
y=samples, frame_length=self.win_size, hop_length=self.hop_size
|
||||
).squeeze(0)
|
||||
sil_tags = []
|
||||
silence_start, clip_start = None, 0
|
||||
|
||||
for i, rms in enumerate(rms_list):
|
||||
if rms < self.threshold:
|
||||
if silence_start is None:
|
||||
silence_start = i
|
||||
continue
|
||||
|
||||
if silence_start is None:
|
||||
continue
|
||||
|
||||
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
|
||||
|
||||
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
|
||||
|
||||
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))
|
||||
|
||||
if not sil_tags:
|
||||
return [waveform]
|
||||
else:
|
||||
chunks = []
|
||||
if sil_tags[0][0] > 0:
|
||||
chunks.append(self._apply_slice(waveform, 0, sil_tags[0][0]))
|
||||
|
||||
for i in range(len(sil_tags) - 1):
|
||||
chunks.append(
|
||||
self._apply_slice(waveform, sil_tags[i][1], sil_tags[i + 1][0])
|
||||
)
|
||||
|
||||
if sil_tags[-1][1] < total_frames:
|
||||
chunks.append(
|
||||
self._apply_slice(waveform, sil_tags[-1][1], total_frames)
|
||||
)
|
||||
|
||||
return chunks
|
||||
|
||||
|
||||
def get_rms(
|
||||
y,
|
||||
frame_length=2048,
|
||||
hop_length=512,
|
||||
pad_mode="constant",
|
||||
):
|
||||
padding = (int(frame_length // 2), int(frame_length // 2))
|
||||
y = np.pad(y, padding, mode=pad_mode)
|
||||
|
||||
axis = -1
|
||||
out_strides = y.strides + tuple([y.strides[axis]])
|
||||
x_shape_trimmed = list(y.shape)
|
||||
x_shape_trimmed[axis] -= frame_length - 1
|
||||
out_shape = tuple(x_shape_trimmed) + tuple([frame_length])
|
||||
xw = np.lib.stride_tricks.as_strided(y, shape=out_shape, strides=out_strides)
|
||||
|
||||
if axis < 0:
|
||||
target_axis = axis - 1
|
||||
else:
|
||||
target_axis = axis + 1
|
||||
|
||||
xw = np.moveaxis(xw, -1, target_axis)
|
||||
slices = [slice(None)] * xw.ndim
|
||||
slices[axis] = slice(0, None, hop_length)
|
||||
x = xw[tuple(slices)]
|
||||
|
||||
power = np.mean(np.abs(x) ** 2, axis=-2, keepdims=True)
|
||||
return np.sqrt(power)
|
||||
@@ -0,0 +1,720 @@
|
||||
import torch
|
||||
import sys
|
||||
import os
|
||||
import datetime
|
||||
import json
|
||||
import re
|
||||
|
||||
from utils import (
|
||||
get_hparams,
|
||||
plot_spectrogram_to_numpy,
|
||||
summarize,
|
||||
load_checkpoint,
|
||||
save_checkpoint,
|
||||
latest_checkpoint_path,
|
||||
)
|
||||
from random import randint, shuffle
|
||||
from time import sleep
|
||||
from time import time as ttime
|
||||
|
||||
from torch.cuda.amp import GradScaler, autocast
|
||||
|
||||
from torch.nn import functional as F
|
||||
from torch.nn.parallel import DistributedDataParallel as DDP
|
||||
from torch.utils.data import DataLoader
|
||||
from torch.utils.tensorboard import SummaryWriter
|
||||
import torch.distributed as dist
|
||||
import torch.multiprocessing as mp
|
||||
|
||||
now_dir = os.getcwd()
|
||||
sys.path.append(os.path.join(now_dir))
|
||||
|
||||
|
||||
from data_utils import (
|
||||
DistributedBucketSampler,
|
||||
TextAudioCollate,
|
||||
TextAudioCollateMultiNSFsid,
|
||||
TextAudioLoader,
|
||||
TextAudioLoaderMultiNSFsid,
|
||||
)
|
||||
|
||||
from losses import (
|
||||
discriminator_loss,
|
||||
feature_loss,
|
||||
generator_loss,
|
||||
kl_loss,
|
||||
)
|
||||
from mel_processing import mel_spectrogram_torch, spec_to_mel_torch
|
||||
|
||||
from rvc.train.process.extract_model import extract_model
|
||||
|
||||
from rvc.lib.infer_pack import commons
|
||||
|
||||
hps = get_hparams()
|
||||
if hps.version == "v1":
|
||||
from rvc.lib.infer_pack.models import MultiPeriodDiscriminator
|
||||
from rvc.lib.infer_pack.models import SynthesizerTrnMs256NSFsid as RVC_Model_f0
|
||||
from rvc.lib.infer_pack.models import (
|
||||
SynthesizerTrnMs256NSFsid_nono as RVC_Model_nof0,
|
||||
)
|
||||
elif hps.version == "v2":
|
||||
from rvc.lib.infer_pack.models import (
|
||||
SynthesizerTrnMs768NSFsid as RVC_Model_f0,
|
||||
SynthesizerTrnMs768NSFsid_nono as RVC_Model_nof0,
|
||||
MultiPeriodDiscriminatorV2 as MultiPeriodDiscriminator,
|
||||
)
|
||||
|
||||
os.environ["CUDA_VISIBLE_DEVICES"] = hps.gpus.replace("-", ",")
|
||||
n_gpus = len(hps.gpus.split("-"))
|
||||
|
||||
|
||||
torch.backends.cudnn.deterministic = False
|
||||
torch.backends.cudnn.benchmark = False
|
||||
|
||||
global_step = 0
|
||||
lowest_value = {"step": 0, "value": float("inf"), "epoch": 0}
|
||||
last_loss_gen_all = 0
|
||||
epochs_since_last_lowest = 0
|
||||
|
||||
|
||||
class EpochRecorder:
|
||||
def __init__(self):
|
||||
self.last_time = ttime()
|
||||
|
||||
def record(self):
|
||||
now_time = ttime()
|
||||
elapsed_time = now_time - self.last_time
|
||||
self.last_time = now_time
|
||||
elapsed_time = round(elapsed_time, 1)
|
||||
elapsed_time_str = str(datetime.timedelta(seconds=int(elapsed_time)))
|
||||
current_time = datetime.datetime.now().strftime("%H:%M:%S")
|
||||
return f"time={current_time} | training_speed={elapsed_time_str}"
|
||||
|
||||
|
||||
def main():
|
||||
def start():
|
||||
children = []
|
||||
pid_file_path = os.path.join(now_dir, "rvc", "train", "train_pid.txt")
|
||||
with open(pid_file_path, "w") as pid_file:
|
||||
for i in range(n_gpus):
|
||||
subproc = mp.Process(
|
||||
target=run,
|
||||
args=(i, n_gpus, hps),
|
||||
)
|
||||
children.append(subproc)
|
||||
subproc.start()
|
||||
pid_file.write(str(subproc.pid) + "\n")
|
||||
|
||||
for i in range(n_gpus):
|
||||
children[i].join()
|
||||
|
||||
n_gpus = torch.cuda.device_count()
|
||||
|
||||
if torch.cuda.is_available() == False and torch.backends.mps.is_available() == True:
|
||||
n_gpus = 1
|
||||
if n_gpus < 1:
|
||||
print("GPU not detected, reverting to CPU (not recommended)")
|
||||
n_gpus = 1
|
||||
|
||||
if hps.sync_graph == 1:
|
||||
print(
|
||||
"Sync graph is now activated! With sync graph enabled, the model undergoes a single epoch of training. Once the graphs are synchronized, training proceeds for the previously specified number of epochs."
|
||||
)
|
||||
hps.custom_total_epoch = 1
|
||||
hps.custom_save_every_weights = "1"
|
||||
start()
|
||||
|
||||
logs_path = os.path.join(now_dir, "logs")
|
||||
model_config_file = os.path.join(now_dir, "logs", hps.name, "config.json")
|
||||
rvc_config_file = os.path.join(
|
||||
now_dir, "rvc", "configs", hps.version, str(hps.sample_rate) + ".json"
|
||||
)
|
||||
if not os.path.exists(rvc_config_file):
|
||||
rvc_config_file = os.path.join(
|
||||
now_dir, "rvc", "configs", "v1", str(hps.sample_rate) + ".json"
|
||||
)
|
||||
|
||||
pattern = rf"{os.path.basename(hps.name)}_1e_(\d+)s\.pth"
|
||||
|
||||
for filename in os.listdir(logs_path):
|
||||
match = re.match(pattern, filename)
|
||||
if match:
|
||||
steps = int(match.group(1))
|
||||
|
||||
def edit_config(config_file):
|
||||
with open(config_file, "r", encoding="utf8") as json_file:
|
||||
config_data = json.load(json_file)
|
||||
|
||||
config_data["train"]["log_interval"] = steps
|
||||
|
||||
with open(config_file, "w", encoding="utf8") as json_file:
|
||||
json.dump(
|
||||
config_data,
|
||||
json_file,
|
||||
indent=2,
|
||||
separators=(",", ": "),
|
||||
ensure_ascii=False,
|
||||
)
|
||||
|
||||
edit_config(model_config_file)
|
||||
edit_config(rvc_config_file)
|
||||
|
||||
for root, dirs, files in os.walk(
|
||||
os.path.join(now_dir, "logs", hps.name), topdown=False
|
||||
):
|
||||
for name in files:
|
||||
file_path = os.path.join(root, name)
|
||||
file_name, file_extension = os.path.splitext(name)
|
||||
if file_extension == ".0":
|
||||
os.remove(file_path)
|
||||
elif ("D" in name or "G" in name) and file_extension == ".pth":
|
||||
os.remove(file_path)
|
||||
elif (
|
||||
"added" in name or "trained" in name
|
||||
) and file_extension == ".index":
|
||||
os.remove(file_path)
|
||||
for name in dirs:
|
||||
if name == "eval":
|
||||
folder_path = os.path.join(root, name)
|
||||
for item in os.listdir(folder_path):
|
||||
item_path = os.path.join(folder_path, item)
|
||||
if os.path.isfile(item_path):
|
||||
os.remove(item_path)
|
||||
os.rmdir(folder_path)
|
||||
|
||||
print("Successfully synchronized graphs!")
|
||||
hps.custom_total_epoch = hps.total_epoch
|
||||
hps.custom_save_every_weights = hps.save_every_weights
|
||||
start()
|
||||
else:
|
||||
hps.custom_total_epoch = hps.total_epoch
|
||||
hps.custom_save_every_weights = hps.save_every_weights
|
||||
start()
|
||||
|
||||
|
||||
def run(
|
||||
rank,
|
||||
n_gpus,
|
||||
hps,
|
||||
):
|
||||
global global_step
|
||||
if rank == 0:
|
||||
writer = SummaryWriter(log_dir=hps.model_dir)
|
||||
writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval"))
|
||||
|
||||
os.environ["MASTER_ADDR"] = "localhost"
|
||||
os.environ["MASTER_PORT"] = str(randint(20000, 55555))
|
||||
dist.init_process_group(
|
||||
backend="gloo", init_method="env://", world_size=n_gpus, rank=rank
|
||||
)
|
||||
torch.manual_seed(hps.train.seed)
|
||||
if torch.cuda.is_available():
|
||||
torch.cuda.set_device(rank)
|
||||
|
||||
if hps.if_f0 == 1:
|
||||
train_dataset = TextAudioLoaderMultiNSFsid(hps.data)
|
||||
else:
|
||||
train_dataset = TextAudioLoader(hps.data)
|
||||
|
||||
train_sampler = DistributedBucketSampler(
|
||||
train_dataset,
|
||||
hps.train.batch_size * n_gpus,
|
||||
[100, 200, 300, 400, 500, 600, 700, 800, 900],
|
||||
num_replicas=n_gpus,
|
||||
rank=rank,
|
||||
shuffle=True,
|
||||
)
|
||||
|
||||
if hps.if_f0 == 1:
|
||||
collate_fn = TextAudioCollateMultiNSFsid()
|
||||
else:
|
||||
collate_fn = TextAudioCollate()
|
||||
train_loader = DataLoader(
|
||||
train_dataset,
|
||||
num_workers=4,
|
||||
shuffle=False,
|
||||
pin_memory=True,
|
||||
collate_fn=collate_fn,
|
||||
batch_sampler=train_sampler,
|
||||
persistent_workers=True,
|
||||
prefetch_factor=8,
|
||||
)
|
||||
if hps.if_f0 == 1:
|
||||
net_g = RVC_Model_f0(
|
||||
hps.data.filter_length // 2 + 1,
|
||||
hps.train.segment_size // hps.data.hop_length,
|
||||
**hps.model,
|
||||
is_half=hps.train.fp16_run,
|
||||
sr=hps.sample_rate,
|
||||
)
|
||||
else:
|
||||
net_g = RVC_Model_nof0(
|
||||
hps.data.filter_length // 2 + 1,
|
||||
hps.train.segment_size // hps.data.hop_length,
|
||||
**hps.model,
|
||||
is_half=hps.train.fp16_run,
|
||||
)
|
||||
if torch.cuda.is_available():
|
||||
net_g = net_g.cuda(rank)
|
||||
net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm)
|
||||
if torch.cuda.is_available():
|
||||
net_d = net_d.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,
|
||||
)
|
||||
if torch.cuda.is_available():
|
||||
net_g = DDP(net_g, device_ids=[rank])
|
||||
net_d = DDP(net_d, device_ids=[rank])
|
||||
else:
|
||||
net_g = DDP(net_g)
|
||||
net_d = DDP(net_d)
|
||||
|
||||
try:
|
||||
print("Starting training...")
|
||||
_, _, _, epoch_str = load_checkpoint(
|
||||
latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d, optim_d
|
||||
)
|
||||
_, _, _, epoch_str = load_checkpoint(
|
||||
latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g, optim_g
|
||||
)
|
||||
global_step = (epoch_str - 1) * len(train_loader)
|
||||
|
||||
except:
|
||||
epoch_str = 1
|
||||
global_step = 0
|
||||
if hps.pretrainG != "":
|
||||
if rank == 0:
|
||||
print(f"Loaded pretrained_G {hps.pretrainG}")
|
||||
if hasattr(net_g, "module"):
|
||||
print(
|
||||
net_g.module.load_state_dict(
|
||||
torch.load(hps.pretrainG, map_location="cpu")["model"]
|
||||
)
|
||||
)
|
||||
else:
|
||||
print(
|
||||
net_g.load_state_dict(
|
||||
torch.load(hps.pretrainG, map_location="cpu")["model"]
|
||||
)
|
||||
)
|
||||
if hps.pretrainD != "":
|
||||
if rank == 0:
|
||||
print(f"Loaded pretrained_D {hps.pretrainD}")
|
||||
if hasattr(net_d, "module"):
|
||||
print(
|
||||
net_d.module.load_state_dict(
|
||||
torch.load(hps.pretrainD, map_location="cpu")["model"]
|
||||
)
|
||||
)
|
||||
else:
|
||||
print(
|
||||
net_d.load_state_dict(
|
||||
torch.load(hps.pretrainD, map_location="cpu")["model"]
|
||||
)
|
||||
)
|
||||
|
||||
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
|
||||
)
|
||||
|
||||
scaler = GradScaler(enabled=hps.train.fp16_run)
|
||||
|
||||
cache = []
|
||||
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],
|
||||
scaler,
|
||||
[train_loader, None],
|
||||
[writer, writer_eval],
|
||||
cache,
|
||||
)
|
||||
else:
|
||||
train_and_evaluate(
|
||||
rank,
|
||||
epoch,
|
||||
hps,
|
||||
[net_g, net_d],
|
||||
[optim_g, optim_d],
|
||||
scaler,
|
||||
[train_loader, None],
|
||||
None,
|
||||
cache,
|
||||
)
|
||||
|
||||
scheduler_g.step()
|
||||
scheduler_d.step()
|
||||
|
||||
|
||||
def train_and_evaluate(rank, epoch, hps, nets, optims, scaler, loaders, writers, cache):
|
||||
global global_step, last_loss_gen_all, lowest_value, epochs_since_last_lowest
|
||||
|
||||
if epoch == 1:
|
||||
lowest_value = {"step": 0, "value": float("inf"), "epoch": 0}
|
||||
last_loss_gen_all = 0.0
|
||||
epochs_since_last_lowest = 0
|
||||
|
||||
net_g, net_d = nets
|
||||
optim_g, optim_d = optims
|
||||
train_loader = loaders[0] if loaders is not None else None
|
||||
if writers is not None:
|
||||
writer = writers[0]
|
||||
|
||||
train_loader.batch_sampler.set_epoch(epoch)
|
||||
|
||||
net_g.train()
|
||||
net_d.train()
|
||||
|
||||
if hps.if_cache_data_in_gpu == True:
|
||||
data_iterator = cache
|
||||
if cache == []:
|
||||
for batch_idx, info in enumerate(train_loader):
|
||||
if hps.if_f0 == 1:
|
||||
(
|
||||
phone,
|
||||
phone_lengths,
|
||||
pitch,
|
||||
pitchf,
|
||||
spec,
|
||||
spec_lengths,
|
||||
wave,
|
||||
wave_lengths,
|
||||
sid,
|
||||
) = info
|
||||
else:
|
||||
(
|
||||
phone,
|
||||
phone_lengths,
|
||||
spec,
|
||||
spec_lengths,
|
||||
wave,
|
||||
wave_lengths,
|
||||
sid,
|
||||
) = info
|
||||
if torch.cuda.is_available():
|
||||
phone = phone.cuda(rank, non_blocking=True)
|
||||
phone_lengths = phone_lengths.cuda(rank, non_blocking=True)
|
||||
if hps.if_f0 == 1:
|
||||
pitch = pitch.cuda(rank, non_blocking=True)
|
||||
pitchf = pitchf.cuda(rank, non_blocking=True)
|
||||
sid = sid.cuda(rank, non_blocking=True)
|
||||
spec = spec.cuda(rank, non_blocking=True)
|
||||
spec_lengths = spec_lengths.cuda(rank, non_blocking=True)
|
||||
wave = wave.cuda(rank, non_blocking=True)
|
||||
wave_lengths = wave_lengths.cuda(rank, non_blocking=True)
|
||||
if hps.if_f0 == 1:
|
||||
cache.append(
|
||||
(
|
||||
batch_idx,
|
||||
(
|
||||
phone,
|
||||
phone_lengths,
|
||||
pitch,
|
||||
pitchf,
|
||||
spec,
|
||||
spec_lengths,
|
||||
wave,
|
||||
wave_lengths,
|
||||
sid,
|
||||
),
|
||||
)
|
||||
)
|
||||
else:
|
||||
cache.append(
|
||||
(
|
||||
batch_idx,
|
||||
(
|
||||
phone,
|
||||
phone_lengths,
|
||||
spec,
|
||||
spec_lengths,
|
||||
wave,
|
||||
wave_lengths,
|
||||
sid,
|
||||
),
|
||||
)
|
||||
)
|
||||
else:
|
||||
shuffle(cache)
|
||||
else:
|
||||
data_iterator = enumerate(train_loader)
|
||||
|
||||
epoch_recorder = EpochRecorder()
|
||||
for batch_idx, info in data_iterator:
|
||||
if hps.if_f0 == 1:
|
||||
(
|
||||
phone,
|
||||
phone_lengths,
|
||||
pitch,
|
||||
pitchf,
|
||||
spec,
|
||||
spec_lengths,
|
||||
wave,
|
||||
wave_lengths,
|
||||
sid,
|
||||
) = info
|
||||
else:
|
||||
phone, phone_lengths, spec, spec_lengths, wave, wave_lengths, sid = info
|
||||
if (hps.if_cache_data_in_gpu == False) and torch.cuda.is_available():
|
||||
phone = phone.cuda(rank, non_blocking=True)
|
||||
phone_lengths = phone_lengths.cuda(rank, non_blocking=True)
|
||||
if hps.if_f0 == 1:
|
||||
pitch = pitch.cuda(rank, non_blocking=True)
|
||||
pitchf = pitchf.cuda(rank, non_blocking=True)
|
||||
sid = sid.cuda(rank, non_blocking=True)
|
||||
spec = spec.cuda(rank, non_blocking=True)
|
||||
spec_lengths = spec_lengths.cuda(rank, non_blocking=True)
|
||||
wave = wave.cuda(rank, non_blocking=True)
|
||||
|
||||
with autocast(enabled=hps.train.fp16_run):
|
||||
if hps.if_f0 == 1:
|
||||
(
|
||||
y_hat,
|
||||
ids_slice,
|
||||
x_mask,
|
||||
z_mask,
|
||||
(z, z_p, m_p, logs_p, m_q, logs_q),
|
||||
) = net_g(phone, phone_lengths, pitch, pitchf, spec, spec_lengths, sid)
|
||||
else:
|
||||
(
|
||||
y_hat,
|
||||
ids_slice,
|
||||
x_mask,
|
||||
z_mask,
|
||||
(z, z_p, m_p, logs_p, m_q, logs_q),
|
||||
) = net_g(phone, phone_lengths, spec, spec_lengths, sid)
|
||||
mel = spec_to_mel_torch(
|
||||
spec,
|
||||
hps.data.filter_length,
|
||||
hps.data.n_mel_channels,
|
||||
hps.data.sampling_rate,
|
||||
hps.data.mel_fmin,
|
||||
hps.data.mel_fmax,
|
||||
)
|
||||
y_mel = commons.slice_segments(
|
||||
mel, ids_slice, hps.train.segment_size // hps.data.hop_length
|
||||
)
|
||||
with autocast(enabled=False):
|
||||
y_hat_mel = mel_spectrogram_torch(
|
||||
y_hat.float().squeeze(1),
|
||||
hps.data.filter_length,
|
||||
hps.data.n_mel_channels,
|
||||
hps.data.sampling_rate,
|
||||
hps.data.hop_length,
|
||||
hps.data.win_length,
|
||||
hps.data.mel_fmin,
|
||||
hps.data.mel_fmax,
|
||||
)
|
||||
if hps.train.fp16_run == True:
|
||||
y_hat_mel = y_hat_mel.half()
|
||||
wave = commons.slice_segments(
|
||||
wave, ids_slice * hps.data.hop_length, hps.train.segment_size
|
||||
)
|
||||
|
||||
y_d_hat_r, y_d_hat_g, _, _ = net_d(wave, y_hat.detach())
|
||||
with autocast(enabled=False):
|
||||
loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(
|
||||
y_d_hat_r, y_d_hat_g
|
||||
)
|
||||
optim_d.zero_grad()
|
||||
scaler.scale(loss_disc).backward()
|
||||
scaler.unscale_(optim_d)
|
||||
grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None)
|
||||
scaler.step(optim_d)
|
||||
|
||||
with autocast(enabled=hps.train.fp16_run):
|
||||
y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(wave, y_hat)
|
||||
with autocast(enabled=False):
|
||||
loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel
|
||||
loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl
|
||||
loss_fm = feature_loss(fmap_r, fmap_g)
|
||||
loss_gen, losses_gen = generator_loss(y_d_hat_g)
|
||||
loss_gen_all = loss_gen + loss_fm + loss_mel + loss_kl
|
||||
|
||||
if loss_gen_all < lowest_value["value"]:
|
||||
lowest_value["value"] = loss_gen_all
|
||||
lowest_value["step"] = global_step
|
||||
lowest_value["epoch"] = epoch
|
||||
# print(f'Lowest generator loss updated: {lowest_value["value"]} at epoch {epoch}, step {global_step}')
|
||||
if epoch > lowest_value["epoch"]:
|
||||
print(
|
||||
"Alert: The lower generating loss has been exceeded by a lower loss in a subsequent epoch."
|
||||
)
|
||||
|
||||
optim_g.zero_grad()
|
||||
scaler.scale(loss_gen_all).backward()
|
||||
scaler.unscale_(optim_g)
|
||||
grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None)
|
||||
scaler.step(optim_g)
|
||||
scaler.update()
|
||||
|
||||
if rank == 0:
|
||||
if global_step % hps.train.log_interval == 0:
|
||||
lr = optim_g.param_groups[0]["lr"]
|
||||
# print("Epoch: {} [{:.0f}%]".format(epoch, 100.0 * batch_idx / len(train_loader)))
|
||||
|
||||
if loss_mel > 75:
|
||||
loss_mel = 75
|
||||
if loss_kl > 9:
|
||||
loss_kl = 9
|
||||
|
||||
scalar_dict = {
|
||||
"loss/g/total": loss_gen_all,
|
||||
"loss/d/total": loss_disc,
|
||||
"learning_rate": lr,
|
||||
"grad_norm_d": grad_norm_d,
|
||||
"grad_norm_g": grad_norm_g,
|
||||
}
|
||||
scalar_dict.update(
|
||||
{
|
||||
"loss/g/fm": loss_fm,
|
||||
"loss/g/mel": loss_mel,
|
||||
"loss/g/kl": loss_kl,
|
||||
}
|
||||
)
|
||||
|
||||
scalar_dict.update(
|
||||
{"loss/g/{}".format(i): v for i, v in enumerate(losses_gen)}
|
||||
)
|
||||
scalar_dict.update(
|
||||
{"loss/d_r/{}".format(i): v for i, v in enumerate(losses_disc_r)}
|
||||
)
|
||||
scalar_dict.update(
|
||||
{"loss/d_g/{}".format(i): v for i, v in enumerate(losses_disc_g)}
|
||||
)
|
||||
image_dict = {
|
||||
"slice/mel_org": plot_spectrogram_to_numpy(
|
||||
y_mel[0].data.cpu().numpy()
|
||||
),
|
||||
"slice/mel_gen": plot_spectrogram_to_numpy(
|
||||
y_hat_mel[0].data.cpu().numpy()
|
||||
),
|
||||
"all/mel": plot_spectrogram_to_numpy(mel[0].data.cpu().numpy()),
|
||||
}
|
||||
summarize(
|
||||
writer=writer,
|
||||
global_step=global_step,
|
||||
images=image_dict,
|
||||
scalars=scalar_dict,
|
||||
)
|
||||
|
||||
# optim_g.step()
|
||||
# optim_d.step()
|
||||
|
||||
global_step += 1
|
||||
|
||||
if epoch % hps.save_every_epoch == 0 and rank == 0:
|
||||
checkpoint_suffix = "{}.pth".format(
|
||||
global_step if hps.if_latest == 0 else 2333333
|
||||
)
|
||||
save_checkpoint(
|
||||
net_g,
|
||||
optim_g,
|
||||
hps.train.learning_rate,
|
||||
epoch,
|
||||
os.path.join(hps.model_dir, "G_" + checkpoint_suffix),
|
||||
)
|
||||
save_checkpoint(
|
||||
net_d,
|
||||
optim_d,
|
||||
hps.train.learning_rate,
|
||||
epoch,
|
||||
os.path.join(hps.model_dir, "D_" + checkpoint_suffix),
|
||||
)
|
||||
|
||||
if rank == 0 and hps.custom_save_every_weights == "1":
|
||||
if hasattr(net_g, "module"):
|
||||
ckpt = net_g.module.state_dict()
|
||||
else:
|
||||
ckpt = net_g.state_dict()
|
||||
extract_model(
|
||||
ckpt,
|
||||
hps.sample_rate,
|
||||
hps.if_f0,
|
||||
hps.name,
|
||||
os.path.join(
|
||||
hps.model_dir, "{}_{}e_{}s.pth".format(hps.name, epoch, global_step)
|
||||
),
|
||||
epoch,
|
||||
global_step,
|
||||
hps.version,
|
||||
hps,
|
||||
)
|
||||
|
||||
if hps.overtraining_detector == 1:
|
||||
if lowest_value["value"] < last_loss_gen_all:
|
||||
epochs_since_last_lowest += 1
|
||||
else:
|
||||
epochs_since_last_lowest = 0
|
||||
|
||||
if epochs_since_last_lowest >= hps.overtraining_threshold:
|
||||
print(
|
||||
"Stopping training due to possible overtraining. Lowest generator loss: {} at epoch {}, step {}".format(
|
||||
lowest_value["value"], lowest_value["epoch"], lowest_value["step"]
|
||||
)
|
||||
)
|
||||
os._exit(2333333)
|
||||
|
||||
if rank == 0:
|
||||
if epoch > 1:
|
||||
print(
|
||||
f"{hps.name} | epoch={epoch} | step={global_step} | {epoch_recorder.record()} | lowest_value={lowest_value['value']} (epoch {lowest_value['epoch']} and step {lowest_value['step']})"
|
||||
)
|
||||
else:
|
||||
print(
|
||||
f"{hps.name} | epoch={epoch} | step={global_step} | {epoch_recorder.record()}"
|
||||
)
|
||||
last_loss_gen_all = loss_gen_all
|
||||
|
||||
if epoch >= hps.custom_total_epoch and rank == 0:
|
||||
print(
|
||||
f"Training has been successfully completed with {epoch} epoch, {global_step} steps and {round(loss_gen_all.item(), 3)} loss gen."
|
||||
)
|
||||
print(
|
||||
f"Lowest generator loss: {lowest_value['value']} at epoch {lowest_value['epoch']}, step {lowest_value['step']}"
|
||||
)
|
||||
|
||||
pid_file_path = os.path.join(now_dir, "rvc", "train", "train_pid.txt")
|
||||
os.remove(pid_file_path)
|
||||
|
||||
if hasattr(net_g, "module"):
|
||||
ckpt = net_g.module.state_dict()
|
||||
else:
|
||||
ckpt = net_g.state_dict()
|
||||
|
||||
extract_model(
|
||||
ckpt,
|
||||
hps.sample_rate,
|
||||
hps.if_f0,
|
||||
hps.name,
|
||||
os.path.join(
|
||||
hps.model_dir, "{}_{}e_{}s.pth".format(hps.name, epoch, global_step)
|
||||
),
|
||||
epoch,
|
||||
global_step,
|
||||
hps.version,
|
||||
hps,
|
||||
)
|
||||
sleep(1)
|
||||
os._exit(2333333)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
torch.multiprocessing.set_start_method("spawn")
|
||||
main()
|
||||
@@ -0,0 +1,311 @@
|
||||
import os
|
||||
import glob
|
||||
import json
|
||||
import torch
|
||||
import argparse
|
||||
import numpy as np
|
||||
from scipy.io.wavfile import read
|
||||
from collections import OrderedDict
|
||||
|
||||
|
||||
def replace_keys_in_dict(d, old_key_part, new_key_part):
|
||||
if isinstance(d, OrderedDict):
|
||||
updated_dict = OrderedDict()
|
||||
else:
|
||||
updated_dict = {}
|
||||
for key, value in d.items():
|
||||
if isinstance(key, str):
|
||||
new_key = key.replace(old_key_part, new_key_part)
|
||||
else:
|
||||
new_key = key
|
||||
if isinstance(value, dict):
|
||||
value = replace_keys_in_dict(value, old_key_part, new_key_part)
|
||||
updated_dict[new_key] = value
|
||||
return updated_dict
|
||||
|
||||
|
||||
def load_checkpoint(checkpoint_path, model, optimizer=None, load_opt=1):
|
||||
assert os.path.isfile(checkpoint_path)
|
||||
checkpoint_old_dict = torch.load(checkpoint_path, map_location="cpu")
|
||||
checkpoint_new_version_path = os.path.join(
|
||||
os.path.dirname(checkpoint_path),
|
||||
f"{os.path.splitext(os.path.basename(checkpoint_path))[0]}_new_version.pth",
|
||||
)
|
||||
|
||||
torch.save(
|
||||
replace_keys_in_dict(
|
||||
replace_keys_in_dict(
|
||||
checkpoint_old_dict, ".weight_v", ".parametrizations.weight.original1"
|
||||
),
|
||||
".weight_g",
|
||||
".parametrizations.weight.original0",
|
||||
),
|
||||
checkpoint_new_version_path,
|
||||
)
|
||||
|
||||
os.remove(checkpoint_path)
|
||||
os.rename(checkpoint_new_version_path, checkpoint_path)
|
||||
|
||||
checkpoint_dict = torch.load(checkpoint_path, map_location="cpu")
|
||||
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:
|
||||
new_state_dict[k] = saved_state_dict[k]
|
||||
if saved_state_dict[k].shape != state_dict[k].shape:
|
||||
print(
|
||||
"shape-%s-mismatch|need-%s|get-%s",
|
||||
k,
|
||||
state_dict[k].shape,
|
||||
saved_state_dict[k].shape,
|
||||
)
|
||||
raise KeyError
|
||||
except:
|
||||
print("%s is not in the checkpoint", k)
|
||||
new_state_dict[k] = v
|
||||
if hasattr(model, "module"):
|
||||
model.module.load_state_dict(new_state_dict, strict=False)
|
||||
else:
|
||||
model.load_state_dict(new_state_dict, strict=False)
|
||||
|
||||
iteration = checkpoint_dict["iteration"]
|
||||
learning_rate = checkpoint_dict["learning_rate"]
|
||||
if optimizer is not None and load_opt == 1:
|
||||
optimizer.load_state_dict(checkpoint_dict["optimizer"])
|
||||
print(f"Loaded checkpoint '{checkpoint_path}' (epoch {iteration})")
|
||||
return model, optimizer, learning_rate, iteration
|
||||
|
||||
|
||||
def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path):
|
||||
print(f"Saved model '{checkpoint_path}' (epoch {iteration})")
|
||||
checkpoint_old_version_path = os.path.join(
|
||||
os.path.dirname(checkpoint_path),
|
||||
f"{os.path.splitext(os.path.basename(checkpoint_path))[0]}_old_version.pth",
|
||||
)
|
||||
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,
|
||||
)
|
||||
checkpoint = torch.load(checkpoint_path, map_location=torch.device("cpu"))
|
||||
torch.save(
|
||||
replace_keys_in_dict(
|
||||
replace_keys_in_dict(
|
||||
checkpoint, ".parametrizations.weight.original1", ".weight_v"
|
||||
),
|
||||
".parametrizations.weight.original0",
|
||||
".weight_g",
|
||||
),
|
||||
checkpoint_old_version_path,
|
||||
)
|
||||
os.remove(checkpoint_path)
|
||||
os.rename(checkpoint_old_version_path, checkpoint_path)
|
||||
|
||||
|
||||
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]
|
||||
return x
|
||||
|
||||
|
||||
def plot_spectrogram_to_numpy(spectrogram):
|
||||
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 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():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument(
|
||||
"-se",
|
||||
"--save_every_epoch",
|
||||
type=int,
|
||||
required=True,
|
||||
help="checkpoint save frequency (epoch)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-te", "--total_epoch", type=int, required=True, help="total_epoch"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-pg", "--pretrainG", type=str, default="", help="Pretrained Discriminator path"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-pd", "--pretrainD", type=str, default="", help="Pretrained Generator path"
|
||||
)
|
||||
parser.add_argument("-g", "--gpus", type=str, default="0", help="split by -")
|
||||
parser.add_argument(
|
||||
"-bs", "--batch_size", type=int, required=True, help="batch size"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-e", "--experiment_dir", type=str, required=True, help="experiment dir"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-sr", "--sample_rate", type=str, required=True, help="sample rate, 32k/40k/48k"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-sw",
|
||||
"--save_every_weights",
|
||||
type=str,
|
||||
default="0",
|
||||
help="save the extracted model in weights directory when saving checkpoints",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-v", "--version", type=str, required=True, help="model version"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-f0",
|
||||
"--if_f0",
|
||||
type=int,
|
||||
required=True,
|
||||
help="use f0 as one of the inputs of the model, 1 or 0",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-l",
|
||||
"--if_latest",
|
||||
type=int,
|
||||
required=True,
|
||||
help="if only save the latest G/D pth file, 1 or 0",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-c",
|
||||
"--if_cache_data_in_gpu",
|
||||
type=int,
|
||||
required=True,
|
||||
help="if caching the dataset in GPU memory, 1 or 0",
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"-od",
|
||||
"--overtraining_detector",
|
||||
type=int,
|
||||
required=True,
|
||||
help="Detect overtraining or not, 1 or 0",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-ot",
|
||||
"--overtraining_threshold",
|
||||
type=int,
|
||||
default=50,
|
||||
help="overtraining_threshold",
|
||||
)
|
||||
parser.add_argument(
|
||||
"-sg",
|
||||
"--sync-graph",
|
||||
type=int,
|
||||
required=True,
|
||||
help="Sync graph or not, 1 or 0",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
name = args.experiment_dir
|
||||
experiment_dir = os.path.join("./logs", args.experiment_dir)
|
||||
config_save_path = os.path.join(experiment_dir, "config.json")
|
||||
with open(config_save_path, "r") as f:
|
||||
config = json.load(f)
|
||||
hparams = HParams(**config)
|
||||
hparams.model_dir = hparams.experiment_dir = experiment_dir
|
||||
hparams.save_every_epoch = args.save_every_epoch
|
||||
hparams.name = name
|
||||
hparams.total_epoch = args.total_epoch
|
||||
hparams.pretrainG = args.pretrainG
|
||||
hparams.pretrainD = args.pretrainD
|
||||
hparams.version = args.version
|
||||
hparams.gpus = args.gpus
|
||||
hparams.train.batch_size = args.batch_size
|
||||
hparams.sample_rate = args.sample_rate
|
||||
hparams.if_f0 = args.if_f0
|
||||
hparams.if_latest = args.if_latest
|
||||
hparams.save_every_weights = args.save_every_weights
|
||||
hparams.if_cache_data_in_gpu = args.if_cache_data_in_gpu
|
||||
hparams.data.training_files = f"{experiment_dir}/filelist.txt"
|
||||
hparams.overtraining_detector = args.overtraining_detector
|
||||
hparams.overtraining_threshold = args.overtraining_threshold
|
||||
hparams.sync_graph = args.sync_graph
|
||||
return hparams
|
||||
|
||||
|
||||
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__()
|
||||
Reference in new issue
Block a user