import os import sys import time import logging import argparse import logging.handlers import soundfile as sf import noisereduce as nr from pydub import AudioSegment from distutils.util import strtobool now_dir = os.getcwd() sys.path.append(now_dir) from main.configs.config import Config from main.library.algorithm.separator import Separator translations = Config().translations log_file = os.path.join("assets", "logs", "separator.log") logger = logging.getLogger(__name__) if logger.hasHandlers(): logger.handlers.clear() else: console_handler = logging.StreamHandler() console_formatter = logging.Formatter(fmt="\n%(asctime)s.%(msecs)03d | %(levelname)s | %(module)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S") console_handler.setFormatter(console_formatter) console_handler.setLevel(logging.INFO) file_handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=5*1024*1024, backupCount=3, encoding='utf-8') file_formatter = logging.Formatter(fmt="\n%(asctime)s.%(msecs)03d | %(levelname)s | %(module)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S") file_handler.setFormatter(file_formatter) file_handler.setLevel(logging.DEBUG) logger.addHandler(console_handler) logger.addHandler(file_handler) logger.setLevel(logging.DEBUG) demucs_models = { "HT-Tuned": "htdemucs_ft.yaml", "HT-Normal": "htdemucs.yaml", "HD_MMI": "hdemucs_mmi.yaml", "HT_6S": "htdemucs_6s.yaml" } mdx_models = { "Main_340": "UVR-MDX-NET_Main_340.onnx", "Main_390": "UVR-MDX-NET_Main_390.onnx", "Main_406": "UVR-MDX-NET_Main_406.onnx", "Main_427": "UVR-MDX-NET_Main_427.onnx", "Main_438": "UVR-MDX-NET_Main_438.onnx", "Inst_full_292": "UVR-MDX-NET-Inst_full_292.onnx", "Inst_HQ_1": "UVR-MDX-NET_Inst_HQ_1.onnx", "Inst_HQ_2": "UVR-MDX-NET_Inst_HQ_2.onnx", "Inst_HQ_3": "UVR-MDX-NET_Inst_HQ_3.onnx", "Inst_HQ_4": "UVR-MDX-NET-Inst_HQ_4.onnx", "Kim_Vocal_1": "Kim_Vocal_1.onnx", "Kim_Vocal_2": "Kim_Vocal_2.onnx", "Kim_Inst": "Kim_Inst.onnx", "Inst_187_beta": "UVR-MDX-NET_Inst_187_beta.onnx", "Inst_82_beta": "UVR-MDX-NET_Inst_82_beta.onnx", "Inst_90_beta": "UVR-MDX-NET_Inst_90_beta.onnx", "Voc_FT": "UVR-MDX-NET-Voc_FT.onnx", "Crowd_HQ": "UVR-MDX-NET_Crowd_HQ_1.onnx", "MDXNET_9482": "UVR_MDXNET_9482.onnx", "Inst_1": "UVR-MDX-NET-Inst_1.onnx", "Inst_2": "UVR-MDX-NET-Inst_2.onnx", "Inst_3": "UVR-MDX-NET-Inst_3.onnx", "MDXNET_1_9703": "UVR_MDXNET_1_9703.onnx", "MDXNET_2_9682": "UVR_MDXNET_2_9682.onnx", "MDXNET_3_9662": "UVR_MDXNET_3_9662.onnx", "Inst_Main": "UVR-MDX-NET-Inst_Main.onnx", "MDXNET_Main": "UVR_MDXNET_Main.onnx" } kara_models = { "Version-1": "UVR_MDXNET_KARA.onnx", "Version-2": "UVR_MDXNET_KARA_2.onnx" } def parse_arguments() -> tuple: parser = argparse.ArgumentParser() parser.add_argument("--input_path", type=str, required=True) parser.add_argument("--output_path", type=str, default="./audios") parser.add_argument("--format", type=str, default="wav") parser.add_argument("--shifts", type=int, default=10) parser.add_argument("--segments_size", type=int, default=256) parser.add_argument("--overlap", type=float, default=0.25) parser.add_argument("--mdx_hop_length", type=int, default=1024) parser.add_argument("--mdx_batch_size", type=int, default=1) parser.add_argument("--clean_audio", type=lambda x: bool(strtobool(x)), default=False) parser.add_argument("--clean_strength", type=float, default=0.7) parser.add_argument("--backing_denoise", type=lambda x: bool(strtobool(x)), default=False) parser.add_argument("--demucs_model", type=str, default="HT-Normal") parser.add_argument("--kara_model", type=str, default="Version-1") parser.add_argument("--mdx_model", type=str, default="Main_340") parser.add_argument("--backing", type=lambda x: bool(strtobool(x)), default=False) parser.add_argument("--mdx", type=lambda x: bool(strtobool(x)), default=False) parser.add_argument("--mdx_denoise", type=lambda x: bool(strtobool(x)), default=False) parser.add_argument("--reverb", type=lambda x: bool(strtobool(x)), default=False) parser.add_argument("--reverb_denoise", type=lambda x: bool(strtobool(x)), default=False) parser.add_argument("--backing_reverb", type=lambda x: bool(strtobool(x)), default=False) args = parser.parse_args() return args def main(): start_time = time.time() try: args = parse_arguments() input_path = args.input_path output_path = args.output_path export_format = args.format shifts = args.shifts segments_size = args.segments_size overlap = args.overlap hop_length = args.mdx_hop_length batch_size = args.mdx_batch_size clean_audio = args.clean_audio clean_strength = args.clean_strength backing_denoise = args.backing_denoise demucs_model = args.demucs_model kara_model = args.kara_model backing = args.backing mdx = args.mdx mdx_model = args.mdx_model mdx_denoise = args.mdx_denoise reverb = args.reverb reverb_denoise = args.reverb_denoise backing_reverb = args.backing_reverb if backing_reverb and not reverb: logger.warning(translations["turn_on_dereverb"]) sys.exit(1) if backing_reverb and not backing: logger.warning(translations["turn_on_separator_backing"]) sys.exit(1) logger.debug(f"{translations['audio_path']}: {input_path}") logger.debug(f"{translations['output_path']}: {output_path}") logger.debug(f"{translations['export_format']}: {export_format}") if not mdx: logger.debug(f"{translations['shift']}: {shifts}") logger.debug(f"{translations['segments_size']}: {segments_size}") logger.debug(f"{translations['overlap']}: {overlap}") if clean_audio: logger.debug(f"{translations['clear_audio']}: {clean_audio}") if clean_audio: logger.debug(f"{translations['clean_strength']}: {clean_strength}") if not mdx: logger.debug(f"{translations['demucs_model']}: {demucs_model}") if backing: logger.debug(f"{translations['denoise_backing']}: {backing_denoise}") if backing: logger.debug(f"{translations['backing_model_ver']}: {kara_model}") if backing: logger.debug(f"{translations['separator_backing']}: {backing}") if mdx: logger.debug(f"{translations['use_mdx']}: {mdx}") if mdx: logger.debug(f"{translations['mdx_model']}: {mdx_model}") if mdx: logger.debug(f"{translations['denoise_mdx']}: {mdx_denoise}") if mdx or backing or reverb: logger.debug(f"Hop length: {hop_length}") if mdx or backing or reverb: logger.debug(f"{translations['batch_size']}: {batch_size}") if reverb: logger.debug(f"{translations['dereveb_audio']}: {reverb}") if reverb: logger.debug(f"{translations['denoise_dereveb']}: {reverb_denoise}") if reverb: logger.debug(f"{translations['dereveb_backing']}: {backing_reverb}") if not mdx: vocals, instruments = separator_music_demucs(input_path, output_path, export_format, shifts, overlap, segments_size, demucs_model) else: vocals, instruments = separator_music_mdx(input_path, output_path, export_format, segments_size, overlap, mdx_denoise, mdx_model, hop_length, batch_size) if backing: main_vocals, backing_vocals = separator_backing(vocals, output_path, export_format, segments_size, overlap, backing_denoise, kara_model, hop_length, batch_size) if reverb: vocals_no_reverb, main_vocals_no_reverb, backing_vocals_no_reverb = separator_reverb(output_path, export_format, segments_size, overlap, reverb_denoise, reverb, backing, backing_reverb, hop_length, batch_size) original_output = os.path.join(output_path, f"Original_Vocals_No_Reverb.{export_format}") if reverb else os.path.join(output_path, f"Original_Vocals.{export_format}") main_output = os.path.join(output_path, f"Main_Vocals_No_Reverb.{export_format}") if reverb and backing else os.path.join(output_path, f"Main_Vocals.{export_format}") backing_output = os.path.join(output_path, f"Backing_Vocals_No_Reverb.{export_format}") if reverb and backing_reverb else os.path.join(output_path, f"Backing_Vocals.{export_format}") if clean_audio: logger.info(f"{translations['clear_audio']}...") vocal_data, vocal_sr = sf.read(vocals_no_reverb if reverb else vocals) main_data, main_sr = sf.read(main_vocals_no_reverb if reverb and backing else main_vocals) backing_data, backing_sr = sf.read(backing_vocals_no_reverb if reverb and backing_reverb else backing_vocals) vocals_clean = nr.reduce_noise(y=vocal_data, prop_decrease=clean_strength) sf.write(original_output, vocals_clean, vocal_sr, format=export_format) if backing: mains_clean = nr.reduce_noise(y=main_data, sr=main_sr, prop_decrease=clean_strength) backing_clean = nr.reduce_noise(y=backing_data, sr=backing_sr, prop_decrease=clean_strength) sf.write(main_output, mains_clean, main_sr, format=export_format) sf.write(backing_output, backing_clean, backing_sr, format=export_format) logger.info(translations["clean_audio_success"]) return original_output, instruments, main_output, backing_output except Exception as e: logger.error(f"{translations['separator_error']}: {e}") return None, None, None, None elapsed_time = time.time() - start_time logger.info(translations["separator_success"].format(elapsed_time=f"{elapsed_time:.2f}")) def separator_music_demucs(input, output, format, shifts, overlap, segments_size, demucs_model): if not os.path.exists(input): logger.warning(translations["input_not_valid"]) sys.exit(1) if not os.path.exists(output): logger.warning(translations["output_not_valid"]) sys.exit(1) for i in [f"Original_Vocals.{format}", f"Instruments.{format}"]: if os.path.exists(os.path.join(output, i)): os.remove(os.path.join(output, i)) model = demucs_models.get(demucs_model) segment_size = segments_size / 2 logger.info(f"{translations['separator_process_2']}...") demucs_output = separator_main(audio_file=input, model_filename=model, output_format=format, output_dir=output, demucs_segment_size=segment_size, demucs_shifts=shifts, demucs_overlap=overlap) for f in demucs_output: path = os.path.join(output, f) if not os.path.exists(path): logger.error(translations["not_found"].format(name=path)) if '_(Drums)_' in f: drums = path elif '_(Bass)_' in f: bass = path elif '_(Other)_' in f: other = path elif '_(Vocals)_' in f: os.rename(path, os.path.join(output, f"Original_Vocals.{format}")) AudioSegment.from_file(drums).overlay(AudioSegment.from_file(bass)).overlay(AudioSegment.from_file(other)).export(os.path.join(output, f"Instruments.{format}"), format=format) for f in [drums, bass, other]: if os.path.exists(f): os.remove(f) logger.info(translations["separator_success_2"]) return os.path.join(output, f"Original_Vocals.{format}"), os.path.join(output, f"Instruments.{format}") def separator_backing(input, output, format, segments_size, overlap, denoise, kara_model, hop_length, batch_size): if not os.path.exists(input): logger.warning(translations["input_not_valid"]) sys.exit(1) if not os.path.exists(output): logger.warning(translations["output_not_valid"]) sys.exit(1) for f in [f"Main_Vocals.{format}", f"Backing_Vocals.{format}"]: if os.path.exists(os.path.join(output, f)): os.remove(os.path.join(output, f)) model_2 = kara_models.get(kara_model) logger.info(f"{translations['separator_process_backing']}...") backing_outputs = separator_main(audio_file=input, model_filename=model_2, output_format=format, output_dir=output, mdx_segment_size=segments_size, mdx_overlap=overlap, mdx_batch_size=batch_size, mdx_hop_length=hop_length, mdx_enable_denoise=denoise) main_output = os.path.join(output, f"Main_Vocals.{format}") backing_output = os.path.join(output, f"Backing_Vocals.{format}") for f in backing_outputs: path = os.path.join(output, f) if not os.path.exists(path): logger.error(translations["not_found"].format(name=path)) if '_(Instrumental)_' in f: os.rename(path, backing_output) elif '_(Vocals)_' in f: os.rename(path, main_output) logger.info(translations["separator_process_backing_success"]) return main_output, backing_output def separator_music_mdx(input, output, format, segments_size, overlap, denoise, mdx_model, hop_length, batch_size): if not os.path.exists(input): logger.warning(translations["input_not_valid"]) sys.exit(1) if not os.path.exists(output): logger.warning(translations["output_not_valid"]) sys.exit(1) for i in [f"Original_Vocals.{format}", f"Instruments.{format}"]: if os.path.exists(os.path.join(output, i)): os.remove(os.path.join(output, i)) model_3 = mdx_models.get(mdx_model) logger.info(f"{translations['separator_process_2']}...") output_music = separator_main(audio_file=input, model_filename=model_3, output_format=format, output_dir=output, mdx_segment_size=segments_size, mdx_overlap=overlap, mdx_batch_size=batch_size, mdx_hop_length=hop_length, mdx_enable_denoise=denoise) original_output = os.path.join(output, f"Original_Vocals.{format}") instruments_output = os.path.join(output, f"Instruments.{format}") for f in output_music: path = os.path.join(output, f) if not os.path.exists(path): logger.error(translations["not_found"].format(name=path)) if '_(Instrumental)_' in f: os.rename(path, instruments_output) elif '_(Vocals)_' in f: os.rename(path, original_output) logger.info(translations["separator_process_backing_success"]) return original_output, instruments_output def separator_reverb(output, format, segments_size, overlap, denoise, original, main, backing_reverb, hop_length, batch_size): if not os.path.exists(output): logger.warning(translations["output_not_valid"]) sys.exit(1) for i in [f"Original_Vocals_Reverb.{format}", f"Main_Vocals_Reverb.{format}", f"Original_Vocals_No_Reverb.{format}", f"Main_Vocals_No_Reverb.{format}"]: if os.path.exists(os.path.join(output, i)): os.remove(os.path.join(output, i)) dereveb_path = [] if original: try: dereveb_path.append(os.path.join(output, [f for f in os.listdir(output) if 'Original_Vocals' in f][0])) except IndexError: logger.warning(translations["not_found_original_vocal"]) sys.exit(1) if main: try: dereveb_path.append(os.path.join(output, [f for f in os.listdir(output) if 'Main_Vocals' in f][0])) except IndexError: logger.warning(translations["not_found_main_vocal"]) sys.exit(1) if backing_reverb: try: dereveb_path.append(os.path.join(output, [f for f in os.listdir(output) if 'Backing_Vocals' in f][0])) except IndexError: logger.warning(translations["not_found_backing_vocal"]) sys.exit(1) for path in dereveb_path: if not os.path.exists(path): logger.warning(translations["not_found"].format(name=path)) sys.exit(1) if "Original_Vocals" in path: reverb_path = os.path.join(output, f"Original_Vocals_Reverb.{format}") no_reverb_path = os.path.join(output, f"Original_Vocals_No_Reverb.{format}") start_title = translations["process_original"] end_title = translations["process_original_success"] elif "Main_Vocals" in path: reverb_path = os.path.join(output, f"Main_Vocals_Reverb.{format}") no_reverb_path = os.path.join(output, f"Main_Vocals_No_Reverb.{format}") start_title = translations["process_main"] end_title = translations["process_main_success"] elif "Backing_Vocals" in path: reverb_path = os.path.join(output, f"Backing_Vocals_Reverb.{format}") no_reverb_path = os.path.join(output, f"Backing_Vocals_No_Reverb.{format}") start_title = translations["process_backing"] end_title = translations["process_backing_success"] logger.info(start_title) output_dereveb = separator_main(audio_file=path, model_filename="Reverb_HQ_By_FoxJoy.onnx", output_format=format, output_dir=output, mdx_segment_size=segments_size, mdx_overlap=overlap, mdx_batch_size=batch_size, mdx_hop_length=hop_length, mdx_enable_denoise=denoise) for f in output_dereveb: path = os.path.join(output, f) if not os.path.exists(path): logger.error(translations["not_found"].format(name=path)) if '_(Reverb)_' in f: os.rename(path, reverb_path) elif '_(No Reverb)_' in f: os.rename(path, no_reverb_path) logger.info(end_title) return (os.path.join(output, f"Original_Vocals_No_Reverb.{format}") if original else None), (os.path.join(output, f"Main_Vocals_No_Reverb.{format}") if main else None), (os.path.join(output, f"Backing_Vocals_No_Reverb.{format}") if backing_reverb else None) def separator_main(audio_file=None, model_filename="UVR-MDX-NET_Main_340.onnx", output_format="wav", output_dir=".", mdx_segment_size=256, mdx_overlap=0.25, mdx_batch_size=1, mdx_hop_length=1024, mdx_enable_denoise=True, demucs_segment_size=256, demucs_shifts=2, demucs_overlap=0.25): separator = Separator( log_formatter=file_formatter, log_level=logging.INFO, output_dir=output_dir, output_format=output_format, output_bitrate=None, normalization_threshold=0.9, output_single_stem=None, invert_using_spec=False, sample_rate=44100, mdx_params={ "hop_length": mdx_hop_length, "segment_size": mdx_segment_size, "overlap": mdx_overlap, "batch_size": mdx_batch_size, "enable_denoise": mdx_enable_denoise, }, demucs_params={ "segment_size": demucs_segment_size, "shifts": demucs_shifts, "overlap": demucs_overlap, "segments_enabled": True, } ) separator.load_model(model_filename=model_filename) return separator.separate(audio_file) if __name__ == "__main__": main()