Upload 23 files

.gitignore

@@ -0,0 +1,153 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+pytestdebug.log
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+doc/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# End of https://www.toptal.com/developers/gitignore/api/python
+
+dataset
+dataset_raw
+raw
+results
+inference/chunks_temp.json
+logs
+hubert/checkpoint_best_legacy_500.pt
+configs/config.json
+filelists/test.txt
+filelists/train.txt
+filelists/val.txt

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jingyi Li
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,241 @@
----
-title: XingTong
-emoji: 📉
-colorFrom: pink
-colorTo: blue
-sdk: gradio
-sdk_version: 3.28.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SoftVC VITS Singing Voice Conversion
+
+[**English**](./README.md) | [**中文简体**](./README_zh_CN.md)
+
+#### ✨ A fork with a greatly improved interface: [34j/so-vits-svc-fork](https://github.com/34j/so-vits-svc-fork)
+
+#### ✨ A client supports real-time conversion: [w-okada/voice-changer](https://github.com/w-okada/voice-changer)
+
+## 📏 Terms of Use
+
+# Warning: Please solve the authorization problem of the dataset on your own. You shall be solely responsible for any problems caused by the use of non-authorized datasets for training and all consequences thereof.The repository and its maintainer, svc develop team, have nothing to do with the consequences!
+
+1. This project is established for academic exchange purposes only and is intended for communication and learning purposes. It is not intended for production environments. 
+2. Any videos based on sovits that are published on video platforms must clearly indicate in the description that they are used for voice changing and specify the input source of the voice or audio, for example, using videos or audios published by others and separating the vocals as input source for conversion, which must provide clear original video or music links. If your own voice or other synthesized voices from other commercial vocal synthesis software are used as the input source for conversion, you must also explain it in the description.
+3. You shall be solely responsible for any infringement problems caused by the input source. When using other commercial vocal synthesis software as input source, please ensure that you comply with the terms of use of the software. Note that many vocal synthesis engines clearly state in their terms of use that they cannot be used for input source conversion.
+4. Continuing to use this project is deemed as agreeing to the relevant provisions stated in this repository README. This repository README has the obligation to persuade, and is not responsible for any subsequent problems that may arise.
+5. If you distribute this repository's code or publish any results produced by this project publicly (including but not limited to video sharing platforms), please indicate the original author and code source (this repository).
+6. If you use this project for any other plan, please contact and inform the author of this repository in advance. Thank you very much.
+
+## 🆕 Update!
+
+> Updated the 4.0-v2 model, the entire process is the same as 4.0. Compared to 4.0, there is some improvement in certain scenarios, but there are also some cases where it has regressed. Please refer to the [4.0-v2 branch](https://github.com/svc-develop-team/so-vits-svc/tree/4.0-v2) for more information.
+
+## 📝 Model Introduction
+
+The singing voice conversion model uses SoftVC content encoder to extract source audio speech features, then the vectors are directly fed into VITS instead of converting to a text based intermediate; thus the pitch and intonations are conserved. Additionally, the vocoder is changed to [NSF HiFiGAN](https://github.com/openvpi/DiffSinger/tree/refactor/modules/nsf_hifigan) to solve the problem of sound interruption.
+
+### 🆕 4.0 Version Update Content
+
+- Feature input is changed to [Content Vec](https://github.com/auspicious3000/contentvec)
+- The sampling rate is unified to use 44100Hz
+- Due to the change of hop size and other parameters, as well as the streamlining of some model structures, the required GPU memory for inference is **significantly reduced**. The 44kHz GPU memory usage of version 4.0 is even smaller than the 32kHz usage of version 3.0.
+- Some code structures have been adjusted
+- The dataset creation and training process are consistent with version 3.0, but the model is completely non-universal, and the data set needs to be fully pre-processed again.
+- Added an option 1: automatic pitch prediction for vc mode, which means that you don't need to manually enter the pitch key when converting speech, and the pitch of male and female voices can be automatically converted. However, this mode will cause pitch shift when converting songs.
+- Added option 2: reduce timbre leakage through k-means clustering scheme, making the timbre more similar to the target timbre.
+
+## 💬 About Python Version
+
+After conducting tests, we believe that the project runs stably on Python version 3.8.9.
+
+## 📥 Pre-trained Model Files
+
+#### **Required**
+
+- ContentVec: [checkpoint_best_legacy_500.pt](https://ibm.box.com/s/z1wgl1stco8ffooyatzdwsqn2psd9lrr)
+  - Place it under the `hubert` directory
+
+```shell
+# contentvec
+wget -P hubert/ http://obs.cstcloud.cn/share/obs/sankagenkeshi/checkpoint_best_legacy_500.pt
+# Alternatively, you can manually download and place it in the hubert directory
+```
+
+#### **Optional(Strongly recommend)**
+
+- Pre-trained model files: `G_0.pth` `D_0.pth`
+  - Place them under the `logs/44k` directory
+
+Get them from svc-develop-team(TBD) or anywhere else.
+
+Although the pretrained model generally does not cause any copyright problems, please pay attention to it. For example, ask the author in advance, or the author has indicated the feasible use in the description clearly.
+
+## 📊 Dataset Preparation
+
+Simply place the dataset in the `dataset_raw` directory with the following file structure.
+
+```
+dataset_raw
+├───speaker0
+│   ├───xxx1-xxx1.wav
+│   ├───...
+│   └───Lxx-0xx8.wav
+└───speaker1
+    ├───xx2-0xxx2.wav
+    ├───...
+    └───xxx7-xxx007.wav
+```
+
+You can customize the speaker name.
+
+```
+dataset_raw
+└───suijiSUI
+    ├───1.wav
+    ├───...
+    └───25788785-20221210-200143-856_01_(Vocals)_0_0.wav
+```
+
+## 🛠️ Preprocessing
+
+1. Resample to 44100Hz and mono
+
+```shell
+python resample.py
+```
+
+2. Automatically split the dataset into training and validation sets, and generate configuration files
+
+```shell
+python preprocess_flist_config.py
+```
+
+3. Generate hubert and f0
+
+```shell
+python preprocess_hubert_f0.py
+```
+
+After completing the above steps, the dataset directory will contain the preprocessed data, and the dataset_raw folder can be deleted.
+
+#### You can modify some parameters in the generated config.json
+
+* `keep_ckpts`: Keep the last `keep_ckpts` models during training. Set to `0` will keep them all. Default is `3`.
+
+* `all_in_mem`: Load all dataset to RAM. It can be enabled when the disk IO of some platforms is too low and the system memory is **much larger** than your dataset.
+
+## 🏋️‍♀️ Training
+
+```shell
+python train.py -c configs/config.json -m 44k
+```
+
+## 🤖 Inference
+
+Use [inference_main.py](https://github.com/svc-develop-team/so-vits-svc/blob/4.0/inference_main.py)
+
+```shell
+# Example
+python inference_main.py -m "logs/44k/G_30400.pth" -c "configs/config.json" -n "君の知らない物語-src.wav" -t 0 -s "nen"
+```
+
+Required parameters:
+- `-m` | `--model_path`: path to the model.
+- `-c` | `--config_path`: path to the configuration file.
+- `-n` | `--clean_names`: a list of wav file names located in the raw folder.
+- `-t` | `--trans`: pitch adjustment, supports positive and negative (semitone) values.
+- `-s` | `--spk_list`: target speaker name for synthesis.
+- `-cl` | `--clip`: voice forced slicing, set to 0 to turn off(default), duration in seconds.
+
+Optional parameters: see the next section
+- `-lg` | `--linear_gradient`: The cross fade length of two audio slices in seconds. If there is a discontinuous voice after forced slicing, you can adjust this value. Otherwise, it is recommended to use the default value of 0.
+- `-fmp` | `--f0_mean_pooling`: Apply mean filter (pooling) to f0，which may improve some hoarse sounds. Enabling this option will reduce inference speed.
+- `-a` | `--auto_predict_f0`: automatic pitch prediction for voice conversion, do not enable this when converting songs as it can cause serious pitch issues.
+- `-cm` | `--cluster_model_path`: path to the clustering model, fill in any value if clustering is not trained.
+- `-cr` | `--cluster_infer_ratio`: proportion of the clustering solution, range 0-1, fill in 0 if the clustering model is not trained.
+
+## 🤔 Optional Settings
+
+If the results from the previous section are satisfactory, or if you didn't understand what is being discussed in the following section, you can skip it, and it won't affect the model usage. (These optional settings have a relatively small impact, and they may have some effect on certain specific data, but in most cases, the difference may not be noticeable.)
+
+### Automatic f0 prediction
+
+During the 4.0 model training, an f0 predictor is also trained, which can be used for automatic pitch prediction during voice conversion. However, if the effect is not good, manual pitch prediction can be used instead. But please do not enable this feature when converting singing voice as it may cause serious pitch shifting!
+- Set `auto_predict_f0` to true in inference_main.
+
+### Cluster-based timbre leakage control
+
+Introduction: The clustering scheme can reduce timbre leakage and make the trained model sound more like the target's timbre (although this effect is not very obvious), but using clustering alone will lower the model's clarity (the model may sound unclear). Therefore, this model adopts a fusion method to linearly control the proportion of clustering and non-clustering schemes. In other words, you can manually adjust the ratio between "sounding like the target's timbre" and "being clear and articulate" to find a suitable trade-off point.
+
+The existing steps before clustering do not need to be changed. All you need to do is to train an additional clustering model, which has a relatively low training cost.
+
+- Training process:
+  - Train on a machine with a good CPU performance. According to my experience, it takes about 4 minutes to train each speaker on a Tencent Cloud 6-core CPU.
+  - Execute "python cluster/train_cluster.py". The output of the model will be saved in "logs/44k/kmeans_10000.pt".
+- Inference process:
+  - Specify "cluster_model_path" in inference_main.
+  - Specify "cluster_infer_ratio" in inference_main, where 0 means not using clustering at all, 1 means only using clustering, and usually 0.5 is sufficient.
+
+### F0 mean filtering
+
+Introduction: The mean filtering of F0 can effectively reduce the hoarse sound caused by the predicted fluctuation of pitch (the hoarse sound caused by reverb or harmony can not be eliminated temporarily). This function has been greatly improved on some songs. If the song appears dumb after reasoning, it can be considered to open.
+- Set f0_mean_pooling to true in inference_main
+
+### [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1kv-3y2DmZo0uya8pEr1xk7cSB-4e_Pct?usp=sharing) [sovits4_for_colab.ipynb](https://colab.research.google.com/drive/1kv-3y2DmZo0uya8pEr1xk7cSB-4e_Pct?usp=sharing)
+
+#### [23/03/16] No longer need to download hubert manually
+
+## 📤 Exporting to Onnx
+
+Use [onnx_export.py](https://github.com/svc-develop-team/so-vits-svc/blob/4.0/onnx_export.py)
+
+- Create a folder named `checkpoints` and open it
+- Create a folder in the `checkpoints` folder as your project folder, naming it after your project, for example `aziplayer`
+- Rename your model as `model.pth`, the configuration file as `config.json`, and place them in the `aziplayer` folder you just created
+- Modify `"NyaruTaffy"` in `path = "NyaruTaffy"` in [onnx_export.py](https://github.com/svc-develop-team/so-vits-svc/blob/4.0/onnx_export.py) to your project name, `path = "aziplayer"`
+- Run [onnx_export.py](https://github.com/svc-develop-team/so-vits-svc/blob/4.0/onnx_export.py)
+- Wait for it to finish running. A `model.onnx` will be generated in your project folder, which is the exported model.
+
+### UI support for Onnx models
+
+- [MoeSS](https://github.com/NaruseMioShirakana/MoeSS)
+
+Note: For Hubert Onnx models, please use the models provided by MoeSS. Currently, they cannot be exported on their own (Hubert in fairseq has many unsupported operators and things involving constants that can cause errors or result in problems with the input/output shape and results when exported.)  [Hubert4.0](https://huggingface.co/NaruseMioShirakana/MoeSS-SUBModel)
+
+## ☀️ Previous contributors
+
+For some reason the author deleted the original repository. Because of the negligence of the organization members, the contributor list was cleared because all files were directly reuploaded to this repository at the beginning of the reconstruction of this repository. Now add a previous contributor list to README.md.
+
+*Some members have not listed according to their personal wishes.*
+
+<table>
+  <tr>
+    <td align="center"><a href="https://github.com/MistEO"><img src="https://avatars.githubusercontent.com/u/18511905?v=4" width="100px;" alt=""/><br /><sub><b>MistEO</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/XiaoMiku01"><img src="https://avatars.githubusercontent.com/u/54094119?v=4" width="100px;" alt=""/><br /><sub><b>XiaoMiku01</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/ForsakenRei"><img src="https://avatars.githubusercontent.com/u/23041178?v=4" width="100px;" alt=""/><br /><sub><b>しぐれ</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/TomoGaSukunai"><img src="https://avatars.githubusercontent.com/u/25863522?v=4" width="100px;" alt=""/><br /><sub><b>TomoGaSukunai</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/Plachtaa"><img src="https://avatars.githubusercontent.com/u/112609742?v=4" width="100px;" alt=""/><br /><sub><b>Plachtaa</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/zdxiaoda"><img src="https://avatars.githubusercontent.com/u/45501959?v=4" width="100px;" alt=""/><br /><sub><b>zd小达</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/Archivoice"><img src="https://avatars.githubusercontent.com/u/107520869?v=4" width="100px;" alt=""/><br /><sub><b>凍聲響世</b></sub></a><br /></td>
+  </tr>
+</table>
+
+## 📚 Some legal provisions for reference
+
+#### Any country, region, organization, or individual using this project must comply with the following laws.
+
+#### 《民法典》
+
+##### 第一千零一十九条 
+
+任何组织或者个人不得以丑化、污损，或者利用信息技术手段伪造等方式侵害他人的肖像权。未经肖像权人同意，不得制作、使用、公开肖像权人的肖像，但是法律另有规定的除外。未经肖像权人同意，肖像作品权利人不得以发表、复制、发行、出租、展览等方式使用或者公开肖像权人的肖像。对自然人声音的保护，参照适用肖像权保护的有关规定。
+
+#####  第一千零二十四条 
+
+【名誉权】民事主体享有名誉权。任何组织或者个人不得以侮辱、诽���等方式侵害他人的名誉权。  
+
+#####  第一千零二十七条
+
+【作品侵害名誉权】行为人发表的文学、艺术作品以真人真事或者特定人为描述对象，含有侮辱、诽谤内容，侵害他人名誉权的，受害人有权依法请求该行为人承担民事责任。行为人发表的文学、艺术作品不以特定人为描述对象，仅其中的情节与该特定人的情况相似的，不承担民事责任。  
+
+#### 《[中华人民共和国宪法](http://www.gov.cn/guoqing/2018-03/22/content_5276318.htm)》
+
+#### 《[中华人民共和国刑法](http://gongbao.court.gov.cn/Details/f8e30d0689b23f57bfc782d21035c3.html?sw=%E4%B8%AD%E5%8D%8E%E4%BA%BA%E6%B0%91%E5%85%B1%E5%92%8C%E5%9B%BD%E5%88%91%E6%B3%95)》
+
+#### 《[中华人民共和国民法典](http://gongbao.court.gov.cn/Details/51eb6750b8361f79be8f90d09bc202.html)》
+
+## 💪 Thanks to all contributors for their efforts
+<a href="https://github.com/svc-develop-team/so-vits-svc/graphs/contributors" target="_blank">
+  <img src="https://contrib.rocks/image?repo=svc-develop-team/so-vits-svc" />
+</a>

README_zh_CN.md

@@ -0,0 +1,241 @@
+# SoftVC VITS Singing Voice Conversion
+
+[**English**](./README.md) | [**中文简体**](./README_zh_CN.md)
+
+#### ✨ 改善了交互的一个分支推荐：[34j/so-vits-svc-fork](https://github.com/34j/so-vits-svc-fork)
+
+#### ✨ 支持实时转换的一个客户端：[w-okada/voice-changer](https://github.com/w-okada/voice-changer)
+
+## 📏 使用规约
+
+# Warning：请自行解决数据集授权问题，禁止使用非授权数据集进行训练！任何由于使用非授权数据集进行训练造成的问题，需自行承担全部责任和后果！与仓库、仓库维护者、svc develop team 无关！
+
+1. 本项目是基于学术交流目的建立，仅供交流与学习使用，并非为生产环境准备。
+2. 任何发布到视频平台的基于 sovits 制作的视频，都必须要在简介明确指明用于变声器转换的输入源歌声、音频，例如：使用他人发布的视频 / 音频，通过分离的人声作为输入源进行转换的，必须要给出明确的原视频、音乐链接；若使用是自己的人声，或是使用其他歌声合成引擎合成的声音作为输入源进行转换的，也必须在简介加以说明。
+3. 由输入源造成的侵权问题需自行承担全部责任和一切后果。使用其他商用歌声合成软件作为输入源时，请确保遵守该软件的使用条例，注意，许多歌声合成引擎使用条例中明确指明不可用于输入源进行转换！
+4. 继续使用视为已同意本仓库 README 所述相关条例，本仓库 README 已进行劝导义务，不对后续可能存在问题负责。
+5. 如将本仓库代码二次分发，或将由此项目产出的任何结果公开发表 (包括但不限于视频网站投稿)，请注明原作者及代码来源 (此仓库)。
+6. 如果将此项目用于任何其他企划，请提前联系并告知本仓库作者，十分感谢。
+
+## 🆕 Update!
+
+> 更新了4.0-v2模型，全部流程同4.0，相比4.0在部分场景下有一定提升，但也有些情况有退步，具体可移步[4.0-v2分支](https://github.com/svc-develop-team/so-vits-svc/tree/4.0-v2)
+
+## 📝 模型简介
+
+歌声音色转换模型，通过SoftVC内容编码器提取源音频语音特征，与F0同时输入VITS替换原本的文本输入达到歌声转换的效果。同时，更换声码器为 [NSF HiFiGAN](https://github.com/openvpi/DiffSinger/tree/refactor/modules/nsf_hifigan) 解决断音问题
+
+### 🆕 4.0 版本更新内容
+
++ 特征输入更换为 [Content Vec](https://github.com/auspicious3000/contentvec) 
++ 采样率统一使用44100hz
++ 由于更改了hop size等参数以及精简了部分模型结构，推理所需显存占用**大幅降低**，4.0版本44khz显存占用甚至小于3.0版本的32khz
++ 调整了部分代码结构
++ 数据集制作、训练过程和3.0保持一致，但模型完全不通用，数据集也需要全部重新预处理
++ 增加了可选项 1：vc模式自动预测音高f0,即转换语音时不需要手动输入变调key，男女声的调能自动转换，但仅限语音转换，该模式转换歌声会跑调
++ 增加了可选项 2：通过kmeans聚类方案减小音色泄漏，即使得音色更加像目标音色
+
+## 💬 关于 Python 版本问题
+
+我们在进行测试后，认为 Python 3.8.9 版本能够稳定地运行该项目
+
+## 📥 预先下载的模型文件
+
+#### **必须项**
+
++ contentvec ：[checkpoint_best_legacy_500.pt](https://ibm.box.com/s/z1wgl1stco8ffooyatzdwsqn2psd9lrr)
+  + 放在`hubert`目录下
+
+```shell
+# contentvec
+http://obs.cstcloud.cn/share/obs/sankagenkeshi/checkpoint_best_legacy_500.pt
+# 也可手动下载放在hubert目录
+```
+
+#### **可选项(强烈建议使用)**
+
++ 预训练底模文件： `G_0.pth` `D_0.pth`
+  + 放在`logs/44k`目录下
+
+从svc-develop-team(待定)或任何其他地方获取
+
+虽然底模一般不会引起什么版权问题，但还是请注意一下，比如事先询问作者，又或者作者在模型描述中明确写明了可行的用途
+
+## 📊 数据集准备
+
+仅需要以以下文件结构将数据集放入dataset_raw目录即可
+
+```
+dataset_raw
+├───speaker0
+│   ├───xxx1-xxx1.wav
+│   ├───...
+│   └───Lxx-0xx8.wav
+└───speaker1
+    ├───xx2-0xxx2.wav
+    ├───...
+    └───xxx7-xxx007.wav
+```
+
+可以自定义说话人名称
+
+```
+dataset_raw
+└───suijiSUI
+    ├───1.wav
+    ├───...
+    └───25788785-20221210-200143-856_01_(Vocals)_0_0.wav
+```
+
+## 🛠️ 数据预处理
+
+1. 重采样至44100Hz单声道
+
+```shell
+python resample.py
+```
+
+2. 自动划分训练集、验证集，以及自动生成配置文件
+
+```shell
+python preprocess_flist_config.py
+```
+
+3. 生成hubert与f0
+
+```shell
+python preprocess_hubert_f0.py
+```
+
+执行完以上步骤后 dataset 目录便是预处理完成的数据，可以删除 dataset_raw 文件夹了
+
+#### 此时可以在生成的config.json修改部分参数
+
+* `keep_ckpts`：训���时保留最后几个模型，`0`为保留所有，默认只保留最后`3`个
+
+* `all_in_mem`：加载所有数据集到内存中，某些平台的硬盘IO过于低下、同时内存容量 **远大于** 数据集体积时可以启用
+
+## 🏋️‍♀️ 训练
+
+```shell
+python train.py -c configs/config.json -m 44k
+```
+
+## 🤖 推理
+
+使用 [inference_main.py](inference_main.py)
+
+```shell
+# 例
+python inference_main.py -m "logs/44k/G_30400.pth" -c "configs/config.json" -n "君の知らない物語-src.wav" -t 0 -s "nen"
+```
+
+必填项部分
++ `-m` | `--model_path`：模型路径
++ `-c` | `--config_path`：配置文件路径
++ `-n` | `--clean_names`：wav 文件名列表，放在 raw 文件夹下
++ `-t` | `--trans`：音高调整，支持正负（半音）
++ `-s` | `--spk_list`：合成目标说话人名称
++ `-cl` | `--clip`：音频强制切片，默认0为自动切片，单位为秒/s
+
+可选项部分：部分具体见下一节
++ `-lg` | `--linear_gradient`：两段音频切片的交叉淡入长度，如果强制切片后出现人声不连贯可调整该数值，如果连贯建议采用默认值0，单位为秒
++ `-fmp` | `--f0_mean_pooling`：是否对F0使用均值滤波器(池化)，对部分哑音有改善。注意，启动该选项会导致推理速度下降，默认关闭
++ `-a` | `--auto_predict_f0`：语音转换自动预测音高，转换歌声时不要打开这个会严重跑调
++ `-cm` | `--cluster_model_path`：聚类模型路径，如果没有训练聚类则随便填
++ `-cr` | `--cluster_infer_ratio`：聚类方案占比，范围0-1，若没有训练聚类模型则默认0即可
+
+## 🤔 可选项
+
+如果前面的效果已经满意，或者没看明白下面在讲啥，那后面的内容都可以忽略，不影响模型使用(这些可选项影响比较小，可能在某些特定数据上有点效果，但大部分情况似乎都感知不太明显)
+
+### 自动f0预测
+
+4.0模型训练过程会训练一个f0预测器，对于语音转换可以开启自动音高预测，如果效果不好也可以使用手动的，但转换歌声时请不要启用此功能！！！会严重跑调！！
++ 在inference_main中设置auto_predict_f0为true即可
+
+### 聚类音色泄漏控制
+
+介绍：聚类方案可以减小音色泄漏，使得模型训练出来更像目标的音色（但其实不是特别明显），但是单纯的聚类方案会降低模型的咬字（会口齿不清）（这个很明显），本模型采用了融合的方式，可以线性控制聚类方案与非聚类方案的占比，也就是可以手动在"像目标音色" 和 "咬字清晰" 之间调整比例，找到合适的折中点。
+
+使用聚类前面的已有步骤不用进行任何的变动，只需要额外训练一个聚类模型，虽然效果比较有限，但训练成本也比较低
+
++ 训练过程：
+  + 使用cpu性能较好的机器训练，据我的经验在腾讯云6核cpu训练每个speaker需要约4分钟即可完成训练
+  + 执行python cluster/train_cluster.py ，模型的输出会在 logs/44k/kmeans_10000.pt
++ 推理过程：
+  + inference_main中指定cluster_model_path
+  + inference_main中指定cluster_infer_ratio，0为完全不使用聚类，1为只使用聚类，通常设置0.5即可
+
+### F0均值滤波
+
+介绍：对F0进行均值滤波，可以有效的减少因音高推测波动造成的哑音（由于混响或和声等造成的哑音暂时不能消除）。该功能在部分歌曲上提升巨大，如果歌曲推理后出现哑音可以考虑开启。
++ 在inference_main中设置f0_mean_pooling为true即可
+
+### [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1kv-3y2DmZo0uya8pEr1xk7cSB-4e_Pct?usp=sharing) [sovits4_for_colab.ipynb](https://colab.research.google.com/drive/1kv-3y2DmZo0uya8pEr1xk7cSB-4e_Pct?usp=sharing)
+
+#### [23/03/16] 不再需要手动下载hubert
+
+## 📤 Onnx导出
+
+使用 [onnx_export.py](onnx_export.py)
++ 新建文件夹：`checkpoints` 并打开
++ 在`checkpoints`文件夹中新建一个文件夹作为项目文件夹，文件夹名为你的项目名称，比如`aziplayer`
++ 将你的模型更名为`model.pth`，配置文件更名为`config.json`，并放置到刚才创建的`aziplayer`文件夹下
++ 将 [onnx_export.py](onnx_export.py) 中`path = "NyaruTaffy"` 的 `"NyaruTaffy"` 修改为你的项目名称，`path = "aziplayer"`
++ 运行 [onnx_export.py](onnx_export.py) 
++ 等待执行完毕，在你的项目文件夹下会生成一个`model.onnx`，即为导出的模型
+
+### Onnx模型支持的UI
+
++ [MoeSS](https://github.com/NaruseMioShirakana/MoeSS)
++ 我去除了所有的训练用函数和一切复杂的转置，一行都没有保留，因为我认为只有去除了这些东西，才知道你用的是Onnx
++ 注意：Hubert Onnx模型请使用MoeSS提供的模型，目前无法自行导出（fairseq中Hubert有不少onnx不支持的算子和涉及到常量的东西，在导出时会报错或者导出的模型输入输出shape和结果都有问题��
+[Hubert4.0](https://huggingface.co/NaruseMioShirakana/MoeSS-SUBModel)
+
+## ☀️ 旧贡献者
+
+因为某些原因原作者进行了删库处理，本仓库重建之初由于组织成员疏忽直接重新上传了所有文件导致以前的contributors全部木大，现在在README里重新添加一个旧贡献者列表
+
+*某些成员已根据其个人意愿不将其列出*
+
+<table>
+  <tr>
+    <td align="center"><a href="https://github.com/MistEO"><img src="https://avatars.githubusercontent.com/u/18511905?v=4" width="100px;" alt=""/><br /><sub><b>MistEO</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/XiaoMiku01"><img src="https://avatars.githubusercontent.com/u/54094119?v=4" width="100px;" alt=""/><br /><sub><b>XiaoMiku01</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/ForsakenRei"><img src="https://avatars.githubusercontent.com/u/23041178?v=4" width="100px;" alt=""/><br /><sub><b>しぐれ</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/TomoGaSukunai"><img src="https://avatars.githubusercontent.com/u/25863522?v=4" width="100px;" alt=""/><br /><sub><b>TomoGaSukunai</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/Plachtaa"><img src="https://avatars.githubusercontent.com/u/112609742?v=4" width="100px;" alt=""/><br /><sub><b>Plachtaa</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/zdxiaoda"><img src="https://avatars.githubusercontent.com/u/45501959?v=4" width="100px;" alt=""/><br /><sub><b>zd小达</b></sub></a><br /></td>
+    <td align="center"><a href="https://github.com/Archivoice"><img src="https://avatars.githubusercontent.com/u/107520869?v=4" width="100px;" alt=""/><br /><sub><b>凍聲響世</b></sub></a><br /></td>
+  </tr>
+</table>
+
+## 📚 一些法律条例参考
+
+#### 任何国家，地区，组织和个人使用此项目必须遵守以下法律
+
+#### 《民法典》
+
+##### 第一千零一十九条
+
+任何组织或者个人不得以丑化、污损，或者利用信息技术手段伪造等方式侵害他人的肖像权。未经肖像权人同意，不得制作、使用、公开肖像权人的肖像，但是法律另有规定的除外。未经肖像权人同意，肖像作品权利人不得以发表、复制、发行、出租、展览等方式使用或者公开肖像权人的肖像。对自然人声音的保护，参照适用肖像权保护的有关规定。
+
+##### 第一千零二十四条
+
+【名誉权】民事主体享有名誉权。任何组织或者个人不得以侮辱、诽谤等方式侵害他人的名誉权。
+
+##### 第一千零二十七条
+
+【作品侵害名誉权】行为人发表的文学、艺术作品以真人真事或者特定人为描述对象，含有侮辱、诽谤内容，侵害他人名誉权的，受害人有权依法请求该行为人承担民事责任。行为人发表的文学、艺术作品不以特定人为描述对象，仅其中的情节与该特定人的情况相似的，不承担民事责任。
+
+#### 《[中华人民共和国宪法](http://www.gov.cn/guoqing/2018-03/22/content_5276318.htm)》
+
+#### 《[中华人民共和国刑法](http://gongbao.court.gov.cn/Details/f8e30d0689b23f57bfc782d21035c3.html?sw=中华人民共和国刑法)》
+
+#### 《[中华人民共和国民法典](http://gongbao.court.gov.cn/Details/51eb6750b8361f79be8f90d09bc202.html)》
+
+## 💪 感谢所有的贡献者
+<a href="https://github.com/svc-develop-team/so-vits-svc/graphs/contributors" target="_blank">
+  <img src="https://contrib.rocks/image?repo=svc-develop-team/so-vits-svc" />
+</a>

app.py

@@ -0,0 +1,446 @@
+import io
+import os
+import re
+import torch
+#import argparse
+import gradio as gr
+import gradio.processing_utils as gr_pu
+import librosa
+import numpy as np
+import soundfile as sf
+from inference.infer_tool import Svc
+import logging
+import json
+import matplotlib.pyplot as plt
+import parselmouth
+import time
+import subprocess
+import shutil
+import asyncio
+import datetime
+
+from scipy.io import wavfile
+
+#parser = argparse.ArgumentParser()
+#parser.add_argument("--user", type=str, help='set gradio user', default=None)
+#parser.add_argument("--password", type=str, help='set gradio password', default=None)
+#cmd_opts = parser.parse_args()
+
+logging.getLogger('numba').setLevel(logging.WARNING)
+logging.getLogger('markdown_it').setLevel(logging.WARNING)
+logging.getLogger('urllib3').setLevel(logging.WARNING)
+logging.getLogger('matplotlib').setLevel(logging.WARNING)
+
+raw_path = "./dataset_raw"
+models_backup_path = './models_backup'
+#now_dir = os.getcwd()
+
+def load_model_func(ckpt_name,cluster_name,config_name,enhance):
+    global model, cluster_model_path
+    
+    config_path = "configs/" + config_name
+
+    with open(config_path, 'r') as f:
+        config = json.load(f)
+    spk_dict = config["spk"]
+    spk_name = config.get('spk', None)
+    if spk_name:
+        spk_choice = next(iter(spk_name))
+    else:
+        spk_choice = "未检测到音色"
+
+    ckpt_path = "logs/44k/" + ckpt_name
+    cluster_path = "logs/44k/" + cluster_name
+    if cluster_name == "no_clu":
+            model = Svc(ckpt_path,config_path,nsf_hifigan_enhance=enhance)
+    else:
+            model = Svc(ckpt_path,config_path,cluster_model_path=cluster_path,nsf_hifigan_enhance=enhance)
+
+    spk_list = list(spk_dict.keys())
+    output_msg = "模型加载成功"
+    return output_msg, gr.Dropdown.update(choices=spk_list, value=spk_choice)
+
+def load_options():
+    file_list = os.listdir("logs/44k")
+    ckpt_list = []
+    cluster_list = []
+    for ck in file_list:
+        if os.path.splitext(ck)[-1] == ".pth" and ck[0] != "k" and ck[:2] != "D_":
+            ckpt_list.append(ck)
+        if ck[0] == "k":
+            cluster_list.append(ck)
+    if not cluster_list:
+        cluster_list = ["你没有聚类模型"]
+    return choice_ckpt.update(choices = ckpt_list), config_choice.update(choices = os.listdir("configs")), cluster_choice.update(choices = cluster_list)
+
+def vc_fn(sid, input_audio, vc_transform, auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,F0_mean_pooling,enhancer_adaptive_key):
+    global model
+    try:
+        if input_audio is None:
+            return "You need to upload an audio", None
+        if model is None:
+            return "You need to upload an model", None
+        sampling_rate, audio = input_audio
+        # print(audio.shape,sampling_rate)
+        audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
+        if len(audio.shape) > 1:
+            audio = librosa.to_mono(audio.transpose(1, 0))
+        temp_path = "temp.wav"
+        sf.write(temp_path, audio, sampling_rate, format="wav")
+        _audio = model.slice_inference(temp_path, sid, vc_transform, slice_db, cluster_ratio, auto_f0, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,F0_mean_pooling,enhancer_adaptive_key)
+        model.clear_empty()
+        os.remove(temp_path)
+        #构建保存文件的路径，并保存到results文件夹内
+        timestamp = str(int(time.time()))
+        output_file = os.path.join("results", sid + "_" + timestamp + ".wav")
+        sf.write(output_file, _audio, model.target_sample, format="wav")
+        return "Success", (model.target_sample, _audio)
+    except Exception as e:
+        return "异常信息:"+str(e)+"\n请排障后重试",None
+
+def load_raw_dirs():
+    #检查文件名
+    allowed_pattern = re.compile(r'^[a-zA-Z0-9_@#$%^&()_+\-=\s]*$')
+    for root, dirs, files in os.walk(raw_path):
+        if root != raw_path:  # 只处理子文件夹内的文件
+            for file in files:
+                file_name, _ = os.path.splitext(file)
+                if not allowed_pattern.match(file_name):
+                    return "数据集文件名只能包含数字、字母、下划线"
+    #检查有没有小可爱不用wav文件当数据集
+    for root, dirs, files in os.walk(raw_path):
+        if root != raw_path:  # 只处理子文件夹内的文件
+            for file in files:
+                if not file.endswith('.wav'):
+                    return "数据集中包含非wav格式文件，请检查后再试"
+    spk_dirs = []
+    with os.scandir(raw_path) as entries:
+        for entry in entries:
+            if entry.is_dir():
+                spk_dirs.append(entry.name)
+    if len(spk_dirs) != 0:
+        return raw_dirs_list.update(value=spk_dirs)
+    else:
+        return raw_dirs_list.update(value="未找到数据集，请检查dataset_raw文件夹")
+'''Old function
+def dataset_preprocess():
+    preprocess_commands = [
+        r".\workenv\python.exe resample.py",
+        r".\workenv\python.exe preprocess_flist_config.py",
+        r".\workenv\python.exe preprocess_hubert_f0.py"
+    ]
+    output = ""
+    for command in preprocess_commands:
+        try:
+            result = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT, text=True)
+        except subprocess.CalledProcessError as e:
+            result = e.output
+        output += f"Command: {command}\nResult:\n{result}\n{'-' * 50}\n"
+    #cmd = r".\venv\Scripts\activate&&python resample.py&&python preprocess_flist_config.py&&python preprocess_hubert_f0.py"
+    #print(cmd)
+    #p = Popen(cmd, shell=True, cwd=now_dir)
+    #p.wait()
+    config_path = "configs/config.json"
+    with open(config_path, 'r') as f:
+        config = json.load(f)
+    spk_dict = config["spk"]
+    spk_name = config.get('spk', None)
+    return output, speakers.update(value=spk_name)
+'''
+def dataset_preprocess():
+    preprocess_commands = [
+        r".\workenv\python.exe resample.py",
+        r".\workenv\python.exe preprocess_flist_config.py",
+        r".\workenv\python.exe preprocess_hubert_f0.py"
+    ]
+    accumulated_output = ""
+
+    for command in preprocess_commands:
+        try:
+            result = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True, text=True)
+
+            accumulated_output += f"Command: {command}\n"
+            yield accumulated_output, None
+
+            for line in result.stdout:
+                accumulated_output += line
+                yield accumulated_output, None
+
+            result.communicate()
+
+        except subprocess.CalledProcessError as e:
+            result = e.output
+            accumulated_output += f"Error: {result}\n"
+            yield accumulated_output, None
+
+        accumulated_output += '-' * 50 + '\n'
+        yield accumulated_output, None
+
+    config_path = "configs/config.json"
+    with open(config_path, 'r') as f:
+        config = json.load(f)
+    spk_dict = config["spk"]
+    spk_name = config.get('spk', None)
+
+    yield accumulated_output, gr.Textbox.update(value=spk_name)
+
+def clear_output():
+    return gr.Textbox.update(value="Cleared!>_<")
+
+def config_fn(log_interval, eval_interval, keep_ckpts, batch_size, lr, fp16_run, all_in_mem):
+    config_origin = ".\\configs\\config.json"
+    with open(config_origin, 'r') as config_file:
+        config_data = json.load(config_file)
+    config_data['train']['log_interval'] = int(log_interval)
+    config_data['train']['eval_interval'] = int(eval_interval)
+    config_data['train']['keep_ckpts'] = int(keep_ckpts)
+    config_data['train']['batch_size'] = int(batch_size)
+    config_data['train']['learning_rate'] = float(lr)
+    config_data['train']['fp16_run'] = fp16_run
+    config_data['train']['all_in_mem'] = all_in_mem
+    with open(config_origin, 'w') as config_file:
+        json.dump(config_data, config_file, indent=4)
+    return "配置文件写入完成"
+
+#def next_backup_folder_number(backup_path):
+#    numbers = [int(folder) for folder in os.listdir(backup_path) if folder.isdigit()]
+#    return max(numbers) + 1 if numbers else 1
+
+def training(gpu_selection):
+    if not os.listdir(r"dataset\44k"):
+        return "数据集不存在，请检查dataset文件夹"
+    dataset_path = "dataset/44k"
+    no_npy_pt_files = True
+    for root, dirs, files in os.walk(dataset_path):
+        for file in files:
+            if file.endswith('.npy') or file.endswith('.pt'):
+                no_npy_pt_files = False
+                break
+    if no_npy_pt_files:
+        return "数据集中未检测到f0和hubert文件，可能是预训练未完成"
+    #备份logs/44k文件
+    logs_44k = "logs/44k"
+    pre_trained_model = "pre_trained_model"
+    models_backup = "models_backup"
+    timestamp = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M')
+    #new_backup_folder_number = next_backup_folder_number(models_backup)
+    new_backup_folder = os.path.join(models_backup, str(timestamp))
+    os.makedirs(new_backup_folder, exist_ok=True)
+    for file in os.listdir(logs_44k):
+        shutil.move(os.path.join(logs_44k, file), os.path.join(new_backup_folder, file))
+    d_0_path = os.path.join(pre_trained_model, "D_0.pth")
+    g_0_path = os.path.join(pre_trained_model, "G_0.pth")
+    if os.path.isfile(d_0_path) and os.path.isfile(g_0_path):
+        print("D_0.pth and G_0.pth exist in pre_trained_model")
+    else:
+        print("D_0.pth and/or G_0.pth are missing in pre_trained_model")
+    shutil.copy(d_0_path, os.path.join(logs_44k, "D_0.pth"))
+    shutil.copy(g_0_path, os.path.join(logs_44k, "G_0.pth"))
+    cmd = r"set CUDA_VISIBLE_DEVICES=%s && .\workenv\python.exe train.py -c configs/config.json -m 44k" % (gpu_selection)
+    subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", cmd])
+    return "已经在新的终端窗口开始训练，请监看终端窗口的训练日志。在终端中按Ctrl+C可暂停训练。"
+
+def continue_training(gpu_selection):
+    if not os.listdir(r"dataset\44k"):
+        return "数据集不存在，请检查dataset��件夹"
+    dataset_path = "dataset/44k"
+    no_npy_pt_files = True
+    for root, dirs, files in os.walk(dataset_path):
+        for file in files:
+            if file.endswith('.npy') or file.endswith('.pt'):
+                no_npy_pt_files = False
+                break
+    if no_npy_pt_files:
+        return "数据集中未检测到f0和hubert文件，可能是预训练未完成"
+    cmd = r"set CUDA_VISIBLE_DEVICES=%s && .\workenv\python.exe train.py -c configs/config.json -m 44k" % (gpu_selection)
+    subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", cmd])
+    return "已经在新的终端窗口开始训练，请监看终端窗口的训练日志。在终端中按Ctrl+C可暂停训练。"
+
+def continue_selected_training(work_dir):
+    print(work_dir)
+    if work_dir is None:
+        return "你没有选择工作进度"
+    if not os.path.exists(os.path.join(models_backup_path, work_dir)):
+        return "该工作文件夹不存在",
+    logs_44k_path = r'logs\44k'
+    logs_44k_files = os.listdir(logs_44k_path)
+    d0_path = os.path.join(logs_44k_path, "D_0.pth")
+    g0_path = os.path.join(logs_44k_path, "G_0.pth")
+    if len(logs_44k_files) == 2 and os.path.isfile(d0_path) and os.path.isfile(g0_path):
+        os.remove(d0_path)
+        os.remove(g0_path)
+    else:
+        if logs_44k_files:
+            timestamp = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M')
+            new_backup_folder = os.path.join(models_backup_path, timestamp)
+            os.makedirs(new_backup_folder)
+
+            for file in logs_44k_files:
+                shutil.copy(os.path.join(logs_44k_path, file), new_backup_folder)
+    work_dir_path = os.path.join(models_backup_path, work_dir)
+    work_dir_files = os.listdir(work_dir_path)
+    for file in work_dir_files:
+        shutil.copy(os.path.join(work_dir_path, file), logs_44k_path)
+
+    return "已经在新的终端窗口开始训练，请监看终端窗口的训练日志。在终端中按Ctrl+C可暂停训练。"
+
+def previous_selection_refresh():
+    work_saved_list = []
+    for entry in os.listdir("models_backup"):
+        entry_path = os.path.join(models_backup_path, entry)
+        if os.path.isdir(entry_path):
+            work_saved_list.append(entry)
+    return gr.Dropdown.update(choices=work_saved_list)
+
+
+def kmeans_training():
+    if not os.listdir(r"dataset\44k"):
+        return "数据集不存在，请检查dataset文件夹"
+    subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", r".\workenv\python.exe cluster\train_cluster.py"])
+    return "已经在新的终端窗口开始训练，训练聚类模型不会输出日志，检查任务管理器中python进程有在占用CPU就是正在训练，训练一般需要5-10分钟左右"
+
+# read ckpt list
+file_list = os.listdir("logs/44k")
+ckpt_list = []
+cluster_list = []
+for ck in file_list:
+    if os.path.splitext(ck)[-1] == ".pth" and ck[0] != "k" and ck[:2] != "D_":
+        ckpt_list.append(ck)
+    if ck[0] == "k":
+        cluster_list.append(ck)
+if not cluster_list:
+    cluster_list = ["你没有聚类模型"]
+
+#read GPU info
+ngpu=torch.cuda.device_count()
+gpu_infos=[]
+if(torch.cuda.is_available()==False or ngpu==0):if_gpu_ok=False
+else:
+    if_gpu_ok = False
+    for i in range(ngpu):
+        gpu_name=torch.cuda.get_device_name(i)
+        if("16"in gpu_name or "MX"in gpu_name):continue
+        if("10"in gpu_name or "20"in gpu_name or "30"in gpu_name or "40"in gpu_name or "A50"in gpu_name.upper() or "70"in gpu_name or "80"in gpu_name or "90"in gpu_name or "M4"in gpu_name or "T4"in gpu_name or "TITAN"in gpu_name.upper()):#A10#A100#V100#A40#P40#M40#K80
+            if_gpu_ok=True#至少有一张能用的N卡
+            gpu_infos.append("%s\t%s"%(i,gpu_name))
+gpu_info="\n".join(gpu_infos)if if_gpu_ok==True and len(gpu_infos)>0 else "很遗憾您这没有能用的显卡来支持您训练"
+gpus="-".join([i[0]for i in gpu_infos])
+
+#get previous saved training work
+work_saved_list = []
+for entry in os.listdir("models_backup"):
+    entry_path = os.path.join(models_backup_path, entry)
+    if os.path.isdir(entry_path):
+        work_saved_list.append(entry)
+
+app = gr.Blocks()
+with app:
+    gr.Markdown(value="""
+        ###sovits4.0 webui 推理&训练
+                
+        修改自原项目及bilibili@麦哲云
+
+        仅供个人娱乐和非商业用途，禁止用于血腥、暴力、性相关、政治相关内容
+
+        作者：bilibili@羽毛布団
+
+        """)
+    with gr.Tabs():
+        with gr.TabItem("推理"):
+            choice_ckpt = gr.Dropdown(label="模型选择", choices=ckpt_list, value="no_model")
+            config_choice = gr.Dropdown(label="配置文件", choices=os.listdir("configs"), value="no_config")
+            cluster_choice = gr.Dropdown(label="选择聚类模型", choices=cluster_list, value="no_clu")
+            enhance = gr.Checkbox(label="是否使用NSF_HIFIGAN增强,该选项对部分训练集少的模型有一定的音质增强效果，但是对训练好的模型有反面效果，默认关闭", value=False)
+            refresh = gr.Button("刷新选项")
+            loadckpt = gr.Button("加载模型", variant="primary")
+            
+            sid = gr.Dropdown(label="音色", value="speaker0")
+            model_message = gr.Textbox(label="Output Message")
+            
+            refresh.click(load_options,[],[choice_ckpt,config_choice,cluster_choice])
+            loadckpt.click(load_model_func,[choice_ckpt,cluster_choice,config_choice,enhance],[model_message, sid])
+
+            gr.Markdown(value="""
+                请稍等片刻，模型加载大约需要10秒。后续操作不需要重新加载模型
+                """)
+            
+            vc_input3 = gr.Audio(label="上传音频")
+            vc_transform = gr.Number(label="变调（整数，可以正负，半音数量，升高八度就是12）", value=0)
+            cluster_ratio = gr.Number(label="聚类模型混合比例，0-1之间，默认为0不启用聚类，能提升音色相似度，但会导致咬字下降（如果使用建议0.5左右）", value=0)
+            auto_f0 = gr.Checkbox(label="自动f0预测，配合聚类模型f0预测效果更好,会导致变调功能失效（仅限转换语音，歌声不要勾选此项会究极跑调）", value=False)
+            F0_mean_pooling = gr.Checkbox(label="F0均值滤波(池化)，开启后可能有效改善哑音（对因和声混响造成的哑音无效）。", value=False)
+            enhancer_adaptive_key = gr.Number(label="使NSF-HIFIGAN增强器适应更高的音域(单位为半音数)|默认为0", value=0,interactive=True)
+            slice_db = gr.Number(label="切片阈值", value=-40)
+            noise_scale = gr.Number(label="noise_scale 建议不要动，会影响音质，玄学参数", value=0.4)
+            cl_num = gr.Number(label="音频自动切片，0为不切片，单位为秒/s", value=0)
+            pad_seconds = gr.Number(label="推理音频pad秒数，由于未知原因开头结尾会有异响，pad一小段静音段后就不会出现", value=0.5)
+            lg_num = gr.Number(label="两端音频切片的交叉淡入长度，如果自动切片后出现人声不连贯可调整该数值，如果连贯建议采用默认值0，注意，该设置会影响推理速度，单位为秒/s", value=0)
+            lgr_num = gr.Number(label="自动音频切片后，需要舍弃每段切片的头尾。该参数设置交叉长度保留的比例，范围0-1,左开右闭", value=0.75,interactive=True)
+
+            vc_submit = gr.Button("转换", variant="primary")
+            vc_output1 = gr.Textbox(label="Output Message")
+            vc_output2 = gr.Audio(label="Output Audio")
+
+        vc_submit.click(vc_fn, [sid, vc_input3, vc_transform,auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,F0_mean_pooling,enhancer_adaptive_key], [vc_output1, vc_output2])
+
+        with gr.TabItem("训练"):
+            gr.Markdown(value="""请将数据集文件夹放置在dataset_raw文件夹下，确认放置正确后点击下方获取数据集名称""")
+            raw_dirs_list=gr.Textbox(label="Raw dataset directory(s):")
+            get_raw_dirs=gr.Button("识别数据集", variant="primary")
+            gr.Markdown(value="""确认数据集正确识别后请点击数据预处理（大数据集可能会花上很长时间预处理，没报错等着就行）""")
+            #with gr.Row():
+            raw_preprocess=gr.Button("数据预处理", variant="primary")
+            preprocess_output=gr.Textbox(label="预处理输出信息，完成后请检查一下是否有报错信息，如无则可以进行下一步", max_lines=999)
+            clear_preprocess_output=gr.Button("清空输出信息")
+            with gr.Group():
+                gr.Markdown(value="""填写训练设置和超参数""")
+                with gr.Row():
+                    gr.Textbox(label="当前使用显卡信息", value=gpu_info)
+                    gpu_selection=gr.Textbox(label="多卡用户请指定希望训练使用的显卡ID（0,1,2...）", value=gpus, interactive=True)
+                with gr.Row():
+                    log_interval=gr.Textbox(label="每隔多少步(steps)生成一次评估日志", value="200")
+                    eval_interval=gr.Textbox(label="每隔多少步(steps)验证并保存一次模型", value="800")
+                    keep_ckpts=gr.Textbox(label="仅保留最新的X个模型，超出该数字的旧模型会被删除。设置为0则永不删除", value="10")
+                with gr.Row():
+                    batch_size=gr.Textbox(label="批量大小，每步取多少条数据进行训练，大batch可以加快训练但显著增加显存占用。6G显存建议设定为4", value="12")
+                    lr=gr.Textbox(label="学习率，尽量与batch size成正比(6:0.0001)，无法整除的话四舍五入一下也行", value="0.0002")
+                    fp16_run=gr.Checkbox(label="是否使用半精度训练，半精度训练可能降低显存占用和训练时间，但对模型质量的影响尚未查证", value=False)
+                    all_in_mem=gr.Checkbox(label="是否加载所有数据集到内存中，硬盘IO过于低下、同时内存容量远大于数据集体积时可以启用", value=False)
+                with gr.Row():
+                    gr.Markdown("请检查右侧的说话人列表是否和你要训练的目标说话人一致，确认无误后点击写入配置文件，然后就可以开始训练了")
+                    speakers=gr.Textbox(label="说话人列表")
+                    write_config=gr.Button("写入配置文件", variant="primary")
+
+            write_config_output=gr.Textbox(label="写入配置文件输出信息")
+
+            gr.Markdown(value="""**点击从头开始训练**将会自动将已有的训练进度保存到models_backup文件夹，并自动装载预训练模型。
+                **继续上一次的训练进度**将从上一个保存模型的进度继续训练。继续训练进度无需重新预处理和写入配置文件。
+                """)
+            with gr.Row():
+                with gr.Column():
+                    start_training=gr.Button("从头开始训练", variant="primary")
+                    training_output=gr.Textbox(label="训练输出信息")
+                with gr.Column():
+                    continue_training_btn=gr.Button("继续上一次的训练进度", variant="primary")
+                    continue_training_output=gr.Textbox(label="训练输出信息")
+                with gr.Column():
+                    kmeans_button=gr.Button("训练聚类模型", variant="primary")
+                    kmeans_output=gr.Textbox(label="训练输出信息")
+                    #previous_selection_training_btn=gr.Button("继续训练已保存的工作", variant="primary")
+                    #with gr.Row():
+                    #    select_previous_work=gr.Dropdown(label="选择已保存的工作进度", choices=work_saved_list)
+                    #    previous_selection_refresh_btn=gr.Button("刷新列表", variant="primary")
+                    #previous_selection_output=gr.Textbox(label="训练输出信息")
+
+
+        get_raw_dirs.click(load_raw_dirs,[],[raw_dirs_list])
+        raw_preprocess.click(dataset_preprocess,[],[preprocess_output, speakers])
+        clear_preprocess_output.click(clear_output,[],[preprocess_output])
+        write_config.click(config_fn,[log_interval, eval_interval, keep_ckpts, batch_size, lr, fp16_run, all_in_mem],[write_config_output])
+        start_training.click(training,[gpu_selection],[training_output])
+        continue_training_btn.click(continue_training,[gpu_selection],[continue_training_output])
+        #previous_selection_training_btn.click(continue_selected_training,[select_previous_work],[previous_selection_output])
+        #previous_selection_refresh_btn.click(previous_selection_refresh,[],[select_previous_work])
+        kmeans_button.click(kmeans_training,[],[kmeans_output])
+
+        app.queue(concurrency_count=1022, max_size=2044).launch(server_name="127.0.0.1",inbrowser=True,quiet=True)

data_utils.py

@@ -0,0 +1,155 @@
+import time
+import os
+import random
+import numpy as np
+import torch
+import torch.utils.data
+
+import modules.commons as commons
+import utils
+from modules.mel_processing import spectrogram_torch, spec_to_mel_torch
+from utils import load_wav_to_torch, load_filepaths_and_text
+
+# import h5py
+
+
+"""Multi speaker version"""
+
+
+class TextAudioSpeakerLoader(torch.utils.data.Dataset):
+    """
+        1) loads audio, speaker_id, text pairs
+        2) normalizes text and converts them to sequences of integers
+        3) computes spectrograms from audio files.
+    """
+
+    def __init__(self, audiopaths, hparams, all_in_mem: bool = False):
+        self.audiopaths = load_filepaths_and_text(audiopaths)
+        self.max_wav_value = hparams.data.max_wav_value
+        self.sampling_rate = hparams.data.sampling_rate
+        self.filter_length = hparams.data.filter_length
+        self.hop_length = hparams.data.hop_length
+        self.win_length = hparams.data.win_length
+        self.sampling_rate = hparams.data.sampling_rate
+        self.use_sr = hparams.train.use_sr
+        self.spec_len = hparams.train.max_speclen
+        self.spk_map = hparams.spk
+
+        random.seed(1234)
+        random.shuffle(self.audiopaths)
+        
+        self.all_in_mem = all_in_mem
+        if self.all_in_mem:
+            self.cache = [self.get_audio(p[0]) for p in self.audiopaths]
+
+    def get_audio(self, filename):
+        filename = filename.replace("\\", "/")
+        audio, sampling_rate = load_wav_to_torch(filename)
+        if sampling_rate != self.sampling_rate:
+            raise ValueError("{} SR doesn't match target {} SR".format(
+                sampling_rate, self.sampling_rate))
+        audio_norm = audio / self.max_wav_value
+        audio_norm = audio_norm.unsqueeze(0)
+        spec_filename = filename.replace(".wav", ".spec.pt")
+
+        # Ideally, all data generated after Mar 25 should have .spec.pt
+        if os.path.exists(spec_filename):
+            spec = torch.load(spec_filename)
+        else:
+            spec = spectrogram_torch(audio_norm, self.filter_length,
+                                     self.sampling_rate, self.hop_length, self.win_length,
+                                     center=False)
+            spec = torch.squeeze(spec, 0)
+            torch.save(spec, spec_filename)
+
+        spk = filename.split("/")[-2]
+        spk = torch.LongTensor([self.spk_map[spk]])
+
+        f0 = np.load(filename + ".f0.npy")
+        f0, uv = utils.interpolate_f0(f0)
+        f0 = torch.FloatTensor(f0)
+        uv = torch.FloatTensor(uv)
+
+        c = torch.load(filename+ ".soft.pt")
+        c = utils.repeat_expand_2d(c.squeeze(0), f0.shape[0])
+
+
+        lmin = min(c.size(-1), spec.size(-1))
+        assert abs(c.size(-1) - spec.size(-1)) < 3, (c.size(-1), spec.size(-1), f0.shape, filename)
+        assert abs(audio_norm.shape[1]-lmin * self.hop_length) < 3 * self.hop_length
+        spec, c, f0, uv = spec[:, :lmin], c[:, :lmin], f0[:lmin], uv[:lmin]
+        audio_norm = audio_norm[:, :lmin * self.hop_length]
+
+        return c, f0, spec, audio_norm, spk, uv
+
+    def random_slice(self, c, f0, spec, audio_norm, spk, uv):
+        # if spec.shape[1] < 30:
+        #     print("skip too short audio:", filename)
+        #     return None
+        if spec.shape[1] > 800:
+            start = random.randint(0, spec.shape[1]-800)
+            end = start + 790
+            spec, c, f0, uv = spec[:, start:end], c[:, start:end], f0[start:end], uv[start:end]
+            audio_norm = audio_norm[:, start * self.hop_length : end * self.hop_length]
+
+        return c, f0, spec, audio_norm, spk, uv
+
+    def __getitem__(self, index):
+        if self.all_in_mem:
+            return self.random_slice(*self.cache[index])
+        else:
+            return self.random_slice(*self.get_audio(self.audiopaths[index][0]))
+
+    def __len__(self):
+        return len(self.audiopaths)
+
+
+class TextAudioCollate:
+
+    def __call__(self, batch):
+        batch = [b for b in batch if b is not None]
+
+        input_lengths, ids_sorted_decreasing = torch.sort(
+            torch.LongTensor([x[0].shape[1] for x in batch]),
+            dim=0, descending=True)
+
+        max_c_len = max([x[0].size(1) for x in batch])
+        max_wav_len = max([x[3].size(1) for x in batch])
+
+        lengths = torch.LongTensor(len(batch))
+
+        c_padded = torch.FloatTensor(len(batch), batch[0][0].shape[0], max_c_len)
+        f0_padded = torch.FloatTensor(len(batch), max_c_len)
+        spec_padded = torch.FloatTensor(len(batch), batch[0][2].shape[0], max_c_len)
+        wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
+        spkids = torch.LongTensor(len(batch), 1)
+        uv_padded = torch.FloatTensor(len(batch), max_c_len)
+
+        c_padded.zero_()
+        spec_padded.zero_()
+        f0_padded.zero_()
+        wav_padded.zero_()
+        uv_padded.zero_()
+
+        for i in range(len(ids_sorted_decreasing)):
+            row = batch[ids_sorted_decreasing[i]]
+
+            c = row[0]
+            c_padded[i, :, :c.size(1)] = c
+            lengths[i] = c.size(1)
+
+            f0 = row[1]
+            f0_padded[i, :f0.size(0)] = f0
+
+            spec = row[2]
+            spec_padded[i, :, :spec.size(1)] = spec
+
+            wav = row[3]
+            wav_padded[i, :, :wav.size(1)] = wav
+
+            spkids[i, 0] = row[4]
+
+            uv = row[5]
+            uv_padded[i, :uv.size(0)] = uv
+
+        return c_padded, f0_padded, spec_padded, wav_padded, spkids, lengths, uv_padded

flask_api.py

@@ -0,0 +1,60 @@
+import io
+import logging
+
+import soundfile
+import torch
+import torchaudio
+from flask import Flask, request, send_file
+from flask_cors import CORS
+
+from inference.infer_tool import Svc, RealTimeVC
+
+app = Flask(__name__)
+
+CORS(app)
+
+logging.getLogger('numba').setLevel(logging.WARNING)
+
+
+@app.route("/voiceChangeModel", methods=["POST"])
+def voice_change_model():
+    request_form = request.form
+    wave_file = request.files.get("sample", None)
+    # 变调信息
+    f_pitch_change = float(request_form.get("fPitchChange", 0))
+    # DAW所需的采样率
+    daw_sample = int(float(request_form.get("sampleRate", 0)))
+    speaker_id = int(float(request_form.get("sSpeakId", 0)))
+    # http获得wav文件并转换
+    input_wav_path = io.BytesIO(wave_file.read())
+
+    # 模型推理
+    if raw_infer:
+        # out_audio, out_sr = svc_model.infer(speaker_id, f_pitch_change, input_wav_path)
+        out_audio, out_sr = svc_model.infer(speaker_id, f_pitch_change, input_wav_path, cluster_infer_ratio=0,
+                                            auto_predict_f0=False, noice_scale=0.4, f0_filter=False)
+        tar_audio = torchaudio.functional.resample(out_audio, svc_model.target_sample, daw_sample)
+    else:
+        out_audio = svc.process(svc_model, speaker_id, f_pitch_change, input_wav_path, cluster_infer_ratio=0,
+                                auto_predict_f0=False, noice_scale=0.4, f0_filter=False)
+        tar_audio = torchaudio.functional.resample(torch.from_numpy(out_audio), svc_model.target_sample, daw_sample)
+    # 返回音频
+    out_wav_path = io.BytesIO()
+    soundfile.write(out_wav_path, tar_audio.cpu().numpy(), daw_sample, format="wav")
+    out_wav_path.seek(0)
+    return send_file(out_wav_path, download_name="temp.wav", as_attachment=True)
+
+
+if __name__ == '__main__':
+    # 启用则为直接切片合成，False为交叉淡化方式
+    # vst插件调整0.3-0.5s切片时间可以降低延迟，直接切片方法会有连接处爆音、交叉淡化会有轻微重叠声音
+    # 自行选择能接受的方法，或将vst最大切片时间调整为1s，此处设为Ture，延迟大音质稳定一些
+    raw_infer = True
+    # 每个模型和config是唯一对应的
+    model_name = "logs/32k/G_174000-Copy1.pth"
+    config_name = "configs/config.json"
+    cluster_model_path = "logs/44k/kmeans_10000.pt"
+    svc_model = Svc(model_name, config_name, cluster_model_path=cluster_model_path)
+    svc = RealTimeVC()
+    # 此处与vst插件对应，不建议更改
+    app.run(port=6842, host="0.0.0.0", debug=False, threaded=False)

flask_api_full_song.py

@@ -0,0 +1,55 @@
+import io
+import numpy as np
+import soundfile
+from flask import Flask, request, send_file
+
+from inference import infer_tool
+from inference import slicer
+
+app = Flask(__name__)
+
+
+@app.route("/wav2wav", methods=["POST"])
+def wav2wav():
+    request_form = request.form
+    audio_path = request_form.get("audio_path", None)  # wav文件地址
+    tran = int(float(request_form.get("tran", 0)))  # 音调
+    spk = request_form.get("spk", 0)  # 说话人(id或者name都可以,具体看你的config)
+    wav_format = request_form.get("wav_format", 'wav')  # 范围文件格式
+    infer_tool.format_wav(audio_path)
+    chunks = slicer.cut(audio_path, db_thresh=-40)
+    audio_data, audio_sr = slicer.chunks2audio(audio_path, chunks)
+
+    audio = []
+    for (slice_tag, data) in audio_data:
+        print(f'#=====segment start, {round(len(data) / audio_sr, 3)}s======')
+
+        length = int(np.ceil(len(data) / audio_sr * svc_model.target_sample))
+        if slice_tag:
+            print('jump empty segment')
+            _audio = np.zeros(length)
+        else:
+            # padd
+            pad_len = int(audio_sr * 0.5)
+            data = np.concatenate([np.zeros([pad_len]), data, np.zeros([pad_len])])
+            raw_path = io.BytesIO()
+            soundfile.write(raw_path, data, audio_sr, format="wav")
+            raw_path.seek(0)
+            out_audio, out_sr = svc_model.infer(spk, tran, raw_path)
+            svc_model.clear_empty()
+            _audio = out_audio.cpu().numpy()
+            pad_len = int(svc_model.target_sample * 0.5)
+            _audio = _audio[pad_len:-pad_len]
+
+        audio.extend(list(infer_tool.pad_array(_audio, length)))
+    out_wav_path = io.BytesIO()
+    soundfile.write(out_wav_path, audio, svc_model.target_sample, format=wav_format)
+    out_wav_path.seek(0)
+    return send_file(out_wav_path, download_name=f"temp.{wav_format}", as_attachment=True)
+
+
+if __name__ == '__main__':
+    model_name = "logs/44k/G_60000.pth"  # 模型地址
+    config_name = "configs/config.json"  # config地址
+    svc_model = infer_tool.Svc(model_name, config_name)
+    app.run(port=1145, host="0.0.0.0", debug=False, threaded=False)

inference_main.py

@@ -0,0 +1,137 @@
+import io
+import logging
+import time
+from pathlib import Path
+
+import librosa
+import matplotlib.pyplot as plt
+import numpy as np
+import soundfile
+
+from inference import infer_tool
+from inference import slicer
+from inference.infer_tool import Svc
+
+logging.getLogger('numba').setLevel(logging.WARNING)
+chunks_dict = infer_tool.read_temp("inference/chunks_temp.json")
+
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description='sovits4 inference')
+
+    # 一定要设置的部分
+    parser.add_argument('-m', '--model_path', type=str, default="logs/44k/G_0.pth", help='模型路径')
+    parser.add_argument('-c', '--config_path', type=str, default="configs/config.json", help='配置文件路径')
+    parser.add_argument('-cl', '--clip', type=float, default=0, help='音频强制切片，默认0为自动切片，单位为秒/s')
+    parser.add_argument('-n', '--clean_names', type=str, nargs='+', default=["君の知らない物語-src.wav"], help='wav文件名列表，放在raw文件夹下')
+    parser.add_argument('-t', '--trans', type=int, nargs='+', default=[0], help='音高调整，支持正负（半音）')
+    parser.add_argument('-s', '--spk_list', type=str, nargs='+', default=['nen'], help='合成目标说话人名称')
+
+    # 可选项部分
+    parser.add_argument('-a', '--auto_predict_f0', action='store_true', default=False,help='语音转换自动预测音高，转换歌声时不要打开这个会严重跑调')
+    parser.add_argument('-cm', '--cluster_model_path', type=str, default="logs/44k/kmeans_10000.pt", help='聚类模型路径，如果没有训练聚类则随便填')
+    parser.add_argument('-cr', '--cluster_infer_ratio', type=float, default=0, help='聚类方案占比，范围0-1，若没有训练聚类模型则默认0即可')
+    parser.add_argument('-lg', '--linear_gradient', type=float, default=0, help='两段音频切片的交叉淡入长度，如果强制切片后出现人声不连贯可调整该数值，如果连贯建议采用默认值0，单位为秒')
+    parser.add_argument('-fmp', '--f0_mean_pooling', type=bool, default=False, help='是否对F0使用均值滤波器(池化)，对部分哑音有改善。注意，启动该选项会导致推理速度下降，默认关闭')
+    parser.add_argument('-eh', '--enhance', type=bool, default=False, help='是否使用NSF_HIFIGAN增强器,该选项对部分训练集少的模型有一定的音质增强效果，但是对训练好的模型有反面效果，默认关闭')
+ 
+    # 不用动的部分
+    parser.add_argument('-sd', '--slice_db', type=int, default=-40, help='默认-40，嘈杂的音频可以-30，干声保留呼吸可以-50')
+    parser.add_argument('-d', '--device', type=str, default=None, help='推理设备，None则为自动选择cpu和gpu')
+    parser.add_argument('-ns', '--noice_scale', type=float, default=0.4, help='噪音级别，会影响咬字和音质，较为玄学')
+    parser.add_argument('-p', '--pad_seconds', type=float, default=0.5, help='推理音频pad秒数，由于未知原因开头结尾会有异响，pad一小段静音段后就不会出现')
+    parser.add_argument('-wf', '--wav_format', type=str, default='flac', help='音频输出格式')
+    parser.add_argument('-lgr', '--linear_gradient_retain', type=float, default=0.75, help='自动音频切片后，需要舍弃每段切片的头尾。该参数设置交叉长度保留的比例，范围0-1,左开右闭')
+    parser.add_argument('-eak', '--enhancer_adaptive_key', type=int, default=0, help='使增强器适应更高的音域(单位为半音数)|默认为0')
+    
+    args = parser.parse_args()
+
+    clean_names = args.clean_names
+    trans = args.trans
+    spk_list = args.spk_list
+    slice_db = args.slice_db
+    wav_format = args.wav_format
+    auto_predict_f0 = args.auto_predict_f0
+    cluster_infer_ratio = args.cluster_infer_ratio
+    noice_scale = args.noice_scale
+    pad_seconds = args.pad_seconds
+    clip = args.clip
+    lg = args.linear_gradient
+    lgr = args.linear_gradient_retain
+    F0_mean_pooling = args.f0_mean_pooling
+    enhance = args.enhance
+    enhancer_adaptive_key = args.enhancer_adaptive_key
+
+    svc_model = Svc(args.model_path, args.config_path, args.device, args.cluster_model_path,enhance)
+    infer_tool.mkdir(["raw", "results"])
+
+    infer_tool.fill_a_to_b(trans, clean_names)
+    for clean_name, tran in zip(clean_names, trans):
+        raw_audio_path = f"raw/{clean_name}"
+        if "." not in raw_audio_path:
+            raw_audio_path += ".wav"
+        infer_tool.format_wav(raw_audio_path)
+        wav_path = Path(raw_audio_path).with_suffix('.wav')
+        chunks = slicer.cut(wav_path, db_thresh=slice_db)
+        audio_data, audio_sr = slicer.chunks2audio(wav_path, chunks)
+        per_size = int(clip*audio_sr)
+        lg_size = int(lg*audio_sr)
+        lg_size_r = int(lg_size*lgr)
+        lg_size_c_l = (lg_size-lg_size_r)//2
+        lg_size_c_r = lg_size-lg_size_r-lg_size_c_l
+        lg = np.linspace(0,1,lg_size_r) if lg_size!=0 else 0
+
+        for spk in spk_list:
+            audio = []
+            for (slice_tag, data) in audio_data:
+                print(f'#=====segment start, {round(len(data) / audio_sr, 3)}s======')
+                
+                length = int(np.ceil(len(data) / audio_sr * svc_model.target_sample))
+                if slice_tag:
+                    print('jump empty segment')
+                    _audio = np.zeros(length)
+                    audio.extend(list(infer_tool.pad_array(_audio, length)))
+                    continue
+                if per_size != 0:
+                    datas = infer_tool.split_list_by_n(data, per_size,lg_size)
+                else:
+                    datas = [data]
+                for k,dat in enumerate(datas):
+                    per_length = int(np.ceil(len(dat) / audio_sr * svc_model.target_sample)) if clip!=0 else length
+                    if clip!=0: print(f'###=====segment clip start, {round(len(dat) / audio_sr, 3)}s======')
+                    # padd
+                    pad_len = int(audio_sr * pad_seconds)
+                    dat = np.concatenate([np.zeros([pad_len]), dat, np.zeros([pad_len])])
+                    raw_path = io.BytesIO()
+                    soundfile.write(raw_path, dat, audio_sr, format="wav")
+                    raw_path.seek(0)
+                    out_audio, out_sr = svc_model.infer(spk, tran, raw_path,
+                                                        cluster_infer_ratio=cluster_infer_ratio,
+                                                        auto_predict_f0=auto_predict_f0,
+                                                        noice_scale=noice_scale,
+                                                        F0_mean_pooling = F0_mean_pooling,
+                                                        enhancer_adaptive_key = enhancer_adaptive_key
+                                                        )
+                    _audio = out_audio.cpu().numpy()
+                    pad_len = int(svc_model.target_sample * pad_seconds)
+                    _audio = _audio[pad_len:-pad_len]
+                    _audio = infer_tool.pad_array(_audio, per_length)
+                    if lg_size!=0 and k!=0:
+                        lg1 = audio[-(lg_size_r+lg_size_c_r):-lg_size_c_r] if lgr != 1 else audio[-lg_size:]
+                        lg2 = _audio[lg_size_c_l:lg_size_c_l+lg_size_r]  if lgr != 1 else _audio[0:lg_size]
+                        lg_pre = lg1*(1-lg)+lg2*lg
+                        audio = audio[0:-(lg_size_r+lg_size_c_r)] if lgr != 1 else audio[0:-lg_size]
+                        audio.extend(lg_pre)
+                        _audio = _audio[lg_size_c_l+lg_size_r:] if lgr != 1 else _audio[lg_size:]
+                    audio.extend(list(_audio))
+            key = "auto" if auto_predict_f0 else f"{tran}key"
+            cluster_name = "" if cluster_infer_ratio == 0 else f"_{cluster_infer_ratio}"
+            res_path = f'./results/{clean_name}_{key}_{spk}{cluster_name}.{wav_format}'
+            soundfile.write(res_path, audio, svc_model.target_sample, format=wav_format)
+            svc_model.clear_empty()
+            
+if __name__ == '__main__':
+    main()

models.py

@@ -0,0 +1,420 @@
+import copy
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import modules.attentions as attentions
+import modules.commons as commons
+import modules.modules as modules
+
+from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
+from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
+
+import utils
+from modules.commons import init_weights, get_padding
+from vdecoder.hifigan.models import Generator
+from utils import f0_to_coarse
+
+class ResidualCouplingBlock(nn.Module):
+  def __init__(self,
+      channels,
+      hidden_channels,
+      kernel_size,
+      dilation_rate,
+      n_layers,
+      n_flows=4,
+      gin_channels=0):
+    super().__init__()
+    self.channels = channels
+    self.hidden_channels = hidden_channels
+    self.kernel_size = kernel_size
+    self.dilation_rate = dilation_rate
+    self.n_layers = n_layers
+    self.n_flows = n_flows
+    self.gin_channels = gin_channels
+
+    self.flows = nn.ModuleList()
+    for i in range(n_flows):
+      self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
+      self.flows.append(modules.Flip())
+
+  def forward(self, x, x_mask, g=None, reverse=False):
+    if not reverse:
+      for flow in self.flows:
+        x, _ = flow(x, x_mask, g=g, reverse=reverse)
+    else:
+      for flow in reversed(self.flows):
+        x = flow(x, x_mask, g=g, reverse=reverse)
+    return x
+
+
+class Encoder(nn.Module):
+  def __init__(self,
+      in_channels,
+      out_channels,
+      hidden_channels,
+      kernel_size,
+      dilation_rate,
+      n_layers,
+      gin_channels=0):
+    super().__init__()
+    self.in_channels = in_channels
+    self.out_channels = out_channels
+    self.hidden_channels = hidden_channels
+    self.kernel_size = kernel_size
+    self.dilation_rate = dilation_rate
+    self.n_layers = n_layers
+    self.gin_channels = gin_channels
+
+    self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+    self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
+    self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
+
+  def forward(self, x, x_lengths, g=None):
+    # print(x.shape,x_lengths.shape)
+    x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+    x = self.pre(x) * x_mask
+    x = self.enc(x, x_mask, g=g)
+    stats = self.proj(x) * x_mask
+    m, logs = torch.split(stats, self.out_channels, dim=1)
+    z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
+    return z, m, logs, x_mask
+
+
+class TextEncoder(nn.Module):
+  def __init__(self,
+      out_channels,
+      hidden_channels,
+      kernel_size,
+      n_layers,
+      gin_channels=0,
+      filter_channels=None,
+      n_heads=None,
+      p_dropout=None):
+    super().__init__()
+    self.out_channels = out_channels
+    self.hidden_channels = hidden_channels
+    self.kernel_size = kernel_size
+    self.n_layers = n_layers
+    self.gin_channels = gin_channels
+    self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
+    self.f0_emb = nn.Embedding(256, hidden_channels)
+
+    self.enc_ =  attentions.Encoder(
+        hidden_channels,
+        filter_channels,
+        n_heads,
+        n_layers,
+        kernel_size,
+        p_dropout)
+
+  def forward(self, x, x_mask, f0=None, noice_scale=1):
+    x = x + self.f0_emb(f0).transpose(1,2)
+    x = self.enc_(x * x_mask, x_mask)
+    stats = self.proj(x) * x_mask
+    m, logs = torch.split(stats, self.out_channels, dim=1)
+    z = (m + torch.randn_like(m) * torch.exp(logs) * noice_scale) * x_mask
+
+    return z, m, logs, x_mask
+
+
+
+class DiscriminatorP(torch.nn.Module):
+    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
+        super(DiscriminatorP, self).__init__()
+        self.period = period
+        self.use_spectral_norm = use_spectral_norm
+        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
+        self.convs = nn.ModuleList([
+            norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+            norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+            norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+            norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+            norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
+        ])
+        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
+
+    def forward(self, x):
+        fmap = []
+
+        # 1d to 2d
+        b, c, t = x.shape
+        if t % self.period != 0: # pad first
+            n_pad = self.period - (t % self.period)
+            x = F.pad(x, (0, n_pad), "reflect")
+            t = t + n_pad
+        x = x.view(b, c, t // self.period, self.period)
+
+        for l in self.convs:
+            x = l(x)
+            x = F.leaky_relu(x, modules.LRELU_SLOPE)
+            fmap.append(x)
+        x = self.conv_post(x)
+        fmap.append(x)
+        x = torch.flatten(x, 1, -1)
+
+        return x, fmap
+
+
+class DiscriminatorS(torch.nn.Module):
+    def __init__(self, use_spectral_norm=False):
+        super(DiscriminatorS, self).__init__()
+        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
+        self.convs = nn.ModuleList([
+            norm_f(Conv1d(1, 16, 15, 1, padding=7)),
+            norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
+            norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
+            norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
+            norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
+            norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
+        ])
+        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
+
+    def forward(self, x):
+        fmap = []
+
+        for l in self.convs:
+            x = l(x)
+            x = F.leaky_relu(x, modules.LRELU_SLOPE)
+            fmap.append(x)
+        x = self.conv_post(x)
+        fmap.append(x)
+        x = torch.flatten(x, 1, -1)
+
+        return x, fmap
+
+
+class MultiPeriodDiscriminator(torch.nn.Module):
+    def __init__(self, use_spectral_norm=False):
+        super(MultiPeriodDiscriminator, self).__init__()
+        periods = [2,3,5,7,11]
+
+        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
+        discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
+        self.discriminators = nn.ModuleList(discs)
+
+    def forward(self, y, y_hat):
+        y_d_rs = []
+        y_d_gs = []
+        fmap_rs = []
+        fmap_gs = []
+        for i, d in enumerate(self.discriminators):
+            y_d_r, fmap_r = d(y)
+            y_d_g, fmap_g = d(y_hat)
+            y_d_rs.append(y_d_r)
+            y_d_gs.append(y_d_g)
+            fmap_rs.append(fmap_r)
+            fmap_gs.append(fmap_g)
+
+        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
+
+
+class SpeakerEncoder(torch.nn.Module):
+    def __init__(self, mel_n_channels=80, model_num_layers=3, model_hidden_size=256, model_embedding_size=256):
+        super(SpeakerEncoder, self).__init__()
+        self.lstm = nn.LSTM(mel_n_channels, model_hidden_size, model_num_layers, batch_first=True)
+        self.linear = nn.Linear(model_hidden_size, model_embedding_size)
+        self.relu = nn.ReLU()
+
+    def forward(self, mels):
+        self.lstm.flatten_parameters()
+        _, (hidden, _) = self.lstm(mels)
+        embeds_raw = self.relu(self.linear(hidden[-1]))
+        return embeds_raw / torch.norm(embeds_raw, dim=1, keepdim=True)
+
+    def compute_partial_slices(self, total_frames, partial_frames, partial_hop):
+        mel_slices = []
+        for i in range(0, total_frames-partial_frames, partial_hop):
+            mel_range = torch.arange(i, i+partial_frames)
+            mel_slices.append(mel_range)
+
+        return mel_slices
+
+    def embed_utterance(self, mel, partial_frames=128, partial_hop=64):
+        mel_len = mel.size(1)
+        last_mel = mel[:,-partial_frames:]
+
+        if mel_len > partial_frames:
+            mel_slices = self.compute_partial_slices(mel_len, partial_frames, partial_hop)
+            mels = list(mel[:,s] for s in mel_slices)
+            mels.append(last_mel)
+            mels = torch.stack(tuple(mels), 0).squeeze(1)
+
+            with torch.no_grad():
+                partial_embeds = self(mels)
+            embed = torch.mean(partial_embeds, axis=0).unsqueeze(0)
+            #embed = embed / torch.linalg.norm(embed, 2)
+        else:
+            with torch.no_grad():
+                embed = self(last_mel)
+
+        return embed
+
+class F0Decoder(nn.Module):
+    def __init__(self,
+                 out_channels,
+                 hidden_channels,
+                 filter_channels,
+                 n_heads,
+                 n_layers,
+                 kernel_size,
+                 p_dropout,
+                 spk_channels=0):
+        super().__init__()
+        self.out_channels = out_channels
+        self.hidden_channels = hidden_channels
+        self.filter_channels = filter_channels
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.kernel_size = kernel_size
+        self.p_dropout = p_dropout
+        self.spk_channels = spk_channels
+
+        self.prenet = nn.Conv1d(hidden_channels, hidden_channels, 3, padding=1)
+        self.decoder = attentions.FFT(
+            hidden_channels,
+            filter_channels,
+            n_heads,
+            n_layers,
+            kernel_size,
+            p_dropout)
+        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
+        self.f0_prenet = nn.Conv1d(1, hidden_channels , 3, padding=1)
+        self.cond = nn.Conv1d(spk_channels, hidden_channels, 1)
+
+    def forward(self, x, norm_f0, x_mask, spk_emb=None):
+        x = torch.detach(x)
+        if (spk_emb is not None):
+            x = x + self.cond(spk_emb)
+        x += self.f0_prenet(norm_f0)
+        x = self.prenet(x) * x_mask
+        x = self.decoder(x * x_mask, x_mask)
+        x = self.proj(x) * x_mask
+        return x
+
+
+class SynthesizerTrn(nn.Module):
+  """
+  Synthesizer for Training
+  """
+
+  def __init__(self,
+    spec_channels,
+    segment_size,
+    inter_channels,
+    hidden_channels,
+    filter_channels,
+    n_heads,
+    n_layers,
+    kernel_size,
+    p_dropout,
+    resblock,
+    resblock_kernel_sizes,
+    resblock_dilation_sizes,
+    upsample_rates,
+    upsample_initial_channel,
+    upsample_kernel_sizes,
+    gin_channels,
+    ssl_dim,
+    n_speakers,
+    sampling_rate=44100,
+    **kwargs):
+
+    super().__init__()
+    self.spec_channels = spec_channels
+    self.inter_channels = inter_channels
+    self.hidden_channels = hidden_channels
+    self.filter_channels = filter_channels
+    self.n_heads = n_heads
+    self.n_layers = n_layers
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.resblock = resblock
+    self.resblock_kernel_sizes = resblock_kernel_sizes
+    self.resblock_dilation_sizes = resblock_dilation_sizes
+    self.upsample_rates = upsample_rates
+    self.upsample_initial_channel = upsample_initial_channel
+    self.upsample_kernel_sizes = upsample_kernel_sizes
+    self.segment_size = segment_size
+    self.gin_channels = gin_channels
+    self.ssl_dim = ssl_dim
+    self.emb_g = nn.Embedding(n_speakers, gin_channels)
+
+    self.pre = nn.Conv1d(ssl_dim, hidden_channels, kernel_size=5, padding=2)
+
+    self.enc_p = TextEncoder(
+        inter_channels,
+        hidden_channels,
+        filter_channels=filter_channels,
+        n_heads=n_heads,
+        n_layers=n_layers,
+        kernel_size=kernel_size,
+        p_dropout=p_dropout
+    )
+    hps = {
+        "sampling_rate": sampling_rate,
+        "inter_channels": inter_channels,
+        "resblock": resblock,
+        "resblock_kernel_sizes": resblock_kernel_sizes,
+        "resblock_dilation_sizes": resblock_dilation_sizes,
+        "upsample_rates": upsample_rates,
+        "upsample_initial_channel": upsample_initial_channel,
+        "upsample_kernel_sizes": upsample_kernel_sizes,
+        "gin_channels": gin_channels,
+    }
+    self.dec = Generator(h=hps)
+    self.enc_q = Encoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
+    self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
+    self.f0_decoder = F0Decoder(
+        1,
+        hidden_channels,
+        filter_channels,
+        n_heads,
+        n_layers,
+        kernel_size,
+        p_dropout,
+        spk_channels=gin_channels
+    )
+    self.emb_uv = nn.Embedding(2, hidden_channels)
+
+  def forward(self, c, f0, uv, spec, g=None, c_lengths=None, spec_lengths=None):
+    g = self.emb_g(g).transpose(1,2)
+    # ssl prenet
+    x_mask = torch.unsqueeze(commons.sequence_mask(c_lengths, c.size(2)), 1).to(c.dtype)
+    x = self.pre(c) * x_mask + self.emb_uv(uv.long()).transpose(1,2)
+
+    # f0 predict
+    lf0 = 2595. * torch.log10(1. + f0.unsqueeze(1) / 700.) / 500
+    norm_lf0 = utils.normalize_f0(lf0, x_mask, uv)
+    pred_lf0 = self.f0_decoder(x, norm_lf0, x_mask, spk_emb=g)
+
+    # encoder
+    z_ptemp, m_p, logs_p, _ = self.enc_p(x, x_mask, f0=f0_to_coarse(f0))
+    z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g) 
+
+    # flow
+    z_p = self.flow(z, spec_mask, g=g)
+    z_slice, pitch_slice, ids_slice = commons.rand_slice_segments_with_pitch(z, f0, spec_lengths, self.segment_size)
+
+    # nsf decoder
+    o = self.dec(z_slice, g=g, f0=pitch_slice)
+
+    return o, ids_slice, spec_mask, (z, z_p, m_p, logs_p, m_q, logs_q), pred_lf0, norm_lf0, lf0
+
+  def infer(self, c, f0, uv, g=None, noice_scale=0.35, predict_f0=False):
+    c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
+    g = self.emb_g(g).transpose(1,2)
+    x_mask = torch.unsqueeze(commons.sequence_mask(c_lengths, c.size(2)), 1).to(c.dtype)
+    x = self.pre(c) * x_mask + self.emb_uv(uv.long()).transpose(1,2)
+
+    if predict_f0:
+        lf0 = 2595. * torch.log10(1. + f0.unsqueeze(1) / 700.) / 500
+        norm_lf0 = utils.normalize_f0(lf0, x_mask, uv, random_scale=False)
+        pred_lf0 = self.f0_decoder(x, norm_lf0, x_mask, spk_emb=g)
+        f0 = (700 * (torch.pow(10, pred_lf0 * 500 / 2595) - 1)).squeeze(1)
+
+    z_p, m_p, logs_p, c_mask = self.enc_p(x, x_mask, f0=f0_to_coarse(f0), noice_scale=noice_scale)
+    z = self.flow(z_p, c_mask, g=g, reverse=True)
+    o = self.dec(z * c_mask, g=g, f0=f0)
+    return o

onnx_export.py

@@ -0,0 +1,54 @@
+import torch
+from onnxexport.model_onnx import SynthesizerTrn
+import utils
+
+def main(NetExport):
+    path = "SoVits4.0"
+    if NetExport:
+        device = torch.device("cpu")
+        hps = utils.get_hparams_from_file(f"checkpoints/{path}/config.json")
+        SVCVITS = SynthesizerTrn(
+            hps.data.filter_length // 2 + 1,
+            hps.train.segment_size // hps.data.hop_length,
+            **hps.model)
+        _ = utils.load_checkpoint(f"checkpoints/{path}/model.pth", SVCVITS, None)
+        _ = SVCVITS.eval().to(device)
+        for i in SVCVITS.parameters():
+            i.requires_grad = False
+        
+        n_frame = 10
+        test_hidden_unit = torch.rand(1, n_frame, 256)
+        test_pitch = torch.rand(1, n_frame)
+        test_mel2ph = torch.arange(0, n_frame, dtype=torch.int64)[None] # torch.LongTensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).unsqueeze(0)
+        test_uv = torch.ones(1, n_frame, dtype=torch.float32)
+        test_noise = torch.randn(1, 192, n_frame)
+        test_sid = torch.LongTensor([0])
+        input_names = ["c", "f0", "mel2ph", "uv", "noise", "sid"]
+        output_names = ["audio", ]
+        
+        torch.onnx.export(SVCVITS,
+                          (
+                              test_hidden_unit.to(device),
+                              test_pitch.to(device),
+                              test_mel2ph.to(device),
+                              test_uv.to(device),
+                              test_noise.to(device),
+                              test_sid.to(device)
+                          ),
+                          f"checkpoints/{path}/model.onnx",
+                          dynamic_axes={
+                              "c": [0, 1],
+                              "f0": [1],
+                              "mel2ph": [1],
+                              "uv": [1],
+                              "noise": [2],
+                          },
+                          do_constant_folding=False,
+                          opset_version=16,
+                          verbose=False,
+                          input_names=input_names,
+                          output_names=output_names)
+
+
+if __name__ == '__main__':
+    main(True)

preprocess_flist_config.py

@@ -0,0 +1,75 @@
+import os
+import argparse
+import re
+
+from tqdm import tqdm
+from random import shuffle
+import json
+import wave
+
+config_template = json.load(open("configs_template/config_template.json"))
+
+pattern = re.compile(r'^[\.a-zA-Z0-9_\/]+$')
+
+def get_wav_duration(file_path):
+    with wave.open(file_path, 'rb') as wav_file:
+        # 获取音频帧数
+        n_frames = wav_file.getnframes()
+        # 获取采样率
+        framerate = wav_file.getframerate()
+        # 计算时长（秒）
+        duration = n_frames / float(framerate)
+    return duration
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--train_list", type=str, default="./filelists/train.txt", help="path to train list")
+    parser.add_argument("--val_list", type=str, default="./filelists/val.txt", help="path to val list")
+    parser.add_argument("--source_dir", type=str, default="./dataset/44k", help="path to source dir")
+    args = parser.parse_args()
+    
+    train = []
+    val = []
+    idx = 0
+    spk_dict = {}
+    spk_id = 0
+    for speaker in tqdm(os.listdir(args.source_dir)):
+        spk_dict[speaker] = spk_id
+        spk_id += 1
+        wavs = ["/".join([args.source_dir, speaker, i]) for i in os.listdir(os.path.join(args.source_dir, speaker))]
+        new_wavs = []
+        for file in wavs:
+            if not file.endswith("wav"):
+                continue
+            #if not pattern.match(file):
+            #    print(f"warning：文件名{file}中包含非字母数字下划线，可能会导致错误。（也可能不会）")
+            if get_wav_duration(file) < 0.3:
+                print("skip too short audio:", file)
+                continue
+            new_wavs.append(file)
+        wavs = new_wavs
+        shuffle(wavs)
+        train += wavs[2:]
+        val += wavs[:2]
+
+    shuffle(train)
+    shuffle(val)
+            
+    print("Writing", args.train_list)
+    with open(args.train_list, "w") as f:
+        for fname in tqdm(train):
+            wavpath = fname
+            f.write(wavpath + "\n")
+        
+    print("Writing", args.val_list)
+    with open(args.val_list, "w") as f:
+        for fname in tqdm(val):
+            wavpath = fname
+            f.write(wavpath + "\n")
+
+    config_template["spk"] = spk_dict
+    config_template["model"]["n_speakers"] = spk_id
+	
+    print("Writing configs/config.json")
+    with open("configs/config.json", "w") as f:
+        json.dump(config_template, f, indent=2)

preprocess_hubert_f0.py

@@ -0,0 +1,101 @@
+import math
+import multiprocessing
+import os
+import argparse
+from random import shuffle
+
+import torch
+from glob import glob
+from tqdm import tqdm
+from modules.mel_processing import spectrogram_torch
+
+import utils
+import logging
+
+logging.getLogger("numba").setLevel(logging.WARNING)
+import librosa
+import numpy as np
+
+hps = utils.get_hparams_from_file("configs/config.json")
+sampling_rate = hps.data.sampling_rate
+hop_length = hps.data.hop_length
+
+
+def process_one(filename, hmodel):
+    # print(filename)
+    wav, sr = librosa.load(filename, sr=sampling_rate)
+    soft_path = filename + ".soft.pt"
+    if not os.path.exists(soft_path):
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        wav16k = librosa.resample(wav, orig_sr=sampling_rate, target_sr=16000)
+        wav16k = torch.from_numpy(wav16k).to(device)
+        c = utils.get_hubert_content(hmodel, wav_16k_tensor=wav16k)
+        torch.save(c.cpu(), soft_path)
+
+    f0_path = filename + ".f0.npy"
+    if not os.path.exists(f0_path):
+        f0 = utils.compute_f0_dio(
+            wav, sampling_rate=sampling_rate, hop_length=hop_length
+        )
+        np.save(f0_path, f0)
+
+    spec_path = filename.replace(".wav", ".spec.pt")
+    if not os.path.exists(spec_path):
+        # Process spectrogram
+        # The following code can't be replaced by torch.FloatTensor(wav)
+        # because load_wav_to_torch return a tensor that need to be normalized
+
+        audio, sr = utils.load_wav_to_torch(filename)
+        if sr != hps.data.sampling_rate:
+            raise ValueError(
+                "{} SR doesn't match target {} SR".format(
+                    sr, hps.data.sampling_rate
+                )
+            )
+
+        audio_norm = audio / hps.data.max_wav_value
+        audio_norm = audio_norm.unsqueeze(0)
+
+        spec = spectrogram_torch(
+            audio_norm,
+            hps.data.filter_length,
+            hps.data.sampling_rate,
+            hps.data.hop_length,
+            hps.data.win_length,
+            center=False,
+        )
+        spec = torch.squeeze(spec, 0)
+        torch.save(spec, spec_path)
+
+
+def process_batch(filenames):
+    print("Loading hubert for content...")
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    hmodel = utils.get_hubert_model().to(device)
+    print("Loaded hubert.")
+    for filename in tqdm(filenames):
+        process_one(filename, hmodel)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--in_dir", type=str, default="dataset/44k", help="path to input dir"
+    )
+
+    args = parser.parse_args()
+    filenames = glob(f"{args.in_dir}/*/*.wav", recursive=True)  # [:10]
+    shuffle(filenames)
+    multiprocessing.set_start_method("spawn", force=True)
+
+    num_processes = 1
+    chunk_size = int(math.ceil(len(filenames) / num_processes))
+    chunks = [
+        filenames[i : i + chunk_size] for i in range(0, len(filenames), chunk_size)
+    ]
+    print([len(c) for c in chunks])
+    processes = [
+        multiprocessing.Process(target=process_batch, args=(chunk,)) for chunk in chunks
+    ]
+    for p in processes:
+        p.start()

requirements.txt

@@ -0,0 +1,21 @@
+Flask
+Flask_Cors
+gradio
+numpy
+pyworld==0.2.5
+scipy==1.7.3
+SoundFile==0.12.1
+torch==1.13.1
+torchaudio==0.13.1
+torchcrepe
+tqdm
+scikit-maad
+praat-parselmouth
+onnx
+onnxsim
+onnxoptimizer
+fairseq==0.12.2
+librosa==0.9.1
+tensorboard
+tensorboardX
+edge_tts

requirements_win.txt

@@ -0,0 +1,24 @@
+librosa==0.9.1
+fairseq==0.12.2
+Flask==2.1.2
+Flask_Cors==3.0.10
+gradio
+numpy
+playsound==1.3.0
+PyAudio==0.2.12
+pydub==0.25.1
+pyworld==0.3.0
+requests==2.28.1
+scipy==1.7.3
+sounddevice==0.4.5
+SoundFile==0.10.3.post1
+starlette==0.19.1
+tqdm==4.63.0
+torchcrepe
+scikit-maad
+praat-parselmouth
+onnx
+onnxsim
+onnxoptimizer
+tensorboardX
+edge_tts

resample.py

@@ -0,0 +1,48 @@
+import os
+import argparse
+import librosa
+import numpy as np
+from multiprocessing import Pool, cpu_count
+from scipy.io import wavfile
+from tqdm import tqdm
+
+
+def process(item):
+    spkdir, wav_name, args = item
+    # speaker 's5', 'p280', 'p315' are excluded,
+    speaker = spkdir.replace("\\", "/").split("/")[-1]
+    wav_path = os.path.join(args.in_dir, speaker, wav_name)
+    if os.path.exists(wav_path) and '.wav' in wav_path:
+        os.makedirs(os.path.join(args.out_dir2, speaker), exist_ok=True)
+        wav, sr = librosa.load(wav_path, sr=None)
+        wav, _ = librosa.effects.trim(wav, top_db=20)
+        peak = np.abs(wav).max()
+        if peak > 1.0:
+            wav = 0.98 * wav / peak
+        wav2 = librosa.resample(wav, orig_sr=sr, target_sr=args.sr2)
+        wav2 /= max(wav2.max(), -wav2.min())
+        save_name = wav_name
+        save_path2 = os.path.join(args.out_dir2, speaker, save_name)
+        wavfile.write(
+            save_path2,
+            args.sr2,
+            (wav2 * np.iinfo(np.int16).max).astype(np.int16)
+        )
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--sr2", type=int, default=44100, help="sampling rate")
+    parser.add_argument("--in_dir", type=str, default="./dataset_raw", help="path to source dir")
+    parser.add_argument("--out_dir2", type=str, default="./dataset/44k", help="path to target dir")
+    args = parser.parse_args()
+    processs = cpu_count()-2 if cpu_count() >4 else 1
+    pool = Pool(processes=processs)
+
+    for speaker in os.listdir(args.in_dir):
+        spk_dir = os.path.join(args.in_dir, speaker)
+        if os.path.isdir(spk_dir):
+            print(spk_dir)
+            for _ in tqdm(pool.imap_unordered(process, [(spk_dir, i, args) for i in os.listdir(spk_dir) if i.endswith("wav")])):
+                pass

setup.py

@@ -0,0 +1,143 @@
+import os
+import sys
+import re
+from pathlib import Path
+import winreg
+'''Old function
+def detect_python_path():
+    path_list = os.environ['Path'].split(';')
+    python_path = None
+    python_version = None
+    python_pattern = re.compile(r'python (3[.][0-9]+([.][0-9]+)?)?')
+
+    for path in path_list:
+        if 'python' in path.lower():
+            python_exec = Path(path) / 'python.exe'
+            if python_exec.exists():
+                version_string = os.popen(f'"{python_exec}" --version').read().strip()
+                match = python_pattern.search(version_string.lower())
+                if match:
+                    python_path = path
+                    python_version = match.group(1)
+                    break
+    print(version_string)
+    return python_path, python_version
+
+def modify_pyvenv_cfg(python_path, python_version):
+    pyvenv_path = Path('.\\venv\\pyvenv.cfg')
+
+    if not pyvenv_path.exists():
+        print("Error: pyvenv.cfg not found.")
+        sys.exit(1)
+
+    with pyvenv_path.open('r') as f:
+        content = f.readlines()
+
+    if len(content) != 1:
+        print("Venv already created.")
+        sys.exit(1)
+
+    with pyvenv_path.open('w') as f:
+        f.write(f"home = {python_path}\n")
+        f.writelines(content)
+        f.write(f"version = {python_version}\n")
+
+
+def create_venv(python_path, python_version):
+    pyvenv_path = Path('.\\venv\\pyvenv.cfg')
+    venv_path = Path('.\\venv')
+    venv_abs_path = os.path.abspath(venv_path)
+
+    if not pyvenv_path.exists():
+        print("Error: pyvenv.cfg not found.")
+        sys.exit(1)
+
+    with pyvenv_path.open('r') as f:
+        content = f.readlines()
+
+    home_line = None
+    version_line = None
+
+    for i, line in enumerate(content):
+        if line.startswith("home ="):
+            home_line = i
+        if line.startswith("version ="):
+            version_line = i
+
+    with pyvenv_path.open('w') as f:
+        if home_line is not None and version_line is not None:
+            for i, line in enumerate(content):
+                if i == home_line:
+                    f.write(f"home = {python_path}\n")
+                elif i == version_line:
+                    f.write(f"version = {python_version}\n")
+                else:
+                    f.write(line)
+        else:
+            f.write(f"home = {python_path}\n")
+            f.writelines(content)
+            f.write(f"version = {python_version}\n")
+    
+    with open(".\\venv\\Scripts\\activate", "r") as file:
+        content = file.readlines()
+
+    with open(".\\venv\\Scripts\\activate", "w") as file:
+        for line in content:
+            if line.startswith("VIRTUAL_ENV="):
+                line = f"VIRTUAL_ENV=\"{venv_abs_path}\"\n"
+            file.write(line)
+'''
+def check_ffmpeg_path():
+    path_list = os.environ['Path'].split(';')
+    ffmpeg_found = False
+
+    for path in path_list:
+        if 'ffmpeg' in path.lower() and 'bin' in path.lower():
+            ffmpeg_found = True
+            print("FFmpeg already installed, skipping...")
+            break
+
+    return ffmpeg_found
+
+def add_ffmpeg_path_to_user_variable():
+    ffmpeg_bin_path = Path('.\\ffmpeg\\bin')
+    if ffmpeg_bin_path.is_dir():
+        abs_path = str(ffmpeg_bin_path.resolve())
+        
+        try:
+            key = winreg.OpenKey(
+                winreg.HKEY_CURRENT_USER,
+                r"Environment",
+                0,
+                winreg.KEY_READ | winreg.KEY_WRITE
+            )
+            
+            try:
+                current_path, _ = winreg.QueryValueEx(key, "Path")
+                if abs_path not in current_path:
+                    new_path = f"{current_path};{abs_path}"
+                    winreg.SetValueEx(key, "Path", 0, winreg.REG_EXPAND_SZ, new_path)
+                    print(f"Added FFmpeg path to user variable 'Path': {abs_path}")
+                else:
+                    print("FFmpeg path already exists in the user variable 'Path'.")
+            finally:
+                winreg.CloseKey(key)
+        except WindowsError:
+            print("Error: Unable to modify user variable 'Path'.")
+            sys.exit(1)
+
+    else:
+        print("Error: ffmpeg\\bin folder not found in the current path.")
+        sys.exit(1)
+
+def main():
+    current_workdir_name = os.path.basename(os.getcwd())
+    if current_workdir_name != "so-vits-svc":
+        print("请将整合包文件夹名称修改为so-vits-svc,否则可能会导致运行出错")
+        sys.exit(1)
+    else:
+        if not check_ffmpeg_path():
+            add_ffmpeg_path_to_user_variable()
+            
+if __name__ == "__main__":
+    main()

train.py

@@ -0,0 +1,315 @@
+import logging
+import multiprocessing
+import time
+
+logging.getLogger('matplotlib').setLevel(logging.WARNING)
+logging.getLogger('numba').setLevel(logging.WARNING)
+
+import os
+import json
+import argparse
+import itertools
+import math
+import torch
+from torch import nn, optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from torch.utils.tensorboard import SummaryWriter
+import torch.multiprocessing as mp
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.cuda.amp import autocast, GradScaler
+
+import modules.commons as commons
+import utils
+from data_utils import TextAudioSpeakerLoader, TextAudioCollate
+from models import (
+    SynthesizerTrn,
+    MultiPeriodDiscriminator,
+)
+from modules.losses import (
+    kl_loss,
+    generator_loss, discriminator_loss, feature_loss
+)
+
+from modules.mel_processing import mel_spectrogram_torch, spec_to_mel_torch
+
+torch.backends.cudnn.benchmark = True
+global_step = 0
+start_time = time.time()
+
+# os.environ['TORCH_DISTRIBUTED_DEBUG'] = 'INFO'
+
+
+def main():
+    """Assume Single Node Multi GPUs Training Only"""
+    assert torch.cuda.is_available(), "CPU training is not allowed."
+    hps = utils.get_hparams()
+
+    n_gpus = torch.cuda.device_count()
+    os.environ['MASTER_ADDR'] = 'localhost'
+    os.environ['MASTER_PORT'] = hps.train.port
+
+    mp.spawn(run, nprocs=n_gpus, args=(n_gpus, hps,))
+
+
+def run(rank, n_gpus, hps):
+    global global_step
+    if rank == 0:
+        logger = utils.get_logger(hps.model_dir)
+        logger.info(hps)
+        utils.check_git_hash(hps.model_dir)
+        writer = SummaryWriter(log_dir=hps.model_dir)
+        writer_eval = SummaryWriter(log_dir=os.path.join(hps.model_dir, "eval"))
+
+    # for pytorch on win, backend use gloo    
+    dist.init_process_group(backend=  'gloo' if os.name == 'nt' else 'nccl', init_method='env://', world_size=n_gpus, rank=rank)
+    torch.manual_seed(hps.train.seed)
+    torch.cuda.set_device(rank)
+    collate_fn = TextAudioCollate()
+    all_in_mem = hps.train.all_in_mem   # If you have enough memory, turn on this option to avoid disk IO and speed up training.
+    train_dataset = TextAudioSpeakerLoader(hps.data.training_files, hps, all_in_mem=all_in_mem)
+    num_workers = 5 if multiprocessing.cpu_count() > 4 else multiprocessing.cpu_count()
+    if all_in_mem:
+        num_workers = 0
+    train_loader = DataLoader(train_dataset, num_workers=num_workers, shuffle=False, pin_memory=True,
+                              batch_size=hps.train.batch_size, collate_fn=collate_fn)
+    if rank == 0:
+        eval_dataset = TextAudioSpeakerLoader(hps.data.validation_files, hps, all_in_mem=all_in_mem)
+        eval_loader = DataLoader(eval_dataset, num_workers=1, shuffle=False,
+                                 batch_size=1, pin_memory=False,
+                                 drop_last=False, collate_fn=collate_fn)
+
+    net_g = SynthesizerTrn(
+        hps.data.filter_length // 2 + 1,
+        hps.train.segment_size // hps.data.hop_length,
+        **hps.model).cuda(rank)
+    net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).cuda(rank)
+    optim_g = torch.optim.AdamW(
+        net_g.parameters(),
+        hps.train.learning_rate,
+        betas=hps.train.betas,
+        eps=hps.train.eps)
+    optim_d = torch.optim.AdamW(
+        net_d.parameters(),
+        hps.train.learning_rate,
+        betas=hps.train.betas,
+        eps=hps.train.eps)
+    net_g = DDP(net_g, device_ids=[rank])  # , find_unused_parameters=True)
+    net_d = DDP(net_d, device_ids=[rank])
+
+    skip_optimizer = False
+    try:
+        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g,
+                                                   optim_g, skip_optimizer)
+        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d,
+                                                   optim_d, skip_optimizer)
+        epoch_str = max(epoch_str, 1)
+        global_step = (epoch_str - 1) * len(train_loader)
+    except:
+        print("load old checkpoint failed...")
+        epoch_str = 1
+        global_step = 0
+    if skip_optimizer:
+        epoch_str = 1
+        global_step = 0
+
+    scheduler_g = torch.optim.lr_scheduler.ExponentialLR(optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
+    scheduler_d = torch.optim.lr_scheduler.ExponentialLR(optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
+
+    scaler = GradScaler(enabled=hps.train.fp16_run)
+
+    for epoch in range(epoch_str, hps.train.epochs + 1):
+        if rank == 0:
+            train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d], scaler,
+                               [train_loader, eval_loader], logger, [writer, writer_eval])
+        else:
+            train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d], scaler,
+                               [train_loader, None], None, None)
+        scheduler_g.step()
+        scheduler_d.step()
+
+
+def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers):
+    net_g, net_d = nets
+    optim_g, optim_d = optims
+    scheduler_g, scheduler_d = schedulers
+    train_loader, eval_loader = loaders
+    if writers is not None:
+        writer, writer_eval = writers
+
+    # train_loader.batch_sampler.set_epoch(epoch)
+    global global_step
+
+    net_g.train()
+    net_d.train()
+    for batch_idx, items in enumerate(train_loader):
+        c, f0, spec, y, spk, lengths, uv = items
+        g = spk.cuda(rank, non_blocking=True)
+        spec, y = spec.cuda(rank, non_blocking=True), y.cuda(rank, non_blocking=True)
+        c = c.cuda(rank, non_blocking=True)
+        f0 = f0.cuda(rank, non_blocking=True)
+        uv = uv.cuda(rank, non_blocking=True)
+        lengths = lengths.cuda(rank, non_blocking=True)
+        mel = spec_to_mel_torch(
+            spec,
+            hps.data.filter_length,
+            hps.data.n_mel_channels,
+            hps.data.sampling_rate,
+            hps.data.mel_fmin,
+            hps.data.mel_fmax)
+
+        with autocast(enabled=hps.train.fp16_run):
+            y_hat, ids_slice, z_mask, \
+            (z, z_p, m_p, logs_p, m_q, logs_q), pred_lf0, norm_lf0, lf0 = net_g(c, f0, uv, spec, g=g, c_lengths=lengths,
+                                                                                spec_lengths=lengths)
+
+            y_mel = commons.slice_segments(mel, ids_slice, hps.train.segment_size // hps.data.hop_length)
+            y_hat_mel = mel_spectrogram_torch(
+                y_hat.squeeze(1),
+                hps.data.filter_length,
+                hps.data.n_mel_channels,
+                hps.data.sampling_rate,
+                hps.data.hop_length,
+                hps.data.win_length,
+                hps.data.mel_fmin,
+                hps.data.mel_fmax
+            )
+            y = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size)  # slice
+
+            # Discriminator
+            y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach())
+
+            with autocast(enabled=False):
+                loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g)
+                loss_disc_all = loss_disc
+
+        optim_d.zero_grad()
+        scaler.scale(loss_disc_all).backward()
+        scaler.unscale_(optim_d)
+        grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None)
+        scaler.step(optim_d)
+
+        with autocast(enabled=hps.train.fp16_run):
+            # Generator
+            y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y, y_hat)
+            with autocast(enabled=False):
+                loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel
+                loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl
+                loss_fm = feature_loss(fmap_r, fmap_g)
+                loss_gen, losses_gen = generator_loss(y_d_hat_g)
+                loss_lf0 = F.mse_loss(pred_lf0, lf0)
+                loss_gen_all = loss_gen + loss_fm + loss_mel + loss_kl + loss_lf0
+        optim_g.zero_grad()
+        scaler.scale(loss_gen_all).backward()
+        scaler.unscale_(optim_g)
+        grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None)
+        scaler.step(optim_g)
+        scaler.update()
+
+        if rank == 0:
+            if global_step % hps.train.log_interval == 0:
+                lr = optim_g.param_groups[0]['lr']
+                losses = [loss_disc, loss_gen, loss_fm, loss_mel, loss_kl]
+                logger.info('Train Epoch: {} [{:.0f}%]'.format(
+                    epoch,
+                    100. * batch_idx / len(train_loader)))
+                logger.info(f"Losses: {[x.item() for x in losses]}, step: {global_step}, lr: {lr}")
+
+                scalar_dict = {"loss/g/total": loss_gen_all, "loss/d/total": loss_disc_all, "learning_rate": lr,
+                               "grad_norm_d": grad_norm_d, "grad_norm_g": grad_norm_g}
+                scalar_dict.update({"loss/g/fm": loss_fm, "loss/g/mel": loss_mel, "loss/g/kl": loss_kl,
+                                    "loss/g/lf0": loss_lf0})
+
+                # scalar_dict.update({"loss/g/{}".format(i): v for i, v in enumerate(losses_gen)})
+                # scalar_dict.update({"loss/d_r/{}".format(i): v for i, v in enumerate(losses_disc_r)})
+                # scalar_dict.update({"loss/d_g/{}".format(i): v for i, v in enumerate(losses_disc_g)})
+                image_dict = {
+                    "slice/mel_org": utils.plot_spectrogram_to_numpy(y_mel[0].data.cpu().numpy()),
+                    "slice/mel_gen": utils.plot_spectrogram_to_numpy(y_hat_mel[0].data.cpu().numpy()),
+                    "all/mel": utils.plot_spectrogram_to_numpy(mel[0].data.cpu().numpy()),
+                    "all/lf0": utils.plot_data_to_numpy(lf0[0, 0, :].cpu().numpy(),
+                                                          pred_lf0[0, 0, :].detach().cpu().numpy()),
+                    "all/norm_lf0": utils.plot_data_to_numpy(lf0[0, 0, :].cpu().numpy(),
+                                                               norm_lf0[0, 0, :].detach().cpu().numpy())
+                }
+
+                utils.summarize(
+                    writer=writer,
+                    global_step=global_step,
+                    images=image_dict,
+                    scalars=scalar_dict
+                )
+
+            if global_step % hps.train.eval_interval == 0:
+                evaluate(hps, net_g, eval_loader, writer_eval)
+                utils.save_checkpoint(net_g, optim_g, hps.train.learning_rate, epoch,
+                                      os.path.join(hps.model_dir, "G_{}.pth".format(global_step)))
+                utils.save_checkpoint(net_d, optim_d, hps.train.learning_rate, epoch,
+                                      os.path.join(hps.model_dir, "D_{}.pth".format(global_step)))
+                keep_ckpts = getattr(hps.train, 'keep_ckpts', 0)
+                if keep_ckpts > 0:
+                    utils.clean_checkpoints(path_to_models=hps.model_dir, n_ckpts_to_keep=keep_ckpts, sort_by_time=True)
+
+        global_step += 1
+
+    if rank == 0:
+        global start_time
+        now = time.time()
+        durtaion = format(now - start_time, '.2f')
+        logger.info(f'====> Epoch: {epoch}, cost {durtaion} s')
+        start_time = now
+
+
+def evaluate(hps, generator, eval_loader, writer_eval):
+    generator.eval()
+    image_dict = {}
+    audio_dict = {}
+    with torch.no_grad():
+        for batch_idx, items in enumerate(eval_loader):
+            c, f0, spec, y, spk, _, uv = items
+            g = spk[:1].cuda(0)
+            spec, y = spec[:1].cuda(0), y[:1].cuda(0)
+            c = c[:1].cuda(0)
+            f0 = f0[:1].cuda(0)
+            uv= uv[:1].cuda(0)
+            mel = spec_to_mel_torch(
+                spec,
+                hps.data.filter_length,
+                hps.data.n_mel_channels,
+                hps.data.sampling_rate,
+                hps.data.mel_fmin,
+                hps.data.mel_fmax)
+            y_hat = generator.module.infer(c, f0, uv, g=g)
+
+            y_hat_mel = mel_spectrogram_torch(
+                y_hat.squeeze(1).float(),
+                hps.data.filter_length,
+                hps.data.n_mel_channels,
+                hps.data.sampling_rate,
+                hps.data.hop_length,
+                hps.data.win_length,
+                hps.data.mel_fmin,
+                hps.data.mel_fmax
+            )
+
+            audio_dict.update({
+                f"gen/audio_{batch_idx}": y_hat[0],
+                f"gt/audio_{batch_idx}": y[0]
+            })
+        image_dict.update({
+            f"gen/mel": utils.plot_spectrogram_to_numpy(y_hat_mel[0].cpu().numpy()),
+            "gt/mel": utils.plot_spectrogram_to_numpy(mel[0].cpu().numpy())
+        })
+    utils.summarize(
+        writer=writer_eval,
+        global_step=global_step,
+        images=image_dict,
+        audios=audio_dict,
+        audio_sampling_rate=hps.data.sampling_rate
+    )
+    generator.train()
+
+
+if __name__ == "__main__":
+    main()

utils.py

@@ -0,0 +1,533 @@
+import os
+import glob
+import re
+import sys
+import argparse
+import logging
+import json
+import subprocess
+import warnings
+import random
+import functools
+
+import librosa
+import numpy as np
+from scipy.io.wavfile import read
+import torch
+from torch.nn import functional as F
+from modules.commons import sequence_mask
+from hubert import hubert_model
+from modules.crepe import CrepePitchExtractor
+
+MATPLOTLIB_FLAG = False
+
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
+logger = logging
+
+f0_bin = 256
+f0_max = 1100.0
+f0_min = 50.0
+f0_mel_min = 1127 * np.log(1 + f0_min / 700)
+f0_mel_max = 1127 * np.log(1 + f0_max / 700)
+
+
+# def normalize_f0(f0, random_scale=True):
+#     f0_norm = f0.clone()  # create a copy of the input Tensor
+#     batch_size, _, frame_length = f0_norm.shape
+#     for i in range(batch_size):
+#         means = torch.mean(f0_norm[i, 0, :])
+#         if random_scale:
+#             factor = random.uniform(0.8, 1.2)
+#         else:
+#             factor = 1
+#         f0_norm[i, 0, :] = (f0_norm[i, 0, :] - means) * factor
+#     return f0_norm
+# def normalize_f0(f0, random_scale=True):
+#     means = torch.mean(f0[:, 0, :], dim=1, keepdim=True)
+#     if random_scale:
+#         factor = torch.Tensor(f0.shape[0],1).uniform_(0.8, 1.2).to(f0.device)
+#     else:
+#         factor = torch.ones(f0.shape[0], 1, 1).to(f0.device)
+#     f0_norm = (f0 - means.unsqueeze(-1)) * factor.unsqueeze(-1)
+#     return f0_norm
+
+def deprecated(func):
+    """This is a decorator which can be used to mark functions
+    as deprecated. It will result in a warning being emitted
+    when the function is used."""
+    @functools.wraps(func)
+    def new_func(*args, **kwargs):
+        warnings.simplefilter('always', DeprecationWarning)  # turn off filter
+        warnings.warn("Call to deprecated function {}.".format(func.__name__),
+                      category=DeprecationWarning,
+                      stacklevel=2)
+        warnings.simplefilter('default', DeprecationWarning)  # reset filter
+        return func(*args, **kwargs)
+    return new_func
+
+def normalize_f0(f0, x_mask, uv, random_scale=True):
+    # calculate means based on x_mask
+    uv_sum = torch.sum(uv, dim=1, keepdim=True)
+    uv_sum[uv_sum == 0] = 9999
+    means = torch.sum(f0[:, 0, :] * uv, dim=1, keepdim=True) / uv_sum
+
+    if random_scale:
+        factor = torch.Tensor(f0.shape[0], 1).uniform_(0.8, 1.2).to(f0.device)
+    else:
+        factor = torch.ones(f0.shape[0], 1).to(f0.device)
+    # normalize f0 based on means and factor
+    f0_norm = (f0 - means.unsqueeze(-1)) * factor.unsqueeze(-1)
+    if torch.isnan(f0_norm).any():
+        exit(0)
+    return f0_norm * x_mask
+
+def compute_f0_uv_torchcrepe(wav_numpy, p_len=None, sampling_rate=44100, hop_length=512,device=None):
+    x = wav_numpy
+    if p_len is None:
+        p_len = x.shape[0]//hop_length
+    else:
+        assert abs(p_len-x.shape[0]//hop_length) < 4, "pad length error"
+    
+    f0_min = 50
+    f0_max = 1100
+    F0Creper = CrepePitchExtractor(hop_length=hop_length,f0_min=f0_min,f0_max=f0_max,device=device)
+    f0,uv = F0Creper(x[None,:].float(),sampling_rate,pad_to=p_len)
+    return f0,uv
+
+def plot_data_to_numpy(x, y):
+    global MATPLOTLIB_FLAG
+    if not MATPLOTLIB_FLAG:
+        import matplotlib
+        matplotlib.use("Agg")
+        MATPLOTLIB_FLAG = True
+        mpl_logger = logging.getLogger('matplotlib')
+        mpl_logger.setLevel(logging.WARNING)
+    import matplotlib.pylab as plt
+    import numpy as np
+
+    fig, ax = plt.subplots(figsize=(10, 2))
+    plt.plot(x)
+    plt.plot(y)
+    plt.tight_layout()
+
+    fig.canvas.draw()
+    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
+    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+    plt.close()
+    return data
+
+
+
+def interpolate_f0(f0):
+    '''
+    对F0进行插值处理
+    '''
+
+    data = np.reshape(f0, (f0.size, 1))
+
+    vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
+    vuv_vector[data > 0.0] = 1.0
+    vuv_vector[data <= 0.0] = 0.0
+
+    ip_data = data
+
+    frame_number = data.size
+    last_value = 0.0
+    for i in range(frame_number):
+        if data[i] <= 0.0:
+            j = i + 1
+            for j in range(i + 1, frame_number):
+                if data[j] > 0.0:
+                    break
+            if j < frame_number - 1:
+                if last_value > 0.0:
+                    step = (data[j] - data[i - 1]) / float(j - i)
+                    for k in range(i, j):
+                        ip_data[k] = data[i - 1] + step * (k - i + 1)
+                else:
+                    for k in range(i, j):
+                        ip_data[k] = data[j]
+            else:
+                for k in range(i, frame_number):
+                    ip_data[k] = last_value
+        else:
+            ip_data[i] = data[i]
+            last_value = data[i]
+
+    return ip_data[:,0], vuv_vector[:,0]
+
+
+def compute_f0_parselmouth(wav_numpy, p_len=None, sampling_rate=44100, hop_length=512):
+    import parselmouth
+    x = wav_numpy
+    if p_len is None:
+        p_len = x.shape[0]//hop_length
+    else:
+        assert abs(p_len-x.shape[0]//hop_length) < 4, "pad length error"
+    time_step = hop_length / sampling_rate * 1000
+    f0_min = 50
+    f0_max = 1100
+    f0 = parselmouth.Sound(x, sampling_rate).to_pitch_ac(
+        time_step=time_step / 1000, voicing_threshold=0.6,
+        pitch_floor=f0_min, pitch_ceiling=f0_max).selected_array['frequency']
+
+    pad_size=(p_len - len(f0) + 1) // 2
+    if(pad_size>0 or p_len - len(f0) - pad_size>0):
+        f0 = np.pad(f0,[[pad_size,p_len - len(f0) - pad_size]], mode='constant')
+    return f0
+
+def resize_f0(x, target_len):
+    source = np.array(x)
+    source[source<0.001] = np.nan
+    target = np.interp(np.arange(0, len(source)*target_len, len(source))/ target_len, np.arange(0, len(source)), source)
+    res = np.nan_to_num(target)
+    return res
+
+def compute_f0_dio(wav_numpy, p_len=None, sampling_rate=44100, hop_length=512):
+    import pyworld
+    if p_len is None:
+        p_len = wav_numpy.shape[0]//hop_length
+    f0, t = pyworld.dio(
+        wav_numpy.astype(np.double),
+        fs=sampling_rate,
+        f0_ceil=800,
+        frame_period=1000 * hop_length / sampling_rate,
+    )
+    f0 = pyworld.stonemask(wav_numpy.astype(np.double), f0, t, sampling_rate)
+    for index, pitch in enumerate(f0):
+        f0[index] = round(pitch, 1)
+    return resize_f0(f0, p_len)
+
+def f0_to_coarse(f0):
+  is_torch = isinstance(f0, torch.Tensor)
+  f0_mel = 1127 * (1 + f0 / 700).log() if is_torch else 1127 * np.log(1 + f0 / 700)
+  f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * (f0_bin - 2) / (f0_mel_max - f0_mel_min) + 1
+
+  f0_mel[f0_mel <= 1] = 1
+  f0_mel[f0_mel > f0_bin - 1] = f0_bin - 1
+  f0_coarse = (f0_mel + 0.5).long() if is_torch else np.rint(f0_mel).astype(np.int)
+  assert f0_coarse.max() <= 255 and f0_coarse.min() >= 1, (f0_coarse.max(), f0_coarse.min())
+  return f0_coarse
+
+
+def get_hubert_model():
+  vec_path = "hubert/checkpoint_best_legacy_500.pt"
+  print("load model(s) from {}".format(vec_path))
+  from fairseq import checkpoint_utils
+  models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
+    [vec_path],
+    suffix="",
+  )
+  model = models[0]
+  model.eval()
+  return model
+
+def get_hubert_content(hmodel, wav_16k_tensor):
+  feats = wav_16k_tensor
+  if feats.dim() == 2:  # double channels
+    feats = feats.mean(-1)
+  assert feats.dim() == 1, feats.dim()
+  feats = feats.view(1, -1)
+  padding_mask = torch.BoolTensor(feats.shape).fill_(False)
+  inputs = {
+    "source": feats.to(wav_16k_tensor.device),
+    "padding_mask": padding_mask.to(wav_16k_tensor.device),
+    "output_layer": 9,  # layer 9
+  }
+  with torch.no_grad():
+    logits = hmodel.extract_features(**inputs)
+    feats = hmodel.final_proj(logits[0])
+  return feats.transpose(1, 2)
+
+
+def get_content(cmodel, y):
+    with torch.no_grad():
+        c = cmodel.extract_features(y.squeeze(1))[0]
+    c = c.transpose(1, 2)
+    return c
+
+
+
+def load_checkpoint(checkpoint_path, model, optimizer=None, skip_optimizer=False):
+    assert os.path.isfile(checkpoint_path)
+    checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
+    iteration = checkpoint_dict['iteration']
+    learning_rate = checkpoint_dict['learning_rate']
+    if optimizer is not None and not skip_optimizer and checkpoint_dict['optimizer'] is not None:
+        optimizer.load_state_dict(checkpoint_dict['optimizer'])
+    saved_state_dict = checkpoint_dict['model']
+    if hasattr(model, 'module'):
+        state_dict = model.module.state_dict()
+    else:
+        state_dict = model.state_dict()
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        try:
+            # assert "dec" in k or "disc" in k
+            # print("load", k)
+            new_state_dict[k] = saved_state_dict[k]
+            assert saved_state_dict[k].shape == v.shape, (saved_state_dict[k].shape, v.shape)
+        except:
+            print("error, %s is not in the checkpoint" % k)
+            logger.info("%s is not in the checkpoint" % k)
+            new_state_dict[k] = v
+    if hasattr(model, 'module'):
+        model.module.load_state_dict(new_state_dict)
+    else:
+        model.load_state_dict(new_state_dict)
+    print("load ")
+    logger.info("Loaded checkpoint '{}' (iteration {})".format(
+        checkpoint_path, iteration))
+    return model, optimizer, learning_rate, iteration
+
+
+def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path):
+  logger.info("Saving model and optimizer state at iteration {} to {}".format(
+    iteration, checkpoint_path))
+  if hasattr(model, 'module'):
+    state_dict = model.module.state_dict()
+  else:
+    state_dict = model.state_dict()
+  torch.save({'model': state_dict,
+              'iteration': iteration,
+              'optimizer': optimizer.state_dict(),
+              'learning_rate': learning_rate}, checkpoint_path)
+
+def clean_checkpoints(path_to_models='logs/44k/', n_ckpts_to_keep=2, sort_by_time=True):
+  """Freeing up space by deleting saved ckpts
+
+  Arguments:
+  path_to_models    --  Path to the model directory
+  n_ckpts_to_keep   --  Number of ckpts to keep, excluding G_0.pth and D_0.pth
+  sort_by_time      --  True -> chronologically delete ckpts
+                        False -> lexicographically delete ckpts
+  """
+  ckpts_files = [f for f in os.listdir(path_to_models) if os.path.isfile(os.path.join(path_to_models, f))]
+  name_key = (lambda _f: int(re.compile('._(\d+)\.pth').match(_f).group(1)))
+  time_key = (lambda _f: os.path.getmtime(os.path.join(path_to_models, _f)))
+  sort_key = time_key if sort_by_time else name_key
+  x_sorted = lambda _x: sorted([f for f in ckpts_files if f.startswith(_x) and not f.endswith('_0.pth')], key=sort_key)
+  to_del = [os.path.join(path_to_models, fn) for fn in
+            (x_sorted('G')[:-n_ckpts_to_keep] + x_sorted('D')[:-n_ckpts_to_keep])]
+  del_info = lambda fn: logger.info(f".. Free up space by deleting ckpt {fn}")
+  del_routine = lambda x: [os.remove(x), del_info(x)]
+  rs = [del_routine(fn) for fn in to_del]
+
+def summarize(writer, global_step, scalars={}, histograms={}, images={}, audios={}, audio_sampling_rate=22050):
+  for k, v in scalars.items():
+    writer.add_scalar(k, v, global_step)
+  for k, v in histograms.items():
+    writer.add_histogram(k, v, global_step)
+  for k, v in images.items():
+    writer.add_image(k, v, global_step, dataformats='HWC')
+  for k, v in audios.items():
+    writer.add_audio(k, v, global_step, audio_sampling_rate)
+
+
+def latest_checkpoint_path(dir_path, regex="G_*.pth"):
+  f_list = glob.glob(os.path.join(dir_path, regex))
+  f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
+  x = f_list[-1]
+  print(x)
+  return x
+
+
+def plot_spectrogram_to_numpy(spectrogram):
+  global MATPLOTLIB_FLAG
+  if not MATPLOTLIB_FLAG:
+    import matplotlib
+    matplotlib.use("Agg")
+    MATPLOTLIB_FLAG = True
+    mpl_logger = logging.getLogger('matplotlib')
+    mpl_logger.setLevel(logging.WARNING)
+  import matplotlib.pylab as plt
+  import numpy as np
+
+  fig, ax = plt.subplots(figsize=(10,2))
+  im = ax.imshow(spectrogram, aspect="auto", origin="lower",
+                  interpolation='none')
+  plt.colorbar(im, ax=ax)
+  plt.xlabel("Frames")
+  plt.ylabel("Channels")
+  plt.tight_layout()
+
+  fig.canvas.draw()
+  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
+  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+  plt.close()
+  return data
+
+
+def plot_alignment_to_numpy(alignment, info=None):
+  global MATPLOTLIB_FLAG
+  if not MATPLOTLIB_FLAG:
+    import matplotlib
+    matplotlib.use("Agg")
+    MATPLOTLIB_FLAG = True
+    mpl_logger = logging.getLogger('matplotlib')
+    mpl_logger.setLevel(logging.WARNING)
+  import matplotlib.pylab as plt
+  import numpy as np
+
+  fig, ax = plt.subplots(figsize=(6, 4))
+  im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
+                  interpolation='none')
+  fig.colorbar(im, ax=ax)
+  xlabel = 'Decoder timestep'
+  if info is not None:
+      xlabel += '\n\n' + info
+  plt.xlabel(xlabel)
+  plt.ylabel('Encoder timestep')
+  plt.tight_layout()
+
+  fig.canvas.draw()
+  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
+  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+  plt.close()
+  return data
+
+
+def load_wav_to_torch(full_path):
+  sampling_rate, data = read(full_path)
+  return torch.FloatTensor(data.astype(np.float32)), sampling_rate
+
+
+def load_filepaths_and_text(filename, split="|"):
+  with open(filename, encoding='utf-8') as f:
+    filepaths_and_text = [line.strip().split(split) for line in f]
+  return filepaths_and_text
+
+
+def get_hparams(init=True):
+  parser = argparse.ArgumentParser()
+  parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
+                      help='JSON file for configuration')
+  parser.add_argument('-m', '--model', type=str, required=True,
+                      help='Model name')
+
+  args = parser.parse_args()
+  model_dir = os.path.join("./logs", args.model)
+
+  if not os.path.exists(model_dir):
+    os.makedirs(model_dir)
+
+  config_path = args.config
+  config_save_path = os.path.join(model_dir, "config.json")
+  if init:
+    with open(config_path, "r") as f:
+      data = f.read()
+    with open(config_save_path, "w") as f:
+      f.write(data)
+  else:
+    with open(config_save_path, "r") as f:
+      data = f.read()
+  config = json.loads(data)
+
+  hparams = HParams(**config)
+  hparams.model_dir = model_dir
+  return hparams
+
+
+def get_hparams_from_dir(model_dir):
+  config_save_path = os.path.join(model_dir, "config.json")
+  with open(config_save_path, "r") as f:
+    data = f.read()
+  config = json.loads(data)
+
+  hparams =HParams(**config)
+  hparams.model_dir = model_dir
+  return hparams
+
+
+def get_hparams_from_file(config_path):
+  with open(config_path, "r") as f:
+    data = f.read()
+  config = json.loads(data)
+
+  hparams =HParams(**config)
+  return hparams
+
+
+def check_git_hash(model_dir):
+  source_dir = os.path.dirname(os.path.realpath(__file__))
+  if not os.path.exists(os.path.join(source_dir, ".git")):
+    logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
+      source_dir
+    ))
+    return
+
+  cur_hash = subprocess.getoutput("git rev-parse HEAD")
+
+  path = os.path.join(model_dir, "githash")
+  if os.path.exists(path):
+    saved_hash = open(path).read()
+    if saved_hash != cur_hash:
+      logger.warn("git hash values are different. {}(saved) != {}(current)".format(
+        saved_hash[:8], cur_hash[:8]))
+  else:
+    open(path, "w").write(cur_hash)
+
+
+def get_logger(model_dir, filename="train.log"):
+  global logger
+  logger = logging.getLogger(os.path.basename(model_dir))
+  logger.setLevel(logging.DEBUG)
+
+  formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
+  if not os.path.exists(model_dir):
+    os.makedirs(model_dir)
+  h = logging.FileHandler(os.path.join(model_dir, filename))
+  h.setLevel(logging.DEBUG)
+  h.setFormatter(formatter)
+  logger.addHandler(h)
+  return logger
+
+
+def repeat_expand_2d(content, target_len):
+    # content : [h, t]
+
+    src_len = content.shape[-1]
+    target = torch.zeros([content.shape[0], target_len], dtype=torch.float).to(content.device)
+    temp = torch.arange(src_len+1) * target_len / src_len
+    current_pos = 0
+    for i in range(target_len):
+        if i < temp[current_pos+1]:
+            target[:, i] = content[:, current_pos]
+        else:
+            current_pos += 1
+            target[:, i] = content[:, current_pos]
+
+    return target
+
+
+class HParams():
+  def __init__(self, **kwargs):
+    for k, v in kwargs.items():
+      if type(v) == dict:
+        v = HParams(**v)
+      self[k] = v
+
+  def keys(self):
+    return self.__dict__.keys()
+
+  def items(self):
+    return self.__dict__.items()
+
+  def values(self):
+    return self.__dict__.values()
+
+  def __len__(self):
+    return len(self.__dict__)
+
+  def __getitem__(self, key):
+    return getattr(self, key)
+
+  def __setitem__(self, key, value):
+    return setattr(self, key, value)
+
+  def __contains__(self, key):
+    return key in self.__dict__
+
+  def __repr__(self):
+    return self.__dict__.__repr__()
+

