Model Quant (model_handler), working Model Viewer, Fusion, and Debug information. Model Selection and reloading. (#8)

- Model Quant (model_handler), working Model Viewer, Fusion, and Debug information. Model Selection and reloading. (495cc7f6e20f7a773f034772065e0fbc90681eec)


Co-authored-by: Mikus <[email protected]>

app.py

@@ -1,366 +1,509 @@
-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
-import anyio
-import asyncio
-from audio_separator.separator import Separator
-
-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
-
-# fucking dogshit toggle
-try:
-    import spaces
-    spaces_status = True
-except ImportError:
-    spaces_status = False
-
-separator = Separator()
-converter = BaseLoader(only_cpu=False, hubert_path=None, rmvpe_path=None)
-
-# CONFIGS
-TEMP_DIR = "temp"
-MODEL_PREFIX = "model"
-PITCH_ALGO_OPT = [
-    "pm",
-    "harvest",
-    "crepe",
-    "rmvpe",
-    "rmvpe+",
-]
-
-os.makedirs(TEMP_DIR, exist_ok=True)
-
-# Model data array to store pth file paths
-model_data = []
-
-# Define the model_dropdown here so it's accessible globally
-model_dropdown = None
-
-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 get_training_info(audio_file):
-    if audio_file is None:
-        return 'Please provide an audio file!'
-    duration = get_audio_duration(audio_file)
-    sample_rate = wave.open(audio_file, 'rb').getframerate()
-
-    training_info = {
-        (0, 2): (150, 'OV2'),
-        (2, 3): (200, 'OV2'),
-        (3, 5): (250, 'OV2'),
-        (5, 10): (300, 'Normal'),
-        (10, 25): (500, 'Normal'),
-        (25, 45): (700, 'Normal'),
-        (45, 60): (1000, 'Normal')
-    }
-
-    for (min_duration, max_duration), (epochs, pretrain) in training_info.items():
-        if min_duration <= duration < max_duration:
-            break
-    else:
-        return 'Duration is not within the specified range!'
-
-    return f'You should use the **{pretrain}** pretrain with **{epochs}** epochs at **{sample_rate/1000}khz** sample rate.'
-
-def on_button_click(audio_file_path):
-    return get_training_info(audio_file_path)
-
-def get_audio_duration(audio_file_path):
-    audio_info = sf.info(audio_file_path)
-    duration_minutes = audio_info.duration / 60
-    return duration_minutes
-
-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, filename=None):
-    global model_dropdown  # Access the global model_dropdown
-
-    if "/blob/" in url:
-        url = url.replace("/blob/", "/resolve/")
-    if "huggingface" not in url:
-        return ["The URL must be from huggingface", "Failed", "Failed"]
-    if filename is None:
-        filename = os.path.join(TEMP_DIR, MODEL_PREFIX + str(random.randint(1, 1000)) + ".zip")
-    response = requests.get(url, stream=True) # Stream the download
-    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")
-
-            # Update the model dropdown during download
-            status_text = f"Downloading... {progress_bar(total, current)}"
-            yield status_text, None, None  # Yield the status while downloading
-
-    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))
-
-    # Update the model dropdown and return the final status
-    model_data.append(pth_files[0])
-    model_dropdown.choices = model_data
-    yield f"Downloaded as {filename}", 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(
-    audio_files,
-    model_selected,
-    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))
-    pth_file = model_selected
-    index_file = None
-
-    print("Random tag:", random_tag)
-    print("File model:", pth_file)
-    print("Pitch algorithm:", pitch_alg)
-    print("Pitch level:", pitch_lvl)
-    print("File index:", index_file)
-    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=pth_file,
-        pitch_algo=pitch_alg,
-        pitch_lvl=pitch_lvl,
-        file_index=index_file,
-        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):
-    pth_file = pth_file.name
-    index_file = index_file.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)
-        model_dropdown = gr.Dropdown(choices=model_data, label="Model", interactive=True)
-
-        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=[
-                sound_gui,
-                model_dropdown,
-                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. (Hugginface RVC model)"
-            )
-            model = gr.Textbox(lines=1, label="Model URL")
-            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,
-                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)")
-            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], upload_status)
-
-    with gr.Tab("Extra"):
-        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(
-                    fn=calculate_remaining_time,
-                    inputs=[epochs_input, seconds_input],
-                    outputs=[remaining_time_output]
-                )
-
-        with gr.Accordion('Training Helper', open=False):
-            with gr.Column():
-                audio_input = gr.Audio(type="filepath", label="Upload your audio file")
-                gr.Text(
-                    "Please note that these results are approximate and intended to provide a general idea for beginners.",
-                    label='Notice:')
-                training_info_output = gr.Markdown(label="Training Information:")
-                get_info_button = gr.Button("Get Training Info")
-                get_info_button.click(
-                    fn=on_button_click,
-                    inputs=[audio_input],
-                    outputs=[training_info_output]
-                )
-
-    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) - i make this ui........
-            ## In loving memory of JLabDX 🕊️
-            """
-        )
-
-demo.queue(api_open=False).launch(show_api=False)
-
-
+import gradio as gr
+import requests
+import random
+import os
+import zipfile # built in module for unzipping files (thank god)
+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
+
+# ilaria tts implementation :rofl:
+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
+
+# fucking dogshit toggle
+try:
+    import spaces
+    spaces_status = True
+except ImportError:
+    spaces_status = False
+
+separator = Separator()
+converter = BaseLoader(only_cpu=False, hubert_path=None, rmvpe_path=None) # <- yeah so like this handles rvc
+
+global pth_file
+global index_file
+
+pth_file = "model.pth"
+index_file = "model.index"
+
+#CONFIGS
+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] # converts "model.zip" to "model" so we can do things
+    with zipfile.ZipFile(file, 'r') as zip_ref:
+        zip_ref.extractall(os.path.join(TEMP_DIR, filename)) # might not be very ram efficient...
+    return True
+    
+
+def progress_bar(total, current): # best progress bar ever trust me sunglasses emoji 😎 
+    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/") # made it delik proof 😎
+    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)) # bytes to download (length of the file)
+    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): # download in chunks of 4096 bytes (4kb - helps with memory usage and speed)
+            f.write(data)
+            current += len(data)
+            print(progress_bar(total, current), end="\r") # \r is a carriage return, it moves the cursor to the start of the line so its like tqdm sunglasses emoji 😎
+    
+    # unzip because the model is in a zip file lel
+
+    try:
+        unzip_file(filename)
+    except Exception as e:
+        return ["Failed to unzip the file", "Failed", "Failed"] # return early if it fails and like tell the user but its dogshit hahahahahahaha 😎 According to all known laws aviation, there is no way a bee should be able to fly.
+    unzipped_dir = os.path.join(TEMP_DIR, os.path.basename(filename).split(".")[0]) # just do what we did in unzip_file because we need the directory
+    pth_files = []
+    index_files = []
+    for root, dirs, files in os.walk(unzipped_dir): # could be done more efficiently because nobody stores models in subdirectories but like who cares (it's a futureproofing thing lel)
+        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) # debug print because im fucking stupid and i need to see what is going on
+    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): # its a shame that zerogpu just WONT cooperate with us
+    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)
+
+    # get from MODELS
+    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="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("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("Ilaria TTS"):
+            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",)
+
+            output_tts = gr.Audio(type="filepath", label="Output",)
+
+            button_tts.click(text_to_speech_edge, inputs=[text_tts, dropdown_tts], outputs=[output_tts])
+
+
+    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",) # UVR models sometimes output it in a weird way where it's like the positions swap randomly, so let's just call them Outputs lol
+        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): # I DIDNT WRITE THIS - MIKUS - THIS IS ILARIA RVC MAINLINE PORT
+                    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", # duh lol
+                "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) - i make this ui........
+
+            ## In loving memory of JLabDX 🕊️
+            """
+        )
+
+demo.queue(api_open=False).launch(show_api=False) # idk ilaria if you want or dont want to

