Upload 14 files

.gitattributes

@@ -25,7 +25,6 @@
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
 *.wasm filter=lfs diff=lfs merge=lfs -text
@@ -33,3 +32,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ffmpeg.exe filter=lfs diff=lfs merge=lfs -text
+ffprobe.exe filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,3 @@
 ---
-license: unknown
+license: mit
 ---

config.py

@@ -0,0 +1,38 @@
+############离线VC参数
+inp_root=r"白鹭霜华长条"#对输入目录下所有音频进行转换，别放非音频文件
+opt_root=r"opt"#输出目录
+f0_up_key=0#升降调，整数，男转女12，女转男-12
+person=r"weights\洛天依v3.pt"#目前只有洛天依v3
+############硬件参数
+device = "cuda:0"#填写cuda:x或cpu，x指代第几张卡，只支持N卡加速
+is_half=True#9-10-20-30-40系显卡无脑True，不影响质量，>=20显卡开启有加速
+n_cpu=0#默认0用上所有线程，写数字限制CPU资源使用
+############下头别动
+import torch
+if(torch.cuda.is_available()==False):
+    print("没有发现支持的N卡，使用CPU进行推理")
+    device="cpu"
+    is_half=False
+if(device!="cpu"):
+    gpu_name=torch.cuda.get_device_name(int(device.split(":")[-1]))
+    if("16"in gpu_name):
+        print("16系显卡强制单精度")
+        is_half=False
+from multiprocessing import cpu_count
+if(n_cpu==0):n_cpu=cpu_count()
+if(is_half==True):
+    #6G显存配置
+    x_pad       =   3
+    x_query     =   10
+    x_center    =   60
+    x_max       =   65
+else:
+    #5G显存配置
+    x_pad       =   1
+    # x_query     =   6
+    # x_center    =   30
+    # x_max       =   32
+    #6G显存配置
+    x_query     =   6
+    x_center    =   38
+    x_max       =   41

go-web.bat

@@ -0,0 +1 @@
+runtime\python.exe infer-web.py

go.bat

@@ -0,0 +1 @@
+runtime\python.exe infer.py

infer-web.py

