|
import gradio as gr
|
|
import requests
|
|
import random
|
|
import os
|
|
import zipfile
|
|
import librosa
|
|
import time
|
|
from infer_rvc_python import BaseLoader
|
|
from pydub import AudioSegment
|
|
from tts_voice import tts_order_voice
|
|
import edge_tts
|
|
import tempfile
|
|
from audio_separator.separator import Separator
|
|
import model_handler
|
|
import psutil
|
|
import cpuinfo
|
|
|
|
language_dict = tts_order_voice
|
|
|
|
async def text_to_speech_edge(text, language_code):
|
|
voice = language_dict[language_code]
|
|
communicate = edge_tts.Communicate(text, voice)
|
|
with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
|
|
tmp_path = tmp_file.name
|
|
|
|
await communicate.save(tmp_path)
|
|
|
|
return tmp_path
|
|
|
|
try:
|
|
import spaces
|
|
spaces_status = True
|
|
except ImportError:
|
|
spaces_status = False
|
|
|
|
separator = Separator()
|
|
converter = BaseLoader(only_cpu=False, hubert_path=None, rmvpe_path=None)
|
|
|
|
global pth_file
|
|
global index_file
|
|
|
|
pth_file = "model.pth"
|
|
index_file = "model.index"
|
|
|
|
|
|
TEMP_DIR = "temp"
|
|
MODEL_PREFIX = "model"
|
|
PITCH_ALGO_OPT = [
|
|
"pm",
|
|
"harvest",
|
|
"crepe",
|
|
"rmvpe",
|
|
"rmvpe+",
|
|
]
|
|
UVR_5_MODELS = [
|
|
{"model_name": "BS-Roformer-Viperx-1297", "checkpoint": "model_bs_roformer_ep_317_sdr_12.9755.ckpt"},
|
|
{"model_name": "MDX23C-InstVoc HQ 2", "checkpoint": "MDX23C-8KFFT-InstVoc_HQ_2.ckpt"},
|
|
{"model_name": "Kim Vocal 2", "checkpoint": "Kim_Vocal_2.onnx"},
|
|
{"model_name": "5_HP-Karaoke", "checkpoint": "5_HP-Karaoke-UVR.pth"},
|
|
{"model_name": "UVR-DeNoise by FoxJoy", "checkpoint": "UVR-DeNoise.pth"},
|
|
{"model_name": "UVR-DeEcho-DeReverb by FoxJoy", "checkpoint": "UVR-DeEcho-DeReverb.pth"},
|
|
]
|
|
MODELS = [
|
|
{"model": "model.pth", "index": "model.index", "model_name": "Test Model"},
|
|
]
|
|
|
|
os.makedirs(TEMP_DIR, exist_ok=True)
|
|
|
|
def unzip_file(file):
|
|
filename = os.path.basename(file).split(".")[0]
|
|
with zipfile.ZipFile(file, 'r') as zip_ref:
|
|
zip_ref.extractall(os.path.join(TEMP_DIR, filename))
|
|
return True
|
|
|
|
|
|
def progress_bar(total, current):
|
|
return "[" + "=" * int(current / total * 20) + ">" + " " * (20 - int(current / total * 20)) + "] " + str(int(current / total * 100)) + "%"
|
|
|
|
def download_from_url(url, name=None):
|
|
if name is None:
|
|
raise ValueError("The model name must be provided")
|
|
if "/blob/" in url:
|
|
url = url.replace("/blob/", "/resolve/")
|
|
if "huggingface" not in url:
|
|
return ["The URL must be from huggingface", "Failed", "Failed"]
|
|
filename = os.path.join(TEMP_DIR, MODEL_PREFIX + str(random.randint(1, 1000)) + ".zip")
|
|
response = requests.get(url)
|
|
total = int(response.headers.get('content-length', 0))
|
|
if total > 500000000:
|
|
|
|
return ["The file is too large. You can only download files up to 500 MB in size.", "Failed", "Failed"]
|
|
current = 0
|
|
with open(filename, "wb") as f:
|
|
for data in response.iter_content(chunk_size=4096):
|
|
f.write(data)
|
|
current += len(data)
|
|
print(progress_bar(total, current), end="\r")
|
|
|
|
|
|
|
|
try:
|
|
unzip_file(filename)
|
|
except Exception as e:
|
|
return ["Failed to unzip the file", "Failed", "Failed"]
|
|
unzipped_dir = os.path.join(TEMP_DIR, os.path.basename(filename).split(".")[0])
|
|
pth_files = []
|
|
index_files = []
|
|
for root, dirs, files in os.walk(unzipped_dir):
|
|
for file in files:
|
|
if file.endswith(".pth"):
|
|
pth_files.append(os.path.join(root, file))
|
|
elif file.endswith(".index"):
|
|
index_files.append(os.path.join(root, file))
|
|
|
|
print(pth_files, index_files)
|
|
global pth_file
|
|
global index_file
|
|
pth_file = pth_files[0]
|
|
index_file = index_files[0]
|
|
|
|
print(pth_file)
|
|
print(index_file)
|
|
|
|
MODELS.append({"model": pth_file, "index": index_file, "model_name": name})
|
|
return ["Downloaded as " + name, pth_files[0], index_files[0]]
|
|
|
|
def inference(audio, model_name):
|
|
output_data = inf_handler(audio, model_name)
|
|
vocals = output_data[0]
|
|
inst = output_data[1]
|
|
|
|
return vocals, inst
|
|
|
|
if spaces_status:
|
|
@spaces.GPU()
|
|
def convert_now(audio_files, random_tag, converter):
|
|
return converter(
|
|
audio_files,
|
|
random_tag,
|
|
overwrite=False,
|
|
parallel_workers=8
|
|
)
|
|
|
|
|
|
else:
|
|
def convert_now(audio_files, random_tag, converter):
|
|
return converter(
|
|
audio_files,
|
|
random_tag,
|
|
overwrite=False,
|
|
parallel_workers=8
|
|
)
|
|
|
|
def calculate_remaining_time(epochs, seconds_per_epoch):
|
|
total_seconds = epochs * seconds_per_epoch
|
|
|
|
hours = total_seconds // 3600
|
|
minutes = (total_seconds % 3600) // 60
|
|
seconds = total_seconds % 60
|
|
|
|
if hours == 0:
|
|
return f"{int(minutes)} minutes"
|
|
elif hours == 1:
|
|
return f"{int(hours)} hour and {int(minutes)} minutes"
|
|
else:
|
|
return f"{int(hours)} hours and {int(minutes)} minutes"
|
|
|
|
def inf_handler(audio, model_name):
|
|
model_found = False
|
|
for model_info in UVR_5_MODELS:
|
|
if model_info["model_name"] == model_name:
|
|
separator.load_model(model_info["checkpoint"])
|
|
model_found = True
|
|
break
|
|
if not model_found:
|
|
separator.load_model()
|
|
output_files = separator.separate(audio)
|
|
vocals = output_files[0]
|
|
inst = output_files[1]
|
|
return vocals, inst
|
|
|
|
|
|
def run(
|
|
model,
|
|
audio_files,
|
|
pitch_alg,
|
|
pitch_lvl,
|
|
index_inf,
|
|
r_m_f,
|
|
e_r,
|
|
c_b_p,
|
|
):
|
|
if not audio_files:
|
|
raise ValueError("The audio pls")
|
|
|
|
if isinstance(audio_files, str):
|
|
audio_files = [audio_files]
|
|
|
|
try:
|
|
duration_base = librosa.get_duration(filename=audio_files[0])
|
|
print("Duration:", duration_base)
|
|
except Exception as e:
|
|
print(e)
|
|
|
|
random_tag = "USER_"+str(random.randint(10000000, 99999999))
|
|
|
|
file_m = model
|
|
print("File model:", file_m)
|
|
|
|
|
|
for model in MODELS:
|
|
if model["model_name"] == file_m:
|
|
print(model)
|
|
file_m = model["model"]
|
|
file_index = model["index"]
|
|
break
|
|
|
|
if not file_m.endswith(".pth"):
|
|
raise ValueError("The model file must be a .pth file")
|
|
|
|
|
|
print("Random tag:", random_tag)
|
|
print("File model:", file_m)
|
|
print("Pitch algorithm:", pitch_alg)
|
|
print("Pitch level:", pitch_lvl)
|
|
print("File index:", file_index)
|
|
print("Index influence:", index_inf)
|
|
print("Respiration median filtering:", r_m_f)
|
|
print("Envelope ratio:", e_r)
|
|
|
|
converter.apply_conf(
|
|
tag=random_tag,
|
|
file_model=file_m,
|
|
pitch_algo=pitch_alg,
|
|
pitch_lvl=pitch_lvl,
|
|
file_index=file_index,
|
|
index_influence=index_inf,
|
|
respiration_median_filtering=r_m_f,
|
|
envelope_ratio=e_r,
|
|
consonant_breath_protection=c_b_p,
|
|
resample_sr=44100 if audio_files[0].endswith('.mp3') else 0,
|
|
)
|
|
time.sleep(0.1)
|
|
|
|
result = convert_now(audio_files, random_tag, converter)
|
|
print("Result:", result)
|
|
|
|
return result[0]
|
|
|
|
def upload_model(index_file, pth_file, model_name):
|
|
pth_file = pth_file.name
|
|
index_file = index_file.name
|
|
MODELS.append({"model": pth_file, "index": index_file, "model_name": model_name})
|
|
return "Uploaded!"
|
|
|
|
with gr.Blocks(theme=gr.themes.Default(primary_hue="pink", secondary_hue="rose"), title="Ilaria RVC 💖") as demo:
|
|
gr.Markdown("## Ilaria RVC 💖")
|
|
with gr.Tab("Inference"):
|
|
sound_gui = gr.Audio(value=None,type="filepath",autoplay=False,visible=True,)
|
|
def update():
|
|
print(MODELS)
|
|
return gr.Dropdown(label="Model",choices=[model["model_name"] for model in MODELS],visible=True,interactive=True, value=MODELS[0]["model_name"],)
|
|
with gr.Row():
|
|
models_dropdown = gr.Dropdown(label="Model",choices=[model["model_name"] for model in MODELS],visible=True,interactive=True, value=MODELS[0]["model_name"],)
|
|
refresh_button = gr.Button("Refresh Models")
|
|
refresh_button.click(update, outputs=[models_dropdown])
|
|
|
|
with gr.Accordion("Ilaria TTS", open=False):
|
|
text_tts = gr.Textbox(label="Text", placeholder="Hello!", lines=3, interactive=True,)
|
|
dropdown_tts = gr.Dropdown(label="Language and Model",choices=list(language_dict.keys()),interactive=True, value=list(language_dict.keys())[0])
|
|
|
|
button_tts = gr.Button("Speak", variant="primary",)
|
|
button_tts.click(text_to_speech_edge, inputs=[text_tts, dropdown_tts], outputs=[sound_gui])
|
|
|
|
with gr.Accordion("Settings", open=False):
|
|
pitch_algo_conf = gr.Dropdown(PITCH_ALGO_OPT,value=PITCH_ALGO_OPT[4],label="Pitch algorithm",visible=True,interactive=True,)
|
|
pitch_lvl_conf = gr.Slider(label="Pitch level (lower -> 'male' while higher -> 'female')",minimum=-24,maximum=24,step=1,value=0,visible=True,interactive=True,)
|
|
index_inf_conf = gr.Slider(minimum=0,maximum=1,label="Index influence -> How much accent is applied",value=0.75,)
|
|
respiration_filter_conf = gr.Slider(minimum=0,maximum=7,label="Respiration median filtering",value=3,step=1,interactive=True,)
|
|
envelope_ratio_conf = gr.Slider(minimum=0,maximum=1,label="Envelope ratio",value=0.25,interactive=True,)
|
|
consonant_protec_conf = gr.Slider(minimum=0,maximum=0.5,label="Consonant breath protection",value=0.5,interactive=True,)
|
|
|
|
button_conf = gr.Button("Convert",variant="primary",)
|
|
output_conf = gr.Audio(type="filepath",label="Output",)
|
|
|
|
button_conf.click(lambda :None, None, output_conf)
|
|
button_conf.click(
|
|
run,
|
|
inputs=[
|
|
models_dropdown,
|
|
sound_gui,
|
|
pitch_algo_conf,
|
|
pitch_lvl_conf,
|
|
index_inf_conf,
|
|
respiration_filter_conf,
|
|
envelope_ratio_conf,
|
|
consonant_protec_conf,
|
|
],
|
|
outputs=[output_conf],
|
|
)
|
|
|
|
|
|
with gr.Tab("Model Loader (Download and Upload)"):
|
|
with gr.Accordion("Model Downloader", open=False):
|
|
gr.Markdown(
|
|
"Download the model from the following URL and upload it here. (Huggingface RVC model)"
|
|
)
|
|
model = gr.Textbox(lines=1, label="Model URL")
|
|
name = gr.Textbox(lines=1, label="Model Name", placeholder="Model Name")
|
|
download_button = gr.Button("Download Model")
|
|
status = gr.Textbox(lines=1, label="Status", placeholder="Waiting....", interactive=False)
|
|
model_pth = gr.Textbox(lines=1, label="Model pth file", placeholder="Waiting....", interactive=False)
|
|
index_pth = gr.Textbox(lines=1, label="Index pth file", placeholder="Waiting....", interactive=False)
|
|
download_button.click(download_from_url, [model, name], outputs=[status, model_pth, index_pth])
|
|
with gr.Accordion("Upload A Model", open=False):
|
|
index_file_upload = gr.File(label="Index File (.index)")
|
|
pth_file_upload = gr.File(label="Model File (.pth)")
|
|
|
|
model_name = gr.Textbox(label="Model Name", placeholder="Model Name")
|
|
upload_button = gr.Button("Upload Model")
|
|
upload_status = gr.Textbox(lines=1, label="Status", placeholder="Waiting....", interactive=False)
|
|
|
|
upload_button.click(upload_model, [index_file_upload, pth_file_upload, model_name], upload_status)
|
|
|
|
|
|
with gr.Tab("Vocal Separator (UVR)"):
|
|
gr.Markdown("Separate vocals and instruments from an audio file using UVR models. - This is only on CPU due to ZeroGPU being ZeroGPU :(")
|
|
uvr5_audio_file = gr.Audio(label="Audio File",type="filepath")
|
|
|
|
with gr.Row():
|
|
uvr5_model = gr.Dropdown(label="Model", choices=[model["model_name"] for model in UVR_5_MODELS])
|
|
uvr5_button = gr.Button("Separate Vocals", variant="primary",)
|
|
|
|
uvr5_output_voc = gr.Audio(type="filepath", label="Output 1",)
|
|
uvr5_output_inst = gr.Audio(type="filepath", label="Output 2",)
|
|
|
|
uvr5_button.click(inference, [uvr5_audio_file, uvr5_model], [uvr5_output_voc, uvr5_output_inst])
|
|
|
|
with gr.Tab("Extra"):
|
|
with gr.Accordion("Model Information", open=False):
|
|
def json_to_markdown_table(json_data):
|
|
table = "| Key | Value |\n| --- | --- |\n"
|
|
for key, value in json_data.items():
|
|
table += f"| {key} | {value} |\n"
|
|
return table
|
|
def model_info(name):
|
|
for model in MODELS:
|
|
if model["model_name"] == name:
|
|
print(model["model"])
|
|
info = model_handler.model_info(model["model"])
|
|
info2 = {
|
|
"Model Name": model["model_name"],
|
|
"Model Config": info['config'],
|
|
"Epochs Trained": info['epochs'],
|
|
"Sample Rate": info['sr'],
|
|
"Pitch Guidance": info['f0'],
|
|
"Model Precision": info['size'],
|
|
}
|
|
return gr.Markdown(json_to_markdown_table(info2))
|
|
|
|
return "Model not found"
|
|
def update():
|
|
print(MODELS)
|
|
return gr.Dropdown(label="Model", choices=[model["model_name"] for model in MODELS])
|
|
with gr.Row():
|
|
model_info_dropdown = gr.Dropdown(label="Model", choices=[model["model_name"] for model in MODELS])
|
|
refresh_button = gr.Button("Refresh Models")
|
|
refresh_button.click(update, outputs=[model_info_dropdown])
|
|
model_info_button = gr.Button("Get Model Information")
|
|
model_info_output = gr.Textbox(value="Waiting...",label="Output", interactive=False)
|
|
model_info_button.click(model_info, [model_info_dropdown], [model_info_output])
|
|
|
|
|
|
|
|
with gr.Accordion("Training Time Calculator", open=False):
|
|
with gr.Column():
|
|
epochs_input = gr.Number(label="Number of Epochs")
|
|
seconds_input = gr.Number(label="Seconds per Epoch")
|
|
calculate_button = gr.Button("Calculate Time Remaining")
|
|
remaining_time_output = gr.Textbox(label="Remaining Time", interactive=False)
|
|
|
|
calculate_button.click(calculate_remaining_time,inputs=[epochs_input, seconds_input],outputs=[remaining_time_output])
|
|
|
|
with gr.Accordion("Model Fusion", open=False):
|
|
with gr.Group():
|
|
def merge(ckpt_a, ckpt_b, alpha_a, sr_, if_f0_, info__, name_to_save0, version_2):
|
|
for model in MODELS:
|
|
if model["model_name"] == ckpt_a:
|
|
ckpt_a = model["model"]
|
|
if model["model_name"] == ckpt_b:
|
|
ckpt_b = model["model"]
|
|
|
|
path = model_handler.merge(ckpt_a, ckpt_b, alpha_a, sr_, if_f0_, info__, name_to_save0, version_2)
|
|
if path == "Fail to merge the models. The model architectures are not the same.":
|
|
return "Fail to merge the models. The model architectures are not the same."
|
|
else:
|
|
MODELS.append({"model": path, "index": None, "model_name": name_to_save0})
|
|
return "Merged, saved as " + name_to_save0
|
|
|
|
gr.Markdown(value="Strongly suggested to use only very clean models.")
|
|
with gr.Row():
|
|
def update():
|
|
print(MODELS)
|
|
return gr.Dropdown(label="Model A", choices=[model["model_name"] for model in MODELS]), gr.Dropdown(label="Model B", choices=[model["model_name"] for model in MODELS])
|
|
refresh_button_fusion = gr.Button("Refresh Models")
|
|
ckpt_a = gr.Dropdown(label="Model A", choices=[model["model_name"] for model in MODELS])
|
|
ckpt_b = gr.Dropdown(label="Model B", choices=[model["model_name"] for model in MODELS])
|
|
refresh_button_fusion.click(update, outputs=[ckpt_a, ckpt_b])
|
|
alpha_a = gr.Slider(
|
|
minimum=0,
|
|
maximum=1,
|
|
label="Weight of the first model over the second",
|
|
value=0.5,
|
|
interactive=True,
|
|
)
|
|
with gr.Group():
|
|
with gr.Row():
|
|
sr_ = gr.Radio(
|
|
label="Sample rate of both models",
|
|
choices=["32k","40k", "48k"],
|
|
value="32k",
|
|
interactive=True,
|
|
)
|
|
if_f0_ = gr.Radio(
|
|
label="Pitch Guidance",
|
|
choices=["Yes", "Nah"],
|
|
value="Yes",
|
|
interactive=True,
|
|
)
|
|
info__ = gr.Textbox(
|
|
label="Add informations to the model",
|
|
value="",
|
|
max_lines=8,
|
|
interactive=True,
|
|
visible=False
|
|
)
|
|
name_to_save0 = gr.Textbox(
|
|
label="Final Model name",
|
|
value="",
|
|
max_lines=1,
|
|
interactive=True,
|
|
)
|
|
version_2 = gr.Radio(
|
|
label="Versions of the models",
|
|
choices=["v1", "v2"],
|
|
value="v2",
|
|
interactive=True,
|
|
)
|
|
with gr.Group():
|
|
with gr.Row():
|
|
but6 = gr.Button("Fuse the two models", variant="primary")
|
|
info4 = gr.Textbox(label="Output", value="", max_lines=8)
|
|
but6.click(
|
|
merge,
|
|
[ckpt_a,ckpt_b,alpha_a,sr_,if_f0_,info__,name_to_save0,version_2,],info4,api_name="ckpt_merge",)
|
|
|
|
with gr.Accordion("Model Quantization", open=False):
|
|
gr.Markdown("Quantize the model to a lower precision. - soon™ or never™ 😎")
|
|
|
|
with gr.Accordion("Debug", open=False):
|
|
def json_to_markdown_table(json_data):
|
|
table = "| Key | Value |\n| --- | --- |\n"
|
|
for key, value in json_data.items():
|
|
table += f"| {key} | {value} |\n"
|
|
return table
|
|
gr.Markdown("View the models that are currently loaded in the instance.")
|
|
|
|
gr.Markdown(json_to_markdown_table({"Models": len(MODELS), "UVR Models": len(UVR_5_MODELS)}))
|
|
|
|
gr.Markdown("View the current status of the instance.")
|
|
status = {
|
|
"Status": "Running",
|
|
"Models": len(MODELS),
|
|
"UVR Models": len(UVR_5_MODELS),
|
|
"CPU Usage": f"{psutil.cpu_percent()}%",
|
|
"RAM Usage": f"{psutil.virtual_memory().percent}%",
|
|
"CPU": f"{cpuinfo.get_cpu_info()['brand_raw']}",
|
|
"System Uptime": f"{round(time.time() - psutil.boot_time(), 2)} seconds",
|
|
"System Load Average": f"{psutil.getloadavg()}",
|
|
"====================": "====================",
|
|
"CPU Cores": psutil.cpu_count(),
|
|
"CPU Threads": psutil.cpu_count(logical=True),
|
|
"RAM Total": f"{round(psutil.virtual_memory().total / 1024**3, 2)} GB",
|
|
"RAM Used": f"{round(psutil.virtual_memory().used / 1024**3, 2)} GB",
|
|
"CPU Frequency": f"{psutil.cpu_freq().current} MHz",
|
|
"====================": "====================",
|
|
"GPU": "A100 - Do a request (Inference, you won't see it either way)",
|
|
}
|
|
gr.Markdown(json_to_markdown_table(status))
|
|
|
|
with gr.Tab("Credits"):
|
|
gr.Markdown(
|
|
"""
|
|
Ilaria RVC made by [Ilaria](https://huggingface.co/TheStinger) suport her on [ko-fi](https://ko-fi.com/ilariaowo)
|
|
|
|
The Inference code is made by [r3gm](https://huggingface.co/r3gm) (his module helped form this space 💖)
|
|
|
|
made with ❤️ by [mikus](https://github.com/cappuch) - made the ui!
|
|
|
|
## In loving memory of JLabDX 🕊️
|
|
"""
|
|
)
|
|
|
|
demo.queue(api_open=False).launch(show_api=False)
|
|
|