model_handler.py

@@ -0,0 +1,155 @@
+import torch
+import numpy as np
+import huggingface_hub
+import zipfile
+import os
+from collections import OrderedDict
+
+def model_info(model_path):
+    model = torch.load(model_path, map_location=torch.device('cpu'))
+    info = {
+        'config': model['config'],
+        'info': model['info'],
+        'epochs': model['info'].split('epoch')[0],
+        'sr': model['sr'],
+        'f0': model['f0'],
+        'size': model['size'] if 'size' in model['weight'] else 'fp32',
+    }
+    return info
+
+def merge(path1, path2, alpha1, sr, f0, info, name, version):
+    try:
+        def extract(ckpt):
+            a = ckpt["model"]
+            opt = OrderedDict()
+            opt["weight"] = {}
+            for key in a.keys():
+                if "enc_q" in key:
+                    continue
+                opt["weight"][key] = a[key]
+            return opt
+
+        ckpt1 = torch.load(path1, map_location="cpu")
+        ckpt2 = torch.load(path2, map_location="cpu")
+        cfg = ckpt1["config"]
+        if "model" in ckpt1:
+            ckpt1 = extract(ckpt1)
+        else:
+            ckpt1 = ckpt1["weight"]
+        if "model" in ckpt2:
+            ckpt2 = extract(ckpt2)
+        else:
+            ckpt2 = ckpt2["weight"]
+        if sorted(list(ckpt1.keys())) != sorted(list(ckpt2.keys())):
+            return "Fail to merge the models. The model architectures are not the same."
+        opt = OrderedDict()
+        opt["weight"] = {}
+        for key in ckpt1.keys():
+            # try:
+            if key == "emb_g.weight" and ckpt1[key].shape != ckpt2[key].shape:
+                min_shape0 = min(ckpt1[key].shape[0], ckpt2[key].shape[0])
+                opt["weight"][key] = (
+                    alpha1 * (ckpt1[key][:min_shape0].float())
+                    + (1 - alpha1) * (ckpt2[key][:min_shape0].float())
+                ).half()
+            else:
+                opt["weight"][key] = (
+                    alpha1 * (ckpt1[key].float()) + (1 - alpha1) * (ckpt2[key].float())
+                ).half()
+        # except:
+        #     pdb.set_trace()
+        opt["config"] = cfg
+        """
+        if(sr=="40k"):opt["config"] = [1025, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10, 10, 2, 2], 512, [16, 16, 4, 4,4], 109, 256, 40000]
+        elif(sr=="48k"):opt["config"] = [1025, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10,6,2,2,2], 512, [16, 16, 4, 4], 109, 256, 48000]
+        elif(sr=="32k"):opt["config"] = [513, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10, 4, 2, 2, 2], 512, [16, 16, 4, 4,4], 109, 256, 32000]
+        """
+        opt["sr"] = sr
+        opt["f0"] = 1 if f0 == "Yes" else 0
+        opt["version"] = version
+        opt["info"] = info
+        torch.save(opt, "models/" + name + ".pth")
+        return "models/" + name + ".pth"
+    except:
+        return "Fail to merge the models. The model architectures are not the same." # <- L if u see this u suck
+
+def model_quant(model_path, size):
+    """
+    Quantize the model to a lower precision. - this is the floating point version
+
+    Args:
+        model_path: str, path to the model file
+        size: str, one of ["fp2", "fp4", "fp8", "fp16"]
+    
+    Returns:
+        str, message indicating the success of the operation
+    """
+    size_options = ["fp2", "fp4", "fp8", "fp16"]
+    if size not in size_options:
+        raise ValueError(f"Size must be one of {size_options}")
+    
+    model_base = torch.load(model_path, map_location=torch.device('cpu'))
+    model = model_base['weight']
+    #model = json.loads(json.dumps(model))
+
+    if size == "fp16":
+        for key in model.keys():
+            model[key] = model[key].half() # 16-bit floating point
+    elif size == "fp8":
+        for key in model.keys():
+            model[key] = model[key].half().half() # 8-bit floating point <- this is the most common one
+    elif size == "fp4":
+        for key in model.keys():
+            model[key] = model[key].half().half().half() # 4-bit floating point <- ok maybe you're mentally ill if you choose this (very low precision)
+    elif size == "fp2":
+        for key in model.keys():
+            model[key] = model[key].half().half().half().half() # 2-bit floating point <- if you choose this you're a fucking dickhead coming
+    
+    print(model_path)
+    output_path = model_path.split('.pth')[0] + f'_{size}.pth'
+    output_style = {
+        'weight': model,
+        'config': model_base['config'],
+        'info': model_base['info'],
+        'sr': model_base['sr'],
+        'f0': model_base['f0'],
+        'credits': f"Quantized to {size} precision, using Ilaria RVC, (Mikus's script)",
+        "size": size
+    }
+    torch.save(output_style, output_path)
+
+    #AmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithraxAmerithrax
+    # our data isnt safe anymore currently typing this and there is a 100% chance that it'll be stolen and used for training another fucking dogshit language model by a horrible company like openai
+    # i say this as a person who communicates with microsoft and i will stop mentioning this as they're so closely tied together nowadays
+    # as fred durst has said - "That's your best friend and your worst enemy - your own brain." - keep your shit local and never trust scumbag companies even if they make the models oss - they're stealing data
+    # this is probably the only rant i'll have in this entire space and i put it in a notable spot
+
+    return "Model quantized successfully" # <- enjoy this fucking hot shit that looks like a steaming turd paired with skibidi toilet and the unibomber
+
+def upload_model(repo, pth, index, token):
+    """
+    Upload a model to the Hugging Face Hub
+
+    Args:
+        repo: str, the name of the repository
+        pth: str, path to the model file
+        index: str, the index of the model in the repository
+        token: str, the API token
+    
+    Returns:
+        str, message indicating the success of the operation
+    """
+    readme = f"""
+    # {repo}
+    This is a model uploaded by Ilaria RVC, using Mikus's script.
+    """
+    repo_name = repo.split('/')[1]
+    with zipfile.ZipFile(f'{repo_name}.zip', 'w') as zipf:
+        zipf.write(pth, os.path.basename(pth))
+        zipf.write(index, os.path.basename(index))
+        zipf.writestr('README.md', readme)
+    
+    huggingface_hub.HfApi().create_repo(token=token, name=repo, exist_ok=True)
+    huggingface_hub.HfApi().upload_file(token=token, path=f'{repo.split("/")[1]}.zip', repo_id=repo)
+    os.remove(f'{repo.split("/")[1]}.zip')
+    return "Model uploaded successfully"

requirements.txt

@@ -8,3 +8,6 @@ audio-separator[gpu]
 scipy
 onnxruntime-gpu
 samplerate
+transformers
+psutil
+py-cpuinfo