@@ -0,0 +1,193 @@
+import torch, pdb, os,traceback,sys,warnings,shutil
+now_dir=os.getcwd()
+sys.path.append(now_dir)
+tmp=os.path.join(now_dir,"TEMP")
+shutil.rmtree(tmp,ignore_errors=True)
+os.makedirs(tmp,exist_ok=True)
+os.environ["TEMP"]=tmp
+warnings.filterwarnings("ignore")
+torch.manual_seed(114514)
+from infer_pack.models import SynthesizerTrnMs256NSF as SynthesizerTrn256
+from scipy.io import wavfile
+from fairseq import checkpoint_utils
+import gradio as gr
+import librosa
+import logging
+from vc_infer_pipeline import VC
+import soundfile as sf
+from config import is_half,device,is_half
+from infer_uvr5 import _audio_pre_
+logging.getLogger('numba').setLevel(logging.WARNING)
+
+models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(["hubert_base.pt"],suffix="",)
+hubert_model = models[0]
+hubert_model = hubert_model.to(device)
+if(is_half):hubert_model = hubert_model.half()
+else:hubert_model = hubert_model.float()
+hubert_model.eval()
+
+
+weight_root="weights"
+weight_uvr5_root="uvr5_weights"
+names=[]
+for name in os.listdir(weight_root):names.append(name.replace(".pt",""))
+uvr5_names=[]
+for name in os.listdir(weight_uvr5_root):uvr5_names.append(name.replace(".pth",""))
+
+def get_vc(sid):
+    person = "%s/%s.pt" % (weight_root, sid)
+    cpt = torch.load(person, map_location="cpu")
+    dv = cpt["dv"]
+    tgt_sr = cpt["config"][-1]
+    net_g = SynthesizerTrn256(*cpt["config"], is_half=is_half)
+    net_g.load_state_dict(cpt["weight"], strict=True)
+    net_g.eval().to(device)
+    if (is_half):net_g = net_g.half()
+    else:net_g = net_g.float()
+    vc = VC(tgt_sr, device, is_half)
+    return dv,tgt_sr,net_g,vc
+
+def vc_single(sid,input_audio,f0_up_key,f0_file):
+    if input_audio is None:return "You need to upload an audio", None
+    f0_up_key = int(f0_up_key)
+    try:
+        if(type(input_audio)==str):
+            print("processing %s" % input_audio)
+            audio, sampling_rate = sf.read(input_audio)
+        else:
+            sampling_rate, audio = input_audio
+            audio = audio.astype("float32") / 32768
+        if(type(sid)==str):dv, tgt_sr, net_g, vc=get_vc(sid)
+        else:dv,tgt_sr,net_g,vc=sid
+        if len(audio.shape) > 1:
+            audio = librosa.to_mono(audio.transpose(1, 0))
+        if sampling_rate != 16000:
+            audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
+        times = [0, 0, 0]
+        audio_opt=vc.pipeline(hubert_model,net_g,dv,audio,times,f0_up_key,f0_file=f0_file)
+        print(times)
+        return "Success", (tgt_sr, audio_opt)
+    except:
+        info=traceback.format_exc()
+        print(info)
+        return info,(None,None)
+    finally:
+        print("clean_empty_cache")
+        del net_g,dv,vc
+        torch.cuda.empty_cache()
+
+def vc_multi(sid,dir_path,opt_root,paths,f0_up_key):
+    try:
+        dir_path=dir_path.strip(" ")#防止小白拷路径头尾带了空格
+        opt_root=opt_root.strip(" ")
+        os.makedirs(opt_root, exist_ok=True)
+        dv, tgt_sr, net_g, vc = get_vc(sid)
+        try:
+            if(dir_path!=""):paths=[os.path.join(dir_path,name)for name in os.listdir(dir_path)]
+            else:paths=[path.name for path in paths]
+        except:
+            traceback.print_exc()
+            paths = [path.name for path in paths]
+        infos=[]
+        for path in paths:
+            info,opt=vc_single([dv,tgt_sr,net_g,vc],path,f0_up_key,f0_file=None)
+            if(info=="Success"):
+                try:
+                    tgt_sr,audio_opt=opt
+                    wavfile.write("%s/%s" % (opt_root, os.path.basename(path)), tgt_sr, audio_opt)
+                except:
+                    info=traceback.format_exc()
+            infos.append("%s->%s"%(os.path.basename(path),info))
+        return "\n".join(infos)
+    except:
+        return traceback.format_exc()
+    finally:
+        print("clean_empty_cache")
+        del net_g,dv,vc
+        torch.cuda.empty_cache()
+
+def uvr(model_name,inp_root,save_root_vocal,save_root_ins):
+    infos = []
+    try:
+        inp_root = inp_root.strip(" ")# 防止小白拷路径头尾带了空格
+        save_root_vocal = save_root_vocal.strip(" ")
+        save_root_ins = save_root_ins.strip(" ")
+        pre_fun = _audio_pre_(model_path=os.path.join(weight_uvr5_root,model_name+".pth"), device=device, is_half=is_half)
+        for name in os.listdir(inp_root):
+            inp_path=os.path.join(inp_root,name)
+            try:
+                pre_fun._path_audio_(inp_path , save_root_ins,save_root_vocal)
+                infos.append("%s->Success"%(os.path.basename(inp_path)))
+            except:
+                infos.append("%s->%s" % (os.path.basename(inp_path),traceback.format_exc()))
+    except:
+        infos.append(traceback.format_exc())
+    finally:
+        try:
+            del pre_fun.model
+            del pre_fun
+        except:
+            traceback.print_exc()
+        print("clean_empty_cache")
+        torch.cuda.empty_cache()
+    return "\n".join(infos)
+
+with gr.Blocks() as app:
+    with gr.Tabs():
+        with gr.TabItem("推理"):
+            with gr.Group():
+                gr.Markdown(value="""
+                    使用软件者、传播软件导出的声音者自负全责。如不认可该条款，则不能使用/引用软件包内所有代码和文件。<br>
+                    目前仅开放白菜音色，后续将扩展为本地训练推理工具，用户可训练自己的音色进行社区共享。<br>
+                    男转女推荐+12key，女转男推荐-12key，如果音域爆炸导致音色失真也可以自己调整到合适音域
+                    """)
+                with gr.Row():
+                    with gr.Column():
+                        sid0 = gr.Dropdown(label="音色", choices=names)
+                        vc_transform0 = gr.Number(label="变调（整数，半音数量，升八度12降八度-12）", value=12)
+                        f0_file = gr.File(label="F0曲线文件，可选，一行一个音高，代替默认F0及升降调")
+                    input_audio0 = gr.Audio(label="上传音频")
+                    but0=gr.Button("转换", variant="primary")
+                    with gr.Column():
+                        vc_output1 = gr.Textbox(label="输出信息")
+                        vc_output2 = gr.Audio(label="输出音频")
+                    but0.click(vc_single, [sid0, input_audio0, vc_transform0,f0_file], [vc_output1, vc_output2])
+            with gr.Group():
+                gr.Markdown(value="""
+                    批量转换，上传多个音频文件，在指定文件夹（默认opt）下输出转换的音频。<br>
+                    合格的文件夹路径格式举例：E:\codes\py39\\vits_vc_gpu\白鹭霜华测试样例（去文件管理器地址栏拷就行了）
+                    """)
+                with gr.Row():
+                    with gr.Column():
+                        sid1 = gr.Dropdown(label="音色", choices=names)
+                        vc_transform1 = gr.Number(label="变调（整数，半音数量，升八度12降八度-12）", value=12)
+                        opt_input = gr.Textbox(label="指定输出文件夹",value="opt")
+                    with gr.Column():
+                        dir_input = gr.Textbox(label="输入待处理音频文件夹路径")
+                        inputs = gr.File(file_count="multiple", label="也可批量输入音频文件，二选一，优先读文件夹")
+                    but1=gr.Button("转换", variant="primary")
+                    vc_output3 = gr.Textbox(label="输出信息")
+                    but1.click(vc_multi, [sid1, dir_input,opt_input,inputs, vc_transform1], [vc_output3])
+
+        with gr.TabItem("数据处理"):
+            with gr.Group():
+                gr.Markdown(value="""
+                    人声伴奏分离批量处理，使用UVR5模型。<br>
+                    不带和声用HP2，带和声且提取的人声不需要和声用HP5<br>
+                    合格的文件夹路径格式举例：E:\codes\py39\\vits_vc_gpu\白鹭霜华测试样例（去文件管理器地址栏拷就行了）
+                    """)
+                with gr.Row():
+                    with gr.Column():
+                        dir_wav_input = gr.Textbox(label="输入待处理音频文件夹路径")
+                        wav_inputs = gr.File(file_count="multiple", label="也可批量输入音频文件，二选一，优先读文件夹")
+                    with gr.Column():
+                        model_choose = gr.Dropdown(label="模型", choices=uvr5_names)
+                        opt_vocal_root = gr.Textbox(label="指定输出人声文件夹",value="opt")
+                        opt_ins_root = gr.Textbox(label="指定输出乐器文件夹",value="opt")
+                    but2=gr.Button("转换", variant="primary")
+                    vc_output4 = gr.Textbox(label="输出信息")
+                    but2.click(uvr, [model_choose, dir_wav_input,opt_vocal_root,opt_ins_root], [vc_output4])
+        with gr.TabItem("训练-待开放"):pass
+
+    # app.launch(server_name="0.0.0.0",server_port=7860)
+    app.launch(server_name="127.0.0.1",server_port=7860)

infer.py

