From 76b67842bad8a17078c8a2f7ebd3ab6b90fd4751 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 13 Aug 2023 11:52:51 +0800 Subject: [PATCH] Format code (#989) Co-authored-by: github-actions[bot] --- MDXNet.py | 10 ++- config.py | 26 +++++-- extract_f0_rmvpe_dml.py | 1 + extract_feature_print.py | 9 ++- gui_v1.py | 9 +-- infer-web.py | 112 +++++++++++++++++++----------- lib/infer_pack/models.py | 4 +- lib/rmvpe.py | 142 +++++++++++++++++++++++++-------------- rvc_for_realtime.py | 19 ++++-- vc_infer_pipeline.py | 3 +- 10 files changed, 218 insertions(+), 117 deletions(-) diff --git a/MDXNet.py b/MDXNet.py index df2c672..c519e25 100644 --- a/MDXNet.py +++ b/MDXNet.py @@ -83,12 +83,13 @@ def get_models(device, dim_f, dim_t, n_fft): warnings.filterwarnings("ignore") import sys + now_dir = os.getcwd() sys.path.append(now_dir) from config import Config cpu = torch.device("cpu") -device=Config().device +device = Config().device # if torch.cuda.is_available(): # device = torch.device("cuda:0") # elif torch.backends.mps.is_available(): @@ -104,10 +105,15 @@ class Predictor: device=cpu, dim_f=args.dim_f, dim_t=args.dim_t, n_fft=args.n_fft ) import onnxruntime as ort + print(ort.get_available_providers()) self.model = ort.InferenceSession( os.path.join(args.onnx, self.model_.target_name + ".onnx"), - providers=["CUDAExecutionProvider", "DmlExecutionProvider","CPUExecutionProvider"], + providers=[ + "CUDAExecutionProvider", + "DmlExecutionProvider", + "CPUExecutionProvider", + ], ) print("onnx load done") diff --git a/config.py b/config.py index 1eee375..3f8b625 100644 --- a/config.py +++ b/config.py @@ -36,7 +36,7 @@ class Config: self.iscolab, self.noparallel, self.noautoopen, - self.dml + self.dml, ) = self.arg_parse() self.instead = "" self.x_pad, self.x_query, self.x_center, self.x_max = self.device_config() @@ -71,7 +71,7 @@ class Config: cmd_opts.colab, cmd_opts.noparallel, cmd_opts.noautoopen, - cmd_opts.dml + cmd_opts.dml, ) # has_mps is only available in nightly pytorch (for now) and MasOS 12.3+. @@ -149,26 +149,38 @@ class Config: if self.dml: print("use DirectML instead") try: - os.rename("runtime\Lib\site-packages\onnxruntime","runtime\Lib\site-packages\onnxruntime-cuda") + os.rename( + "runtime\Lib\site-packages\onnxruntime", + "runtime\Lib\site-packages\onnxruntime-cuda", + ) except: pass try: - os.rename("runtime\Lib\site-packages\onnxruntime-dml","runtime\Lib\site-packages\onnxruntime") + os.rename( + "runtime\Lib\site-packages\onnxruntime-dml", + "runtime\Lib\site-packages\onnxruntime", + ) except: - pass import torch_directml + self.device = torch_directml.device(torch_directml.default_device()) self.is_half = False else: if self.instead: print(f"use {self.instead} instead") try: - os.rename("runtime\Lib\site-packages\onnxruntime","runtime\Lib\site-packages\onnxruntime-cuda") + os.rename( + "runtime\Lib\site-packages\onnxruntime", + "runtime\Lib\site-packages\onnxruntime-cuda", + ) except: pass try: - os.rename("runtime\Lib\site-packages\onnxruntime-dml","runtime\Lib\site-packages\onnxruntime") + os.rename( + "runtime\Lib\site-packages\onnxruntime-dml", + "runtime\Lib\site-packages\onnxruntime", + ) except: pass return x_pad, x_query, x_center, x_max diff --git a/extract_f0_rmvpe_dml.py b/extract_f0_rmvpe_dml.py index 6a46fbd..0de50c5 100644 --- a/extract_f0_rmvpe_dml.py +++ b/extract_f0_rmvpe_dml.py @@ -10,6 +10,7 @@ logging.getLogger("numba").setLevel(logging.WARNING) exp_dir = sys.argv[1] import torch_directml + device = torch_directml.device(torch_directml.default_device()) f = open("%s/extract_f0_feature.log" % exp_dir, "a+") diff --git a/extract_feature_print.py b/extract_feature_print.py index e44ca04..e613de4 100644 --- a/extract_feature_print.py +++ b/extract_feature_print.py @@ -3,7 +3,7 @@ import os, sys, traceback os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" os.environ["PYTORCH_MPS_HIGH_WATERMARK_RATIO"] = "0.0" -device=sys.argv[1] +device = sys.argv[1] n_part = int(sys.argv[2]) i_part = int(sys.argv[3]) if len(sys.argv) == 6: @@ -20,7 +20,7 @@ import soundfile as sf import numpy as np import fairseq -if("privateuseone"not in device): +if "privateuseone" not in device: device = "cpu" if torch.cuda.is_available(): device = "cuda" @@ -28,12 +28,15 @@ if("privateuseone"not in device): device = "mps" else: import torch_directml + device = torch_directml.device(torch_directml.default_device()) + def forward_dml(ctx, x, scale): ctx.scale = scale res = x.clone().detach() return res - fairseq.modules.grad_multiply.GradMultiply.forward=forward_dml + + fairseq.modules.grad_multiply.GradMultiply.forward = forward_dml f = open("%s/extract_f0_feature.log" % exp_dir, "a+") diff --git a/gui_v1.py b/gui_v1.py index 3216403..f80fe4c 100644 --- a/gui_v1.py +++ b/gui_v1.py @@ -1,5 +1,6 @@ -import os, sys,pdb -os.environ["OMP_NUM_THREADS"]="2" +import os, sys, pdb + +os.environ["OMP_NUM_THREADS"] = "2" if sys.platform == "darwin": os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" @@ -47,8 +48,9 @@ if __name__ == "__main__": import torchaudio.transforms as tat from i18n import I18nAuto import rvc_for_realtime + i18n = I18nAuto() - device=rvc_for_realtime.config.device + device = rvc_for_realtime.config.device # device = torch.device( # "cuda" # if torch.cuda.is_available() @@ -61,7 +63,6 @@ if __name__ == "__main__": for _ in range(n_cpu): Harvest(inp_q, opt_q).start() - class GUIConfig: def __init__(self) -> None: self.pth_path: str = "" diff --git a/infer-web.py b/infer-web.py index fc1005c..925ee0d 100644 --- a/infer-web.py +++ b/infer-web.py @@ -43,9 +43,7 @@ logging.getLogger("numba").setLevel(logging.WARNING) now_dir = os.getcwd() tmp = os.path.join(now_dir, "TEMP") shutil.rmtree(tmp, ignore_errors=True) -shutil.rmtree( - "%s/runtime/Lib/site-packages/infer_pack" % (now_dir), ignore_errors=True -) +shutil.rmtree("%s/runtime/Lib/site-packages/infer_pack" % (now_dir), ignore_errors=True) shutil.rmtree("%s/runtime/Lib/site-packages/uvr5_pack" % (now_dir), ignore_errors=True) os.makedirs(tmp, exist_ok=True) os.makedirs(os.path.join(now_dir, "logs"), exist_ok=True) @@ -56,12 +54,14 @@ torch.manual_seed(114514) config = Config() -if(config.dml==True): +if config.dml == True: + def forward_dml(ctx, x, scale): ctx.scale = scale res = x.clone().detach() return res - fairseq.modules.grad_multiply.GradMultiply.forward=forward_dml + + fairseq.modules.grad_multiply.GradMultiply.forward = forward_dml i18n = I18nAuto() i18n.print() # 判断是否有能用来训练和加速推理的N卡 @@ -451,15 +451,21 @@ def get_vc(sid, to_return_protect0, to_return_protect1): del net_g, cpt if torch.cuda.is_available(): torch.cuda.empty_cache() - return {"visible": False, "__type__": "update"},{ - "visible": True, - "value": to_return_protect0, - "__type__": "update", - },{ - "visible": True, - "value": to_return_protect1, - "__type__": "update", - },"","" + return ( + {"visible": False, "__type__": "update"}, + { + "visible": True, + "value": to_return_protect0, + "__type__": "update", + }, + { + "visible": True, + "value": to_return_protect1, + "__type__": "update", + }, + "", + "", + ) person = "%s/%s" % (weight_root, sid) print("loading %s" % person) @@ -504,15 +510,13 @@ def get_vc(sid, to_return_protect0, to_return_protect1): net_g = net_g.float() vc = VC(tgt_sr, config) n_spk = cpt["config"][-3] - index={ - "value":get_index_path_from_model(sid), - "__type__": "update" - } + index = {"value": get_index_path_from_model(sid), "__type__": "update"} return ( {"visible": True, "maximum": n_spk, "__type__": "update"}, to_return_protect0, to_return_protect1, - index,index + index, + index, ) @@ -629,7 +633,7 @@ def extract_f0_feature(gpus, n_p, f0method, if_f0, exp_dir, version19, gpus_rmvp ), ).start() else: - if(gpus_rmvpe!="-"): + if gpus_rmvpe != "-": gpus_rmvpe = gpus_rmvpe.split("-") leng = len(gpus_rmvpe) ps = [] @@ -647,7 +651,7 @@ def extract_f0_feature(gpus, n_p, f0method, if_f0, exp_dir, version19, gpus_rmvp ###煞笔gr, popen read都非得全跑完了再一次性读取, 不用gr就正常读一句输出一句;只能额外弄出一个文本流定时读 done = [False] threading.Thread( - target=if_done_multi,# + target=if_done_multi, # args=( done, ps, @@ -655,7 +659,8 @@ def extract_f0_feature(gpus, n_p, f0method, if_f0, exp_dir, version19, gpus_rmvp ).start() else: cmd = config.python_cmd + ' extract_f0_rmvpe_dml.py "%s/logs/%s" ' % ( - now_dir, exp_dir + now_dir, + exp_dir, ) print(cmd) p = Popen( @@ -671,9 +676,7 @@ def extract_f0_feature(gpus, n_p, f0method, if_f0, exp_dir, version19, gpus_rmvp sleep(1) if done[0]: break - with open( - "%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r" - ) as f: + with open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r") as f: log = f.read() print(log) yield log @@ -971,7 +974,7 @@ def click_train( # but4.click(train_index, [exp_dir1], info3) def train_index(exp_dir1, version19): # exp_dir = "%s/logs/%s" % (now_dir, exp_dir1) - exp_dir = "logs/%s" % ( exp_dir1) + exp_dir = "logs/%s" % (exp_dir1) os.makedirs(exp_dir, exist_ok=True) feature_dir = ( "%s/3_feature256" % (exp_dir) @@ -1115,17 +1118,21 @@ def train1key( p = Popen(cmd, shell=True, cwd=now_dir) p.wait() else: - if(gpus_rmvpe!="-"): + if gpus_rmvpe != "-": gpus_rmvpe = gpus_rmvpe.split("-") leng = len(gpus_rmvpe) ps = [] for idx, n_g in enumerate(gpus_rmvpe): - cmd = config.python_cmd + ' extract_f0_rmvpe.py %s %s %s "%s" %s ' % ( - leng, - idx, - n_g, - model_log_dir, - config.is_half, + cmd = ( + config.python_cmd + + ' extract_f0_rmvpe.py %s %s %s "%s" %s ' + % ( + leng, + idx, + n_g, + model_log_dir, + config.is_half, + ) ) yield get_info_str(cmd) p = Popen( @@ -1134,7 +1141,7 @@ def train1key( ps.append(p) for p in ps: p.wait() - else:#dml + else: # dml cmd = config.python_cmd + ' extract_f0_rmvpe_dml.py "%s" ' % ( model_log_dir ) @@ -1316,7 +1323,17 @@ def train1key( index_ivf = faiss.extract_index_ivf(index) # index_ivf.nprobe = 1 index.train(big_npy) - faiss.write_index(index,"%s/trained_IVF%s_Flat_nprobe_%s_%s_%s.index"% (model_log_dir.replace(now_dir+"/",""), n_ivf, index_ivf.nprobe, exp_dir1, version19)) + faiss.write_index( + index, + "%s/trained_IVF%s_Flat_nprobe_%s_%s_%s.index" + % ( + model_log_dir.replace(now_dir + "/", ""), + n_ivf, + index_ivf.nprobe, + exp_dir1, + version19, + ), + ) yield get_info_str("adding index") batch_size_add = 8192 for i in range(0, big_npy.shape[0], batch_size_add): @@ -1324,7 +1341,13 @@ def train1key( faiss.write_index( index, "%s/added_IVF%s_Flat_nprobe_%s_%s_%s.index" - % (model_log_dir.replace(now_dir+"/",""), n_ivf, index_ivf.nprobe, exp_dir1, version19), + % ( + model_log_dir.replace(now_dir + "/", ""), + n_ivf, + index_ivf.nprobe, + exp_dir1, + version19, + ), ) yield get_info_str( "成功构建索引, added_IVF%s_Flat_nprobe_%s_%s_%s.index" @@ -1351,6 +1374,8 @@ def change_info_(ckpt_path): F0GPUVisible = config.dml == False + + def change_f0_method(f0method8): if f0method8 == "rmvpe_gpu": visible = F0GPUVisible @@ -1450,7 +1475,9 @@ with gr.Blocks(title="RVC WebUI") as app: label=i18n( "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比,crepe效果好但吃GPU,rmvpe效果最好且微吃GPU" ), - choices=["pm", "harvest", "crepe", "rmvpe"]if config.dml==False else ["pm", "harvest", "rmvpe"], + choices=["pm", "harvest", "crepe", "rmvpe"] + if config.dml == False + else ["pm", "harvest", "rmvpe"], value="pm", interactive=True, ) @@ -1556,7 +1583,9 @@ with gr.Blocks(title="RVC WebUI") as app: label=i18n( "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比,crepe效果好但吃GPU,rmvpe效果最好且微吃GPU" ), - choices=["pm", "harvest", "crepe", "rmvpe"]if config.dml==False else ["pm", "harvest", "rmvpe"], + choices=["pm", "harvest", "crepe", "rmvpe"] + if config.dml == False + else ["pm", "harvest", "rmvpe"], value="pm", interactive=True, ) @@ -1790,9 +1819,12 @@ with gr.Blocks(title="RVC WebUI") as app: gpus6 = gr.Textbox( label=i18n("以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2"), value=gpus, - interactive=True,visible=F0GPUVisible + interactive=True, + visible=F0GPUVisible, + ) + gpu_info9 = gr.Textbox( + label=i18n("显卡信息"), value=gpu_info, visible=F0GPUVisible ) - gpu_info9 = gr.Textbox(label=i18n("显卡信息"), value=gpu_info,visible=F0GPUVisible) with gr.Column(): f0method8 = gr.Radio( label=i18n( diff --git a/lib/infer_pack/models.py b/lib/infer_pack/models.py index fa45f6b..11266b4 100644 --- a/lib/infer_pack/models.py +++ b/lib/infer_pack/models.py @@ -315,8 +315,8 @@ class SineGen(torch.nn.Module): # generate uv signal uv = torch.ones_like(f0) uv = uv * (f0 > self.voiced_threshold) - if(uv.device.type=="privateuseone"):#for DirectML - uv=uv.float() + if uv.device.type == "privateuseone": # for DirectML + uv = uv.float() return uv def forward(self, f0, upp): diff --git a/lib/rmvpe.py b/lib/rmvpe.py index 25dcb8c..e5fa613 100644 --- a/lib/rmvpe.py +++ b/lib/rmvpe.py @@ -1,14 +1,23 @@ -import torch, numpy as np,pdb +import torch, numpy as np, pdb import torch.nn as nn import torch.nn.functional as F -import torch,pdb +import torch, pdb import numpy as np import torch.nn.functional as F from scipy.signal import get_window -from librosa.util import pad_center, tiny,normalize +from librosa.util import pad_center, tiny, normalize + + ###stft codes from https://github.com/pseeth/torch-stft/blob/master/torch_stft/util.py -def window_sumsquare(window, n_frames, hop_length=200, win_length=800, - n_fft=800, dtype=np.float32, norm=None): +def window_sumsquare( + window, + n_frames, + hop_length=200, + win_length=800, + n_fft=800, + dtype=np.float32, + norm=None, +): """ # from librosa 0.6 Compute the sum-square envelope of a window function at a given hop length. @@ -41,18 +50,20 @@ def window_sumsquare(window, n_frames, hop_length=200, win_length=800, # Compute the squared window at the desired length win_sq = get_window(window, win_length, fftbins=True) - win_sq = normalize(win_sq, norm=norm)**2 + win_sq = normalize(win_sq, norm=norm) ** 2 win_sq = pad_center(win_sq, n_fft) # Fill the envelope for i in range(n_frames): sample = i * hop_length - x[sample:min(n, sample + n_fft)] += win_sq[:max(0, min(n_fft, n - sample))] + x[sample : min(n, sample + n_fft)] += win_sq[: max(0, min(n_fft, n - sample))] return x + class STFT(torch.nn.Module): - def __init__(self, filter_length=1024, hop_length=512, win_length=None, - window='hann'): + def __init__( + self, filter_length=1024, hop_length=512, win_length=None, window="hann" + ): """ This module implements an STFT using 1D convolution and 1D transpose convolutions. This is a bit tricky so there are some cases that probably won't work as working @@ -79,12 +90,15 @@ class STFT(torch.nn.Module): fourier_basis = np.fft.fft(np.eye(self.filter_length)) cutoff = int((self.filter_length / 2 + 1)) - fourier_basis = np.vstack([np.real(fourier_basis[:cutoff, :]),np.imag(fourier_basis[:cutoff, :])]) + fourier_basis = np.vstack( + [np.real(fourier_basis[:cutoff, :]), np.imag(fourier_basis[:cutoff, :])] + ) forward_basis = torch.FloatTensor(fourier_basis[:, None, :]) inverse_basis = torch.FloatTensor( - np.linalg.pinv(scale * fourier_basis).T[:, None, :]) + np.linalg.pinv(scale * fourier_basis).T[:, None, :] + ) - assert (filter_length >= self.win_length) + assert filter_length >= self.win_length # get window and zero center pad it to filter_length fft_window = get_window(window, self.win_length, fftbins=True) fft_window = pad_center(fft_window, size=filter_length) @@ -94,8 +108,8 @@ class STFT(torch.nn.Module): forward_basis *= fft_window inverse_basis *= fft_window - self.register_buffer('forward_basis', forward_basis.float()) - self.register_buffer('inverse_basis', inverse_basis.float()) + self.register_buffer("forward_basis", forward_basis.float()) + self.register_buffer("inverse_basis", inverse_basis.float()) def transform(self, input_data): """Take input data (audio) to STFT domain. @@ -117,23 +131,25 @@ class STFT(torch.nn.Module): # similar to librosa, reflect-pad the input input_data = input_data.view(num_batches, 1, num_samples) # print(1234,input_data.shape) - input_data = F.pad(input_data.unsqueeze(1),(self.pad_amount, self.pad_amount, 0, 0,0,0),mode='reflect').squeeze(1) + input_data = F.pad( + input_data.unsqueeze(1), + (self.pad_amount, self.pad_amount, 0, 0, 0, 0), + mode="reflect", + ).squeeze(1) # print(2333,input_data.shape,self.forward_basis.shape,self.hop_length) # pdb.set_trace() forward_transform = F.conv1d( - input_data, - self.forward_basis, - stride=self.hop_length, - padding=0) + input_data, self.forward_basis, stride=self.hop_length, padding=0 + ) cutoff = int((self.filter_length / 2) + 1) real_part = forward_transform[:, :cutoff, :] imag_part = forward_transform[:, cutoff:, :] - magnitude = torch.sqrt(real_part ** 2 + imag_part ** 2) + magnitude = torch.sqrt(real_part**2 + imag_part**2) # phase = torch.atan2(imag_part.data, real_part.data) - return magnitude#, phase + return magnitude # , phase def inverse(self, magnitude, phase): """Call the inverse STFT (iSTFT), given magnitude and phase tensors produced @@ -150,30 +166,39 @@ class STFT(torch.nn.Module): shape (num_batch, num_samples) """ recombine_magnitude_phase = torch.cat( - [magnitude * torch.cos(phase), magnitude * torch.sin(phase)], dim=1) + [magnitude * torch.cos(phase), magnitude * torch.sin(phase)], dim=1 + ) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, self.inverse_basis, stride=self.hop_length, - padding=0) + padding=0, + ) if self.window is not None: window_sum = window_sumsquare( - self.window, magnitude.size(-1), hop_length=self.hop_length, - win_length=self.win_length, n_fft=self.filter_length, - dtype=np.float32) + self.window, + magnitude.size(-1), + hop_length=self.hop_length, + win_length=self.win_length, + n_fft=self.filter_length, + dtype=np.float32, + ) # remove modulation effects approx_nonzero_indices = torch.from_numpy( - np.where(window_sum > tiny(window_sum))[0]) + np.where(window_sum > tiny(window_sum))[0] + ) window_sum = torch.from_numpy(window_sum).to(inverse_transform.device) - inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] + inverse_transform[:, :, approx_nonzero_indices] /= window_sum[ + approx_nonzero_indices + ] # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length - inverse_transform = inverse_transform[..., self.pad_amount:] - inverse_transform = inverse_transform[..., :self.num_samples] + inverse_transform = inverse_transform[..., self.pad_amount :] + inverse_transform = inverse_transform[..., : self.num_samples] inverse_transform = inverse_transform.squeeze(1) return inverse_transform @@ -191,7 +216,11 @@ class STFT(torch.nn.Module): self.magnitude, self.phase = self.transform(input_data) reconstruction = self.inverse(self.magnitude, self.phase) return reconstruction + + from time import time as ttime + + class BiGRU(nn.Module): def __init__(self, input_features, hidden_features, num_layers): super(BiGRU, self).__init__() @@ -509,14 +538,14 @@ class MelSpectrogram(torch.nn.Module): # print(1111111111) # print(222222222222222,audio.device,self.is_half) if hasattr(self, "stft") == False: - # print(n_fft_new,hop_length_new,win_length_new,audio.shape) - self.stft=STFT( + # print(n_fft_new,hop_length_new,win_length_new,audio.shape) + self.stft = STFT( filter_length=n_fft_new, hop_length=hop_length_new, win_length=win_length_new, - window='hann' + window="hann", ).to(audio.device) - magnitude = self.stft.transform(audio)#phase + magnitude = self.stft.transform(audio) # phase # if (audio.device.type == "privateuseone"): # magnitude=magnitude.to(audio.device) if keyshift != 0: @@ -544,10 +573,13 @@ class RMVPE: self.mel_extractor = MelSpectrogram( is_half, 128, 16000, 1024, 160, None, 30, 8000 ).to(device) - if ("privateuseone" in str(device)): + if "privateuseone" in str(device): import onnxruntime as ort - ort_session = ort.InferenceSession("rmvpe.onnx", providers=["DmlExecutionProvider"]) - self.model=ort_session + + ort_session = ort.InferenceSession( + "rmvpe.onnx", providers=["DmlExecutionProvider"] + ) + self.model = ort_session else: model = E2E(4, 1, (2, 2)) ckpt = torch.load(model_path, map_location="cpu") @@ -566,10 +598,13 @@ class RMVPE: mel = F.pad( mel, (0, 32 * ((n_frames - 1) // 32 + 1) - n_frames), mode="reflect" ) - if("privateuseone" in str(self.device) ): + if "privateuseone" in str(self.device): onnx_input_name = self.model.get_inputs()[0].name onnx_outputs_names = self.model.get_outputs()[0].name - hidden = self.model.run([onnx_outputs_names], input_feed={onnx_input_name: mel.cpu().numpy()})[0] + hidden = self.model.run( + [onnx_outputs_names], + input_feed={onnx_input_name: mel.cpu().numpy()}, + )[0] else: hidden = self.model(mel) return hidden[:, :n_frames] @@ -583,25 +618,27 @@ class RMVPE: def infer_from_audio(self, audio, thred=0.03): # torch.cuda.synchronize() - t0=ttime() - mel = self.mel_extractor(torch.from_numpy(audio).float().to(self.device).unsqueeze(0), center=True) + t0 = ttime() + mel = self.mel_extractor( + torch.from_numpy(audio).float().to(self.device).unsqueeze(0), center=True + ) # print(123123123,mel.device.type) # torch.cuda.synchronize() - t1=ttime() + t1 = ttime() hidden = self.mel2hidden(mel) # torch.cuda.synchronize() - t2=ttime() + t2 = ttime() # print(234234,hidden.device.type) - if("privateuseone" not in str(self.device)): + if "privateuseone" not in str(self.device): hidden = hidden.squeeze(0).cpu().numpy() else: - hidden=hidden[0] + hidden = hidden[0] if self.is_half == True: hidden = hidden.astype("float32") f0 = self.decode(hidden, thred=thred) # torch.cuda.synchronize() - t3=ttime() + t3 = ttime() # print("hmvpe:%s\t%s\t%s\t%s"%(t1-t0,t2-t1,t3-t2,t3-t0)) return f0 @@ -632,8 +669,9 @@ class RMVPE: return devided -if __name__ == '__main__': +if __name__ == "__main__": import soundfile as sf, librosa + audio, sampling_rate = sf.read(r"C:\Users\liujing04\Desktop\Z\冬之花clip1.wav") if len(audio.shape) > 1: audio = librosa.to_mono(audio.transpose(1, 0)) @@ -642,13 +680,13 @@ if __name__ == '__main__': audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000) model_path = r"D:\BaiduNetdiskDownload\RVC-beta-v2-0727AMD_realtime\rmvpe.pt" thred = 0.03 # 0.01 - device = 'cuda' if torch.cuda.is_available() else 'cpu' - rmvpe = RMVPE(model_path,is_half=False, device=device) - t0=ttime() + device = "cuda" if torch.cuda.is_available() else "cpu" + rmvpe = RMVPE(model_path, is_half=False, device=device) + t0 = ttime() f0 = rmvpe.infer_from_audio(audio, thred=thred) # f0 = rmvpe.infer_from_audio(audio, thred=thred) # f0 = rmvpe.infer_from_audio(audio, thred=thred) # f0 = rmvpe.infer_from_audio(audio, thred=thred) # f0 = rmvpe.infer_from_audio(audio, thred=thred) - t1=ttime() - print(f0.shape,t1-t0) + t1 = ttime() + print(f0.shape, t1 - t0) diff --git a/rvc_for_realtime.py b/rvc_for_realtime.py index 3a4af04..e377016 100644 --- a/rvc_for_realtime.py +++ b/rvc_for_realtime.py @@ -18,12 +18,16 @@ from multiprocessing import Manager as M mm = M() config = Config() -if(config.dml==True): +if config.dml == True: + def forward_dml(ctx, x, scale): ctx.scale = scale res = x.clone().detach() return res - fairseq.modules.grad_multiply.GradMultiply.forward=forward_dml + + fairseq.modules.grad_multiply.GradMultiply.forward = forward_dml + + # config.device=torch.device("cpu")########强制cpu测试 # config.is_half=False########强制cpu测试 class RVC: @@ -183,8 +187,8 @@ class RVC: return self.get_f0_post(f0bak) def get_f0_crepe(self, x, f0_up_key): - if self.device.type == "privateuseone":###不支持dml，cpu又太慢用不成，拿pm顶替 - return self.get_f0(x, f0_up_key,1,"pm") + if self.device.type == "privateuseone": ###不支持dml，cpu又太慢用不成，拿pm顶替 + return self.get_f0(x, f0_up_key, 1, "pm") audio = torch.tensor(np.copy(x))[None].float() # print("using crepe,device:%s"%self.device) f0, pd = torchcrepe.predict( @@ -209,12 +213,15 @@ class RVC: def get_f0_rmvpe(self, x, f0_up_key): if hasattr(self, "model_rmvpe") == False: from lib.rmvpe import RMVPE + print("loading rmvpe model") self.model_rmvpe = RMVPE( # "rmvpe.pt", is_half=self.is_half if self.device.type!="privateuseone" else False, device=self.device if self.device.type!="privateuseone"else "cpu"####dml时强制对rmvpe用cpu跑 # "rmvpe.pt", is_half=False, device=self.device####dml配置 - # "rmvpe.pt", is_half=False, device="cpu"####锁定cpu配置 - "rmvpe.pt", is_half=self.is_half, device=self.device####正常逻辑 + # "rmvpe.pt", is_half=False, device="cpu"####锁定cpu配置 + "rmvpe.pt", + is_half=self.is_half, + device=self.device, ####正常逻辑 ) # self.model_rmvpe = RMVPE("aug2_58000_half.pt", is_half=self.is_half, device=self.device) f0 = self.model_rmvpe.infer_from_audio(x, thred=0.03) diff --git a/vc_infer_pipeline.py b/vc_infer_pipeline.py index 87ab2ef..980fc21 100644 --- a/vc_infer_pipeline.py +++ b/vc_infer_pipeline.py @@ -130,13 +130,14 @@ class VC(object): elif f0_method == "rmvpe": if hasattr(self, "model_rmvpe") == False: from lib.rmvpe import RMVPE + print("loading rmvpe model") self.model_rmvpe = RMVPE( "rmvpe.pt", is_half=self.is_half, device=self.device ) f0 = self.model_rmvpe.infer_from_audio(x, thred=0.03) - if("privateuseone"in str(self.device)):#clean ortruntime memory + if "privateuseone" in str(self.device): # clean ortruntime memory del self.model_rmvpe.model del self.model_rmvpe print("cleaning ortruntime memory")