| 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
|
|
|
|
|
|
|
| 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
|
| 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 = False
|
| use_fp32_config()
|
|
|
| if self.n_cpu == 0:
|
| self.n_cpu = 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 != 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)
|
|
|