@@ -0,0 +1,48 @@
+import torch, pdb, os,sys,librosa,warnings,traceback
+warnings.filterwarnings("ignore")
+torch.manual_seed(114514)
+sys.path.append(os.getcwd())
+from config import inp_root,opt_root,f0_up_key,person,is_half,device
+os.makedirs(opt_root,exist_ok=True)
+import soundfile as sf
+from infer_pack.models import SynthesizerTrnMs256NSF as SynthesizerTrn256
+from scipy.io import wavfile
+from fairseq import checkpoint_utils
+import scipy.signal as signal
+from vc_infer_pipeline import VC
+
+models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(["hubert_base.pt"],suffix="",)
+model = models[0]
+model = model.to(device)
+if(is_half):model = model.half()
+else:model = model.float()
+model.eval()
+
+cpt=torch.load(person,map_location="cpu")
+dv=cpt["dv"]
+tgt_sr=cpt["config"][-1]
+net_g = SynthesizerTrn256(*cpt["config"],is_half=is_half)
+net_g.load_state_dict(cpt["weight"],strict=True)
+net_g.eval().to(device)
+if(is_half):net_g = net_g.half()
+else:net_g = net_g.float()
+
+vc=VC(tgt_sr,device,is_half)
+
+for name in os.listdir(inp_root):
+    try:
+        wav_path="%s\%s"%(inp_root,name)
+        print("processing %s"%wav_path)
+        audio, sampling_rate = sf.read(wav_path)
+        if len(audio.shape) > 1:
+            audio = librosa.to_mono(audio.transpose(1, 0))
+        if sampling_rate != vc.sr:
+            audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=vc.sr)
+
+        times = [0, 0, 0]
+        audio_opt=vc.pipeline(model,net_g,dv,audio,times,f0_up_key,f0_file=None)
+        wavfile.write("%s/%s"%(opt_root,name), tgt_sr, audio_opt)
+    except:
+        traceback.print_exc()
+
+print(times)

infer_uvr5.py

@@ -0,0 +1,108 @@
+import os,sys,torch,warnings,pdb
+warnings.filterwarnings("ignore")
+import librosa
+import importlib
+import  numpy as np
+import hashlib , math
+from tqdm import tqdm
+from uvr5_pack.lib_v5 import spec_utils
+from uvr5_pack.utils import _get_name_params,inference
+from uvr5_pack.lib_v5.model_param_init import ModelParameters
+from scipy.io import wavfile
+
+class  _audio_pre_():
+    def __init__(self, model_path,device,is_half):
+        self.model_path = model_path
+        self.device = device
+        self.data = {
+            # Processing Options
+            'postprocess': False,
+            'tta': False,
+            # Constants
+            'window_size': 512,
+            'agg': 10,
+            'high_end_process': 'mirroring',
+        }
+        nn_arch_sizes = [
+            31191, # default
+            33966,61968, 123821, 123812, 537238 # custom
+        ]
+        self.nn_architecture = list('{}KB'.format(s) for s in nn_arch_sizes)
+        model_size = math.ceil(os.stat(model_path ).st_size / 1024)
+        nn_architecture = '{}KB'.format(min(nn_arch_sizes, key=lambda x:abs(x-model_size)))
+        nets = importlib.import_module('uvr5_pack.lib_v5.nets' + f'_{nn_architecture}'.replace('_{}KB'.format(nn_arch_sizes[0]), ''), package=None)
+        model_hash = hashlib.md5(open(model_path,'rb').read()).hexdigest()
+        param_name ,model_params_d = _get_name_params(model_path , model_hash)
+
+        mp = ModelParameters(model_params_d)
+        model = nets.CascadedASPPNet(mp.param['bins'] * 2)
+        cpk = torch.load( model_path , map_location='cpu')  
+        model.load_state_dict(cpk)
+        model.eval()
+        if(is_half==True):model = model.half().to(device)
+        else:model = model.to(device)
+
+        self.mp = mp
+        self.model = model
+
+    def _path_audio_(self, music_file ,ins_root=None,vocal_root=None):
+        if(ins_root is None and vocal_root is None):return "No save root."
+        name=os.path.basename(music_file)
+        if(ins_root is not None):os.makedirs(ins_root, exist_ok=True)
+        if(vocal_root is not None):os.makedirs(vocal_root , exist_ok=True)
+        X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
+        bands_n = len(self.mp.param['band'])
+        # print(bands_n)
+        for d in range(bands_n, 0, -1): 
+            bp = self.mp.param['band'][d]
+            if d == bands_n: # high-end band
+                X_wave[d], _ = librosa.core.load(
+                    music_file, bp['sr'], False, dtype=np.float32, res_type=bp['res_type'])
+                if X_wave[d].ndim == 1:
+                    X_wave[d] = np.asfortranarray([X_wave[d], X_wave[d]])
+            else: # lower bands
+                X_wave[d] = librosa.core.resample(X_wave[d+1], self.mp.param['band'][d+1]['sr'], bp['sr'], res_type=bp['res_type'])
+            # Stft of wave source
+            X_spec_s[d] = spec_utils.wave_to_spectrogram_mt(X_wave[d], bp['hl'], bp['n_fft'], self.mp.param['mid_side'], self.mp.param['mid_side_b2'], self.mp.param['reverse'])
+            # pdb.set_trace()
+            if d == bands_n and self.data['high_end_process'] != 'none':
+                input_high_end_h = (bp['n_fft']//2 - bp['crop_stop']) + ( self.mp.param['pre_filter_stop'] - self.mp.param['pre_filter_start'])
+                input_high_end = X_spec_s[d][:, bp['n_fft']//2-input_high_end_h:bp['n_fft']//2, :]
+
+        X_spec_m = spec_utils.combine_spectrograms(X_spec_s, self.mp)
+        aggresive_set = float(self.data['agg']/100)
+        aggressiveness = {'value': aggresive_set, 'split_bin': self.mp.param['band'][1]['crop_stop']}
+        with torch.no_grad():
+            pred, X_mag, X_phase = inference(X_spec_m,self.device,self.model, aggressiveness,self.data)
+        # Postprocess
+        if self.data['postprocess']:
+            pred_inv = np.clip(X_mag - pred, 0, np.inf)
+            pred = spec_utils.mask_silence(pred, pred_inv)
+        y_spec_m = pred * X_phase
+        v_spec_m = X_spec_m - y_spec_m
+
+        if (ins_root is not None):
+            if self.data['high_end_process'].startswith('mirroring'):
+                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'], y_spec_m, input_high_end, self.mp)
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp,input_high_end_h, input_high_end_)
+            else:
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp)
+            print ('%s instruments done'%name)
+            wavfile.write(os.path.join(ins_root, 'instrument_{}.wav'.format(name) ), self.mp.param['sr'], (np.array(wav_instrument)*32768).astype("int16"))  #
+        if (vocal_root is not None):
+            if self.data['high_end_process'].startswith('mirroring'):
+                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'],  v_spec_m, input_high_end, self.mp)
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp, input_high_end_h, input_high_end_)
+            else:
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp)
+            print ('%s vocals done'%name)
+            wavfile.write(os.path.join(vocal_root , 'vocal_{}.wav'.format(name) ), self.mp.param['sr'], (np.array(wav_vocals)*32768).astype("int16"))
+
+if __name__ == '__main__':
+    device = 'cuda'
+    is_half=True
+    model_path='uvr5_weights/2_HP-UVR.pth'
+    pre_fun = _audio_pre_(model_path=model_path,device=device,is_half=True)
+    audio_path = '神女劈观.aac'
+    save_path = 'opt'
+    pre_fun._path_audio_(audio_path , save_path,save_path)