wav_upload.py

@@ -0,0 +1,23 @@
+from google.colab import files
+import shutil
+import os
+import argparse
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--type", type=str, required=True, help="type of file to upload")
+    args = parser.parse_args()
+    file_type = args.type
+
+    basepath = os.getcwd()
+    uploaded = files.upload() # 上传文件
+    assert(file_type in ['zip', 'audio'])
+    if file_type == "zip":
+        upload_path = "./upload/"
+        for filename in uploaded.keys():
+            #将上传的文件移动到指定的位置上
+            shutil.move(os.path.join(basepath, filename), os.path.join(upload_path, "userzip.zip"))
+    elif file_type == "audio":
+        upload_path = "./raw/"
+        for filename in uploaded.keys():
+            #将上传的文件移动到指定的位置上
+            shutil.move(os.path.join(basepath, filename), os.path.join(upload_path, filename))

webUI.py

@@ -0,0 +1,172 @@
+import io
+import os
+
+# os.system("wget -P cvec/ https://huggingface.co/spaces/innnky/nanami/resolve/main/checkpoint_best_legacy_500.pt")
+import gradio as gr
+import gradio.processing_utils as gr_pu
+import librosa
+import numpy as np
+import soundfile
+from inference.infer_tool import Svc
+import logging
+
+import subprocess
+import edge_tts
+import asyncio
+from scipy.io import wavfile
+import librosa
+import torch
+import time
+
+logging.getLogger('numba').setLevel(logging.WARNING)
+logging.getLogger('markdown_it').setLevel(logging.WARNING)
+logging.getLogger('urllib3').setLevel(logging.WARNING)
+logging.getLogger('matplotlib').setLevel(logging.WARNING)
+logging.getLogger('multipart').setLevel(logging.WARNING)
+
+model = None
+spk = None
+cuda = []
+if torch.cuda.is_available():
+    for i in range(torch.cuda.device_count()):
+        cuda.append("cuda:{}".format(i))
+
+def vc_fn(sid, input_audio, vc_transform, auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,F0_mean_pooling):
+    global model
+    try:
+        if input_audio is None:
+            return "You need to upload an audio", None
+        if model is None:
+            return "You need to upload an model", None
+        sampling_rate, audio = input_audio
+        # print(audio.shape,sampling_rate)
+        audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
+        if len(audio.shape) > 1:
+            audio = librosa.to_mono(audio.transpose(1, 0))
+        temp_path = "temp.wav"
+        soundfile.write(temp_path, audio, sampling_rate, format="wav")
+        _audio = model.slice_inference(temp_path, sid, vc_transform, slice_db, cluster_ratio, auto_f0, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,F0_mean_pooling)
+        model.clear_empty()
+        os.remove(temp_path)
+        #构建保存文件的路径，并保存到results文件夹内
+        timestamp = str(int(time.time()))
+        output_file = os.path.join("results", sid + "_" + timestamp + ".wav")
+        soundfile.write(output_file, _audio, model.target_sample, format="wav")
+        return "Success", (model.target_sample, _audio)
+    except Exception as e:
+        return "异常信息:"+str(e)+"\n请排障后重试",None
+    
+def tts_func(_text,_rate):
+    #使用edge-tts把文字转成音频
+    # voice = "zh-CN-XiaoyiNeural"#女性，较高音
+    # voice = "zh-CN-YunxiNeural"#男性
+    voice = "zh-CN-YunxiNeural"#男性
+    output_file = _text[0:10]+".wav"
+    # communicate = edge_tts.Communicate(_text, voice)
+    # await communicate.save(output_file)
+    if _rate>=0:
+        ratestr="+{:.0%}".format(_rate)
+    elif _rate<0:
+        ratestr="{:.0%}".format(_rate)#减号自带
+
+    p=subprocess.Popen(["edge-tts",
+                        "--text",_text,
+                        "--write-media",output_file,
+                        "--voice",voice,
+                        "--rate="+ratestr]
+                        ,shell=True,
+                        stdout=subprocess.PIPE,
+                        stdin=subprocess.PIPE)
+    p.wait() 
+    return output_file
+
+def vc_fn2(sid, input_audio, vc_transform, auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,text2tts,tts_rate,F0_mean_pooling):
+    #使用edge-tts把文字转成音频
+    output_file=tts_func(text2tts,tts_rate)
+
+    #调整采样率
+    sr2=44100
+    wav, sr = librosa.load(output_file)
+    wav2 = librosa.resample(wav, orig_sr=sr, target_sr=sr2)
+    save_path2= text2tts[0:10]+"_44k"+".wav"
+    wavfile.write(save_path2,sr2,
+                (wav2 * np.iinfo(np.int16).max).astype(np.int16)
+                )
+    
+    #读取音频
+    sample_rate, data=gr_pu.audio_from_file(save_path2)
+    vc_input=(sample_rate, data)
+
+    a,b=vc_fn(sid, vc_input, vc_transform,auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,F0_mean_pooling)
+    os.remove(output_file)
+    os.remove(save_path2)
+    return a,b
+
+app = gr.Blocks()
+with app:
+    with gr.Tabs():
+        with gr.TabItem("Sovits4.0"):
+            gr.Markdown(value="""
+                Sovits4.0 WebUI
+                """)
+            
+            gr.Markdown(value="""
+                <font size=3>下面是模型文件选择：</font>
+                """)
+            model_path = gr.File(label="模型文件")
+            gr.Markdown(value="""
+                <font size=3>下面是配置文件选择：</font>
+                """)
+            config_path = gr.File(label="配置文件")
+            gr.Markdown(value="""
+                <font size=3>下面是聚类模型文件选择，没有可以不填：</font>
+                """)
+            cluster_model_path = gr.File(label="聚类模型文件")
+            device = gr.Dropdown(label="推理设备，默认为自动选择cpu和gpu",choices=["Auto",*cuda,"cpu"],value="Auto")
+            gr.Markdown(value="""
+                <font size=3>全部上传完毕后(全部文件模块显示download),点击模型解析进行解析：</font>
+                """)
+            model_analysis_button = gr.Button(value="模型解析")
+            sid = gr.Dropdown(label="音色（说话人）")
+            sid_output = gr.Textbox(label="Output Message")
+
+            text2tts=gr.Textbox(label="在此输入要转译的文字。注意，使用该功能建议打开F0预测，不然会很怪")
+            tts_rate = gr.Number(label="tts语速", value=0)
+
+            vc_input3 = gr.Audio(label="上传音频")
+            vc_transform = gr.Number(label="变调（整数，可以正负，半音数量，升高八度就是12）", value=0)
+            cluster_ratio = gr.Number(label="聚类模型混合比例，0-1之间，默认为0不启用聚类，能提升音色相似度，但会导致咬字下降（如果使用建议0.5左右）", value=0)
+            auto_f0 = gr.Checkbox(label="自动f0预测，配合聚类模型f0预测效果更好,会导致变调功能失效（仅限转换语音，歌声不要勾选此项会究极跑调）", value=False)
+            F0_mean_pooling = gr.Checkbox(label="是否对F0使用均值滤波器(池化)，对部分哑音有改善。注意，启动该选项会导致推理速度下降，默认关闭", value=False)
+            slice_db = gr.Number(label="切片阈值", value=-40)
+            noise_scale = gr.Number(label="noise_scale 建议不要动，会影响音质，玄学参数", value=0.4)
+            cl_num = gr.Number(label="音频自动切片，0为不切片，单位为秒/s", value=0)
+            pad_seconds = gr.Number(label="推理音频pad秒数，由于未知原因开头结尾会有异响，pad一小段静音段后就不会出现", value=0.5)
+            lg_num = gr.Number(label="两端音频切片的交叉淡入长度，如果自动切片后出现人声不连贯可调整该数值，如果连贯建议采用默认值0，注意，该设置会影响推理速度，单位为秒/s", value=0)
+            lgr_num = gr.Number(label="自动音频切片后，需要舍弃每段切片的头尾。该参数设置交叉长度保留的比例，范围0-1,左开右闭", value=0.75,interactive=True)
+            vc_submit = gr.Button("音频直接转换", variant="primary")
+            vc_submit2 = gr.Button("文字转音频+转换", variant="primary")
+            vc_output1 = gr.Textbox(label="Output Message")
+            vc_output2 = gr.Audio(label="Output Audio")
+            def modelAnalysis(model_path,config_path,cluster_model_path,device):
+                global model
+                debug=False
+                if debug:
+                    model = Svc(model_path.name, config_path.name,device=device if device!="Auto" else None,cluster_model_path= cluster_model_path.name if cluster_model_path!=None else "")
+                    spks = list(model.spk2id.keys())
+                    device_name = torch.cuda.get_device_properties(model.dev).name if "cuda" in str(model.dev) else str(model.dev)
+                    return sid.update(choices = spks,value=spks[0]),"ok,模型被加载到了设备{}之上".format(device_name)
+                else:
+                    try:
+                        model = Svc(model_path.name, config_path.name,device=device if device!="Auto" else None,cluster_model_path= cluster_model_path.name if cluster_model_path!=None else "")
+                        spks = list(model.spk2id.keys())
+                        device_name = torch.cuda.get_device_properties(model.dev).name if "cuda" in str(model.dev) else str(model.dev)
+                        return sid.update(choices = spks,value=spks[0]),"ok,模型被加载到了设备{}之上".format(device_name)
+                    except Exception as e:
+                        return "","异常信息:"+str(e)+"\n请排障后重试"
+        vc_submit.click(vc_fn, [sid, vc_input3, vc_transform,auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,F0_mean_pooling], [vc_output1, vc_output2])
+        vc_submit2.click(vc_fn2, [sid, vc_input3, vc_transform,auto_f0,cluster_ratio, slice_db, noise_scale,pad_seconds,cl_num,lg_num,lgr_num,text2tts,tts_rate,F0_mean_pooling], [vc_output1, vc_output2])
+        model_analysis_button.click(modelAnalysis,[model_path,config_path,cluster_model_path,device],[sid,sid_output])
+    app.launch()
+
+

启动tensorboard.bat

@@ -0,0 +1,9 @@
+chcp 65001
+@echo off
+
+echo 正在启动Tensorboard...
+echo 如果看到输出了一条网址（大概率是localhost:6006）就可以访问该网址进入Tensorboard了
+
+.\workenv\python.exe -m tensorboard.main --logdir=logs\44k
+
+pause

启动webui.bat

@@ -0,0 +1,8 @@
+chcp 65001
+@echo off
+
+echo 初始化并启动WebUI……初次启动可能会花上较长时间
+.\workenv\python.exe setup.py
+.\workenv\python.exe app.py
+
+pause