Upload 115 files

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/ico.png filter=lfs diff=lfs merge=lfs -text
+assets/logs/mute_spin/sliced_audios/mute32000.wav filter=lfs diff=lfs merge=lfs -text
+assets/logs/mute_spin/sliced_audios/mute40000.wav filter=lfs diff=lfs merge=lfs -text
+assets/logs/mute_spin/sliced_audios/mute48000.wav filter=lfs diff=lfs merge=lfs -text
+assets/logs/mute/sliced_audios/mute32000.wav filter=lfs diff=lfs merge=lfs -text
+assets/logs/mute/sliced_audios/mute40000.wav filter=lfs diff=lfs merge=lfs -text
+assets/logs/mute/sliced_audios/mute48000.wav filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.11-slim
+
+EXPOSE 7860
+
+RUN apt-get update && apt-get install -y ffmpeg && apt-get clean
+
+WORKDIR /app
+
+COPY . .
+
+RUN python3 -m venv /app/.venv && \
+    . /app/.venv/bin/activate && \
+    pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+VOLUME [ "/app/assets" ]
+ENV PATH="/app/.venv/bin:$PATH"
+
+CMD ["python3", "main/app/app.py"]

Dockerfile.cuda118

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+EXPOSE 7860
+
+RUN apt-get update && apt-get install -y ffmpeg && apt-get clean
+
+WORKDIR /app
+
+COPY . .
+
+RUN python3 -m venv /app/.venv && \
+    . /app/.venv/bin/activate && \
+    pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir torch==2.7.0 torchvision torchaudio==2.7.0 --index-url https://download.pytorch.org/whl/cu118 && \
+    pip install --no-cache-dir -r requirements.txt
+
+VOLUME [ "/app/assets" ]
+ENV PATH="/app/.venv/bin:$PATH"
+
+CMD ["python3", "main/app/app.py"]

Dockerfile.cuda128

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+EXPOSE 7860
+
+RUN apt-get update && apt-get install -y ffmpeg && apt-get clean
+
+WORKDIR /app
+
+COPY . .
+
+RUN python3 -m venv /app/.venv && \
+    . /app/.venv/bin/activate && \
+    pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir torch==2.7.0 torchvision torchaudio==2.7.0 --index-url https://download.pytorch.org/whl/cu128 && \
+    pip install --no-cache-dir -r requirements.txt
+
+VOLUME [ "/app/assets" ]
+ENV PATH="/app/.venv/bin:$PATH"
+
+CMD ["python3", "main/app/app.py"]

LICENSE

@@ -0,0 +1,201 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Phạm Huỳnh Anh
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,12 +1,184 @@
----
-title: RVC MAKER
-emoji: 🦀
-colorFrom: purple
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.29.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<div align="center">
+<img alt="LOGO" src="assets/ico.png" width="300" height="300" /><div align="center">
+  <img src="https://count.nett.moe/get/foo/img?theme=rule34" alt="yeh"></div>
+
+</div>
+  
+A high-quality voice conversion tool focused on ease of use and performance.
+
+[![RVC MAKER](https://img.shields.io/badge/GitHub-100000?style=for-the-badge&logo=github&logoColor=white)](https://github.com/TheNeodev/RVC-MAKER)
+[![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/github/TheNeodev/RVC-MAKER/blob/main/webui.ipynb)
+[![Licence](https://img.shields.io/github/license/saltstack/salt?style=for-the-badge)](https://github.com/TheNeodev/RVC-MAKER/blob/main/LICENSE)
+
+</div>
+
+<div align="center">
+
+
+</div>
+
+# Description
+This project is all in one, easy-to-use voice conversion tool. With the goal of creating high-quality and high-performance voice conversion products, the project allows users to change voices smoothly and naturally.
+
+# Project Features
+
+- Music separation (MDX-Net/Demucs)
+
+- Voice conversion (File conversion/Batch conversion/Conversion with Whisper/Text-to-speech conversion)
+
+- Background music editing
+
+- Apply effects to audio
+
+- Generate training data (From linked paths)
+
+- Model training (v1/v2, high-quality encoders)
+
+- Model fusion
+
+- Read model information
+
+- Export models to ONNX
+
+- Download from pre-existing model repositories
+
+- Search for models on the web
+
+- Pitch extraction
+
+- Support for audio conversion inference using ONNX models
+
+- ONNX RVC models also support indexing for inference
+
+- Multiple model options:
+
+**F0**: `pm, dio, mangio-crepe-tiny, mangio-crepe-small, mangio-crepe-medium, mangio-crepe-large, mangio-crepe-full, crepe-tiny, crepe-small, crepe-medium, crepe-large, crepe-full, fcpe, fcpe-legacy, rmvpe, rmvpe-legacy, harvest, yin, pyin, swipe`
+
+**F0_ONNX**: Some models are converted to ONNX to support accelerated extraction
+
+**F0_HYBRID**: Multiple options can be combined, such as `hybrid[rmvpe+harvest]`, or you can try combining all options together
+
+**EMBEDDERS**: `contentvec_base, hubert_base, japanese_hubert_base, korean_hubert_base, chinese_hubert_base, portuguese_hubert_base`
+
+**EMBEDDERS_ONNX**: All the above embedding models have ONNX versions pre-converted for accelerated embedding extraction
+
+**EMBEDDERS_TRANSFORMERS**: All the above embedding models have versions pre-converted to Hugging Face for use as an alternative to Fairseq
+
+**SPIN_EMBEDDERS**: A new embedding extraction model that may provide higher quality than older extractions
+
+# Usage Instructions
+
+**Will be provided if I’m truly free...**
+
+# Installation and Usage
+
+- **Step 1**: Install Python from the official website or [Python](https://www.python.org/ftp/python/3.10.7/python-3.10.7-amd64.exe) (**REQUIRES PYTHON 3.10.x OR PYTHON 3.11.x**)
+- **Step 2**: Install FFmpeg from [FFMPEG](https://github.com/BtbN/FFmpeg-Builds/releases), extract it, and add it to PATH
+- **Step 3**: Download and extract the source code
+- **Step 4**: Navigate to the source code directory and open Command Prompt or Terminal
+- **Step 5**: Run the command to install the required libraries
+
+python -m venv envenv\Scripts\activate
+
+If you have an NVIDIA GPU, run this step depending on your CUDA version (you may need to change cu117 to cu128, etc.):
+
+If using Torch 2.3.1
+python -m pip install torch==2.3.1 torchaudio==2.3.1 torchvision==0.18.1 --index-url https://download.pytorch.org/whl/cu117
+If using Torch 2.6.0
+python -m pip install torch==2.6.0 torchaudio==2.6.0 torchvision==0.21.0 --index-url https://download.pytorch.org/whl/cu117
+
+Then run:
+
+python -m pip install -r requirements.txt
+
+- **Step 6**: Run the `run_app` file to open the user interface (Note: Do not close the Command Prompt or Terminal for the interface)
+- Alternatively, use Command Prompt or Terminal in the source code directory
+- To allow the interface to access files outside the project, add `--allow_all_disk` to the command:
+
+env\Scripts\python.exe main\app\app.py --open
+
+**To use TensorBoard for training monitoring**:
+
+Run the file: tensorboard or the command env\Scripts\python.exe main\app\tensorboard.py
+
+# Command-Line Usage
+
+python main\app\parser.py --help
+
+</pre>
+
+# NOTES
+
+- **This project only supports NVIDIA GPUs**
+- **Currently, new encoders like MRF HIFIGAN do not yet have complete pre-trained datasets**
+- **MRF HIFIGAN and REFINEGAN encoders do not support training without pitch training**
+
+# Terms of Use
+
+- You must ensure that the audio content you upload and convert through this project does not violate the intellectual property rights of third parties.
+
+- The project must not be used for any illegal activities, including but not limited to fraud, harassment, or causing harm to others.
+
+- You are solely responsible for any damages arising from improper use of the product.
+
+- I will not be responsible for any direct or indirect damages arising from the use of this project.
+
+# This Project is Built Based on the Following Projects
+
+
+
+| Project | Author/Organization | License |
+|---------|---------------------|---------|
+| [Vietnamese-RVC](https://github.com/PhamHuynhAnh16/Vietnamese-RVC) | Phạm Huỳnh Anh | Apache License 2.0 |
+| [Applio](https://github.com/IAHispano/Applio/tree/main) | IAHispano | MIT License |
+| [Python-audio-separator](https://github.com/nomadkaraoke/python-audio-separator/tree/main) | Nomad Karaoke | MIT License |
+| [Retrieval-based-Voice-Conversion-WebUI](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/tree/main) | RVC Project | MIT License |
+| [RVC-ONNX-INFER-BY-Anh](https://github.com/PhamHuynhAnh16/RVC_Onnx_Infer) | Phạm Huỳnh Anh | MIT License |
+| [Torch-Onnx-Crepe-By-Anh](https://github.com/PhamHuynhAnh16/TORCH-ONNX-CREPE) | Phạm Huỳnh Anh | MIT License |
+| [Hubert-No-Fairseq](https://github.com/PhamHuynhAnh16/hubert-no-fairseq) | Phạm Huỳnh Anh | MIT License |
+| [Local-attention](https://github.com/lucidrains/local-attention) | Phil Wang | MIT License |
+| [TorchFcpe](https://github.com/CNChTu/FCPE/tree/main) | CN_ChiTu | MIT License |
+| [FcpeONNX](https://github.com/deiteris/voice-changer/blob/master-custom/server/utils/fcpe_onnx.py) | Yury | MIT License |
+| [ContentVec](https://github.com/auspicious3000/contentvec) | Kaizhi Qian | MIT License |
+| [Mediafiredl](https://github.com/Gann4Life/mediafiredl) | Santiago Ariel Mansilla | MIT License |
+| [Noisereduce](https://github.com/timsainb/noisereduce) | Tim Sainburg | MIT License |
+| [World.py-By-Anh](https://github.com/PhamHuynhAnh16/world.py) | Phạm Huỳnh Anh | MIT License |
+| [Mega.py](https://github.com/odwyersoftware/mega.py) | O'Dwyer Software | Apache 2.0 License |
+| [Gdown](https://github.com/wkentaro/gdown) | Kentaro Wada | MIT License |
+| [Whisper](https://github.com/openai/whisper) | OpenAI | MIT License |
+| [PyannoteAudio](https://github.com/pyannote/pyannote-audio) | pyannote | MIT License |
+| [AudioEditingCode](https://github.com/HilaManor/AudioEditingCode) | Hila Manor | MIT License |
+| [StftPitchShift](https://github.com/jurihock/stftPitchShift) | Jürgen Hock | MIT License |
+| [Codename-RVC-Fork-3](https://github.com/codename0og/codename-rvc-fork-3) | Codename;0 | MIT License |
+
+
+
+# Model Repository for Model Search Tool
+
+- **[VOICE-MODELS.COM](https://voice-models.com/)**
+
+# Pitch Extraction Methods in RVC
+
+This document provides detailed information on the pitch extraction methods used, including their advantages, limitations, strengths, and reliability based on personal experience.
+
+| Method            | Type           | Advantages                | Limitations                  | Strength           | Reliability        |
+|-------------------|----------------|---------------------------|------------------------------|--------------------|--------------------|
+| pm                | Praat          | Fast                      | Less accurate                | Low                | Low                |
+| dio               | PYWORLD        | Suitable for rap          | Less accurate at high frequencies | Medium             | Medium             |
+| harvest           | PYWORLD        | More accurate than DIO    | Slower processing            | High               | Very high          |
+| crepe             | Deep Learning  | High accuracy             | Requires GPU                 | Very high          | Very high          |
+| mangio-crepe      | Crepe finetune | Optimized for RVC         | Sometimes less accurate than original crepe | Medium to high     | Medium to high     |
+| fcpe              | Deep Learning  | Accurate, real-time       | Requires powerful GPU        | Good               | Medium             |
+| fcpe-legacy       | Old            | Accurate, real-time       | Older                        | Good               | Medium             |
+| rmvpe             | Deep Learning  | Effective for singing voices | Resource-intensive           | Very high          | Excellent          |
+| rmvpe-legacy      | Old            | Supports older systems     | Older                        | High               | Good               |
+| yin               | Librosa        | Simple, efficient         | Prone to octave errors       | Medium             | Low                |
+| pyin              | Librosa        | More stable than YIN      | More complex computation     | Good               | Good               |
+| swipe             | WORLD          | High accuracy             | Sensitive to noise           | High               | Good               |
+
+# Bug Reporting
+
+- **If you encounter an error while using this source code, I sincerely apologize for the poor experience. You can report the bug using the methods below.**
+
+- **you can report bugs to us via [ISSUE](https://github.com/unchCrew/RVC-MAKER/issues).**
+

assets/languages/en-US.json

@@ -0,0 +1,809 @@
+{
+    "set_lang": "Display language set to {lang}.",
+    "no_support_gpu": "Unfortunately, no compatible GPU is available to support your training.",
+    "text": "text",
+    "upload_success": "File {name} uploaded successfully.",
+    "download_url": "Download from the link",
+    "download_from_csv": "Download from the CSV model repository",
+    "search_models": "Search models",
+    "upload": "Upload",
+    "option_not_valid": "Invalid option!",
+    "list_model": "Model list",
+    "success": "Completed!",
+    "index": "index",
+    "model": "model",
+    "zip": "compress",
+    "search": "search",
+    "provide_file": "Please provide a valid {filename} file!",
+    "start": "Starting {start}...",
+    "not_found": "Not found {name}.",
+    "found": "Found {results} results!",
+    "download_music": "download music",
+    "download": "download",
+    "provide_url": "Please provide a url.",
+    "provide_name_is_save": "Please provide a model name to save.",
+    "not_support_url": "Your model url is not supported.",
+    "error_occurred": "An error occurred: {e}.",
+    "not_model": "The file you uploaded is not a model file!",
+    "unable_analyze_model": "Unable to analyze the model!",
+    "download_pretrain": "Downloading pre-trained model...",
+    "provide_pretrain": "Please provide a pre-trained model url {dg}.",
+    "sr_not_same": "The sample rates of the two models are not the same.",
+    "architectures_not_same": "Cannot merge models. The architectures are not the same.",
+    "fushion_model": "model fusion",
+    "model_fushion_info": "The model {name} is fused from {pth_1} and {pth_2} with a ratio of {ratio}.",
+    "not_found_create_time": "Creation time not found.",
+    "format_not_valid": "Invalid format.",
+    "read_info": "Models trained on different applications may produce different information or may not be readable!",
+    "epoch": "epoch.",
+    "step": "step",
+    "sr": "Sample rate",
+    "f0": "pitch training",
+    "version": "version.",
+    "not_f0": "Pitch training not performed",
+    "trained_f0": "Pitch training performed",
+    "model_info": "Model Name: {model_name}\n\n Model Creator: {model_author}\n\nEpoch: {epochs}\n\nSteps: {steps}\n\nVersion: {version}\n\nSample Rate: {sr}\n\nPitch Training: {pitch_guidance}\n\nHash (ID): {model_hash}\n\nCreation Time: {creation_date_str}\n\nVocoder: {vocoder}\n",
+    "input_not_valid": "Please provide valid input!",
+    "output_not_valid": "Please provide valid output!",
+    "apply_effect": "apply effect",
+    "enter_the_text": "Please enter the text to speech!",
+    "choose_voice": "Please choose a voice!",
+    "convert": "Converting {name}...",
+    "separator_music": "music separation",
+    "notfound": "Not found",
+    "turn_on_use_audio": "Please enable using separated audio to proceed",
+    "turn_off_convert_backup": "Disable backup voice conversion to use the original voice",
+    "turn_off_merge_backup": "Disable merging backup voice to use the original voice",
+    "not_found_original_vocal": "Original vocal not found!",
+    "convert_vocal": "Converting voice...",
+    "convert_success": "Voice conversion completed!",
+    "convert_backup": "Converting backup voice...",
+    "convert_backup_success": "Backup voice conversion completed!",
+    "merge_backup": "Merging main voice with backup voice...",
+    "merge_success": "Merge completed.",
+    "is_folder": "Input is a folder: Converting all audio files in the folder...",
+    "not_found_in_folder": "No audio files found in the folder!",
+    "batch_convert": "Batch conversion in progress...",
+    "batch_convert_success": "Batch conversion successful!",
+    "create": "create",
+    "provide_name": "Please provide a model name.",
+    "not_found_data": "Data not found",
+    "not_found_data_preprocess": "Processed audio data not found, please reprocess.",
+    "not_found_data_extract": "Extracted audio data not found, please re-extract.",
+    "provide_pretrained": "Please provide pre-trained {dg}.",
+    "download_pretrained": "Download pre-trained {dg}{rvc_version} original",
+    "not_found_pretrain": "Pre-trained {dg} not found",
+    "not_use_pretrain": "No pre-trained model will be used",
+    "training": "training",
+    "rick_roll": "Click here if you want to be Rick Roll :) ---> [RickRoll]({rickroll})",
+    "terms_of_use": "**Please do not use the project for any unethical, illegal, or harmful purposes to individuals or organizations...**",
+    "exemption": "**In cases where users do not comply with the terms or violate them, I will not be responsible for any claims, damages, or liabilities, whether in contract, negligence, or other causes arising from, outside of, or related to the software, its use, or other transactions associated with it.**",
+    "separator_tab": "Music Separation",
+    "4_part": "A simple music separation system can separate into 4 parts: Instruments, Vocals, Main vocals, Backup vocals",
+    "clear_audio": "Clean audio",
+    "separator_backing": "Separate backup vocals",
+    "denoise_mdx": "Denoise MDX separation",
+    "use_mdx": "Use MDX",
+    "dereveb_audio": "Remove vocal reverb",
+    "dereveb_backing": "Remove backup reverb",
+    "separator_model": "Music separation model",
+    "separator_backing_model": "Backup separation model",
+    "shift": "Shift",
+    "shift_info": "Higher is better quality but slower and uses more resources",
+    "segments_size": "Segments Size",
+    "segments_size_info": "Higher is better quality but uses more resources",
+    "batch_size": "Batch size",
+    "batch_size_info": "Number of samples processed simultaneously in one training cycle. Higher can cause memory overflow",
+    "mdx_batch_size_info": "Number of samples processed at a time. Batch processing optimizes calculations. Large batches can cause memory overflow; small batches reduce resource efficiency",
+    "overlap": "Overlap",
+    "overlap_info": "Overlap amount between prediction windows",
+    "export_format": "Export format",
+    "export_info": "The export format to export the audio file in",
+    "output_separator": "Separated output",
+    "hop_length_info": "Analyzing the time transfer window when performing transformations is allowed. The detailed value is compact but requires more calculation",
+    "drop_audio": "Drop audio here",
+    "drop_text": "Drop text file here",
+    "use_url": "YouTube link",
+    "url_audio": "Link audio",
+    "downloads": "Downloads",
+    "clean_strength": "Audio cleaning strength",
+    "clean_strength_info": "Strength of the audio cleaner for filtering vocals during export",
+    "input_output": "Audio input, output",
+    "audio_path": "Input audio path",
+    "refesh": "Refresh",
+    "output_folder": "Output audio folder path",
+    "output_folder_info": "Enter the folder path where the audio will be exported",
+    "input_audio": "Audio input",
+    "instruments": "Instruments",
+    "original_vocal": "Original vocal",
+    "main_vocal": "Main vocal",
+    "backing_vocal": "Backup vocal",
+    "convert_audio": "Convert Audio",
+    "convert_info": "Convert audio using a trained voice model",
+    "autotune": "Auto-tune",
+    "use_audio": "Use separated audio",
+    "convert_original": "Convert original voice",
+    "convert_backing": "Convert backup voice",
+    "not_merge_backing": "Do not merge backup voice",
+    "merge_instruments": "Merge instruments",
+    "pitch": "Pitch",
+    "pitch_info": "Recommendation: set to 12 to change male voice to female and vice versa",
+    "model_accordion": "Model and index",
+    "model_name": "Model file",
+    "index_path": "Index file",
+    "index_strength": "Index strength",
+    "index_strength_info": "Higher values increase strength. However, lower values may reduce artificial effects in the audio",
+    "output_path": "Audio output path",
+    "output_path_info": "Enter the output path (leave it as .wav format; it will auto-correct during conversion)",
+    "setting": "General settings",
+    "f0_method": "Extraction method",
+    "f0_method_info": "Method used for data extraction",
+    "f0_method_hybrid": "HYBRID extraction method",
+    "f0_method_hybrid_info": "Combination of two or more different types of extracts",
+    "hubert_model": "Embedding model",
+    "hubert_info": "Pre-trained model to assist embedding",
+    "modelname": "Model name",
+    "modelname_info": "If you have your own model, just upload it and input the name here",
+    "split_audio": "Split audio",
+    "autotune_rate": "Auto-tune rate",
+    "autotune_rate_info": "Level of auto-tuning adjustment",
+    "resample": "Resample",
+    "resample_info": "Resample post-processing to the final sample rate; 0 means no resampling, NOTE: SOME FORMATS DO NOT SUPPORT SPEEDS OVER 48000",
+    "filter_radius": "Filter radius",
+    "filter_radius_info": "If greater than three, median filtering is applied. The value represents the filter radius and can reduce breathiness or noise.",
+    "volume_envelope": "Volume envelope",
+    "volume_envelope_info": "Use the input volume envelope to replace or mix with the output volume envelope. The closer to 1, the more the output envelope is used",
+    "protect": "Consonant protection",
+    "protect_info": "Protect distinct consonants and breathing sounds to prevent audio tearing and other artifacts. Increasing this value provides comprehensive protection. Reducing it may reduce protection but also minimize indexing effects",
+    "output_convert": "Converted audio",
+    "main_convert": "Convert main voice",
+    "main_or_backing": "Main voice + Backup voice",
+    "voice_or_instruments": "Voice + Instruments",
+    "convert_text": "Convert Text",
+    "convert_text_markdown": "## Convert Text to Speech",
+    "convert_text_markdown_2": "Convert text to speech and read aloud using the trained voice model",
+    "input_txt": "Input data from a text file (.txt)",
+    "text_to_speech": "Text to read",
+    "voice_speed": "Reading speed",
+    "voice_speed_info": "Speed of the voice",
+    "tts_1": "1. Convert Text to Speech",
+    "tts_2": "2. Convert Speech",
+    "voice": "Voices by country",
+    "output_tts": "Output speech path",
+    "output_tts_convert": "Converted speech output path",
+    "tts_output": "Enter the output path",
+    "output_tts_markdown": "Unconverted and converted audio",
+    "output_text_to_speech": "Generated speech from text-to-speech conversion",
+    "output_file_tts_convert": "Speech converted using the model",
+    "output_audio": "Audio output",
+    "provide_output": "Enter the output path",
+    "audio_effects": "Audio Effects",
+    "apply_audio_effects": "## Add Additional Audio Effects",
+    "audio_effects_edit": "Add effects to audio",
+    "reverb": "Reverb effect",
+    "chorus": "Chorus effect",
+    "delay": "Delay effect",
+    "more_option": "Additional options",
+    "phaser": "Phaser effect",
+    "compressor": "Compressor effect",
+    "apply": "Apply",
+    "reverb_freeze": "Freeze mode",
+    "reverb_freeze_info": "Create a continuous echo effect when this mode is enabled",
+    "room_size": "Room size",
+    "room_size_info": "Adjust the room space to create reverberation",
+    "damping": "Damping",
+    "damping_info": "Adjust the level of absorption to control the amount of reverberation",
+    "wet_level": "Reverb signal level",
+    "wet_level_info": "Adjust the level of the reverb signal effect",
+    "dry_level": "Original signal level",
+    "dry_level_info": "Adjust the level of the signal without effects",
+    "width": "Audio width",
+    "width_info": "Adjust the width of the audio space",
+    "chorus_depth": "Chorus depth",
+    "chorus_depth_info": "Adjust the intensity of the chorus to create a wider sound",
+    "chorus_rate_hz": "Frequency",
+    "chorus_rate_hz_info": "Adjust the oscillation speed of the chorus effect",
+    "chorus_mix": "Mix signals",
+    "chorus_mix_info": "Adjust the mix level between the original and the processed signal",
+    "chorus_centre_delay_ms": "Center delay (ms)",
+    "chorus_centre_delay_ms_info": "The delay time between stereo channels to create the chorus effect",
+    "chorus_feedback": "Feedback",
+    "chorus_feedback_info": "Adjust the amount of the effect signal fed back into the original signal",
+    "delay_seconds": "Delay time",
+    "delay_seconds_info": "Adjust the delay time between the original and the processed signal",
+    "delay_feedback": "Delay feedback",
+    "delay_feedback_info": "Adjust the amount of feedback signal, creating a repeating effect",
+    "delay_mix": "Delay signal mix",
+    "delay_mix_info": "Adjust the mix level between the original and delayed signal",
+    "fade": "Fade effect",
+    "bass_or_treble": "Bass and treble",
+    "limiter": "Threshold limiter",
+    "distortion": "Distortion effect",
+    "gain": "Audio gain",
+    "bitcrush": "Bit reduction effect",
+    "clipping": "Clipping effect",
+    "fade_in": "Fade-in effect (ms)",
+    "fade_in_info": "Time for the audio to gradually increase from 0 to normal level",
+    "fade_out": "Fade-out effect (ms)",
+    "fade_out_info": "the time it takes for the sound to fade from normal to zero",
+    "bass_boost": "Bass boost level (dB)",
+    "bass_boost_info": "amount of bass boost in audio track",
+    "bass_frequency": "Low-pass filter cutoff frequency (Hz)",
+    "bass_frequency_info": "frequencies are reduced. Low frequencies make the bass clearer",
+    "treble_boost": "Treble boost level (dB)",
+    "treble_boost_info": "high level of sound reinforcement in the audio track",
+    "treble_frequency": "High-pass filter cutoff frequency (Hz)",
+    "treble_frequency_info": "The frequency will be filtered out. The higher the frequency, the higher the sound will be retained.",
+    "limiter_threashold_db": "Limiter threshold",
+    "limiter_threashold_db_info": "Limit the maximum audio level to prevent it from exceeding the threshold",
+    "limiter_release_ms": "Release time",
+    "limiter_release_ms_info": "Time for the audio to return after being limited (Mili Seconds)",
+    "distortion_info": "Adjust the level of distortion to create a noisy effect",
+    "gain_info": "Adjust the volume level of the signal",
+    "clipping_threashold_db": "Clipping threshold",
+    "clipping_threashold_db_info": "Trim signals exceeding the threshold, creating a distorted sound",
+    "bitcrush_bit_depth": "Bit depth",
+    "bitcrush_bit_depth_info": "Reduce audio quality by decreasing bit depth, creating a distorted effect",
+    "phaser_depth": "Phaser depth",
+    "phaser_depth_info": "Adjust the depth of the effect, impacting its intensity",
+    "phaser_rate_hz": "Frequency",
+    "phaser_rate_hz_info": "Adjust the frequency of the phaser effect",
+    "phaser_mix": "Mix signal",
+    "phaser_mix_info": "Adjust the mix level between the original and processed signals",
+    "phaser_centre_frequency_hz": "Center frequency",
+    "phaser_centre_frequency_hz_info": "The center frequency of the phaser effect, affecting the adjusted frequencies",
+    "phaser_feedback": "Feedback",
+    "phaser_feedback_info": "Adjust the feedback level of the effect, creating a stronger or lighter phaser feel",
+    "compressor_threashold_db": "Compressor threshold",
+    "compressor_threashold_db_info": "The threshold level above which the audio will be compressed",
+    "compressor_ratio": "Compression ratio",
+    "compressor_ratio_info": "Adjust the level of audio compression when exceeding the threshold",
+    "compressor_attack_ms": "Attack time (ms)",
+    "compressor_attack_ms_info": "Time for compression to start taking effect after the audio exceeds the threshold",
+    "compressor_release_ms": "Release time",
+    "compressor_release_ms_info": "Time for the audio to return to normal after being compressed",
+    "create_dataset_url": "Link to audio (use commas for multiple links)",
+    "createdataset": "Create dataset",
+    "create_dataset_markdown": "## Create Dataset training from YouTube",
+    "create_dataset_markdown_2": "Process and create training datasets using YouTube links",
+    "denoise": "Denoise",
+    "skip": "Skip",
+    "model_ver": "Voice separation version",
+    "model_ver_info": "The model version for separating vocals",
+    "create_dataset_info": "Dataset creation information",
+    "output_data": "Dataset output",
+    "output_data_info": "Output data after creation",
+    "skip_start": "Skip beginning",
+    "skip_start_info": "Skip the initial seconds of the audio; use commas for multiple audios",
+    "skip_end": "Skip end",
+    "skip_end_info": "Skip the final seconds of the audio; use commas for multiple audios",
+    "training_model": "Train Model",
+    "training_markdown": "Train and build a voice model with a set of voice data",
+    "training_model_name": "Name of the model during training (avoid special characters or spaces)",
+    "sample_rate": "Sample rate",
+    "sample_rate_info": "Sample rate of the model",
+    "training_version": "Model version",
+    "training_version_info": "Version of the model during training",
+    "training_pitch": "Pitch Guidance",
+    "upload_dataset": "Upload dataset",
+    "preprocess_effect": "Post processing",
+    "clear_dataset": "Clean dataset",
+    "preprocess_info": "Preprocessing information",
+    "preprocess_button": "1. Processing",
+    "extract_button": "2. Extract",
+    "extract_info": "Data extraction information",
+    "total_epoch": "Total epochs",
+    "total_epoch_info": "Total training epochs",
+    "save_epoch": "Save frequency",
+    "save_epoch_info": "Frequency of saving the model during training to allow retraining",
+    "create_index": "Create index",
+    "index_algorithm": "Index algorithm",
+    "index_algorithm_info": "Algorithm for creating the index",
+    "custom_dataset": "Custom dataset folder",
+    "custom_dataset_info": "Custom dataset folder for training data",
+    "overtraining_detector": "Overtraining detector",
+    "overtraining_detector_info": "Check for overtraining during model training",
+    "cleanup_training": "Clean Up",
+    "cleanup_training_info": "Only enable if you need to retrain the model from scratch.",
+    "cache_in_gpu": "Cache in GPU",
+    "cache_in_gpu_info": "Store the model in GPU cache memory",
+    "dataset_folder": "Folder containing dataset",
+    "threshold": "Overtraining threshold",
+    "setting_cpu_gpu": "CPU/GPU settings",
+    "gpu_number": "Number of GPUs used",
+    "gpu_number_info": "Number of GPUs used during training",
+    "save_only_latest": "Save only the latest",
+    "save_only_latest_info": "Save only the latest D and G models",
+    "save_every_weights": "Save all models",
+    "save_every_weights_info": "Save all models after each epoch",
+    "gpu_info": "GPU information",
+    "gpu_info_2": "Information about the GPU used during training",
+    "cpu_core": "Number of CPU cores available",
+    "cpu_core_info": "Number of CPU cores used during training",
+    "not_use_pretrain_2": "Do not use pretraining",
+    "not_use_pretrain_info": "Do not use pre-trained models",
+    "custom_pretrain": "Custom pretraining",
+    "custom_pretrain_info": "Customize pre-training settings",
+    "pretrain_file": "Pre-trained model file {dg}",
+    "train_info": "Training information",
+    "export_model": "5. Export Model",
+    "zip_model": "2. Compress model",
+    "output_zip": "Output file after compression",
+    "model_path": "Model path",
+    "model_ratio": "Model ratio",
+    "model_ratio_info": "Adjusting towards one side will make the model more like that side",
+    "output_model_path": "Model output path",
+    "fushion": "Model Fusion",
+    "fushion_markdown": "## Fushion Two Models",
+    "fushion_markdown_2": "Combine two voice models into a single model",
+    "read_model": "Read Information",
+    "read_model_markdown": "## Read Model Information",
+    "read_model_markdown_2": "Retrieve recorded information within the model",
+    "drop_model": "Drop model here",
+    "readmodel": "Read model",
+    "model_path_info": "Enter the path to the model file",
+    "modelinfo": "Model Information",
+    "download_markdown": "## Download Model",
+    "download_markdown_2": "Download voice models, pre-trained models, and embedding models",
+    "model_download": "Download voice model",
+    "model_url": "Link to the model",
+    "15s": "Please wait about 15 seconds. The system will restart automatically!",
+    "model_download_select": "Choose a model download method",
+    "model_warehouse": "Model repository",
+    "get_model": "Retrieve model",
+    "name_to_search": "Name to search",
+    "search_2": "Search",
+    "select_download_model": "Choose a searched model (Click to select)",
+    "download_pretrained_2": "Download pre-trained model",
+    "only_huggingface": "Supports only huggingface.co",
+    "pretrained_url": "Pre-trained model link {dg}",
+    "select_pretrain": "Choose pre-trained model",
+    "select_pretrain_info": "Choose a pre-trained model to download",
+    "pretrain_sr": "Model sample rate",
+    "drop_pretrain": "Drop pre-trained model {dg} here",
+    "settings": "Settings",
+    "settings_markdown": "## Additional Settings",
+    "settings_markdown_2": "Customize additional features of the project",
+    "lang": "Language",
+    "lang_restart": "The display language in the project (When changing the language, the system will automatically restart after 15 seconds to update)",
+    "change_lang": "Change Language",
+    "theme": "Theme",
+    "theme_restart": "Theme type displayed in the interface (When changing the theme, the system will automatically restart after 15 seconds to update)",
+    "theme_button": "Change Theme",
+    "change_light_dark": "Switch Light/Dark Mode",
+    "tensorboard_url": "Tensorboard URL",
+    "errors_loading_audio": "Error loading audio: {e}",
+    "apply_error": "An error occurred while applying effects: {e}",
+    "indexpath": "Index path",
+    "split_total": "Total parts split",
+    "process_audio_error": "An error occurred while processing the audio",
+    "merge_error": "An error occurred while merging audio",
+    "not_found_convert_file": "Processed file not found",
+    "convert_batch": "Batch conversion...",
+    "found_audio": "Found {audio_files} audio files for conversion.",
+    "not_found_audio": "No audio files found!",
+    "error_convert": "An error occurred during audio conversion: {e}",
+    "convert_batch_success": "Batch conversion completed successfully in {elapsed_time} seconds. {output_path}",
+    "convert_audio_success": "File {input_path} converted successfully in {elapsed_time} seconds. {output_path}",
+    "hybrid_methods": "Estimating f0 pitch using methods {methods}",
+    "method_not_valid": "Invalid method",
+    "read_faiss_index_error": "An error occurred while reading the FAISS index: {e}",
+    "read_model_error": "Failed to load model: {e}",
+    "starting_download": "Starting download",
+    "version_not_valid": "Invalid vocal separation version",
+    "skip<audio": "Cannot skip as skip time is less than audio file length",
+    "skip>audio": "Cannot skip as skip time is greater than audio file length",
+    "=<0": "Skip time is less than or equal to 0 and has been skipped",
+    "skip_warning": "Skip duration ({seconds} seconds) exceeds audio length ({total_duration} seconds). Skipping.",
+    "download_success": "Download completed successfully",
+    "create_dataset_error": "An error occurred while creating the training dataset",
+    "create_dataset_success": "Training dataset creation completed in {elapsed_time} seconds",
+    "skip_start_audio": "Successfully skipped start of audio: {input_file}",
+    "skip_end_audio": "Successfully skipped end of audio: {input_file}",
+    "merge_audio": "Merged all parts containing audio",
+    "separator_process": "Separating vocals: {input}...",
+    "not_found_main_vocal": "Main vocal not found!",
+    "not_found_backing_vocal": "Backup vocal not found!",
+    "not_found_instruments": "Instruments not found",
+    "merge_instruments_process": "Merging vocals with instruments...",
+    "dereverb": "Removing vocal reverb",
+    "dereverb_success": "Successfully removed vocal reverb",
+    "save_index": "Index file saved",
+    "create_index_error": "An error occurred while creating the index",
+    "sr_not_16000": "Sample rate must be 16000",
+    "gpu_not_valid": "Invalid GPU index. Switching to CPU.",
+    "extract_file_error": "An error occurred while extracting the file",
+    "extract_f0_method": "Starting pitch extraction using {num_processes} cores with method {f0_method}...",
+    "extract_f0": "Pitch Extraction",
+    "extract_f0_success": "Pitch extraction completed in {elapsed_time} seconds.",
+    "NaN": "contains NaN values and will be ignored.",
+    "start_extract_hubert": "Starting Embedding extraction...",
+    "not_found_audio_file": "Audio file not found. Please ensure you provided the correct audio.",
+    "process_error": "An error occurred during processing",
+    "extract_hubert_success": "Embedding extraction completed in {elapsed_time} seconds.",
+    "export_process": "Model path",
+    "extract_error": "An error occurred during data extraction",
+    "extract_success": "Data extraction successful",
+    "min_length>=min_interval>=hop_size": "min_length must be greater than or equal to min_interval and hop_size",
+    "max_sil_kept>=hop_size": "max_sil_kept must be greater than or equal to hop_size",
+    "start_preprocess": "Starting data preprocessing with {num_processes} cores...",
+    "not_integer": "Voice ID folder must be an integer; instead got",
+    "preprocess_success": "Preprocessing completed in {elapsed_time} seconds.",
+    "preprocess_model_success": "Preprocessing data for the model completed successfully",
+    "turn_on_dereverb": "Reverb removal for backup vocals requires enabling reverb removal",
+    "turn_on_separator_backing": "Backup vocal separation requires enabling vocal separation",
+    "backing_model_ver": "Backup vocal separation model version",
+    "clean_audio_success": "Audio cleaned successfully!",
+    "separator_error": "An error occurred during music separation",
+    "separator_success": "Music separation completed in {elapsed_time} seconds",
+    "separator_process_2": "Processing music separation",
+    "separator_success_2": "Music separation successful!",
+    "separator_process_backing": "Processing backup vocal separation",
+    "separator_process_backing_success": "Backup vocal separation successful!",
+    "process_original": "Processing original vocal reverb removal...",
+    "process_original_success": "Original vocal reverb removal successful!",
+    "process_main": "Processing main vocal reverb removal...",
+    "process_main_success": "Main vocal reverb removal successful!",
+    "process_backing": "Processing backup vocal reverb removal...",
+    "process_backing_success": "Backup vocal reverb removal successful!",
+    "save_every_epoch": "Save model after: ",
+    "total_e": "Total epochs: ",
+    "dorg": "Pre-trained G: {pretrainG} | Pre-trained D: {pretrainD}",
+    "training_f0": "Pitch Guidance",
+    "not_gpu": "No GPU detected, reverting to CPU (not recommended)",
+    "not_found_checkpoint": "Checkpoint file not found: {checkpoint_path}",
+    "save_checkpoint": "Reloaded checkpoint '{checkpoint_path}' (epoch {checkpoint_dict})",
+    "save_model": "Saved model '{checkpoint_path}' (epoch {iteration})",
+    "sr_does_not_match": "{sample_rate} Sample rate does not match target {sample_rate2} Sample rate",
+    "spec_error": "An error occurred while retrieving specifications from {spec_filename}: {e}",
+    "time_or_speed_training": "time={current_time} | training speed={elapsed_time_str}",
+    "savemodel": "Saved model '{model_dir}' (epoch {epoch} and step {step})",
+    "model_author": "Credit model to {model_author}",
+    "unregistered": "Model unregistered",
+    "not_author": "Model not credited",
+    "training_author": "Model creator name",
+    "training_author_info": "To credit the model, enter your name here",
+    "extract_model_error": "An error occurred while extracting the model",
+    "start_training": "Starting training",
+    "import_pretrain": "Loaded pre-trained model ({dg}) '{pretrain}'",
+    "not_using_pretrain": "No pre-trained model ({dg}) will be used",
+    "training_warning": "WARNING: Generated loss is lower than the lower threshold loss for the next epoch.",
+    "overtraining_find": "Overtraining detected at epoch {epoch} with smoothed generator loss {smoothed_value_gen} and smoothed discriminator loss {smoothed_value_disc}",
+    "best_epoch": "New best epoch {epoch} with smoothed generator loss {smoothed_value_gen} and smoothed discriminator loss {smoothed_value_disc}",
+    "success_training": "Training completed with {epoch} epochs, {global_step} steps, and {loss_gen_all} total generator loss.",
+    "training_info": "Lowest generator loss: {lowest_value_rounded} at epoch {lowest_value_epoch}, step {lowest_value_step}",
+    "model_training_info": "{model_name} | epoch={epoch} | step={global_step} | {epoch_recorder} | lowest value={lowest_value_rounded} (epoch {lowest_value_epoch} and step {lowest_value_step}) | remaining epochs for overtraining: g/total: {remaining_epochs_gen} d/total: {remaining_epochs_disc} | smoothed generator loss={smoothed_value_gen} | smoothed discriminator loss={smoothed_value_disc}",
+    "model_training_info_2": "{model_name} | epoch={epoch} | step={global_step} | {epoch_recorder} | lowest value={lowest_value_rounded} (epoch {lowest_value_epoch} and step {lowest_value_step})",
+    "model_training_info_3": "{model_name} | epoch={epoch} | step={global_step} | {epoch_recorder}",
+    "training_error": "An error occurred while training the model:",
+    "separator_info": "Initializing with output path: {output_dir}, output format: {output_format}",
+    "output_dir_is_none": "Output folder not specified. Using current working directory.",
+    ">0or=1": "Normalization threshold must be greater than 0 and less than or equal to 1.",
+    "output_single": "Single root output requested; only one file ({output_single_stem}) will be written",
+    "step2": "The second step will be reversed using spectrogram instead of waveform. This may improve quality but is slightly slower.",
+    "name_ver": "Version {name}",
+    "os": "Operating System",
+    "platform_info": "System: {system_info} Name: {node} Release: {release} Machine: {machine} Processor: {processor}",
+    "none_ffmpeg": "FFmpeg is not installed. Please install FFmpeg to use this package.",
+    "install_onnx": "ONNX Runtime package {pu} installed with version",
+    "running_in_cpu": "Unable to configure hardware acceleration, running in CPU mode",
+    "running_in_cuda": "CUDA available in Torch, setting Torch device to CUDA",
+    "onnx_have": "ONNXruntime available {have}, enabling acceleration",
+    "onnx_not_have": "{have} not available in ONNXruntime; acceleration will NOT be enabled",
+    "python_not_install": "Python package: {package_name} is not installed",
+    "hash": "Calculating hash for model file {model_path}",
+    "ioerror": "IOError while seeking -10 MB or reading model file to compute hash: {e}",
+    "cancel_download": "File already exists at {output_path}, skipping download",
+    "download_model": "Downloading file from {url} to {output_path} with a timeout of 300 seconds",
+    "download_error": "Failed to download file from {url}, response code: {status_code}",
+    "vip_model": "Model: '{model_friendly_name}' is a premium model intended by Anjok07 only for paid subscriber access.",
+    "vip_print": "Hey there, if you haven't subscribed, please consider supporting UVR's developer, Anjok07, by subscribing here: https://patreon.com/uvr",
+    "search_model": "Searching for model {model_filename} in the list of supported models in the group",
+    "load_download_json": "Downloaded model list loaded",
+    "single_model": "Identified single model file: {model_friendly_name}",
+    "not_found_model": "Model not found in the UVR repository, attempting to download from the audio model separation repository...",
+    "single_model_path": "Returning path for single model file: {model_path}",
+    "find_model": "Input file name {model_filename} found in multi-file model: {model_friendly_name}",
+    "find_models": "Identified multi-file model: {model_friendly_name}, iterating through files to download",
+    "find_path": "Attempting to determine download PATH for config pair",
+    "not_found_model_warehouse": "Model not found in the UVR repository, attempting to download from the audio model separation repository...",
+    "yaml_warning": "The model name you specified, {model_filename}, is actually a model config file rather than a model file.",
+    "yaml_warning_2": "We found a model matching this config file: {config_key}, so we'll use that model file for this run.",
+    "yaml_warning_3": "To avoid confusing/inconsistent behavior in the future, specify the actual model file name instead.",
+    "yaml_debug": "Config YAML model file not found in UVR repository, attempting to download from the audio model separation repository...",
+    "download_model_friendly": "All files downloaded for model {model_friendly_name}, returning original path {model_path}",
+    "not_found_model_2": "Model file {model_filename} not found in the supported files",
+    "load_yaml": "Loading model data from YAML at path {model_data_yaml_filepath}",
+    "load_yaml_2": "Model data loaded from YAML file: {model_data}",
+    "hash_md5": "Computing MD5 hash for model file to identify model parameters from UVR data...",
+    "model_hash": "Model {model_path} has hash {model_hash}",
+    "mdx_data": "MDX model data path set to {mdx_model_data_path}",
+    "load_mdx": "Loading MDX model parameters from UVR model data file...",
+    "model_not_support": "Unsupported model file: no parameters found for MD5 hash {model_hash} in UVR model data for MDX vault.",
+    "uvr_json": "Model data loaded from UVR JSON with hash {model_hash}: {model_data}",
+    "loading_model": "Loading model {model_filename}...",
+    "download_model_friendly_2": "Downloaded model, friendly name: {model_friendly_name}, Model path: {model_path}",
+    "model_type_not_support": "Unsupported model type: {model_type}",
+    "demucs_not_support_python<3.10": "Demucs models require Python version 3.10 or higher.",
+    "import_module": "Importing module for model type",
+    "initialization": "Initializing separator class for model type",
+    "loading_model_success": "Model loading completed.",
+    "loading_model_duration": "Model loading duration",
+    "starting_separator": "Starting separation process for audio file path",
+    "normalization": "Normalization threshold set to {normalization_threshold}, waveform will be scaled down to this maximum amplitude to prevent clipping.",
+    "loading_separator_model": "Downloading model {model_filename}...",
+    "separator_success_3": "Separation process completed.",
+    "separator_duration": "Separation duration",
+    "downloading_model": "Downloaded model, type: {model_type}, friendly name: {model_friendly_name}, Model path: {model_path}, Model data: {model_data_dict_size} items",
+    "demucs_info": "Demucs parameters: Segment size = {segment_size}, Segment size active = {segments_enabled}",
+    "demucs_info_2": "Demucs parameters: Number of predictions = {shifts}, Overlap = {overlap}",
+    "start_demucs": "Demucs Separator initialization completed",
+    "start_separator": "Starting separation process...",
+    "prepare_mix": "Preparing mixture...",
+    "demix": "Mixture prepared for demixing. Shape: {shape}",
+    "cancel_mix": "Loading model for demixing...",
+    "model_review": "Model loaded and set to evaluation mode.",
+    "del_gpu_cache_after_demix": "Cleared model and GPU cache after demixing.",
+    "process_output_file": "Processing output file...",
+    "source_length": "Processing source array, source length is {source_length}",
+    "process_ver": "Processing source version...",
+    "set_map": "Set source map to {part} parts...",
+    "process_all_part": "Processing for all root parts...",
+    "skip_part": "Skipping root part {stem_name} as out_single_stem is set to {output_single_stem}...",
+    "starting_demix_demucs": "Starting the demix process in demix_demucs...",
+    "model_infer": "Running model inference...",
+    "name_not_pretrained": "{name} is not a pre-trained model or a model bundle.",
+    "invalid_checksum": "Invalid checksum for file {path}, expected {checksum} but got {actual_checksum}",
+    "mdx_info": "MDX parameters: Batch size = {batch_size}, Segment size = {segment_size}",
+    "mdx_info_2": "MDX parameters: Overlap = {overlap}, Hop_length = {hop_length}, Denoising enabled = {enable_denoise}",
+    "mdx_info_3": "MDX parameters",
+    "load_model_onnx": "Loading ONNX model for inference...",
+    "load_model_onnx_success": "Successfully loaded model using ONNXruntime inference session.",
+    "onnx_to_pytorch": "Model converted from ONNX to PyTorch due to mismatched segment size with dim_t, processing may be slower.",
+    "stft": "Inverse STFT applied. Returning result with shape",
+    "no_denoise": "Model running on spectrum without denoising.",
+    "mix": "Preparing mix for input audio file {audio_file_path}...",
+    "normalization_demix": "Normalizing mix prior to demixing...",
+    "mix_success": "Mix preparation completed.",
+    "primary_source": "Normalizing primary source...",
+    "secondary_source": "Producing secondary source: Mixing in compatible mode",
+    "invert_using_spec": "Inverting secondary stem using spectrum when invert_USE_spec is set to True",
+    "invert_using_spec_2": "Inverting secondary stem by subtracting transformed stem from the initial transformed mix",
+    "enable_denoise": "Model running on both positive and negative spectrums for denoising.",
+    "is_match_mix": "is_match_mix: Predicted spectrum obtained directly from STFT output.",
+    "save_secondary_stem_output_path": "Saving secondary stem {stem_name} to {stem_output_path}...",
+    "starting_model": "Initializing model settings...",
+    "input_info": "Model input parameters",
+    "model_settings": "Model settings",
+    "initialize_mix": "Initializing mix with is_ckpt = {is_ckpt}. Initial mix shape: {shape}",
+    "!=2": "Expected 2-channel audio signal but got {shape} channels",
+    "process_check": "Processing in checkpoint mode...",
+    "stft_2": "STFT applied to mix. Spectrum shape: {shape}",
+    "cache": "Computed padding",
+    "shape": "Mix shape after padding: {shape}, Number of parts: {num_chunks}",
+    "process_no_check": "Processing in no-checkpoint mode...",
+    "n_sample_or_pad": "Number of samples: {n_sample}, Computed padding: {pad}",
+    "shape_2": "Mix shape after padding",
+    "process_part": "Processed part {mix_waves}: Start {i}, End {ii}",
+    "mix_waves_to_tensor": "Converted mix_waves to tensor. Tensor shape: {shape}",
+    "mix_match": "Mix mode Match; applying compensation factor.",
+    "tar_waves": "tar_waves. Shape",
+    "normalization_2": "Normalizing result by dividing it by divisor.",
+    "mix_wave": "Processing mix_wave batch",
+    "mix_or_batch": "Mix parts into batches. Number of batches",
+    "demix_is_match_mix": "Starting demix process with is_match_mix,",
+    "mix_shape": "Root mix parts stored. Shape",
+    "chunk_size_or_overlap": "Chunk size for compatible mixing: {chunk_size}, Overlap: {overlap}",
+    "chunk_size_or_overlap_standard": "Standard chunk size: {chunk_size}, Overlap: {overlap}",
+    "calc_size": "Generated size calculated",
+    "window": "Window applied to this segment.",
+    "process_part_2": "Processing segment {total}/{total_chunks}: Start {start}, End {end}",
+    "all_process_part": "Total segments to process",
+    "step_or_overlap": "Step size to process parts: {step} with overlap set to {overlap}.",
+    "mix_cache": "Mix prepared with padding. Mix shape",
+    "dims": "Cannot use sin/cos position encoding with odd dimensions (dim={dims})",
+    "activation": "activation must be relu/gelu, not {activation}",
+    "length_or_training_length": "Provided length {length} exceeds training duration {training_length}",
+    "type_not_valid": "Invalid type for",
+    "del_parameter": "Removing non-existent parameter ",
+    "info": "Common parameters: Model name = {model_name}, Model path = {model_path}",
+    "info_2": "Common parameters: Output path = {output_dir}, Output format = {output_format}",
+    "info_3": "Common parameters: Normalization threshold = {normalization_threshold}",
+    "info_4": "Common parameters: Denoising enabled = {enable_denoise}, Single stem output = {output_single_stem}",
+    "info_5": "Common parameters: Inversion using specs = {invert_using_spec}, Sample rate = {sample_rate}",
+    "info_6": "Common parameters: Primary root name = {primary_stem_name}, Secondary root name = {secondary_stem_name}",
+    "info_7": "Common parameters: Karaoke mode = {is_karaoke}, BV model = {is_bv_model}, BV model rebalancing = {bv_model_rebalance}",
+    "success_process": "Completed processing root {stem_name} and writing audio...",
+    "load_audio": "Loading audio from file",
+    "load_audio_success": "Audio loaded. Sample rate: {sr}, Audio shape: {shape}",
+    "convert_mix": "Converting provided mix array.",
+    "convert_shape": "Converted mix shape: {shape}",
+    "audio_not_valid": "Audio file {audio_path} is empty or invalid",
+    "audio_valid": "Audio file is valid and contains data.",
+    "mix_single": "Mix is mono. Converting to stereo.",
+    "convert_mix_audio": "Converted to stereo mix.",
+    "mix_success_2": "Mix preparation completed.",
+    "duration": "Audio duration is {duration_hours} hours ({duration_seconds} seconds).",
+    "write": "Using {name} to write.",
+    "write_audio": "Writing {name} with root path:",
+    "original_not_valid": "Warning: Original source array is nearly silent or empty.",
+    "shape_audio": "Audio data shape before processing",
+    "convert_data": "Data type before conversion",
+    "original_source_to_int16": "Converted original_source to int16.",
+    "shape_audio_2": "Interleaved audio data shape",
+    "create_audiosegment": "Successfully created AudioSegment.",
+    "create_audiosegment_error": "Specific error while creating AudioSegment",
+    "export_error": "Error exporting audio file",
+    "export_success": "Successfully exported audio file to",
+    "clean": "Running garbage collection...",
+    "clean_cache": "Clearing {name} cache...",
+    "del_path": "Deleting path, source, and root of input audio file...",
+    "not_success": "Process was not successful: ",
+    "resample_error": "Error during resampling",
+    "shapes": "Shapes",
+    "wav_resolution": "Resolution type",
+    "warnings": "Warning: Extremely aggressive values detected",
+    "warnings_2": "Warning: NaN or infinite values detected in wave input. Shape",
+    "process_file": "Processing file... \n",
+    "save_instruments": "Saving reverse track...",
+    "assert": "Audio files must have the same shape - Mix: {mixshape}, Inst: {instrumentalshape}",
+    "rubberband": "Rubberband CLI cannot be executed. Please ensure Rubberband-CLI is installed.",
+    "rate": "Rate must be strictly positive",
+    "gdown_error": "Could not retrieve the public link for the file. You may need to change its permissions to 'Anyone with the link' or there may already be excessive access permissions.",
+    "to": "To:",
+    "gdown_value_error": "A path or ID must be specified",
+    "missing_url": "URL is missing",
+    "mac_not_match": "MAC does not match",
+    "file_not_access": "File is not accessible",
+    "int_resp==-3": "Request failed, retrying",
+    "search_separate": "Search for separate files...",
+    "found_choice": "Found {choice}",
+    "separator==0": "No separate files found!",
+    "select_separate": "Select separate files",
+    "start_app": "Starting interface...",
+    "provide_audio": "Enter the path to the audio file",
+    "set_torch_mps": "Set Torch device to MPS",
+    "googletts": "Convert text using Google",
+    "pitch_info_2": "Pitch adjustment for text-to-speech converter",
+    "waveform": "Waveform must have the shape (# frames, # channels)",
+    "freq_mask_smooth_hz": "freq_mask_smooth_hz must be at least {hz}Hz",
+    "time_mask_smooth_ms": "time_mask_smooth_ms must be at least {ms}ms",
+    "x": "x must be greater",
+    "xn": "xn must be greater",
+    "not_found_pid": "No processes found!",
+    "end_pid": "Process terminated!",
+    "not_found_separate_model": "No separation model files found!",
+    "not_found_pretrained": "No pretrained model files found!",
+    "not_found_log": "No log files found!",
+    "not_found_predictors": "No predictor model files found!",
+    "not_found_embedders": "No embedder model files found!",
+    "provide_folder": "Please provide a valid folder!",
+    "empty_folder": "The data folder is empty!",
+    "vocoder": "Vocoder",
+    "vocoder_info": "A vocoder analyzes and synthesizes human speech signals for voice transformation.\n\nDefault: This option is HiFi-GAN-NSF, compatible with all RVCs\n\nMRF-HiFi-GAN: Higher fidelity.\n\nRefineGAN: Superior sound quality.",
+    "code_error": "Error: Received status code",
+    "json_error": "Error: Unable to parse response.",
+    "requests_error": "Request failed: {e}",
+    "memory_efficient_training": "Using memory-efficient training",
+    "not_use_pretrain_error_download": "Will not use pretrained models due to missing files",
+    "provide_file_settings": "Please provide a preset settings file!",
+    "load_presets": "Loaded preset file {presets}",
+    "provide_filename_settings": "Please provide a preset file name!",
+    "choose1": "Please select one to export!",
+    "export_settings": "Exported preset file {name}",
+    "use_presets": "Using preset file",
+    "file_preset": "Preset file",
+    "load_file": "Load file",
+    "export_file": "Export preset file",
+    "save_clean": "Save cleanup",
+    "save_autotune": "Save autotune",
+    "save_pitch": "Save pitch",
+    "save_index_2": "Save index impact",
+    "save_resample": "Save resampling",
+    "save_filter": "Save median filter",
+    "save_envelope": "Save sound envelope",
+    "save_protect": "Save sound protection",
+    "save_split": "Save sound split",
+    "filename_to_save": "File name to save",
+    "upload_presets": "Upload preset file",
+    "stop": "Stop process",
+    "stop_separate": "Stop Music Separation",
+    "stop_convert": "Stop Conversion",
+    "stop_create_dataset": "Stop Dataset Creation",
+    "stop_training": "Stop Training",
+    "stop_extract": "Stop Data Processing",
+    "stop_preprocess": "Stop Data Extraction",
+    "not_found_presets": "No preset files found in the folder!",
+    "port": "Port {port} is unavailable! Lowering port by one...",
+    "empty_json": "{file}: Corrupted or empty",
+    "thank": "Thank you for reporting the issue, and apologies for any inconvenience caused!",
+    "error_read_log": "An error occurred while reading log files!",
+    "error_send": "An error occurred while sending the report! Please contact me on Discord: pham_huynh_anh!",
+    "report_bugs": "Report Bugs",
+    "agree_log": "Agree to provide all log files",
+    "error_info": "Error description",
+    "error_info_2": "Provide more information about the error",
+    "report_bug_info": "Report bugs encountered during program usage",
+    "sr_info": "NOTE: SOME FORMATS DO NOT SUPPORT RATES ABOVE 48000",
+    "report_info": "If possible, agree to provide log files to help with debugging.\n\nIf log files are not provided, please describe the error in detail, including when and where it occurred.\n\nIf this reporting system also fails, you can reach out via [ISSUE]({github}) or Discord: `pham_huynh_anh`",
+    "default_setting": "An error occurred during separation, resetting all settings to default...",
+    "dataset_folder1": "Please enter the data folder name",
+    "checkpointing_err": "Pretrained model parameters such as sample rate or architecture do not match the selected model.",
+    "start_onnx_export": "Start converting model to onnx...",
+    "convert_model": "Convert Model",
+    "pytorch2onnx": "Converting PYTORCH Model to ONNX Model",
+    "pytorch2onnx_markdown": "Convert RVC model from pytorch to onnx to optimize audio conversion",
+    "error_readfile": "An error occurred while reading the file!",
+    "read_sf": "Read audio file using soundfile...",
+    "read_librosa": "Read audio files using librosa as soundfile is not supported...",
+    "f0_onnx_mode": "F0 ONNX Mode",
+    "f0_onnx_mode_info": "Extracting pitch using the ONNX model can help improve speed",
+    "formantshift": "Pitch and Formant Shift",
+    "formant_qfrency": "Frequency for Formant Shift",
+    "formant_timbre": "Timbre for Formant Transformation",
+    "time_frames": "Time (Frames)",
+    "Frequency": "Frequency (Hz)",
+    "f0_extractor_tab": "F0 Extraction",
+    "f0_extractor_markdown": "## Pitch Extraction",
+    "f0_extractor_markdown_2": "F0 pitch extraction is intended for use in audio conversion inference",
+    "start_extract": "Starting extraction process...",
+    "extract_done": "Extraction process completed!",
+    "f0_file": "Use pre-extracted F0 file",
+    "upload_f0": "Upload F0 file",
+    "f0_file_2": "F0 File",
+    "clean_f0_file": "Clean up F0 file",
+    "embed_mode": "Embedders Mode",
+    "embed_mode_info": "Extracting embeddings using different models",
+    "close": "The application is shutting down...",
+    "start_whisper": "Starting voice recognition with Whisper...",
+    "whisper_done": "Voice recognition complete!",
+    "process_audio": "Preprocessing audio...",
+    "process_done_start_convert": "Audio processing complete! proceeding with audio conversion...",
+    "convert_with_whisper": "Convert Audio With Whisper",
+    "convert_with_whisper_info": "Convert audio using a trained speech model with a Whisper model for speech recognition\n\nWhisper will recognize different voices then cut the individual voices and use the RVC model to convert those segments\n\nThe Whisper model may not work properly which may cause strange output",
+    "num_spk": "Number of voices",
+    "num_spk_info": "Number of voices in the audio",
+    "model_size": "Whisper model size",
+    "model_size_info": "Whisper model size\n\nLarge models can produce strange outputs",
+    "editing": "Editing",
+    "inverting": "Inverting",
+    "steps": "Steps",
+    "source_prompt": "Source Prompt",
+    "target_prompt": "Prompt",
+    "cfg_scale_src": "Source Prompt",
+    "cfg_scale_tar": "Target Prompt",
+    "t_start": "Edit Level",
+    "save_compute": "Effective Edit",
+    "error_edit": "An error occurred while editing background music {e}",
+    "start_edit": "Starting editing background music {input_path}...",
+    "edit_success": "Finished editing the soundtrack after {time} with output {output_path}",
+    "audio_editing": "Editing the Soundtrack",
+    "audio_editing_info": "## Editing Soundtrack Using Audioldm2 Model",
+    "audio_editing_markdown": "Editing the soundtrack using Audioldm2 model can help change the type of instrument inside the soundtrack",
+    "target_prompt_info": "Describe your desired edited output",
+    "cfg_scale_src_info": "The extent to which the source influences the output. Higher values retain more characteristics from the source. Lower values give the system more freedom to transform.",
+    "cfg_scale_tar_info": "The extent to which the target influences the final result. Higher values force the result to follow the characteristics of the target. Lower values balance the source and target.",
+    "audioldm2_model": "Audioldm2 model",
+    "audioldm2_model_info": "Choose the Audioldm2 model of your choice\n\nLoading the weights and inference will also take a long time depending on your GPU",
+    "source_prompt_info": "Optional: Describe the original audio input",
+    "t_start_info": "Lower correction levels will be closer to the original sound, higher will be stronger correction.",
+    "steps_label": "Number diffusion steps",
+    "steps_info": "Higher values (e.g. 200) produce higher quality output.",
+    "title": "Simple high-quality and high-performance voice and instrument conversion and training tool for Vietnamese people",
+    "fp16_not_support": "CPU does not support fp16 well, convert fp16 -> fp32",
+    "precision": "Precision",
+    "precision_info": "Precision of inference and model training\n\nNote: CPU Does not support fp16\n\nFor RefineGAN and MRF HIFIGAN when converting use fp32 as fp16 can cause them to give weird output",
+    "update_precision": "Update Precision",
+    "start_update_precision": "Start updating precision",
+    "deterministic": "Deterministic algorithm",
+    "deterministic_info": "When enabled, highly deterministic algorithms are used, ensuring that each run of the same input data will yield the same results.\n\nWhen disabled, more optimal algorithms may be selected but may not be fully deterministic, resulting in different training results between runs.",
+    "benchmark": "Benchmark algorithm",
+    "benchmark_info": "When enabled, it will test and select the most optimized algorithm for the specific hardware and size. This can help speed up training.\n\nWhen disabled, it will not perform this algorithm optimization, which can reduce speed but ensures that each run uses the same algorithm, which is useful if you want to reproduce exactly.",
+    "font": "Font",
+    "font_info": "Interface font\n\nVisit [Google Font](https://fonts.google.com) to choose your favorite font.",
+    "change_font": "Change Font",
+    "f0_unlock": "Unlock all",
+    "f0_unlock_info": "Unlock all pitch extraction methods",
+    "stop_audioldm2": "Stop Audioldm2",
+    "srt": "SRT file is empty or corrupt!"
+}

assets/languages/id_ID.json

@@ -0,0 +1,809 @@
+{
+    "set_lang": "Bahasa tampilan diatur ke {lang}.",
+    "no_support_gpu": "Sayangnya, tidak ada GPU yang kompatibel untuk mendukung pelatihan Anda.",
+    "text": "teks",
+    "upload_success": "File {name} berhasil diunggah.",
+    "download_url": "Unduh dari tautan",
+    "download_from_csv": "Unduh dari repositori model CSV",
+    "search_models": "Cari model",
+    "upload": "Unggah",
+    "option_not_valid": "Opsi tidak valid!",
+    "list_model": "Daftar model",
+    "success": "Selesai!",
+    "index": "indeks",
+    "model": "model",
+    "zip": "kompres",
+    "search": "cari",
+    "provide_file": "Harap berikan file {filename} yang valid!",
+    "start": "Memulai {start}...",
+    "not_found": "Tidak ditemukan {name}.",
+    "found": "Ditemukan {results} hasil!",
+    "download_music": "unduh musik",
+    "download": "unduh",
+    "provide_url": "Harap berikan URL.",
+    "provide_name_is_save": "Harap berikan nama model untuk disimpan.",
+    "not_support_url": "URL model Anda tidak didukung.",
+    "error_occurred": "Terjadi kesalahan: {e}.",
+    "not_model": "File yang Anda unggah bukan file model!",
+    "unable_analyze_model": "Tidak dapat menganalisis model!",
+    "download_pretrain": "Mengunduh model pra-latih...",
+    "provide_pretrain": "Harap berikan URL model pra-latih {dg}.",
+    "sr_not_same": "Laju sampel kedua model tidak sama.",
+    "architectures_not_same": "Tidak dapat menggabungkan model. Arsitekturnya tidak sama.",
+    "fushion_model": "fusi model",
+    "model_fushion_info": "Model {name} difusikan dari {pth_1} dan {pth_2} dengan rasio {ratio}.",
+    "not_found_create_time": "Waktu pembuatan tidak ditemukan.",
+    "format_not_valid": "Format tidak valid.",
+    "read_info": "Model yang dilatih pada aplikasi berbeda mungkin menghasilkan informasi berbeda atau tidak dapat dibaca!",
+    "epoch": "epok.",
+    "step": "langkah",
+    "sr": "Laju sampel",
+    "f0": "pelatihan nada",
+    "version": "versi.",
+    "not_f0": "Pelatihan nada tidak dilakukan",
+    "trained_f0": "Pelatihan nada dilakukan",
+    "model_info": "Nama Model: {model_name}\n\nPembuat Model: {model_author}\n\nEpok: {epochs}\n\nLangkah: {steps}\n\nVersi: {version}\n\nLaju Sampel: {sr}\n\nPelatihan Nada: {pitch_guidance}\n\nHash (ID): {model_hash}\n\nWaktu Pembuatan: {creation_date_str}\n\nVocoder: {vocoder}\n",
+    "input_not_valid": "Harap berikan input yang valid!",
+    "output_not_valid": "Harap berikan output yang valid!",
+    "apply_effect": "terapkan efek",
+    "enter_the_text": "Harap masukkan teks untuk diucapkan!",
+    "choose_voice": "Harap pilih suara!",
+    "convert": "Mengonversi {name}...",
+    "separator_music": "pemisahan musik",
+    "notfound": "Tidak ditemukan",
+    "turn_on_use_audio": "Harap aktifkan penggunaan audio yang dipisahkan untuk melanjutkan",
+    "turn_off_convert_backup": "Nonaktifkan konversi suara cadangan untuk menggunakan suara asli",
+    "turn_off_merge_backup": "Nonaktifkan penggabungan suara cadangan untuk menggunakan suara asli",
+    "not_found_original_vocal": "Vokal asli tidak ditemukan!",
+    "convert_vocal": "Mengonversi suara...",
+    "convert_success": "Konversi suara selesai!",
+    "convert_backup": "Mengonversi suara cadangan...",
+    "convert_backup_success": "Konversi suara cadangan selesai!",
+    "merge_backup": "Menggabungkan suara utama dengan suara cadangan...",
+    "merge_success": "Penggabungan selesai.",
+    "is_folder": "Input adalah folder: Mengonversi semua file audio dalam folder...",
+    "not_found_in_folder": "Tidak ada file audio yang ditemukan dalam folder!",
+    "batch_convert": "Konversi batch sedang berlangsung...",
+    "batch_convert_success": "Konversi batch berhasil!",
+    "create": "buat",
+    "provide_name": "Harap berikan nama model.",
+    "not_found_data": "Data tidak ditemukan",
+    "not_found_data_preprocess": "Data audio yang diproses tidak ditemukan, harap proses ulang.",
+    "not_found_data_extract": "Data audio yang diekstrak tidak ditemukan, harap ekstrak ulang.",
+    "provide_pretrained": "Harap berikan model pra-latih {dg}.",
+    "download_pretrained": "Mengunduh model pra-latih {dg}{rvc_version} asli",
+    "not_found_pretrain": "Model pra-latih {dg} tidak ditemukan",
+    "not_use_pretrain": "Tidak ada model pra-latih yang akan digunakan",
+    "training": "pelatihan",
+    "rick_roll": "Klik di sini jika Anda ingin di-Rick Roll :) ---> [RickRoll]({rickroll})",
+    "terms_of_use": "**Harap tidak menggunakan proyek ini untuk tujuan yang tidak etis, ilegal, atau merugikan individu atau organisasi...**",
+    "exemption": "**Jika pengguna tidak mematuhi syarat atau melanggarnya, saya tidak bertanggung jawab atas klaim, kerusakan, atau tanggung jawab apa pun, baik dalam kontrak, kelalaian, atau penyebab lain yang timbul dari, di luar, atau terkait dengan perangkat lunak, penggunaannya, atau transaksi lain yang terkait dengannya.**",
+    "separator_tab": "Pemisahan Musik",
+    "4_part": "Sistem pemisahan musik sederhana dapat memisahkan menjadi 4 bagian: Instrumen, Vokal, Vokal Utama, Vokal Cadangan",
+    "clear_audio": "Bersihkan audio",
+    "separator_backing": "Pisahkan vokal cadangan",
+    "denoise_mdx": "Pemisahan MDX denoise",
+    "use_mdx": "Gunakan MDX",
+    "dereveb_audio": "Hapus reverb vokal",
+    "dereveb_backing": "Hapus reverb cadangan",
+    "separator_model": "Model pemisahan musik",
+    "separator_backing_model": "Model pemisahan cadangan",
+    "shift": "Pergeseran",
+    "shift_info": "Semakin tinggi, kualitas lebih baik tetapi lebih lambat dan menggunakan lebih banyak sumber daya",
+    "segments_size": "Ukuran Segmen",
+    "segments_size_info": "Semakin tinggi, kualitas lebih baik tetapi menggunakan lebih banyak sumber daya",
+    "batch_size": "Ukuran batch",
+    "batch_size_info": "Jumlah sampel yang diproses secara bersamaan dalam satu siklus pelatihan. Semakin tinggi dapat menyebabkan kelebihan memori",
+    "mdx_batch_size_info": "Jumlah sampel yang diproses sekaligus. Pemrosesan batch mengoptimalkan perhitungan. Batch besar dapat menyebabkan kelebihan memori; batch kecil mengurangi efisiensi sumber daya",
+    "overlap": "Tumpang tindih",
+    "overlap_info": "Jumlah tumpang tindih antara jendela prediksi",
+    "export_format": "Format ekspor",
+    "export_info": "Format ekspor untuk mengekspor file audio",
+    "output_separator": "Output yang dipisahkan",
+    "hop_length_info": "Menganalisis jendela transfer waktu saat melakukan transformasi diperbolehkan. Nilai detail lebih kompak tetapi membutuhkan lebih banyak perhitungan",
+    "drop_audio": "Letakkan audio di sini",
+    "drop_text": "Letakkan file teks di sini",
+    "use_url": "Tautan YouTube",
+    "url_audio": "Tautan audio",
+    "downloads": "Unduhan",
+    "clean_strength": "Kekuatan pembersihan audio",
+    "clean_strength_info": "Kekuatan pembersih audio untuk menyaring vokal selama ekspor",
+    "input_output": "Input audio, output",
+    "audio_path": "Jalur input audio",
+    "refesh": "Segarkan",
+    "output_folder": "Jalur folder output audio",
+    "output_folder_info": "Masukkan jalur folder tempat audio akan diekspor",
+    "input_audio": "Input audio",
+    "instruments": "Instrumen",
+    "original_vocal": "Vokal asli",
+    "main_vocal": "Vokal utama",
+    "backing_vocal": "Vokal cadangan",
+    "convert_audio": "Konversi Audio",
+    "convert_info": "Konversi audio menggunakan model suara yang dilatih",
+    "autotune": "Auto-tune",
+    "use_audio": "Gunakan audio yang dipisahkan",
+    "convert_original": "Konversi suara asli",
+    "convert_backing": "Konversi suara cadangan",
+    "not_merge_backing": "Jangan gabungkan suara cadangan",
+    "merge_instruments": "Gabungkan instrumen",
+    "pitch": "Nada",
+    "pitch_info": "Rekomendasi: atur ke 12 untuk mengubah suara pria ke wanita dan sebaliknya",
+    "model_accordion": "Model dan indeks",
+    "model_name": "File model",
+    "index_path": "File indeks",
+    "index_strength": "Kekuatan indeks",
+    "index_strength_info": "Nilai lebih tinggi meningkatkan kekuatan. Namun, nilai lebih rendah dapat mengurangi efek buatan pada audio",
+    "output_path": "Jalur output audio",
+    "output_path_info": "Masukkan jalur output (biarkan dalam format .wav; akan dikoreksi otomatis selama konversi)",
+    "setting": "Pengaturan umum",
+    "f0_method": "Metode ekstraksi",
+    "f0_method_info": "Metode yang digunakan untuk ekstraksi data",
+    "f0_method_hybrid": "Metode ekstraksi HIBRID",
+    "f0_method_hybrid_info": "Kombinasi dari dua atau lebih jenis ekstraksi yang berbeda",
+    "hubert_model": "Model penyematan",
+    "hubert_info": "Model pra-latih untuk membantu penyematan",
+    "modelname": "Nama model",
+    "modelname_info": "Jika Anda memiliki model sendiri, unggah dan masukkan nama di sini",
+    "split_audio": "Pisahkan audio",
+    "autotune_rate": "Tingkat auto-tune",
+    "autotune_rate_info": "Tingkat penyesuaian auto-tuning",
+    "resample": "Resample",
+    "resample_info": "Resample pasca-pemrosesan ke laju sampel akhir; 0 berarti tidak ada resampling, CATATAN: BEBERAPA FORMAT TIDAK MENDUKUNG KECEPATAN DI ATAS 48000",
+    "filter_radius": "Radius filter",
+    "filter_radius_info": "Jika lebih dari tiga, filter median diterapkan. Nilai ini mewakili radius filter dan dapat mengurangi napas atau kebisingan.",
+    "volume_envelope": "Amplop volume",
+    "volume_envelope_info": "Gunakan amplop volume input untuk mengganti atau mencampur dengan amplop volume output. Semakin mendekati 1, semakin banyak amplop output yang digunakan",
+    "protect": "Perlindungan konsonan",
+    "protect_info": "Melindungi konsonan yang jelas dan suara napas untuk mencegah robekan audio dan artefak lainnya. Meningkatkan nilai ini memberikan perlindungan menyeluruh. Menguranginya dapat mengurangi perlindungan tetapi juga meminimalkan efek pengindeksan",
+    "output_convert": "Audio yang dikonversi",
+    "main_convert": "Konversi suara utama",
+    "main_or_backing": "Suara utama + Suara cadangan",
+    "voice_or_instruments": "Suara + Instrumen",
+    "convert_text": "Konversi Teks",
+    "convert_text_markdown": "## Konversi Teks ke Ucapan",
+    "convert_text_markdown_2": "Konversi teks ke ucapan dan baca keras menggunakan model suara yang dilatih",
+    "input_txt": "Input data dari file teks (.txt)",
+    "text_to_speech": "Teks untuk dibaca",
+    "voice_speed": "Kecepatan baca",
+    "voice_speed_info": "Kecepatan suara",
+    "tts_1": "1. Konversi Teks ke Ucapan",
+    "tts_2": "2. Konversi Ucapan",
+    "voice": "Suara berdasarkan negara",
+    "output_tts": "Jalur output ucapan",
+    "output_tts_convert": "Jalur output ucapan yang dikonversi",
+    "tts_output": "Masukkan jalur output",
+    "output_tts_markdown": "Audio yang belum dikonversi dan dikonversi",
+    "output_text_to_speech": "Ucapan yang dihasilkan dari konversi teks-ke-ucapan",
+    "output_file_tts_convert": "Ucapan yang dikonversi menggunakan model",
+    "output_audio": "Output audio",
+    "provide_output": "Masukkan jalur output",
+    "audio_effects": "Efek Audio",
+    "apply_audio_effects": "## Tambahkan Efek Audio Tambahan",
+    "audio_effects_edit": "Tambahkan efek ke audio",
+    "reverb": "Efek reverb",
+    "chorus": "Efek chorus",
+    "delay": "Efek delay",
+    "more_option": "Opsi tambahan",
+    "phaser": "Efek phaser",
+    "compressor": "Efek kompresor",
+    "apply": "Terapkan",
+    "reverb_freeze": "Mode beku",
+    "reverb_freeze_info": "Ciptakan efek gema berkelanjutan ketika mode ini diaktifkan",
+    "room_size": "Ukuran ruangan",
+    "room_size_info": "Sesuaikan ruang ruangan untuk menciptakan reverberasi",
+    "damping": "Peredaman",
+    "damping_info": "Sesuaikan tingkat penyerapan untuk mengontrol jumlah reverberasi",
+    "wet_level": "Tingkat sinyal reverb",
+    "wet_level_info": "Sesuaikan tingkat efek sinyal reverb",
+    "dry_level": "Tingkat sinyal asli",
+    "dry_level_info": "Sesuaikan tingkat sinyal tanpa efek",
+    "width": "Lebar audio",
+    "width_info": "Sesuaikan lebar ruang audio",
+    "chorus_depth": "Kedalaman chorus",
+    "chorus_depth_info": "Sesuaikan intensitas chorus untuk menciptakan suara yang lebih lebar",
+    "chorus_rate_hz": "Frekuensi",
+    "chorus_rate_hz_info": "Sesuaikan kecepatan osilasi efek chorus",
+    "chorus_mix": "Campur sinyal",
+    "chorus_mix_info": "Sesuaikan tingkat campuran antara sinyal asli dan sinyal yang diproses",
+    "chorus_centre_delay_ms": "Penundaan pusat (ms)",
+    "chorus_centre_delay_ms_info": "Waktu penundaan antara saluran stereo untuk menciptakan efek chorus",
+    "chorus_feedback": "Umpan balik",
+    "chorus_feedback_info": "Sesuaikan jumlah sinyal efek yang diumpankan kembali ke sinyal asli",
+    "delay_seconds": "Waktu penundaan",
+    "delay_seconds_info": "Sesuaikan waktu penundaan antara sinyal asli dan sinyal yang diproses",
+    "delay_feedback": "Umpan balik penundaan",
+    "delay_feedback_info": "Sesuaikan jumlah sinyal umpan balik, menciptakan efek berulang",
+    "delay_mix": "Campuran sinyal penundaan",
+    "delay_mix_info": "Sesuaikan tingkat campuran antara sinyal asli dan sinyal yang ditunda",
+    "fade": "Efek fade",
+    "bass_or_treble": "Bass dan treble",
+    "limiter": "Pembatas ambang",
+    "distortion": "Efek distorsi",
+    "gain": "Penguatan audio",
+    "bitcrush": "Efek pengurangan bit",
+    "clipping": "Efek pemotongan",
+    "fade_in": "Efek fade-in (ms)",
+    "fade_in_info": "Waktu untuk audio meningkat secara bertahap dari 0 ke level normal",
+    "fade_out": "Efek fade-out (ms)",
+    "fade_out_info": "Waktu yang dibutuhkan untuk suara memudar dari normal ke nol",
+    "bass_boost": "Tingkat penguatan bass (dB)",
+    "bass_boost_info": "Jumlah penguatan bass dalam trek audio",
+    "bass_frequency": "Frekuensi pemotongan filter low-pass (Hz)",
+    "bass_frequency_info": "Frekuensi akan dikurangi. Frekuensi rendah membuat bass lebih jelas",
+    "treble_boost": "Tingkat penguatan treble (dB)",
+    "treble_boost_info": "Tingkat penguatan suara tinggi dalam trek audio",
+    "treble_frequency": "Frekuensi pemotongan filter high-pass (Hz)",
+    "treble_frequency_info": "Frekuensi akan disaring. Semakin tinggi frekuensi, semakin tinggi suara yang akan dipertahankan.",
+    "limiter_threashold_db": "Ambang pembatas",
+    "limiter_threashold_db_info": "Batasi level audio maksimum untuk mencegahnya melebihi ambang",
+    "limiter_release_ms": "Waktu pelepasan",
+    "limiter_release_ms_info": "Waktu untuk audio kembali setelah dibatasi (Mili Detik)",
+    "distortion_info": "Sesuaikan tingkat distorsi untuk menciptakan efek berisik",
+    "gain_info": "Sesuaikan tingkat volume sinyal",
+    "clipping_threashold_db": "Ambang pemotongan",
+    "clipping_threashold_db_info": "Pangkas sinyal yang melebihi ambang, menciptakan suara terdistorsi",
+    "bitcrush_bit_depth": "Kedalaman bit",
+    "bitcrush_bit_depth_info": "Kurangi kualitas audio dengan mengurangi kedalaman bit, menciptakan efek terdistorsi",
+    "phaser_depth": "Kedalaman phaser",
+    "phaser_depth_info": "Sesuaikan kedalaman efek, memengaruhi intensitasnya",
+    "phaser_rate_hz": "Frekuensi",
+    "phaser_rate_hz_info": "Sesuaikan frekuensi efek phaser",
+    "phaser_mix": "Campur sinyal",
+    "phaser_mix_info": "Sesuaikan tingkat campuran antara sinyal asli dan yang diproses",
+    "phaser_centre_frequency_hz": "Frekuensi pusat",
+    "phaser_centre_frequency_hz_info": "Frekuensi pusat efek phaser, memengaruhi frekuensi yang disesuaikan",
+    "phaser_feedback": "Umpan balik",
+    "phaser_feedback_info": "Sesuaikan tingkat umpan balik efek, menciptakan rasa phaser yang lebih kuat atau lebih ringan",
+    "compressor_threashold_db": "Ambang kompresor",
+    "compressor_threashold_db_info": "Tingkat ambang di mana audio akan dikompresi",
+    "compressor_ratio": "Rasio kompresi",
+    "compressor_ratio_info": "Sesuaikan tingkat kompresi audio saat melebihi ambang",
+    "compressor_attack_ms": "Waktu serangan (ms)",
+    "compressor_attack_ms_info": "Waktu untuk kompresi mulai berlaku setelah audio melebihi ambang",
+    "compressor_release_ms": "Waktu pelepasan",
+    "compressor_release_ms_info": "Waktu untuk audio kembali ke normal setelah dikompresi",
+    "create_dataset_url": "Tautan ke audio (gunakan koma untuk beberapa tautan)",
+    "createdataset": "Buat dataset",
+    "create_dataset_markdown": "## Buat Dataset Pelatihan dari YouTube",
+    "create_dataset_markdown_2": "Proses dan buat dataset pelatihan menggunakan tautan YouTube",
+    "denoise": "Denoise",
+    "skip": "Lewati",
+    "model_ver": "Versi pemisahan suara",
+    "model_ver_info": "Versi model untuk memisahkan vokal",
+    "create_dataset_info": "Informasi pembuatan dataset",
+    "output_data": "Output dataset",
+    "output_data_info": "Data output setelah pembuatan",
+    "skip_start": "Lewati awal",
+    "skip_start_info": "Lewati detik awal audio; gunakan koma untuk beberapa audio",
+    "skip_end": "Lewati akhir",
+    "skip_end_info": "Lewati detik akhir audio; gunakan koma untuk beberapa audio",
+    "training_model": "Latih Model",
+    "training_markdown": "Latih dan bangun model suara dengan kumpulan data suara",
+    "training_model_name": "Nama model selama pelatihan (hindari karakter khusus atau spasi)",
+    "sample_rate": "Laju sampel",
+    "sample_rate_info": "Laju sampel model",
+    "training_version": "Versi model",
+    "training_version_info": "Versi model selama pelatihan",
+    "training_pitch": "Panduan Nada",
+    "upload_dataset": "Unggah dataset",
+    "preprocess_effect": "Pemrosesan pasca",
+    "clear_dataset": "Bersihkan dataset",
+    "preprocess_info": "Informasi pemrosesan awal",
+    "preprocess_button": "1. Pemrosesan",
+    "extract_button": "2. Ekstrak",
+    "extract_info": "Informasi ekstraksi data",
+    "total_epoch": "Total epok",
+    "total_epoch_info": "Total epok pelatihan",
+    "save_epoch": "Frekuensi penyimpanan",
+    "save_epoch_info": "Frekuensi menyimpan model selama pelatihan untuk memungkinkan pelatihan ulang",
+    "create_index": "Buat indeks",
+    "index_algorithm": "Algoritma indeks",
+    "index_algorithm_info": "Algoritma untuk membuat indeks",
+    "custom_dataset": "Folder dataset kustom",
+    "custom_dataset_info": "Folder dataset kustom untuk data pelatihan",
+    "overtraining_detector": "Detektor pelatihan berlebih",
+    "overtraining_detector_info": "Periksa pelatihan berlebih selama pelatihan model",
+    "cleanup_training": "Bersihkan",
+    "cleanup_training_info": "Hanya aktifkan jika Anda perlu melatih ulang model dari awal.",
+    "cache_in_gpu": "Cache di GPU",
+    "cache_in_gpu_info": "Simpan model di memori cache GPU",
+    "dataset_folder": "Folder yang berisi dataset",
+    "threshold": "Ambang pelatihan berlebih",
+    "setting_cpu_gpu": "Pengaturan CPU/GPU",
+    "gpu_number": "Jumlah GPU yang digunakan",
+    "gpu_number_info": "Jumlah GPU yang digunakan selama pelatihan",
+    "save_only_latest": "Simpan hanya yang terbaru",
+    "save_only_latest_info": "Simpan hanya model D dan G terbaru",
+    "save_every_weights": "Simpan semua model",
+    "save_every_weights_info": "Simpan semua model setelah setiap epok",
+    "gpu_info": "Informasi GPU",
+    "gpu_info_2": "Informasi tentang GPU yang digunakan selama pelatihan",
+    "cpu_core": "Jumlah inti CPU yang tersedia",
+    "cpu_core_info": "Jumlah inti CPU yang digunakan selama pelatihan",
+    "not_use_pretrain_2": "Jangan gunakan pra-pelatihan",
+    "not_use_pretrain_info": "Jangan gunakan model pra-latih",
+    "custom_pretrain": "Pra-pelatihan kustom",
+    "custom_pretrain_info": "Sesuaikan pengaturan pra-pelatihan",
+    "pretrain_file": "File model pra-latih {dg}",
+    "train_info": "Informasi pelatihan",
+    "export_model": "5. Ekspor Model",
+    "zip_model": "2. Kompres model",
+    "output_zip": "File output setelah kompresi",
+    "model_path": "Jalur model",
+    "model_ratio": "Rasio model",
+    "model_ratio_info": "Menyesuaikan ke satu sisi akan membuat model lebih mirip dengan sisi itu",
+    "output_model_path": "Jalur output model",
+    "fushion": "Fusi Model",
+    "fushion_markdown": "## Fusi Dua Model",
+    "fushion_markdown_2": "Gabungkan dua model suara menjadi satu model",
+    "read_model": "Baca Informasi",
+    "read_model_markdown": "## Baca Informasi Model",
+    "read_model_markdown_2": "Ambil informasi yang terekam dalam model",
+    "drop_model": "Letakkan model di sini",
+    "readmodel": "Baca model",
+    "model_path_info": "Masukkan jalur ke file model",
+    "modelinfo": "Informasi Model",
+    "download_markdown": "## Unduh Model",
+    "download_markdown_2": "Unduh model suara, model pra-latih, dan model penyematan",
+    "model_download": "Unduh model suara",
+    "model_url": "Tautan ke model",
+    "15s": "Harap tunggu sekitar 15 detik. Sistem akan restart otomatis!",
+    "model_download_select": "Pilih metode unduh model",
+    "model_warehouse": "Repositori model",
+    "get_model": "Ambil model",
+    "name_to_search": "Nama untuk dicari",
+    "search_2": "Cari",
+    "select_download_model": "Pilih model yang dicari (Klik untuk memilih)",
+    "download_pretrained_2": "Unduh model pra-latih",
+    "only_huggingface": "Hanya mendukung huggingface.co",
+    "pretrained_url": "Tautan model pra-latih {dg}",
+    "select_pretrain": "Pilih model pra-latih",
+    "select_pretrain_info": "Pilih model pra-latih untuk diunduh",
+    "pretrain_sr": "Laju sampel model",
+    "drop_pretrain": "Letakkan model pra-latih {dg} di sini",
+    "settings": "Pengaturan",
+    "settings_markdown": "## Pengaturan Tambahan",
+    "settings_markdown_2": "Sesuaikan fitur tambahan proyek",
+    "lang": "Bahasa",
+    "lang_restart": "Bahasa tampilan dalam proyek (Saat mengubah bahasa, sistem akan restart otomatis setelah 15 detik untuk memperbarui)",
+    "change_lang": "Ubah Bahasa",
+    "theme": "Tema",
+    "theme_restart": "Jenis tema yang ditampilkan di antarmuka (Saat mengubah tema, sistem akan restart otomatis setelah 15 detik untuk memperbarui)",
+    "theme_button": "Ubah Tema",
+    "change_light_dark": "Beralih Mode Terang/Gelap",
+    "tensorboard_url": "URL Tensorboard",
+    "errors_loading_audio": "Kesalahan memuat audio: {e}",
+    "apply_error": "Terjadi kesalahan saat menerapkan efek: {e}",
+    "indexpath": "Jalur indeks",
+    "split_total": "Total bagian yang dipisah",
+    "process_audio_error": "Terjadi kesalahan saat memproses audio",
+    "merge_error": "Terjadi kesalahan saat menggabungkan audio",
+    "not_found_convert_file": "File yang diproses tidak ditemukan",
+    "convert_batch": "Konversi batch...",
+    "found_audio": "Ditemukan {audio_files} file audio untuk konversi.",
+    "not_found_audio": "Tidak ada file audio yang ditemukan!",
+    "error_convert": "Terjadi kesalahan selama konversi audio: {e}",
+    "convert_batch_success": "Konversi batch selesai dengan sukses dalam {elapsed_time} detik. {output_path}",
+    "convert_audio_success": "File {input_path} berhasil dikonversi dalam {elapsed_time} detik. {output_path}",
+    "hybrid_methods": "Memperkirakan nada f0 menggunakan metode {methods}",
+    "method_not_valid": "Metode tidak valid",
+    "read_faiss_index_error": "Terjadi kesalahan saat membaca indeks FAISS: {e}",
+    "read_model_error": "Gagal memuat model: {e}",
+    "starting_download": "Memulai unduhan",
+    "version_not_valid": "Versi pemisahan vokal tidak valid",
+    "skip<audio": "Tidak dapat melewati karena waktu lewati kurang dari panjang file audio",
+    "skip>audio": "Tidak dapat melewati karena waktu lewati lebih besar dari panjang file audio",
+    "=<0": "Waktu lewati kurang dari atau sama dengan 0 dan telah dilewati",
+    "skip_warning": "Durasi lewati ({seconds} detik) melebihi panjang audio ({total_duration} detik). Melewati.",
+    "download_success": "Unduhan selesai dengan sukses",
+    "create_dataset_error": "Terjadi kesalahan saat membuat dataset pelatihan",
+    "create_dataset_success": "Pembuatan dataset pelatihan selesai dalam {elapsed_time} detik",
+    "skip_start_audio": "Berhasil melewati awal audio: {input_file}",
+    "skip_end_audio": "Berhasil melewati akhir audio: {input_file}",
+    "merge_audio": "Menggabungkan semua bagian yang berisi audio",
+    "separator_process": "Memisahkan vokal: {input}...",
+    "not_found_main_vocal": "Vokal utama tidak ditemukan!",
+    "not_found_backing_vocal": "Vokal cadangan tidak ditemukan!",
+    "not_found_instruments": "Instrumen tidak ditemukan",
+    "merge_instruments_process": "Menggabungkan vokal dengan instrumen...",
+    "dereverb": "Menghapus reverb vokal",
+    "dereverb_success": "Berhasil menghapus reverb vokal",
+    "save_index": "File indeks disimpan",
+    "create_index_error": "Terjadi kesalahan saat membuat indeks",
+    "sr_not_16000": "Laju sampel harus 16000",
+    "gpu_not_valid": "Indeks GPU tidak valid. Beralih ke CPU.",
+    "extract_file_error": "Terjadi kesalahan saat mengekstrak file",
+    "extract_f0_method": "Memulai ekstraksi nada menggunakan {num_processes} inti dengan metode {f0_method}...",
+    "extract_f0": "Ekstraksi Nada",
+    "extract_f0_success": "Ekstraksi nada selesai dalam {elapsed_time} detik.",
+    "NaN": "berisi nilai NaN dan akan diabaikan.",
+    "start_extract_hubert": "Memulai ekstraksi penyematan...",
+    "not_found_audio_file": "File audio tidak ditemukan. Pastikan Anda memberikan audio yang benar.",
+    "process_error": "Terjadi kesalahan selama pemrosesan",
+    "extract_hubert_success": "Ekstraksi penyematan selesai dalam {elapsed_time} detik.",
+    "export_process": "Jalur model",
+    "extract_error": "Terjadi kesalahan selama ekstraksi data",
+    "extract_success": "Ekstraksi data berhasil",
+    "min_length>=min_interval>=hop_size": "min_length harus lebih besar atau sama dengan min_interval dan hop_size",
+    "max_sil_kept>=hop_size": "max_sil_kept harus lebih besar atau sama dengan hop_size",
+    "start_preprocess": "Memulai pemrosesan awal data dengan {num_processes} inti...",
+    "not_integer": "Folder ID suara harus berupa bilangan bulat; sebaliknya mendapat",
+    "preprocess_success": "Pemrosesan selesai dalam {elapsed_time} detik.",
+    "preprocess_model_success": "Pemrosesan data untuk model selesai dengan sukses",
+    "turn_on_dereverb": "Penghapusan reverb untuk vokal cadangan memerlukan pengaktifan penghapusan reverb",
+    "turn_on_separator_backing": "Pemisahan vokal cadangan memerlukan pengaktifan pemisahan vokal",
+    "backing_model_ver": "Versi model pemisahan vokal cadangan",
+    "clean_audio_success": "Audio berhasil dibersihkan!",
+    "separator_error": "Terjadi kesalahan selama pemisahan musik",
+    "separator_success": "Pemisahan musik selesai dalam {elapsed_time} detik",
+    "separator_process_2": "Memproses pemisahan musik",
+    "separator_success_2": "Pemisahan musik berhasil!",
+    "separator_process_backing": "Memproses pemisahan vokal cadangan",
+    "separator_process_backing_success": "Pemisahan vokal cadangan berhasil!",
+    "process_original": "Memproses penghapusan reverb vokal asli...",
+    "process_original_success": "Penghapusan reverb vokal asli berhasil!",
+    "process_main": "Memproses penghapusan reverb vokal utama...",
+    "process_main_success": "Penghapusan reverb vokal utama berhasil!",
+    "process_backing": "Memproses penghapusan reverb vokal cadangan...",
+    "process_backing_success": "Penghapusan reverb vokal cadangan berhasil!",
+    "save_every_epoch": "Simpan model setelah: ",
+    "total_e": "Total epok: ",
+    "dorg": "Pra-latih G: {pretrainG} | Pra-latih D: {pretrainD}",
+    "training_f0": "Panduan Nada",
+    "not_gpu": "Tidak ada GPU yang terdeteksi, kembali ke CPU (tidak disarankan)",
+    "not_found_checkpoint": "File checkpoint tidak ditemukan: {checkpoint_path}",
+    "save_checkpoint": "Memuat ulang checkpoint '{checkpoint_path}' (epok {checkpoint_dict})",
+    "save_model": "Model disimpan '{checkpoint_path}' (epok {iteration})",
+    "sr_does_not_match": "Laju sampel {sample_rate} tidak cocok dengan laju sampel target {sample_rate2}",
+    "spec_error": "Terjadi kesalahan saat mengambil spesifikasi dari {spec_filename}: {e}",
+    "time_or_speed_training": "waktu={current_time} | kecepatan pelatihan={elapsed_time_str}",
+    "savemodel": "Model disimpan '{model_dir}' (epok {epoch} dan langkah {step})",
+    "model_author": "Kredit model ke {model_author}",
+    "unregistered": "Model tidak terdaftar",
+    "not_author": "Model tidak dikreditkan",
+    "training_author": "Nama pembuat model",
+    "training_author_info": "Untuk mengkredit model, masukkan nama Anda di sini",
+    "extract_model_error": "Terjadi kesalahan saat mengekstrak model",
+    "start_training": "Memulai pelatihan",
+    "import_pretrain": "Memuat model pra-latih ({dg}) '{pretrain}'",
+    "not_using_pretrain": "Tidak ada model pra-latih ({dg}) yang akan digunakan",
+    "training_warning": "PERINGATAN: Kerugian yang dihasilkan lebih rendah dari kerugian ambang bawah untuk epok berikutnya.",
+    "overtraining_find": "Pelatihan berlebih terdeteksi pada epok {epoch} dengan kerugian generator yang dihaluskan {smoothed_value_gen} dan kerugian diskriminator yang dihaluskan {smoothed_value_disc}",
+    "best_epoch": "Epok terbaik baru {epoch} dengan kerugian generator yang dihaluskan {smoothed_value_gen} dan kerugian diskriminator yang dihaluskan {smoothed_value_disc}",
+    "success_training": "Pelatihan selesai dengan {epoch} epok, {global_step} langkah, dan {loss_gen_all} total kerugian generator.",
+    "training_info": "Kerugian generator terendah: {lowest_value_rounded} pada epok {lowest_value_epoch}, langkah {lowest_value_step}",
+    "model_training_info": "{model_name} | epok={epoch} | langkah={global_step} | {epoch_recorder} | nilai terendah={lowest_value_rounded} (epok {lowest_value_epoch} dan langkah {lowest_value_step}) | epok tersisa untuk pelatihan berlebih: g/total: {remaining_epochs_gen} d/total: {remaining_epochs_disc} | kerugian generator yang dihaluskan={smoothed_value_gen} | kerugian diskriminator yang dihaluskan={smoothed_value_disc}",
+    "model_training_info_2": "{model_name} | epok={epoch} | langkah={global_step} | {epoch_recorder} | nilai terendah={lowest_value_rounded} (epok {lowest_value_epoch} dan langkah {lowest_value_step})",
+    "model_training_info_3": "{model_name} | epok={epoch} | langkah={global_step} | {epoch_recorder}",
+    "training_error": "Terjadi kesalahan saat melatih model:",
+    "separator_info": "Menginisialisasi dengan jalur output: {output_dir}, format output: {output_format}",
+    "output_dir_is_none": "Folder output tidak ditentukan. Menggunakan direktori kerja saat ini.",
+    ">0or=1": "Ambang normalisasi harus lebih besar dari 0 dan kurang dari atau sama dengan 1.",
+    "output_single": "Output akar tunggal diminta; hanya satu file ({output_single_stem}) yang akan ditulis",
+    "step2": "Langkah kedua akan dibalik menggunakan spektrogram bukan gelombang. Ini dapat meningkatkan kualitas tetapi sedikit lebih lambat.",
+    "name_ver": "Versi {name}",
+    "os": "Sistem Operasi",
+    "platform_info": "Sistem: {system_info} Nama: {node} Rilis: {release} Mesin: {machine} Prosesor: {processor}",
+    "none_ffmpeg": "FFmpeg tidak terinstal. Harap instal FFmpeg untuk menggunakan paket ini.",
+    "install_onnx": "Paket ONNX Runtime {pu} terinstal dengan versi",
+    "running_in_cpu": "Tidak dapat mengkonfigurasi akselerasi perangkat keras, berjalan dalam mode CPU",
+    "running_in_cuda": "CUDA tersedia di Torch, mengatur perangkat Torch ke CUDA",
+    "onnx_have": "ONNXruntime tersedia {have}, mengaktifkan akselerasi",
+    "onnx_not_have": "{have} tidak tersedia di ONNXruntime; akselerasi TIDAK akan diaktifkan",
+    "python_not_install": "Paket Python: {package_name} tidak terinstal",
+    "hash": "Menghitung hash untuk file model {model_path}",
+    "ioerror": "IOError saat mencari -10 MB atau membaca file model untuk menghitung hash: {e}",
+    "cancel_download": "File sudah ada di {output_path}, melewati unduhan",
+    "download_model": "Mengunduh file dari {url} ke {output_path} dengan batas waktu 300 detik",
+    "download_error": "Gagal mengunduh file dari {url}, kode respons: {status_code}",
+    "vip_model": "Model: '{model_friendly_name}' adalah model premium yang dimaksudkan oleh Anjok07 hanya untuk akses pelanggan berbayar.",
+    "vip_print": "Hai, jika Anda belum berlangganan, pertimbangkan untuk mendukung pengembang UVR, Anjok07, dengan berlangganan di sini: https://patreon.com/uvr",
+    "search_model": "Mencari model {model_filename} dalam daftar model yang didukung dalam grup",
+    "load_download_json": "Daftar model yang diunduh dimuat",
+    "single_model": "Mengidentifikasi file model tunggal: {model_friendly_name}",
+    "not_found_model": "Model tidak ditemukan di repositori UVR, mencoba mengunduh dari repositori pemisahan model audio...",
+    "single_model_path": "Mengembalikan jalur untuk file model tunggal: {model_path}",
+    "find_model": "Nama file input {model_filename} ditemukan dalam model multi-file: {model_friendly_name}",
+    "find_models": "Mengidentifikasi model multi-file: {model_friendly_name}, mengulang file untuk diunduh",
+    "find_path": "Mencoba menentukan jalur unduhan untuk pasangan konfigurasi",
+    "not_found_model_warehouse": "Model tidak ditemukan di repositori UVR, mencoba mengunduh dari repositori pemisahan model audio...",
+    "yaml_warning": "Nama model yang Anda tentukan, {model_filename}, sebenarnya adalah file konfigurasi model daripada file model.",
+    "yaml_warning_2": "Kami menemukan model yang cocok dengan file konfigurasi ini: {config_key}, jadi kami akan menggunakan file model itu untuk proses ini.",
+    "yaml_warning_3": "Untuk menghindari perilaku yang membingungkan/tidak konsisten di masa depan, tentukan nama file model yang sebenarnya.",
+    "yaml_debug": "File model konfigurasi YAML tidak ditemukan di repositori UVR, mencoba mengunduh dari repositori pemisahan model audio...",
+    "download_model_friendly": "Semua file diunduh untuk model {model_friendly_name}, mengembalikan jalur asli {model_path}",
+    "not_found_model_2": "File model {model_filename} tidak ditemukan di file yang didukung",
+    "load_yaml": "Memuat data model dari YAML di jalur {model_data_yaml_filepath}",
+    "load_yaml_2": "Data model dimuat dari file YAML: {model_data}",
+    "hash_md5": "Menghitung hash MD5 untuk file model untuk mengidentifikasi parameter model dari data UVR...",
+    "model_hash": "Model {model_path} memiliki hash {model_hash}",
+    "mdx_data": "Jalur data model MDX diatur ke {mdx_model_data_path}",
+    "load_mdx": "Memuat parameter model MDX dari file data model UVR...",
+    "model_not_support": "File model tidak didukung: tidak ada parameter yang ditemukan untuk hash MD5 {model_hash} di data model UVR untuk vault MDX.",
+    "uvr_json": "Data model dimuat dari JSON UVR dengan hash {model_hash}: {model_data}",
+    "loading_model": "Memuat model {model_filename}...",
+    "download_model_friendly_2": "Model diunduh, nama ramah: {model_friendly_name}, Jalur Model: {model_path}",
+    "model_type_not_support": "Jenis model tidak didukung: {model_type}",
+    "demucs_not_support_python<3.10": "Model Demucs memerlukan versi Python 3.10 atau lebih tinggi.",
+    "import_module": "Mengimpor modul untuk jenis model",
+    "initialization": "Menginisialisasi kelas pemisah untuk jenis model",
+    "loading_model_success": "Pemuatan model selesai.",
+    "loading_model_duration": "Durasi pemuatan model",
+    "starting_separator": "Memulai proses pemisahan untuk jalur file audio",
+    "normalization": "Ambang normalisasi diatur ke {normalization_threshold}, gelombang akan diskalakan ke amplitudo maksimum ini untuk mencegah pemotongan.",
+    "loading_separator_model": "Mengunduh model {model_filename}...",
+    "separator_success_3": "Proses pemisahan selesai.",
+    "separator_duration": "Durasi pemisahan",
+    "downloading_model": "Model diunduh, jenis: {model_type}, nama ramah: {model_friendly_name}, Jalur Model: {model_path}, Data Model: {model_data_dict_size} item",
+    "demucs_info": "Parameter Demucs: Ukuran segmen = {segment_size}, Ukuran segmen aktif = {segments_enabled}",
+    "demucs_info_2": "Parameter Demucs: Jumlah prediksi = {shifts}, Tumpang tindih = {overlap}",
+    "start_demucs": "Inisialisasi Pemisah Demucs selesai",
+    "start_separator": "Memulai proses pemisahan...",
+    "prepare_mix": "Mempersiapkan campuran...",
+    "demix": "Campuran disiapkan untuk demixing. Bentuk: {shape}",
+    "cancel_mix": "Memuat model untuk demixing...",
+    "model_review": "Model dimuat dan diatur ke mode evaluasi.",
+    "del_gpu_cache_after_demix": "Membersihkan model dan cache GPU setelah demixing.",
+    "process_output_file": "Memproses file output...",
+    "source_length": "Memproses array sumber, panjang sumber adalah {source_length}",
+    "process_ver": "Memproses versi sumber...",
+    "set_map": "Mengatur peta sumber ke {part} bagian...",
+    "process_all_part": "Memproses untuk semua bagian akar...",
+    "skip_part": "Melewati bagian akar {stem_name} karena out_single_stem diatur ke {output_single_stem}...",
+    "starting_demix_demucs": "Memulai proses demix di demix_demucs...",
+    "model_infer": "Menjalankan inferensi model...",
+    "name_not_pretrained": "{name} bukan model pra-latih atau bundel model.",
+    "invalid_checksum": "Checksum tidak valid untuk file {path}, diharapkan {checksum} tetapi mendapat {actual_checksum}",
+    "mdx_info": "Parameter MDX: Ukuran batch = {batch_size}, Ukuran segmen = {segment_size}",
+    "mdx_info_2": "Parameter MDX: Tumpang tindih = {overlap}, Hop_length = {hop_length}, Denoising diaktifkan = {enable_denoise}",
+    "mdx_info_3": "Parameter MDX",
+    "load_model_onnx": "Memuat model ONNX untuk inferensi...",
+    "load_model_onnx_success": "Berhasil memuat model menggunakan sesi inferensi ONNXruntime.",
+    "onnx_to_pytorch": "Model dikonversi dari ONNX ke PyTorch karena ukuran segmen tidak cocok dengan dim_t, pemrosesan mungkin lebih lambat.",
+    "stft": "STFT terbalik diterapkan. Mengembalikan hasil dengan bentuk",
+    "no_denoise": "Model berjalan pada spektrum tanpa denoising.",
+    "mix": "Mempersiapkan campuran untuk file audio input {audio_file_path}...",
+    "normalization_demix": "Menormalkan campuran sebelum demixing...",
+    "mix_success": "Persiapan campuran selesai.",
+    "primary_source": "Menormalkan sumber utama...",
+    "secondary_source": "Menghasilkan sumber sekunder: Mencampur dalam mode kompatibel",
+    "invert_using_spec": "Membalikkan batang sekunder menggunakan spektrum saat invert_USE_spec diatur ke True",
+    "invert_using_spec_2": "Membalikkan batang sekunder dengan mengurangi batang yang diubah dari campuran awal yang diubah",
+    "enable_denoise": "Model berjalan pada spektrum positif dan negatif untuk denoising.",
+    "is_match_mix": "is_match_mix: Spektrum yang diprediksi diperoleh langsung dari output STFT.",
+    "save_secondary_stem_output_path": "Menyimpan batang sekunder {stem_name} ke {stem_output_path}...",
+    "starting_model": "Menginisialisasi pengaturan model...",
+    "input_info": "Parameter input model",
+    "model_settings": "Pengaturan model",
+    "initialize_mix": "Menginisialisasi campuran dengan is_ckpt = {is_ckpt}. Bentuk campuran awal: {shape}",
+    "!=2": "Diharapkan sinyal audio 2 saluran tetapi mendapat {shape} saluran",
+    "process_check": "Memproses dalam mode checkpoint...",
+    "stft_2": "STFT diterapkan ke campuran. Bentuk spektrum: {shape}",
+    "cache": "Padding dihitung",
+    "shape": "Bentuk campuran setelah padding: {shape}, Jumlah bagian: {num_chunks}",
+    "process_no_check": "Memproses dalam mode tanpa checkpoint...",
+    "n_sample_or_pad": "Jumlah sampel: {n_sample}, Padding dihitung: {pad}",
+    "shape_2": "Bentuk campuran setelah padding",
+    "process_part": "Memproses bagian {mix_waves}: Mulai {i}, Akhir {ii}",
+    "mix_waves_to_tensor": "Mengonversi mix_waves ke tensor. Bentuk tensor: {shape}",
+    "mix_match": "Mode campuran Cocok; menerapkan faktor kompensasi.",
+    "tar_waves": "tar_waves. Bentuk",
+    "normalization_2": "Menormalkan hasil dengan membaginya dengan pembagi.",
+    "mix_wave": "Memproses batch mix_wave",
+    "mix_or_batch": "Mencampur bagian menjadi batch. Jumlah batch",
+    "demix_is_match_mix": "Memulai proses demix dengan is_match_mix,",
+    "mix_shape": "Bagian campuran akar disimpan. Bentuk",
+    "chunk_size_or_overlap": "Ukuran potongan untuk pencampuran kompatibel: {chunk_size}, Tumpang tindih: {overlap}",
+    "chunk_size_or_overlap_standard": "Ukuran potongan standar: {chunk_size}, Tumpang tindih: {overlap}",
+    "calc_size": "Ukuran yang dihasilkan dihitung",
+    "window": "Jendela diterapkan ke segmen ini.",
+    "process_part_2": "Memproses segmen {total}/{total_chunks}: Mulai {start}, Akhir {end}",
+    "all_process_part": "Total segmen untuk diproses",
+    "step_or_overlap": "Ukuran langkah untuk memproses bagian: {step} dengan tumpang tindih diatur ke {overlap}.",
+    "mix_cache": "Campuran disiapkan dengan padding. Bentuk campuran",
+    "dims": "Tidak dapat menggunakan pengkodean posisi sin/cos dengan dimensi ganjil (dim={dims})",
+    "activation": "aktivasi harus relu/gelu, bukan {activation}",
+    "length_or_training_length": "Panjang yang diberikan {length} melebihi durasi pelatihan {training_length}",
+    "type_not_valid": "Jenis tidak valid untuk",
+    "del_parameter": "Menghapus parameter yang tidak ada ",
+    "info": "Parameter umum: Nama model = {model_name}, Jalur model = {model_path}",
+    "info_2": "Parameter umum: Jalur output = {output_dir}, Format output = {output_format}",
+    "info_3": "Parameter umum: Ambang normalisasi = {normalization_threshold}",
+    "info_4": "Parameter umum: Denoising diaktifkan = {enable_denoise}, Output batang tunggal = {output_single_stem}",
+    "info_5": "Parameter umum: Inversi menggunakan spesifikasi = {invert_using_spec}, Laju sampel = {sample_rate}",
+    "info_6": "Parameter umum: Nama akar utama = {primary_stem_name}, Nama akar sekunder = {secondary_stem_name}",
+    "info_7": "Parameter umum: Mode karaoke = {is_karaoke}, Model BV = {is_bv_model}, Rebalancing model BV = {bv_model_rebalance}",
+    "success_process": "Selesai memproses akar {stem_name} dan menulis audio...",
+    "load_audio": "Memuat audio dari file",
+    "load_audio_success": "Audio dimuat. Laju sampel: {sr}, Bentuk audio: {shape}",
+    "convert_mix": "Mengonversi array campuran yang diberikan.",
+    "convert_shape": "Bentuk campuran yang dikonversi: {shape}",
+    "audio_not_valid": "File audio {audio_path} kosong atau tidak valid",
+    "audio_valid": "File audio valid dan berisi data.",
+    "mix_single": "Campuran adalah mono. Mengonversi ke stereo.",
+    "convert_mix_audio": "Dikonversi ke campuran stereo.",
+    "mix_success_2": "Persiapan campuran selesai.",
+    "duration": "Durasi audio adalah {duration_hours} jam ({duration_seconds} detik).",
+    "write": "Menggunakan {name} untuk menulis.",
+    "write_audio": "Menulis {name} dengan jalur akar:",
+    "original_not_valid": "Peringatan: Array sumber asli hampir senyap atau kosong.",
+    "shape_audio": "Bentuk data audio sebelum pemrosesan",
+    "convert_data": "Tipe data sebelum konversi",
+    "original_source_to_int16": "Mengonversi original_source ke int16.",
+    "shape_audio_2": "Bentuk data audio yang diinterkalasi",
+    "create_audiosegment": "Berhasil membuat AudioSegment.",
+    "create_audiosegment_error": "Kesalahan spesifik saat membuat AudioSegment",
+    "export_error": "Kesalahan mengekspor file audio",
+    "export_success": "Berhasil mengekspor file audio ke",
+    "clean": "Menjalankan pengumpulan sampah...",
+    "clean_cache": "Membersihkan cache {name}...",
+    "del_path": "Menghapus jalur, sumber, dan akar dari file audio input...",
+    "not_success": "Proses tidak berhasil: ",
+    "resample_error": "Kesalahan selama resampling",
+    "shapes": "Bentuk",
+    "wav_resolution": "Jenis resolusi",
+    "warnings": "Peringatan: Nilai yang sangat agresif terdeteksi",
+    "warnings_2": "Peringatan: Nilai NaN atau tak terbatas terdeteksi dalam input gelombang. Bentuk",
+    "process_file": "Memproses file... \n",
+    "save_instruments": "Menyimpan trek terbalik...",
+    "assert": "File audio harus memiliki bentuk yang sama - Campuran: {mixshape}, Instrumen: {instrumentalshape}",
+    "rubberband": "Rubberband CLI tidak dapat dieksekusi. Pastikan Rubberband-CLI terinstal.",
+    "rate": "Laju harus benar-benar positif",
+    "gdown_error": "Tidak dapat mengambil tautan publik untuk file. Anda mungkin perlu mengubah izinnya menjadi 'Siapa saja dengan tautan' atau mungkin sudah ada izin akses yang berlebihan.",
+    "to": "Ke:",
+    "gdown_value_error": "Jalur atau ID harus ditentukan",
+    "missing_url": "URL tidak ada",
+    "mac_not_match": "MAC tidak cocok",
+    "file_not_access": "File tidak dapat diakses",
+    "int_resp==-3": "Permintaan gagal, mencoba lagi",
+    "search_separate": "Cari file terpisah...",
+    "found_choice": "Ditemukan {choice}",
+    "separator==0": "Tidak ada file terpisah yang ditemukan!",
+    "select_separate": "Pilih file terpisah",
+    "start_app": "Memulai antarmuka...",
+    "provide_audio": "Masukkan jalur ke file audio",
+    "set_torch_mps": "Atur perangkat Torch ke MPS",
+    "googletts": "Konversi teks menggunakan Google",
+    "pitch_info_2": "Penyesuaian nada untuk konverter teks-ke-ucapan",
+    "waveform": "Gelombang harus memiliki bentuk (# frame, # saluran)",
+    "freq_mask_smooth_hz": "freq_mask_smooth_hz harus setidaknya {hz}Hz",
+    "time_mask_smooth_ms": "time_mask_smooth_ms harus setidaknya {ms}ms",
+    "x": "x harus lebih besar",
+    "xn": "xn harus lebih besar",
+    "not_found_pid": "Tidak ada proses yang ditemukan!",
+    "end_pid": "Proses dihentikan!",
+    "not_found_separate_model": "Tidak ada file model pemisahan yang ditemukan!",
+    "not_found_pretrained": "Tidak ada file model pra-latih yang ditemukan!",
+    "not_found_log": "Tidak ada file log yang ditemukan!",
+    "not_found_predictors": "Tidak ada file model prediktor yang ditemukan!",
+    "not_found_embedders": "Tidak ada file model penyemat yang ditemukan!",
+    "provide_folder": "Harap berikan folder yang valid!",
+    "empty_folder": "Folder data kosong!",
+    "vocoder": "Vocoder",
+    "vocoder_info": "Vocoder menganalisis dan mensintesis sinyal ucapan manusia untuk transformasi suara.\n\nDefault: Opsi ini adalah HiFi-GAN-NSF, kompatibel dengan semua RVC\n\nMRF-HiFi-GAN: Fidelitas lebih tinggi.\n\nRefineGAN: Kualitas suara superior.",
+    "code_error": "Kesalahan: Menerima kode status",
+    "json_error": "Kesalahan: Tidak dapat mem-parsing respons.",
+    "requests_error": "Permintaan gagal: {e}",
+    "memory_efficient_training": "Menggunakan pelatihan hemat memori",
+    "not_use_pretrain_error_download": "Tidak akan menggunakan model pra-latih karena file tidak ada",
+    "provide_file_settings": "Harap berikan file pengaturan preset!",
+    "load_presets": "Memuat file preset {presets}",
+    "provide_filename_settings": "Harap berikan nama file preset!",
+    "choose1": "Harap pilih satu untuk diekspor!",
+    "export_settings": "File preset diekspor {name}",
+    "use_presets": "Menggunakan file preset",
+    "file_preset": "File preset",
+    "load_file": "Muat file",
+    "export_file": "Ekspor file preset",
+    "save_clean": "Simpan pembersihan",
+    "save_autotune": "Simpan autotune",
+    "save_pitch": "Simpan nada",
+    "save_index_2": "Simpan dampak indeks",
+    "save_resample": "Simpan resampling",
+    "save_filter": "Simpan filter median",
+    "save_envelope": "Simpan amplop suara",
+    "save_protect": "Simpan perlindungan suara",
+    "save_split": "Simpan pemisahan suara",
+    "filename_to_save": "Nama file untuk disimpan",
+    "upload_presets": "Unggah file preset",
+    "stop": "Hentikan proses",
+    "stop_separate": "Hentikan Pemisahan Musik",
+    "stop_convert": "Hentikan Konversi",
+    "stop_create_dataset": "Hentikan Pembuatan Dataset",
+    "stop_training": "Hentikan Pelatihan",
+    "stop_extract": "Hentikan Pemrosesan Data",
+    "stop_preprocess": "Hentikan Ekstraksi Data",
+    "not_found_presets": "Tidak ada file preset yang ditemukan di folder!",
+    "port": "Port {port} tidak tersedia! Menurunkan port satu...",
+    "empty_json": "{file}: Rusak atau kosong",
+    "thank": "Terima kasih telah melaporkan masalah, dan mohon maaf atas ketidaknyamanan yang ditimbulkan!",
+    "error_read_log": "Terjadi kesalahan saat membaca file log!",
+    "error_send": "Terjadi kesalahan saat mengirim laporan! Silakan hubungi saya di Discord: pham_huynh_anh!",
+    "report_bugs": "Laporkan Bug",
+    "agree_log": "Setuju untuk memberikan semua file log",
+    "error_info": "Deskripsi kesalahan",
+    "error_info_2": "Berikan informasi lebih lanjut tentang kesalahan",
+    "report_bug_info": "Laporkan bug yang ditemui selama penggunaan program",
+    "sr_info": "CATATAN: BEBERAPA FORMAT TIDAK MENDUKUNG LAJU DI ATAS 48000",
+    "report_info": "Jika memungkinkan, setuju untuk memberikan file log untuk membantu debugging.\n\nJika file log tidak diberikan, harap jelaskan kesalahan secara rinci, termasuk kapan dan di mana itu terjadi.\n\nJika sistem pelaporan ini juga gagal, Anda dapat menghubungi melalui [ISSUE]({github}) atau Discord: `pham_huynh_anh`",
+    "default_setting": "Terjadi kesalahan selama pemisahan, mengatur ulang semua pengaturan ke default...",
+    "dataset_folder1": "Harap masukkan nama folder data",
+    "checkpointing_err": "Parameter model pra-latih seperti laju sampel atau arsitektur tidak cocok dengan model yang dipilih.",
+    "start_onnx_export": "Memulai konversi model ke onnx...",
+    "convert_model": "Konversi Model",
+    "pytorch2onnx": "Mengonversi Model PYTORCH ke Model ONNX",
+    "pytorch2onnx_markdown": "Konversi model RVC dari pytorch ke onnx untuk mengoptimalkan konversi audio",
+    "error_readfile": "Terjadi kesalahan saat membaca file!",
+    "read_sf": "Baca file audio menggunakan soundfile...",
+    "read_librosa": "Baca file audio menggunakan librosa karena soundfile tidak didukung...",
+    "f0_onnx_mode": "Mode F0 ONNX",
+    "f0_onnx_mode_info": "Ekstraksi nada menggunakan model ONNX dapat membantu meningkatkan kecepatan",
+    "formantshift": "Pergeseran Nada dan Forman",
+    "formant_qfrency": "Frekuensi untuk Pergeseran Forman",
+    "formant_timbre": "Timbre untuk Transformasi Forman",
+    "time_frames": "Waktu (Frame)",
+    "Frequency": "Frekuensi (Hz)",
+    "f0_extractor_tab": "Ekstraksi F0",
+    "f0_extractor_markdown": "## Ekstraksi Nada",
+    "f0_extractor_markdown_2": "Ekstraksi nada F0 dimaksudkan untuk digunakan dalam inferensi konversi audio",
+    "start_extract": "Memulai proses ekstraksi...",
+    "extract_done": "Proses ekstraksi selesai!",
+    "f0_file": "Gunakan file F0 yang sudah diekstrak",
+    "upload_f0": "Unggah file F0",
+    "f0_file_2": "File F0",
+    "clean_f0_file": "Bersihkan file F0",
+    "embed_mode": "Mode Penyemat",
+    "embed_mode_info": "Ekstraksi penyematan menggunakan model yang berbeda",
+    "close": "Aplikasi sedang ditutup...",
+    "start_whisper": "Memulai pengenalan suara dengan Whisper...",
+    "whisper_done": "Pengenalan suara selesai!",
+    "process_audio": "Memproses audio awal...",
+    "process_done_start_convert": "Pemrosesan audio selesai! Melanjutkan dengan konversi audio...",
+    "convert_with_whisper": "Konversi Audio dengan Whisper",
+    "convert_with_whisper_info": "Konversi audio menggunakan model ucapan yang dilatih dengan model Whisper untuk pengenalan suara\n\nWhisper akan mengenali suara yang berbeda kemudian memotong suara individu dan menggunakan model RVC untuk mengonversi segmen tersebut\n\nModel Whisper mungkin tidak bekerja dengan baik yang dapat menyebabkan output aneh",
+    "num_spk": "Jumlah suara",
+    "num_spk_info": "Jumlah suara dalam audio",
+    "model_size": "Ukuran model Whisper",
+    "model_size_info": "Ukuran model Whisper\n\nModel besar dapat menghasilkan output aneh",
+    "editing": "Penyuntingan",
+    "inverting": "Pembalikan",
+    "steps": "Langkah",
+    "source_prompt": "Prompt Sumber",
+    "target_prompt": "Prompt",
+    "cfg_scale_src": "Prompt Sumber",
+    "cfg_scale_tar": "Prompt Target",
+    "t_start": "Tingkat Edit",
+    "save_compute": "Edit Efektif",
+    "error_edit": "Terjadi kesalahan saat mengedit musik latar {e}",
+    "start_edit": "Memulai penyuntingan musik latar {input_path}...",
+    "edit_success": "Selesai mengedit soundtrack setelah {time} dengan output {output_path}",
+    "audio_editing": "Menyunting Soundtrack",
+    "audio_editing_info": "## Menyunting Soundtrack Menggunakan Model Audioldm2",
+    "audio_editing_markdown": "Menyunting soundtrack menggunakan model Audioldm2 dapat membantu mengubah jenis instrumen di dalam soundtrack",
+    "target_prompt_info": "Jelaskan output edit yang diinginkan",
+    "cfg_scale_src_info": "Sejauh mana sumber memengaruhi output. Nilai lebih tinggi mempertahankan lebih banyak karakteristik dari sumber. Nilai lebih rendah memberikan sistem lebih banyak kebebasan untuk mengubah.",
+    "cfg_scale_tar_info": "Sejauh mana target memengaruhi hasil akhir. Nilai lebih tinggi memaksa hasil untuk mengikuti karakteristik target. Nilai lebih rendah menyeimbangkan sumber dan target.",
+    "audioldm2_model": "Model Audioldm2",
+    "audioldm2_model_info": "Pilih model Audioldm2 pilihan Anda\n\nMemuat bobot dan inferensi juga akan memakan waktu lama tergantung pada GPU Anda",
+    "source_prompt_info": "Opsional: Jelaskan input audio asli",
+    "t_start_info": "Tingkat koreksi yang lebih rendah akan lebih dekat dengan suara asli, lebih tinggi akan menjadi koreksi yang lebih kuat.",
+    "steps_label": "Jumlah langkah difusi",
+    "steps_info": "Nilai lebih tinggi (misalnya 200) menghasilkan output dengan kualitas lebih tinggi.",
+    "title": "Alat konversi dan pelatihan suara dan instrumen berkualitas tinggi dan berkinerja tinggi sederhana untuk orang Vietnam",
+    "fp16_not_support": "CPU tidak mendukung fp16 dengan baik, konversi fp16 -> fp32",
+    "precision": "Presisi",
+    "precision_info": "Presisi inferensi dan pelatihan model\n\nCatatan: CPU Tidak mendukung fp16\n\nUntuk RefineGAN dan MRF HIFIGAN saat mengonversi gunakan fp32 karena fp16 dapat menyebabkan output aneh",
+    "update_precision": "Perbarui Presisi",
+    "start_update_precision": "Mulai memperbarui presisi",
+    "deterministic": "Algoritma deterministik",
+    "deterministic_info": "Saat diaktifkan, algoritma yang sangat deterministik digunakan, memastikan bahwa setiap run dari data input yang sama akan menghasilkan hasil yang sama.\n\nSaat dinonaktifkan, algoritma yang lebih optimal mungkin dipilih tetapi mungkin tidak sepenuhnya deterministik, menghasilkan hasil pelatihan yang berbeda antara run.",
+    "benchmark": "Algoritma benchmark",
+    "benchmark_info": "Saat diaktifkan, ini akan menguji dan memilih algoritma yang paling dioptimalkan untuk perangkat keras dan ukuran tertentu. Ini dapat membantu mempercepat pelatihan.\n\nSaat dinonaktifkan, ini tidak akan melakukan optimasi algoritma ini, yang dapat mengurangi kecepatan tetapi memastikan bahwa setiap run menggunakan algoritma yang sama, yang berguna jika Anda ingin mereproduksi secara tepat.",
+    "font": "Font",
+    "font_info": "Font antarmuka\n\nKunjungi [Google Font](https://fonts.google.com) untuk memilih font favorit Anda.",
+    "change_font": "Ubah Font",
+    "f0_unlock": "Buka semua",
+    "f0_unlock_info": "Buka semua metode ekstraksi nada",
+    "stop_audioldm2": "Hentikan Audioldm2",
+    "srt": "File SRT kosong atau rusak!"
+}

assets/languages/ja-JP.json

@@ -0,0 +1,809 @@
+{
+    "set_lang": "表示言語が{lang}に設定されました。",
+    "no_support_gpu": "残念ながら、トレーニングをサポートする互換性のあるGPUがありません。",
+    "text": "テキスト",
+    "upload_success": "ファイル{name}が正常にアップロードされました。",
+    "download_url": "リンクからダウンロード",
+    "download_from_csv": "CSVモデルリポジトリからダウンロード",
+    "search_models": "モデルを検索",
+    "upload": "アップロード",
+    "option_not_valid": "無効なオプション！",
+    "list_model": "モデルリスト",
+    "success": "完了！",
+    "index": "インデックス",
+    "model": "モデル",
+    "zip": "圧縮",
+    "search": "検索",
+    "provide_file": "有効な{filename}ファイルを提供してください！",
+    "start": "{start}を開始...",
+    "not_found": "{name}が見つかりませんでした。",
+    "found": "{results}件の結果が見つかりました！",
+    "download_music": "音楽をダウンロード",
+    "download": "ダウンロード",
+    "provide_url": "URLを提供してください。",
+    "provide_name_is_save": "保存するモデル名を提供してください。",
+    "not_support_url": "モデルURLがサポートされていません。",
+    "error_occurred": "エラーが発生しました：{e}。",
+    "not_model": "アップロードしたファイルはモデルファイルではありません！",
+    "unable_analyze_model": "モデルを分析できません！",
+    "download_pretrain": "事前学習済みモデルをダウンロード中...",
+    "provide_pretrain": "事前学習済みモデルのURL{dg}を提供してください。",
+    "sr_not_same": "2つのモデルのサンプルレートが同じではありません。",
+    "architectures_not_same": "モデルを統合できません。アーキテクチャが同じではありません。",
+    "fushion_model": "モデル統合",
+    "model_fushion_info": "モデル{name}は{ratio}の比率で{pth_1}と{pth_2}から統合されました。",
+    "not_found_create_time": "作成時間が見つかりませんでした。",
+    "format_not_valid": "無効な形式。",
+    "read_info": "異なるアプリケーションでトレーニングされたモデルは、異なる情報生成したり、読み取り不可能な場合があります！",
+    "epoch": "エポック",
+    "step": "ステップ",
+    "sr": "サンプルレート",
+    "f0": "ピッチトレーニング",
+    "version": "バージョン",
+    "not_f0": "ピッチトレーニングは行われていません",
+    "trained_f0": "ピッチトレーニングが行われました",
+    "model_info": "モデル名: {model_name}\n\nモデル作成者: {model_author}\n\nエポック: {epochs}\n\nステップ: {steps}\n\nバージョン: {version}\n\nサンプルレート: {sr}\n\nピッチトレーニング: {pitch_guidance}\n\nハッシュ（ID）: {model_hash}\n\n作成時間: {creation_date_str}\n\nボコーダー: {vocoder}\n",
+    "input_not_valid": "有効な入力を提供してください！",
+    "output_not_valid": "有効な出力を提供してください！",
+    "apply_effect": "エフェクトを適用",
+    "enter_the_text": "音声変換するテキストを入力してください！",
+    "choose_voice": "音声を選択してください！",
+    "convert": "{name}を変換中...",
+    "separator_music": "音楽分離",
+    "notfound": "見つかりませんでした",
+    "turn_on_use_audio": "分離されたオーディオを使用するには有効にしてください",
+    "turn_off_convert_backup": "元の音声を使用するにはバックアップ音声変換を無効にしてください",
+    "turn_off_merge_backup": "元の音声を使用するにはバックアップ音声の統合を無効にしてください",
+    "not_found_original_vocal": "元のボーカルが見つかりませんでした！",
+    "convert_vocal": "音声を変換中...",
+    "convert_success": "音声変換が完了しました！",
+    "convert_backup": "バックアップ音声を変換中...",
+    "convert_backup_success": "バックアップ音声変換が完了しました！",
+    "merge_backup": "メイン音声とバックアップ音声を統合中...",
+    "merge_success": "統合が完了しました。",
+    "is_folder": "入力がフォルダです：フォルダ内のすべてのオーディオファイルを変換中...",
+    "not_found_in_folder": "フォルダ内にオーディオファイルが見つかりませんでした！",
+    "batch_convert": "バッチ変換中...",
+    "batch_convert_success": "バッチ変換が成功しました！",
+    "create": "作成",
+    "provide_name": "モデル名を提供してください。",
+    "not_found_data": "データが見つかりませんでした",
+    "not_found_data_preprocess": "処理済みのオーディオデータが見つかりませんでした。再度処��してください。",
+    "not_found_data_extract": "抽出されたオーディオデータが見つかりませんでした。再度抽出してください。",
+    "provide_pretrained": "事前学習済み{dg}を提供してください。",
+    "download_pretrained": "事前学習済み{dg}{rvc_version}オリジナルをダウンロード",
+    "not_found_pretrain": "事前学習済み{dg}が見つかりませんでした",
+    "not_use_pretrain": "事前学習済みモデルは使用されません",
+    "training": "トレーニング",
+    "rick_roll": "リックロールされたい場合はこちらをクリック :) ---> [RickRoll]({rickroll})",
+    "terms_of_use": "**プロジェクトを非倫理的、違法、または個人や組織に有害な目的で使用しないでください...**",
+    "exemption": "**ユーザーが規約を守らない、または違反した場合、契約、過失、その他の原因によるソフトウェアの使用や関連する取引に起因する、またはそれに関連する請求、損害、責任について一切責任を負いません。**",
+    "separator_tab": "音楽分離",
+    "4_part": "シンプルな音楽分離システムは、楽器、ボーカル、メインのボーカル、バックアップボーカルの4つの部分に分離できます",
+    "clear_audio": "クリーンオーディオ",
+    "separator_backing": "バックアップボーカルを分離",
+    "denoise_mdx": "MDXノイズ除去分離",
+    "use_mdx": "MDXを使用",
+    "dereveb_audio": "ボーカルのリバーブを除去",
+    "dereveb_backing": "バックアップのリバーブを除去",
+    "separator_model": "音楽分離モデル",
+    "separator_backing_model": "バックアップ分離モデル",
+    "shift": "シフト",
+    "shift_info": "高いほど品質は向上しますが、遅くなり、より多くのリソースを使用します",
+    "segments_size": "セグメントサイズ",
+    "segments_size_info": "高いほど品質は向上しますが、より多くのリソースを使用します",
+    "batch_size": "バッチサイズ",
+    "batch_size_info": "1つのトレーニングサイクルで同時に処理されるサンプルの数。高いとメモリオーバーフローが発生する可能性があります",
+    "mdx_batch_size_info": "一度に処理されるサンプルの数。バッチ処理は計算を最適化します。大きなバッチはメモリオーバーフローを引き起こす可能性があり、小さなバッチはリソース効率を下げます",
+    "overlap": "オーバーラップ",
+    "overlap_info": "予測ウィンドウ間のオーバーラップ量",
+    "export_format": "エクスポート形式",
+    "export_info": "オーディオファイルをエクスポートする形式",
+    "output_separator": "分離された出力",
+    "hop_length_info": "変換を行う際の時間転送ウィンドウを分析します。詳細な値はコンパクトですが、より多くの計算が必要です",
+    "drop_audio": "ここにオーディオをドロップ",
+    "drop_text": "ここにテキストファイルをドロップ",
+    "use_url": "YouTubeリンク",
+    "url_audio": "オーディオリンク",
+    "downloads": "ダウンロード",
+    "clean_strength": "オーディオクリーニング強度",
+    "clean_strength_info": "エクスポート中にボーカルをフィルタリングするためのオーディオクリーナーの強度",
+    "input_output": "オーディオ入力、出力",
+    "audio_path": "入力オーディオパス",
+    "refesh": "リフレッシュ",
+    "output_folder": "出力オーディオフォルダパス",
+    "output_folder_info": "オーディオが出力されるフォルダパスを入力",
+    "input_audio": "オーディオ入力",
+    "instruments": "楽器",
+    "original_vocal": "元のボーカル",
+    "main_vocal": "メインボーカル",
+    "backing_vocal": "バックアップボーカル",
+    "convert_audio": "オーディオ変換",
+    "convert_info": "トレーニング済みの音声モデルを使用してオーディオを変換",
+    "autotune": "オートチューン",
+    "use_audio": "分離されたオーディオを使用",
+    "convert_original": "元の音声を変換",
+    "convert_backing": "バックアップ音声を変換",
+    "not_merge_backing": "バックアップ音声を統合しない",
+    "merge_instruments": "楽器を統合",
+    "pitch": "ピッチ",
+    "pitch_info": "推奨：男性の声を女性に、またはその逆に変更するには12に設定",
+    "model_accordion": "モデルとインデックス",
+    "model_name": "モデルファイル",
+    "index_path": "インデックスファイル",
+    "index_strength": "インデックス強度",
+    "index_strength_info": "値が高いほど強度が増します。ただし、低い値はオーディオの人工的な効果を減らす可能性があります",
+    "output_path": "オーディオ出��パス",
+    "output_path_info": "出力パスを入力（.wav形式のままにしてください。変換中に自動修正されます）",
+    "setting": "一般設定",
+    "f0_method": "抽出方法",
+    "f0_method_info": "データ抽出に使用される方法",
+    "f0_method_hybrid": "ハイブリッド抽出方法",
+    "f0_method_hybrid_info": "2つ以上の異なる抽出タイプの組み合わせ",
+    "hubert_model": "埋め込みモデル",
+    "hubert_info": "埋め込みを補助する事前学習済みモデル",
+    "modelname": "モデル名",
+    "modelname_info": "独自のモデルがある場合、それをアップロードし、ここに名前を入力してください",
+    "split_audio": "オーディオを分割",
+    "autotune_rate": "オートチューンレート",
+    "autotune_rate_info": "オートチューンの調整レベル",
+    "resample": "リサンプル",
+    "resample_info": "最終サンプルレートへのリサンプル後処理。0はリサンプルなし。注：一部の形式は48000を超える速度をサポートしていません",
+    "filter_radius": "フィルタ半径",
+    "filter_radius_info": "3より大きい場合、メジアンフィルタリングが適用されます。値はフィルタ半径を表し、呼吸音やノイズを軽減できます。",
+    "volume_envelope": "ボリュームエンベロープ",
+    "volume_envelope_info": "入力ボリュームエンベロープを使用して出力ボリュームエンベロープを置き換えるか、ミックスします。1に近いほど出力エンベロープが使用されます",
+    "protect": "子音保護",
+    "protect_info": "明確な子音や呼吸音を保護し、オーディオの破損やその他のアーティファクトを防ぎます。この値を増やすと包括的な保護が得られます。減らすと保護が減少し、インデックス効果も最小限に抑えられます",
+    "output_convert": "変換されたオーディオ",
+    "main_convert": "メインボイスを変換",
+    "main_or_backing": "メインボイス + バックアップボイス",
+    "voice_or_instruments": "ボイス + 楽器",
+    "convert_text": "テキスト変換",
+    "convert_text_markdown": "## テキストを音声に変換",
+    "convert_text_markdown_2": "トレーニング済みの音声モデルを使用してテキストを音声に変換し、読み上げます",
+    "input_txt": "テキストファイル（.txt）からデータを入力",
+    "text_to_speech": "読み上げるテキスト",
+    "voice_speed": "読み上げ速度",
+    "voice_speed_info": "音声の速度",
+    "tts_1": "1. テキストを音声に変換",
+    "tts_2": "2. 音声変換",
+    "voice": "国ごとの音声",
+    "output_tts": "音声出力パス",
+    "output_tts_convert": "変換された音声出力パス",
+    "tts_output": "出力パスを入力",
+    "output_tts_markdown": "未変換および変換されたオーディオ",
+    "output_text_to_speech": "テキストから音声への変換で生成された音声",
+    "output_file_tts_convert": "モデルを使用して変換された音声",
+    "output_audio": "オーディオ出力",
+    "provide_output": "出力パスを入力",
+    "audio_effects": "オーディオエフェクト",
+    "apply_audio_effects": "## 追加のオーディオエフェクトを適用",
+    "audio_effects_edit": "オーディオにエフェクトを追加",
+    "reverb": "リバーブエフェクト",
+    "chorus": "コーラスエフェクト",
+    "delay": "ディレイエフェクト",
+    "more_option": "追加オプション",
+    "phaser": "フェイザーエフェクト",
+    "compressor": "コンプレッサーエフェクト",
+    "apply": "適用",
+    "reverb_freeze": "フリーズモード",
+    "reverb_freeze_info": "このモードを有効にすると、連続したエコーエフェクトが作成されます",
+    "room_size": "部屋のサイズ",
+    "room_size_info": "リバーブを作成するために部屋の空間を調整",
+    "damping": "ダンピング",
+    "damping_info": "リバーブの量を制御するために吸収レベルを調整",
+    "wet_level": "リバーブ信号レベル",
+    "wet_level_info": "リバーブ信号エフェクトのレベルを調整",
+    "dry_level": "オリジナル信号レベル",
+    "dry_level_info": "エフェクトなしの信号のレベルを調整",
+    "width": "オーディオ幅",
+    "width_info": "オーディオ空間の幅を調整",
+    "chorus_depth": "コーラス深度",
+    "chorus_depth_info": "より広いサウンドを作成するためにコーラスの強度を調整",
+    "chorus_rate_hz": "周波数",
+    "chorus_rate_hz_info": "コーラスエフェクトの振動速度を調整",
+    "chorus_mix": "信号ミックス",
+    "chorus_mix_info": "オリジナルと処理された信号のミックスレベルを調整",
+    "chorus_centre_delay_ms": "センター遅延（ms）",
+    "chorus_centre_delay_ms_info": "コーラスエフェクトを作成するためのステレオチャンネル間の遅延時間",
+    "chorus_feedback": "フィードバック",
+    "chorus_feedback_info": "オリジナル信号にフィードバックされるエフェクト信号の量を調整",
+    "delay_seconds": "ディレイ時間",
+    "delay_seconds_info": "オリジナルと処理された信号のディレイ時間を調整",
+    "delay_feedback": "ディレイフィードバック",
+    "delay_feedback_info": "繰り返しエフェクトを作成するフィードバック信号の量を調整",
+    "delay_mix": "ディレイ信号ミックス",
+    "delay_mix_info": "オリジナルと遅延信号のミックスレベルを調整",
+    "fade": "フェードエフェクト",
+    "bass_or_treble": "バスとトレブル",
+    "limiter": "閾値リミッター",
+    "distortion": "歪みエフェクト",
+    "gain": "オーディオゲイン",
+    "bitcrush": "ビットリダクションエフェクト",
+    "clipping": "クリッピングエフェクト",
+    "fade_in": "フェードインエフェクト（ms）",
+    "fade_in_info": "オーディオが0から通常レベルに徐々に増加する時間",
+    "fade_out": "フェードアウトエフェクト（ms）",
+    "fade_out_info": "音が通常からゼロにフェードする時間",
+    "bass_boost": "バスブーストレベル（dB）",
+    "bass_boost_info": "オーディオトラックのバスブーストの量",
+    "bass_frequency": "ローパスフィルターカットオフ周波数（Hz）",
+    "bass_frequency_info": "周波数が削減されます。低周波数はバスをより明確にします",
+    "treble_boost": "トレブルブーストレベル（dB）",
+    "treble_boost_info": "オーディオトラックの高音強化レベル",
+    "treble_frequency": "ハイパスフィルターカットオフ周波数（Hz）",
+    "treble_frequency_info": "周波数がフィルタリングされます。高い周波数ほど高い音が保持されます。",
+    "limiter_threashold_db": "リミッター閾値",
+    "limiter_threashold_db_info": "オーディオの最大レベルを制限して閾値を超えないようにします",
+    "limiter_release_ms": "リリース時間",
+    "limiter_release_ms_info": "制限された後にオーディオが戻る時間（ミリ秒）",
+    "distortion_info": "ノイズ効果を作成するために歪みのレベルを調整",
+    "gain_info": "信号の音量レベルを調整",
+    "clipping_threashold_db": "クリッピング閾値",
+    "clipping_threashold_db_info": "閾値を超える信号をトリミングし、歪んだ音を作成",
+    "bitcrush_bit_depth": "ビット深度",
+    "bitcrush_bit_depth_info": "ビット深度を下げてオーディオ品質を減らし、歪み効果を作成",
+    "phaser_depth": "フェイザー深度",
+    "phaser_depth_info": "エフェクトの深度を調整し、その強度に影響",
+    "phaser_rate_hz": "周波数",
+    "phaser_rate_hz_info": "フェイザーエフェクトの周波数を調整",
+    "phaser_mix": "信号ミックス",
+    "phaser_mix_info": "オリジナルと処理された信号のミックスレベルを調整",
+    "phaser_centre_frequency_hz": "センター周波数",
+    "phaser_centre_frequency_hz_info": "フェイザーエフェクトの中心周波数、調整される周波数に影響",
+    "phaser_feedback": "フィードバック",
+    "phaser_feedback_info": "エフェクトのフィードバックレベルを調整し、より強いまたは軽いフェイザーの感触を作成",
+    "compressor_threashold_db": "コンプレッサー閾値",
+    "compressor_threashold_db_info": "オーディオが圧縮される閾値レベル",
+    "compressor_ratio": "圧縮比率",
+    "compressor_ratio_info": "閾値を超えた場合のオーディオ圧縮レベルを調整",
+    "compressor_attack_ms": "アタック時間（ms）",
+    "compressor_attack_ms_info": "オーディオが閾値を超えた後に圧縮が効果を発揮し始める時間",
+    "compressor_release_ms": "リリース時間",
+    "compressor_release_ms_info": "圧縮された後にオーディオが通常に戻る時間",
+    "create_dataset_url": "オーディオリンク（複数のリンクの場合はカンマで区切る）",
+    "createdataset": "データセット作成",
+    "create_dataset_markdown": "## YouTubeからトレーニングデータセットを作成",
+    "create_dataset_markdown_2": "YouTubeリンクを使用してトレーニングデータセットを処理および作成",
+    "denoise": "ノイズ除去",
+    "skip": "スキップ",
+    "model_ver": "音声分離バージョン",
+    "model_ver_info": "ボーカル分離用のモデルバージョン",
+    "create_dataset_info": "データセット作成情報",
+    "output_data": "データセット出力",
+    "output_data_info": "作成後の出力データ",
+    "skip_start": "開始をスキップ",
+    "skip_start_info": "オーディオの最初の数秒をスキップ。複数のオーディオの場合はカンマで区切る",
+    "skip_end": "終了をスキップ",
+    "skip_end_info": "オーディオの最後の数秒をスキップ。複数のオーディオの場合はカンマで区切る",
+    "training_model": "モデルをトレーニング",
+    "training_markdown": "音声データのセットで音声モデルをトレーニングおよび構築",
+    "training_model_name": "トレーニング中のモデル名（特殊文字やスペースは避ける）",
+    "sample_rate": "サンプルレート",
+    "sample_rate_info": "モデルのサンプルレート",
+    "training_version": "モデルバージョン",
+    "training_version_info": "トレーニング中のモデルバージョン",
+    "training_pitch": "ピッチガイダンス",
+    "upload_dataset": "データセットをアップロード",
+    "preprocess_effect": "後処理",
+    "clear_dataset": "データセットをクリア",
+    "preprocess_info": "前処理情報",
+    "preprocess_button": "1. 処理",
+    "extract_button": "2. 抽出",
+    "extract_info": "データ抽出情報",
+    "total_epoch": "総エポック",
+    "total_epoch_info": "総トレーニングエポック",
+    "save_epoch": "保存頻度",
+    "save_epoch_info": "再トレーニングを可能にするためにトレーニング中にモデルを保存する頻度",
+    "create_index": "インデックス作成",
+    "index_algorithm": "インデックスアルゴリズム",
+    "index_algorithm_info": "インデックス作成のためのアルゴリズム",
+    "custom_dataset": "カスタムデータセットフォルダ",
+    "custom_dataset_info": "トレーニングデータ用のカスタムデータセットフォルダ",
+    "overtraining_detector": "過学習検出器",
+    "overtraining_detector_info": "モデルトレーニング中の過学習をチェック",
+    "cleanup_training": "クリーンアップ",
+    "cleanup_training_info": "モデルを最初から再トレーニングする必要がある場合にのみ有効にしてください。",
+    "cache_in_gpu": "GPUにキャッシュ",
+    "cache_in_gpu_info": "モデルをGPUキャッシュメモリに保存",
+    "dataset_folder": "データセットを含むフォルダ",
+    "threshold": "過学習閾値",
+    "setting_cpu_gpu": "CPU/GPU設定",
+    "gpu_number": "使用するGPUの数",
+    "gpu_number_info": "トレーニング中に使用するGPUの数",
+    "save_only_latest": "最新のみ保存",
+    "save_only_latest_info": "最新のDおよびGモデルを保存",
+    "save_every_weights": "すべてのモデルを保存",
+    "save_every_weights_info": "各エポック後にすべてのモデルを保存",
+    "gpu_info": "GPU情報",
+    "gpu_info_2": "トレーニング中に使用されるGPUの情報",
+    "cpu_core": "利用可能なCPUコアの数",
+    "cpu_core_info": "トレーニング中に使用されるCPUコアの数",
+    "not_use_pretrain_2": "事前トレーニングを使用しない",
+    "not_use_pretrain_info": "事前学習済みモデルを使用しない",
+    "custom_pretrain": "カスタム事前トレーニング",
+    "custom_pretrain_info": "事前トレーニング設定をカスタマイズ",
+    "pretrain_file": "事前学習済みモデルファイル{dg}",
+    "train_info": "トレーニング情報",
+    "export_model": "5. モデルをエクスポート",
+    "zip_model": "2. モデルを圧縮",
+    "output_zip": "圧縮後の出力ファイル",
+    "model_path": "モデルパス",
+    "model_ratio": "モデル比率",
+    "model_ratio_info": "一方に調整すると、モデルはその側に似るようになります",
+    "output_model_path": "モデル出力パス",
+    "fushion": "モデル統合",
+    "fushion_markdown": "## 2つのモデルを統合",
+    "fushion_markdown_2": "2つの音声モデルを1つのモデルに結合",
+    "read_model": "情報を読み込む",
+    "read_model_markdown": "## モデル情報を読み込む",
+    "read_model_markdown_2": "モデル内に記録された情報を取得",
+    "drop_model": "ここにモデルをドロップ",
+    "readmodel": "モデルを読み込む",
+    "model_path_info": "モデルファイルのパスを入力",
+    "modelinfo": "モデル情報",
+    "download_markdown": "## モデルをダウンロード",
+    "download_markdown_2": "音声モデル、事前学習済みモデル、埋め込みモデルをダウンロード",
+    "model_download": "音声モデルをダウンロード",
+    "model_url": "モデルへのリンク",
+    "15s": "約15秒お待ちください。システムは自動的に再起動します！",
+    "model_download_select": "モデルダウンロード方法を選択",
+    "model_warehouse": "モデルリポジトリ",
+    "get_model": "モデルを取得",
+    "name_to_search": "検索する名前",
+    "search_2": "検索",
+    "select_download_model": "検索し��モデルを選択（クリックして選択）",
+    "download_pretrained_2": "事前学習済みモデルをダウンロード",
+    "only_huggingface": "huggingface.coのみサポート",
+    "pretrained_url": "事前学習済みモデルリンク{dg}",
+    "select_pretrain": "事前学習済みモデルを選択",
+    "select_pretrain_info": "ダウンロードする事前学習済みモデルを選択",
+    "pretrain_sr": "モデルサンプルレート",
+    "drop_pretrain": "ここに事前学習済みモデル{dg}をドロップ",
+    "settings": "設定",
+    "settings_markdown": "## 追加設定",
+    "settings_markdown_2": "プロジェクトの追加機能をカスタマイズ",
+    "lang": "言語",
+    "lang_restart": "プロジェクトの表示言語（言語を変更すると、システムは15秒後に自動的に再起動して更新します）",
+    "change_lang": "言語を変更",
+    "theme": "テーマ",
+    "theme_restart": "インターフェースに表示されるテーマタイプ（テーマを変更すると、システムは15秒後に自動的に再起動して更新します）",
+    "theme_button": "テーマを変更",
+    "change_light_dark": "ライト/ダークモードを切り替え",
+    "tensorboard_url": "Tensorboard URL",
+    "errors_loading_audio": "オーディオの読み込みエラー：{e}",
+    "apply_error": "エフェクト適用中にエラーが発生しました：{e}",
+    "indexpath": "インデックスパス",
+    "split_total": "分割された総パーツ",
+    "process_audio_error": "オーディオ処理中にエラーが発生しました",
+    "merge_error": "オーディオ統合中にエラーが発生しました",
+    "not_found_convert_file": "処理済みファイルが見つかりませんでした",
+    "convert_batch": "バッチ変換中...",
+    "found_audio": "変換用のオーディオファイル{audio_files}が見つかりました。",
+    "not_found_audio": "オーディオファイルが見つかりませんでした！",
+    "error_convert": "オーディオ変換中にエラーが発生しました：{e}",
+    "convert_batch_success": "バッチ変換が{elapsed_time}秒で正常に完了しました。{output_path}",
+    "convert_audio_success": "ファイル{input_path}が{elapsed_time}秒で正常に変換されました。{output_path}",
+    "hybrid_methods": "メソッド{methods}を使用してf0ピッチを推定",
+    "method_not_valid": "無効なメソッド",
+    "read_faiss_index_error": "FAISSインデックスの読み込み中にエラーが発生しました：{e}",
+    "read_model_error": "モデルの読み込みに失敗しました：{e}",
+    "starting_download": "ダウンロードを開始",
+    "version_not_valid": "無効な音声分離バージョン",
+    "skip<audio": "スキップ時間がオーディオファイルの長さより短いためスキップできません",
+    "skip>audio": "スキップ時間がオーディオファイルの長さより長いためスキップできません",
+    "=<0": "スキップ時間が0以下でスキップされました",
+    "skip_warning": "スキップ時間（{seconds}秒）がオーディオの長さ（{total_duration}秒）を超えています。スキップします。",
+    "download_success": "ダウンロードが正常に完了しました",
+    "create_dataset_error": "トレーニングデータセット作成中にエラーが発生しました",
+    "create_dataset_success": "トレーニングデータセットの作成が{elapsed_time}秒で完了しました",
+    "skip_start_audio": "オーディオの開始を正常にスキップ：{input_file}",
+    "skip_end_audio": "オーディオの終了を正常にスキップ：{input_file}",
+    "merge_audio": "オーディオを含むすべてのパーツを統合",
+    "separator_process": "ボーカルを分離中：{input}...",
+    "not_found_main_vocal": "メインボーカルが見つかりませんでした！",
+    "not_found_backing_vocal": "バックアップボーカルが見つかりませんでした！",
+    "not_found_instruments": "楽器が見つかりませんでした",
+    "merge_instruments_process": "ボーカルと楽器を統合中...",
+    "dereverb": "ボーカルのリバーブを除去",
+    "dereverb_success": "ボーカルのリバーブ除去に成功しました",
+    "save_index": "インデックスファイルが保存されました",
+    "create_index_error": "インデックス作成中にエラーが発生しました",
+    "sr_not_16000": "サンプルレートは16000でなければなりません",
+    "gpu_not_valid": "無効なGPUインデックス。CPUに切り替えています。",
+    "extract_file_error": "ファイル抽出中にエラーが発生しました",
+    "extract_f0_method": "{num_processes}コアを使用して{f0_method}メソッドでピッチ抽出を開始...",
+    "extract_f0": "ピッチ抽出",
+    "extract_f0_success": "ピッチ抽出が{elapsed_time}秒で完了しました。",
+    "NaN": "NaN値が含まれており、無視されます。",
+    "start_extract_hubert": "埋め込み抽出を開始...",
+    "not_found_audio_file": "オーディオファイルが見つかりませんでした。正しいオーディオを提供してください。",
+    "process_error": "処理中にエラーが発生しました",
+    "extract_hubert_success": "埋め込み抽出が{elapsed_time}秒で完了しました。",
+    "export_process": "モデルパス",
+    "extract_error": "データ抽出中にエラーが発生しました",
+    "extract_success": "データ抽出に成功しました",
+    "min_length>=min_interval>=hop_size": "min_lengthはmin_intervalおよびhop_size以上でなければなりません",
+    "max_sil_kept>=hop_size": "max_sil_keptはhop_size以上でなければなりません",
+    "start_preprocess": "{num_processes}コアでデータ前処理を開始...",
+    "not_integer": "音声IDフォルダは整数でなければなりません。代わりに取得したのは",
+    "preprocess_success": "前処理が{elapsed_time}秒で完了しました。",
+    "preprocess_model_success": "モデルのデータ前処理が正常に完了しました",
+    "turn_on_dereverb": "バックアップボーカルのリバーブ除去には、リバーブ除去を有効にする必要があります",
+    "turn_on_separator_backing": "バックアップボーカル分離には、ボーカル分離を有効にする必要があります",
+    "backing_model_ver": "バックアップボーカル分離モデルバージョン",
+    "clean_audio_success": "オーディオが正常にクリーニングされました！",
+    "separator_error": "音楽分離中にエラーが発生しました",
+    "separator_success": "音楽分離が{elapsed_time}秒で完了しました",
+    "separator_process_2": "音楽分離を処理中",
+    "separator_success_2": "音楽分離に成功しました！",
+    "separator_process_backing": "バックアップボーカル分離を処理中",
+    "separator_process_backing_success": "バックアップボーカル分離に成功しました！",
+    "process_original": "元のボーカルのリバーブ除去を処理中...",
+    "process_original_success": "元のボーカルのリバーブ除去に成功しました！",
+    "process_main": "メインボーカルのリバーブ除去を処理中...",
+    "process_main_success": "メインボーカルのリバーブ除去に成功しました！",
+    "process_backing": "バックアップボーカルのリバーブ除去を処理中...",
+    "process_backing_success": "バックアップボーカルのリバーブ除去に成功しました！",
+    "save_every_epoch": "エポックごとに保存：",
+    "total_e": "総エポック：",
+    "dorg": "事前学習済みG：{pretrainG} | 事前学習済みD：{pretrainD}",
+    "training_f0": "ピッチガイダンス",
+    "not_gpu": "GPUが検出されませんでした。CPUに切り替えます（推奨されません）",
+    "not_found_checkpoint": "チェックポイントファイルが見つかりませんでした：{checkpoint_path}",
+    "save_checkpoint": "チェックポイント'{checkpoint_path}'を再読み込み（エポック{checkpoint_dict}）",
+    "save_model": "モデル'{checkpoint_path}'を保存（エポック{iteration}）",
+    "sr_does_not_match": "{sample_rate}サンプルレートがターゲット{sample_rate2}サンプルレートと一致しません",
+    "spec_error": "{spec_filename}から仕様を取得中にエラーが発生しました：{e}",
+    "time_or_speed_training": "時間={current_time} | トレーニング速度={elapsed_time_str}",
+    "savemodel": "モデル'{model_dir}'を保存（エポック{epoch}およびステップ{step}）",
+    "model_author": "モデルのクレジット：{model_author}",
+    "unregistered": "モデルが登録されていません",
+    "not_author": "モデルにクレジットがありません",
+    "training_author": "モデル作成者名",
+    "training_author_info": "モデルにクレジットを付けるために、ここに名前を入力してください",
+    "extract_model_error": "モデル抽出中にエラーが発生しました",
+    "start_training": "トレーニングを開始",
+    "import_pretrain": "事前学習済みモデル（{dg}）'{pretrain}'を読み込みました",
+    "not_using_pretrain": "事前学習済みモデル（{dg}）は使用されません",
+    "training_warning": "警告：生成された損失が次のエポックの損失下限閾値より低くなっています。",
+    "overtraining_find": "エポック{epoch}で過学習が検出されました。スムーズジェネレータ損失{smoothed_value_gen}、スムーズディスクリミネータ損失{smoothed_value_disc}",
+    "best_epoch": "新しい最高エポック{epoch}：スムーズジェネレータ損失{smoothed_value_gen}、スムーズディスクリミネータ損失{smoothed_value_disc}",
+    "success_training": "{epoch}エポック、{global_step}ステップ、総ジェネレータ損失{loss_gen_all}でトレーニングが完了しました。",
+    "training_info": "最低ジェネレータ損失：{lowest_value_rounded}（エポック{lowest_value_epoch}、ステップ{lowest_value_step}）",
+    "model_training_info": "{model_name} | エポック={epoch} | ステップ={global_step} | {epoch_recorder} | 最低値={lowest_value_rounded}（エポック{lowest_value_epoch}、ステップ{lowest_value_step}） | 過学習までの残りエポック：g/合計：{remaining_epochs_gen} d/合計：{remaining_epochs_disc} | スムーズジェネレータ損失={smoothed_value_gen} | スムーズディスクリミネータ損失={smoothed_value_disc}",
+    "model_training_info_2": "{model_name} | エポック={epoch} | ステップ={global_step} | {epoch_recorder} | 最低値={lowest_value_rounded}（エポック{lowest_value_epoch}、ステップ{lowest_value_step}）",
+    "model_training_info_3": "{model_name} | エポック={epoch} | ステップ={global_step} | {epoch_recorder}",
+    "training_error": "モデルトレーニング中にエラーが発生しました：",
+    "separator_info": "出力パス：{output_dir}、出力形式：{output_format}で初期化",
+    "output_dir_is_none": "出力フォルダが指定されていません。現在の作業ディレクトリを使用します。",
+    ">0or=1": "正規化閾値は0より大きく、1以下でなければなりません。",
+    "output_single": "単一ルート出力が要求されました。1つのファイル（{output_single_stem}）のみが書き込まれます",
+    "step2": "2番目のステップは波形の代わりにスペクトログラムを使用して反転されます。これにより品質が向上する可能性がありますが、若干遅くなります。",
+    "name_ver": "バージョン{name}",
+    "os": "オペレーティングシステム",
+    "platform_info": "システム：{system_info} 名前：{node} リリース：{release} マシン：{machine} プロセッサ：{processor}",
+    "none_ffmpeg": "FFmpegがインストールされていません。このパッケージを使用するにはFFmpegをインストールしてください。",
+    "install_onnx": "ONNX Runtimeパッケージ{pu}がインストールされました。バージョン",
+    "running_in_cpu": "ハードウェアアクセラレーションを構成できません。CPUモードで実行します",
+    "running_in_cuda": "TorchでCUDAが利用可能です。TorchデバイスをCUDAに設定",
+    "onnx_have": "ONNXruntimeが利用可能です{have}、アクセラレーションを有効にします",
+    "onnx_not_have": "ONNXruntimeで{have}が利用できません。アクセラレーションは有効になりません",
+    "python_not_install": "Pythonパッケージ：{package_name}がインストールされていません",
+    "hash": "モデルファイル{model_path}のハッシュを計算中",
+    "ioerror": "ハッシュを計算するためにモデルファイルを-10 MBシークまたは読み込み中にIOErrorが発生しました：{e}",
+    "cancel_download": "ファイルが{output_path}に既に存在するため、ダウンロードをスキップします",
+    "download_model": "{url}から{output_path}にファイルをダウンロード中。タイムアウトは300秒",
+    "download_error": "{url}からのファイルダウンロードに失敗しました。レスポンスコード：{status_code}",
+    "vip_model": "モデル：'{model_friendly_name}'は、Anjok07が有料サブスクライバー専用に意図したプレミアムモデルです。",
+    "vip_print": "こんにちは、サブスクライブしていない場合、UVRの開発者であるAnjok07をサポートするためにこちらでサブスクライブを検討してください：https://patreon.com/uvr",
+    "search_model": "サポートされているモデルのリストでモデル{model_filename}を検索中",
+    "load_download_json": "ダウンロードモデルリストが読み込まれました",
+    "single_model": "単一モデルファイルが特定されました：{model_friendly_name}",
+    "not_found_model": "UVRリポジトリでモデルが見つかりませんでした。オーディオモデル分離リポジトリからダウンロードを試みます...",
+    "single_model_path": "単一モデルファイルのパスを返します：{model_path}",
+    "find_model": "入力ファイル名{model_filename}がマルチファイルモデルで発見されました：{model_friendly_name}",
+    "find_models": "マルチファイルモデルが特定されました：{model_friendly_name}、ファイルをダウンロードするために反復処理します",
+    "find_path": "構成ペアのダウンロードパスを特定しようとしています",
+    "not_found_model_warehouse": "UVRリポジトリでモデルが見つかりませんでした。オーディオモデ��分離リポジトリからダウンロードを試みます...",
+    "yaml_warning": "指定したモデル名{model_filename}は、モデルファイルではなくモデル構成ファイルです。",
+    "yaml_warning_2": "この構成ファイルに一致するモデルを見つけました：{config_key}、そのモデルファイルを使用します。",
+    "yaml_warning_3": "将来の混乱や一貫性のない動作を避けるために、実際のモデルファイル名を指定してください。",
+    "yaml_debug": "UVRリポジトリで構成YAMLモデルファイルが見つかりませんでした。オーディオモデル分離リポジトリからダウンロードを試みます...",
+    "download_model_friendly": "モデル{model_friendly_name}のすべてのファイルがダウンロードされました。元のパス{model_path}を返します",
+    "not_found_model_2": "サポートされているファイルでモデルファイル{model_filename}が見つかりませんでした",
+    "load_yaml": "パス{model_data_yaml_filepath}のYAMLからモデルデータを読み込み中",
+    "load_yaml_2": "YAMLファイルからモデルデータが読み込まれました：{model_data}",
+    "hash_md5": "UVRデータからモデルパラメータを特定するためにモデルファイルのMD5ハッシュを計算中...",
+    "model_hash": "モデル{model_path}のハッシュは{model_hash}です",
+    "mdx_data": "MDXモデルデータパスが{mdx_model_data_path}に設定されました",
+    "load_mdx": "UVRモデルデータファイルからMDXモデルパラメータを読み込み中...",
+    "model_not_support": "サポートされていないモデルファイル：MDXボールトのUVRモデルデータでMD5ハッシュ{model_hash}のパラメータが見つかりませんでした。",
+    "uvr_json": "ハッシュ{model_hash}のUVR JSONからモデルデータが読み込まれました：{model_data}",
+    "loading_model": "モデル{model_filename}を読み込み中...",
+    "download_model_friendly_2": "ダウンロードされたモデル、フレンドリー名：{model_friendly_name}、モデルパス：{model_path}",
+    "model_type_not_support": "サポートされていないモデルタイプ：{model_type}",
+    "demucs_not_support_python<3.10": "DemucsモデルにはPythonバージョン3.10以上が必要です。",
+    "import_module": "モデルタイプのモジュールをインポート中",
+    "initialization": "モデルタイプの分離クラスの初期化",
+    "loading_model_success": "モデル読み込みが完了しました。",
+    "loading_model_duration": "モデル読み込み時間",
+    "starting_separator": "オーディオファイルパスの分離プロセスを開始",
+    "normalization": "正規化閾値が{normalization_threshold}に設定され、クリッピングを防ぐために波形がこの最大振幅にスケールダウンされます。",
+    "loading_separator_model": "モデル{model_filename}をダウンロード中...",
+    "separator_success_3": "分離プロセスが完了しました。",
+    "separator_duration": "分離時間",
+    "downloading_model": "ダウンロードされたモデル、タイプ：{model_type}、フレンドリー名：{model_friendly_name}、モデルパス：{model_path}、モデルデータ：{model_data_dict_size}アイテム",
+    "demucs_info": "Demucsパラメータ：セグメントサイズ = {segment_size}、セグメントサイズ有効 = {segments_enabled}",
+    "demucs_info_2": "Demucsパラメータ：予測回数 = {shifts}、オーバーラップ = {overlap}",
+    "start_demucs": "Demucs分離器の初期化が完了しました",
+    "start_separator": "分離プロセスを開始...",
+    "prepare_mix": "ミックスを準備中...",
+    "demix": "デミックス用のミックスが準備されました。形状：{shape}",
+    "cancel_mix": "デミックスのためにモデルを読み込み中...",
+    "model_review": "モデルが読み込まれ、評価モードに設定されました。",
+    "del_gpu_cache_after_demix": "デミックス後にモデルとGPUキャッシュをクリアしました。",
+    "process_output_file": "出力ファイルを処理中...",
+    "source_length": "ソース配列を処理中、ソースの長さは{source_length}",
+    "process_ver": "ソースバージョンを処理中...",
+    "set_map": "ソースマップを{part}パーツに設定...",
+    "process_all_part": "すべてのルートパーツを処理中...",
+    "skip_part": "out_single_stemが{output_single_stem}に設定されているため、ルートパーツ{stem_name}をスキップ...",
+    "starting_demix_demucs": "demix_demucsでデミックスプロセスを開始...",
+    "model_infer": "モデル推論を実行中...",
+    "name_not_pretrained": "{name}は事前学習済みモデルまたはモデルバンドルではありません。",
+    "invalid_checksum": "ファイル{path}のチェックサムが無効です。期待値{checksum}、実際の値{actual_checksum}",
+    "mdx_info": "MDXパラメータ：バッチサイズ = {batch_size}、セグメントサイズ = {segment_size}",
+    "mdx_info_2": "MDXパラメータ：オーバーラップ = {overlap}、ホップ長 = {hop_length}、ノイズ除去有効 = {enable_denoise}",
+    "mdx_info_3": "MDXパラメータ",
+    "load_model_onnx": "推論用のONNXモデルを読み込み中...",
+    "load_model_onnx_success": "ONNXruntime推論セッションを使用してモデルを正常に読み込みました。",
+    "onnx_to_pytorch": "dim_tとセグメントサイズが一致しないため、ONNXからPyTorchにモデルを変換しました。処理が遅くなる可能性があります。",
+    "stft": "逆STFTが適用されました。形状の結果を返します",
+    "no_denoise": "ノイズ除去なしでスペクトラム上でモデルを実行。",
+    "mix": "入力オーディオファイル{audio_file_path}のミックスを準備中...",
+    "normalization_demix": "デミックス前にミックスを正規化中...",
+    "mix_success": "ミックス準備が完了しました。",
+    "primary_source": "プライマリソースを正規化中...",
+    "secondary_source": "セカンダリソースを生成中：互換モードでミキシング",
+    "invert_using_spec": "invert_USE_specがTrueに設定されている場合、スペクトラムを使用してセカンダリステムを反転",
+    "invert_using_spec_2": "初期変換ミックスから変換されたステムを引くことでセカンダリステムを反転",
+    "enable_denoise": "ノイズ除去のために正と負のスペクトラムの両方でモデルを実行。",
+    "is_match_mix": "is_match_mix：STFT出力から直接取得された予測スペクトラム。",
+    "save_secondary_stem_output_path": "セカンダリステム{stem_name}を{stem_output_path}に保存中...",
+    "starting_model": "モデル設定を初期化中...",
+    "input_info": "モデル入力パラメータ",
+    "model_settings": "モデル設定",
+    "initialize_mix": "is_ckpt = {is_ckpt}でミックスを初期化。初期ミックス形状：{shape}",
+    "!=2": "2チャンネルのオーディオ信号を期待しましたが、{shape}チャンネルを取得しました",
+    "process_check": "チェックポイントモードで処理中...",
+    "stft_2": "ミックスにSTFTを適用。スペクトラム形状：{shape}",
+    "cache": "パディングを計算",
+    "shape": "パディング後のミックス形状：{shape}、パーツ数：{num_chunks}",
+    "process_no_check": "ノーチェックポイントモードで処理中...",
+    "n_sample_or_pad": "サンプル数：{n_sample}、計算されたパディング：{pad}",
+    "shape_2": "パディング後のミックス形状",
+    "process_part": "パーツ{mix_waves}を処理：開始{i}、終了{ii}",
+    "mix_waves_to_tensor": "mix_wavesをテンソルに変換。テンソル形状：{shape}",
+    "mix_match": "ミックスモードマッチ；補償係数を適用。",
+    "tar_waves": "tar_waves。形状",
+    "normalization_2": "結果を除数で割って正規化。",
+    "mix_wave": "mix_waveバッチを処理中",
+    "mix_or_batch": "バッチにミックスパーツ。バッチ数",
+    "demix_is_match_mix": "is_match_mixでデミックスプロセスを開始、",
+    "mix_shape": "ルートミックスパーツが保存されました。形状",
+    "chunk_size_or_overlap": "互換ミキシングのチャンクサイズ：{chunk_size}、オーバーラップ：{overlap}",
+    "chunk_size_or_overlap_standard": "標準チャンクサイズ：{chunk_size}、オーバーラップ：{overlap}",
+    "calc_size": "生成されたサイズを計算",
+    "window": "このセグメントにウィンドウを適用。",
+    "process_part_2": "セグメント{total}/{total_chunks}を処理：開始{start}、終了{end}",
+    "all_process_part": "処理するセグメントの総数",
+    "step_or_overlap": "パーツを処理するステップサイズ：{step}、オーバーラップは{overlap}に設定。",
+    "mix_cache": "パディングでミックスを準備。ミックス形状",
+    "dims": "奇数の次元（dim={dims}）ではsin/cos位置エンコーディングを使用できません",
+    "activation": "アクティベーションはrelu/geluでなければならず、{activation}ではありません",
+    "length_or_training_length": "提供された長さ{length}がトレーニング期間{training_length}を超えています",
+    "type_not_valid": "無効なタイプ",
+    "del_parameter": "存在しないパラメータを削除",
+    "info": "共通パラメータ：モデル名 = {model_name}、モデルパス = {model_path}",
+    "info_2": "共通パラメータ：出力パス = {output_dir}、出力形式 = {output_format}",
+    "info_3": "共通パラメータ：正規化閾値 = {normalization_threshold}",
+    "info_4": "共通パラメータ：��イズ除去有効 = {enable_denoise}、単一ステム出力 = {output_single_stem}",
+    "info_5": "共通パラメータ：スペックを使用した反転 = {invert_using_spec}、サンプルレート = {sample_rate}",
+    "info_6": "共通パラメータ：プライマリルート名 = {primary_stem_name}、セカンダリルート名 = {secondary_stem_name}",
+    "info_7": "共通パラメータ：カラオケモード = {is_karaoke}、BVモデル = {is_bv_model}、BVモデルリバランシング = {bv_model_rebalance}",
+    "success_process": "ルート{stem_name}の処理が完了し、オーディオを書き込み中...",
+    "load_audio": "ファイルからオーディオを読み込み中",
+    "load_audio_success": "オーディオが読み込まれました。サンプルレート：{sr}、オーディオ形状：{shape}",
+    "convert_mix": "提供されたミックス配列を変換中。",
+    "convert_shape": "変換されたミックス形状：{shape}",
+    "audio_not_valid": "オーディオファイル{audio_path}が空または無効です",
+    "audio_valid": "オーディオファイルは有効でデータを含んでいます。",
+    "mix_single": "ミックスがモノラルです。ステレオに変換します。",
+    "convert_mix_audio": "ステレオミックスに変換しました。",
+    "mix_success_2": "ミックス準備が完了しました。",
+    "duration": "オーディオの長さは{duration_hours}時間（{duration_seconds}秒）です。",
+    "write": "{name}を使用して書き込みます。",
+    "write_audio": "ルートパスで{name}を書き込み中：",
+    "original_not_valid": "警告：元のソース配列がほぼ無音または空です。",
+    "shape_audio": "処理前のオーディオデータ形状",
+    "convert_data": "変換前のデータタイプ",
+    "original_source_to_int16": "original_sourceをint16に変換しました。",
+    "shape_audio_2": "インターリーブされたオーディオデータ形状",
+    "create_audiosegment": "AudioSegmentの作成に成功しました。",
+    "create_audiosegment_error": "AudioSegment作成中の特定エラー",
+    "export_error": "オーディオファイルのエクスポートエラー",
+    "export_success": "オーディオファイルを正常にエクスポートしました",
+    "clean": "ガベージコレクションを実行中...",
+    "clean_cache": "{name}キャッシュをクリア中...",
+    "del_path": "入力オーディオファイルのパス、ソース、ルートを削除中...",
+    "not_success": "プロセスが成功しませんでした：",
+    "resample_error": "リサンプリング中のエラー",
+    "shapes": "形状",
+    "wav_resolution": "解像度タイプ",
+    "warnings": "警告：非常に積極的な値が検出されました",
+    "warnings_2": "警告：波形入力でNaNまたは無限値が検出されました。形状",
+    "process_file": "ファイルを処理中... \n",
+    "save_instruments": "リバーストラックを保存中...",
+    "assert": "オーディオファイルは同じ形状でなければなりません - ミックス：{mixshape}、楽器：{instrumentalshape}",
+    "rubberband": "Rubberband CLIを実行できません。Rubberband-CLIがインストールされていることを確認してください。",
+    "rate": "レートは厳密に正でなければなりません",
+    "gdown_error": "ファイルの公開リンクを取得できませんでした。リンクの権限を「リンクを知っている全員」に変更する必要があるか、既に過剰なアクセス権限がある可能性があります。",
+    "to": "宛先：",
+    "gdown_value_error": "パスまたはIDを指定する必要があります",
+    "missing_url": "URLがありません",
+    "mac_not_match": "MACが一致しません",
+    "file_not_access": "ファイルにアクセスできません",
+    "int_resp==-3": "リクエストが失敗しました、再試行中",
+    "search_separate": "別々のファイルを検索...",
+    "found_choice": "{choice}が見つかりました",
+    "separator==0": "別々のファイルが見つかりませんでした！",
+    "select_separate": "別々のファイルを選択",
+    "start_app": "インターフェースを開始...",
+    "provide_audio": "オーディオファイルのパスを入力してください",
+    "set_torch_mps": "TorchデバイスをMPSに設定",
+    "googletts": "Googleを使用してテキストを変換",
+    "pitch_info_2": "テキストから音声への変換のピッチ調整",
+    "waveform": "波形は（フレーム数、チャンネル数）の形状でなければなりません",
+    "freq_mask_smooth_hz": "freq_mask_smooth_hzは少なくとも{hz}Hzでなければなりません",
+    "time_mask_smooth_ms": "time_mask_smooth_msは少なくとも{ms}msでなければなりません",
+    "x": "xはより大きくなければなりません",
+    "xn": "xnはより大きくなければなりません",
+    "not_found_pid": "プロセスが見つかりませんでした！",
+    "end_pid": "プロセスが終了しました！",
+    "not_found_separate_model": "分離モデルファイルが見つかりませんでした！",
+    "not_found_pretrained": "事前学習済みモデルファイルが見つかりませんでした！",
+    "not_found_log": "ログファイルが見つかりませんでした！",
+    "not_found_predictors": "予測モデルファイルが見つかりませんでした！",
+    "not_found_embedders": "埋め込みモデルファイルが見つかりませんでした！",
+    "provide_folder": "有効なフォルダを提供してください！",
+    "empty_folder": "データフォルダが空です！",
+    "vocoder": "ボコーダー",
+    "vocoder_info": "ボコーダーは音声変換のために人間の音声信号を分析および合成します。\n\nデフォルト：このオプションはHiFi-GAN-NSFで、すべてのRVCと互換性があります\n\nMRF-HiFi-GAN：高忠実度。\n\nRefineGAN：優れた音質。",
+    "code_error": "エラー：ステータスコードを受信しました",
+    "json_error": "エラー：レスポンスを解析できません。",
+    "requests_error": "リクエストが失敗しました：{e}",
+    "memory_efficient_training": "メモリ効率の高いトレーニングを使用",
+    "not_use_pretrain_error_download": "ファイルが欠落しているため、事前学習済みモデルは使用されません",
+    "provide_file_settings": "プリセット設定ファイルを提供してください！",
+    "load_presets": "プリセットファイル{presets}を読み込みました",
+    "provide_filename_settings": "プリセットファイル名を提供してください！",
+    "choose1": "エクスポートするものを1つ選択してください！",
+    "export_settings": "プリセットファイル{name}をエクスポートしました",
+    "use_presets": "プリセットファイルを使用",
+    "file_preset": "プリセットファイル",
+    "load_file": "ファイルを読み込む",
+    "export_file": "プリセットファイルをエクスポート",
+    "save_clean": "クリーニングを保存",
+    "save_autotune": "オートチューンを保存",
+    "save_pitch": "ピッチを保存",
+    "save_index_2": "インデックスの影響を保存",
+    "save_resample": "リサンプリングを保存",
+    "save_filter": "メディアンフィルターを保存",
+    "save_envelope": "サウンドエンベロープを保存",
+    "save_protect": "サウンド保護を保存",
+    "save_split": "サウンド分割を保存",
+    "filename_to_save": "保存するファイル名",
+    "upload_presets": "プリセットファイルをアップロード",
+    "stop": "プロセスを停止",
+    "stop_separate": "音楽分離を停止",
+    "stop_convert": "変換を停止",
+    "stop_create_dataset": "データセット作成を停止",
+    "stop_training": "トレーニングを停止",
+    "stop_extract": "データ処理を停止",
+    "stop_preprocess": "データ抽出を停止",
+    "not_found_presets": "フォルダにプリセットファイルが見つかりませんでした！",
+    "port": "ポート{port}が利用できません！ポートを1つ下げます...",
+    "empty_json": "{file}：破損または空",
+    "thank": "問題を報告してくれてありがとう。ご不便をおかけして申し訳ありません！",
+    "error_read_log": "ログファイルの読み込み中にエラーが発生しました！",
+    "error_send": "レポート送信中にエラーが発生しました！Discordでご連絡ください：pham_huynh_anh！",
+    "report_bugs": "バグを報告",
+    "agree_log": "すべてのログファイルを提供することに同意",
+    "error_info": "エラーの説明",
+    "error_info_2": "エラーについての詳細情報を提供",
+    "report_bug_info": "プログラム使用中に発生したバグを報告",
+    "sr_info": "注：一部の形式は48000を超えるレートをサポートしていません",
+    "report_info": "可能であれば、デバッグを助けるためにログファイルを提供することに同意してください。\n\nログファイルが提供されない場合、エラーがいつどこで発生したかを詳細に説明してください。\n\nこのレポートシステムも失敗した場合、[ISSUE]({github})またはDiscord：`pham_huynh_anh`で連絡できます",
+    "default_setting": "分離中にエラーが発生しました。すべての設定をデフォルトにリセットします...",
+    "dataset_folder1": "データフォルダ名を入力してください",
+    "checkpointing_err": "サンプルレートやアーキテクチャなどの事前学習済みモデルパラメータが選択したモデルと一致しません。",
+    "start_onnx_export": "モデルをonnxに変換開始...",
+    "convert_model": "��デルを変換",
+    "pytorch2onnx": "PYTORCHモデルをONNXモデルに変換",
+    "pytorch2onnx_markdown": "オーディオ変換を最適化するためにRVCモデルをpytorchからonnxに変換",
+    "error_readfile": "ファイルの読み込み中にエラーが発生しました！",
+    "read_sf": "soundfileを使用してオーディオファイルを読み込む...",
+    "read_librosa": "soundfileがサポートされていないため、librosaを使用してオーディオファイルを読み込む...",
+    "f0_onnx_mode": "F0 ONNXモード",
+    "f0_onnx_mode_info": "ONNXモデルを使用してピッチを抽出すると、速度が向上する可能性があります",
+    "formantshift": "ピッチとフォルマントシフト",
+    "formant_qfrency": "フォルマントシフトの周波数",
+    "formant_timbre": "フォルマント変換の音色",
+    "time_frames": "時間（フレーム）",
+    "Frequency": "周波数（Hz）",
+    "f0_extractor_tab": "F0抽出",
+    "f0_extractor_markdown": "## ピッチ抽出",
+    "f0_extractor_markdown_2": "F0ピッチ抽出はオーディオ変換推論に使用することを目的としています",
+    "start_extract": "抽出プロセスを開始...",
+    "extract_done": "抽出プロセスが完了しました！",
+    "f0_file": "事前に抽出されたF0ファイルを使用",
+    "upload_f0": "F0ファイルをアップロード",
+    "f0_file_2": "F0ファイル",
+    "clean_f0_file": "F0ファイルをクリーンアップ",
+    "embed_mode": "埋め込みモード",
+    "embed_mode_info": "異なるモデルを使用して埋め込みを抽出",
+    "close": "アプリケーションを終了中...",
+    "start_whisper": "Whisperで音声認識を開始...",
+    "whisper_done": "音声認識が完了しました！",
+    "process_audio": "オーディオを前処理中...",
+    "process_done_start_convert": "オーディオ処理が完了しました！オーディオ変換に進みます...",
+    "convert_with_whisper": "Whisperでオーディオを変換",
+    "convert_with_whisper_info": "Whisperモデルで音声認識を使用してトレーニング済みの音声モデルでオーディオを変換\n\nWhisperは異なる音声を認識し、個々の音声を切り出し、RVCモデルを使用してそれらのセグメントを変換します\n\nWhisperモデルが正しく動作しない場合、異常な出力が発生する可能性があります",
+    "num_spk": "音声の数",
+    "num_spk_info": "オーディオ内の音声の数",
+    "model_size": "Whisperモデルサイズ",
+    "model_size_info": "Whisperモデルサイズ\n\n大きなモデルは異常な出力を生成する可能性があります",
+    "editing": "編集",
+    "inverting": "反転",
+    "steps": "ステップ",
+    "source_prompt": "ソースプロンプト",
+    "target_prompt": "プロンプト",
+    "cfg_scale_src": "ソースプロンプト",
+    "cfg_scale_tar": "ターゲットプロンプト",
+    "t_start": "編集レベル",
+    "save_compute": "効果的な編集",
+    "error_edit": "バックグラウンドミュージックの編集中にエラーが発生しました：{e}",
+    "start_edit": "バックグラウンドミュージック{input_path}の編集を開始...",
+    "edit_success": "{time}後にサウンドトラックの編集が完了しました。出力{output_path}",
+    "audio_editing": "サウンドトラックの編集",
+    "audio_editing_info": "## Audioldm2モデルを使用してサウンドトラックを編集",
+    "audio_editing_markdown": "Audioldm2モデルを使用してサウンドトラックを編集すると、サウンドトラック内の楽器の種類を変更できます",
+    "target_prompt_info": "希望する編集出力を説明",
+    "cfg_scale_src_info": "ソースが出力にどの程度影響するかを示します。高い値はソースの特性をより多く保持します。低い値はシステムに変換の自由度を与えます。",
+    "cfg_scale_tar_info": "ターゲットが最終結果にどの程度影響するかを示します。高い値はターゲットの特性を強制的に反映します。低い値はソースとターゲットをバランスさせます。",
+    "audioldm2_model": "Audioldm2モデル",
+    "audioldm2_model_info": "お好みのAudioldm2モデルを選択\n\nウェイトの読み込みと推論もGPUに応じて時間がかかります",
+    "source_prompt_info": "オプション：元のオーディオ入力を説明",
+    "t_start_info": "低い補正レベルは元のサウンドに近く、高いほど強い補正になります。",
+    "steps_label": "拡散ステップ数",
+    "steps_info": "高い値（例：200）は高品質の出力を生成します。",
+    "title": "ベトナム人向けのシンプルで高品質、高性能な音声および楽器変換およびトレーニングツール",
+    "fp16_not_support": "CPUはfp16を十分にサポートしていません。fp16 -> fp32に変換",
+    "precision": "精度",
+    "precision_info": "推論およびモデルトレーニングの精度\n\n注：CPUはfp16をサポートしていません\n\nRefineGANおよびMRF HIFIGANで変換する場合は、fp16が異常な出力を引き起こす可能性があるため、fp32を使用してください",
+    "update_precision": "精度を更新",
+    "start_update_precision": "精度の更新を開始",
+    "deterministic": "決定論的アルゴリズム",
+    "deterministic_info": "有効にすると、非常に決定論的なアルゴリズムが使用され、同じ入力データの各実行が同じ結果を生成します。\n\n無効にすると、より最適なアルゴリズムが選択される可能性がありますが、完全に決定論的ではなく、実行間で異なるトレーニング結果になる可能性があります。",
+    "benchmark": "ベンチマークアルゴリズム",
+    "benchmark_info": "有効にすると、特定のハードウェアとサイズに対して最も最適化されたアルゴリズムをテストして選択します。これによりトレーニングが高速化します。\n\n無効にすると、このアルゴリズムの最適化は行われず、速度は低下しますが、各実行で同じアルゴリズムが使用されるため、正確に再現したい場合に便利です。",
+    "font": "フォント",
+    "font_info": "インターフェースフォント\n\n[Google Font](https://fonts.google.com)にアクセスして好きなフォントを選択してください。",
+    "change_font": "フォントを変更",
+    "f0_unlock": "すべてをアンロック",
+    "f0_unlock_info": "すべてのピッチ抽出方法をアンロック",
+    "stop_audioldm2": "Audioldm2を停止",
+    "srt": "SRTファイルが空または破損しています！"
+}

assets/languages/vi-VN.json

@@ -0,0 +1,809 @@
+{
+    "set_lang": "Đã đặt ngôn ngữ hiển thị là {lang}",
+    "no_support_gpu": "Thật không may, không có GPU tương thích để hỗ trợ việc đào tạo của bạn.",
+    "text": "văn bản",
+    "upload_success": "Đã tải lên tệp {name} hoàn tất.",
+    "download_url": "Tải từ đường dẫn liên kết",
+    "download_from_csv": "Tải từ kho mô hình csv",
+    "search_models": "Tìm kiếm mô hình",
+    "upload": "Tải lên",
+    "option_not_valid": "Tùy chọn không hợp lệ!",
+    "list_model": "Danh sách mô hình",
+    "success": "Hoàn tất!",
+    "index": "chỉ mục",
+    "model": "mô hình",
+    "zip": "nén",
+    "search": "tìm kiếm",
+    "provide_file": "Vui lòng cung cấp tệp {filename} hợp lệ!",
+    "start": "Bắt đầu {start}...",
+    "not_found": "Không tìm thấy {name}",
+    "found": "Đã tìm thấy {results} kết quả!",
+    "download_music": "tải nhạc",
+    "download": "tải xuống",
+    "provide_url": "Vui lòng cung cấp đường dẫn liên kết.",
+    "provide_name_is_save": "Vui lòng cung cấp tên mô hình để lưu.",
+    "not_support_url": "Liên kết mô hình của bạn không được hỗ trợ.",
+    "error_occurred": "Đã xảy ra lỗi: {e}",
+    "not_model": "Tệp bạn vừa tải lên không phải là tệp mô hình!",
+    "unable_analyze_model": "Không phân tích được mô hình!",
+    "download_pretrain": "Tải xuống huấn luyện trước...",
+    "provide_pretrain": "Vui lòng cung cấp đường dẫn mô hình huấn luyện trước {dg}.",
+    "sr_not_same": "Tốc độ lấy mẫu của hai mô hình không giống nhau",
+    "architectures_not_same": "Không thể hợp nhất các mô hình. Các kiến trúc mô hình không giống nhau.",
+    "fushion_model": "dung hợp mô hình",
+    "model_fushion_info": "Mô hình được {name} được dung hợp từ {pth_1} và {pth_2} với ratio {ratio}.",
+    "not_found_create_time": "Không tìm thấy thời gian tạo.",
+    "format_not_valid": "Định dạng không hợp lệ.",
+    "read_info": "Các mô hình được huấn luyện trên các ứng dụng khác nhau có thể đem lại các thông tin khác nhau hoặc không thể đọc!",
+    "epoch": "kỷ nguyên.",
+    "step": "bước",
+    "sr": "Tốc độ lấy mẫu",
+    "f0": "huấn luyện cao độ",
+    "version": "phiên bản.",
+    "not_f0": "Không được huấn luyện cao độ",
+    "trained_f0": "Được huấn luyện cao độ",
+    "model_info": "Tên mô hình: {model_name}\n\n Người tạo mô hình: {model_author}\n\nKỷ nguyên: {epochs}\n\nSố bước: {steps}\n\nPhiên bản của mô hình: {version}\n\nTốc độ lấy mẫu: {sr}\n\nHuấn luyện cao độ: {pitch_guidance}\n\nHash (ID): {model_hash}\n\nThời gian tạo: {creation_date_str}\n\nBộ mã hóa: {vocoder}\n",
+    "input_not_valid": "Vui lòng nhập đầu vào hợp lệ!",
+    "output_not_valid": "Vui lòng nhập đầu ra hợp lệ!",
+    "apply_effect": "áp dụng hiệu ứng",
+    "enter_the_text": "Vui lòng nhập văn bản để chuyển!",
+    "choose_voice": "Vui lòng chọn giọng!",
+    "convert": "Chuyển đổi {name}...",
+    "separator_music": "tách nhạc",
+    "notfound": "Không tìm thấy",
+    "turn_on_use_audio": "Vui lòng bật sử dụng âm thanh vừa tách để sử dụng",
+    "turn_off_convert_backup": "Tắt chuyển đổi giọng bè để có thể sử dụng giọng gốc",
+    "turn_off_merge_backup": "Tắt không kết hợp giọng bè để có thể sử dụng giọng gốc",
+    "not_found_original_vocal": "Không tìm thấy giọng gốc!",
+    "convert_vocal": "Đang chuyển đổi giọng nói...",
+    "convert_success": "Đã hoàn tất chuyển đổi giọng nói!",
+    "convert_backup": "Đang chuyển đổi giọng bè...",
+    "convert_backup_success": "Đã Hoàn tất chuyển đổi giọng bè!",
+    "merge_backup": "Kết hợp giọng với giọng bè...",
+    "merge_success": "Kết hợp Hoàn tất.",
+    "is_folder": "Đầu vào là một thư mục: Chuyển đổi tất cả tệp âm thanh trong thư mục...",
+    "not_found_in_folder": "Không tìm thấy tệp âm thanh trong thư mục!",
+    "batch_convert": "Đang chuyển đổi hàng loạt...",
+    "batch_convert_success": "Chuyển đổi hàng loạt hoàn tất!",
+    "create": "tạo",
+    "provide_name": "Vui lòng cung cấp tên mô hình.",
+    "not_found_data": "Không tìm thấy dữ liệu",
+    "not_found_data_preprocess": "Không tìm thấy dữ liệu được xử lý, vui lòng xử lý lại âm thanh",
+    "not_found_data_extract": "Không tìm thấy dữ liệu được trích xuất, vui lòng trích xuất lại âm thanh",
+    "provide_pretrained": "Vui lòng nhập huấn luyện {dg}",
+    "download_pretrained": "Tải xuống huấn luyện trước {dg}{rvc_version} gốc",
+    "not_found_pretrain": "Không tìm thấy huấn luyện trước {dg}",
+    "not_use_pretrain": "Sẽ không có huấn luyện trước được sử dụng",
+    "training": "huấn luyện",
+    "rick_roll": "Bấm vào đây nếu bạn muốn bị Rick Roll:) ---> [RickRoll]({rickroll})",
+    "terms_of_use": "**Vui lòng không sử dụng Dự án với bất kỳ mục đích nào vi phạm đạo đức, pháp luật, hoặc gây tổn hại đến cá nhân, tổ chức...**",
+    "exemption": "**Trong trường hợp người sử dụng không tuân thủ các điều khoản hoặc vi phạm, tôi sẽ không chịu trách nhiệm về bất kỳ khiếu nại, thiệt hại, hay trách nhiệm pháp lý nào, dù là trong hợp đồng, do sơ suất, hay các lý do khác, phát sinh từ, ngoài, hoặc liên quan đến phần mềm, việc sử dụng phần mềm hoặc các giao dịch khác liên quan đến phần mềm.**",
+    "separator_tab": "Tách Nhạc",
+    "4_part": "Một hệ thống tách nhạc đơn giản có thể tách được 4 phần: Nhạc, giọng, giọng chính, giọng bè",
+    "clear_audio": "Làm sạch âm thanh",
+    "separator_backing": "Tách giọng bè",
+    "denoise_mdx": "Khữ tách MDX",
+    "use_mdx": "Sử dụng MDX",
+    "dereveb_audio": "Tách vang",
+    "dereveb_backing": "Tách vang bè",
+    "separator_model": "Mô hình tách nhạc",
+    "separator_backing_model": "Mô hình tách bè",
+    "shift": "Số lượng dự đoán",
+    "shift_info": "Càng cao chất lượng càng tốt nhưng lâu nhưng tốn tài nguyên",
+    "segments_size": "Kích Thước Phân Đoạn",
+    "segments_size_info": "Càng cao chất lượng càng tốt nhưng tốn tài nguyên",
+    "batch_size": "Kích thước lô",
+    "batch_size_info": "Số lượng mẫu xử lý đồng thời trong một lần huấn luyện. Cao có thể gây tràn bộ nhớ",
+    "mdx_batch_size_info": "Số lượng mẫu được xử lý cùng một lúc. Việc chia thành các lô giúp tối ưu hóa quá trình tính toán. Lô quá lớn có thể làm tràn bộ nhớ, khi lô quá nhỏ sẽ làm giảm hiệu quả dùng tài nguyên",
+    "overlap": "Chồng chéo",
+    "overlap_info": "Số lượng chồng chéo giữa các cửa sổ dự đoán",
+    "export_format": "Định dạng âm thanh",
+    "export_info": "Định dạng âm thanh khi xuất tệp âm thanh ra",
+    "output_separator": "Âm thanh đã được tách",
+    "hop_length_info": "Khoảng thời gian chuyển cửa sổ phân tích khi thực hiện phép biến đổi. Giá trị nhỏ độ chi tiết cao nhưng cần tính toán nhiều hơn",
+    "drop_audio": "Thả âm thanh vào đây",
+    "drop_text": "Thả tệp văn bản vào đây",
+    "use_url": "Sử dụng đường dẫn youtube",
+    "url_audio": "Đường dẫn liên kết đến âm thanh",
+    "downloads": "Tải Xuống",
+    "clean_strength": "Mức độ làm sạch âm thanh",
+    "clean_strength_info": "Mức độ của bộ làm sạch âm thanh để lọc giọng hát khi xuất",
+    "input_output": "Đầu vào, đầu ra âm thanh",
+    "audio_path": "Đường dẫn đầu vào âm thanh",
+    "refesh": "Tải lại",
+    "output_folder": "Đường dẫn thư mục đầu ra âm thanh",
+    "output_folder_info": "Nhập đường dẫn thư mục âm thanh sẽ xuất ra ở đó",
+    "input_audio": "Đầu vào âm thanh",
+    "instruments": "Nhạc nền",
+    "original_vocal": "Giọng gốc",
+    "main_vocal": "Giọng chính",
+    "backing_vocal": "Giọng bè",
+    "convert_audio": "Chuyển Đổi Âm Thanh",
+    "convert_info": "Chuyển đổi âm thanh bằng mô hình giọng nói đã được huấn luyện",
+    "autotune": "Tự động điều chỉnh",
+    "use_audio": "Sử dụng âm thanh vừa tách",
+    "convert_original": "Chuyển đổi giọng gốc",
+    "convert_backing": "Chuyển đổi giọng bè",
+    "not_merge_backing": "Không kết hợp giọng bè",
+    "merge_instruments": "Kết hợp nhạc nền",
+    "pitch": "Cao độ",
+    "pitch_info": "Khuyến cáo: chỉnh lên 12 để chuyển giọng nam thành nữ và ngược lại",
+    "model_accordion": "Mô hình và chỉ mục",
+    "model_name": "Tệp mô hình",
+    "index_path": "Tệp chỉ mục",
+    "index_strength": "Ảnh hưởng của chỉ mục",
+    "index_strength_info": "Càng cao ảnh hưởng càng lớn. Tuy nhiên, việc chọn giá trị thấp hơn có thể giảm hiện tượng giả trong âm thanh",
+    "output_path": "Đường dẫn đầu ra âm thanh",
+    "output_path_info": "Nhập đường dẫn đầu ra(cứ để định dạng .wav khi chuyển đổi nó tự sửa)",
+    "setting": "Cài đặt chung",
+    "f0_method": "Phương pháp trích xuất",
+    "f0_method_info": "Phương pháp để trích xuất dữ liệu",
+    "f0_method_hybrid": "Phương pháp trích xuất HYBRID",
+    "f0_method_hybrid_info": "Sự kết h���p của hai hoặc nhiều loại trích xuất khác nhau",
+    "hubert_model": "Mô hình nhúng",
+    "hubert_info": "Mô hình được huấn luyện trước để giúp nhúng",
+    "modelname": "Tên của mô hình",
+    "modelname_info": "Nếu bạn có mô hình riêng chỉ cần tải và nhập tên của mô hình vào đây",
+    "split_audio": "Cắt âm thanh",
+    "autotune_rate": "Mức độ điều chỉnh",
+    "autotune_rate_info": "Mức độ điều chỉnh tự động",
+    "resample": "Lấy mẫu lại",
+    "resample_info": "Lấy mẫu lại sau xử lý đến tốc độ lấy mẫu cuối cùng, 0 có nghĩa là không lấy mẫu lại, LƯU Ý: MỘT SỐ ĐỊNH DẠNG KHÔNG HỖ TRỢ TỐC ĐỘ TRÊN 48000",
+    "filter_radius": "Lọc trung vị",
+    "filter_radius_info": "Nếu giá trị lớn hơn ba sẽ áp dụng tính năng lọc trung vị. Giá trị đại diện cho bán kính bộ lọc và có thể làm giảm hơi thở hoặc tắt thở.",
+    "volume_envelope": "Đường bao âm thanh",
+    "volume_envelope_info": "Sử dụng đường bao âm lượng của đầu vào để thay thế hoặc trộn với đường bao âm lượng của đầu ra. Càng gần 1 thì đường bao đầu ra càng được sử dụng nhiều",
+    "protect": "Bảo vệ phụ âm",
+    "protect_info": "Bảo vệ các phụ âm riêng biệt và âm thanh thở ngăn chặn việc rách điện âm và các hiện tượng giả khác. Việc chỉnh tối đa sẽ bảo vệ toàn diện. Việc giảm giá trị này có thể giảm độ bảo vệ, đồng thời có khả năng giảm thiểu hiệu ứng lập chỉ mục",
+    "output_convert": "Âm thanh đã được chuyển đổi",
+    "main_convert": "Chuyển đổi giọng chính",
+    "main_or_backing": "Giọng chính + Giọng bè",
+    "voice_or_instruments": "Giọng + Nhạc nền",
+    "convert_text": "Chuyển Đổi Văn Bản",
+    "convert_text_markdown": "## Chuyển Đổi Văn Bản Thành Giọng Nói",
+    "convert_text_markdown_2": "Chuyển văn bản thành giọng nói và đọc lại bằng mô hình giọng nói được huấn luyện",
+    "input_txt": "Nhập dữ liệu từ tệp văn bản txt",
+    "text_to_speech": "Văn bản cần đọc",
+    "voice_speed": "Tốc độ đọc",
+    "voice_speed_info": "Tốc độ đọc của giọng nói",
+    "tts_1": "1. Chuyển Đổi Văn Bản",
+    "tts_2": "2. Chuyển Đổi Giọng Nói",
+    "voice": "Giọng nói của các nước",
+    "output_tts": "Đường dẫn đầu ra giọng nói",
+    "output_tts_convert": "Đường dẫn đầu ra giọng chuyển đổi",
+    "tts_output": "Nhập đường dẫn đầu ra",
+    "output_tts_markdown": "Âm thanh chưa được chuyển đổi và âm thanh đã được chuyển đổi",
+    "output_text_to_speech": "Giọng được tạo bởi chuyển đổi văn bản thành giọng nói",
+    "output_file_tts_convert": "Giọng được chuyển đổi bởi mô hình",
+    "output_audio": "Đầu ra âm thanh",
+    "provide_output": "Nhập đường dẫn đầu ra",
+    "audio_effects": "Hiệu Ứng Âm Thanh",
+    "apply_audio_effects": "## Áp Dụng Thêm Hiệu Ứng Cho Âm Thanh",
+    "audio_effects_edit": "Chỉnh sửa thêm hiệu ứng cho âm thanh",
+    "reverb": "Hiệu ứng vọng âm",
+    "chorus": "Hiệu ứng hòa âm",
+    "delay": "Hiệu ứng độ trễ",
+    "more_option": "Tùy chọn thêm",
+    "phaser": "Hiệu ứng xoay pha",
+    "compressor": "Hiệu ứng nén",
+    "apply": "Áp dụng",
+    "reverb_freeze": "Chế độ đóng băng",
+    "reverb_freeze_info": "Tạo hiệu ứng vang liên tục khi bật chế độ này",
+    "room_size": "Kích thước phòng",
+    "room_size_info": "Điều chỉnh không gian của phòng để tạo độ vang",
+    "damping": "Giảm âm",
+    "damping_info": "Điều chỉnh độ hút âm, kiểm soát mức độ vang",
+    "wet_level": "Mức độ tín hiệu vang",
+    "wet_level_info": "Điều chỉnh mức độ của tín hiệu có hiệu ứng vọng âm",
+    "dry_level": "Mức độ tín hiệu gốc",
+    "dry_level_info": "Điều chỉnh mức độ của tín hiệu không có hiệu ứng",
+    "width": "Chiều rộng âm thanh",
+    "width_info": "Điều chỉnh độ rộng của không gian âm thanh",
+    "chorus_depth": "Giảm âm",
+    "chorus_depth_info": "Điều chỉnh cường độ hòa âm, tạo ra cảm giác rộng cho âm thanh",
+    "chorus_rate_hz": "Tần số",
+    "chorus_rate_hz_info": "Điều chỉnh tốc độ dao động của hòa âm",
+    "chorus_mix": "Trộn tín hiệu",
+    "chorus_mix_info": "Điều chỉnh mức độ trộn giữa âm gốc và âm có hiệu ứng",
+    "chorus_centre_delay_ms": "Đỗ trễ trung tâm (mili giây)",
+    "chorus_centre_delay_ms_info": "Khoảng thời gian trễ giữa các kênh stereo để tạo hiệu ứng hòa âm",
+    "chorus_feedback": "Phản hồi",
+    "chorus_feedback_info": "Điều chỉnh lượng tín hiệu hiệu ứng được quay lại vào tín hiệu gốc",
+    "delay_seconds": "Thời gian trễ",
+    "delay_seconds_info": "Điều chỉnh khoảng thời gian trễ giữa âm gốc và âm có hiệu ứng",
+    "delay_feedback": "Phản hồi độ trễ",
+    "delay_feedback_info": "Điều chỉnh lượng tín hiệu được quay lại, tạo hiệu ứng lặp lại",
+    "delay_mix": "Trộn tín hiệu độ trễ",
+    "delay_mix_info": "Điều chỉnh mức độ trộn giữa âm gốc và âm trễ",
+    "fade": "Hiệu ứng mờ dần",
+    "bass_or_treble": "Âm trầm và âm cao",
+    "limiter": "Giới hạn ngưỡng",
+    "distortion": "Hiệu ứng nhiễu âm",
+    "gain": "Cường độ âm",
+    "bitcrush": "Hiệu ứng giảm bits",
+    "clipping": "Hiệu ứng méo âm",
+    "fade_in": "Hiệu ứng mờ dần vào (mili giây)",
+    "fade_in_info": "Thời gian mà âm thanh sẽ tăng dần từ mức 0 đến mức bình thường",
+    "fade_out": "Hiệu ứng mờ dần ra (mili giây)",
+    "fade_out_info": "thời gian mà âm thanh sẽ giảm dần từ bình thường xuống mức 0",
+    "bass_boost": "Độ khuếch đại âm trầm (db)",
+    "bass_boost_info": "mức độ tăng cường âm trầm trong đoạn âm thanh",
+    "bass_frequency": "Tần số cắt của bộ lọc thông thấp (Hz)",
+    "bass_frequency_info": "tần số bị giảm. Tần số thấp sẽ làm âm trầm rõ hơn",
+    "treble_boost": "Độ khuếch đại âm cao (db)",
+    "treble_boost_info": "mức độ tăng cường âm cao trong đoạn âm thanh",
+    "treble_frequency": "Tần số cắt của bộ lọc thông cao (Hz)",
+    "treble_frequency_info": "tần số sẽ lọc bỏ. Tần số càng cao thì giữ lại âm càng cao",
+    "limiter_threashold_db": "Ngưỡng giới hạn",
+    "limiter_threashold_db_info": "Giới hạn mức độ âm thanh tối đa, ngăn không cho vượt quá ngưỡng",
+    "limiter_release_ms": "Thời gian thả",
+    "limiter_release_ms_info": "Khoảng thời gian để âm thanh trở lại sau khi bị giới hạn (Mili Giây)",
+    "distortion_info": "Điều chỉnh mức độ nhiễu âm, tạo hiệu ứng méo tiếng",
+    "gain_info": "Tăng giảm âm lượng của tín hiệu",
+    "clipping_threashold_db": "Ngưỡng cắt",
+    "clipping_threashold_db_info": "Cắt bớt tín hiệu vượt quá ngưỡng, tạo âm thanh méo",
+    "bitcrush_bit_depth": "Độ sâu bit",
+    "bitcrush_bit_depth_info": "Giảm chất lượng âm thanh bằng cách giảm số bit, tạo hiệu ứng âm thanh bị méo",
+    "phaser_depth": "Độ sâu",
+    "phaser_depth_info": "Điều chỉnh độ sâu của hiệu ứng, ảnh hưởng đến cường độ của hiệu ứng xoay pha",
+    "phaser_rate_hz": "Tần số",
+    "phaser_rate_hz_info": "Điều chỉnh tốc độ của hiệu ứng hiệu ứng xoay pha",
+    "phaser_mix": "Trộn tín hiệu",
+    "phaser_mix_info": "Điều chỉnh mức độ trộn giữa tín hiệu gốc và tín hiệu đã qua xử lý",
+    "phaser_centre_frequency_hz": "Tần số trung tâm",
+    "phaser_centre_frequency_hz_info": "Tần số trung tâm của hiệu ứng xoay pha, ảnh hưởng đến tần số bị điều chỉnh",
+    "phaser_feedback": "Phản hồi",
+    "phaser_feedback_info": "Điều chỉnh lượng phản hồi tín hiệu, tạo cảm giác xoay pha mạnh hoặc nhẹ",
+    "compressor_threashold_db": "Ngưỡng nén",
+    "compressor_threashold_db_info": "Ngưỡng mức âm thanh sẽ bị nén khi vượt qua ngưỡng này",
+    "compressor_ratio": "Tỉ lệ nén",
+    "compressor_ratio_info": "Điều chỉnh mức độ nén âm thanh khi vượt qua ngưỡng",
+    "compressor_attack_ms": "Thời gian tấn công (mili giây)",
+    "compressor_attack_ms_info": "Khoảng thời gian nén bắt đầu tác dụng sau khi âm thanh vượt ngưỡng",
+    "compressor_release_ms": "Thời gian thả",
+    "compressor_release_ms_info": "Thời gian để âm thanh trở lại trạng thái bình thường sau khi bị nén",
+    "create_dataset_url": "Đường dẫn liên kết đến âm thanh(sử dụng dấu , để sử dụng nhiều liên kết)",
+    "createdataset": "Tạo dữ liệu",
+    "create_dataset_markdown": "## Tạo Dữ Liệu Huấn Luyện Từ Youtube",
+    "create_dataset_markdown_2": "Xử lý và tạo tập tin dữ liệu huấn luyện bằng đường dẫn youtube",
+    "denoise": "Khử tách mô hình",
+    "skip": "Bỏ qua giây",
+    "model_ver": "Phiên bản tách giọng",
+    "model_ver_info": "Phiên bản của mô hình tách nhạc để tách giọng",
+    "create_dataset_info": "Thông tin tạo dữ liệu",
+    "output_data": "Đầu ra dữ liệu",
+    "output_data_info": "Đầu ra dữ liệu sau khi tạo xong dữ liệu",
+    "skip_start": "Bỏ qua phần đầu",
+    "skip_start_info": "Bỏ qua số giây đầu của âm thanh, dùng dấu , để sử dụng cho nhiều âm thanh",
+    "skip_end": "Bỏ qua phần cuối",
+    "skip_end_info": "Bỏ qua số giây cuối của âm thanh, dùng dấu , để sử dụng cho nhiều âm thanh",
+    "training_model": "Huấn Luyện Mô Hình",
+    "training_markdown": "Huấn luyện và đào tạo mô hình giọng nói bằng một lượng dữ liệu giọng nói",
+    "training_model_name": "Tên của mô hình khi huấn luyện(không sử dụng ký tự đặc biệt hay dấu cách)",
+    "sample_rate": "Tỉ lệ lấy mẫu",
+    "sample_rate_info": "Tỉ lệ lấy mẫu của mô hình",
+    "training_version": "Phiên bản mô hình",
+    "training_version_info": "Phiên bản mô hình khi huấn luyện",
+    "training_pitch": "Huấn luyện cao độ",
+    "upload_dataset": "Tải lên dữ liệu huấn luyện",
+    "preprocess_effect": "Xử lý hậu kỳ",
+    "clear_dataset": "Làm sạch dữ liệu",
+    "preprocess_info": "Thông tin phần xử lý trước",
+    "preprocess_button": "1. Xử lý dữ liệu",
+    "extract_button": "2. Trích xuất dữ liệu",
+    "extract_info": "Thông tin phần trích xuất dữ liệu",
+    "total_epoch": "Tổng số kỷ nguyên",
+    "total_epoch_info": "Tổng số kỷ nguyên huấn luyện đào tạo",
+    "save_epoch": "Tần suất lưu",
+    "save_epoch_info": "Tần suất lưu mô hình khi huấn luyện, giúp việc huấn luyện lại mô hình",
+    "create_index": "Tạo chỉ mục",
+    "index_algorithm": "Thuật toán chỉ mục",
+    "index_algorithm_info": "Thuật toán tạo chỉ mục",
+    "custom_dataset": "Tùy chọn thư mục",
+    "custom_dataset_info": "Tùy chọn thư mục dữ liệu huấn luyện",
+    "overtraining_detector": "Kiểm tra quá sức",
+    "overtraining_detector_info": "Kiểm tra huấn luyện mô hình quá sức",
+    "cleanup_training": "Làm sạch huấn luyện",
+    "cleanup_training_info": "Bật khi cần huấn luyện lại từ đầu.",
+    "cache_in_gpu": "Lưu mô hình vào đệm",
+    "cache_in_gpu_info": "Lưu mô hình vào bộ nhớ đệm gpu",
+    "dataset_folder": "Thư mục chứa dữ liệu",
+    "threshold": "Ngưỡng huấn luyện quá sức",
+    "setting_cpu_gpu": "Tùy chọn CPU/GPU",
+    "gpu_number": "Số gpu được sử dụng",
+    "gpu_number_info": "Số của GPU được sử dụng trong huấn luyện",
+    "save_only_latest": "Chỉ lưu mới nhất",
+    "save_only_latest_info": "Chỉ lưu mô hình D và G mới nhất",
+    "save_every_weights": "Lưu mọi mô hình",
+    "save_every_weights_info": "Lưu mọi mô hình sau mỗi lượt kỷ nguyên",
+    "gpu_info": "Thông tin của GPU",
+    "gpu_info_2": "Thông tin của GPU được sử dụng trong huấn luyện",
+    "cpu_core": "Số lõi xử lý có thể sử dụng",
+    "cpu_core_info": "Số lõi được sử dụng trong việc huấn luyện",
+    "not_use_pretrain_2": "Không dùng huấn luyện",
+    "not_use_pretrain_info": "Không dùng huấn luyện trước",
+    "custom_pretrain": "Tùy chỉnh huấn luyện",
+    "custom_pretrain_info": "Tùy chỉnh huấn luyện trước",
+    "pretrain_file": "Tệp mô hình huấn luyện trước {dg}",
+    "train_info": "Thông tin phần huấn luyện",
+    "export_model": "5. Xuất Mô hình",
+    "zip_model": "2. Nén mô hình",
+    "output_zip": "Đầu ra tệp khi nén",
+    "model_path": "Đường dẫn mô hình",
+    "model_ratio": "Tỉ lệ mô hình",
+    "model_ratio_info": "Chỉnh hướng về bên nào sẽ làm cho mô hình giống với bên đó",
+    "output_model_path": "Đầu ra mô hình",
+    "fushion": "Dung Hợp Mô Hình",
+    "fushion_markdown": "## Dung Hợp Hai Mô Hình Với Nhau",
+    "fushion_markdown_2": "Dung hợp hai mô hình giọng nói lại với nhau để tạo thành một mô hình duy nhất",
+    "read_model": "Đọc Thông Tin",
+    "read_model_markdown": "## Đọc Thông Tin Của Mô Hình",
+    "read_model_markdown_2": "Đọc các thông tin được ghi trong mô hình",
+    "drop_model": "Thả mô hình vào đây",
+    "readmodel": "Đọc mô hình",
+    "model_path_info": "Nhập đường dẫn đến tệp mô hình",
+    "modelinfo": "Thông Tin Mô Hình",
+    "download_markdown": "## Tải Xuống Mô Hình",
+    "download_markdown_2": "Tải xuống mô hình giọng nói, mô hình huấn luyện trước, mô hình nhúng",
+    "model_download": "Tải xuống mô hình giọng nói",
+    "model_url": "Đường dẫn liên kết đến mô hình",
+    "15s": "Vui lòng đợi khoảng 15 giây. Hệ thống sẽ tự khởi động lại!",
+    "model_download_select": "Chọn cách tải mô hình",
+    "model_warehouse": "Kho mô hình",
+    "get_model": "Nhận mô hình",
+    "name_to_search": "Tên để tìm kiếm",
+    "search_2": "Tìm kiếm",
+    "select_download_model": "Chọn mô hình đã được tìm kiếm(Bấm vào để chọn)",
+    "download_pretrained_2": "Tải xuống mô hình huấn luyện trước",
+    "only_huggingface": "Chỉ hỗ trợ huggingface.co",
+    "pretrained_url": "Đường dẫn liên kết đến mô hình huấn luyện trước {dg}",
+    "select_pretrain": "Chọn mô hình huấn luyện trước",
+    "select_pretrain_info": "Chọn mô hình huấn luyện trước để cài đặt về",
+    "pretrain_sr": "Tốc độ lấy mẫu của mô hình",
+    "drop_pretrain": "Thả mô hình huấn luyện trước {dg} vào đây",
+    "settings": "Tùy Chỉnh",
+    "settings_markdown": "## Tùy Chỉnh Thêm",
+    "settings_markdown_2": "Tùy chỉnh thêm một số tính năng của dự án",
+    "lang": "Ngôn ngữ",
+    "lang_restart": "Ngôn ngữ được hiển thị trong dự án(Khi đổi ngôn ngữ hệ thống sẽ tự khởi động lại sau 15 giây để cập nhật)",
+    "change_lang": "Đổi Ngôn Ngữ",
+    "theme": "Chủ đề",
+    "theme_restart": "Loại Chủ đề của giao diện được hiển thị(Khi đổi chủ đề hệ thống sẽ tự khởi động lại sau 15 giây để cập nhật)",
+    "theme_button": "Đổi Chủ Đề",
+    "change_light_dark": "Đổi Chế Độ Sáng/Tối",
+    "tensorboard_url": "Đường dẫn biểu đồ",
+    "errors_loading_audio": "Lỗi khi tải âm thanh: {e}",
+    "apply_error": "Đã xảy ra lỗi khi áp dụng hiệu ứng: {e}",
+    "indexpath": "Đường dẫn chỉ mục",
+    "split_total": "Tổng số phần đã cắt",
+    "process_audio_error": "Đã xảy ra lỗi khi xử lý âm thanh",
+    "merge_error": "Đã xảy ra lỗi khi ghép âm thanh",
+    "not_found_convert_file": "Không tìm thấy tệp đã xử lý",
+    "convert_batch": "Chuyển đổi hàng loạt...",
+    "found_audio": "Tìm thấy {audio_files} tệp âm thanh cho việc chuyển đổi.",
+    "not_found_audio": "Không tìm thấy tệp âm thanh!",
+    "error_convert": "Đã xảy ra lỗi khi chuyển đổi âm thanh: {e}",
+    "convert_batch_success": "Đã chuyển đổi hàng loạt hoàn tất sau {elapsed_time} giây. {output_path}",
+    "convert_audio_success": "Tệp {input_path} được chuyển đổi hoàn tất sau {elapsed_time} giây. {output_path}",
+    "hybrid_methods": "Tính toán ước lượng cao độ f0 cho các phương pháp {methods}",
+    "method_not_valid": "Phương pháp không hợp lệ",
+    "read_faiss_index_error": "Đã xảy ra lỗi khi đọc chỉ mục FAISS: {e}",
+    "read_model_error": "Thất bại khi tải mô hình: {e}",
+    "starting_download": "Bắt đầu tải xuống",
+    "version_not_valid": "Phiên bản tách giọng không hợp lệ",
+    "skip<audio": "Không thể bỏ qua vì số lượng thời gian bỏ qua thấp hơn số lượng tệp âm thanh",
+    "skip>audio": "Không thể bỏ qua vì số lượng thời gian bỏ qua cao hơn số lượng tệp âm thanh",
+    "=<0": "Thời gian bỏ qua bé hơn hoặc bằng 0 nên bỏ qua",
+    "skip_warning": "Thời lượng bỏ qua ({seconds} giây) vượt quá thời lượng âm thanh ({total_duration} giây). Bỏ qua.",
+    "download_success": "Đã tải xuống hoàn tất",
+    "create_dataset_error": "Đã xảy ra lỗi khi tạo dữ liệu huấn luyện",
+    "create_dataset_success": "Quá trình tạo dữ liệu huấn huyện đã hoàn tất sau: {elapsed_time} giây",
+    "skip_start_audio": "Bỏ qua âm thanh đầu hoàn tất: {input_file}",
+    "skip_end_audio": "Bỏ qua âm thanh cuối hoàn tất: {input_file}",
+    "merge_audio": "Đã ghép các phần chứa âm thanh lại",
+    "separator_process": "Đang tách giọng: {input}...",
+    "not_found_main_vocal": "Không tìm thấy giọng chính!",
+    "not_found_backing_vocal": "Không tìm thấy giọng bè!",
+    "not_found_instruments": "Không tìm thấy nhạc nền",
+    "merge_instruments_process": "Kết hợp giọng với nhạc nền...",
+    "dereverb": "Đang tách âm vang",
+    "dereverb_success": "Đã tách âm vang hoàn tất",
+    "save_index": "Đã lưu tệp chỉ mục",
+    "create_index_error": "Đã xảy ra lỗi khi tạo chỉ mục",
+    "sr_not_16000": "Tỉ lệ mẫu phải là 16000",
+    "gpu_not_valid": "Chỉ số GPU không hợp lệ. Chuyển sang CPU.",
+    "extract_file_error": "Đã xảy ra lỗi khi giải nén tập tin",
+    "extract_f0_method": "Bắt đầu trích xuất cao độ với {num_processes} lõi với phương pháp trích xuất {f0_method}...",
+    "extract_f0": "Trích Xuất Cao Độ",
+    "extract_f0_success": "Quá trình trích xuất cao độ đã hoàn tất vào {elapsed_time} giây.",
+    "NaN": "chứa giá trị NaN và sẽ bị bỏ qua.",
+    "start_extract_hubert": "Đang bắt đầu nhúng trích xuất...",
+    "not_found_audio_file": "Không tìm thấy tập tin âm thanh. Hãy chắc chắn rằng bạn đã cung cấp âm thanh chính xác.",
+    "process_error": "Đã xảy ra lỗi khi xử lý",
+    "extract_hubert_success": "Quá trình trích xuất nhúng đã hoàn tất trong {elapsed_time} giây.",
+    "export_process": "Đường dẫn của mô hình",
+    "extract_error": "Đã xảy ra lỗi khi trích xuất dữ liệu",
+    "extract_success": "Đã trích xuất hoàn tất mô hình",
+    "min_length>=min_interval>=hop_size": "min_length lớn hơn hoặc bằng min_interval lớn hơn hoặc bằng hop_size là bắt buộc",
+    "max_sil_kept>=hop_size": "max_sil_kept lớn hơn hoặc bằng hop_size là bắt buộc",
+    "start_preprocess": "Đang bắt đầu xử lý dữ liệu với {num_processes} lõi xử lý...",
+    "not_integer": "Thư mục ID giọng nói phải là số nguyên, thay vào đó có",
+    "preprocess_success": "Quá trình xử lý hoàn tất sau {elapsed_time} giây.",
+    "preprocess_model_success": "Đã hoàn tất xử lý trước dữ liệu cho mô hình",
+    "turn_on_dereverb": "Điều kiện cần để sử dụng tách vang giọng bè là phải bật tách vang",
+    "turn_on_separator_backing": "Điều kiện cần để sử dụng tách vang giọng bè là phải bật tách bè",
+    "backing_model_ver": "Phiên bản mô hình của tách bè",
+    "clean_audio_success": "Đã làm sạch âm hoàn tất!",
+    "separator_error": "Đã xảy ra lỗi khi tách nhạc",
+    "separator_success": "Quá trình tách nhạc đã hoàn tất sau: {elapsed_time} giây",
+    "separator_process_2": "Đang xử lý tách nhạc",
+    "separator_success_2": "Đã tách nhạc hoàn tất!",
+    "separator_process_backing": "Đang xử lý tách giọng bè",
+    "separator_process_backing_success": "Đã tách giọng bè hoàn tất!",
+    "process_original": "Đang xử lý tách âm vang giọng gốc...",
+    "process_original_success": "Đã tách âm vang giọng gốc hoàn tất!",
+    "process_main": "Đang xử lý tách âm vang giọng chính...",
+    "process_main_success": "Đã tách âm vang giọng chính hoàn tất!",
+    "process_backing": "Đang xử lý tách âm vang giọng bè...",
+    "process_backing_success": "Đã tách âm vang giọng bè hoàn tất!",
+    "save_every_epoch": "Lưu mô hình sau: ",
+    "total_e": "Tổng số kỷ nguyên huấn luyện: ",
+    "dorg": "Huấn luyện trước G: {pretrainG} | Huấn luyện trước D: {pretrainD}",
+    "training_f0": "Huấn luyện cao độ",
+    "not_gpu": "Không phát hiện thấy GPU, hoàn nguyên về CPU (không khuyến nghị)",
+    "not_found_checkpoint": "Không tìm thấy tệp điểm đã lưu: {checkpoint_path}",
+    "save_checkpoint": "Đã tải lại điểm đã lưu '{checkpoint_path}' (kỷ nguyên {checkpoint_dict})",
+    "save_model": "Đã lưu mô hình '{checkpoint_path}' (kỷ nguyên {iteration})",
+    "sr_does_not_match": "{sample_rate} Tỉ lệ mẫu không khớp với mục tiêu {sample_rate2} Tỉ lệ mẫu",
+    "spec_error": "Đã xảy ra lỗi khi nhận thông số kỹ thuật từ {spec_filename}: {e}",
+    "time_or_speed_training": "thời gian={current_time} | tốc độ huấn luyện={elapsed_time_str}",
+    "savemodel": "Đã lưu mô hình '{model_dir}' (kỷ nguyên {epoch} và bước {step})",
+    "model_author": "Ghi công mô hình cho {model_author}",
+    "unregistered": "Mô hình không được ghi chép",
+    "not_author": "Mô hình không được ghi chép",
+    "training_author": "Tên chủ mô hình",
+    "training_author_info": "Nếu bạn muốn ghi công mô hình hãy nhập tên của bạn vào đây",
+    "extract_model_error": "Đã xảy ra lỗi khi trích xuất mô hình",
+    "start_training": "Bắt đầu huấn luyện",
+    "import_pretrain": "Đã nạp huấn luyện trước ({dg}) '{pretrain}'",
+    "not_using_pretrain": "Sẽ không có huấn luyện trước ({dg}) được sử dụng",
+    "training_warning": "CẢNH BÁO: Tổn thất tạo ra thấp hơn đã bị vượt quá tổn thất thấp hơn trong kỷ nguyên tiếp theo.",
+    "overtraining_find": "Tập luyện quá sức được phát hiện ở kỷ nguyên {epoch} với mất mát g được làm mịn {smoothed_value_gen} và mất mát d được làm mịn {smoothed_value_disc}",
+    "best_epoch": "Kỷ nguyên mới tốt nhất {epoch} với mất mát g được làm mịn {smoothed_value_gen} và mất mát d được làm mịn {smoothed_value_disc}",
+    "success_training": "Đã đào tạo hoàn tất với {epoch} kỷ nguyên, {global_step} các bước và {loss_gen_all} mất mát gen.",
+    "training_info": "Tổn thất gen thấp nhất: {lowest_value_rounded} ở ký nguyên {lowest_value_epoch}, bước {lowest_value_step}",
+    "model_training_info": "{model_name} | kỷ nguyên={epoch} | bước={global_step} | {epoch_recorder} | giá trị thấp nhất={lowest_value_rounded} (kỷ nguyên {lowest_value_epoch} và bước {lowest_value_step}) | Số kỷ nguyên còn lại để tập luyện quá sức: g/total: {remaining_epochs_gen} d/total: {remaining_epochs_disc} | làm mịn mất mát gen={smoothed_value_gen} | làm mịn mất mát disc={smoothed_value_disc}",
+    "model_training_info_2": "{model_name} | kỷ nguyên={epoch} | bước={global_step} | {epoch_recorder} | giá trị thấp nhất={lowest_value_rounded} (kỷ nguyên {lowest_value_epoch} và bước {lowest_value_step})",
+    "model_training_info_3": "{model_name} | kỷ nguyên={epoch} | bước={global_step} | {epoch_recorder}",
+    "training_error": "Đã xảy ra lỗi khi huấn luyện mô hình:",
+    "separator_info": "Đang khởi tạo với đường dẫn đầu ra: {output_dir}, định dạng đầu ra: {output_format}",
+    "output_dir_is_none": "Thư mục đầu ra không được chỉ định. Sử dụng thư mục làm việc hiện tại.",
+    ">0or=1": "Ngưỡng chuẩn hóa phải lớn hơn 0 và nhỏ hơn hoặc bằng 1.",
+    "output_single": "Đã yêu cầu đầu ra một gốc nên chỉ có một tệp đầu ra ({output_single_stem}) sẽ được ghi",
+    "step2": "Bước thứ hai sẽ được đảo ngược bằng cách sử dụng quang phổ thay vì dạng sóng. Điều này có thể cải thiện chất lượng nhưng chậm hơn một chút.",
+    "name_ver": "Phiên bản {name}",
+    "os": "Hệ điều hành",
+    "platform_info": "Hệ thống: {system_info} Tên: {node} Phát hành: {release} Máy: {machine} Vi xử lý: {processor}",
+    "none_ffmpeg": "FFmpeg chưa được cài đặt. Vui lòng cài đặt FFmpeg để sử dụng gói này.",
+    "install_onnx": "Gói {pu} ONNX Runtime được cài đặt cùng với phiên bản",
+    "running_in_cpu": "Không thể cấu hình khả năng tăng tốc phần cứng, chạy ở chế độ CPU",
+    "running_in_cuda": "CUDA có sẵn trong Torch, cài đặt thiết bị Torch thành CUDA",
+    "onnx_have": "ONNXruntime có sẵn {have}, cho phép tăng tốc",
+    "onnx_not_have": "{have} không có sẵn trong ONNXruntime, do đó khả năng tăng tốc sẽ KHÔNG được bật",
+    "python_not_install": "Gói Python: {package_name} chưa được cài đặt",
+    "hash": "Tính hash của tệp mô hình {model_path}",
+    "ioerror": "IOError đang tìm kiếm -10 MB hoặc đọc tệp mô hình để tính toán hàm băm: {e}",
+    "cancel_download": "Tệp đã tồn tại tại {output_path}, bỏ qua quá trình tải xuống",
+    "download_model": "Đang tải tệp từ {url} xuống {output_path} với thời gian chờ 300 giây",
+    "download_error": "Không tải được tệp xuống từ {url}, mã phản hồi: {status_code}",
+    "vip_model": "Mô hình: '{model_friendly_name}' là mô hình cao cấp, được Anjok07 dự định chỉ dành cho những người đăng ký trả phí truy cập.",
+    "vip_print": "Này bạn, nếu bạn chưa đăng ký, vui lòng cân nhắc việc hỗ trợ cho nhà phát triển của UVR, Anjok07 bằng cách đăng ký tại đây: https://patreon.com/uvr",
+    "search_model": "Đang tìm kiếm mô hình {model_filename} trong tập tin các mô hình được hỗ trợ trong nhóm",
+    "load_download_json": "Đã tải danh sách tải xuống mô hình",
+    "single_model": "Đã xác định được tệp mô hình đơn: {model_friendly_name}",
+    "not_found_model": "Không tìm thấy mô hình trong kho lưu trữ UVR, đang cố tải xuống từ kho lưu trữ mô hình phân tách âm thanh...",
+    "single_model_path": "Đường dẫn trả về cho tệp mô hình đơn: {model_path}",
+    "find_model": "Đã tìm thấy tên tệp đầu vào {model_filename} trong mô hình nhiều tệp: {model_friendly_name}",
+    "find_models": "Đã xác định mô hình nhiều tệp: {model_friendly_name}, lặp qua các tệp để tải xuống",
+    "find_path": "Đang cố gắng xác định ĐƯỜNG DẪN tải xuống cho cặp cấu hình",
+    "not_found_model_warehouse": "Không tìm thấy mô hình trong kho lưu trữ UVR, đang cố tải xuống từ kho lưu trữ mô hình phân tách âm thanh...",
+    "yaml_warning": "Tên mô hình bạn đã chỉ định, {model_filename} thực sự là tệp cấu hình mô hình chứ không phải tệp mô hình.",
+    "yaml_warning_2": "Chúng tôi đã tìm thấy một mô hình khớp với tệp cấu hình này: {config_key} nên chúng tôi sẽ sử dụng tệp mô hình đó cho lần chạy này.",
+    "yaml_warning_3": "Để tránh hành vi gây nhầm lẫn/không nhất quán trong tương lai, thay vào đó hãy chỉ định tên tệp mô hình thực tế.",
+    "yaml_debug": "Không tìm thấy tệp cấu hình mô hình YAML trong kho lưu trữ UVR, đang cố tải xuống từ kho lưu trữ mô hình phân tách âm thanh...",
+    "download_model_friendly": "Tất cả các tệp đã tải xuống cho mô hình {model_friendly_name}, trả về đường dẫn ban đầu {model_path}",
+    "not_found_model_2": "Không tìm thấy tệp mô hình {model_filename} trong các tệp mô hình được hỗ trợ",
+    "load_yaml": "Đang tải dữ liệu mô hình từ YAML tại đường dẫn {model_data_yaml_filepath}",
+    "load_yaml_2": "Dữ liệu mô hình được tải từ tệp YAML: {model_data}",
+    "hash_md5": "Tính hash MD5 cho tệp mô hình để xác định các tham số mô hình từ dữ liệu UVR...",
+    "model_hash": "Mô hình {model_path} có hash {model_hash}",
+    "mdx_data": "Đường dẫn dữ liệu mô hình MDX được đặt thành {mdx_model_data_path}",
+    "load_mdx": "Đang tải các tham số mô hình MDX từ tệp dữ liệu mô hình UVR...",
+    "model_not_support": "Tệp mô hình không được hỗ trợ: không thể tìm thấy tham số cho hash MD5 {model_hash} trong tệp dữ liệu mô hình UVR cho vòm MDX.",
+    "uvr_json": "Dữ liệu mô hình được tải từ UVR JSON bằng hàm băm {model_hash}: {model_data}",
+    "loading_model": "Đang tải mô hình {model_filename}...",
+    "download_model_friendly_2": "Đã tải xuống mô hình, tên thân thiện: {model_friendly_name}, Đường dẫn mô hình: {model_path}",
+    "model_type_not_support": "Loại mô hình không được hỗ trợ: {model_type}",
+    "demucs_not_support_python<3.10": "Các mô hình Demucs yêu cầu phiên bản Python 3.10 trở lên.",
+    "import_module": "Nhập mô-đun cho loại mô hình",
+    "initialization": "Khởi tạo lớp phân cách cho loại mô hình",
+    "loading_model_success": "Đang tải mô hình hoàn tất.",
+    "loading_model_duration": "Tải thời lượng mô hình",
+    "starting_separator": "Bắt đầu quá trình tách cho đường dẫn tập tin âm thanh",
+    "normalization": "Ngưỡng chuẩn hóa được đặt thành {normalization_threshold}, dạng sóng sẽ hạ xuống biên độ tối đa này để tránh bị cắt.",
+    "loading_separator_model": "Đang tải xuống mô hình {model_filename}...",
+    "separator_success_3": "Quá trình tách hoàn tất.",
+    "separator_duration": "Thời gian tách",
+    "downloading_model": "Đã tải xuống mô hình, loại: {model_type}, tên thân thiện: {model_friendly_name}, đường dẫn mô hình: {model_path}, dữ liệu mô hình: {model_data_dict_size} mục",
+    "demucs_info": "Thông số Demucs: Kích thước phân đoạn = {segment_size}, Kích hoạt kích thước phân đoạn = {segments_enabled}",
+    "demucs_info_2": "Thông số Demucs: Số lượng dự đoán = {shifts}, Chồng chéo = {overlap}",
+    "start_demucs": "Khởi tạo hoàn tất Demucs Separator",
+    "start_separator": "Bắt đầu quá trình tách...",
+    "prepare_mix": "Chuẩn bị hỗn hợp...",
+    "demix": "Hỗn hợp đã chuẩn bị để khử trộn. Hình dạng: {shape}",
+    "cancel_mix": "Đang tải mô hình để hủy trộn...",
+    "model_review": "Mô hình được tải và đặt ở chế độ đánh giá.",
+    "del_gpu_cache_after_demix": "Đã xóa bộ nhớ đệm mô hình và GPU sau khi hủy trộn.",
+    "process_output_file": "Đang xử lý tập tin đầu ra...",
+    "source_length": "Đang xử lý mảng nguồn, độ dài nguồn là {source_length}",
+    "process_ver": "Đang xử lý nguồn phiên bản...",
+    "set_map": "Đặt bản đồ nguồn thành {part} phần gốc...",
+    "process_all_part": "Xử lý cho tất cả các phần gốc...",
+    "skip_part": "Bỏ qua phần viết gốc {stem_name} vì out_single_stem được đặt thành {output_single_stem}...",
+    "starting_demix_demucs": "Đang bắt đầu quá trình trộn trong demix_demucs...",
+    "model_infer": "Chạy mô hình suy luận...",
+    "name_not_pretrained": "{name} không phải là một mô hình được đào tạo trước hay một túi mô hình.",
+    "invalid_checksum": "Tổng kiểm tra không hợp lệ cho tệp {path}, dự kiến {checksum} nhưng lại nhận được {actual_checksum}",
+    "mdx_info": "Thông số MDX: Kích thước lô = {batch_size}, Kích thước phân đoạn = {segment_size}",
+    "mdx_info_2": "Thông số MDX: Chồng chéo = {overlap}, Hop_length = {hop_length}, Kích hoạt khữ nhiễu = {enable_denoise}",
+    "mdx_info_3": "Thông số MDX",
+    "load_model_onnx": "Đang tải mô hình ONNX để suy luận...",
+    "load_model_onnx_success": "Đã tải mô hình hoàn tất bằng phiên suy luận ONNXruntime.",
+    "onnx_to_pytorch": "Mô hình được chuyển đổi từ onnx sang pytorch do kích thước phân đoạn không khớp với dim_t, quá trình xử lý có thể chậm hơn.",
+    "stft": "STFT nghịch đảo được áp dụng. Trả về kết quả có hình dạng",
+    "no_denoise": "Mô hình chạy trên quang phổ mà không khử nhiễu.",
+    "mix": "Đang chuẩn bị trộn cho tệp âm thanh đầu vào {audio_file_path}...",
+    "normalization_demix": "Chuẩn hóa hỗn hợp trước khi khử trộn...",
+    "mix_success": "Quá trình trộn hoàn tất.",
+    "primary_source": "Bình thường hóa nguồn chính...",
+    "secondary_source": "Sản xuất nguồn thứ cấp: Trộn ở chế độ trộn phù hợp",
+    "invert_using_spec": "Đảo ngược thân thứ cấp bằng cách sử dụng quang phổ khi invert_USE_spec được đặt thành True",
+    "invert_using_spec_2": "Đảo ngược thân thứ cấp bằng cách trừ đi thân cây được chuyển đổi từ hỗn hợp ban đầu được chuyển đổi",
+    "enable_denoise": "Mô hình chạy trên cả phổ âm và dương để khử nhiễu.",
+    "is_match_mix": "is_match_mix: dự đoán phổ thu được trực tiếp từ đầu ra STFT.",
+    "save_secondary_stem_output_path": "Đang lưu phần gốc {stem_name} vào {stem_output_path}...",
+    "starting_model": "Đang khởi tạo cài đặt mô hình...",
+    "input_info": "Thông số đầu vào của mô hình",
+    "model_settings": "Cài đặt mô hình",
+    "initialize_mix": "Đang khởi tạo kết hợp với is_ckpt = {is_ckpt}. Hình dạng trộn ban đầu: {shape}",
+    "!=2": "Dự kiến có tín hiệu âm thanh 2 kênh nhưng lại có {shape} kênh",
+    "process_check": "Xử lý ở chế độ điểm kiểm tra...",
+    "stft_2": "STFT được áp dụng trên hỗn hợp. Hình dạng quang phổ: {shape}",
+    "cache": "Khoảng đệm được tính toán",
+    "shape": "Hình dạng hỗn hợp sau khi đệm: {shape}, Số phần: {num_chunks}",
+    "process_no_check": "Xử lý ở chế độ không có điểm kiểm tra...",
+    "n_sample_or_pad": "Số lượng mẫu: {n_sample}, Đã tính đệm: {pad}",
+    "shape_2": "Hình dạng hỗn hợp sau khi đệm",
+    "process_part": "Đoạn đã xử lý {mix_waves}: Bắt đầu {i}, Kết thúc {ii}",
+    "mix_waves_to_tensor": "Đã chuyển đổi mix_waves thành tensor. Hình dạng tensor: {shape}",
+    "mix_match": "Chế độ trộn Match; áp dụng hệ số bù.",
+    "tar_waves": "Sóng tar_waves. Hình dạng",
+    "normalization_2": "Chuẩn hóa kết quả bằng cách chia kết quả cho số chia.",
+    "mix_wave": "Đang xử lý lô mix_wave",
+    "mix_or_batch": "Trộn phần chia thành từng đợt. Số lượng lô",
+    "demix_is_match_mix": "Bắt đầu quá trình hủy trộn với is_match_mix,",
+    "mix_shape": "Hỗn hợp phần gốc được lưu trữ. Hình dạng",
+    "chunk_size_or_overlap": "Kích thước đoạn để trộn phù hợp: {chunk_size}, Chồng chéo: {overlap}",
+    "chunk_size_or_overlap_standard": "Kích thước phần tiêu chuẩn: {chunk_size}, Chồng chéo: {overlap}",
+    "calc_size": "Kích thước được tạo được tính toán",
+    "window": "Cửa sổ được áp dụng cho đoạn này.",
+    "process_part_2": "Đang xử lý đoạn {total}/{total_chunks}: Bắt đầu {start}, Kết thúc {end}",
+    "all_process_part": "Tổng số phần cần xử lý",
+    "step_or_overlap": "Kích thước bước để xử lý các phần: {step} khi chồng chéo được đặt thành {overlap}.",
+    "mix_cache": "Hỗn hợp được chuẩn bị với lớp đệm. Hình dạng hỗn hợp",
+    "dims": "Không thể sử dụng mã hóa vị trí sin/cos với thứ nguyên lẻ (có dim={dims})",
+    "activation": "kích hoạt phải là relu/gelu, không phải {activation}",
+    "length_or_training_length": "Độ dài cho trước {length} dài hơn thời lượng huấn luyện {training_length}",
+    "type_not_valid": "Loại không hợp lệ cho",
+    "del_parameter": "Bỏ tham số không tồn tại ",
+    "info": "Các thông số phổ biến: Tên mô hình = {model_name}, Đường dẫn mô hình = {model_path}",
+    "info_2": "Các thông số phổ biến: Đường dẫn đầu ra = {output_dir}, Định dạng đầu ra = {output_format}",
+    "info_3": "Các thông số phổ biến: ngưỡng chuẩn hóa = {normalization_threshold}",
+    "info_4": "Các thông số phổ biến: Kích hoạt khữ nhiễu = {enable_denoise}, Đầu ra một phần = {output_single_stem}",
+    "info_5": "Các thông số phổ biến: Đảo ngược bằng cách sử dụng thông số kỹ thuật = {invert_using_spec}, tỷ lệ mẫu = {sample_rate}",
+    "info_6": "Các thông số phổ biến: Tên phần gốc chính = {primary_stem_name}, Tên phần gốc phụ = {secondary_stem_name}",
+    "info_7": "Các thông số phổ biến: Là Karaoke = {is_karaoke}, là mô hình bv = {is_bv_model}, tái cân bằng mô hình bv = {bv_model_rebalance}",
+    "success_process": "Đang hoàn tất quá trình xử lý phần gốc {stem_name} và ghi âm thanh...",
+    "load_audio": "Đang tải âm thanh từ tập tin",
+    "load_audio_success": "Đã tải âm thanh. Tốc độ mẫu: {sr}, Hình dạng âm thanh: {shape}",
+    "convert_mix": "Chuyển đổi mảng hỗn hợp được cung cấp.",
+    "convert_shape": "Hình dạng hỗn hợp chuyển đổi: {shape}",
+    "audio_not_valid": "Tệp âm thanh {audio_path} trống hoặc không hợp lệ",
+    "audio_valid": "Tệp âm thanh hợp lệ và chứa dữ liệu.",
+    "mix_single": "Hỗn hợp là đơn sắc. Chuyển đổi sang âm thanh nổi.",
+    "convert_mix_audio": "Đã chuyển đổi thành bản trộn âm thanh nổi.",
+    "mix_success_2": "Công tác chuẩn bị hỗn hợp đã hoàn tất.",
+    "duration": "Thời lượng âm thanh là {duration_hours} giờ ({duration_seconds} giây).",
+    "write": "Sử dụng {name} để viết.",
+    "write_audio": "Đang nhập {name} bằng đường dẫn gốc:",
+    "original_not_valid": "Cảnh báo: mảng nguồn gốc gần như im lặng hoặc trống.",
+    "shape_audio": "Hình dạng dữ liệu âm thanh trước khi xử lý",
+    "convert_data": "Kiểu dữ liệu trước khi chuyển đổi",
+    "original_source_to_int16": "Đã chuyển đổi original_source thành int16.",
+    "shape_audio_2": "Hình dạng dữ liệu âm thanh xen kẽ",
+    "create_audiosegment": "Đã tạo AudioSegment hoàn tất.",
+    "create_audiosegment_error": "Lỗi cụ thể khi tạo AudioSegment",
+    "export_error": "Lỗi xuất file âm thanh",
+    "export_success": "Đã xuất hoàn tất tệp âm thanh sang",
+    "clean": "Chạy thu gom rác...",
+    "clean_cache": "Xóa bộ nhớ đệm {name}...",
+    "del_path": "Xóa đường dẫn, nguồn và gốc của tệp âm thanh đầu vào...",
+    "not_success": "Quá trình đăng không hoàn tất: ",
+    "resample_error": "Lỗi trong quá trình lấy mẫu lại",
+    "shapes": "Hình dạng",
+    "wav_resolution": "Loại độ phân giải",
+    "warnings": "Cảnh báo: Đã phát hiện các giá trị cực kỳ hung hãn",
+    "warnings_2": "Cảnh báo: Đã phát hiện NaN hoặc giá trị vô hạn trong đầu vào sóng. Hình dạng",
+    "process_file": "Đang xử lý tập tin... \n",
+    "save_instruments": "Lưu bản nhạc ngược...",
+    "assert": "Các tệp âm thanh phải có hình dạng giống nhau - Mix: {mixshape}, Inst: {instrumentalshape}",
+    "rubberband": "Không thể thực Rubberband. Vui lòng xác minh rằng Rubberband-cli đã được cài đặt.",
+    "rate": "Tỉ lệ phải hoàn toàn tích cực",
+    "gdown_error": "Không thể truy xuất liên kết công khai của tệp. Bạn có thể cần phải thay đổi quyền thành bất kỳ ai có liên kết hoặc đã có nhiều quyền truy cập.",
+    "to": "Đến:",
+    "gdown_value_error": "Phải chỉ định đường dẫn hoặc id",
+    "missing_url": "Thiếu đường dẫn",
+    "mac_not_match": "MAC không khớp",
+    "file_not_access": "Tệp tin không thể truy cập",
+    "int_resp==-3": "Yêu cầu không hoàn tất, đang thử lại",
+    "search_separate": "Tìm bản tách...",
+    "found_choice": "Tìm thấy {choice}",
+    "separator==0": "Không tìm thấy bản tách nào!",
+    "select_separate": "Chọn bản tách",
+    "start_app": "Khởi động giao diện...",
+    "provide_audio": "Nhập đường dẫn đến tệp âm thanh",
+    "set_torch_mps": "Cài đặt thiết bị Torch thành MPS",
+    "googletts": "Chuyển đổi văn bản bằng google",
+    "pitch_info_2": "Cao độ giọng nói của bộ chuyển đổi văn bản",
+    "waveform": "Dạng sóng phải có hình dạng (# khung, # kênh)",
+    "freq_mask_smooth_hz": "freq_mask_smooth_hz cần ít nhất là {hz}Hz",
+    "time_mask_smooth_ms": "time_mask_smooth_ms cần ít nhất là {ms}ms",
+    "x": "x phải lớn hơn",
+    "xn": "xn phải lớn hơn",
+    "not_found_pid": "Không thấy tiến trình nào!",
+    "end_pid": "Đã kết thúc tiến trình!",
+    "not_found_separate_model": "Không tìm thấy tệp mô hình tách nhạc nào!",
+    "not_found_pretrained": "Không tìm thấy tệp mô hình huấn luyện trước nào!",
+    "not_found_log": "Không tìm thấy tệp nhật ký nào!",
+    "not_found_predictors": "Không tìm thấy tệp mô hình dự đoán nào!",
+    "not_found_embedders": "Không tìm thấy tệp mô hình nhúng nào!",
+    "provide_folder": "Vui lòng cung cấp thư mục hợp lệ!",
+    "empty_folder": "Thư mục dữ liệu trống!",
+    "vocoder": "Bộ mã hóa",
+    "vocoder_info": "Bộ mã hóa giọng nói dùng để phân tích và tổng hợp tín hiệu giọng nói của con người để chuyển đổi giọng nói.\n\nDefault: Tùy chọn này là HiFi-GAN-NSF, tương thích với tất cả các RVC\n\nMRF-HiFi-GAN: Độ trung thực cao hơn.\n\nRefineGAN: Chất lượng âm thanh vượt trội.",
+    "code_error": "Lỗi: Nhận mã trạng thái",
+    "json_error": "Lỗi: Không thể phân tích từ phản hồi.",
+    "requests_error": "Yêu cầu thất bại: {e}",
+    "memory_efficient_training": "Sử dụng hiệu quả bộ nhớ",
+    "not_use_pretrain_error_download": "Sẽ không dùng huấn luyện trước vì không có mô hình",
+    "provide_file_settings": "Vui lòng cung cấp tệp cài đặt trước!",
+    "load_presets": "Đã tải tệp cài đặt trước {presets}",
+    "provide_filename_settings": "Vui lòng cung cấp tên tệp cài đặt trước!",
+    "choose1": "Vui lòng chọn 1 để xuất!",
+    "export_settings": "Đã xuất tệp cài đặt trước {name}",
+    "use_presets": "Sử dụng tệp cài đặt trước",
+    "file_preset": "Tệp cài đặt trước",
+    "load_file": "Tải tệp",
+    "export_file": "Xuất tệp cài đặt trước",
+    "save_clean": "Lưu làm sạch",
+    "save_autotune": "Lưu tự điều chỉnh",
+    "save_pitch": "Lưu cao độ",
+    "save_index_2": "Lưu ảnh hưởng chỉ mục",
+    "save_resample": "Lưu lấy mẫu lại",
+    "save_filter": "Lưu trung vị",
+    "save_envelope": "Lưu đường bao âm",
+    "save_protect": "Lưu bảo vệ âm",
+    "save_split": "Lưu cắt âm",
+    "filename_to_save": "Tên khi lưu tệp",
+    "upload_presets": "Tải lên tệp cài đặt",
+    "stop": "Dừng tiến trình",
+    "stop_separate": "Dừng Tách Nhạc",
+    "stop_convert": "Dừng Chuyển Đổi",
+    "stop_create_dataset": "Dừng Tạo Dữ Liệu",
+    "stop_training": "Dừng Huấn Luyện",
+    "stop_extract": "Dừng Xử Lí Dữ Liệu",
+    "stop_preprocess": "Dừng Trích Xuất Dữ Liệu",
+    "not_found_presets": "Không tìm thấy tệp cài đặt sẳn nào trong thư mục!",
+    "port": "Cổng {port} không thể dùng! Giảm cổng xuống một...",
+    "empty_json": "{file}: Bị lỗi hoặc trống",
+    "thank": "Cảm ơn bạn đã báo cáo lỗi và cũng xin lỗi bạn vì sự bất tiện do lỗi gây ra này!",
+    "error_read_log": "Đã xảy ra lỗi khi đọc các tệp nhật ký!",
+    "error_send": "Đã xảy ra lỗi khi gửi báo cáo! Hãy liên hệ tôi qua Discord: pham_huynh_anh!",
+    "report_bugs": "Báo Cáo Lỗi",
+    "agree_log": "Đồng ý cung cấp tất cả tệp nhật ký",
+    "error_info": "Mô tả lỗi",
+    "error_info_2": "Cung cấp thêm thông tin về lỗi",
+    "report_bug_info": "Báo cáo các lỗi xảy ra khi sử dụng chương trình",
+    "sr_info": "LƯU Ý: MỘT SỐ ĐỊNH DẠNG KHÔNG HỖ TRỢ TRÊN 48000",
+    "report_info": "Nếu được bạn hãy đồng ý cung cấp các tệp nhật ký để hỗ trợ quá trình sửa lỗi\n\nNếu không cung cấp các tệp nhật ký bạn hãy mô tả chi tiết lỗi, lỗi xảy ra khi nào ở đâu\n\nNếu hệ thống báo cáo này bị lỗi nốt thì bạn có thể liên hệ qua [ISSUE]({github}) hoặc discord: `pham_huynh_anh`",
+    "default_setting": "Đã xảy ra lỗi khi sử dụng tách, đặt tất cả cài đặt về mặc định...",
+    "dataset_folder1": "Vui lòng nhập tên thư mục dữ liệu",
+    "checkpointing_err": "Các tham số của mô hình đào tạo trước như tốc độ mẫu hoặc kiến trúc không khớp với mô hình đã chọn.",
+    "start_onnx_export": "Bắt đầu chuyển đổi mô hình sang dạng onnx...",
+    "convert_model": "Chuyển Đổi Mô Hình",
+    "pytorch2onnx": "Chuyển Đổi Mô Hình PYTORCH Sang ONNX",
+    "pytorch2onnx_markdown": "Chuyển đổi mô hình RVC từ dạng pytorch sang onnx để tối ưu cho việc chuyển đổi âm thanh",
+    "error_readfile": "Đã xảy ra lỗi khi đọc tệp!",
+    "read_sf": "Đọc tệp âm thanh bằng soundfile...",
+    "read_librosa": "Đọc tệp âm thanh bằng librosa do soundfile không hỗ trợ...",
+    "f0_onnx_mode": "Chế độ F0 ONNX",
+    "f0_onnx_mode_info": "Trích xuất cao độ bằng mô hình ONNX có thể giúp tăng tốc độ",
+    "formantshift": "Dịch chuyển cao độ và âm sắc",
+    "formant_qfrency": "Tần số cho dịch chuyển định dạng",
+    "formant_timbre": "Âm sắc để chuyển đổi định dạng",
+    "time_frames": "Thời Gian (Khung)",
+    "Frequency": "Tần Số (Hz)",
+    "f0_extractor_tab": "Trích xuất F0",
+    "f0_extractor_markdown": "## Trích Xuất Cao Độ",
+    "f0_extractor_markdown_2": "Trích xuất cao độ F0 nhằm mục đích sử dụng cho suy luận chuyển đổi âm thanh",
+    "start_extract": "Bắt đầu quá trình trích xuất...",
+    "extract_done": "Hoàn tất quá trình trích xuất!",
+    "f0_file": "Sử dụng tệp F0 trích xuất trước",
+    "upload_f0": "Tải lên tệp F0",
+    "f0_file_2": "Tệp F0",
+    "clean_f0_file": "Dọp dẹp tệp F0",
+    "embed_mode": "Chế độ nhúng",
+    "embed_mode_info": "Trích xuất nhúng bằng các mô hình khác nhau",
+    "close": "Ứng dụng đang tắt...",
+    "start_whisper": "Bắt đầu nhận dạng giọng nói bằng Whisper...",
+    "whisper_done": "Đã nhận dạng giọng nói hoàn tất!",
+    "process_audio": "Xử lí trước âm thanh...",
+    "process_done_start_convert": "Hoàn tất xử lí âm thanh! tiến hành chuyển đổi âm thanh...",
+    "convert_with_whisper": "Chuyển Đổi Âm Thanh Với Whisper",
+    "convert_with_whisper_info": "Chuyển đổi âm thanh bằng mô hình giọng nói đã được huấn luyện kèm với mô hình Whisper để nhận diện giọng nói\n\nWhisper sẽ nhận dạng các giọng nói khác nhau sau đó cắt các giọng riêng ra rồi dùng mô hình RVC để chuyển đổi lại các phân đoạn đó\n\nMô hình Whisper có thể hoạt động không chính xác làm cho đầu ra có thể kì lạ",
+    "num_spk": "Số lượng giọng",
+    "num_spk_info": "Số lượng giọng nói có trong âm thanh",
+    "model_size": "Kích thước mô hình Whisper",
+    "model_size_info": "Kích thước mô hình Whisper\n\nCác mô hình large có thể đưa ra các đầu ra kì lạ",
+    "editing": "Chỉnh Sửa",
+    "inverting": "Đảo Ngược",
+    "steps": "Bước",
+    "source_prompt": "Lời Nhắc Nguồn",
+    "target_prompt": "Lời Nhắc",
+    "cfg_scale_src": "Hướng Dẫn Nguồn",
+    "cfg_scale_tar": "Hướng Dẫn Mục Tiêu",
+    "t_start": "Mức Độ Chỉnh Sửa",
+    "save_compute": "Chỉnh Sửa Hiệu Quả",
+    "error_edit": "Đã xảy ra lỗi khi chỉnh sửa nhạc nền {e}",
+    "start_edit": "Bắt đầu chỉnh sửa nhạc nền {input_path}...",
+    "edit_success": "Đã hoàn thành chỉnh sửa nhạc nền sau {time} với đầu ra {output_path}",
+    "audio_editing": "Chỉnh Sửa Nhạc Nền",
+    "audio_editing_info": "## Chỉnh Sửa Nhạc Nền Bằng Mô Hình Audioldm2",
+    "audio_editing_markdown": "Chỉnh sửa nhạc nền bằng mô hình của Audioldm2 có thể giúp thay đổi loại nhạc cụ bên trong nhạc nền",
+    "target_prompt_info": "Mô tả đầu ra đã chỉnh sửa mong muốn của bạn",
+    "cfg_scale_src_info": "Mức độ ảnh hưởng của gốc lên kết quả đầu ra. Giá trị cao hơn giữ lại nhiều đặc điểm hơn từ nguồn. Giá trị thấp hơn làm cho hệ thống tự do hơn trong việc biến đổi.",
+    "cfg_scale_tar_info": "Mức độ mục tiêu ảnh hưởng đến kết quả cuối cùng. Giá trị cao hơn sẽ ép kết quả theo đặc điểm của mục tiêu. Giá trị thấp hơn sẽ cân bằng giữa nguồn và mục tiêu.",
+    "audioldm2_model": "Mô hình Audioldm2",
+    "audioldm2_model_info": "Chọn mô hình Audioldm2 theo mong muốn của bạn\n\nViệc tải trọng số và suy luận cũng sẽ tốn nhiều thời gian tùy thuộc vào GPU của bạn",
+    "source_prompt_info": "Tùy chọn: Mô tả đầu vào âm thanh gốc",
+    "t_start_info": "Mức chỉnh sửa thấp hơn sẽ gần với âm thanh gốc hơn, cao hơn sẽ chỉnh sửa mạnh hơn.",
+    "steps_label": "Bước khuếch tán số",
+    "steps_info": "Giá trị cao hơn (ví dụ: 200) tạo ra sản phẩm có chất lượng cao hơn.",
+    "title": "Công cụ huấn luyện, chuyển đổi nhạc cụ và giọng nói chất lượng và hiệu suất cao đơn giản dành cho người Việt",
+    "fp16_not_support": "CPU Không hỗ trợ tốt fp16, chuyển đổi fp16 -> fp32",
+    "precision": "Độ chính xác",
+    "precision_info": "Độ chính xác của suy luận và huấn luyện mô hình\n\nLưu ý: CPU Không hỗ trợ fp16\n\nĐối với RefineGAN và MRF HIFIGAN khi chuyển đổi nên sử dụng fp32 vì fp16 có thể khiến chúng cho ra đầu ra kì lạ",
+    "update_precision": "Cập Nhật Độ Chính Xác",
+    "start_update_precision": "Bắt đầu cập nhật độ chính xác",
+    "deterministic": "Thuật toán xác định",
+    "deterministic_info": "Khi bật sẽ sử dụng các thuật toán có tính xác định cao, đảm bảo rằng mỗi lần chạy cùng một dữ liệu đầu vào sẽ cho kết quả giống nhau.\n\nKhi tắt có thể chọn các thuật toán tối ưu hơn nhưng có thể không hoàn toàn xác định, dẫn đến kết quả huấn luyện có sự khác biệt giữa các lần chạy.",
+    "benchmark": "Thuật toán điểm chuẩn",
+    "benchmark_info": "Khi bật sẽ thử nghiệm và chọn thuật toán tối ưu nhất cho phần cứng và kích thước cụ thể. Điều này có thể giúp tăng tốc độ huấn luyện.\n\nKhi tắt sẽ không thực hiện tối ưu thuật toán này, có thể làm giảm tốc độ nhưng đảm bảo rằng mỗi lần chạy sử dụng cùng một thuật toán, điều này hữu ích nếu bạn muốn tái tạo chính xác.",
+    "font": "Phông chữ",
+    "font_info": "Phông chữ của giao diện\n\nTruy cập vào [Google Font](https://fonts.google.com) để lựa phông yêu thích của bạn.",
+    "change_font": "Đổi Phông Chữ",
+    "f0_unlock": "Mở khóa tất cả",
+    "f0_unlock_info": "Mở khóa toàn bộ phương pháp trích xuất cao độ",
+    "stop_audioldm2": "Dừng chỉnh sửa nhạc",
+    "srt": "Tệp SRT trống hoặc bị lỗi!"
+}

assets/logs/mute/f0/mute.wav.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b9acf9ab7facdb032e1d687fe35182670b0b94566c4b209ae48c239d19956a6
+size 1332

assets/logs/mute/f0_voiced/mute.wav.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30792849c8e72d67e6691754077f2888b101cb741e9c7f193c91dd9692870c87
+size 2536

assets/logs/mute/sliced_audios/mute32000.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9edcf85ec77e88bd01edf3d887bdc418d3596d573f7ad2694da546f41dae6baf
+size 192078

assets/logs/mute/sliced_audios/mute40000.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67a816e77b50cb9f016e49e5c01f07e080c4e3b82b7a8ac3e64bcb143f90f31b
+size 240078

assets/logs/mute/sliced_audios/mute48000.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f2bb4daaa106e351aebb001e5a25de985c0b472f22e8d60676bc924a79056ee
+size 288078

assets/logs/mute/v1_extracted/mute.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64d5abbac078e19a3f649c0d78a02cb33a71407ded3ddf2db78e6b803d0c0126
+size 152704

assets/logs/mute/v2_extracted/mute.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16ef62b957887ac9f0913aa5158f18983afff1ef5a3e4c5fd067ac20fc380d54
+size 457856

assets/logs/mute_spin/f0/mute.wav.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b9acf9ab7facdb032e1d687fe35182670b0b94566c4b209ae48c239d19956a6
+size 1332

assets/logs/mute_spin/f0_voiced/mute.wav.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30792849c8e72d67e6691754077f2888b101cb741e9c7f193c91dd9692870c87
+size 2536

assets/logs/mute_spin/sliced_audios/mute32000.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9edcf85ec77e88bd01edf3d887bdc418d3596d573f7ad2694da546f41dae6baf
+size 192078

assets/logs/mute_spin/sliced_audios/mute40000.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67a816e77b50cb9f016e49e5c01f07e080c4e3b82b7a8ac3e64bcb143f90f31b
+size 240078

assets/logs/mute_spin/sliced_audios/mute48000.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f2bb4daaa106e351aebb001e5a25de985c0b472f22e8d60676bc924a79056ee
+size 288078

assets/logs/mute_spin/v1_extracted/mute.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ec393080466213b7eaa951526d632b92b4d3f9adc3f208bee6d8364fcc0ad0b
+size 152704

assets/logs/mute_spin/v2_extracted/mute.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:997d1ba7055e5567344fe2dbf34be29dd5de70a66cf1cfc32ff98326f957618d
+size 457856

assets/models/speaker_diarization/assets/mel_filters.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7450ae70723a5ef9d341e3cee628c7cb0177f36ce42c44b7ed2bf3325f0f6d4c
+size 4271

assets/png/.g

@@ -0,0 +1 @@
+

docker-compose-cpu.yaml

@@ -0,0 +1,14 @@
+version: '1'
+
+services:
+  rvc:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: rvc
+    ports:
+      - 7865:7865
+    deploy:
+      resources:
+        reservations:
+          devices: []

docker-compose-cuda118.yaml

@@ -0,0 +1,17 @@
+version: '1'
+
+services:
+  rvc:
+    build:
+      context: .
+      dockerfile: Dockerfile.cuda118
+    container_name: rvc
+    ports:
+      - 7865:7865
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]

docker-compose-cuda128.yaml

@@ -0,0 +1,17 @@
+version: '1'
+
+services:
+  rvc:
+    build:
+      context: .
+      dockerfile: Dockerfile.cuda128
+    container_name: rvc
+    ports:
+      - 7865:7865
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]

main/app/based/utils.py

@@ -0,0 +1,1534 @@
+import os
+import re
+import ssl
+import sys
+import json
+import torch
+import codecs
+import shutil
+import asyncio
+import librosa
+import logging
+import datetime
+import platform
+import requests
+import warnings
+import threading
+import subprocess
+import logging.handlers
+
+import numpy as np
+import gradio as gr
+import pandas as pd
+import soundfile as sf
+
+from time import sleep
+from multiprocessing import cpu_count
+
+sys.path.append(os.getcwd())
+
+from main.tools import huggingface
+from main.configs.config import Config
+
+ssl._create_default_https_context = ssl._create_unverified_context
+logger = logging.getLogger(__name__)
+logger.propagate = False
+
+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(os.path.join("assets", "logs", "app.log"), 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)
+
+warnings.filterwarnings("ignore")
+for l in ["httpx", "gradio", "uvicorn", "httpcore", "urllib3"]:
+    logging.getLogger(l).setLevel(logging.ERROR)
+
+config = Config()
+python = sys.executable
+translations = config.translations 
+configs_json = os.path.join("main", "configs", "config.json")
+configs = json.load(open(configs_json, "r"))
+
+os.environ["TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD"] = "1"
+os.environ["TORCH_FORCE_WEIGHTS_ONLY_LOAD"] = "0"
+
+if config.device in ["cpu", "mps"]  and configs.get("fp16", False):
+    logger.warning(translations["fp16_not_support"])
+    configs["fp16"] = config.is_half = False
+    with open(configs_json, "w") as f:
+        json.dump(configs, f, indent=4)
+
+models, model_options = {}, {}
+
+method_f0 = ["mangio-crepe-full", "crepe-full", "fcpe", "rmvpe", "harvest", "pyin"]
+method_f0_full = ["pm", "dio", "mangio-crepe-tiny", "mangio-crepe-small", "mangio-crepe-medium", "mangio-crepe-large", "mangio-crepe-full", "crepe-tiny", "crepe-small", "crepe-medium", "crepe-large", "crepe-full", "fcpe", "fcpe-legacy", "rmvpe", "rmvpe-legacy", "harvest", "yin", "pyin", "swipe"]
+
+embedders_mode = ["fairseq", "onnx", "transformers", "spin"]
+embedders_model = ["contentvec_base", "hubert_base", "japanese_hubert_base", "korean_hubert_base", "chinese_hubert_base", "portuguese_hubert_base", "custom"]
+
+paths_for_files = sorted([os.path.abspath(os.path.join(root, f)) for root, _, files in os.walk("audios") for f in files if os.path.splitext(f)[1].lower() in (".wav", ".mp3", ".flac", ".ogg", ".opus", ".m4a", ".mp4", ".aac", ".alac", ".wma", ".aiff", ".webm", ".ac3")])
+model_name, index_path, delete_index = sorted(list(model for model in os.listdir(os.path.join("assets", "weights")) if model.endswith((".pth", ".onnx")) and not model.startswith("G_") and not model.startswith("D_"))), sorted([os.path.join(root, name) for root, _, files in os.walk(os.path.join("assets", "logs"), topdown=False) for name in files if name.endswith(".index") and "trained" not in name]), sorted([os.path.join("assets", "logs", f) for f in os.listdir(os.path.join("assets", "logs")) if "mute" not in f and os.path.isdir(os.path.join("assets", "logs", f))])
+pretrainedD, pretrainedG, Allpretrained = ([model for model in os.listdir(os.path.join("assets", "models", "pretrained_custom")) if model.endswith(".pth") and "D" in model], [model for model in os.listdir(os.path.join("assets", "models", "pretrained_custom")) if model.endswith(".pth") and "G" in model], [os.path.join("assets", "models", path, model) for path in ["pretrained_v1", "pretrained_v2", "pretrained_custom"] for model in os.listdir(os.path.join("assets", "models", path)) if model.endswith(".pth") and ("D" in model or "G" in model)])
+
+separate_model = sorted([os.path.join("assets", "models", "uvr5", models) for models in os.listdir(os.path.join("assets", "models", "uvr5")) if models.endswith((".th", ".yaml", ".onnx"))])
+presets_file = sorted(list(f for f in os.listdir(os.path.join("assets", "presets")) if f.endswith(".json")))
+f0_file = sorted([os.path.abspath(os.path.join(root, f)) for root, _, files in os.walk(os.path.join("assets", "f0")) for f in files if f.endswith(".txt")])
+
+language, theme, edgetts, google_tts_voice, mdx_model, uvr_model, font = configs.get("language", "vi-VN"), configs.get("theme", "NoCrypt/miku"), configs.get("edge_tts", ["vi-VN-HoaiMyNeural", "vi-VN-NamMinhNeural"]), configs.get("google_tts_voice", ["vi", "en"]), configs.get("mdx_model", "MDXNET_Main"), (configs.get("demucs_model", "HD_MMI") + configs.get("mdx_model", "MDXNET_Main")), configs.get("font", "https://fonts.googleapis.com/css2?family=Courgette&display=swap")
+
+csv_path = os.path.join("assets", "spreadsheet.csv")
+logger.info(config.device)
+
+if "--allow_all_disk" in sys.argv:
+    import win32api
+
+    allow_disk = win32api.GetLogicalDriveStrings().split('\x00')[:-1]
+else: allow_disk = []
+
+if language == "vi-VN": 
+    import gradio.strings
+    gradio.strings.en = {"RUNNING_LOCALLY": "* Chạy trên liên kết nội bộ:  {}://{}:{}", "RUNNING_LOCALLY_SSR": "* Chạy trên liên kết nội bộ:  {}://{}:{}, với SSR ⚡ (thử nghiệm, để tắt hãy dùng `ssr=False` trong `launch()`)", "SHARE_LINK_DISPLAY": "* Chạy trên liên kết công khai: {}", "COULD_NOT_GET_SHARE_LINK": "\nKhông thể tạo liên kết công khai. Vui lòng kiểm tra kết nối mạng của bạn hoặc trang trạng thái của chúng tôi: https://status.gradio.app.", "COULD_NOT_GET_SHARE_LINK_MISSING_FILE": "\nKhông thể tạo liên kết công khai. Thiếu tập tin: {}. \n\nVui lòng kiểm tra kết nối internet của bạn. Điều này có thể xảy ra nếu phần mềm chống vi-rút của bạn chặn việc tải xuống tệp này. Bạn có thể cài đặt thủ công bằng cách làm theo các bước sau: \n\n1. Tải xuống tệp này: {}\n2. Đổi tên tệp đã tải xuống thành: {}\n3. Di chuyển tệp đến vị trí này: {}", "COLAB_NO_LOCAL": "Không thể hiển thị giao diện nội bộ trên google colab, liên kết công khai đã được tạo.", "PUBLIC_SHARE_TRUE": "\nĐể tạo một liên kết công khai, hãy đặt `share=True` trong `launch()`.", "MODEL_PUBLICLY_AVAILABLE_URL": "Mô hình được cung cấp công khai tại: {} (có thể mất tới một phút để sử dụng được liên kết)", "GENERATING_PUBLIC_LINK": "Đang tạo liên kết công khai (có thể mất vài giây...):", "BETA_INVITE": "\nCảm ơn bạn đã là người dùng Gradio! Nếu bạn có thắc mắc hoặc phản hồi, vui lòng tham gia máy chủ Discord của chúng tôi và trò chuyện với chúng tôi: https://discord.gg/feTf9x3ZSB", "COLAB_DEBUG_TRUE": "Đã phát hiện thấy sổ tay Colab. Ô này sẽ chạy vô thời hạn để bạn có thể xem lỗi và nhật ký. " "Để tắt, hãy đặt debug=False trong launch().", "COLAB_DEBUG_FALSE": "Đã phát hiện thấy sổ tay Colab. Để hiển thị lỗi trong sổ ghi chép colab, hãy đặt debug=True trong launch()", "COLAB_WARNING": "Lưu ý: việc mở Chrome Inspector có thể làm hỏng bản demo trong sổ tay Colab.", "SHARE_LINK_MESSAGE": "\nLiên kết công khai sẽ hết hạn sau 72 giờ. Để nâng cấp GPU và lưu trữ vĩnh viễn miễn phí, hãy chạy `gradio deploy` từ terminal trong thư mục làm việc để triển khai lên huggingface (https://huggingface.co/spaces)", "INLINE_DISPLAY_BELOW": "Đang tải giao diện bên dưới...", "COULD_NOT_GET_SHARE_LINK_CHECKSUM": "\nKhông thể tạo liên kết công khai. Tổng kiểm tra không khớp cho tập tin: {}."}
+
+if os.path.exists(csv_path): cached_data = pd.read_csv(csv_path) 
+else:
+    cached_data = pd.read_csv(codecs.decode("uggcf://qbpf.tbbtyr.pbz/fcernqfurrgf/q/1gNHnDeRULtEfz1Yieaw14USUQjWJy0Oq9k0DrCrjApb/rkcbeg?sbezng=pfi&tvq=1977693859", "rot13"))
+    cached_data.to_csv(csv_path, index=False)
+
+for _, row in cached_data.iterrows():
+    filename = row['Filename']
+    url = None
+
+    for value in row.values:
+        if isinstance(value, str) and "huggingface" in value:
+            url = value
+            break
+
+    if url: models[filename] = url
+
+
+
+def gr_info(message):
+    gr.Info(message, duration=2)
+    logger.info(message)
+
+def gr_warning(message):
+    gr.Warning(message, duration=2)
+    logger.warning(message)
+
+def gr_error(message):
+    gr.Error(message=message, duration=6)
+    logger.error(message)
+
+def get_gpu_info():
+    ngpu = torch.cuda.device_count()
+    gpu_infos = [f"{i}: {torch.cuda.get_device_name(i)} ({int(torch.cuda.get_device_properties(i).total_memory / 1024 / 1024 / 1024 + 0.4)} GB)" for i in range(ngpu) if torch.cuda.is_available() or ngpu != 0]
+    return "\n".join(gpu_infos) if len(gpu_infos) > 0 else translations["no_support_gpu"]
+
+def change_f0_choices(): 
+    f0_file = sorted([os.path.abspath(os.path.join(root, f)) for root, _, files in os.walk(os.path.join("assets", "f0")) for f in files if f.endswith(".txt")])
+    return {"value": f0_file[0] if len(f0_file) >= 1 else "", "choices": f0_file, "__type__": "update"}
+
+def change_audios_choices(input_audio): 
+    audios = sorted([os.path.abspath(os.path.join(root, f)) for root, _, files in os.walk("audios") for f in files if os.path.splitext(f)[1].lower() in (".wav", ".mp3", ".flac", ".ogg", ".opus", ".m4a", ".mp4", ".aac", ".alac", ".wma", ".aiff", ".webm", ".ac3")])
+    return {"value": input_audio if input_audio != "" else (audios[0] if len(audios) >= 1 else ""), "choices": audios, "__type__": "update"}
+
+def change_separate_choices():
+    return [{"choices": sorted([os.path.join("assets", "models", "uvr5", models) for models in os.listdir(os.path.join("assets", "models", "uvr5")) if model.endswith((".th", ".yaml", ".onnx"))]), "__type__": "update"}]
+
+def change_models_choices():
+    model, index = sorted(list(model for model in os.listdir(os.path.join("assets", "weights")) if model.endswith((".pth", ".onnx")) and not model.startswith("G_") and not model.startswith("D_"))), sorted([os.path.join(root, name) for root, _, files in os.walk(os.path.join("assets", "logs"), topdown=False) for name in files if name.endswith(".index") and "trained" not in name])
+    return [{"value": model[0] if len(model) >= 1 else "", "choices": model, "__type__": "update"}, {"value": index[0] if len(index) >= 1 else "", "choices": index, "__type__": "update"}]
+
+def change_allpretrained_choices():
+    return [{"choices": sorted([os.path.join("assets", "models", path, model) for path in ["pretrained_v1", "pretrained_v2", "pretrained_custom"] for model in os.listdir(os.path.join("assets", "models", path)) if model.endswith(".pth") and ("D" in model or "G" in model)]), "__type__": "update"}]
+
+def change_pretrained_choices():
+    return [{"choices": sorted([model for model in os.listdir(os.path.join("assets", "models", "pretrained_custom")) if model.endswith(".pth") and "D" in model]), "__type__": "update"}, {"choices": sorted([model for model in os.listdir(os.path.join("assets", "models", "pretrained_custom")) if model.endswith(".pth") and "G" in model]), "__type__": "update"}]
+
+def change_choices_del():
+    return [{"choices": sorted(list(model for model in os.listdir(os.path.join("assets", "weights")) if model.endswith(".pth") and not model.startswith("G_") and not model.startswith("D_"))), "__type__": "update"}, {"choices": sorted([os.path.join("assets", "logs", f) for f in os.listdir(os.path.join("assets", "logs")) if "mute" not in f and os.path.isdir(os.path.join("assets", "logs", f))]), "__type__": "update"}]
+
+def change_preset_choices():
+    return {"value": "", "choices": sorted(list(f for f in os.listdir(os.path.join("assets", "presets")) if f.endswith(".json"))), "__type__": "update"}
+
+def change_tts_voice_choices(google):
+    return {"choices": google_tts_voice if google else edgetts, "value": google_tts_voice[0] if google else edgetts[0], "__type__": "update"}
+
+def change_backing_choices(backing, merge):
+    if backing or merge: return {"value": False, "interactive": False, "__type__": "update"}
+    elif not backing or not merge: return  {"interactive": True, "__type__": "update"}
+    else: gr_warning(translations["option_not_valid"])
+
+def change_download_choices(select):
+    selects = [False]*10
+
+    if select == translations["download_url"]: selects[0] = selects[1] = selects[2] = True
+    elif select == translations["download_from_csv"]:  selects[3] = selects[4] = True
+    elif select == translations["search_models"]: selects[5] = selects[6] = True
+    elif select == translations["upload"]: selects[9] = True
+    else: gr_warning(translations["option_not_valid"])
+
+    return [{"visible": selects[i], "__type__": "update"} for i in range(len(selects))]
+
+def change_download_pretrained_choices(select):
+    selects = [False]*8
+
+    if select == translations["download_url"]: selects[0] = selects[1] = selects[2] = True
+    elif select == translations["list_model"]: selects[3] = selects[4] = selects[5] = True
+    elif select == translations["upload"]: selects[6] = selects[7] = True
+    else: gr_warning(translations["option_not_valid"])
+
+    return [{"visible": selects[i], "__type__": "update"} for i in range(len(selects))]
+
+def get_index(model):
+    model = os.path.basename(model).split("_")[0]
+    return {"value": next((f for f in [os.path.join(root, name) for root, _, files in os.walk(os.path.join("assets", "logs"), topdown=False) for name in files if name.endswith(".index") and "trained" not in name] if model.split(".")[0] in f), ""), "__type__": "update"} if model else None
+
+def index_strength_show(index):
+    return {"visible": index != "" and os.path.exists(index), "value": 0.5, "__type__": "update"}
+
+def hoplength_show(method, hybrid_method=None):
+    show_hop_length_method = ["mangio-crepe-tiny", "mangio-crepe-small", "mangio-crepe-medium", "mangio-crepe-large", "mangio-crepe-full", "fcpe", "fcpe-legacy", "yin", "pyin"]
+
+    if method in show_hop_length_method: visible = True
+    elif method == "hybrid":
+        methods_str = re.search("hybrid\[(.+)\]", hybrid_method)
+        if methods_str: methods = [method.strip() for method in methods_str.group(1).split("+")]
+
+        for i in methods:
+            visible = i in show_hop_length_method
+            if visible: break
+    else: visible = False
+    
+    return {"visible": visible, "__type__": "update"}
+
+def visible(value):
+    return {"visible": value, "__type__": "update"}
+
+def valueFalse_interactive(inp): 
+    return {"value": False, "interactive": inp, "__type__": "update"}
+
+def valueEmpty_visible1(inp1): 
+    return {"value": "", "visible": inp1, "__type__": "update"}
+
+def process_input(file_path):
+    file_contents = ""
+
+    if not file_path.endswith(".srt"):
+        with open(file_path, "r", encoding="utf-8") as file:
+            file_contents = file.read()
+
+    gr_info(translations["upload_success"].format(name=translations["text"]))
+    return file_contents
+
+def fetch_pretrained_data():
+    response = requests.get(codecs.decode("uggcf://uhttvatsnpr.pb/NauC/Ivrganzrfr-EIP-Cebwrpg/erfbyir/znva/wfba/phfgbz_cergenvarq.wfba", "rot13"))
+    response.raise_for_status()
+
+    return response.json()
+
+def update_sample_rate_dropdown(model):
+    data = fetch_pretrained_data()
+    if model != translations["success"]: return {"choices": list(data[model].keys()), "value": list(data[model].keys())[0], "__type__": "update"}
+
+def if_done(done, p):
+    while 1:
+        if p.poll() is None: sleep(0.5)
+        else: break
+
+    done[0] = True
+
+def restart_app():
+    global app
+
+    gr_info(translations["15s"])
+    os.system("cls" if platform.system() == "Windows" else "clear")
+    
+    app.close()
+    subprocess.run([python, os.path.join("main", "app", "app.py")] + sys.argv[1:])
+
+def change_language(lang):
+    configs = json.load(open(configs_json, "r"))
+    configs["language"] = lang
+
+    with open(configs_json, "w") as f:
+        json.dump(configs, f, indent=4)
+
+    restart_app()
+
+def change_theme(theme):
+    with open(configs_json, "r") as f:
+        configs = json.load(f)
+
+    configs["theme"] = theme
+    with open(configs_json, "w") as f:
+        json.dump(configs, f, indent=4)
+
+    restart_app()
+
+def change_font(font):
+    with open(configs_json, "r") as f:
+        configs = json.load(f)
+
+    configs["font"] = font
+    with open(configs_json, "w") as f:
+        json.dump(configs, f, indent=4)
+
+    restart_app()
+
+def zip_file(name, pth, index):
+    pth_path = os.path.join("assets", "weights", pth)
+    if not pth or not os.path.exists(pth_path) or not pth.endswith((".pth", ".onnx")): return gr_warning(translations["provide_file"].format(filename=translations["model"]))
+
+    zip_file_path = os.path.join("assets", "logs", name, name + ".zip")
+    gr_info(translations["start"].format(start=translations["zip"]))
+
+    import zipfile
+    with zipfile.ZipFile(zip_file_path, 'w') as zipf:
+        zipf.write(pth_path, os.path.basename(pth_path))
+        if index: zipf.write(index, os.path.basename(index))
+
+    gr_info(translations["success"])
+    return {"visible": True, "value": zip_file_path, "__type__": "update"}
+
+def fetch_models_data(search):
+    all_table_data = [] 
+    page = 1 
+
+    while 1:
+        try:
+            response = requests.post(url=codecs.decode("uggcf://ibvpr-zbqryf.pbz/srgpu_qngn.cuc", "rot13"), data={"page": page, "search": search})
+
+            if response.status_code == 200:
+                table_data = response.json().get("table", "")
+                if not table_data.strip(): break  
+                all_table_data.append(table_data)
+                page += 1
+            else:
+                logger.debug(f"{translations['code_error']} {response.status_code}")
+                break  
+        except json.JSONDecodeError:
+            logger.debug(translations["json_error"])
+            break
+        except requests.RequestException as e:
+            logger.debug(translations["requests_error"].format(e=e))
+            break
+    return all_table_data
+
+def search_models(name):
+    gr_info(translations["start"].format(start=translations["search"]))
+    tables = fetch_models_data(name)
+
+    if len(tables) == 0:
+        gr_info(translations["not_found"].format(name=name))
+        return [None]*2
+    else:
+        model_options.clear()
+        
+        from bs4 import BeautifulSoup
+
+        for table in tables:
+            for row in BeautifulSoup(table, "html.parser").select("tr"):
+                name_tag, url_tag = row.find("a", {"class": "fs-5"}), row.find("a", {"class": "btn btn-sm fw-bold btn-light ms-0 p-1 ps-2 pe-2"})
+                url = url_tag["href"].replace("https://easyaivoice.com/run?url=", "")
+                if "huggingface" in url:
+                    if name_tag and url_tag: model_options[name_tag.text.replace(".onnx", "").replace(".pth", "").replace(".index", "").replace(".zip", "").replace(" ", "_").replace("(", "").replace(")", "").replace("[", "").replace("]", "").replace(",", "").replace('"', "").replace("'", "").replace("|", "").strip()] = url
+
+        gr_info(translations["found"].format(results=len(model_options)))
+        return [{"value": "", "choices": model_options, "interactive": True, "visible": True, "__type__": "update"}, {"value": translations["downloads"], "visible": True, "__type__": "update"}]
+
+def move_files_from_directory(src_dir, dest_weights, dest_logs, model_name):
+    for root, _, files in os.walk(src_dir):
+        for file in files:
+            file_path = os.path.join(root, file)
+            if file.endswith(".index"):
+                model_log_dir = os.path.join(dest_logs, model_name)
+                os.makedirs(model_log_dir, exist_ok=True)
+
+                filepath = os.path.join(model_log_dir, file.replace(' ', '_').replace('(', '').replace(')', '').replace('[', '').replace(']', '').replace(",", "").replace('"', "").replace("'", "").replace("|", "").strip())
+                if os.path.exists(filepath): os.remove(filepath)
+
+                shutil.move(file_path, filepath)
+            elif file.endswith(".pth") and not file.startswith("D_") and not file.startswith("G_"):
+                pth_path = os.path.join(dest_weights, model_name + ".pth")
+                if os.path.exists(pth_path): os.remove(pth_path)
+
+                shutil.move(file_path, pth_path)
+            elif file.endswith(".onnx") and not file.startswith("D_") and not file.startswith("G_"):
+                pth_path = os.path.join(dest_weights, model_name + ".onnx")
+                if os.path.exists(pth_path): os.remove(pth_path)
+
+                shutil.move(file_path, pth_path)
+
+def download_url(url):
+    import yt_dlp
+
+    if not url: return gr_warning(translations["provide_url"])
+    if not os.path.exists("audios"): os.makedirs("audios", exist_ok=True)
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore")
+        ydl_opts = {"format": "bestaudio/best", "postprocessors": [{"key": "FFmpegExtractAudio", "preferredcodec": "wav", "preferredquality": "192"}], "quiet": True, "no_warnings": True, "noplaylist": True, "verbose": False}
+
+        gr_info(translations["start"].format(start=translations["download_music"]))
+
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            audio_output = os.path.join("audios", re.sub(r'\s+', '-', re.sub(r'[^\w\s\u4e00-\u9fff\uac00-\ud7af\u0400-\u04FF\u1100-\u11FF]', '', ydl.extract_info(url, download=False).get('title', 'video')).strip()))
+            if os.path.exists(audio_output): shutil.rmtree(audio_output, ignore_errors=True)
+
+            ydl_opts['outtmpl'] = audio_output
+            
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl: 
+            audio_output = audio_output + ".wav"
+            if os.path.exists(audio_output): os.remove(audio_output)
+            
+            ydl.download([url])
+
+        gr_info(translations["success"])
+        return [audio_output, audio_output, translations["success"]]
+
+def download_model(url=None, model=None):
+    if not url: return gr_warning(translations["provide_url"])
+    if not model: return gr_warning(translations["provide_name_is_save"])
+
+    model = model.replace(".onnx", "").replace(".pth", "").replace(".index", "").replace(".zip", "").replace(" ", "_").replace("(", "").replace(")", "").replace("[", "").replace("]", "").replace(",", "").replace('"', "").replace("'", "").replace("|", "").strip()
+    url = url.replace("/blob/", "/resolve/").replace("?download=true", "").strip()
+
+    download_dir = os.path.join("download_model")
+    weights_dir = os.path.join("assets", "weights")
+    logs_dir = os.path.join("assets", "logs")
+
+    if not os.path.exists(download_dir): os.makedirs(download_dir, exist_ok=True)
+    if not os.path.exists(weights_dir): os.makedirs(weights_dir, exist_ok=True)
+    if not os.path.exists(logs_dir): os.makedirs(logs_dir, exist_ok=True)
+    
+    try:
+        gr_info(translations["start"].format(start=translations["download"]))
+
+        if url.endswith(".pth"): huggingface.HF_download_file(url, os.path.join(weights_dir, f"{model}.pth"))
+        elif url.endswith(".onnx"): huggingface.HF_download_file(url, os.path.join(weights_dir, f"{model}.onnx"))
+        elif url.endswith(".index"):
+            model_log_dir = os.path.join(logs_dir, model)
+            os.makedirs(model_log_dir, exist_ok=True)
+
+            huggingface.HF_download_file(url, os.path.join(model_log_dir, f"{model}.index"))
+        elif url.endswith(".zip"):
+            output_path = huggingface.HF_download_file(url, os.path.join(download_dir, model + ".zip"))
+            shutil.unpack_archive(output_path, download_dir)
+
+            move_files_from_directory(download_dir, weights_dir, logs_dir, model)
+        else:
+            if "drive.google.com" in url or "drive.usercontent.google.com" in url:
+                file_id = None
+
+                from main.tools import gdown
+
+                if "/file/d/" in url: file_id = url.split("/d/")[1].split("/")[0]
+                elif "open?id=" in url: file_id = url.split("open?id=")[1].split("/")[0]
+                elif "/download?id=" in url: file_id = url.split("/download?id=")[1].split("&")[0]
+                
+                if file_id:
+                    file = gdown.gdown_download(id=file_id, output=download_dir)
+                    if file.endswith(".zip"): shutil.unpack_archive(file, download_dir)
+
+                    move_files_from_directory(download_dir, weights_dir, logs_dir, model)
+            elif "mega.nz" in url:
+                from main.tools import meganz
+                
+                meganz.mega_download_url(url, download_dir)
+
+                file_download = next((f for f in os.listdir(download_dir)), None)
+                if file_download.endswith(".zip"): shutil.unpack_archive(os.path.join(download_dir, file_download), download_dir)
+
+                move_files_from_directory(download_dir, weights_dir, logs_dir, model)
+            elif "mediafire.com" in url:
+                from main.tools import mediafire
+
+                file = mediafire.Mediafire_Download(url, download_dir)
+                if file.endswith(".zip"): shutil.unpack_archive(file, download_dir)
+
+                move_files_from_directory(download_dir, weights_dir, logs_dir, model)
+            elif "pixeldrain.com" in url:
+                from main.tools import pixeldrain
+
+                file = pixeldrain.pixeldrain(url, download_dir)
+                if file.endswith(".zip"): shutil.unpack_archive(file, download_dir)
+
+                move_files_from_directory(download_dir, weights_dir, logs_dir, model)
+            else:
+                gr_warning(translations["not_support_url"])
+                return translations["not_support_url"]
+        
+        gr_info(translations["success"])
+        return translations["success"]
+    except Exception as e:
+        gr_error(message=translations["error_occurred"].format(e=e))
+        logger.debug(e)
+        return translations["error_occurred"].format(e=e)
+    finally:
+        shutil.rmtree(download_dir, ignore_errors=True)
+
+def save_drop_model(dropbox):
+    weight_folder = os.path.join("assets", "weights")
+    logs_folder = os.path.join("assets", "logs")
+    save_model_temp = os.path.join("save_model_temp")
+
+    if not os.path.exists(weight_folder): os.makedirs(weight_folder, exist_ok=True)
+    if not os.path.exists(logs_folder): os.makedirs(logs_folder, exist_ok=True)
+    if not os.path.exists(save_model_temp): os.makedirs(save_model_temp, exist_ok=True)
+
+    shutil.move(dropbox, save_model_temp)
+
+    try:
+        file_name = os.path.basename(dropbox)
+
+        if file_name.endswith(".pth") and file_name.endswith(".onnx") and file_name.endswith(".index"): gr_warning(translations["not_model"])
+        else:    
+            if file_name.endswith(".zip"):
+                shutil.unpack_archive(os.path.join(save_model_temp, file_name), save_model_temp)
+                move_files_from_directory(save_model_temp, weight_folder, logs_folder, file_name.replace(".zip", ""))
+            elif file_name.endswith((".pth", ".onnx")): 
+                output_file = os.path.join(weight_folder, file_name)
+                if os.path.exists(output_file): os.remove(output_file)
+                
+                shutil.move(os.path.join(save_model_temp, file_name), output_file)
+            elif file_name.endswith(".index"):
+                def extract_name_model(filename):
+                    match = re.search(r"([A-Za-z]+)(?=_v|\.|$)", filename)
+                    return match.group(1) if match else None
+                
+                model_logs = os.path.join(logs_folder, extract_name_model(file_name))
+                if not os.path.exists(model_logs): os.makedirs(model_logs, exist_ok=True)
+                shutil.move(os.path.join(save_model_temp, file_name), model_logs)
+            else: 
+                gr_warning(translations["unable_analyze_model"])
+                return None
+        
+        gr_info(translations["upload_success"].format(name=translations["model"]))
+        return None
+    except Exception as e:
+        gr_error(message=translations["error_occurred"].format(e=e))
+        logger.debug(e)
+        return None
+    finally:
+        shutil.rmtree(save_model_temp, ignore_errors=True)
+
+def download_pretrained_model(choices, model, sample_rate):
+    pretraineds_custom_path = os.path.join("assets", "models", "pretrained_custom")
+    if choices == translations["list_model"]:
+        paths = fetch_pretrained_data()[model][sample_rate]
+
+        if not os.path.exists(pretraineds_custom_path): os.makedirs(pretraineds_custom_path, exist_ok=True)
+        url = codecs.decode("uggcf://uhttvatsnpr.pb/NauC/Ivrganzrfr-EIP-Cebwrpg/erfbyir/znva/cergenvarq_phfgbz/", "rot13") + paths
+
+        gr_info(translations["download_pretrain"])
+        file = huggingface.HF_download_file(url.replace("/blob/", "/resolve/").replace("?download=true", "").strip(), os.path.join(pretraineds_custom_path, paths))
+
+        if file.endswith(".zip"): 
+            shutil.unpack_archive(file, pretraineds_custom_path)
+            os.remove(file)
+
+        gr_info(translations["success"])
+        return translations["success"]
+    elif choices == translations["download_url"]:
+        if not model: return gr_warning(translations["provide_pretrain"].format(dg="D"))
+        if not sample_rate: return gr_warning(translations["provide_pretrain"].format(dg="G"))
+
+        gr_info(translations["download_pretrain"])
+
+        huggingface.HF_download_file(model.replace("/blob/", "/resolve/").replace("?download=true", "").strip(), pretraineds_custom_path)
+        huggingface.HF_download_file(sample_rate.replace("/blob/", "/resolve/").replace("?download=true", "").strip(), pretraineds_custom_path)
+
+        gr_info(translations["success"])
+        return translations["success"]
+
+def fushion_model_pth(name, pth_1, pth_2, ratio):
+    if not name.endswith(".pth"): name = name + ".pth"
+
+    if not pth_1 or not os.path.exists(pth_1) or not pth_1.endswith(".pth"):
+        gr_warning(translations["provide_file"].format(filename=translations["model"] + " 1"))
+        return [translations["provide_file"].format(filename=translations["model"] + " 1"), None]
+    
+    if not pth_2 or not os.path.exists(pth_2) or not pth_2.endswith(".pth"):
+        gr_warning(translations["provide_file"].format(filename=translations["model"] + " 2"))
+        return [translations["provide_file"].format(filename=translations["model"] + " 2"), None]
+    
+    from collections import OrderedDict
+
+    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
+    
+    try:
+        ckpt1 = torch.load(pth_1, map_location="cpu")
+        ckpt2 = torch.load(pth_2, map_location="cpu")
+
+        if ckpt1["sr"] != ckpt2["sr"]: 
+            gr_warning(translations["sr_not_same"])
+            return [translations["sr_not_same"], None]
+
+        cfg = ckpt1["config"]
+        cfg_f0 = ckpt1["f0"]
+        cfg_version = ckpt1["version"]
+        cfg_sr = ckpt1["sr"]
+
+        vocoder = ckpt1.get("vocoder", "Default")
+
+        ckpt1 = extract(ckpt1) if "model" in ckpt1 else ckpt1["weight"]
+        ckpt2 = extract(ckpt2) if "model" in ckpt2 else ckpt2["weight"]
+
+        if sorted(list(ckpt1.keys())) != sorted(list(ckpt2.keys())): 
+            gr_warning(translations["architectures_not_same"])
+            return [translations["architectures_not_same"], None]
+         
+        gr_info(translations["start"].format(start=translations["fushion_model"]))
+
+        opt = OrderedDict()
+        opt["weight"] = {}
+
+        for key in ckpt1.keys():
+            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] = (ratio * (ckpt1[key][:min_shape0].float()) + (1 - ratio) * (ckpt2[key][:min_shape0].float())).half()
+            else: opt["weight"][key] = (ratio * (ckpt1[key].float()) + (1 - ratio) * (ckpt2[key].float())).half()
+
+        opt["config"] = cfg
+        opt["sr"] = cfg_sr
+        opt["f0"] = cfg_f0
+        opt["version"] = cfg_version
+        opt["infos"] = translations["model_fushion_info"].format(name=name, pth_1=pth_1, pth_2=pth_2, ratio=ratio)
+        opt["vocoder"] = vocoder
+
+        output_model = os.path.join("assets", "weights")
+        if not os.path.exists(output_model): os.makedirs(output_model, exist_ok=True)
+
+        torch.save(opt, os.path.join(output_model, name))
+
+        gr_info(translations["success"])
+        return [translations["success"], os.path.join(output_model, name)]
+    except Exception as e:
+        gr_error(message=translations["error_occurred"].format(e=e))
+        logger.debug(e)
+        return [e, None]
+
+def fushion_model(name, path_1, path_2, ratio):
+    if not name:
+        gr_warning(translations["provide_name_is_save"]) 
+        return [translations["provide_name_is_save"], None]
+
+    if path_1.endswith(".pth") and path_2.endswith(".pth"): return fushion_model_pth(name.replace(".onnx", ".pth"), path_1, path_2, ratio)
+    else:
+        gr_warning(translations["format_not_valid"])
+        return [None, None]
+    
+def onnx_export(model_path):
+    from main.library.algorithm.onnx_export import onnx_exporter
+    
+    if not model_path.endswith(".pth"): model_path + ".pth"
+    if not model_path or not os.path.exists(model_path) or not model_path.endswith(".pth"):
+        gr_warning(translations["provide_file"].format(filename=translations["model"]))
+        return [None, translations["provide_file"].format(filename=translations["model"])]
+    
+    try:
+        gr_info(translations["start_onnx_export"])
+        output = onnx_exporter(model_path, model_path.replace(".pth", ".onnx"), is_half=config.is_half, device=config.device)
+
+        gr_info(translations["success"])
+        return [output, translations["success"]]
+    except Exception as e:
+        return [None, e]
+    
+def model_info(path):
+    if not path or not os.path.exists(path) or os.path.isdir(path) or not path.endswith((".pth", ".onnx")): return gr_warning(translations["provide_file"].format(filename=translations["model"]))
+    
+    def prettify_date(date_str):
+        if date_str == translations["not_found_create_time"]: return None
+
+        try:
+            return datetime.datetime.strptime(date_str, "%Y-%m-%dT%H:%M:%S.%f").strftime("%Y-%m-%d %H:%M:%S")
+        except ValueError as e:
+            logger.debug(e)
+            return translations["format_not_valid"]
+    
+    if path.endswith(".pth"): model_data = torch.load(path, map_location=torch.device("cpu"))
+    else:
+        import onnx
+        
+        model = onnx.load(path)
+        model_data = None
+
+        for prop in model.metadata_props:
+            if prop.key == "model_info":
+                model_data = json.loads(prop.value)
+                break
+
+    gr_info(translations["read_info"])
+
+    epochs = model_data.get("epoch", None)
+    if epochs is None: 
+        epochs = model_data.get("info", None)
+        try:
+            epoch = epochs.replace("epoch", "").replace("e", "").isdigit()
+            if epoch and epochs is None: epochs = translations["not_found"].format(name=translations["epoch"])
+        except: 
+            pass
+
+    steps = model_data.get("step", translations["not_found"].format(name=translations["step"]))
+    sr = model_data.get("sr", translations["not_found"].format(name=translations["sr"]))
+    f0 = model_data.get("f0", translations["not_found"].format(name=translations["f0"]))
+    version = model_data.get("version", translations["not_found"].format(name=translations["version"]))
+    creation_date = model_data.get("creation_date", translations["not_found_create_time"])
+    model_hash = model_data.get("model_hash", translations["not_found"].format(name="model_hash"))
+    pitch_guidance = translations["trained_f0"] if f0 else translations["not_f0"]
+    creation_date_str = prettify_date(creation_date) if creation_date else translations["not_found_create_time"]
+    model_name = model_data.get("model_name", translations["unregistered"])
+    model_author = model_data.get("author", translations["not_author"])
+    vocoder = model_data.get("vocoder", "Default")
+
+    gr_info(translations["success"])
+    return translations["model_info"].format(model_name=model_name, model_author=model_author, epochs=epochs, steps=steps, version=version, sr=sr, pitch_guidance=pitch_guidance, model_hash=model_hash, creation_date_str=creation_date_str, vocoder=vocoder)
+
+def audio_effects(input_path, output_path, resample, resample_sr, chorus_depth, chorus_rate, chorus_mix, chorus_delay, chorus_feedback, distortion_drive, reverb_room_size, reverb_damping, reverb_wet_level, reverb_dry_level, reverb_width, reverb_freeze_mode, pitch_shift, delay_seconds, delay_feedback, delay_mix, compressor_threshold, compressor_ratio, compressor_attack_ms, compressor_release_ms, limiter_threshold, limiter_release, gain_db, bitcrush_bit_depth, clipping_threshold, phaser_rate_hz, phaser_depth, phaser_centre_frequency_hz, phaser_feedback, phaser_mix, bass_boost_db, bass_boost_frequency, treble_boost_db, treble_boost_frequency, fade_in_duration, fade_out_duration, export_format, chorus, distortion, reverb, delay, compressor, limiter, gain, bitcrush, clipping, phaser, treble_bass_boost, fade_in_out, audio_combination, audio_combination_input):
+    if not input_path or not os.path.exists(input_path) or os.path.isdir(input_path): 
+        gr_warning(translations["input_not_valid"])
+        return None
+        
+    if not output_path:
+        gr_warning(translations["output_not_valid"])
+        return None
+    
+    if os.path.isdir(output_path): output_path = os.path.join(output_path, f"audio_effects.{export_format}")
+    output_dir = os.path.dirname(output_path) or output_path
+
+    if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True)
+    if os.path.exists(output_path): os.remove(output_path)
+    
+    gr_info(translations["start"].format(start=translations["apply_effect"]))
+    subprocess.run([python, "main/inference/audio_effects.py", "--input_path", input_path, "--output_path", output_path, "--resample", str(resample), "--resample_sr", str(resample_sr), "--chorus_depth", str(chorus_depth), "--chorus_rate", str(chorus_rate), "--chorus_mix", str(chorus_mix), "--chorus_delay", str(chorus_delay), "--chorus_feedback", str(chorus_feedback), "--drive_db", str(distortion_drive), "--reverb_room_size", str(reverb_room_size), "--reverb_damping", str(reverb_damping), "--reverb_wet_level", str(reverb_wet_level), "--reverb_dry_level", str(reverb_dry_level), "--reverb_width", str(reverb_width), "--reverb_freeze_mode", str(reverb_freeze_mode), "--pitch_shift", str(pitch_shift), "--delay_seconds", str(delay_seconds), "--delay_feedback", str(delay_feedback), "--delay_mix", str(delay_mix), "--compressor_threshold", str(compressor_threshold), "--compressor_ratio", str(compressor_ratio), "--compressor_attack_ms", str(compressor_attack_ms), "--compressor_release_ms", str(compressor_release_ms), "--limiter_threshold", str(limiter_threshold), "--limiter_release", str(limiter_release), "--gain_db", str(gain_db), "--bitcrush_bit_depth", str(bitcrush_bit_depth), "--clipping_threshold", str(clipping_threshold), "--phaser_rate_hz", str(phaser_rate_hz), "--phaser_depth", str(phaser_depth), "--phaser_centre_frequency_hz", str(phaser_centre_frequency_hz), "--phaser_feedback", str(phaser_feedback), "--phaser_mix", str(phaser_mix), "--bass_boost_db", str(bass_boost_db), "--bass_boost_frequency", str(bass_boost_frequency), "--treble_boost_db", str(treble_boost_db), "--treble_boost_frequency", str(treble_boost_frequency), "--fade_in_duration", str(fade_in_duration), "--fade_out_duration", str(fade_out_duration), "--export_format", export_format, "--chorus", str(chorus), "--distortion", str(distortion), "--reverb", str(reverb), "--pitchshift", str(pitch_shift != 0), "--delay", str(delay), "--compressor", str(compressor), "--limiter", str(limiter), "--gain", str(gain), "--bitcrush", str(bitcrush), "--clipping", str(clipping), "--phaser", str(phaser), "--treble_bass_boost", str(treble_bass_boost), "--fade_in_out", str(fade_in_out), "--audio_combination", str(audio_combination), "--audio_combination_input", audio_combination_input])
+
+    gr_info(translations["success"])
+    return output_path.replace("wav", export_format)
+
+def synthesize_tts(prompt, voice, speed, output, pitch, google):
+    if not google: 
+        from edge_tts import Communicate
+
+        asyncio.run(Communicate(text=prompt, voice=voice, rate=f"+{speed}%" if speed >= 0 else f"{speed}%", pitch=f"+{pitch}Hz" if pitch >= 0 else f"{pitch}Hz").save(output))
+    else: 
+        response = requests.get(codecs.decode("uggcf://genafyngr.tbbtyr.pbz/genafyngr_ggf", "rot13"), params={"ie": "UTF-8", "q": prompt, "tl": voice, "ttsspeed": speed, "client": "tw-ob"}, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36"})
+
+        if response.status_code == 200:
+            with open(output, "wb") as f:
+                f.write(response.content)
+
+            if pitch != 0 or speed != 0:
+                y, sr = librosa.load(output, sr=None)
+
+                if pitch != 0: y = librosa.effects.pitch_shift(y, sr=sr, n_steps=pitch)
+                if speed != 0: y = librosa.effects.time_stretch(y, rate=speed)
+
+                sf.write(file=output, data=y, samplerate=sr, format=os.path.splitext(os.path.basename(output))[-1].lower().replace('.', ''))
+        else: gr_error(f"{response.status_code}, {response.text}")
+
+def time_stretch(y, sr, target_duration):
+    rate = (len(y) / sr) / target_duration
+    if rate != 1.0: y = librosa.effects.time_stretch(y=y.astype(np.float32), rate=rate)
+
+    n_target = int(round(target_duration * sr))
+    return np.pad(y, (0, n_target - len(y))) if len(y) < n_target else y[:n_target]
+
+def pysrttime_to_seconds(t):
+    return (t.hours * 60 + t.minutes) * 60 + t.seconds + t.milliseconds / 1000
+
+def srt_tts(srt_file, out_file, voice, rate = 0, sr = 24000, google = False):
+    import pysrt
+    import tempfile
+
+    subs = pysrt.open(srt_file)
+    if not subs: raise ValueError(translations["srt"])
+
+    final_audio = np.zeros(int(round(pysrttime_to_seconds(subs[-1].end) * sr)), dtype=np.float32)
+
+    with tempfile.TemporaryDirectory() as tempdir:
+        for idx, seg in enumerate(subs):
+            wav_path = os.path.join(tempdir, f"seg_{idx}.wav")
+            synthesize_tts(" ".join(seg.text.splitlines()), voice, 0, wav_path, rate, google)
+
+            audio, file_sr = sf.read(wav_path, dtype=np.float32)
+            if file_sr != sr: audio = np.interp(np.linspace(0, len(audio) - 1, int(len(audio) * sr / file_sr)), np.arange(len(audio)), audio)
+            adjusted = time_stretch(audio, sr, pysrttime_to_seconds(seg.duration))
+
+            start_sample = int(round(pysrttime_to_seconds(seg.start) * sr))
+            end_sample = start_sample + adjusted.shape[0]
+
+            if end_sample > final_audio.shape[0]:
+                adjusted = adjusted[: final_audio.shape[0] - start_sample]
+                end_sample = final_audio.shape[0]
+
+            final_audio[start_sample:end_sample] += adjusted
+
+    sf.write(out_file, final_audio, sr)
+
+def TTS(prompt, voice, speed, output, pitch, google, srt_input):
+    if not srt_input: srt_input = ""
+
+    if not prompt and not srt_input.endswith(".srt"):
+        gr_warning(translations["enter_the_text"])
+        return None
+    
+    if not voice:
+        gr_warning(translations["choose_voice"])
+        return None
+    
+    if not output: 
+        gr_warning(translations["output_not_valid"])
+        return None
+    
+    if os.path.isdir(output): output = os.path.join(output, f"tts.wav")
+    gr_info(translations["convert"].format(name=translations["text"]))
+
+    output_dir = os.path.dirname(output) or output
+    if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True)
+
+    if srt_input.endswith(".srt"): srt_tts(srt_input, output, voice, 0, 24000, google)
+    else: synthesize_tts(prompt, voice, speed, output, pitch, google)
+
+    gr_info(translations["success"])
+    return output
+
+def separator_music(input, output_audio, format, shifts, segments_size, overlap, clean_audio, clean_strength, denoise, separator_model, kara_model, backing, reverb, backing_reverb, hop_length, batch_size, sample_rate):
+    output = os.path.dirname(output_audio) or output_audio
+
+    if not input or not os.path.exists(input) or os.path.isdir(input): 
+        gr_warning(translations["input_not_valid"])
+        return [None]*4
+    
+    if not os.path.exists(output): 
+        gr_warning(translations["output_not_valid"])
+        return [None]*4
+
+    if not os.path.exists(output): os.makedirs(output)
+    gr_info(translations["start"].format(start=translations["separator_music"]))
+
+    subprocess.run([python, "main/inference/separator_music.py", "--input_path", input, "--output_path", output, "--format", format, "--shifts", str(shifts), "--segments_size", str(segments_size), "--overlap", str(overlap), "--mdx_hop_length", str(hop_length), "--mdx_batch_size", str(batch_size), "--clean_audio", str(clean_audio), "--clean_strength", str(clean_strength), "--kara_model", kara_model, "--backing", str(backing), "--mdx_denoise", str(denoise), "--reverb", str(reverb), "--backing_reverb", str(backing_reverb), "--model_name", separator_model, "--sample_rate", str(sample_rate)])
+    gr_info(translations["success"])
+
+    filename, _ = os.path.splitext(os.path.basename(input))
+    output = os.path.join(output, filename)
+
+    return [os.path.join(output, f"Original_Vocals_No_Reverb.{format}") if reverb else os.path.join(output, f"Original_Vocals.{format}"), os.path.join(output, f"Instruments.{format}"), (os.path.join(output, f"Main_Vocals_No_Reverb.{format}") if reverb else os.path.join(output, f"Main_Vocals.{format}") if backing else None), (os.path.join(output, f"Backing_Vocals_No_Reverb.{format}") if backing_reverb else os.path.join(output, f"Backing_Vocals.{format}") if backing else None)] if os.path.isfile(input) else [None]*4
+
+def convert(pitch, filter_radius, index_rate, volume_envelope, protect, hop_length, f0_method, input_path, output_path, pth_path, index_path, f0_autotune, clean_audio, clean_strength, export_format, embedder_model, resample_sr, split_audio, f0_autotune_strength, checkpointing, onnx_f0_mode, embedders_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file):    
+    subprocess.run([python, "main/inference/convert.py", "--pitch", str(pitch), "--filter_radius", str(filter_radius), "--index_rate", str(index_rate), "--volume_envelope", str(volume_envelope), "--protect", str(protect), "--hop_length", str(hop_length), "--f0_method", f0_method, "--input_path", input_path, "--output_path", output_path, "--pth_path", pth_path, "--index_path", index_path if index_path else "", "--f0_autotune", str(f0_autotune), "--clean_audio", str(clean_audio), "--clean_strength", str(clean_strength), "--export_format", export_format, "--embedder_model", embedder_model, "--resample_sr", str(resample_sr), "--split_audio", str(split_audio), "--f0_autotune_strength", str(f0_autotune_strength), "--checkpointing", str(checkpointing), "--f0_onnx", str(onnx_f0_mode), "--embedders_mode", embedders_mode, "--formant_shifting", str(formant_shifting), "--formant_qfrency", str(formant_qfrency), "--formant_timbre", str(formant_timbre), "--f0_file", f0_file])
+
+def convert_audio(clean, autotune, use_audio, use_original, convert_backing, not_merge_backing, merge_instrument, pitch, clean_strength, model, index, index_rate, input, output, format, method, hybrid_method, hop_length, embedders, custom_embedders, resample_sr, filter_radius, volume_envelope, protect, split_audio, f0_autotune_strength, input_audio_name, checkpointing, onnx_f0_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file, embedders_mode):
+    model_path = os.path.join("assets", "weights", model)
+
+    return_none = [None]*6
+    return_none[5] = {"visible": True, "__type__": "update"}
+
+    if not use_audio:
+        if merge_instrument or not_merge_backing or convert_backing or use_original:
+            gr_warning(translations["turn_on_use_audio"])
+            return return_none
+
+    if use_original:
+        if convert_backing:
+            gr_warning(translations["turn_off_convert_backup"])
+            return return_none
+        elif not_merge_backing:
+            gr_warning(translations["turn_off_merge_backup"])
+            return return_none
+
+    if not model or not os.path.exists(model_path) or os.path.isdir(model_path) or not model.endswith((".pth", ".onnx")):
+        gr_warning(translations["provide_file"].format(filename=translations["model"]))
+        return return_none
+
+    f0method, embedder_model = (method if method != "hybrid" else hybrid_method), (embedders if embedders != "custom" else custom_embedders)
+
+    if use_audio:
+        output_audio = os.path.join("audios", input_audio_name)
+
+        from main.library.utils import pydub_convert, pydub_load
+        
+        def get_audio_file(label):
+            matching_files = [f for f in os.listdir(output_audio) if label in f]
+
+            if not matching_files: return translations["notfound"]   
+            return os.path.join(output_audio, matching_files[0])
+
+        output_path = os.path.join(output_audio, f"Convert_Vocals.{format}")
+        output_backing = os.path.join(output_audio, f"Convert_Backing.{format}")
+        output_merge_backup = os.path.join(output_audio, f"Vocals+Backing.{format}")
+        output_merge_instrument = os.path.join(output_audio, f"Vocals+Instruments.{format}")
+
+        if os.path.exists(output_audio): os.makedirs(output_audio, exist_ok=True)
+        if os.path.exists(output_path): os.remove(output_path)
+
+        if use_original:
+            original_vocal = get_audio_file('Original_Vocals_No_Reverb.')
+
+            if original_vocal == translations["notfound"]: original_vocal = get_audio_file('Original_Vocals.')
+
+            if original_vocal == translations["notfound"]: 
+                gr_warning(translations["not_found_original_vocal"])
+                return return_none
+            
+            input_path = original_vocal
+        else:
+            main_vocal = get_audio_file('Main_Vocals_No_Reverb.')
+            backing_vocal = get_audio_file('Backing_Vocals_No_Reverb.')
+
+            if main_vocal == translations["notfound"]: main_vocal = get_audio_file('Main_Vocals.')
+            if not not_merge_backing and backing_vocal == translations["notfound"]: backing_vocal = get_audio_file('Backing_Vocals.')
+
+            if main_vocal == translations["notfound"]: 
+                gr_warning(translations["not_found_main_vocal"])
+                return return_none
+            
+            if not not_merge_backing and backing_vocal == translations["notfound"]: 
+                gr_warning(translations["not_found_backing_vocal"])
+                return return_none
+            
+            input_path = main_vocal
+            backing_path = backing_vocal
+
+        gr_info(translations["convert_vocal"])
+
+        convert(pitch, filter_radius, index_rate, volume_envelope, protect, hop_length, f0method, input_path, output_path, model_path, index, autotune, clean, clean_strength, format, embedder_model, resample_sr, split_audio, f0_autotune_strength, checkpointing, onnx_f0_mode, embedders_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file)
+
+        gr_info(translations["convert_success"])
+
+        if convert_backing:
+            if os.path.exists(output_backing): os.remove(output_backing)
+
+            gr_info(translations["convert_backup"])
+
+            convert(pitch, filter_radius, index_rate, volume_envelope, protect, hop_length, f0method, backing_path, output_backing, model_path, index, autotune, clean, clean_strength, format, embedder_model, resample_sr, split_audio, f0_autotune_strength, checkpointing, onnx_f0_mode, embedders_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file)
+
+            gr_info(translations["convert_backup_success"])
+
+        try:
+            if not not_merge_backing and not use_original:
+                backing_source = output_backing if convert_backing else backing_vocal
+
+                if os.path.exists(output_merge_backup): os.remove(output_merge_backup)
+
+                gr_info(translations["merge_backup"])
+
+                pydub_convert(pydub_load(output_path)).overlay(pydub_convert(pydub_load(backing_source))).export(output_merge_backup, format=format)
+
+                gr_info(translations["merge_success"])
+
+            if merge_instrument:    
+                vocals = output_merge_backup if not not_merge_backing and not use_original else output_path
+
+                if os.path.exists(output_merge_instrument): os.remove(output_merge_instrument)
+
+                gr_info(translations["merge_instruments_process"])
+
+                instruments = get_audio_file('Instruments.')
+                
+                if instruments == translations["notfound"]: 
+                    gr_warning(translations["not_found_instruments"])
+                    output_merge_instrument = None
+                else: pydub_convert(pydub_load(instruments)).overlay(pydub_convert(pydub_load(vocals))).export(output_merge_instrument, format=format)
+                
+                gr_info(translations["merge_success"])
+        except:
+            return return_none
+
+        return [(None if use_original else output_path), output_backing, (None if not_merge_backing and use_original else output_merge_backup), (output_path if use_original else None), (output_merge_instrument if merge_instrument else None), {"visible": True, "__type__": "update"}]
+    else:
+        if not input or not os.path.exists(input) or os.path.isdir(input): 
+            gr_warning(translations["input_not_valid"])
+            return return_none
+        
+        if not output:
+            gr_warning(translations["output_not_valid"])
+            return return_none
+        
+        output = output.replace("wav", format)
+
+        if os.path.isdir(input):
+            gr_info(translations["is_folder"])
+
+            if not [f for f in os.listdir(input) if f.lower().endswith(("wav", "mp3", "flac", "ogg", "opus", "m4a", "mp4", "aac", "alac", "wma", "aiff", "webm", "ac3"))]:
+                gr_warning(translations["not_found_in_folder"])
+                return return_none
+            
+            gr_info(translations["batch_convert"])
+
+            output_dir = os.path.dirname(output) or output
+            convert(pitch, filter_radius, index_rate, volume_envelope, protect, hop_length, f0method, input, output_dir, model_path, index, autotune, clean, clean_strength, format, embedder_model, resample_sr, split_audio, f0_autotune_strength, checkpointing, onnx_f0_mode, embedders_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file)
+
+            gr_info(translations["batch_convert_success"])
+
+            return return_none
+        else:
+            output_dir = os.path.dirname(output) or output
+
+            if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True)
+            if os.path.exists(output): os.remove(output)
+
+            gr_info(translations["convert_vocal"])
+
+            convert(pitch, filter_radius, index_rate, volume_envelope, protect, hop_length, f0method, input, output, model_path, index, autotune, clean, clean_strength, format, embedder_model, resample_sr, split_audio, f0_autotune_strength, checkpointing, onnx_f0_mode, embedders_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file)
+
+            gr_info(translations["convert_success"])
+
+            return_none[0] = output
+            return return_none
+
+def convert_selection(clean, autotune, use_audio, use_original, convert_backing, not_merge_backing, merge_instrument, pitch, clean_strength, model, index, index_rate, input, output, format, method, hybrid_method, hop_length, embedders, custom_embedders, resample_sr, filter_radius, volume_envelope, protect, split_audio, f0_autotune_strength, checkpointing, onnx_f0_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file, embedders_mode):
+    if use_audio:
+        gr_info(translations["search_separate"])
+
+        choice = [f for f in os.listdir("audios") if os.path.isdir(os.path.join("audios", f))]
+
+        gr_info(translations["found_choice"].format(choice=len(choice)))
+
+        if len(choice) == 0: 
+            gr_warning(translations["separator==0"])
+
+            return [{"choices": [], "value": "", "interactive": False, "visible": False, "__type__": "update"}, None, None, None, None, None, {"visible": True, "__type__": "update"}]
+        elif len(choice) == 1:
+            convert_output = convert_audio(clean, autotune, use_audio, use_original, convert_backing, not_merge_backing, merge_instrument, pitch, clean_strength, model, index, index_rate, None, None, format, method, hybrid_method, hop_length, embedders, custom_embedders, resample_sr, filter_radius, volume_envelope, protect, split_audio, f0_autotune_strength, choice[0], checkpointing, onnx_f0_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file, embedders_mode)
+
+            return [{"choices": [], "value": "", "interactive": False, "visible": False, "__type__": "update"}, convert_output[0], convert_output[1], convert_output[2], convert_output[3], convert_output[4], {"visible": True, "__type__": "update"}]
+        else: return [{"choices": choice, "value": "", "interactive": True, "visible": True, "__type__": "update"}, None, None, None, None, None, {"visible": False, "__type__": "update"}]
+    else:
+        main_convert = convert_audio(clean, autotune, use_audio, use_original, convert_backing, not_merge_backing, merge_instrument, pitch, clean_strength, model, index, index_rate, input, output, format, method, hybrid_method, hop_length, embedders, custom_embedders, resample_sr, filter_radius, volume_envelope, protect, split_audio, f0_autotune_strength, None, checkpointing, onnx_f0_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file, embedders_mode)
+
+        return [{"choices": [], "value": "", "interactive": False, "visible": False, "__type__": "update"}, main_convert[0], None, None, None, None, {"visible": True, "__type__": "update"}]
+    
+def convert_with_whisper(num_spk, model_size, cleaner, clean_strength, autotune, f0_autotune_strength, checkpointing, model_1, model_2, model_index_1, model_index_2, pitch_1, pitch_2, index_strength_1, index_strength_2, export_format, input_audio, output_audio, onnx_f0_mode, method, hybrid_method, hop_length, embed_mode, embedders, custom_embedders, resample_sr, filter_radius, volume_envelope, protect, formant_shifting, formant_qfrency_1, formant_timbre_1, formant_qfrency_2, formant_timbre_2):
+    from pydub import AudioSegment
+    from sklearn.cluster import AgglomerativeClustering
+    
+    from main.library.speaker_diarization.audio import Audio
+    from main.library.speaker_diarization.segment import Segment
+    from main.library.speaker_diarization.whisper import load_model
+    from main.library.utils import check_spk_diarization, pydub_convert, pydub_load
+    from main.library.speaker_diarization.embedding import SpeechBrainPretrainedSpeakerEmbedding
+    
+    check_spk_diarization(model_size)
+    model_pth_1, model_pth_2 = os.path.join("assets", "weights", model_1), os.path.join("assets", "weights", model_2)
+
+    if (not model_1 or not os.path.exists(model_pth_1) or os.path.isdir(model_pth_1) or not model_pth_1.endswith((".pth", ".onnx"))) and (not model_2 or not os.path.exists(model_pth_2) or os.path.isdir(model_pth_2) or not model_pth_2.endswith((".pth", ".onnx"))):
+        gr_warning(translations["provide_file"].format(filename=translations["model"]))
+        return None
+    
+    if not model_1: model_pth_1 = model_pth_2
+    if not model_2: model_pth_2 = model_pth_1
+
+    if not input_audio or not os.path.exists(input_audio) or os.path.isdir(input_audio): 
+        gr_warning(translations["input_not_valid"])
+        return None
+        
+    if not output_audio:
+        gr_warning(translations["output_not_valid"])
+        return None
+    
+    if os.path.exists(output_audio): os.remove(output_audio)
+    gr_info(translations["start_whisper"])
+    
+    try:
+        audio = Audio()
+
+        embedding_model = SpeechBrainPretrainedSpeakerEmbedding(device=config.device)
+        segments = load_model(model_size, device=config.device).transcribe(input_audio, fp16=configs.get("fp16", False), word_timestamps=True)["segments"]
+
+        y, sr = librosa.load(input_audio, sr=None)  
+        duration = len(y) / sr
+            
+        def segment_embedding(segment):
+            waveform, _ = audio.crop(input_audio, Segment(segment["start"], min(duration, segment["end"])))
+            return embedding_model(waveform.mean(dim=0, keepdim=True)[None] if waveform.shape[0] == 2 else waveform[None])  
+        
+        def time(secs):
+            return datetime.timedelta(seconds=round(secs))
+        
+        def merge_audio(files_list, time_stamps, original_file_path, output_path, format):
+            def extract_number(filename):
+                match = re.search(r'_(\d+)', filename)
+                return int(match.group(1)) if match else 0
+
+            total_duration = len(pydub_load(original_file_path))
+            combined = AudioSegment.empty() 
+            current_position = 0 
+
+            for file, (start_i, end_i) in zip(sorted(files_list, key=extract_number), time_stamps):
+                if start_i > current_position: combined += AudioSegment.silent(duration=start_i - current_position)  
+                
+                combined += pydub_load(file)  
+                current_position = end_i
+
+            if current_position < total_duration: combined += AudioSegment.silent(duration=total_duration - current_position)
+            combined.export(output_path, format=format)
+
+            return output_path
+
+        embeddings = np.zeros(shape=(len(segments), 192))
+        for i, segment in enumerate(segments):
+            embeddings[i] = segment_embedding(segment)
+
+        labels = AgglomerativeClustering(num_spk).fit(np.nan_to_num(embeddings)).labels_
+        for i in range(len(segments)):
+            segments[i]["speaker"] = 'SPEAKER ' + str(labels[i] + 1)
+
+        merged_segments, current_text = [], []
+        current_speaker, current_start = None, None
+
+        for i, segment in enumerate(segments):
+            speaker = segment["speaker"]
+            start_time = segment["start"]
+            text = segment["text"][1:]  
+
+            if speaker == current_speaker:
+                current_text.append(text)
+                end_time = segment["end"]
+            else:
+                if current_speaker is not None: merged_segments.append({"speaker": current_speaker, "start": current_start, "end": end_time, "text": " ".join(current_text)})
+                
+                current_speaker = speaker
+                current_start = start_time
+                current_text = [text]
+                end_time = segment["end"]
+
+        if current_speaker is not None: merged_segments.append({"speaker": current_speaker, "start": current_start, "end": end_time, "text": " ".join(current_text)})
+
+        gr_info(translations["whisper_done"])
+
+        x = ""
+        for segment in merged_segments:
+            x += f"\n{segment['speaker']} {str(time(segment['start']))} - {str(time(segment['end']))}\n"
+            x += segment["text"] + "\n"
+
+        logger.info(x)
+
+        gr_info(translations["process_audio"])
+
+        audio = pydub_convert(pydub_load(input_audio))
+        output_folder = "audios_temp"
+
+        if os.path.exists(output_folder): shutil.rmtree(output_folder, ignore_errors=True)
+        for f in [output_folder, os.path.join(output_folder, "1"), os.path.join(output_folder, "2")]:
+            os.makedirs(f, exist_ok=True)
+
+        time_stamps, processed_segments = [], []
+        for i, segment in enumerate(merged_segments):
+            start_ms = int(segment["start"] * 1000) 
+            end_ms = int(segment["end"] * 1000)
+
+            index = i + 1
+
+            segment_filename = os.path.join(output_folder, "1" if i % 2 == 1 else "2", f"segment_{index}.wav")
+            audio[start_ms:end_ms].export(segment_filename, format="wav")
+
+            processed_segments.append(os.path.join(output_folder, "1" if i % 2 == 1 else "2", f"segment_{index}_output.wav"))
+            time_stamps.append((start_ms, end_ms))
+
+        f0method, embedder_model = (method if method != "hybrid" else hybrid_method), (embedders if embedders != "custom" else custom_embedders)
+
+        gr_info(translations["process_done_start_convert"])
+
+        convert(pitch_1, filter_radius, index_strength_1, volume_envelope, protect, hop_length, f0method, os.path.join(output_folder, "1"), output_folder, model_pth_1, model_index_1, autotune, cleaner, clean_strength, "wav", embedder_model, resample_sr, False, f0_autotune_strength, checkpointing, onnx_f0_mode, embed_mode, formant_shifting, formant_qfrency_1, formant_timbre_1, "")
+        convert(pitch_2, filter_radius, index_strength_2, volume_envelope, protect, hop_length, f0method, os.path.join(output_folder, "2"), output_folder, model_pth_2, model_index_2, autotune, cleaner, clean_strength, "wav", embedder_model, resample_sr, False, f0_autotune_strength, checkpointing, onnx_f0_mode, embed_mode, formant_shifting, formant_qfrency_2, formant_timbre_2, "")
+
+        gr_info(translations["convert_success"])
+        return merge_audio(processed_segments, time_stamps, input_audio, output_audio.replace("wav", export_format), export_format)
+    except Exception as e:
+        gr_error(translations["error_occurred"].format(e=e))
+        import traceback
+        logger.debug(traceback.format_exc())
+        return None
+    finally:
+        if os.path.exists("audios_temp"): shutil.rmtree("audios_temp", ignore_errors=True)
+
+def convert_tts(clean, autotune, pitch, clean_strength, model, index, index_rate, input, output, format, method, hybrid_method, hop_length, embedders, custom_embedders, resample_sr, filter_radius, volume_envelope, protect, split_audio, f0_autotune_strength, checkpointing, onnx_f0_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file, embedders_mode):
+    model_path = os.path.join("assets", "weights", model)
+
+    if not model_path or not os.path.exists(model_path) or os.path.isdir(model_path) or not model.endswith((".pth", ".onnx")):
+        gr_warning(translations["provide_file"].format(filename=translations["model"]))
+        return None
+
+    if not input or not os.path.exists(input): 
+        gr_warning(translations["input_not_valid"])
+        return None
+    
+    if os.path.isdir(input): 
+        input_audio = [f for f in os.listdir(input) if "tts" in f and f.lower().endswith(("wav", "mp3", "flac", "ogg", "opus", "m4a", "mp4", "aac", "alac", "wma", "aiff", "webm", "ac3"))]
+        
+        if not input_audio:
+            gr_warning(translations["not_found_in_folder"])
+            return None
+        
+        input = os.path.join(input, input_audio[0])
+    
+    if not output:
+        gr_warning(translations["output_not_valid"])
+        return None
+    
+    output = output.replace("wav", format)
+    if os.path.isdir(output): output = os.path.join(output, f"tts.{format}")
+
+    output_dir = os.path.dirname(output)
+    if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True)
+    
+    if os.path.exists(output): os.remove(output)
+
+    f0method = method if method != "hybrid" else hybrid_method
+    embedder_model = embedders if embedders != "custom" else custom_embedders
+
+    gr_info(translations["convert_vocal"])
+
+    convert(pitch, filter_radius, index_rate, volume_envelope, protect, hop_length, f0method, input, output, model_path, index, autotune, clean, clean_strength, format, embedder_model, resample_sr, split_audio, f0_autotune_strength, checkpointing, onnx_f0_mode, embedders_mode, formant_shifting, formant_qfrency, formant_timbre, f0_file)
+
+    gr_info(translations["convert_success"])
+    return output
+
+def log_read(log_file, done):
+    f = open(log_file, "w", encoding="utf-8")
+    f.close()
+
+    while 1:
+        with open(log_file, "r", encoding="utf-8") as f:
+            yield "".join(line for line in f.readlines() if "DEBUG" not in line and line.strip() != "")
+
+        sleep(1)
+        if done[0]: break
+
+    with open(log_file, "r", encoding="utf-8") as f:
+        log = "".join(line for line in f.readlines() if "DEBUG" not in line and line.strip() != "")
+
+    yield log
+
+def create_dataset(input_audio, output_dataset, clean_dataset, clean_strength, separator_reverb, kim_vocals_version, overlap, segments_size, denoise_mdx, skip, skip_start, skip_end, hop_length, batch_size, sample_rate):
+    version = 1 if kim_vocals_version == "Version-1" else 2
+
+    gr_info(translations["start"].format(start=translations["create"]))
+
+    p = subprocess.Popen(f'{python} main/inference/create_dataset.py --input_audio "{input_audio}" --output_dataset "{output_dataset}" --clean_dataset {clean_dataset} --clean_strength {clean_strength} --separator_reverb {separator_reverb} --kim_vocal_version {version} --overlap {overlap} --segments_size {segments_size} --mdx_hop_length {hop_length} --mdx_batch_size {batch_size} --denoise_mdx {denoise_mdx} --skip {skip} --skip_start_audios "{skip_start}" --skip_end_audios "{skip_end}" --sample_rate {sample_rate}', shell=True)
+    done = [False]
+
+    threading.Thread(target=if_done, args=(done, p)).start()
+
+    for log in log_read(os.path.join("assets", "logs", "create_dataset.log"), done):
+        yield log
+
+def preprocess(model_name, sample_rate, cpu_core, cut_preprocess, process_effects, path, clean_dataset, clean_strength):
+    dataset = os.path.join(path)
+    sr = int(float(sample_rate.rstrip("k")) * 1000)
+
+    if not model_name: return gr_warning(translations["provide_name"])
+    if not any(f.lower().endswith(("wav", "mp3", "flac", "ogg", "opus", "m4a", "mp4", "aac", "alac", "wma", "aiff", "webm", "ac3")) for f in os.listdir(dataset) if os.path.isfile(os.path.join(dataset, f))): return gr_warning(translations["not_found_data"])
+    
+    model_dir = os.path.join("assets", "logs", model_name)
+    if os.path.exists(model_dir): shutil.rmtree(model_dir, ignore_errors=True)
+
+    p = subprocess.Popen(f'{python} main/inference/preprocess.py --model_name "{model_name}" --dataset_path "{dataset}" --sample_rate {sr} --cpu_cores {cpu_core} --cut_preprocess {cut_preprocess} --process_effects {process_effects} --clean_dataset {clean_dataset} --clean_strength {clean_strength}', shell=True)
+    done = [False]
+
+    threading.Thread(target=if_done, args=(done, p)).start()
+    os.makedirs(model_dir, exist_ok=True)
+
+    for log in log_read(os.path.join(model_dir, "preprocess.log"), done):
+        yield log
+
+def extract(model_name, version, method, pitch_guidance, hop_length, cpu_cores, gpu, sample_rate, embedders, custom_embedders, onnx_f0_mode, embedders_mode):
+    embedder_model = embedders if embedders != "custom" else custom_embedders
+    sr = int(float(sample_rate.rstrip("k")) * 1000)
+
+    if not model_name: return gr_warning(translations["provide_name"])
+
+    model_dir = os.path.join("assets", "logs", model_name)
+    if not any(os.path.isfile(os.path.join(model_dir, "sliced_audios", f)) for f in os.listdir(os.path.join(model_dir, "sliced_audios"))) or not any(os.path.isfile(os.path.join(model_dir, "sliced_audios_16k", f)) for f in os.listdir(os.path.join(model_dir, "sliced_audios_16k"))): return gr_warning(translations["not_found_data_preprocess"])
+
+    p = subprocess.Popen(f'{python} main/inference/extract.py --model_name "{model_name}" --rvc_version {version} --f0_method {method} --pitch_guidance {pitch_guidance} --hop_length {hop_length} --cpu_cores {cpu_cores} --gpu {gpu} --sample_rate {sr} --embedder_model {embedder_model} --f0_onnx {onnx_f0_mode} --embedders_mode {embedders_mode}', shell=True)
+    done = [False]
+
+    threading.Thread(target=if_done, args=(done, p)).start()
+    os.makedirs(model_dir, exist_ok=True)
+
+    for log in log_read(os.path.join(model_dir, "extract.log"), done):
+        yield log
+
+def create_index(model_name, rvc_version, index_algorithm):
+    if not model_name: return gr_warning(translations["provide_name"])
+    model_dir = os.path.join("assets", "logs", model_name)
+
+    if not any(os.path.isfile(os.path.join(model_dir, f"{rvc_version}_extracted", f)) for f in os.listdir(os.path.join(model_dir, f"{rvc_version}_extracted"))): return gr_warning(translations["not_found_data_extract"])
+
+    p = subprocess.Popen(f'{python} main/inference/create_index.py --model_name "{model_name}" --rvc_version {rvc_version} --index_algorithm {index_algorithm}', shell=True)
+    done = [False]
+
+    threading.Thread(target=if_done, args=(done, p)).start()
+    os.makedirs(model_dir, exist_ok=True)
+
+    for log in log_read(os.path.join(model_dir, "create_index.log"), done):
+        yield log
+
+def training(model_name, rvc_version, save_every_epoch, save_only_latest, save_every_weights, total_epoch, sample_rate, batch_size, gpu, pitch_guidance, not_pretrain, custom_pretrained, pretrain_g, pretrain_d, detector, threshold, clean_up, cache, model_author, vocoder, checkpointing, deterministic, benchmark):
+    sr = int(float(sample_rate.rstrip("k")) * 1000)
+    if not model_name: return gr_warning(translations["provide_name"])
+
+    model_dir = os.path.join("assets", "logs", model_name)
+    if os.path.exists(os.path.join(model_dir, "train_pid.txt")): os.remove(os.path.join(model_dir, "train_pid.txt"))
+
+    if not any(os.path.isfile(os.path.join(model_dir, f"{rvc_version}_extracted", f)) for f in os.listdir(os.path.join(model_dir, f"{rvc_version}_extracted"))): return gr_warning(translations["not_found_data_extract"])
+
+    if not not_pretrain:
+        if not custom_pretrained: 
+            pretrained_selector = {True: {32000: ("f0G32k.pth", "f0D32k.pth"), 40000: ("f0G40k.pth", "f0D40k.pth"), 48000: ("f0G48k.pth", "f0D48k.pth")}, False: {32000: ("G32k.pth", "D32k.pth"), 40000: ("G40k.pth", "D40k.pth"), 48000: ("G48k.pth", "D48k.pth")}}
+
+            pg, pd = pretrained_selector[pitch_guidance][sr]
+        else:
+            if not pretrain_g: return gr_warning(translations["provide_pretrained"].format(dg="G"))
+            if not pretrain_d: return gr_warning(translations["provide_pretrained"].format(dg="D"))
+            
+            pg, pd = pretrain_g, pretrain_d
+
+        pretrained_G, pretrained_D = (os.path.join("assets", "models", f"pretrained_{rvc_version}", f"{vocoder}_{pg}" if vocoder != 'Default' else pg), os.path.join("assets", "models", f"pretrained_{rvc_version}", f"{vocoder}_{pd}" if vocoder != 'Default' else pd)) if not custom_pretrained else (os.path.join("assets", "models", f"pretrained_custom", pg), os.path.join("assets", "models", f"pretrained_custom", pd))
+        download_version = codecs.decode(f"uggcf://uhttvatsnpr.pb/NauC/Ivrganzrfr-EIP-Cebwrpg/erfbyir/znva/cergenvarq_i{'2' if rvc_version == 'v2' else '1'}/", "rot13")
+        
+        if not custom_pretrained:
+            try:
+                if not os.path.exists(pretrained_G):
+                    gr_info(translations["download_pretrained"].format(dg="G", rvc_version=rvc_version))
+                    huggingface.HF_download_file("".join([download_version, vocoder, "_", pg]) if vocoder != 'Default' else (download_version + pg), os.path.join("assets", "models", f"pretrained_{rvc_version}", f"{vocoder}_{pg}" if vocoder != 'Default' else pg))
+                        
+                if not os.path.exists(pretrained_D):
+                    gr_info(translations["download_pretrained"].format(dg="D", rvc_version=rvc_version))
+                    huggingface.HF_download_file("".join([download_version, vocoder, "_", pd]) if vocoder != 'Default' else (download_version + pd), os.path.join("assets", "models", f"pretrained_{rvc_version}", f"{vocoder}_{pd}" if vocoder != 'Default' else pd))
+            except:
+                gr_warning(translations["not_use_pretrain_error_download"])
+                pretrained_G, pretrained_D = None, None
+        else:
+            if not os.path.exists(pretrained_G): return gr_warning(translations["not_found_pretrain"].format(dg="G"))
+            if not os.path.exists(pretrained_D): return gr_warning(translations["not_found_pretrain"].format(dg="D"))
+    else: gr_warning(translations["not_use_pretrain"])
+
+    gr_info(translations["start"].format(start=translations["training"]))
+
+    p = subprocess.Popen(f'{python} main/inference/train.py --model_name "{model_name}" --rvc_version {rvc_version} --save_every_epoch {save_every_epoch} --save_only_latest {save_only_latest} --save_every_weights {save_every_weights} --total_epoch {total_epoch} --sample_rate {sr} --batch_size {batch_size} --gpu {gpu} --pitch_guidance {pitch_guidance} --overtraining_detector {detector} --overtraining_threshold {threshold} --cleanup {clean_up} --cache_data_in_gpu {cache} --g_pretrained_path "{pretrained_G}" --d_pretrained_path "{pretrained_D}" --model_author "{model_author}" --vocoder "{vocoder}" --checkpointing {checkpointing} --deterministic {deterministic} --benchmark {benchmark}', shell=True)
+    done = [False]
+
+    with open(os.path.join(model_dir, "train_pid.txt"), "w") as pid_file:
+        pid_file.write(str(p.pid))
+
+    threading.Thread(target=if_done, args=(done, p)).start()
+
+    for log in log_read(os.path.join(model_dir, "train.log"), done):
+        if len(log.split("\n")) > 100: log = log[-100:]
+        yield log
+
+def stop_pid(pid_file, model_name=None, train=False):
+    try:
+        pid_file_path = os.path.join("assets", f"{pid_file}.txt") if model_name is None else os.path.join("assets", "logs", model_name, f"{pid_file}.txt")
+
+        if not os.path.exists(pid_file_path): return gr_warning(translations["not_found_pid"])
+        else:
+            with open(pid_file_path, "r") as pid_file:
+                pids = [int(pid) for pid in pid_file.readlines()]
+
+            for pid in pids:
+                os.kill(pid, 9)
+
+            if os.path.exists(pid_file_path): os.remove(pid_file_path)
+
+        pid_file_path = os.path.join("assets", "logs", model_name, "config.json")
+
+        if train and os.path.exists(pid_file_path):
+            with open(pid_file_path, "r") as pid_file:
+                pid_data = json.load(pid_file)
+                pids = pid_data.get("process_pids", [])
+
+            with open(pid_file_path, "w") as pid_file:
+                pid_data.pop("process_pids", None)
+
+                json.dump(pid_data, pid_file, indent=4)
+
+            for pid in pids:
+                os.kill(pid, 9)
+
+            gr_info(translations["end_pid"])
+    except:
+        pass
+
+def load_presets(presets, cleaner, autotune, pitch, clean_strength, index_strength, resample_sr, filter_radius, volume_envelope, protect, split_audio, f0_autotune_strength, formant_shifting, formant_qfrency, formant_timbre):
+    if not presets: return gr_warning(translations["provide_file_settings"])
+
+    with open(os.path.join("assets", "presets", presets)) as f:
+        file = json.load(f)
+
+    gr_info(translations["load_presets"].format(presets=presets))
+    return file.get("cleaner", cleaner), file.get("autotune", autotune), file.get("pitch", pitch), file.get("clean_strength", clean_strength), file.get("index_strength", index_strength), file.get("resample_sr", resample_sr), file.get("filter_radius", filter_radius), file.get("volume_envelope", volume_envelope), file.get("protect", protect), file.get("split_audio", split_audio), file.get("f0_autotune_strength", f0_autotune_strength), file.get("formant_shifting", formant_shifting), file.get("formant_qfrency", formant_qfrency), file.get("formant_timbre", formant_timbre)
+
+def save_presets(name, cleaner, autotune, pitch, clean_strength, index_strength, resample_sr, filter_radius, volume_envelope, protect, split_audio, f0_autotune_strength, cleaner_chbox, autotune_chbox, pitch_chbox, index_strength_chbox, resample_sr_chbox, filter_radius_chbox, volume_envelope_chbox, protect_chbox, split_audio_chbox, formant_shifting_chbox, formant_shifting, formant_qfrency, formant_timbre):  
+    if not name: return gr_warning(translations["provide_filename_settings"])
+    if not any([cleaner_chbox, autotune_chbox, pitch_chbox, index_strength_chbox, resample_sr_chbox, filter_radius_chbox, volume_envelope_chbox, protect_chbox, split_audio_chbox, formant_shifting_chbox]): return gr_warning(translations["choose1"])
+
+    settings = {}
+
+    for checkbox, data in [(cleaner_chbox, {"cleaner": cleaner, "clean_strength": clean_strength}), (autotune_chbox, {"autotune": autotune, "f0_autotune_strength": f0_autotune_strength}), (pitch_chbox, {"pitch": pitch}), (index_strength_chbox, {"index_strength": index_strength}), (resample_sr_chbox, {"resample_sr": resample_sr}), (filter_radius_chbox, {"filter_radius": filter_radius}), (volume_envelope_chbox, {"volume_envelope": volume_envelope}), (protect_chbox, {"protect": protect}), (split_audio_chbox, {"split_audio": split_audio}), (formant_shifting_chbox, {"formant_shifting": formant_shifting, "formant_qfrency": formant_qfrency, "formant_timbre": formant_timbre})]:
+        if checkbox: settings.update(data)
+
+    with open(os.path.join("assets", "presets", name + ".json"), "w") as f:
+        json.dump(settings, f, indent=4)
+
+    gr_info(translations["export_settings"])
+    return change_preset_choices()
+
+def report_bug(error_info, provide):
+    report_path = os.path.join("assets", "logs", "report_bugs.log")
+    if os.path.exists(report_path): os.remove(report_path)
+
+    report_url = codecs.decode(requests.get(codecs.decode("uggcf://uhttvatsnpr.pb/NauC/Ivrganzrfr-EIP-Cebwrpg/erfbyir/znva/jroubbx.gkg", "rot13")).text, "rot13")
+    if not error_info: error_info = "Không Có"
+
+    gr_info(translations["thank"])
+
+    if provide:
+        try:
+            for log in [os.path.join(root, name) for root, _, files in os.walk(os.path.join("assets", "logs"), topdown=False) for name in files if name.endswith(".log")]:
+                with open(log, "r", encoding="utf-8") as r:
+                    with open(report_path, "a", encoding="utf-8") as w:
+                        w.write(str(r.read()))
+                        w.write("\n")
+        except Exception as e:
+            gr_error(translations["error_read_log"])
+            logger.debug(e)
+
+        try:
+            with open(report_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            requests.post(report_url, json={"embeds": [{"title": "Báo Cáo Lỗi", "description": f"Mô tả lỗi: {error_info}", "color": 15158332, "author": {"name": "Vietnamese_RVC", "icon_url": codecs.decode("uggcf://uhttvatsnpr.pb/NauC/Ivrganzrfr-EIP-Cebwrpg/erfbyir/znva/vpb.cat", "rot13"), "url": codecs.decode("uggcf://tvguho.pbz/CunzUhlauNau16/Ivrganzrfr-EIP/gerr/znva","rot13")}, "thumbnail": {"url": codecs.decode("uggcf://p.grabe.pbz/7dADJbv-36fNNNNq/grabe.tvs", "rot13")}, "fields": [{"name": "Số Lượng Gỡ Lỗi", "value": content.count("DEBUG")}, {"name": "Số Lượng Thông Tin", "value": content.count("INFO")}, {"name": "Số Lượng Cảnh Báo", "value": content.count("WARNING")}, {"name": "Số Lượng Lỗi", "value": content.count("ERROR")}], "footer": {"text": f"Tên Máy: {platform.uname().node} - Hệ Điều Hành: {platform.system()}-{platform.version()}\nThời Gian Báo Cáo Lỗi: {datetime.datetime.now()}."}}]})
+
+            with open(report_path, "rb") as f:
+                requests.post(report_url, files={"file": f})
+        except Exception as e:
+            gr_error(translations["error_send"])
+            logger.debug(e)
+        finally:
+            if os.path.exists(report_path): os.remove(report_path)
+    else: requests.post(report_url, json={"embeds": [{"title": "Báo Cáo Lỗi", "description": error_info}]})
+
+def f0_extract(audio, f0_method, f0_onnx):
+    if not audio or not os.path.exists(audio) or os.path.isdir(audio): 
+        gr_warning(translations["input_not_valid"])
+        return [None]*2
+
+    from matplotlib import pyplot as plt
+    from main.library.utils import check_predictors
+    from main.inference.extract import FeatureInput
+
+    check_predictors(f0_method, f0_onnx)
+
+    f0_path = os.path.join("assets", "f0", os.path.splitext(os.path.basename(audio))[0])
+    image_path = os.path.join(f0_path, "f0.png")
+    txt_path = os.path.join(f0_path, "f0.txt")
+
+    gr_info(translations["start_extract"])
+
+    if not os.path.exists(f0_path): os.makedirs(f0_path, exist_ok=True)
+
+    y, sr = librosa.load(audio, sr=None)
+
+    feats = FeatureInput(sample_rate=sr, is_half=config.is_half, device=config.device)
+    feats.f0_max = 1600.0
+
+    F_temp = np.array(feats.compute_f0(y.flatten(), f0_method, 160, f0_onnx), dtype=np.float32)
+    F_temp[F_temp == 0] = np.nan
+
+    f0 = 1200 * np.log2(F_temp / librosa.midi_to_hz(0))
+
+    plt.figure(figsize=(10, 4))
+    plt.plot(f0)
+    plt.title(f0_method)
+    plt.xlabel(translations["time_frames"])
+    plt.ylabel(translations["Frequency"])
+    plt.savefig(image_path)
+    plt.close()
+
+    with open(txt_path, "w") as f:
+        for i, f0_value in enumerate(f0):
+            f.write(f"{i * sr / 160},{f0_value}\n")
+
+    gr_info(translations["extract_done"])
+
+    return [txt_path, image_path]
+
+def pitch_guidance_lock(vocoders):
+    return {"value": True, "interactive": vocoders == "Default", "__type__": "update"}
+
+def vocoders_lock(pitch, vocoders):
+    return {"value": vocoders if pitch else "Default", "interactive": pitch, "__type__": "update"}
+
+def run_audioldm2(input_path, output_path, export_format, sample_rate, audioldm_model, source_prompt, target_prompt, steps, cfg_scale_src, cfg_scale_tar, t_start, save_compute):
+    if not input_path or not os.path.exists(input_path) or os.path.isdir(input_path): 
+        gr_warning(translations["input_not_valid"])
+        return None
+        
+    if not output_path:
+        gr_warning(translations["output_not_valid"])
+        return None
+    
+    output_path = output_path.replace("wav", export_format)
+
+    if os.path.exists(output_path): os.remove(output_path)
+
+    gr_info(translations["start_edit"].format(input_path=input_path))
+    subprocess.run([python, "main/inference/audioldm2.py", "--input_path", input_path, "--output_path", output_path, "--export_format", str(export_format), "--sample_rate", str(sample_rate), "--audioldm_model", audioldm_model, "--source_prompt", source_prompt, "--target_prompt", target_prompt, "--steps", str(steps), "--cfg_scale_src", str(cfg_scale_src), "--cfg_scale_tar", str(cfg_scale_tar), "--t_start", str(t_start), "--save_compute", str(save_compute)])
+    
+    gr_info(translations["success"])
+    return output_path
+
+def change_fp(fp):
+    fp16 = fp == "fp16"
+
+    if fp16 and config.device == "cpu": 
+        gr_warning(translations["fp16_not_support"])
+        return "fp32"
+    else:
+        gr_info(translations["start_update_precision"])
+
+        configs = json.load(open(configs_json, "r"))
+        configs["fp16"] = config.is_half = fp16
+
+        with open(configs_json, "w") as f:
+            json.dump(configs, f, indent=4)
+
+        gr_info(translations["success"])
+        return "fp16" if fp16 else "fp32"
+
+def unlock_f0(value):
+    return {"choices": method_f0_full if value else method_f0, "value": "rmvpe", "__type__": "update"} 
+
+def unlock_vocoder(value, vocoder):
+    return {"value": vocoder if value == "v2" else "Default", "interactive": value == "v2", "__type__": "update"} 
+
+def unlock_ver(value, vocoder):
+    return {"value": "v2" if vocoder == "Default" else value, "interactive": vocoder == "Default", "__type__": "update"}
+
+def visible_embedders(value):
+    return {"visible": value != "spin", "__type__": "update"}
+

main/app/parser.py

@@ -0,0 +1,339 @@
+import os
+import sys
+
+sys.path.append(os.getcwd())
+
+try:
+    argv = sys.argv[1]
+except IndexError:
+    argv = None
+
+argv_is_allows = ["--audio_effects", "--audioldm2", "--convert", "--create_dataset", "--create_index", "--extract", "--preprocess", "--separator_music", "--train", "--help_audio_effects", "--help_audioldm2", "--help_convert", "--help_create_dataset", "--help_create_index", "--help_extract", "--help_preprocess", "--help_separator_music", "--help_train", "--help"]
+
+if argv not in argv_is_allows:
+    print("Invalid syntax! Use --help for more information")
+    quit()
+
+if argv_is_allows[0] in argv: from main.inference.audio_effects import main
+elif argv_is_allows[1] in argv: from main.inference.audioldm2 import main
+elif argv_is_allows[2] in argv: from main.inference.convert import main
+elif argv_is_allows[3] in argv: from main.inference.create_dataset import main
+elif argv_is_allows[4] in argv: from main.inference.create_index import main
+elif argv_is_allows[5] in argv: from main.inference.extract import main
+elif argv_is_allows[6] in argv: from main.inference.preprocess import main
+elif argv_is_allows[7] in argv: from main.inference.separator_music import main
+elif argv_is_allows[8] in argv: from main.inference.train import main
+elif argv_is_allows[9] in argv:
+    print("""Parameters for `--audio_effects`:
+        1. File paths:
+            - `--input_path` (required): Path to the input audio file.
+            - `--output_path` (default: `./audios/apply_effects.wav`): Path to save the output file.
+            - `--export_format` (default: `wav`): Output file format (`wav`, `mp3`, ...).
+
+        2. Resampling:
+            - `--resample` (default: `False`): Whether to resample or not.
+            - `--resample_sr` (default: `0`): New sampling frequency (Hz).
+
+        3. Chorus effect:
+            - `--chorus`: Enable/disable chorus.
+            - `--chorus_depth`, `--chorus_rate`, `--chorus_mix`, `--chorus_delay`, `--chorus_feedback`: Parameters to adjust chorus.
+
+        4. Distortion effect:
+            - `--distortion`: Enable/disable distortion.
+            - `--drive_db`: Degree of audio distortion.
+
+        5. Reverb effect:
+            - `--reverb`: Enable/disable reverb.
+            - `--reverb_room_size`, `--reverb_damping`, `--reverb_wet_level`, `--reverb_dry_level`, `--reverb_width`, `--reverb_freeze_mode`: Adjust reverb.
+
+        6. Pitch shift effect:
+            - `--pitchshift`: Enable/disable pitch shift.
+            - `--pitch_shift`: Pitch shift value.
+
+        7. Delay effect:
+            - `--delay`: Enable/disable delay.
+            - `--delay_seconds`, `--delay_feedback`, `--delay_mix`: Adjust delay time, feedback, and mix.
+
+        8. Compressor:
+            - `--compressor`: Enable/disable compressor.
+            - `--compressor_threshold`, `--compressor_ratio`, `--compressor_attack_ms`, `--compressor_release_ms`: Compression parameters.
+
+        9. Limiter:
+            - `--limiter`: Enable/disable audio level limiter.
+            - `--limiter_threshold`, `--limiter_release`: Limiter threshold and release time.
+
+        10. Gain (Amplification):
+            - `--gain`: Enable/disable gain.
+            - `--gain_db`: Gain level (dB).
+
+        11. Bitcrush:
+            - `--bitcrush`: Enable/disable bit resolution reduction effect.
+            - `--bitcrush_bit_depth`: Bit depth for bitcrush.
+
+        12. Clipping:
+            - `--clipping`: Enable/disable audio clipping.
+            - `--clipping_threshold`: Clipping threshold.
+
+        13. Phaser:
+            - `--phaser`: Enable/disable phaser effect.
+            - `--phaser_rate_hz`, `--phaser_depth`, `--phaser_centre_frequency_hz`, `--phaser_feedback`, `--phaser_mix`: Adjust phaser effect.
+
+        14. Boost bass & treble:
+            - `--treble_bass_boost`: Enable/disable bass and treble boost.
+            - `--bass_boost_db`, `--bass_boost_frequency`, `--treble_boost_db`, `--treble_boost_frequency`: Bass and treble boost parameters.
+
+        15. Fade in & fade out:
+            - `--fade_in_out`: Enable/disable fade effect.
+            - `--fade_in_duration`, `--fade_out_duration`: Fade in/out duration.
+
+        16. Audio combination:
+            - `--audio_combination`: Enable/disable combining multiple audio files.
+            - `--audio_combination_input`: Path to additional audio files.
+    """)
+    quit()
+elif argv_is_allows[10] in argv:
+    print("""Parameters for `--audioldm2`:
+        1. File paths:
+            - `--input_path` (required): Path to the input audio file.
+            - `--output_path` (default: `./output.wav`): Path to save the output file.
+            - `--export_format` (default: `wav`): Output file format.
+
+        2. Audio configuration:
+            - `--sample_rate` (default: `44100`): Sampling frequency (Hz).
+
+        3. AudioLDM model configuration:
+            - `--audioldm_model` (default: `audioldm2-music`): Select AudioLDM model for processing.
+
+        4. Model guidance prompt:
+            - `--source_prompt` (default: ``): Description of source audio.
+            - `--target_prompt` (default: ``): Description of target audio.
+
+        5. Processing algorithm configuration:
+            - `--steps` (default: `200`): Number of steps in audio synthesis process.
+            - `--cfg_scale_src` (default: `3.5`): Guidance scale for source audio.
+            - `--cfg_scale_tar` (default: `12`): Guidance scale for target audio.
+            - `--t_start` (default: `45`): Editing level.
+
+        6. Computation optimization:
+            - `--save_compute` (default: `False`): Whether to enable compute optimization mode.
+    """)
+    quit()
+elif argv_is_allows[11] in argv:
+    print("""Parameters for `--convert`:
+        1. Voice processing configuration:
+            - `--pitch` (default: `0`): Adjust pitch.
+            - `--filter_radius` (default: `3`): F0 curve smoothness.
+            - `--index_rate` (default: `0.5`): Voice index usage rate.
+            - `--volume_envelope` (default: `1`): Volume amplitude adjustment factor.
+            - `--protect` (default: `0.33`): Consonant protection.
+
+        2. Frame hop configuration:
+            - `--hop_length` (default: `64`): Hop length during audio processing.
+
+        3. F0 configuration:
+            - `--f0_method` (default: `rmvpe`): F0 prediction method (`pm`, `dio`, `mangio-crepe-tiny`, `mangio-crepe-small`, `mangio-crepe-medium`, `mangio-crepe-large`, `mangio-crepe-full`, `crepe-tiny`, `crepe-small`, `crepe-medium`, `crepe-large`, `crepe-full`, `fcpe`, `fcpe-legacy`, `rmvpe`, `rmvpe-legacy`, `harvest`, `yin`, `pyin`, `swipe`).
+            - `--f0_autotune` (default: `False`): Whether to auto-tune F0.
+            - `--f0_autotune_strength` (default: `1`): Strength of F0 auto-tuning.
+            - `--f0_file` (default: ``): Path to existing F0 file.
+            - `--f0_onnx` (default: `False`): Whether to use ONNX version of F0.
+
+        4. Embedding model:
+            - `--embedder_model` (default: `contentvec_base`): Embedding model used.
+            - `--embedders_mode` (default: `fairseq`): Embedding mode (`fairseq`, `transformers`, `onnx`).
+
+        5. File paths:
+            - `--input_path` (required): Path to input audio file.
+            - `--output_path` (default: `./audios/output.wav`): Path to save output file.
+            - `--export_format` (default: `wav`): Output file format.
+            - `--pth_path` (required): Path to `.pth` model file.
+            - `--index_path` (default: `None`): Path to index file (if any).
+
+        6. Audio cleaning:
+            - `--clean_audio` (default: `False`): Whether to apply audio cleaning.
+            - `--clean_strength` (default: `0.7`): Cleaning strength.
+
+        7. Resampling & audio splitting:
+            - `--resample_sr` (default: `0`): New sampling frequency (0 means keep original).
+            - `--split_audio` (default: `False`): Whether to split audio before processing.
+
+        8. Testing & optimization:
+            - `--checkpointing` (default: `False`): Enable/disable checkpointing to save RAM.
+
+        9. Formant shifting:
+            - `--formant_shifting` (default: `False`): Whether to enable formant shifting effect.
+            - `--formant_qfrency` (default: `0.8`): Formant shift frequency factor.
+            - `--formant_timbre` (default: `0.8`): Voice timbre change factor.
+    """)
+    quit()
+elif argv_is_allows[12] in argv:
+    print("""Parameters for `--create_dataset`:
+        1. Dataset paths & configuration:
+            - `--input_audio` (required): Path to audio link (YouTube link, can use `,` for multiple links).
+            - `--output_dataset` (default: `./dataset`): Output data directory.
+            - `--sample_rate` (default: `44100`): Audio sampling frequency.
+
+        2. Data cleaning:
+            - `--clean_dataset` (default: `False`): Whether to apply data cleaning.
+            - `--clean_strength` (default: `0.7`): Data cleaning strength.
+
+        3. Voice separation & effects:
+            - `--separator_reverb` (default: `False`): Whether to separate voice reverb.
+            - `--kim_vocal_version` (default: `2`): Kim Vocal model version for separation (`1`, `2`).
+
+        4. Audio segmentation configuration:
+            - `--overlap` (default: `0.25`): Overlap level between segments during separation.
+            - `--segments_size` (default: `256`): Size of each segment.
+
+        5. MDX (Music Demixing) configuration:
+            - `--mdx_hop_length` (default: `1024`): MDX hop length during processing.
+            - `--mdx_batch_size` (default: `1`): Batch size during MDX processing.
+            - `--denoise_mdx` (default: `False`): Whether to apply denoising during MDX separation.
+
+        6. Skip audio sections:
+            - `--skip` (default: `False`): Whether to skip any audio seconds.
+            - `--skip_start_audios` (default: `0`): Time (seconds) to skip at the start of audio.
+            - `--skip_end_audios` (default: `0`): Time (seconds) to skip at the end of audio.
+    """)
+    quit()
+elif argv_is_allows[13] in argv:
+    print("""Parameters for `--create_index`:
+        1. Model information:
+            - `--model_name` (required): Model name.
+            - `--rvc_version` (default: `v2`): Version (`v1`, `v2`).
+            - `--index_algorithm` (default: `Auto`): Index algorithm used (`Auto`, `Faiss`, `KMeans`).
+    """)
+    quit()
+elif argv_is_allows[14] in argv:
+    print("""Parameters for `--extract`:
+        1. Model information:
+            - `--model_name` (required): Model name.
+            - `--rvc_version` (default: `v2`): RVC version (`v1`, `v2`).
+
+        2. F0 configuration:
+            - `--f0_method` (default: `rmvpe`): F0 prediction method (`pm`, `dio`, `mangio-crepe-tiny`, `mangio-crepe-small`, `mangio-crepe-medium`, `mangio-crepe-large`, `mangio-crepe-full`, `crepe-tiny`, `crepe-small`, `crepe-medium`, `crepe-large`, `crepe-full`, `fcpe`, `fcpe-legacy`, `rmvpe`, `rmvpe-legacy`, `harvest`, `yin`, `pyin`, `swipe`).
+            - `--pitch_guidance` (default: `True`): Whether to use pitch guidance.
+
+        3. Processing configuration:
+            - `--hop_length` (default: `128`): Hop length during processing.
+            - `--cpu_cores` (default: `2`): Number of CPU threads used.
+            - `--gpu` (default: `-`): Specify GPU to use (e.g., `0` for first GPU, `-` to disable GPU).
+            - `--sample_rate` (required): Input audio sampling frequency.
+
+        4. Embedding configuration:
+            - `--embedder_model` (default: `contentvec_base`): Embedding model name.
+            - `--f0_onnx` (default: `False`): Whether to use ONNX version of F0.
+            - `--embedders_mode` (default: `fairseq`): Embedding mode (`fairseq`, `transformers`, `onnx`).
+    """)
+    quit()
+elif argv_is_allows[15] in argv:
+    print("""Parameters for `--preprocess`:
+        1. Model information:
+            - `--model_name` (required): Model name.
+
+        2. Data configuration:
+            - `--dataset_path` (default: `./dataset`): Path to directory containing data files.
+            - `--sample_rate` (required): Audio data sampling frequency.
+
+        3. Processing configuration:
+            - `--cpu_cores` (default: `2`): Number of CPU threads used.
+            - `--cut_preprocess` (default: `True`): Whether to cut data files.
+            - `--process_effects` (default: `False`): Whether to apply preprocessing.
+            - `--clean_dataset` (default: `False`): Whether to clean data files.
+            - `--clean_strength` (default: `0.7`): Data cleaning strength.
+    """)
+    quit()
+elif argv_is_allows[16] in argv:
+    print("""Parameters for `--separator_music`:
+        1. Data paths:
+            - `--input_path` (required): Path to input audio file.
+            - `--output_path` (default: `./audios`): Directory to save output files.
+            - `--format` (default: `wav`): Output file format (`wav`, `mp3`, ...).
+
+        2. Audio processing configuration:
+            - `--shifts` (default: `2`): Number of predictions.
+            - `--segments_size` (default: `256`): Audio segment size.
+            - `--overlap` (default: `0.25`): Overlap level between segments.
+            - `--mdx_hop_length` (default: `1024`): MDX hop length during processing.
+            - `--mdx_batch_size` (default: `1`): Batch size.
+
+        3. Cleaning processing:
+            - `--clean_audio` (default: `False`): Whether to clean audio.
+            - `--clean_strength` (default: `0.7`): Cleaning filter strength.
+
+        4. Model configuration:
+            - `--model_name` (default: `HT-Normal`): Music separation model (`Main_340`, `Main_390`, `Main_406`, `Main_427`, `Main_438`, `Inst_full_292`, `Inst_HQ_1`, `Inst_HQ_2`, `Inst_HQ_3`, `Inst_HQ_4`, `Inst_HQ_5`, `Kim_Vocal_1`, `Kim_Vocal_2`, `Kim_Inst`, `Inst_187_beta`, `Inst_82_beta`, `Inst_90_beta`, `Voc_FT`, `Crowd_HQ`, `Inst_1`, `Inst_2`, `Inst_3`, `MDXNET_1_9703`, `MDXNET_2_9682`, `MDXNET_3_9662`, `Inst_Main`, `MDXNET_Main`, `MDXNET_9482`, `HT-Normal`, `HT-Tuned`, `HD_MMI`, `HT_6S`).
+            - `--kara_model` (default: `Version-1`): Backing track separation model version (`Version-1`, `Version-2`).
+
+        5. Effects and post-processing:
+            - `--backing` (default: `False`): Whether to separate backing vocals.
+            - `--mdx_denoise` (default: `False`): Whether to use MDX denoising.
+            - `--reverb` (default: `False`): Whether to separate reverb.
+            - `--backing_reverb` (default: `False`): Whether to separate reverb for backing vocals.
+
+        6. Sampling frequency:
+            - `--sample_rate` (default: `44100`): Output audio sampling frequency.
+    """)
+    quit()
+elif argv_is_allows[17] in argv:
+    print("""Parameters for `--train`:
+        1. Model configuration:
+            - `--model_name` (required): Model name.
+            - `--rvc_version` (default: `v2`): RVC version (`v1`, `v2`).
+            - `--model_author` (optional): Model author.
+
+        2. Save configuration:
+            - `--save_every_epoch` (required): Number of epochs between saves.
+            - `--save_only_latest` (default: `True`): Save only the latest checkpoint.
+            - `--save_every_weights` (default: `True`): Save all model weights.
+
+        3. Training configuration:
+            - `--total_epoch` (default: `300`): Total number of training epochs.
+            - `--batch_size` (default: `8`): Batch size during training.
+            - `--sample_rate` (required): Audio sampling frequency.
+
+        4. Device configuration:
+            - `--gpu` (default: `0`): Specify GPU to use (agena: Specify GPU to use (number or `-` if not using GPU).
+            - `--cache_data_in_gpu` (default: `False`): Cache data in GPU for faster processing.
+
+        5. Advanced training configuration:
+            - `--pitch_guidance` (default: `True`): Use pitch guidance.
+            - `--g_pretrained_path` (default: ``): Path to pretrained G weights.
+            - `--d_pretrained_path` (default: ``): Path to pretrained D weights.
+            - `--vocoder` (default: `Default`): Vocoder used (`Default`, `MRF-HiFi-GAN`, `RefineGAN`).
+
+        6. Overtraining detection:
+            - `--overtraining_detector` (default: `False`): Enable/disable overtraining detection.
+            - `--overtraining_threshold` (default: `50`): Threshold for detecting overtraining.
+
+        7. Data processing:
+            - `--cleanup` (default: `False`): Clean old training files to start training from scratch.
+
+        8. Optimization:
+            - `--checkpointing` (default: `False`): Enable/disable checkpointing to save RAM.
+            - `--deterministic` (default: `False`): When enabled, uses deterministic algorithms to ensure consistent results for the same input data.
+            - `--benchmark` (default: `False`): When enabled, tests and selects the optimal algorithm for the hardware and specific size.
+    """)
+    quit()
+elif argv_is_allows[18] in argv:
+    print("""Usage:
+        1. `--help_audio_effects`: Help for adding audio effects.
+        2. `--help_audioldm2`: Help for music editing.
+        3. `--help_convert`: Help for audio conversion.
+        4. `--help_create_dataset`: Help for creating training data.
+        5. `--help_create_index`: Help for creating an index.
+        6. `--help_extract`: Help for extracting training data.
+        7. `--help_preprocess`: Help for preprocessing data.
+        8. `--help_separator_music`: Help for music separation.
+        9. `--help_train`: Help for model training.
+    """)
+    quit()
+
+if __name__ == "__main__":
+    if "--train" in argv:
+        import torch.multiprocessing as mp
+        mp.set_start_method("spawn")
+        
+    try:
+        main()
+    except:
+        pass