myinfer-v2-0528.py

@@ -0,0 +1,175 @@
+'''
+v1
+runtime\python.exe myinfer-v2-0528.py 0 "E:\codes\py39\RVC-beta\todo-songs\1111.wav" "E:\codes\py39\logs\mi-test\added_IVF677_Flat_nprobe_7.index" harvest "test.wav" "E:\codes\py39\test-20230416b\weights\mi-test.pth" 0.66 cuda:0 True 3 0 1 0.33
+v2
+runtime\python.exe myinfer-v2-0528.py 0 "E:\codes\py39\RVC-beta\todo-songs\1111.wav" "E:\codes\py39\test-20230416b\logs\mi-test-v2\aadded_IVF677_Flat_nprobe_1_v2.index" harvest "test_v2.wav" "E:\codes\py39\test-20230416b\weights\mi-test-v2.pth" 0.66 cuda:0 True 3 0 1 0.33
+'''
+import os,sys,pdb,torch
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+import argparse
+import glob
+import sys
+import torch
+from multiprocessing import cpu_count
+class Config:
+    def __init__(self,device,is_half):
+        self.device = device
+        self.is_half = is_half
+        self.n_cpu = 0
+        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系/10系显卡和P40强制单精度")
+                self.is_half = False
+                for config_file in ["32k.json", "40k.json", "48k.json"]:
+                    with open(f"configs/{config_file}", "r") as f:
+                        strr = f.read().replace("true", "false")
+                    with open(f"configs/{config_file}", "w") as f:
+                        f.write(strr)
+                with open("trainset_preprocess_pipeline_print.py", "r") as f:
+                    strr = f.read().replace("3.7", "3.0")
+                with open("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("trainset_preprocess_pipeline_print.py", "r") as f:
+                    strr = f.read().replace("3.7", "3.0")
+                with open("trainset_preprocess_pipeline_print.py", "w") as f:
+                    f.write(strr)
+        elif torch.backends.mps.is_available():
+            print("没有发现支持的N卡, 使用MPS进行推理")
+            self.device = "mps"
+        else:
+            print("没有发现支持的N卡, 使用CPU进行推理")
+            self.device = "cpu"
+            self.is_half = True
+
+        if self.n_cpu == 0:
+            self.n_cpu = cpu_count()
+
+        if self.is_half:
+            # 6G显存配置
+            x_pad = 3
+            x_query = 10
+            x_center = 60
+            x_max = 65
+        else:
+            # 5G显存配置
+            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
+
+f0up_key=sys.argv[1]
+input_path=sys.argv[2]
+index_path=sys.argv[3]
+f0method=sys.argv[4]#harvest or pm
+opt_path=sys.argv[5]
+model_path=sys.argv[6]
+index_rate=float(sys.argv[7])
+device=sys.argv[8]
+is_half=bool(sys.argv[9])
+filter_radius=int(sys.argv[10])
+resample_sr=int(sys.argv[11])
+rms_mix_rate=float(sys.argv[12])
+protect=float(sys.argv[13])
+print(sys.argv)
+config=Config(device,is_half)
+now_dir=os.getcwd()
+sys.path.append(now_dir)
+from vc_infer_pipeline import VC
+from lib.infer_pack.models import (
+    SynthesizerTrnMs256NSFsid,
+    SynthesizerTrnMs256NSFsid_nono,
+    SynthesizerTrnMs768NSFsid,
+    SynthesizerTrnMs768NSFsid_nono,
+)
+from lib.audio import load_audio
+from fairseq import checkpoint_utils
+from scipy.io import wavfile
+
+hubert_model=None
+def load_hubert():
+    global hubert_model
+    models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(["hubert_base.pt"],suffix="",)
+    hubert_model = models[0]
+    hubert_model = hubert_model.to(device)
+    if(is_half):hubert_model = hubert_model.half()
+    else:hubert_model = hubert_model.float()
+    hubert_model.eval()
+
+def vc_single(sid,input_audio,f0_up_key,f0_file,f0_method,file_index,index_rate):
+    global tgt_sr,net_g,vc,hubert_model,version
+    if input_audio is None:return "You need to upload an audio", None
+    f0_up_key = int(f0_up_key)
+    audio=load_audio(input_audio,16000)
+    times = [0, 0, 0]
+    if(hubert_model==None):load_hubert()
+    if_f0 = cpt.get("f0", 1)
+    # audio_opt=vc.pipeline(hubert_model,net_g,sid,audio,times,f0_up_key,f0_method,file_index,file_big_npy,index_rate,if_f0,f0_file=f0_file)
+    audio_opt=vc.pipeline(hubert_model,net_g,sid,audio,input_audio,times,f0_up_key,f0_method,file_index,index_rate,if_f0,filter_radius,tgt_sr,resample_sr,rms_mix_rate,version,protect,f0_file=f0_file)
+    print(times)
+    return audio_opt
+
+
+def get_vc(model_path):
+    global n_spk,tgt_sr,net_g,vc,cpt,device,is_half,version
+    print("loading pth %s"%model_path)
+    cpt = torch.load(model_path, map_location="cpu")
+    tgt_sr = cpt["config"][-1]
+    cpt["config"][-3]=cpt["weight"]["emb_g.weight"].shape[0]#n_spk
+    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)
+    n_spk=cpt["config"][-3]
+    # return {"visible": True,"maximum": n_spk, "__type__": "update"}
+
+
+get_vc(model_path)
+wav_opt=vc_single(0,input_path,f0up_key,None,f0method,index_path,index_rate)
+wavfile.write(opt_path, tgt_sr, wav_opt)
+

