OPENGIT/Retrieval-based-Voice-Conversion-WebUI
1
0
Fork 0
mirror of https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git synced 2025-04-18 10:38:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

optimize: config

Browse Source
This commit is contained in:
源文雨 2023-08-27 00:35:39 +08:00
parent 80bf0cb8c8
commit 8c36dc2cc7
5 changed files with 144 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app.py
View File

@ -9,7 +9,7 @@ import logging
from fairseq import checkpoint_utils from fairseq import checkpoint_utils
from vc_infer_pipeline import VC from vc_infer_pipeline import VC
import traceback import traceback
from config import Config from config import defaultconfig as config
from lib.infer_pack.models import ( from lib.infer_pack.models import (
SynthesizerTrnMs256NSFsid, SynthesizerTrnMs256NSFsid,
SynthesizerTrnMs256NSFsid_nono, SynthesizerTrnMs256NSFsid_nono,
@ -26,8 +26,6 @@ logging.getLogger("matplotlib").setLevel(logging.WARNING)
i18n = I18nAuto() i18n = I18nAuto()
i18n.print() i18n.print()
config = Config()
weight_root = "weights" weight_root = "weights"
weight_uvr5_root = "uvr5_weights" weight_uvr5_root = "uvr5_weights"
index_root = "logs" index_root = "logs"

2
config.py
View File

@ -198,3 +198,5 @@ class Config:
except: except:
pass pass
return x_pad, x_query, x_center, x_max return x_pad, x_query, x_center, x_max
defaultconfig = Config()

3
infer-web.py
View File

@ -22,7 +22,7 @@ import faiss
import ffmpeg import ffmpeg
import gradio as gr import gradio as gr
import soundfile as sf import soundfile as sf
from config import Config from config import defaultconfig as config
import fairseq import fairseq
from i18n import I18nAuto from i18n import I18nAuto
from lib.infer_pack.models import ( from lib.infer_pack.models import (
@ -53,7 +53,6 @@ warnings.filterwarnings("ignore")
torch.manual_seed(114514) torch.manual_seed(114514)
config = Config()
if config.dml == True: if config.dml == True:
def forward_dml(ctx, x, scale): def forward_dml(ctx, x, scale):

3
rvc_for_realtime.py
View File

@ -13,11 +13,10 @@ import scipy.signal as signal
now_dir = os.getcwd() now_dir = os.getcwd()
sys.path.append(now_dir) sys.path.append(now_dir)
from config import Config from config import defaultconfig as config
from multiprocessing import Manager as M from multiprocessing import Manager as M
mm = M() mm = M()
config = Config()
if config.dml == True: if config.dml == True:
def forward_dml(ctx, x, scale): def forward_dml(ctx, x, scale):

278
trainset_preprocess_pipeline_print.py
View File

@ -1,139 +1,139 @@
import sys, os, multiprocessing import sys, os, multiprocessing
from scipy import signal from scipy import signal
now_dir = os.getcwd() now_dir = os.getcwd()
sys.path.append(now_dir) sys.path.append(now_dir)
print(sys.argv) print(sys.argv)
inp_root = sys.argv[1] inp_root = sys.argv[1]
sr = int(sys.argv[2]) sr = int(sys.argv[2])
n_p = int(sys.argv[3]) n_p = int(sys.argv[3])
exp_dir = sys.argv[4] exp_dir = sys.argv[4]
noparallel = sys.argv[5] == "True" noparallel = sys.argv[5] == "True"
import numpy as np, os, traceback import numpy as np, os, traceback
from lib.slicer2 import Slicer from lib.slicer2 import Slicer
import librosa, traceback import librosa, traceback
from scipy.io import wavfile from scipy.io import wavfile
import multiprocessing import multiprocessing
from lib.audio import load_audio from lib.audio import load_audio
mutex = multiprocessing.Lock() mutex = multiprocessing.Lock()
f = open("%s/preprocess.log" % exp_dir, "a+") f = open("%s/preprocess.log" % exp_dir, "a+")
def println(strr): def println(strr):
mutex.acquire() mutex.acquire()
print(strr) print(strr)
f.write("%s\n" % strr) f.write("%s\n" % strr)
f.flush() f.flush()
mutex.release() mutex.release()
class PreProcess: class PreProcess:
def __init__(self, sr, exp_dir): def __init__(self, sr, exp_dir):
self.slicer = Slicer( self.slicer = Slicer(
sr=sr, sr=sr,
threshold=-42, threshold=-42,
min_length=1500, min_length=1500,
min_interval=400, min_interval=400,
hop_size=15, hop_size=15,
max_sil_kept=500, max_sil_kept=500,
) )
self.sr = sr self.sr = sr
self.bh, self.ah = signal.butter(N=5, Wn=48, btype="high", fs=self.sr) self.bh, self.ah = signal.butter(N=5, Wn=48, btype="high", fs=self.sr)
self.per = 3.0 self.per = 3.0
self.overlap = 0.3 self.overlap = 0.3
self.tail = self.per + self.overlap self.tail = self.per + self.overlap
self.max = 0.9 self.max = 0.9
self.alpha = 0.75 self.alpha = 0.75
self.exp_dir = exp_dir self.exp_dir = exp_dir
self.gt_wavs_dir = "%s/0_gt_wavs" % exp_dir self.gt_wavs_dir = "%s/0_gt_wavs" % exp_dir
self.wavs16k_dir = "%s/1_16k_wavs" % exp_dir self.wavs16k_dir = "%s/1_16k_wavs" % exp_dir
os.makedirs(self.exp_dir, exist_ok=True) os.makedirs(self.exp_dir, exist_ok=True)
os.makedirs(self.gt_wavs_dir, exist_ok=True) os.makedirs(self.gt_wavs_dir, exist_ok=True)
os.makedirs(self.wavs16k_dir, exist_ok=True) os.makedirs(self.wavs16k_dir, exist_ok=True)
def norm_write(self, tmp_audio, idx0, idx1): def norm_write(self, tmp_audio, idx0, idx1):
tmp_max = np.abs(tmp_audio).max() tmp_max = np.abs(tmp_audio).max()
if tmp_max > 2.5: if tmp_max > 2.5:
print("%s-%s-%s-filtered" % (idx0, idx1, tmp_max)) print("%s-%s-%s-filtered" % (idx0, idx1, tmp_max))
return return
tmp_audio = (tmp_audio / tmp_max * (self.max * self.alpha)) + ( tmp_audio = (tmp_audio / tmp_max * (self.max * self.alpha)) + (
1 - self.alpha 1 - self.alpha
) * tmp_audio ) * tmp_audio
wavfile.write( wavfile.write(
"%s/%s_%s.wav" % (self.gt_wavs_dir, idx0, idx1), "%s/%s_%s.wav" % (self.gt_wavs_dir, idx0, idx1),
self.sr, self.sr,
tmp_audio.astype(np.float32), tmp_audio.astype(np.float32),
) )
tmp_audio = librosa.resample( tmp_audio = librosa.resample(
tmp_audio, orig_sr=self.sr, target_sr=16000 tmp_audio, orig_sr=self.sr, target_sr=16000
) # , res_type="soxr_vhq" ) # , res_type="soxr_vhq"
wavfile.write( wavfile.write(
"%s/%s_%s.wav" % (self.wavs16k_dir, idx0, idx1), "%s/%s_%s.wav" % (self.wavs16k_dir, idx0, idx1),
16000, 16000,
tmp_audio.astype(np.float32), tmp_audio.astype(np.float32),
) )
def pipeline(self, path, idx0): def pipeline(self, path, idx0):
try: try:
audio = load_audio(path, self.sr) audio = load_audio(path, self.sr)
# zero phased digital filter cause pre-ringing noise... # zero phased digital filter cause pre-ringing noise...
# audio = signal.filtfilt(self.bh, self.ah, audio) # audio = signal.filtfilt(self.bh, self.ah, audio)
audio = signal.lfilter(self.bh, self.ah, audio) audio = signal.lfilter(self.bh, self.ah, audio)
idx1 = 0 idx1 = 0
for audio in self.slicer.slice(audio): for audio in self.slicer.slice(audio):
i = 0 i = 0
while 1: while 1:
start = int(self.sr * (self.per - self.overlap) * i) start = int(self.sr * (self.per - self.overlap) * i)
i += 1 i += 1
if len(audio[start:]) > self.tail * self.sr: if len(audio[start:]) > self.tail * self.sr:
tmp_audio = audio[start : start + int(self.per * self.sr)] tmp_audio = audio[start : start + int(self.per * self.sr)]
self.norm_write(tmp_audio, idx0, idx1) self.norm_write(tmp_audio, idx0, idx1)
idx1 += 1 idx1 += 1
else: else:
tmp_audio = audio[start:] tmp_audio = audio[start:]
idx1 += 1 idx1 += 1
break break
self.norm_write(tmp_audio, idx0, idx1) self.norm_write(tmp_audio, idx0, idx1)
println("%s->Suc." % path) println("%s->Suc." % path)
except: except:
println("%s->%s" % (path, traceback.format_exc())) println("%s->%s" % (path, traceback.format_exc()))
def pipeline_mp(self, infos): def pipeline_mp(self, infos):
for path, idx0 in infos: for path, idx0 in infos:
self.pipeline(path, idx0) self.pipeline(path, idx0)
def pipeline_mp_inp_dir(self, inp_root, n_p): def pipeline_mp_inp_dir(self, inp_root, n_p):
try: try:
infos = [ infos = [
("%s/%s" % (inp_root, name), idx) ("%s/%s" % (inp_root, name), idx)
for idx, name in enumerate(sorted(list(os.listdir(inp_root)))) for idx, name in enumerate(sorted(list(os.listdir(inp_root))))
] ]
if noparallel: if noparallel:
for i in range(n_p): for i in range(n_p):
self.pipeline_mp(infos[i::n_p]) self.pipeline_mp(infos[i::n_p])
else: else:
ps = [] ps = []
for i in range(n_p): for i in range(n_p):
p = multiprocessing.Process( p = multiprocessing.Process(
target=self.pipeline_mp, args=(infos[i::n_p],) target=self.pipeline_mp, args=(infos[i::n_p],)
) )
ps.append(p) ps.append(p)
p.start() p.start()
for i in range(n_p): for i in range(n_p):
ps[i].join() ps[i].join()
except: except:
println("Fail. %s" % traceback.format_exc()) println("Fail. %s" % traceback.format_exc())
def preprocess_trainset(inp_root, sr, n_p, exp_dir): def preprocess_trainset(inp_root, sr, n_p, exp_dir):
pp = PreProcess(sr, exp_dir) pp = PreProcess(sr, exp_dir)
println("start preprocess") println("start preprocess")
println(sys.argv) println(sys.argv)
pp.pipeline_mp_inp_dir(inp_root, n_p) pp.pipeline_mp_inp_dir(inp_root, n_p)
println("end preprocess") println("end preprocess")
if __name__ == "__main__": if __name__ == "__main__":
preprocess_trainset(inp_root, sr, n_p, exp_dir) preprocess_trainset(inp_root, sr, n_p, exp_dir)