|
import os |
|
import sys |
|
import argparse |
|
import subprocess |
|
|
|
now_dir = os.getcwd() |
|
sys.path.append(now_dir) |
|
|
|
from rvc.configs.config import Config |
|
from rvc.lib.tools.validators import ( |
|
validate_sampling_rate, |
|
validate_f0up_key, |
|
validate_f0method, |
|
validate_true_false, |
|
validate_tts_voices, |
|
) |
|
|
|
from rvc.train.extract.preparing_files import generate_config, generate_filelist |
|
from rvc.lib.tools.pretrained_selector import pretrained_selector |
|
|
|
from rvc.lib.process.model_fusion import model_fusion |
|
from rvc.lib.process.model_information import model_information |
|
|
|
config = Config() |
|
current_script_directory = os.path.dirname(os.path.realpath(__file__)) |
|
logs_path = os.path.join(current_script_directory, "logs") |
|
subprocess.run( |
|
["python", os.path.join("rvc", "lib", "tools", "prerequisites_download.py")] |
|
) |
|
|
|
|
|
|
|
def run_infer_script( |
|
f0up_key, |
|
filter_radius, |
|
index_rate, |
|
hop_length, |
|
f0method, |
|
input_path, |
|
output_path, |
|
pth_file, |
|
index_path, |
|
split_audio, |
|
): |
|
infer_script_path = os.path.join("rvc", "infer", "infer.py") |
|
command = [ |
|
"python", |
|
infer_script_path, |
|
str(f0up_key), |
|
str(filter_radius), |
|
str(index_rate), |
|
str(hop_length), |
|
f0method, |
|
input_path, |
|
output_path, |
|
pth_file, |
|
index_path, |
|
str(split_audio), |
|
] |
|
subprocess.run(command) |
|
return f"File {input_path} inferred successfully.", output_path |
|
|
|
|
|
|
|
def run_batch_infer_script( |
|
f0up_key, |
|
filter_radius, |
|
index_rate, |
|
hop_length, |
|
f0method, |
|
input_folder, |
|
output_folder, |
|
pth_file, |
|
index_path, |
|
): |
|
infer_script_path = os.path.join("rvc", "infer", "infer.py") |
|
|
|
audio_files = [ |
|
f for f in os.listdir(input_folder) if f.endswith((".mp3", ".wav", ".flac")) |
|
] |
|
print(f"Detected {len(audio_files)} audio files for inference.") |
|
|
|
for audio_file in audio_files: |
|
if "_output" in audio_file: |
|
pass |
|
else: |
|
input_path = os.path.join(input_folder, audio_file) |
|
output_file_name = os.path.splitext(os.path.basename(audio_file))[0] |
|
output_path = os.path.join( |
|
output_folder, |
|
f"{output_file_name}_output{os.path.splitext(audio_file)[1]}", |
|
) |
|
print(f"Inferring {input_path}...") |
|
|
|
command = [ |
|
"python", |
|
infer_script_path, |
|
str(f0up_key), |
|
str(filter_radius), |
|
str(index_rate), |
|
str(hop_length), |
|
f0method, |
|
input_path, |
|
output_path, |
|
pth_file, |
|
index_path, |
|
] |
|
subprocess.run(command) |
|
|
|
return f"Files from {input_folder} inferred successfully." |
|
|
|
|
|
|
|
def run_tts_script( |
|
tts_text, |
|
tts_voice, |
|
f0up_key, |
|
filter_radius, |
|
index_rate, |
|
hop_length, |
|
f0method, |
|
output_tts_path, |
|
output_rvc_path, |
|
pth_file, |
|
index_path, |
|
): |
|
tts_script_path = os.path.join("rvc", "lib", "tools", "tts.py") |
|
infer_script_path = os.path.join("rvc", "infer", "infer.py") |
|
|
|
if os.path.exists(output_tts_path): |
|
os.remove(output_tts_path) |
|
|
|
command_tts = [ |
|
"python", |
|
tts_script_path, |
|
tts_text, |
|
tts_voice, |
|
output_tts_path, |
|
] |
|
|
|
command_infer = [ |
|
"python", |
|
infer_script_path, |
|
str(f0up_key), |
|
str(filter_radius), |
|
str(index_rate), |
|
str(hop_length), |
|
f0method, |
|
output_tts_path, |
|
output_rvc_path, |
|
pth_file, |
|
index_path, |
|
] |
|
subprocess.run(command_tts) |
|
subprocess.run(command_infer) |
|
return f"Text {tts_text} synthesized successfully.", output_rvc_path |
|
|
|
|
|
|
|
def run_preprocess_script(model_name, dataset_path, sampling_rate): |
|
per = 3.0 if config.is_half else 3.7 |
|
preprocess_script_path = os.path.join("rvc", "train", "preprocess", "preprocess.py") |
|
command = [ |
|
"python", |
|
preprocess_script_path, |
|
os.path.join(logs_path, str(model_name)), |
|
dataset_path, |
|
str(sampling_rate), |
|
str(per), |
|
] |
|
|
|
os.makedirs(os.path.join(logs_path, str(model_name)), exist_ok=True) |
|
subprocess.run(command) |
|
return f"Model {model_name} preprocessed successfully." |
|
|
|
|
|
|
|
def run_extract_script(model_name, rvc_version, f0method, hop_length, sampling_rate): |
|
model_path = os.path.join(logs_path, str(model_name)) |
|
extract_f0_script_path = os.path.join( |
|
"rvc", "train", "extract", "extract_f0_print.py" |
|
) |
|
extract_feature_script_path = os.path.join( |
|
"rvc", "train", "extract", "extract_feature_print.py" |
|
) |
|
|
|
command_1 = [ |
|
"python", |
|
extract_f0_script_path, |
|
model_path, |
|
f0method, |
|
str(hop_length), |
|
] |
|
command_2 = [ |
|
"python", |
|
extract_feature_script_path, |
|
config.device, |
|
"1", |
|
"0", |
|
"0", |
|
model_path, |
|
rvc_version, |
|
"True", |
|
] |
|
subprocess.run(command_1) |
|
subprocess.run(command_2) |
|
|
|
generate_config(rvc_version, sampling_rate, model_path) |
|
generate_filelist(f0method, model_path, rvc_version, sampling_rate) |
|
return f"Model {model_name} extracted successfully." |
|
|
|
|
|
|
|
def run_train_script( |
|
model_name, |
|
rvc_version, |
|
save_every_epoch, |
|
save_only_latest, |
|
save_every_weights, |
|
total_epoch, |
|
sampling_rate, |
|
batch_size, |
|
gpu, |
|
pitch_guidance, |
|
pretrained, |
|
custom_pretrained, |
|
g_pretrained_path=None, |
|
d_pretrained_path=None, |
|
): |
|
f0 = 1 if str(pitch_guidance) == "True" else 0 |
|
latest = 1 if str(save_only_latest) == "True" else 0 |
|
save_every = 1 if str(save_every_weights) == "True" else 0 |
|
|
|
if str(pretrained) == "True": |
|
if str(custom_pretrained) == "False": |
|
pg, pd = pretrained_selector(f0)[rvc_version][sampling_rate] |
|
else: |
|
if g_pretrained_path is None or d_pretrained_path is None: |
|
raise ValueError( |
|
"Please provide the path to the pretrained G and D models." |
|
) |
|
pg, pd = g_pretrained_path, d_pretrained_path |
|
else: |
|
pg, pd = "", "" |
|
|
|
train_script_path = os.path.join("rvc", "train", "train.py") |
|
command = [ |
|
"python", |
|
str(train_script_path), |
|
"-se", |
|
str(save_every_epoch), |
|
"-te", |
|
str(total_epoch), |
|
"-pg", |
|
str(pg), |
|
"-pd", |
|
str(pd), |
|
"-sr", |
|
str(sampling_rate), |
|
"-bs", |
|
str(batch_size), |
|
"-g", |
|
str(gpu), |
|
"-e", |
|
os.path.join(logs_path, str(model_name)), |
|
"-v", |
|
str(rvc_version), |
|
"-l", |
|
str(latest), |
|
"-c", |
|
"0", |
|
"-sw", |
|
str(save_every), |
|
"-f0", |
|
str(f0), |
|
] |
|
|
|
subprocess.run(command) |
|
run_index_script(model_name, rvc_version) |
|
return f"Model {model_name} trained successfully." |
|
|
|
|
|
|
|
def run_index_script(model_name, rvc_version): |
|
index_script_path = os.path.join("rvc", "train", "index_generator.py") |
|
command = [ |
|
"python", |
|
index_script_path, |
|
os.path.join(logs_path, str(model_name)), |
|
rvc_version, |
|
] |
|
|
|
subprocess.run(command) |
|
return f"Index file for {model_name} generated successfully." |
|
|
|
|
|
|
|
def run_model_information_script(pth_path): |
|
print(model_information(pth_path)) |
|
|
|
|
|
|
|
def run_model_fusion_script(model_name, pth_path_1, pth_path_2): |
|
model_fusion(model_name, pth_path_1, pth_path_2) |
|
|
|
|
|
|
|
def run_tensorboard_script(): |
|
tensorboard_script_path = os.path.join( |
|
"rvc", "lib", "tools", "launch_tensorboard.py" |
|
) |
|
command = [ |
|
"python", |
|
tensorboard_script_path, |
|
] |
|
subprocess.run(command) |
|
|
|
|
|
|
|
def run_download_script(model_link): |
|
download_script_path = os.path.join("rvc", "lib", "tools", "model_download.py") |
|
command = [ |
|
"python", |
|
download_script_path, |
|
model_link, |
|
] |
|
subprocess.run(command) |
|
return f"Model downloaded successfully." |
|
|
|
|
|
|
|
def parse_arguments(): |
|
parser = argparse.ArgumentParser( |
|
description="Run the main.py script with specific parameters." |
|
) |
|
subparsers = parser.add_subparsers( |
|
title="subcommands", dest="mode", help="Choose a mode" |
|
) |
|
|
|
|
|
infer_parser = subparsers.add_parser("infer", help="Run inference") |
|
infer_parser.add_argument( |
|
"f0up_key", |
|
type=validate_f0up_key, |
|
help="Value for f0up_key (-24 to +24)", |
|
) |
|
infer_parser.add_argument( |
|
"filter_radius", |
|
type=str, |
|
help="Value for filter_radius (0 to 10)", |
|
) |
|
infer_parser.add_argument( |
|
"index_rate", |
|
type=str, |
|
help="Value for index_rate (0.0 to 1)", |
|
) |
|
infer_parser.add_argument( |
|
"hop_length", |
|
type=str, |
|
help="Value for hop_length (1 to 512)", |
|
) |
|
infer_parser.add_argument( |
|
"f0method", |
|
type=validate_f0method, |
|
help="Value for f0method (pm, dio, crepe, crepe-tiny, harvest, rmvpe)", |
|
) |
|
infer_parser.add_argument( |
|
"input_path", type=str, help="Input path (enclose in double quotes)" |
|
) |
|
infer_parser.add_argument( |
|
"output_path", type=str, help="Output path (enclose in double quotes)" |
|
) |
|
infer_parser.add_argument( |
|
"pth_file", type=str, help="Path to the .pth file (enclose in double quotes)" |
|
) |
|
infer_parser.add_argument( |
|
"index_path", |
|
type=str, |
|
help="Path to the .index file (enclose in double quotes)", |
|
) |
|
infer_parser.add_argument( |
|
"split_audio", |
|
type=str, |
|
help="Enable split audio ( better results )", |
|
) |
|
|
|
|
|
batch_infer_parser = subparsers.add_parser( |
|
"batch_infer", help="Run batch inference" |
|
) |
|
batch_infer_parser.add_argument( |
|
"f0up_key", |
|
type=validate_f0up_key, |
|
help="Value for f0up_key (-24 to +24)", |
|
) |
|
batch_infer_parser.add_argument( |
|
"filter_radius", |
|
type=str, |
|
help="Value for filter_radius (0 to 10)", |
|
) |
|
batch_infer_parser.add_argument( |
|
"index_rate", |
|
type=str, |
|
help="Value for index_rate (0.0 to 1)", |
|
) |
|
batch_infer_parser.add_argument( |
|
"hop_length", |
|
type=str, |
|
help="Value for hop_length (1 to 512)", |
|
) |
|
batch_infer_parser.add_argument( |
|
"f0method", |
|
type=validate_f0method, |
|
help="Value for f0method (pm, dio, crepe, crepe-tiny, harvest, rmvpe)", |
|
) |
|
batch_infer_parser.add_argument( |
|
"input_folder", type=str, help="Input folder (enclose in double quotes)" |
|
) |
|
batch_infer_parser.add_argument( |
|
"output_folder", type=str, help="Output folder (enclose in double quotes)" |
|
) |
|
batch_infer_parser.add_argument( |
|
"pth_file", type=str, help="Path to the .pth file (enclose in double quotes)" |
|
) |
|
batch_infer_parser.add_argument( |
|
"index_path", |
|
type=str, |
|
help="Path to the .index file (enclose in double quotes)", |
|
) |
|
|
|
|
|
tts_parser = subparsers.add_parser("tts", help="Run TTS") |
|
tts_parser.add_argument( |
|
"tts_text", |
|
type=str, |
|
help="Text to be synthesized (enclose in double quotes)", |
|
) |
|
tts_parser.add_argument( |
|
"tts_voice", |
|
type=validate_tts_voices, |
|
help="Voice to be used (enclose in double quotes)", |
|
) |
|
tts_parser.add_argument( |
|
"f0up_key", |
|
type=validate_f0up_key, |
|
help="Value for f0up_key (-24 to +24)", |
|
) |
|
tts_parser.add_argument( |
|
"filter_radius", |
|
type=str, |
|
help="Value for filter_radius (0 to 10)", |
|
) |
|
tts_parser.add_argument( |
|
"index_rate", |
|
type=str, |
|
help="Value for index_rate (0.0 to 1)", |
|
) |
|
tts_parser.add_argument( |
|
"hop_length", |
|
type=str, |
|
help="Value for hop_length (1 to 512)", |
|
) |
|
tts_parser.add_argument( |
|
"f0method", |
|
type=validate_f0method, |
|
help="Value for f0method (pm, dio, crepe, crepe-tiny, harvest, rmvpe)", |
|
) |
|
tts_parser.add_argument( |
|
"output_tts_path", type=str, help="Output tts path (enclose in double quotes)" |
|
) |
|
tts_parser.add_argument( |
|
"output_rvc_path", type=str, help="Output rvc path (enclose in double quotes)" |
|
) |
|
tts_parser.add_argument( |
|
"pth_file", type=str, help="Path to the .pth file (enclose in double quotes)" |
|
) |
|
tts_parser.add_argument( |
|
"index_path", |
|
type=str, |
|
help="Path to the .index file (enclose in double quotes)", |
|
) |
|
|
|
|
|
preprocess_parser = subparsers.add_parser("preprocess", help="Run preprocessing") |
|
preprocess_parser.add_argument( |
|
"model_name", type=str, help="Name of the model (enclose in double quotes)" |
|
) |
|
preprocess_parser.add_argument( |
|
"dataset_path", |
|
type=str, |
|
help="Path to the dataset (enclose in double quotes)", |
|
) |
|
preprocess_parser.add_argument( |
|
"sampling_rate", |
|
type=validate_sampling_rate, |
|
help="Sampling rate (32000, 40000 or 48000)", |
|
) |
|
|
|
|
|
extract_parser = subparsers.add_parser("extract", help="Run extract") |
|
extract_parser.add_argument( |
|
"model_name", |
|
type=str, |
|
help="Name of the model (enclose in double quotes)", |
|
) |
|
extract_parser.add_argument( |
|
"rvc_version", |
|
type=str, |
|
help="Version of the model (v1 or v2)", |
|
) |
|
extract_parser.add_argument( |
|
"f0method", |
|
type=validate_f0method, |
|
help="Value for f0method (pm, dio, crepe, crepe-tiny, mangio-crepe, mangio-crepe-tiny, harvest, rmvpe)", |
|
) |
|
extract_parser.add_argument( |
|
"hop_length", |
|
type=str, |
|
help="Value for hop_length (1 to 512)", |
|
) |
|
extract_parser.add_argument( |
|
"sampling_rate", |
|
type=validate_sampling_rate, |
|
help="Sampling rate (32000, 40000 or 48000)", |
|
) |
|
|
|
|
|
train_parser = subparsers.add_parser("train", help="Run training") |
|
train_parser.add_argument( |
|
"model_name", |
|
type=str, |
|
help="Name of the model (enclose in double quotes)", |
|
) |
|
train_parser.add_argument( |
|
"rvc_version", |
|
type=str, |
|
help="Version of the model (v1 or v2)", |
|
) |
|
train_parser.add_argument( |
|
"save_every_epoch", |
|
type=str, |
|
help="Save every epoch", |
|
) |
|
train_parser.add_argument( |
|
"save_only_latest", |
|
type=str, |
|
help="Save weight only at last epoch", |
|
) |
|
train_parser.add_argument( |
|
"save_every_weights", |
|
type=str, |
|
help="Save weight every epoch", |
|
) |
|
train_parser.add_argument( |
|
"total_epoch", |
|
type=str, |
|
help="Total epoch", |
|
) |
|
train_parser.add_argument( |
|
"sampling_rate", |
|
type=validate_sampling_rate, |
|
help="Sampling rate (32000, 40000, or 48000)", |
|
) |
|
train_parser.add_argument( |
|
"batch_size", |
|
type=str, |
|
help="Batch size", |
|
) |
|
train_parser.add_argument( |
|
"gpu", |
|
type=str, |
|
help="GPU number (0 to 10 separated by -)", |
|
) |
|
train_parser.add_argument( |
|
"pitch_guidance", |
|
type=validate_true_false, |
|
help="Pitch guidance (True or False)", |
|
) |
|
train_parser.add_argument( |
|
"pretrained", |
|
type=validate_true_false, |
|
help="Pretrained (True or False)", |
|
) |
|
train_parser.add_argument( |
|
"custom_pretrained", |
|
type=validate_true_false, |
|
help="Custom pretrained (True or False)", |
|
) |
|
train_parser.add_argument( |
|
"g_pretrained_path", |
|
type=str, |
|
nargs="?", |
|
default=None, |
|
help="Path to the pretrained G file (enclose in double quotes)", |
|
) |
|
train_parser.add_argument( |
|
"d_pretrained_path", |
|
type=str, |
|
nargs="?", |
|
default=None, |
|
help="Path to the pretrained D file (enclose in double quotes)", |
|
) |
|
|
|
|
|
index_parser = subparsers.add_parser("index", help="Generate index file") |
|
index_parser.add_argument( |
|
"model_name", |
|
type=str, |
|
help="Name of the model (enclose in double quotes)", |
|
) |
|
index_parser.add_argument( |
|
"rvc_version", |
|
type=str, |
|
help="Version of the model (v1 or v2)", |
|
) |
|
|
|
|
|
model_information_parser = subparsers.add_parser( |
|
"model_information", help="Print model information" |
|
) |
|
model_information_parser.add_argument( |
|
"pth_path", |
|
type=str, |
|
help="Path to the .pth file (enclose in double quotes)", |
|
) |
|
|
|
|
|
model_fusion_parser = subparsers.add_parser("model_fusion", help="Fuse two models") |
|
model_fusion_parser.add_argument( |
|
"model_name", |
|
type=str, |
|
help="Name of the model (enclose in double quotes)", |
|
) |
|
model_fusion_parser.add_argument( |
|
"pth_path_1", |
|
type=str, |
|
help="Path to the first .pth file (enclose in double quotes)", |
|
) |
|
model_fusion_parser.add_argument( |
|
"pth_path_2", |
|
type=str, |
|
help="Path to the second .pth file (enclose in double quotes)", |
|
) |
|
|
|
|
|
subparsers.add_parser("tensorboard", help="Run tensorboard") |
|
|
|
|
|
download_parser = subparsers.add_parser("download", help="Download models") |
|
download_parser.add_argument( |
|
"model_link", |
|
type=str, |
|
help="Link of the model (enclose in double quotes)", |
|
) |
|
|
|
return parser.parse_args() |
|
|
|
|
|
def main(): |
|
if len(sys.argv) == 1: |
|
print("Please run the script with '-h' for more information.") |
|
sys.exit(1) |
|
|
|
args = parse_arguments() |
|
|
|
try: |
|
if args.mode == "infer": |
|
run_infer_script( |
|
args.f0up_key, |
|
args.filter_radius, |
|
args.index_rate, |
|
args.hop_length, |
|
args.f0method, |
|
args.input_path, |
|
args.output_path, |
|
args.pth_file, |
|
args.index_path, |
|
args.split_audio, |
|
) |
|
elif args.mode == "batch_infer": |
|
run_batch_infer_script( |
|
args.f0up_key, |
|
args.filter_radius, |
|
args.index_rate, |
|
args.hop_length, |
|
args.f0method, |
|
args.input_folder, |
|
args.output_folder, |
|
args.pth_file, |
|
args.index_path, |
|
) |
|
elif args.mode == "tts": |
|
run_tts_script( |
|
args.tts_text, |
|
args.tts_voice, |
|
args.f0up_key, |
|
args.filter_radius, |
|
args.index_rate, |
|
args.hop_length, |
|
args.f0method, |
|
args.output_tts_path, |
|
args.output_rvc_path, |
|
args.pth_file, |
|
args.index_path, |
|
) |
|
elif args.mode == "preprocess": |
|
run_preprocess_script( |
|
args.model_name, |
|
args.dataset_path, |
|
str(args.sampling_rate), |
|
) |
|
|
|
elif args.mode == "extract": |
|
run_extract_script( |
|
args.model_name, |
|
args.rvc_version, |
|
args.f0method, |
|
args.hop_length, |
|
args.sampling_rate, |
|
) |
|
elif args.mode == "train": |
|
run_train_script( |
|
args.model_name, |
|
args.rvc_version, |
|
args.save_every_epoch, |
|
args.save_only_latest, |
|
args.save_every_weights, |
|
args.total_epoch, |
|
args.sampling_rate, |
|
args.batch_size, |
|
args.gpu, |
|
args.pitch_guidance, |
|
args.pretrained, |
|
args.custom_pretrained, |
|
args.g_pretrained_path, |
|
args.d_pretrained_path, |
|
) |
|
elif args.mode == "index": |
|
run_index_script( |
|
args.model_name, |
|
args.rvc_version, |
|
) |
|
elif args.mode == "model_information": |
|
run_model_information_script( |
|
args.pth_path, |
|
) |
|
elif args.mode == "model_fusion": |
|
run_model_fusion_script( |
|
args.model_name, |
|
args.pth_path_1, |
|
args.pth_path_2, |
|
) |
|
elif args.mode == "tensorboard": |
|
run_tensorboard_script() |
|
elif args.mode == "download": |
|
run_download_script( |
|
args.model_link, |
|
) |
|
except Exception as error: |
|
print(f"Error: {error}") |
|
|
|
|
|
if __name__ == "__main__": |
|
main() |
|
|