myinfer.py

@@ -0,0 +1,156 @@
+'''
+runtime\python.exe myinfer.py 0 "E:\codes\py39\RVC-beta\todo-songs\1111.wav" "E:\codes\py39\logs\mi-test\added_IVF677_Flat_nprobe_7.index" harvest "test.wav" "weights/mi-test.pth" 0.6 cuda:0 True
+'''
+import os,sys,pdb,torch
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+import argparse
+import glob
+import sys
+import torch
+from multiprocessing import cpu_count
+class Config:
+    def __init__(self,device,is_half):
+        self.device = device
+        self.is_half = is_half
+        self.n_cpu = 0
+        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系/10系显卡和P40强制单精度")
+                self.is_half = False
+                for config_file in ["32k.json", "40k.json", "48k.json"]:
+                    with open(f"configs/{config_file}", "r") as f:
+                        strr = f.read().replace("true", "false")
+                    with open(f"configs/{config_file}", "w") as f:
+                        f.write(strr)
+                with open("trainset_preprocess_pipeline_print.py", "r") as f:
+                    strr = f.read().replace("3.7", "3.0")
+                with open("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("trainset_preprocess_pipeline_print.py", "r") as f:
+                    strr = f.read().replace("3.7", "3.0")
+                with open("trainset_preprocess_pipeline_print.py", "w") as f:
+                    f.write(strr)
+        elif torch.backends.mps.is_available():
+            print("没有发现支持的N卡, 使用MPS进行推理")
+            self.device = "mps"
+        else:
+            print("没有发现支持的N卡, 使用CPU进行推理")
+            self.device = "cpu"
+            self.is_half = True
+
+        if self.n_cpu == 0:
+            self.n_cpu = cpu_count()
+
+        if self.is_half:
+            # 6G显存配置
+            x_pad = 3
+            x_query = 10
+            x_center = 60
+            x_max = 65
+        else:
+            # 5G显存配置
+            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
+
+f0up_key=sys.argv[1]
+input_path=sys.argv[2]
+index_path=sys.argv[3]
+f0method=sys.argv[4]#harvest or pm
+opt_path=sys.argv[5]
+model_path=sys.argv[6]
+index_rate=float(sys.argv[7])
+device=sys.argv[8]
+is_half=bool(sys.argv[9])
+print(sys.argv)
+config=Config(device,is_half)
+now_dir=os.getcwd()
+sys.path.append(now_dir)
+from vc_infer_pipeline import VC
+from lib.infer_pack.models import SynthesizerTrnMs256NSFsid, SynthesizerTrnMs256NSFsid_nono
+from lib.audio import load_audio
+from fairseq import checkpoint_utils
+from scipy.io import wavfile
+
+hubert_model=None
+def load_hubert():
+    global hubert_model
+    models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(["hubert_base.pt"],suffix="",)
+    hubert_model = models[0]
+    hubert_model = hubert_model.to(device)
+    if(is_half):hubert_model = hubert_model.half()
+    else:hubert_model = hubert_model.float()
+    hubert_model.eval()
+
+def vc_single(sid,input_audio,f0_up_key,f0_file,f0_method,file_index,index_rate):
+    global tgt_sr,net_g,vc,hubert_model
+    if input_audio is None:return "You need to upload an audio", None
+    f0_up_key = int(f0_up_key)
+    audio=load_audio(input_audio,16000)
+    times = [0, 0, 0]
+    if(hubert_model==None):load_hubert()
+    if_f0 = cpt.get("f0", 1)
+    # audio_opt=vc.pipeline(hubert_model,net_g,sid,audio,times,f0_up_key,f0_method,file_index,file_big_npy,index_rate,if_f0,f0_file=f0_file)
+    audio_opt=vc.pipeline(hubert_model,net_g,sid,audio,times,f0_up_key,f0_method,file_index,index_rate,if_f0,f0_file=f0_file)
+    print(times)
+    return audio_opt
+
+
+def get_vc(model_path):
+    global n_spk,tgt_sr,net_g,vc,cpt,device,is_half
+    print("loading pth %s"%model_path)
+    cpt = torch.load(model_path, map_location="cpu")
+    tgt_sr = cpt["config"][-1]
+    cpt["config"][-3]=cpt["weight"]["emb_g.weight"].shape[0]#n_spk
+    if_f0=cpt.get("f0",1)
+    if(if_f0==1):
+        net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=is_half)
+    else:
+        net_g = SynthesizerTrnMs256NSFsid_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)
+    n_spk=cpt["config"][-3]
+    # return {"visible": True,"maximum": n_spk, "__type__": "update"}
+
+
+get_vc(model_path)
+wav_opt=vc_single(0,input_path,f0up_key,None,f0method,index_path,index_rate)
+wavfile.write(opt_path, tgt_sr, wav_opt)
+

slicer.py

