|
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) |
|
|
