Spaces:
Sleeping
Sleeping
from multiprocessing import cpu_count | |
from pathlib import Path | |
import torch | |
from fairseq import checkpoint_utils | |
from scipy.io import wavfile | |
from infer_pack.models import ( | |
SynthesizerTrnMs256NSFsid, | |
SynthesizerTrnMs256NSFsid_nono, | |
SynthesizerTrnMs768NSFsid, | |
SynthesizerTrnMs768NSFsid_nono, | |
) | |
from my_utils import load_audio | |
from vc_infer_pipeline import VC | |
BASE_DIR = Path(__file__).resolve().parent.parent | |
# config cpu | |
def use_fp32_config(): | |
for config_file in [ | |
"32k.json", | |
"40k.json", | |
"48k.json", | |
"48k_v2.json", | |
"32k_v2.json", | |
]: | |
with open(f"src/configs/{config_file}", "r") as f: | |
strr = f.read().replace("true", "false") | |
with open(f"src/configs/{config_file}", "w") as f: | |
f.write(strr) | |
class Config: | |
def __init__(self, device, is_half): | |
self.device = device | |
self.is_half = is_half | |
self.n_cpu = 2 # set cpu cores | |
self.gpu_name = None | |
self.gpu_mem = None | |
self.x_pad, self.x_query, self.x_center, self.x_max = self.device_config() | |
def device_config(self) -> tuple: | |
if torch.cuda.is_available(): | |
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 "1060" in self.gpu_name | |
or "1070" in self.gpu_name | |
or "1080" in self.gpu_name | |
): | |
print("16 series/10 series P40 forced single precision") | |
self.is_half = False | |
for config_file in ["32k.json", "40k.json", "48k.json"]: | |
with open(BASE_DIR / "src" / "configs" / config_file, "r") as f: | |
strr = f.read().replace("true", "false") | |
with open(BASE_DIR / "src" / "configs" / config_file, "w") as f: | |
f.write(strr) | |
with open(BASE_DIR / "src" / "trainset_preprocess_pipeline_print.py", "r") as f: | |
strr = f.read().replace("3.7", "3.0") | |
with open(BASE_DIR / "src" / "trainset_preprocess_pipeline_print.py", "w") as f: | |
f.write(strr) | |
else: | |
self.gpu_name = None | |
self.gpu_mem = int( | |
torch.cuda.get_device_properties(i_device).total_memory | |
/ 1024 | |
/ 1024 | |
/ 1024 | |
+ 0.4 | |
) | |
if self.gpu_mem <= 4: | |
with open(BASE_DIR / "src" / "trainset_preprocess_pipeline_print.py", "r") as f: | |
strr = f.read().replace("3.7", "3.0") | |
with open(BASE_DIR / "src" / "trainset_preprocess_pipeline_print.py", "w") as f: | |
f.write(strr) | |
elif torch.backends.mps.is_available(): | |
print("No supported N-card found, use MPS for inference") | |
self.device = "mps" | |
else: | |
print("No supported N-card found, use CPU for inference") | |
self.device = "cpu" | |
self.is_half = True | |
use_fp32_config() # cpu config | |
if self.n_cpu == 0: | |
self.n_cpu = cpu_count() | |
if self.is_half: | |
# 6G memory config | |
x_pad = 3 | |
x_query = 10 | |
x_center = 60 | |
x_max = 65 | |
else: | |
# 5G memory config | |
x_pad = 1 | |
x_query = 6 | |
x_center = 38 | |
x_max = 41 | |
if self.gpu_mem != 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 load_hubert(device, is_half, model_path): | |
models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task([model_path], suffix='', ) | |
hubert = models[0] | |
hubert = hubert.to(device) | |
if is_half: | |
hubert = hubert.half() | |
else: | |
hubert = hubert.float() | |
hubert.eval() | |
return hubert | |
def get_vc(device, is_half, config, model_path): | |
cpt = torch.load(model_path, map_location='cpu') | |
if "config" not in cpt or "weight" not in cpt: | |
raise ValueError(f'Incorrect format for {model_path}. Use a voice model trained using RVC v2 instead.') | |
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 version == "v1": | |
if if_f0 == 1: | |
net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=is_half) | |
else: | |
net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"]) | |
elif version == "v2": | |
if if_f0 == 1: | |
net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=is_half) | |
else: | |
net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"]) | |
del net_g.enc_q | |
print(net_g.load_state_dict(cpt["weight"], strict=False)) | |
net_g.eval().to(device) | |
if is_half: | |
net_g = net_g.half() | |
else: | |
net_g = net_g.float() | |
vc = VC(tgt_sr, config) | |
return cpt, version, net_g, tgt_sr, vc | |
def rvc_infer(index_path, index_rate, input_path, output_path, pitch_change, f0_method, cpt, version, net_g, filter_radius, tgt_sr, rms_mix_rate, protect, crepe_hop_length, vc, hubert_model): | |
audio = load_audio(input_path, 16000) | |
times = [0, 0, 0] | |
if_f0 = cpt.get('f0', 1) | |
audio_opt = vc.pipeline(hubert_model, net_g, 0, audio, input_path, times, pitch_change, f0_method, index_path, index_rate, if_f0, filter_radius, tgt_sr, 0, rms_mix_rate, version, protect, crepe_hop_length) | |
wavfile.write(output_path, tgt_sr, audio_opt) | |