Spaces:
Running
Running
| import multiprocessing | |
| import os | |
| import re | |
| import torch | |
| import glob | |
| import gradio as gr | |
| import librosa | |
| import numpy as np | |
| import soundfile as sf | |
| from inference.infer_tool import Svc | |
| import logging | |
| import json | |
| import yaml | |
| import time | |
| import subprocess | |
| import shutil | |
| import utils | |
| import datetime | |
| import traceback | |
| from utils import mix_model | |
| from onnxexport.model_onnx import SynthesizerTrn | |
| from itertools import chain | |
| from compress_model import removeOptimizer | |
| from auto_slicer import AutoSlicer | |
| logging.getLogger('numba').setLevel(logging.WARNING) | |
| logging.getLogger('markdown_it').setLevel(logging.WARNING) | |
| logging.getLogger('urllib3').setLevel(logging.WARNING) | |
| logging.getLogger('matplotlib').setLevel(logging.WARNING) | |
| workdir = "logs/44k" | |
| diff_workdir = "logs/44k/diffusion" | |
| config_dir = "configs/" | |
| raw_path = "dataset_raw" | |
| raw_wavs_path = "raw" | |
| models_backup_path = 'models_backup' | |
| root_dir = "checkpoints" | |
| debug = False | |
| sovits_params = {} | |
| diff_params = {} | |
| loaded = None | |
| def debug_change(): | |
| global debug | |
| debug = debug_button.value | |
| def get_default_settings(): | |
| global sovits_params, diff_params | |
| yaml_path = "settings.yaml" | |
| with open(yaml_path, 'r') as f: | |
| default_settings = yaml.safe_load(f) | |
| sovits_params = default_settings['sovits_params'] | |
| diff_params = default_settings['diff_params'] | |
| return sovits_params, diff_params | |
| def save_default_settings(log_interval,eval_interval,keep_ckpts,batch_size,learning_rate,fp16_run,all_in_mem,num_workers,cache_all_data,cache_device,amp_dtype,diff_batch_size,diff_lr,diff_interval_log,diff_interval_val,diff_force_save): | |
| yaml_path = "settings.yaml" | |
| with open(yaml_path, 'r') as f: | |
| default_settings = yaml.safe_load(f) | |
| default_settings['sovits_params']['log_interval'] = int(log_interval) | |
| default_settings['sovits_params']['eval_interval'] = int(eval_interval) | |
| default_settings['sovits_params']['keep_ckpts'] = int(keep_ckpts) | |
| default_settings['sovits_params']['batch_size'] = int(batch_size) | |
| default_settings['sovits_params']['learning_rate'] = float(learning_rate) | |
| default_settings['sovits_params']['fp16_run'] = fp16_run | |
| default_settings['sovits_params']['all_in_mem'] = all_in_mem | |
| default_settings['diff_params']['num_workers'] = int(num_workers) | |
| default_settings['diff_params']['cache_all_data'] = cache_all_data | |
| default_settings['diff_params']['cache_device'] = str(cache_device) | |
| default_settings['diff_params']['amp_dtype'] = str(amp_dtype) | |
| default_settings['diff_params']['diff_batch_size'] = int(diff_batch_size) | |
| default_settings['diff_params']['diff_lr'] = float(diff_lr) | |
| default_settings['diff_params']['diff_interval_log'] = int(diff_interval_log) | |
| default_settings['diff_params']['diff_interval_val'] = int(diff_interval_val) | |
| default_settings['diff_params']['diff_force_save'] = int(diff_force_save) | |
| with open(yaml_path, 'w') as y: | |
| yaml.safe_dump(default_settings, y, default_flow_style=False, sort_keys=False) | |
| return "成功保存默认配置" | |
| def get_model_info(choice_ckpt): | |
| pthfile = os.path.join(workdir, choice_ckpt) | |
| net = torch.load(pthfile, map_location=torch.device('cpu')) #cpu load | |
| spk_emb = net["model"].get("emb_g.weight") | |
| if spk_emb is None: | |
| return "所选模型缺少emb_g.weight，你可能选择了一个底模" | |
| _dim, _layer = spk_emb.size() | |
| model_type = { | |
| 768: "Vec768-Layer12", | |
| 256: "Vec256-Layer9 / HubertSoft", | |
| 1024: "Whisper-PPG" | |
| } | |
| return model_type.get(_layer, "不受支持的模型") | |
| def load_json_encoder(config_choice): | |
| config_file = os.path.join(config_dir + config_choice) | |
| with open(config_file, 'r') as f: | |
| config = json.load(f) | |
| try: | |
| config_encoder = str(config["model"]["speech_encoder"]) | |
| return config_encoder | |
| except Exception as e: | |
| if "speech_encoder" in str(e): | |
| return "你的配置文件似乎是未作兼容的旧版，请根据文档指示对你的配置文件进行修改" | |
| else: | |
| return f"出错了: {e}" | |
| def load_model_func(ckpt_name,cluster_name,config_name,enhance,diff_model_name,diff_config_name,only_diffusion,encoder,using_device): | |
| global model | |
| config_path = os.path.join(config_dir, config_name) | |
| diff_config_path = os.path.join(config_dir, diff_config_name) if diff_config_name != "no_diff_config" else "configs/diffusion.yaml" | |
| with open(config_path, 'r') as f: | |
| config = json.load(f) | |
| spk_dict = config["spk"] | |
| spk_name = config.get('spk', None) | |
| spk_choice = next(iter(spk_name)) if spk_name else "未检测到音色" | |
| ckpt_path = os.path.join(workdir, ckpt_name) | |
| _, _suffix = os.path.splitext(cluster_name) | |
| fr = True if _suffix == ".pkl" else False #如果是pkl后缀就启用特征检索 | |
| cluster_path = os.path.join(workdir, cluster_name) | |
| diff_model_path = os.path.join(diff_workdir, diff_model_name) | |
| shallow_diffusion = True if diff_model_name != "no_diff" else False | |
| use_spk_mix = False | |
| device = None if using_device == "Auto" else using_device | |
| model = Svc(ckpt_path, | |
| config_path, | |
| device, | |
| cluster_path, | |
| enhance, | |
| diff_model_path, | |
| diff_config_path, | |
| shallow_diffusion, | |
| only_diffusion, | |
| use_spk_mix, | |
| fr) | |
| spk_list = list(spk_dict.keys()) | |
| clip = 25 if encoder == "Whisper-PPG" else 0 #Whisper必须强制切片25秒 | |
| device_name = torch.cuda.get_device_properties(model.dev).name if "cuda" in str(model.dev) else str(model.dev) | |
| index_or_kmeans = "特征索引" if fr is True else "聚类模型" | |
| clu_load = "未加载" if cluster_name == "no_clu" else cluster_name | |
| diff_load = "未加载" if diff_model_name == "no_diff" else diff_model_name | |
| output_msg = f"模型被成功加载到了{device_name}上\n{index_or_kmeans}：{clu_load}\n扩散模型：{diff_load}" | |
| return output_msg, gr.Dropdown.update(choices=spk_list, value=spk_choice), clip | |
| def Newload_model_func(ckpt_name,cluster_name,config_name2,enhance2,diff_model_name2,diff_config_name2,only_diffusion2,encoder2,using_device2): | |
| global model, loaded | |
| config_name = config_name2.value | |
| enhance = enhance2.value | |
| diff_model_name = diff_model_name2.value | |
| diff_config_name = (diff_config_name2).value | |
| only_diffusion = (only_diffusion2).value | |
| encoder = (encoder2).value | |
| using_device = (using_device2).value | |
| config_path = os.path.join(config_dir, config_name) | |
| diff_config_path = os.path.join(config_dir, diff_config_name) if diff_config_name != "no_diff_config" else "configs/diffusion.yaml" | |
| with open(config_path, 'r') as f: | |
| config = json.load(f) | |
| spk_dict = config["spk"] | |
| spk_name = config.get('spk', None) | |
| spk_choice = next(iter(spk_name)) if spk_name else "未检测到音色" | |
| ckpt_path = os.path.join(workdir, ckpt_name) | |
| _, _suffix = os.path.splitext(cluster_name) | |
| fr = True if _suffix == ".pkl" else False #如果是pkl后缀就启用特征检索 | |
| cluster_path = os.path.join(workdir, cluster_name) | |
| diff_model_path = os.path.join(diff_workdir, diff_model_name) | |
| shallow_diffusion = True if diff_model_name != "no_diff" else False | |
| use_spk_mix = False | |
| device = None if using_device == "Auto" else using_device | |
| model = Svc(ckpt_path, | |
| config_path, | |
| device, | |
| cluster_path, | |
| enhance, | |
| diff_model_path, | |
| diff_config_path, | |
| shallow_diffusion, | |
| only_diffusion, | |
| use_spk_mix, | |
| fr) | |
| spk_list = list(spk_dict.keys()) | |
| clip = 25 if encoder == "Whisper-PPG" else 0 #Whisper必须强制切片25秒 | |
| device_name = torch.cuda.get_device_properties(model.dev).name if "cuda" in str(model.dev) else str(model.dev) | |
| index_or_kmeans = "特征索引" if fr is True else "聚类模型" | |
| clu_load = "未加载" if cluster_name == "no_clu" else cluster_name | |
| diff_load = "未加载" if diff_model_name == "no_diff" else diff_model_name | |
| loaded = cluster_name | |
| #output_msg = f"模型被成功加载到了{device_name}上\n{index_or_kmeans}：{clu_load}\n扩散模型：{diff_load}" | |
| #return output_msg, gr.Dropdown.update(choices=spk_list, value=spk_choice), clip | |
| def get_file_options(directory, extension): | |
| return [file for file in os.listdir(directory) if file.endswith(extension)] | |
| def load_options(): | |
| ckpt_list = [file for file in get_file_options(workdir, ".pth") if not file.startswith("D_")] | |
| config_list = get_file_options(config_dir, ".json") | |
| cluster_list = ["no_clu"] + get_file_options(workdir, ".pt") + get_file_options(workdir, ".pkl") # 聚类和特征检索模型 | |
| diff_list = ["no_diff"] + get_file_options(diff_workdir, ".pt") | |
| diff_config_list = get_file_options(config_dir, ".yaml") | |
| return ckpt_list, config_list, cluster_list, diff_list, diff_config_list | |
| def refresh_options(): | |
| ckpt_list, config_list, cluster_list, diff_list, diff_config_list = load_options() | |
| return ( | |
| choice_ckpt.update(choices=ckpt_list), | |
| config_choice.update(choices=config_list), | |
| cluster_choice.update(choices=cluster_list), | |
| diff_choice.update(choices=diff_list), | |
| diff_config_choice.update(choices=diff_config_list) | |
| ) | |
| def vc_infer(sid, input_audio, input_audio_path, vc_transform, auto_f0, cluster_ratio, slice_db, noise_scale, pad_seconds, cl_num, lg_num, lgr_num, f0_predictor, enhancer_adaptive_key, cr_threshold, k_step, use_spk_mix, second_encoding, loudness_envelope_adjustment): | |
| if np.issubdtype(input_audio.dtype, np.integer): | |
| input_audio = (input_audio / np.iinfo(input_audio.dtype).max).astype(np.float32) | |
| if len(input_audio.shape) > 1: | |
| input_audio = librosa.to_mono(input_audio.transpose(1, 0)) | |
| _audio = model.slice_inference( | |
| input_audio_path, | |
| sid, | |
| vc_transform, | |
| slice_db, | |
| cluster_ratio, | |
| auto_f0, | |
| noise_scale, | |
| pad_seconds, | |
| cl_num, | |
| lg_num, | |
| lgr_num, | |
| f0_predictor, | |
| enhancer_adaptive_key, | |
| cr_threshold, | |
| k_step, | |
| use_spk_mix, | |
| second_encoding, | |
| loudness_envelope_adjustment | |
| ) | |
| model.clear_empty() | |
| timestamp = str(int(time.time())) | |
| if not os.path.exists("results"): | |
| os.makedirs("results") | |
| output_file_name = os.path.splitext(os.path.basename(input_audio_path))[0] + "_" + sid + "_" + timestamp + ".wav" | |
| output_file_path = os.path.join("results", output_file_name) | |
| sf.write(output_file_path, _audio, model.target_sample, format="wav") | |
| return output_file_path | |
| def vc_fn(sid, input_audio, vc_transform, auto_f0, cluster_ratio, slice_db, noise_scale, pad_seconds, cl_num, lg_num, lgr_num, f0_predictor, enhancer_adaptive_key, cr_threshold, k_step, use_spk_mix, second_encoding, loudness_envelope_adjustment): | |
| global model | |
| try: | |
| if input_audio is None: | |
| return "You need to upload an audio", None | |
| if model is None: | |
| return "You need to upload an model", None | |
| sampling_rate, audio = input_audio | |
| temp_path = "temp.wav" | |
| sf.write(temp_path, audio, sampling_rate, format="wav") | |
| output_file_path = vc_infer(sid, audio, temp_path, vc_transform, auto_f0, cluster_ratio, slice_db, noise_scale, pad_seconds, cl_num, lg_num, lgr_num, f0_predictor, enhancer_adaptive_key, cr_threshold, k_step, use_spk_mix, second_encoding, loudness_envelope_adjustment) | |
| os.remove(temp_path) | |
| return "Success", output_file_path | |
| except Exception as e: | |
| if debug: traceback.print_exc() | |
| raise gr.Error(e) | |
| def vc_batch_fn(sid, input_audio_files, vc_transform, auto_f0, cluster_ratio, slice_db, noise_scale, pad_seconds, cl_num, lg_num, lgr_num, f0_predictor, enhancer_adaptive_key, cr_threshold, k_step, use_spk_mix, second_encoding, loudness_envelope_adjustment): | |
| global model | |
| try: | |
| if input_audio_files is None or len(input_audio_files) == 0: | |
| return "You need to upload at least one audio file" | |
| if model is None: | |
| return "You need to upload a model" | |
| for file_obj in input_audio_files: | |
| input_audio_path = file_obj.name | |
| audio, sampling_rate = sf.read(input_audio_path) | |
| vc_infer(sid, audio, input_audio_path, vc_transform, auto_f0, cluster_ratio, slice_db, noise_scale, pad_seconds, cl_num, lg_num, lgr_num, f0_predictor, enhancer_adaptive_key, cr_threshold, k_step, use_spk_mix, second_encoding, loudness_envelope_adjustment) | |
| return "批量推理完成，音频已经被保存到results文件夹" | |
| except Exception as e: | |
| if debug: traceback.print_exc() | |
| raise gr.Error(e) | |
| def tts_fn(_text, _speaker, sid, vc_transform, auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,f0_predictor,enhancer_adaptive_key,cr_threshold, k_step,use_spk_mix,second_encoding,loudness_envelope_adjustment): | |
| global model | |
| try: | |
| subprocess.run([r"python", "tts.py", _text, _speaker]) | |
| sr = 44100 | |
| y, sr = librosa.load("tts.wav") | |
| resampled_y = librosa.resample(y, orig_sr=sr, target_sr=sr) | |
| sf.write("tts.wav", resampled_y, sr, subtype = "PCM_16") | |
| input_audio = "tts.wav" | |
| audio, sampling_rate = sf.read(input_audio) | |
| if model is None: | |
| return "You need to upload a model", None | |
| output_file_path = vc_infer(sid, audio, input_audio, vc_transform, auto_f0, cluster_ratio, slice_db, noise_scale, pad_seconds, cl_num, lg_num, lgr_num, f0_predictor, enhancer_adaptive_key, cr_threshold, k_step, use_spk_mix, second_encoding, loudness_envelope_adjustment) | |
| return "Success", output_file_path | |
| except Exception as e: | |
| if debug: traceback.print_exc() | |
| raise gr.Error(e) | |
| def load_raw_dirs(): | |
| illegal_files = [] | |
| #检查文件名 | |
| allowed_pattern = re.compile(r'^[a-zA-Z0-9_@#$%^&()_+\-=\s\.]*$') | |
| for root, dirs, files in os.walk(raw_path): | |
| if root != raw_path: # 只处理子文件夹内的文件 | |
| for file in files: | |
| file_name, _ = os.path.splitext(file) | |
| if not allowed_pattern.match(file_name): | |
| illegal_files.append(file) | |
| if len(illegal_files)!=0: | |
| return f"数据集文件名只能包含数字、字母、下划线，以下文件不符合要求，请改名后再试：{illegal_files}" | |
| #检查有没有小可爱不用wav文件当数据集 | |
| for root, dirs, files in os.walk(raw_path): | |
| if root != raw_path: # 只处理子文件夹内的文件 | |
| for file in files: | |
| if not file.lower().endswith('.wav'): | |
| illegal_files.append(file) | |
| if len(illegal_files)!=0: | |
| return f"以下文件为非wav格式文件，请删除后再试：{illegal_files}" | |
| spk_dirs = [] | |
| with os.scandir(raw_path) as entries: | |
| for entry in entries: | |
| if entry.is_dir(): | |
| spk_dirs.append(entry.name) | |
| if len(spk_dirs) != 0: | |
| return raw_dirs_list.update(value=spk_dirs) | |
| else: | |
| return raw_dirs_list.update(value="未找到数据集，请检查dataset_raw文件夹") | |
| def dataset_preprocess(encoder, f0_predictor, use_diff, vol_aug, skip_loudnorm, num_processes): | |
| diff_arg = "--use_diff" if use_diff else "" | |
| vol_aug_arg = "--vol_aug" if vol_aug else "" | |
| skip_loudnorm_arg = "--skip_loudnorm" if skip_loudnorm else "" | |
| preprocess_commands = [ | |
| r"python resample.py %s" % (skip_loudnorm_arg), | |
| r"python preprocess_flist_config.py --speech_encoder %s %s" % (encoder, vol_aug_arg), | |
| r"python preprocess_hubert_f0.py --num_processes %s --f0_predictor %s %s" % (num_processes ,f0_predictor, diff_arg) | |
| ] | |
| accumulated_output = "" | |
| #清空dataset | |
| dataset = os.listdir("dataset/44k") | |
| if len(dataset) != 0: | |
| for dir in dataset: | |
| dataset_dir = "dataset/44k/" + str(dir) | |
| if os.path.isdir(dataset_dir): | |
| shutil.rmtree(dataset_dir) | |
| accumulated_output += f"Deleting previous dataset: {dir}\n" | |
| for command in preprocess_commands: | |
| try: | |
| result = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True, text=True) | |
| accumulated_output += f"Command: {command}, Using Encoder: {encoder}, Using f0 Predictor: {f0_predictor}\n" | |
| yield accumulated_output, None | |
| progress_line = None | |
| for line in result.stdout: | |
| if r"it/s" in line or r"s/it" in line: #防止进度条刷屏 | |
| progress_line = line | |
| else: | |
| accumulated_output += line | |
| if progress_line is None: | |
| yield accumulated_output, None | |
| else: | |
| yield accumulated_output + progress_line, None | |
| result.communicate() | |
| except subprocess.CalledProcessError as e: | |
| result = e.output | |
| accumulated_output += f"Error: {result}\n" | |
| yield accumulated_output, None | |
| if progress_line is not None: | |
| accumulated_output += progress_line | |
| accumulated_output += '-' * 50 + '\n' | |
| yield accumulated_output, None | |
| config_path = "configs/config.json" | |
| with open(config_path, 'r') as f: | |
| config = json.load(f) | |
| spk_name = config.get('spk', None) | |
| yield accumulated_output, gr.Textbox.update(value=spk_name) | |
| def regenerate_config(encoder, vol_aug): | |
| vol_aug_arg = "--vol_aug" if vol_aug else "" | |
| cmd = r"python preprocess_flist_config.py --speech_encoder %s %s" % (encoder, vol_aug_arg) | |
| output = "" | |
| try: | |
| result = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True, text=True) | |
| for line in result.stdout: | |
| output += line | |
| output += "Regenerate config file successfully." | |
| except subprocess.CalledProcessError as e: | |
| result = e.output | |
| output += f"Error: {result}\n" | |
| return output | |
| def clear_output(): | |
| return gr.Textbox.update(value="Cleared!>_<") | |
| def read_config(config_path): | |
| with open(config_path, 'r') as config_file: | |
| config_data = json.load(config_file) | |
| return config_data | |
| def config_fn(log_interval, eval_interval, keep_ckpts, batch_size, lr, fp16_run, all_in_mem, diff_num_workers, diff_cache_all_data, diff_batch_size, diff_lr, diff_interval_log, diff_interval_val, diff_cache_device, diff_amp_dtype, diff_force_save): | |
| config_origin = "configs/config.json" | |
| diff_config = "configs/diffusion.yaml" | |
| config_data = read_config(config_origin) | |
| config_data['train']['log_interval'] = int(log_interval) | |
| config_data['train']['eval_interval'] = int(eval_interval) | |
| config_data['train']['keep_ckpts'] = int(keep_ckpts) | |
| config_data['train']['batch_size'] = int(batch_size) | |
| config_data['train']['learning_rate'] = float(lr) | |
| config_data['train']['fp16_run'] = fp16_run | |
| config_data['train']['all_in_mem'] = all_in_mem | |
| with open(config_origin, 'w') as config_file: | |
| json.dump(config_data, config_file, indent=4) | |
| with open(diff_config, 'r') as diff_yaml: | |
| diff_config_data = yaml.safe_load(diff_yaml) | |
| diff_config_data['train']['num_workers'] = int(diff_num_workers) | |
| diff_config_data['train']['cache_all_data'] = diff_cache_all_data | |
| diff_config_data['train']['batch_size'] = int(diff_batch_size) | |
| diff_config_data['train']['lr'] = float(diff_lr) | |
| diff_config_data['train']['interval_log'] = int(diff_interval_log) | |
| diff_config_data['train']['interval_val'] = int(diff_interval_val) | |
| diff_config_data['train']['cache_device'] = str(diff_cache_device) | |
| diff_config_data['train']['amp_dtype'] = str(diff_amp_dtype) | |
| diff_config_data['train']['interval_force_save'] = int(diff_force_save) | |
| with open(diff_config, 'w') as diff_yaml: | |
| yaml.safe_dump(diff_config_data, diff_yaml, default_flow_style=False, sort_keys=False) | |
| return "配置文件写入完成" | |
| def check_dataset(dataset_path): | |
| if not os.listdir(dataset_path): | |
| return "数据集不存在，请检查dataset文件夹" | |
| no_npy_pt_files = True | |
| for root, dirs, files in os.walk(dataset_path): | |
| for file in files: | |
| if file.endswith('.npy') or file.endswith('.pt'): | |
| no_npy_pt_files = False | |
| break | |
| if no_npy_pt_files: | |
| return "数据集中未检测到f0和hubert文件，可能是预处理未完成" | |
| return None | |
| def training(gpu_selection, encoder): | |
| config_data = read_config("configs/config.json") | |
| vol_emb = config_data["model"]["vol_embedding"] | |
| dataset_warn = check_dataset("dataset/44k") | |
| if dataset_warn is not None: | |
| return dataset_warn | |
| encoder_models = { #编码器好多，要塞不下了 | |
| "vec256l9": ("D_0.pth", "G_0.pth", "pre_trained_model"), | |
| "vec768l12": ("D_0.pth", "G_0.pth", "pre_trained_model/768l12/vol_emb" if vol_emb else "pre_trained_model/768l12"), | |
| "hubertsoft": ("D_0.pth", "G_0.pth", "pre_trained_model/hubertsoft"), | |
| "whisper-ppg": ("D_0.pth", "G_0.pth", "pre_trained_model/whisper-ppg"), | |
| "cnhubertlarge": ("D_0.pth", "G_0.pth", "pre_trained_model/cnhubertlarge"), | |
| "dphubert": ("D_0.pth", "G_0.pth", "pre_trained_model/dphubert"), | |
| "whisper-ppg-large": ("D_0.pth", "G_0.pth", "pre_trained_model/whisper-ppg-large") | |
| } | |
| if encoder not in encoder_models: | |
| return "未知编码器" | |
| d_0_file, g_0_file, encoder_model_path = encoder_models[encoder] | |
| d_0_path = os.path.join(encoder_model_path, d_0_file) | |
| g_0_path = os.path.join(encoder_model_path, g_0_file) | |
| timestamp = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M') | |
| new_backup_folder = os.path.join(models_backup_path, str(timestamp)) | |
| if os.listdir(workdir) != ['diffusion']: | |
| os.makedirs(new_backup_folder, exist_ok=True) | |
| for file in os.listdir(workdir): | |
| if file != "diffusion": | |
| shutil.move(os.path.join(workdir, file), os.path.join(new_backup_folder, file)) | |
| shutil.copy(d_0_path, os.path.join(workdir, "D_0.pth")) | |
| shutil.copy(g_0_path, os.path.join(workdir, "G_0.pth")) | |
| cmd = r"set CUDA_VISIBLE_DEVICES=%s && python train.py -c configs/config.json -m 44k" % (gpu_selection) | |
| subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", cmd]) | |
| return "已经在新的终端窗口开始训练，请监看终端窗口的训练日志。在终端中按Ctrl+C可暂停训练。" | |
| def continue_training(gpu_selection, encoder): | |
| dataset_warn = check_dataset("dataset/44k") | |
| if dataset_warn is not None: | |
| return dataset_warn | |
| if encoder == "": | |
| return "请先选择预处理对应的编码器" | |
| all_files = os.listdir(workdir) | |
| model_files = [f for f in all_files if f.startswith('G_') and f.endswith('.pth')] | |
| if len(model_files) == 0: | |
| return "你还没有已开始的训练" | |
| cmd = r"set CUDA_VISIBLE_DEVICES=%s && python train.py -c configs/config.json -m 44k" % (gpu_selection) | |
| subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", cmd]) | |
| return "已经在新的终端窗口开始训练，请监看终端窗口的训练日志。在终端中按Ctrl+C可暂停训练。" | |
| def kmeans_training(kmeans_gpu): | |
| if not os.listdir(r"dataset/44k"): | |
| return "数据集不存在，请检查dataset文件夹" | |
| cmd = r"python cluster/train_cluster.py --gpu" if kmeans_gpu else r"python cluster/train_cluster.py" | |
| subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", cmd]) | |
| return "已经在新的终端窗口开始训练，训练聚类模型不会输出日志，CPU训练一般需要5-10分钟左右" | |
| def index_training(): | |
| if not os.listdir(r"dataset/44k"): | |
| return "数据集不存在，请检查dataset文件夹" | |
| cmd = r"python train_index.py -c configs/config.json" | |
| subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", cmd]) | |
| return "已经在新的终端窗口开始训练" | |
| def diff_training(encoder): | |
| if not os.listdir(r"dataset/44k"): | |
| return "数据集不存在，请检查dataset文件夹" | |
| pre_trained_model_768l12 = "pre_trained_model/diffusion/768l12/model_0.pt" | |
| pre_trained_model_hubertsoft = "pre_trained_model/diffusion/hubertsoft/model_0.pt" | |
| timestamp = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M') | |
| new_backup_folder = os.path.join(models_backup_path, "diffusion", str(timestamp)) | |
| if len(os.listdir(diff_workdir)) != 0: | |
| os.makedirs(new_backup_folder, exist_ok=True) | |
| for file in os.listdir(diff_workdir): | |
| shutil.move(os.path.join(diff_workdir, file), os.path.join(new_backup_folder, file)) | |
| if encoder == "vec256l9" or encoder == "whisper-ppg": | |
| return "你所选的编码器暂时不支持训练扩散模型" | |
| elif encoder == "vec768l12": | |
| shutil.copy(pre_trained_model_768l12, os.path.join(diff_workdir, "model_0.pt")) | |
| elif encoder == "hubertsoft": | |
| shutil.copy(pre_trained_model_hubertsoft, os.path.join(diff_workdir, "model_0.pt")) | |
| else: | |
| return "请先选择编码器" | |
| subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", r"python train_diff.py -c configs/diffusion.yaml"]) | |
| return "已经在新的终端窗口开始训练，请监看终端窗口的训练日志。在终端中按Ctrl+C可暂停训练。" | |
| def diff_continue_training(encoder): | |
| if not os.listdir(r"dataset/44k"): | |
| return "数据集不存在，请检查dataset文件夹" | |
| if encoder == "": | |
| return "请先选择预处理对应的编码器" | |
| all_files = os.listdir(diff_workdir) | |
| model_files = [f for f in all_files if f.endswith('.pt')] | |
| if len(model_files) == 0: | |
| return "你还没有已开始的训练" | |
| subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", r"python train_diff.py -c configs/diffusion.yaml"]) | |
| return "已经在新的终端窗口开始训练，请监看终端窗口的训练日志。在终端中按Ctrl+C可暂停训练。" | |
| def upload_mix_append_file(files,sfiles): | |
| try: | |
| if(sfiles == None): | |
| file_paths = [file.name for file in files] | |
| else: | |
| file_paths = [file.name for file in chain(files,sfiles)] | |
| p = {file:100 for file in file_paths} | |
| return file_paths,mix_model_output1.update(value=json.dumps(p,indent=2)) | |
| except Exception as e: | |
| if debug: traceback.print_exc() | |
| raise gr.Error(e) | |
| def mix_submit_click(js,mode): | |
| try: | |
| assert js.lstrip()!="" | |
| modes = {"凸组合":0, "线性组合":1} | |
| mode = modes[mode] | |
| data = json.loads(js) | |
| data = list(data.items()) | |
| model_path,mix_rate = zip(*data) | |
| path = mix_model(model_path,mix_rate,mode) | |
| return f"成功，文件被保存在了{path}" | |
| except Exception as e: | |
| if debug: traceback.print_exc() | |
| raise gr.Error(e) | |
| def updata_mix_info(files): | |
| try: | |
| if files == None : return mix_model_output1.update(value="") | |
| p = {file.name:100 for file in files} | |
| return mix_model_output1.update(value=json.dumps(p,indent=2)) | |
| except Exception as e: | |
| if debug: traceback.print_exc() | |
| raise gr.Error(e) | |
| def pth_identify(): | |
| if not os.path.exists(root_dir): | |
| return f"未找到{root_dir}文件夹，请先创建一个{root_dir}文件夹并按第一步流程操作" | |
| model_dirs = [d for d in os.listdir(root_dir) if os.path.isdir(os.path.join(root_dir, d))] | |
| if not model_dirs: | |
| return f"未在{root_dir}文件夹中找到模型文件夹，请确保每个模型和配置文件都被放置在单独的文件夹中" | |
| valid_model_dirs = [] | |
| for path in model_dirs: | |
| pth_files = glob.glob(f"{root_dir}/{path}/*.pth") | |
| json_files = glob.glob(f"{root_dir}/{path}/*.json") | |
| if len(pth_files) != 1 or len(json_files) != 1: | |
| return f"错误: 在{root_dir}/{path}中找到了{len(pth_files)}个.pth文件和{len(json_files)}个.json文件。应当确保每个文件夹内有且只有一个.pth文件和.json文件" | |
| valid_model_dirs.append(path) | |
| return f"成功识别了{len(valid_model_dirs)}个模型：{valid_model_dirs}" | |
| def onnx_export(): | |
| model_dirs = [d for d in os.listdir(root_dir) if os.path.isdir(os.path.join(root_dir, d))] | |
| try: | |
| for path in model_dirs: | |
| pth_files = glob.glob(f"{root_dir}/{path}/*.pth") | |
| json_files = glob.glob(f"{root_dir}/{path}/*.json") | |
| model_file = pth_files[0] | |
| json_file = json_files[0] | |
| with open(json_file, 'r') as config_file: | |
| config_data = json.load(config_file) | |
| channels = config_data["model"]["gin_channels"] | |
| if str(channels) == "256": | |
| para1 = 1 | |
| if str(channels) == "768": | |
| para1 = 192 | |
| device = torch.device("cpu") | |
| hps = utils.get_hparams_from_file(json_file) | |
| SVCVITS = SynthesizerTrn( | |
| hps.data.filter_length // 2 + 1, | |
| hps.train.segment_size // hps.data.hop_length, | |
| **hps.model) | |
| _ = utils.load_checkpoint(model_file, SVCVITS, None) | |
| _ = SVCVITS.eval().to(device) | |
| for i in SVCVITS.parameters(): | |
| i.requires_grad = False | |
| n_frame = 10 | |
| test_hidden_unit = torch.rand(para1, n_frame, channels) | |
| test_pitch = torch.rand(1, n_frame) | |
| test_mel2ph = torch.arange(0, n_frame, dtype=torch.int64)[None] # torch.LongTensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).unsqueeze(0) | |
| test_uv = torch.ones(1, n_frame, dtype=torch.float32) | |
| test_noise = torch.randn(1, 192, n_frame) | |
| test_sid = torch.LongTensor([0]) | |
| input_names = ["c", "f0", "mel2ph", "uv", "noise", "sid"] | |
| output_names = ["audio", ] | |
| onnx_file = os.path.splitext(model_file)[0] + ".onnx" | |
| torch.onnx.export(SVCVITS, | |
| ( | |
| test_hidden_unit.to(device), | |
| test_pitch.to(device), | |
| test_mel2ph.to(device), | |
| test_uv.to(device), | |
| test_noise.to(device), | |
| test_sid.to(device) | |
| ), | |
| onnx_file, | |
| dynamic_axes={ | |
| "c": [0, 1], | |
| "f0": [1], | |
| "mel2ph": [1], | |
| "uv": [1], | |
| "noise": [2], | |
| }, | |
| do_constant_folding=False, | |
| opset_version=16, | |
| verbose=False, | |
| input_names=input_names, | |
| output_names=output_names) | |
| return "转换成功，模型被保存在了checkpoints下的对应目录" | |
| except Exception as e: | |
| if debug: traceback.print_exc() | |
| return "转换错误："+str(e) | |
| def load_raw_audio(audio_path): | |
| if not os.path.isdir(audio_path): | |
| return "请输入正确的目录", None | |
| files = os.listdir(audio_path) | |
| wav_files = [file for file in files if file.lower().endswith('.wav')] | |
| if not wav_files: | |
| return "未在目录中找到.wav音频文件", None | |
| return "成功加载", wav_files | |
| def slicer_fn(input_dir, output_dir, process_method, max_sec, min_sec): | |
| if output_dir == "": | |
| return "请先选择输出的文件夹" | |
| slicer = AutoSlicer() | |
| if not os.path.exists(output_dir): | |
| os.makedirs(output_dir) | |
| for filename in os.listdir(input_dir): | |
| if filename.lower().endswith(".wav"): | |
| slicer.auto_slice(filename, input_dir, output_dir, max_sec) | |
| if process_method == "丢弃": | |
| for filename in os.listdir(output_dir): | |
| if filename.endswith(".wav"): | |
| filepath = os.path.join(output_dir, filename) | |
| audio, sr = librosa.load(filepath, sr=None, mono=False) | |
| if librosa.get_duration(y=audio, sr=sr) < min_sec: | |
| os.remove(filepath) | |
| elif process_method == "将过短音频整合为长音频": | |
| slicer.merge_short(output_dir, max_sec, min_sec) | |
| file_count, max_duration, min_duration, orig_duration, final_duration = slicer.slice_count(input_dir, output_dir) | |
| hrs = int(final_duration / 3600) | |
| mins = int((final_duration % 3600) / 60) | |
| sec = format(float(final_duration % 60), '.2f') | |
| rate = format(100 * (final_duration / orig_duration), '.2f') | |
| return f"成功将音频切分为{file_count}条片段，其中最长{max_duration}秒，最短{min_duration}秒，切片后的音频总时长{hrs:02d}小时{mins:02d}分{sec}秒，为原始音频时长的{rate}%" | |
| def model_compression(_model): | |
| if _model == "": | |
| return "请先选择要压缩的模型" | |
| else: | |
| model_path = os.path.join(workdir, _model) | |
| filename, extension = os.path.splitext(_model) | |
| output_model_name = f"{filename}_compressed{extension}" | |
| output_path = os.path.join(workdir, output_model_name) | |
| removeOptimizer(model_path, output_path) | |
| return f"模型已成功被保存在了{output_path}" | |
| # read ckpt list | |
| ckpt_list, config_list, cluster_list, diff_list, diff_config_list = load_options() | |
| #read GPU info | |
| ngpu=torch.cuda.device_count() | |
| gpu_infos=[] | |
| if(torch.cuda.is_available()==False or ngpu==0):if_gpu_ok=False | |
| else: | |
| if_gpu_ok = False | |
| for i in range(ngpu): | |
| gpu_name=torch.cuda.get_device_name(i) | |
| if("MX"in gpu_name):continue | |
| if("10"in gpu_name or "16"in gpu_name or "20"in gpu_name or "30"in gpu_name or "40"in gpu_name or "A50"in gpu_name.upper() or "70"in gpu_name or "80"in gpu_name or "90"in gpu_name or "M4"in gpu_name or"P4"in gpu_name or "T4"in gpu_name or "TITAN"in gpu_name.upper()):#A10#A100#V100#A40#P40#M40#K80 | |
| if_gpu_ok=True#至少有一张能用的N卡 | |
| gpu_infos.append("%s\t%s"%(i,gpu_name)) | |
| gpu_info="\n".join(gpu_infos)if if_gpu_ok==True and len(gpu_infos)>0 else "很遗憾您这没有能用的显卡来支持您训练" | |
| gpus="-".join([i[0]for i in gpu_infos]) | |
| #read default params | |
| sovits_params, diff_params = get_default_settings() | |
| app = gr.Blocks() | |
| def Newget_model_info(choice_ckpt2): | |
| choice_ckpt = str(choice_ckpt2) | |
| pthfile = os.path.join(workdir, choice_ckpt) | |
| net = torch.load(pthfile, map_location=torch.device('cpu')) #cpu load | |
| spk_emb = net["model"].get("emb_g.weight") | |
| if spk_emb is None: | |
| return "所选模型缺少emb_g.weight，你可能选择了一个底模" | |
| _dim, _layer = spk_emb.size() | |
| model_type = { | |
| 768: "Vec768-Layer12", | |
| 256: "Vec256-Layer9 / HubertSoft", | |
| 1024: "Whisper-PPG" | |
| } | |
| return gr.Textbox(visible=False, value=model_type.get(_layer, "不受支持的模型")) | |
| with app: | |
| gr.Markdown(value=""" | |
| ### So-VITS-SVC 4.1-Stable | |
| 修改自原项目及bilibili@麦哲云 | |
| 仅供个人娱乐和非商业用途，禁止用于血腥、暴力、性相关、政治相关内容 | |
| weiui来自：bilibili@羽毛布団，交流③群:416656175 | |
| 镜像作者：bilibili@kiss丿冷鸟鸟,交流群:829974025 | |
| """) | |
| with gr.Tabs(): | |
| with gr.TabItem("米浴 (Rice Shower)"): | |
| #with gr.Row(): | |
| # choice_ckpt = gr.Dropdown(label="模型选择", choices=ckpt_list, value="no_model") | |
| # model_branch = gr.Textbox(label="模型编码器", placeholder="请先选择模型", interactive=False) | |
| #choice_ckpt = gr.Dropdown(value="G_132000.pth", visible=False) | |
| #with gr.Row(): | |
| # config_choice = gr.Dropdown(label="配置文件", choices=config_list, value="no_config") | |
| # config_info = gr.Textbox(label="配置文件编码器", placeholder="请选择配置文件") | |
| config_choice = gr.Dropdown(value="config.json", visible=False) | |
| #gr.Markdown(value="""**请检查模型和配置文件的编码器是否匹配**""") | |
| #with gr.Row(): | |
| # diff_choice = gr.Dropdown(label="（可选）选择扩散模型", choices=diff_list, value="no_diff", interactive=True) | |
| # diff_config_choice = gr.Dropdown(label="扩散模型配置文件", choices=diff_config_list, value="no_diff_config", interactive=True) | |
| diff_choice = gr.Dropdown(value="no_diff", visible=False) | |
| diff_config_choice = gr.Dropdown(value="no_diff_config", visible=False) | |
| with gr.Row(): | |
| cluster_choice = gr.Dropdown(label="（可选）选择聚类模型/特征检索模型", choices=cluster_list, value="no_clu") | |
| with gr.Row(): | |
| enhance = gr.Checkbox(label="是否使用NSF_HIFIGAN增强，该选项对部分训练集少的模型有一定的音质增强效果，但是对训练好的模型有反面效果，默认关闭", value=False) | |
| #only_diffusion = gr.Checkbox(label="是否使用全扩散推理，开启后将不使用So-VITS模型，仅使用扩散模型进行完整扩散推理，默认关闭", value=False) | |
| only_diffusion = gr.Checkbox(value=False, visible=False) | |
| #using_device = gr.Dropdown(label="推理设备，默认为自动选择", choices=["Auto","cuda","cpu"], value="Auto") | |
| using_device = gr.Dropdown(value='Auto', visible=False) | |
| #refresh = gr.Button("刷新选项") | |
| #loadckpt = gr.Button("加载模型", variant="primary") | |
| #with gr.Row(): | |
| # model_message = gr.Textbox(label="Output Message") | |
| # sid = gr.Dropdown(label="So-VITS说话人", value="speaker0") | |
| sid = gr.Dropdown(value="1030", visible=False) | |
| #choice_ckpt.change(get_model_info, [choice_ckpt], [model_branch]) | |
| model_branch = Newget_model_info("G_132000.pth") | |
| #config_choice.change(load_json_encoder, [config_choice], [config_info]) | |
| #refresh.click(refresh_options,[],[choice_ckpt,config_choice,cluster_choice,diff_choice,diff_config_choice]) | |
| gr.Markdown(value=""" | |
| 请稍等片刻，模型加载大约需要10秒。后续操作不需要重新加载模型 | |
| """) | |
| with gr.Tabs(): | |
| with gr.TabItem("单个音频上传"): | |
| vc_input3 = gr.Audio(label="单个音频上传") | |
| with gr.TabItem("批量音频上传"): | |
| vc_batch_files = gr.Files(label="批量音频上传", file_types=["audio"], file_count="multiple") | |
| with gr.TabItem("文字转语音（实验性）"): | |
| gr.Markdown(""" | |
| 文字转语音（TTS）说明：使用edge_tts服务生成音频，并转换为So-VITS模型音色。可以在输入文字中使用标点符号简单控制情绪 | |
| zh-CN-XiaoyiNeural：中文女声 | |
| zh-CN-YunxiNeural: 中文男声 | |
| ja-JP-NanamiNeural：日文女声 | |
| ja-JP-KeitaNeural：日文男声 | |
| zh-CN-liaoning-XiaobeiNeural：东北话女声 | |
| zh-CN-shaanxi-XiaoniNeural: 陕西话女声 | |
| zh-HK-HiuMaanNeural: 粤语女声 | |
| zh-HK-WanLungNeural: 粤语男声 | |
| """) | |
| with gr.Row(): | |
| text_input = gr.Textbox(label = "在此输入需要转译的文字（建议打开自动f0预测）",) | |
| tts_spk = gr.Dropdown(label = "选择原始音频音色（来自微软TTS）", choices=["zh-CN-XiaoyiNeural", "zh-CN-YunxiNeural", "zh-CN-liaoning-XiaobeiNeural", "zh-CN-shaanxi-XiaoniNeural", "zh-HK-HiuMaanNeural", "zh-HK-WanLungNeural", "ja-JP-NanamiNeural", "ja-JP-KeitaNeural"], value = "zh-CN-XiaoyiNeural") | |
| #with gr.Row(): | |
| # tts_rate = gr.Slider(label = "TTS语音变速（倍速）", minimum = 0, maximum = 3, value = 1) | |
| # tts_volume = gr.Slider(label = "TTS语音音量（相对值）", minimum = 0, maximum = 1.5, value = 1) | |
| with gr.Row(): | |
| auto_f0 = gr.Checkbox(label="自动f0预测，配合聚类模型f0预测效果更好,会导致变调功能失效（仅限转换语音，歌声不要勾选此项会跑调）", value=False) | |
| f0_predictor = gr.Radio(label="f0预测器选择（如遇哑音可以更换f0预测器解决，crepe为原F0使用均值滤波器）", choices=["pm","crepe","harvest","dio"], value="pm") | |
| cr_threshold = gr.Number(label="F0过滤阈值，只有使用crepe时有效. 数值范围从0-1. 降低该值可减少跑调概率，但会增加哑音", value=0.05) | |
| with gr.Row(): | |
| vc_transform = gr.Number(label="变调（整数，可以正负，半音数量，升高八度就是12）", value=0) | |
| cluster_ratio = gr.Number(label="聚类模型/特征检索混合比例，0-1之间，默认为0不启用聚类或特征检索，能提升音色相似度，但会导致咬字下降", value=0) | |
| k_step = gr.Slider(label="浅扩散步数，只有使用了扩散模型才有效，步数越大越接近扩散模型的结果", value=100, minimum = 1, maximum = 1000) | |
| with gr.Row(): | |
| enhancer_adaptive_key = gr.Number(label="使NSF-HIFIGAN增强器适应更高的音域(单位为半音数)|默认为0", value=0,interactive=True) | |
| slice_db = gr.Number(label="切片阈值", value=-50) | |
| cl_num = gr.Number(label="音频自动切片，0为按默认方式切片，单位为秒/s，爆显存可以设置此处强制切片", value=0) | |
| with gr.Accordion("高级设置（一般不需要动）", open=False): | |
| noise_scale = gr.Number(label="noise_scale 建议不要动，会影响音质，玄学参数", value=0.4) | |
| pad_seconds = gr.Number(label="推理音频pad秒数，由于未知原因开头结尾会有异响，pad一小段静音段后就不会出现", value=0.5) | |
| lg_num = gr.Number(label="两端音频切片的交叉淡入长度，如果自动切片后出现人声不连贯可调整该数值，如果连贯建议采用默认值0，注意，该设置会影响推理速度，单位为秒/s", value=1) | |
| lgr_num = gr.Number(label="自动音频切片后，需要舍弃每段切片的头尾。该参数设置交叉长度保留的比例，范围0-1,左开右闭", value=0.75,interactive=True) | |
| second_encoding = gr.Checkbox(label = "二次编码，浅扩散前会对原始音频进行二次编码，玄学选项，效果时好时差，默认关闭", value=False) | |
| loudness_envelope_adjustment = gr.Number(label="输入源响度包络替换输出响度包络融合比例，越靠近1越使用输出响度包络", value = 0) | |
| use_spk_mix = gr.Checkbox(label="动态声线融合，暂时没做完", value=False, interactive=False) | |
| with gr.Row(): | |
| vc_submit = gr.Button("音频转换", variant="primary") | |
| vc_batch_submit = gr.Button("批量转换", variant="primary") | |
| vc_tts_submit = gr.Button("文本转语音", variant="primary") | |
| vc_output1 = gr.Textbox(label="Output Message") | |
| vc_output2 = gr.Audio(label="Output Audio") | |
| def Newvc_fn(sid, input_audio, vc_transform, auto_f0, cluster_ratio, slice_db, noise_scale, pad_seconds, cl_num, lg_num, lgr_num, f0_predictor, enhancer_adaptive_key, cr_threshold, k_step, use_spk_mix, second_encoding, loudness_envelope_adjustment, clus2): | |
| global model, loaded | |
| if loaded != clus2: | |
| Newload_model_func("G_132000.pth",clus2,config_choice,enhance,diff_choice,diff_config_choice,only_diffusion,model_branch,using_device) | |
| loaded = clus2 | |
| try: | |
| if input_audio is None: | |
| return "You need to upload an audio", None | |
| if model is None: | |
| return "You need to upload an model", None | |
| sampling_rate, audio = input_audio | |
| temp_path = "temp.wav" | |
| sf.write(temp_path, audio, sampling_rate, format="wav") | |
| output_file_path = vc_infer(sid, audio, temp_path, vc_transform, auto_f0, cluster_ratio, slice_db, noise_scale, pad_seconds, cl_num, lg_num, lgr_num, f0_predictor, enhancer_adaptive_key, cr_threshold, k_step, use_spk_mix, second_encoding, loudness_envelope_adjustment) | |
| os.remove(temp_path) | |
| return "Success", output_file_path | |
| except Exception as e: | |
| if debug: traceback.print_exc() | |
| raise gr.Error(e) | |
| #loadckpt.click(load_model_func,[choice_ckpt,cluster_choice,config_choice,enhance,diff_choice,diff_config_choice,only_diffusion,model_branch,using_device],[model_message, sid, cl_num]) | |
| vc_submit.click(Newvc_fn, [sid, vc_input3, vc_transform,auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,f0_predictor,enhancer_adaptive_key,cr_threshold,k_step,use_spk_mix,second_encoding,loudness_envelope_adjustment,cluster_choice], [vc_output1, vc_output2]) | |
| vc_batch_submit.click(vc_batch_fn, [sid, vc_batch_files, vc_transform,auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,f0_predictor,enhancer_adaptive_key,cr_threshold,k_step,use_spk_mix,second_encoding,loudness_envelope_adjustment], [vc_output1]) | |
| vc_tts_submit.click(tts_fn, [text_input, tts_spk, sid, vc_transform,auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,f0_predictor,enhancer_adaptive_key,cr_threshold,k_step,use_spk_mix,second_encoding,loudness_envelope_adjustment], [vc_output1, vc_output2]) | |
| ''' | |
| with gr.TabItem("训练"): | |
| gr.Markdown(value="""请将数据集文件夹放置在dataset_raw文件夹下，确认放置正确后点击下方获取数据集名称""") | |
| raw_dirs_list=gr.Textbox(label="Raw dataset directory(s):") | |
| get_raw_dirs=gr.Button("识别数据集", variant="primary") | |
| gr.Markdown(value="""确认数据集正确识别后请选择训练使用的特征编码器和f0预测器，**如果要训练扩散模型，请选择Vec768l12或hubertsoft，并确保So-VITS和扩散模型使用同一个编码器**""") | |
| with gr.Row(): | |
| gr.Markdown(value="""**vec256l9**: ContentVec(256Layer9)，旧版本叫v1，So-VITS-SVC 4.0的基础版本，**暂不支持扩散模型** | |
| **vec768l12**: 特征输入更换为ContentVec的第12层Transformer输出，模型理论上会更加还原训练集音色 | |
| **hubertsoft**: So-VITS-SVC 3.0使用的编码器，咬字更为准确，但可能存在多说话人音色泄露问题 | |
| **whisper-ppg**: 来自OpenAI，咬字最为准确，但和Hubertsoft一样存在多说话人音色泄露，且显存占用和训练时间有明显增加。**暂不支持扩散模型** | |
| """) | |
| gr.Markdown(value="""**crepe**: 抗噪能力最强，但预处理速度慢（不过如果你的显卡很强的话速度会很快） | |
| **pm**: 预处理速度快，但抗噪能力较弱 | |
| **dio**: 先前版本预处理默认使用的f0预测器 | |
| **harvest**: 有一定抗噪能力，预处理显存占用友好，速度比较慢 | |
| """) | |
| with gr.Row(): | |
| branch_selection = gr.Radio(label="选择训练使用的编码器", choices=["vec256l9","vec768l12","hubertsoft","whisper-ppg"], value="vec768l12", interactive=True) | |
| f0_predictor_selection = gr.Radio(label="选择训练使用的f0预测器", choices=["crepe","pm","dio","harvest"], value="crepe", interactive=True) | |
| use_diff = gr.Checkbox(label="是否使用浅扩散模型，如要训练浅扩散模型请勾选此项", value=True) | |
| vol_aug=gr.Checkbox(label="是否启用响度嵌入和音量增强，启用后可以根据输入源控制输出响度，但对数据集质量的要求更高。**仅支持vec768l12编码器**", value=False) | |
| with gr.Row(): | |
| skip_loudnorm = gr.Checkbox(label="是否跳过响度匹配，如果你已经用音频处理软件做过响度匹配，请勾选此处") | |
| num_processes = gr.Slider(label="预处理使用的CPU线程数，可以大幅加快预处理速度，但线程数过大容易爆显存，建议12G显存设置为2", minimum=1, maximum=multiprocessing.cpu_count(), value=1, step=1) | |
| with gr.Row(): | |
| raw_preprocess=gr.Button("数据预处理", variant="primary") | |
| regenerate_config_btn=gr.Button("重新生成配置文件", variant="primary") | |
| preprocess_output=gr.Textbox(label="预处理输出信息，完成后请检查一下是否有报错信息，如无则可以进行下一步", max_lines=999) | |
| clear_preprocess_output=gr.Button("清空输出信息") | |
| with gr.Group(): | |
| gr.Markdown(value="""填写训练设置和超参数""") | |
| with gr.Row(): | |
| gr.Textbox(label="当前使用显卡信息", value=gpu_info) | |
| gpu_selection=gr.Textbox(label="多卡用户请指定希望训练使用的显卡ID（0,1,2...）", value=gpus, interactive=True) | |
| with gr.Row(): | |
| log_interval=gr.Textbox(label="每隔多少步(steps)生成一次评估日志", value=sovits_params['log_interval']) | |
| eval_interval=gr.Textbox(label="每隔多少步(steps)验证并保存一次模型", value=sovits_params['eval_interval']) | |
| keep_ckpts=gr.Textbox(label="仅保留最新的X个模型，超出该数字的旧模型会被删除。设置为0则永不删除", value=sovits_params['keep_ckpts']) | |
| with gr.Row(): | |
| batch_size=gr.Textbox(label="批量大小，每步取多少条数据进行训练，大batch有助于训练但显著增加显存占用。6G显存建议设定为4", value=sovits_params['batch_size']) | |
| lr=gr.Textbox(label="学习率，一般不用动，批量大小较大时可以适当增大学习率，但强烈不建议超过0.0002，有炸炉风险", value=sovits_params['learning_rate']) | |
| fp16_run=gr.Checkbox(label="是否使用fp16混合精度训练，fp16训练可能降低显存占用和训练时间，但对模型质量的影响尚未查证", value=sovits_params['fp16_run']) | |
| all_in_mem=gr.Checkbox(label="是否加载所有数据集到内存中，硬盘IO过于低下、同时内存容量远大于数据集体积时可以启用，能显著加快训练速度", value=sovits_params['all_in_mem']) | |
| with gr.Row(): | |
| gr.Markdown("请检查右侧的说话人列表是否和你要训练的目标说话人一致，确认无误后点击写入配置文件，然后就可以开始训练了") | |
| speakers=gr.Textbox(label="说话人列表") | |
| with gr.Accordion(label = "扩散模型配置（训练扩散模型需要写入此处）", open=True): | |
| with gr.Row(): | |
| diff_num_workers = gr.Number(label="num_workers, 如果你的电脑配置较高，可以将这里设置为0加快训练速度", value=diff_params['num_workers']) | |
| diff_cache_all_data = gr.Checkbox(label="是否缓存数据，启用后可以加快训练速度，关闭后可以节省显存或内存，但会减慢训练速度", value=diff_params['cache_all_data']) | |
| diff_cache_device = gr.Radio(label="若启用缓存数据，使用显存(cuda)还是内存(cpu)缓存，如果显卡显存充足，选择cuda以加快训练速度", choices=["cuda","cpu"], value=diff_params['cache_device']) | |
| diff_amp_dtype = gr.Radio(label="训练数据类型，fp16可能会有更快的训练速度，前提是你的显卡支持", choices=["fp32","fp16"], value=diff_params['amp_dtype']) | |
| with gr.Row(): | |
| diff_batch_size = gr.Number(label="批量大小(batch_size)，根据显卡显存设置，小显存适当降低该项，6G显存可以设定为48，但该数值不要超过数据集总数量的1/4", value=diff_params['diff_batch_size']) | |
| diff_lr = gr.Number(label="学习率（一般不需要动）", value=diff_params['diff_lr']) | |
| diff_interval_log = gr.Number(label="每隔多少步(steps)生成一次评估日志", value = diff_params['diff_interval_log']) | |
| diff_interval_val = gr.Number(label="每隔多少步(steps)验证并保存一次模型，如果你的批量大小较大，可以适当减少这里的数字，但不建议设置为1000以下", value=diff_params['diff_interval_val']) | |
| diff_force_save = gr.Number(label="每隔多少步强制保留模型，只有该步数的倍数保存的模型会被保留，其余会被删除。设置为与验证步数相同的值则每个模型都会被保留", value=diff_params['diff_force_save']) | |
| with gr.Row(): | |
| save_params=gr.Button("将当前设置保存为默认设置", variant="primary") | |
| write_config=gr.Button("写入配置文件", variant="primary") | |
| write_config_output=gr.Textbox(label="输出信息") | |
| gr.Markdown(value="""**点击从头开始训练**将会自动将已有的训练进度保存到models_backup文件夹，并自动装载预训练模型。 | |
| **继续上一次的训练进度**将从上一个保存模型的进度继续训练。继续训练进度无需重新预处理和写入配置文件。 | |
| 关于扩散、聚类和特征检索的详细说明请看[此处](https://www.yuque.com/umoubuton/ueupp5/kmui02dszo5zrqkz)。 | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| start_training=gr.Button("从头开始训练", variant="primary") | |
| training_output=gr.Textbox(label="训练输出信息") | |
| with gr.Column(): | |
| continue_training_btn=gr.Button("继续上一次的训练进度", variant="primary") | |
| continue_training_output=gr.Textbox(label="训练输出信息") | |
| with gr.Row(): | |
| with gr.Column(): | |
| diff_training_btn=gr.Button("从头训练扩散模型", variant="primary") | |
| diff_training_output=gr.Textbox(label="训练输出信息") | |
| with gr.Column(): | |
| diff_continue_training_btn=gr.Button("继续训练扩散模型", variant="primary") | |
| diff_continue_training_output=gr.Textbox(label="训练输出信息") | |
| with gr.Accordion(label = "聚类、特征检索训练", open=False): | |
| with gr.Row(): | |
| with gr.Column(): | |
| kmeans_button=gr.Button("训练聚类模型", variant="primary") | |
| kmeans_gpu = gr.Checkbox(label="使用GPU训练", value=True) | |
| kmeans_output=gr.Textbox(label="训练输出信息") | |
| with gr.Column(): | |
| index_button=gr.Button("训练特征检索模型", variant="primary") | |
| index_output=gr.Textbox(label="训练输出信息") | |
| ''' | |
| with gr.TabItem("小工具/实验室特性"): | |
| gr.Markdown(value=""" | |
| ### So-vits-svc 4.1 小工具/实验室特性 | |
| 提供了一些有趣或实用的小工具，可以自行探索 | |
| """) | |
| with gr.Tabs(): | |
| with gr.TabItem("静态声线融合"): | |
| gr.Markdown(value=""" | |
| <font size=2> 介绍:该功能可以将多个声音模型合成为一个声音模型(多个模型参数的凸组合或线性组合)，从而制造出现实中不存在的声线 | |
| 注意： | |
| 1.该功能仅支持单说话人的模型 | |
| 2.如果强行使用多说话人模型，需要保证多个模型的说话人数量相同，这样可以混合同一个SpaekerID下的声音 | |
| 3.保证所有待混合模型的config.json中的model字段是相同的 | |
| 4.输出的混合模型可以使用待合成模型的任意一个config.json，但聚类模型将不能使用 | |
| 5.批量上传模型的时候最好把模型放到一个文件夹选中后一起上传 | |
| 6.混合比例调整建议大小在0-100之间，也可以调为其他数字，但在线性组合模式下会出现未知的效果 | |
| 7.混合完毕后，文件将会保存在项目根目录中，文件名为output.pth | |
| 8.凸组合模式会将混合比例执行Softmax使混合比例相加为1，而线性组合模式不会 | |
| </font> | |
| """) | |
| mix_model_path = gr.Files(label="选择需要混合模型文件") | |
| mix_model_upload_button = gr.UploadButton("选择/追加需要混合模型文件", file_count="multiple") | |
| mix_model_output1 = gr.Textbox( | |
| label="混合比例调整，单位/%", | |
| interactive = True | |
| ) | |
| mix_mode = gr.Radio(choices=["凸组合", "线性组合"], label="融合模式",value="凸组合",interactive = True) | |
| mix_submit = gr.Button("声线融合启动", variant="primary") | |
| mix_model_output2 = gr.Textbox( | |
| label="Output Message" | |
| ) | |
| with gr.TabItem("onnx转换"): | |
| gr.Markdown(value=""" | |
| 提供了将.pth模型（批量）转换为.onnx模型的功能 | |
| 源项目本身自带转换的功能，但不支持批量，操作也不够简单，这个工具可以支持在WebUI中以可视化的操作方式批量转换.onnx模型 | |
| 有人可能会问，转.onnx模型有什么作用呢？相信我，如果你问出了这个问题，说明这个工具你应该用不上 | |
| ### Step 1: | |
| 在整合包根目录下新建一个"checkpoints"文件夹，将pth模型和对应的json配置文件按目录分别放置到checkpoints文件夹下 | |
| 看起来应该像这样： | |
| checkpoints | |
| ├───xxxx | |
| │ ├───xxxx.pth | |
| │ └───xxxx.json | |
| ├───xxxx | |
| │ ├───xxxx.pth | |
| │ └───xxxx.json | |
| └───…… | |
| """) | |
| pth_dir_msg = gr.Textbox(label="识别待转换模型", placeholder="请将模型和配置文件按上述说明放置在正确位置") | |
| pth_dir_identify_btn = gr.Button("识别", variant="primary") | |
| gr.Markdown(value=""" | |
| ### Step 2: | |
| 识别正确后点击下方开始转换，转换一个模型可能需要一分钟甚至更久 | |
| """) | |
| pth2onnx_btn = gr.Button("开始转换", variant="primary") | |
| pth2onnx_msg = gr.Textbox(label="输出信息") | |
| with gr.TabItem("智能音频切片"): | |
| gr.Markdown(value=""" | |
| 该工具可以实现对音频的切片，无需调整参数即可完成符合要求的数据集制作。 | |
| 数据集要求的音频切片约在2-15秒内，用传统的Slicer-GUI切片工具需要精准调参和二次切片才能符合要求，该工具省去了上述繁琐的操作，只要上传原始音频即可一键制作数据集。 | |
| """) | |
| with gr.Row(): | |
| raw_audio_path = gr.Textbox(label="原始音频文件夹", placeholder="包含所有待切片音频的文件夹，示例: D:\干声\speakers") | |
| load_raw_audio_btn = gr.Button("加载原始音频", variant = "primary") | |
| load_raw_audio_output = gr.Textbox(label = "输出信息") | |
| raw_audio_dataset = gr.Textbox(label = "音频列表", value = "") | |
| slicer_output_dir = gr.Textbox(label = "输出目录", placeholder = "选择输出目录") | |
| with gr.Row(): | |
| process_method = gr.Radio(label = "对过短音频的处理方式", choices = ["丢弃","将过短音频整合为长音频"], value = "丢弃") | |
| max_sec = gr.Number(label = "切片的最长秒数", value = 15) | |
| min_sec = gr.Number(label = "切片的最短秒数", value = 2) | |
| slicer_btn = gr.Button("开始切片", variant = "primary") | |
| slicer_output_msg = gr.Textbox(label = "输出信息") | |
| mix_model_path.change(updata_mix_info,[mix_model_path],[mix_model_output1]) | |
| mix_model_upload_button.upload(upload_mix_append_file, [mix_model_upload_button,mix_model_path], [mix_model_path,mix_model_output1]) | |
| mix_submit.click(mix_submit_click, [mix_model_output1,mix_mode], [mix_model_output2]) | |
| pth_dir_identify_btn.click(pth_identify, [], [pth_dir_msg]) | |
| pth2onnx_btn.click(onnx_export, [], [pth2onnx_msg]) | |
| load_raw_audio_btn.click(load_raw_audio, [raw_audio_path], [load_raw_audio_output, raw_audio_dataset]) | |
| slicer_btn.click(slicer_fn, [raw_audio_path, slicer_output_dir, process_method, max_sec, min_sec], [slicer_output_msg]) | |
| with gr.TabItem("模型压缩工具"): | |
| gr.Markdown(value=""" | |
| 该工具可以实现对模型的体积压缩，在**不影响模型推理功能**的情况下，将原本约600M的So-VITS模型压缩至约200M, 大大减少了硬盘的压力。 | |
| **注意：压缩后的模型将无法继续训练，请在确认封炉后再压缩。** | |
| 将模型文件放置在logs/44k下，然后选择需要压缩的模型 | |
| """) | |
| model_to_compress = gr.Dropdown(label="模型选择", choices=ckpt_list, value="") | |
| compress_model_btn = gr.Button("压缩模型", variant="primary") | |
| compress_model_output = gr.Textbox(label="输出信息", value="") | |
| compress_model_btn.click(model_compression, [model_to_compress], [compress_model_output]) | |
| """ | |
| get_raw_dirs.click(load_raw_dirs,[],[raw_dirs_list]) | |
| raw_preprocess.click(dataset_preprocess,[branch_selection, f0_predictor_selection, use_diff, vol_aug, skip_loudnorm, num_processes],[preprocess_output, speakers]) | |
| regenerate_config_btn.click(regenerate_config,[branch_selection, vol_aug],[preprocess_output]) | |
| clear_preprocess_output.click(clear_output,[],[preprocess_output]) | |
| save_params.click(save_default_settings, [log_interval,eval_interval,keep_ckpts,batch_size,lr,fp16_run,all_in_mem,diff_num_workers,diff_cache_all_data,diff_cache_device,diff_amp_dtype,diff_batch_size,diff_lr,diff_interval_log,diff_interval_val,diff_force_save], [write_config_output]) | |
| write_config.click(config_fn,[log_interval, eval_interval, keep_ckpts, batch_size, lr, fp16_run, all_in_mem, diff_num_workers, diff_cache_all_data, diff_batch_size, diff_lr, diff_interval_log, diff_interval_val, diff_cache_device, diff_amp_dtype, diff_force_save],[write_config_output]) | |
| start_training.click(training,[gpu_selection, branch_selection],[training_output]) | |
| diff_training_btn.click(diff_training,[branch_selection],[diff_training_output]) | |
| continue_training_btn.click(continue_training,[gpu_selection, branch_selection],[continue_training_output]) | |
| diff_continue_training_btn.click(diff_continue_training,[branch_selection],[diff_continue_training_output]) | |
| kmeans_button.click(kmeans_training,[kmeans_gpu],[kmeans_output]) | |
| index_button.click(index_training, [], [index_output]) | |
| """ | |
| with gr.Tabs(): | |
| with gr.Row(variant="panel"): | |
| with gr.Column(): | |
| gr.Markdown(value=""" | |
| <font size=2> WebUI设置</font> | |
| """) | |
| debug_button = gr.Checkbox(label="Debug模式，反馈BUG需要打开，打开后控制台可以显示具体错误提示", value=debug) | |
| debug_button.change(debug_change,[],[]) | |
| app.queue(concurrency_count=1022, max_size=2044).launch() | |