@@ -0,0 +1,151 @@
+import os.path
+from argparse import ArgumentParser
+import time
+
+import librosa
+import numpy as np
+import soundfile
+from scipy.ndimage import maximum_filter1d, uniform_filter1d
+
+
+def timeit(func):
+    def run(*args, **kwargs):
+        t = time.time()
+        res = func(*args, **kwargs)
+        print('executing \'%s\' costed %.3fs' % (func.__name__, time.time() - t))
+        return res
+    return run
+
+
+# @timeit
+def _window_maximum(arr, win_sz):
+    return maximum_filter1d(arr, size=win_sz)[win_sz // 2: win_sz // 2 + arr.shape[0] - win_sz + 1]
+
+
+# @timeit
+def _window_rms(arr, win_sz):
+    filtered = np.sqrt(uniform_filter1d(np.power(arr, 2), win_sz) - np.power(uniform_filter1d(arr, win_sz), 2))
+    return filtered[win_sz // 2: win_sz // 2 + arr.shape[0] - win_sz + 1]
+
+
+def level2db(levels, eps=1e-12):
+    return 20 * np.log10(np.clip(levels, a_min=eps, a_max=1))
+
+
+def _apply_slice(audio, begin, end):
+    if len(audio.shape) > 1:
+        return audio[:, begin: end]
+    else:
+        return audio[begin: end]
+
+
+class Slicer:
+    def __init__(self,
+                 sr: int,
+                 db_threshold: float = -40,
+                 min_length: int = 5000,
+                 win_l: int = 300,
+                 win_s: int = 20,
+                 max_silence_kept: int = 500):
+        self.db_threshold = db_threshold
+        self.min_samples = round(sr * min_length / 1000)
+        self.win_ln = round(sr * win_l / 1000)
+        self.win_sn = round(sr * win_s / 1000)
+        self.max_silence = round(sr * max_silence_kept / 1000)
+        if not self.min_samples >= self.win_ln >= self.win_sn:
+            raise ValueError('The following condition must be satisfied: min_length >= win_l >= win_s')
+        if not self.max_silence >= self.win_sn:
+            raise ValueError('The following condition must be satisfied: max_silence_kept >= win_s')
+
+    @timeit
+    def slice(self, audio):
+        if len(audio.shape) > 1:
+            samples = librosa.to_mono(audio)
+        else:
+            samples = audio
+        if samples.shape[0] <= self.min_samples:
+            return [audio]
+        # get absolute amplitudes
+        abs_amp = np.abs(samples - np.mean(samples))
+        # calculate local maximum with large window
+        win_max_db = level2db(_window_maximum(abs_amp, win_sz=self.win_ln))
+        sil_tags = []
+        left = right = 0
+        while right < win_max_db.shape[0]:
+            if win_max_db[right] < self.db_threshold:
+                right += 1
+            elif left == right:
+                left += 1
+                right += 1
+            else:
+                if left == 0:
+                    split_loc_l = left
+                else:
+                    sil_left_n = min(self.max_silence, (right + self.win_ln - left) // 2)
+                    rms_db_left = level2db(_window_rms(samples[left: left + sil_left_n], win_sz=self.win_sn))
+                    split_win_l = left + np.argmin(rms_db_left)
+                    split_loc_l = split_win_l + np.argmin(abs_amp[split_win_l: split_win_l + self.win_sn])
+                if len(sil_tags) != 0 and split_loc_l - sil_tags[-1][1] < self.min_samples and right < win_max_db.shape[0] - 1:
+                    right += 1
+                    left = right
+                    continue
+                if right == win_max_db.shape[0] - 1:
+                    split_loc_r = right + self.win_ln
+                else:
+                    sil_right_n = min(self.max_silence, (right + self.win_ln - left) // 2)
+                    rms_db_right = level2db(_window_rms(samples[right + self.win_ln - sil_right_n: right + self.win_ln], win_sz=self.win_sn))
+                    split_win_r = right + self.win_ln - sil_right_n + np.argmin(rms_db_right)
+                    split_loc_r = split_win_r + np.argmin(abs_amp[split_win_r: split_win_r + self.win_sn])
+                sil_tags.append((split_loc_l, split_loc_r))
+                right += 1
+                left = right
+        if left != right:
+            sil_left_n = min(self.max_silence, (right + self.win_ln - left) // 2)
+            rms_db_left = level2db(_window_rms(samples[left: left + sil_left_n], win_sz=self.win_sn))
+            split_win_l = left + np.argmin(rms_db_left)
+            split_loc_l = split_win_l + np.argmin(abs_amp[split_win_l: split_win_l + self.win_sn])
+            sil_tags.append((split_loc_l, samples.shape[0]))
+        if len(sil_tags) == 0:
+            return [audio]
+        else:
+            chunks = []
+            if sil_tags[0][0] > 0:
+                chunks.append(_apply_slice(audio, 0, sil_tags[0][0]))
+            for i in range(0, len(sil_tags) - 1):
+                chunks.append(_apply_slice(audio, sil_tags[i][1], sil_tags[i + 1][0]))
+            if sil_tags[-1][1] < samples.shape[0] - 1:
+                chunks.append(_apply_slice(audio, sil_tags[-1][1], samples.shape[0]))
+            return chunks
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument('audio', type=str, help='The audio to be sliced')
+    parser.add_argument('--out', type=str, help='Output directory of the sliced audio clips')
+    parser.add_argument('--db_thresh', type=float, required=False, default=-40, help='The dB threshold for silence detection')
+    parser.add_argument('--min_len', type=int, required=False, default=5000, help='The minimum milliseconds required for each sliced audio clip')
+    parser.add_argument('--win_l', type=int, required=False, default=300, help='Size of the large sliding window, presented in milliseconds')
+    parser.add_argument('--win_s', type=int, required=False, default=20, help='Size of the small sliding window, presented in milliseconds')
+    parser.add_argument('--max_sil_kept', type=int, required=False, default=500, help='The maximum silence length kept around the sliced audio, presented in milliseconds')
+    args = parser.parse_args()
+    out = args.out
+    if out is None:
+        out = os.path.dirname(os.path.abspath(args.audio))
+    audio, sr = librosa.load(args.audio, sr=None)
+    slicer = Slicer(
+        sr=sr,
+        db_threshold=args.db_thresh,
+        min_length=args.min_len,
+        win_l=args.win_l,
+        win_s=args.win_s,
+        max_silence_kept=args.max_sil_kept
+    )
+    chunks = slicer.slice(audio)
+    if not os.path.exists(args.out):
+        os.makedirs(args.out)
+    for i, chunk in enumerate(chunks):
+        soundfile.write(os.path.join(out, f'%s_%d.wav' % (os.path.basename(args.audio).rsplit('.', maxsplit=1)[0], i)), chunk, sr)
+
+
+if __name__ == '__main__':
+    main()

trainset_preprocess_pipeline.py

@@ -0,0 +1,63 @@
+import numpy as np,ffmpeg,os,traceback
+from slicer import Slicer
+slicer = Slicer(
+    sr=40000,
+    db_threshold=-32,
+    min_length=800,
+    win_l=400,
+    win_s=20,
+    max_silence_kept=150
+)
+
+
+
+
+def p0_load_audio(file, sr):#str-ing
+    try:
+        out, _ = (
+            ffmpeg.input(file, threads=0)
+            .output("-", format="s16le", acodec="pcm_s16le", ac=1, ar=sr)
+            .run(cmd=["ffmpeg", "-nostdin"], capture_stdout=True, capture_stderr=True)
+        )
+    except ffmpeg.Error as e:
+        raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}") from e
+    return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0
+
+def p1_trim_audio(slicer,audio):return slicer.slice(audio)
+
+def p2_avg_cut(audio,sr,per=3.7,overlap=0.3,tail=4):
+    i = 0
+    audios=[]
+    while (1):
+        start = int(sr * (per - overlap) * i)
+        i += 1
+        if (len(audio[start:]) > tail * sr):
+            audios.append(audio[start:start + int(per * sr)])
+        else:
+            audios.append(audio[start:])
+            break
+    return audios
+
+def p2b_get_vol(audio):return np.square(audio).mean()
+
+def p3_norm(audio,alpha=0.8,maxx=0.95):return audio / np.abs(audio).max() * (maxx * alpha) + (1-alpha) * audio
+
+def pipeline(inp_root,sr1=40000,sr2=16000,if_trim=True,if_avg_cut=True,if_norm=True,save_root1=None,save_root2=None):
+    if(save_root1==None and save_root2==None):return "No save root."
+    name2vol={}
+    infos=[]
+    names=[]
+    for name in os.listdir(inp_root):
+        try:
+            inp_path=os.path.join(inp_root,name)
+            audio=p0_load_audio(inp_path)
+        except:
+            infos.append("%s\t%s"%(name,traceback.format_exc()))
+            continue
+        if(if_trim==True):res1s=p1_trim_audio(audio)
+        else:res1s=[audio]
+        for i0,res1 in res1s:
+            if(if_avg_cut==True):res2=p2_avg_cut(res1)
+            else:res2=[res1]
+
+

vc_infer_pipeline.py

@@ -0,0 +1,225 @@
+import numpy as np,parselmouth,torch,pdb
+from time import time as ttime
+import torch.nn.functional as F
+from config import x_pad,x_query,x_center,x_max
+from sklearn.cluster import KMeans
+
+def resize2d(x, target_len,is1):
+    minn=1 if is1==True else 0
+    ss = np.array(x).astype("float32")
+    ss[ss <=minn] = np.nan
+    target = np.interp(np.arange(0, len(ss) * target_len, len(ss)) / target_len, np.arange(0, len(ss)), ss)
+    res = np.nan_to_num(target)
+    return res
+
+class VC(object):
+    def __init__(self,tgt_sr,device,is_half):
+        self.sr=16000#hubert输入采样率
+        self.window=160#每帧点数
+        self.t_pad=self.sr*x_pad#每条前后pad时间
+        self.t_pad_tgt=tgt_sr*x_pad
+        self.t_pad2=self.t_pad*2
+        self.t_query=self.sr*x_query#查询切点前后查询时间
+        self.t_center=self.sr*x_center#查询切点位置
+        self.t_max=self.sr*x_max#免查询时长阈值
+        self.device=device
+        self.is_half=is_half
+
+    def get_f0(self,x, p_len,f0_up_key=0,inp_f0=None):
+        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)
+        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')
+        f0 *= pow(2, f0_up_key / 12)
+        # with open("test.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
+        tf0=self.sr//self.window#每秒f0点数
+        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[x_pad*tf0:x_pad*tf0+len(replace_f0)].shape[0]
+            f0[x_pad*tf0:x_pad*tf0+len(replace_f0)]=replace_f0[:shape]
+        # with open("test_opt.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
+        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(np.int)
+        return f0_coarse, f0bak#1-0
+
+    def vc(self,model,net_g,dv,audio0,pitch,pitchf,times):
+        feats = torch.from_numpy(audio0)
+        if(self.is_half==True):feats=feats.half()
+        else:feats=feats.float()
+        if feats.dim() == 2:  # double channels
+            feats = feats.mean(-1)
+        assert feats.dim() == 1, feats.dim()
+        feats = feats.view(1, -1)
+        padding_mask = torch.BoolTensor(feats.shape).fill_(False)
+
+        inputs = {
+            "source": feats.to(self.device),
+            "padding_mask": padding_mask.to(self.device),
+            "output_layer": 9,  # layer 9
+        }
+        t0 = ttime()
+        with torch.no_grad():
+            logits = model.extract_features(**inputs)
+            feats  = model.final_proj(logits[0])
+        feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
+        t1 = ttime()
+        p_len = audio0.shape[0]//self.window
+        if(feats.shape[1]<p_len):
+            p_len=feats.shape[1]
+            pitch=pitch[:,:p_len]
+            pitchf=pitchf[:,:p_len]
+        p_len=torch.LongTensor([p_len]).to(self.device)
+        with torch.no_grad():
+            audio1 = (net_g.infer(feats, p_len, pitch, pitchf, dv)[0][0, 0] * 32768).data.cpu().float().numpy().astype(np.int16)
+        del feats,p_len,padding_mask
+        torch.cuda.empty_cache()
+        t2 = ttime()
+        times[0] += (t1 - t0)
+        times[2] += (t2 - t1)
+        return audio1
+    def vc_km(self,model,net_g,dv,audio0,pitch,pitchf,times):
+        kmeans = KMeans(500)
+        def get_cluster_result(x):
+            """x: np.array [t, 256]"""
+            return kmeans.predict(x)
+        checkpoint = torch.load("lulu_contentvec_kmeans_500.pt")
+        kmeans.__dict__["n_features_in_"] = checkpoint["n_features_in_"]
+        kmeans.__dict__["_n_threads"] = checkpoint["_n_threads"]
+        kmeans.__dict__["cluster_centers_"] = checkpoint["cluster_centers_"]
+        feats = torch.from_numpy(audio0).float()
+        if feats.dim() == 2:  # double channels
+            feats = feats.mean(-1)
+        assert feats.dim() == 1, feats.dim()
+        feats = feats.view(1, -1)
+        padding_mask = torch.BoolTensor(feats.shape).fill_(False)
+        inputs = {
+            "source": feats.half().to(self.device),
+            "padding_mask": padding_mask.to(self.device),
+            "output_layer": 9,  # layer 9
+        }
+        torch.cuda.synchronize()
+        t0 = ttime()
+        with torch.no_grad():
+            logits = model.extract_features(**inputs)
+            feats = model.final_proj(logits[0])
+        feats = get_cluster_result(feats.cpu().numpy()[0].astype("float32"))
+        feats = torch.from_numpy(feats).to(self.device)
+        feats = F.interpolate(feats.half().unsqueeze(0).unsqueeze(0), scale_factor=2).long().squeeze(0)
+        t1 = ttime()
+        p_len = audio0.shape[0]//self.window
+        if(feats.shape[1]<p_len):
+            p_len=feats.shape[1]
+            pitch=pitch[:,:p_len]
+            pitchf=pitchf[:,:p_len]
+        p_len=torch.LongTensor([p_len]).to(self.device)
+        with torch.no_grad():
+            audio1 = (net_g.infer(feats, p_len, pitch, pitchf, dv)[0][0, 0] * 32768).data.cpu().float().numpy().astype(np.int16)
+        del feats,p_len,padding_mask
+        torch.cuda.empty_cache()
+        t2 = ttime()
+        times[0] += (t1 - t0)
+        times[2] += (t2 - t1)
+        return audio1
+
+    def pipeline(self,model,net_g,dv,audio,times,f0_up_key,f0_file=None):
+        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:
+                traceback.print_exc()
+        pitch, pitchf = self.get_f0(audio_pad, p_len, f0_up_key,inp_f0)
+
+        pitch = pitch[:p_len]
+        pitchf = pitchf[:p_len]
+        # if(inp_f0 is None):
+        #     pitch = pitch[:p_len]
+        #     pitchf = pitchf[:p_len]
+        # else:
+        #     pitch=resize2d(pitch,p_len,is1=True)
+        #     pitchf=resize2d(pitchf,p_len,is1=False)
+        pitch = torch.LongTensor(pitch).unsqueeze(0).to(self.device)
+        pitchf = torch.FloatTensor(pitchf).unsqueeze(0).to(self.device)
+        t2=ttime()
+        times[1] += (t2 - t1)
+        for t in opt_ts:
+            t=t//self.window*self.window
+            audio_opt.append(self.vc(model,net_g,dv,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],times)[self.t_pad_tgt:-self.t_pad_tgt])
+            s = t
+        audio_opt.append(self.vc(model,net_g,dv,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,times)[self.t_pad_tgt:-self.t_pad_tgt])
+        audio_opt=np.concatenate(audio_opt)
+        del pitch,pitchf
+        return audio_opt
+    def pipeline_km(self,model,net_g,dv,audio,times,f0_up_key,f0_file=None):
+        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:
+                traceback.print_exc()
+        pitch, pitchf = self.get_f0(audio_pad, p_len, f0_up_key,inp_f0)
+
+        pitch = pitch[:p_len]
+        pitchf = pitchf[:p_len]
+        # if(inp_f0 is None):
+        #     pitch = pitch[:p_len]
+        #     pitchf = pitchf[:p_len]
+        # else:
+        #     pitch=resize2d(pitch,p_len,is1=True)
+        #     pitchf=resize2d(pitchf,p_len,is1=False)
+        pitch = torch.LongTensor(pitch).unsqueeze(0).to(self.device)
+        pitchf = torch.FloatTensor(pitchf).unsqueeze(0).to(self.device)
+        t2=ttime()
+        times[1] += (t2 - t1)
+        for t in opt_ts:
+            t=t//self.window*self.window
+            audio_opt.append(self.vc_km(model,net_g,dv,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],times)[self.t_pad_tgt:-self.t_pad_tgt])
+            s = t
+        audio_opt.append(self.vc_km(model,net_g,dv,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,times)[self.t_pad_tgt:-self.t_pad_tgt])
+        audio_opt=np.concatenate(audio_opt)
+        del pitch,pitchf
+        return audio_opt

使用需遵守的协议-LICENSE.txt

@@ -0,0 +1,54 @@
+MIT License
+
+Copyright (c) 2022 lj1995
+
+本软件仅供研究使用，使用软件者、传播软件导出的声音者自负全责。如不认可该条款，则不能使用/引用软件包内所有代码和文件。
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+#################
+ContentVec
+https://github.com/auspicious3000/contentvec/blob/main/LICENSE
+MIT License
+#################
+VITS
+https://github.com/jaywalnut310/vits/blob/main/LICENSE
+MIT License
+#################
+HIFIGAN
+https://github.com/jik876/hifi-gan/blob/master/LICENSE
+MIT License
+#################
+gradio
+https://github.com/gradio-app/gradio/blob/main/LICENSE
+Apache License 2.0
+#################
+ffmpeg
+https://github.com/FFmpeg/FFmpeg/blob/master/COPYING.LGPLv3
+https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2021-02-28-12-32/ffmpeg-n4.3.2-160-gfbb9368226-win64-lgpl-4.3.zip
+LPGLv3 License
+MIT License
+#################
+ultimatevocalremovergui
+https://github.com/Anjok07/ultimatevocalremovergui/blob/master/LICENSE
+https://github.com/yang123qwe/vocal_separation_by_uvr5
+MIT License
+#################
+audio-slicer
+https://github.com/openvpi/audio-slicer/blob/main/LICENSE
+MIT License