From 563bf7af6d6c551ab7eb0942dd4c4cf60c0da0de Mon Sep 17 00:00:00 2001
From: tzshao <66196038+shaotz@users.noreply.github.com>
Date: Sat, 20 May 2023 18:46:18 +0800
Subject: [PATCH 01/16] Update of en_US.json, Proposal for i18n standard.
(#314)
* Update en_US.json
### Description:
A rough modification of en-US i18n file.
### Changes:
+ Many translation phrases have been replaced with rather native expressions.
+ Majority of translation phrases have been re-formatted for more efficient reading.
### Problems:
+ There's no standard for i18n. E.g, and my proposal:
+ All Input Prompts ends with colon(":").
+ All progress indication(e.g. "step1:processing data","step2a: ...") stays lowercase, may add CSI SGR escape sequences for highlighting.
+ List of Selections and their descriptions be written in key-value pairs.
+ No more plain-translations.
* Update en_US.json
1.Strings that refer to specific paths/locations have been quoted with '' pairs.
2.1 Typo fixed.
* Update en_US.json
1.Minor re-format.
---
i18n/en_US.json | 68 ++++++++++++++++++++++++-------------------------
1 file changed, 34 insertions(+), 34 deletions(-)
diff --git a/i18n/en_US.json b/i18n/en_US.json
index f14abc2..ad3171b 100644
--- a/i18n/en_US.json
+++ b/i18n/en_US.json
@@ -1,34 +1,34 @@
{
- "很遗憾您这没有能用的显卡来支持您训练": "Unfortunately, you don't have a GPU to help you train",
+ "很遗憾您这没有能用的显卡来支持您训练": "No supported GPU is found. Training may be ",
"是": "yes",
"step1:正在处理数据": "step 1: processing data",
- "step2a:无需提取音高": "step 2a: skipped extracting pitch",
+ "step2a:无需提取音高": "step 2a: skipping pitch extraction",
"step2b:正在提取特征": "step 2b: extracting features",
- "step3a:正在训练模型": "step 3a: training the model",
- "训练结束, 您可查看控制台训练日志或实验文件夹下的train.log": "Training completed, you can view the training logs in the console or the train.log within the experiement folder",
+ "step3a:正在训练模型": "step 3a: model traning started",
+ "训练结束, 您可查看控制台训练日志或实验文件夹下的train.log": "Training complete. Logs are available in the console, or the 'train.log' under experiment folder",
"全流程结束！": "all processes have been completed!",
"本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责.
如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录使用需遵守的协议-LICENSE.txt.": "This software is open source under the MIT license, the author does not have any control over the software, and those who use the software and spread the sounds exported by the software are solely responsible.
If you do not agree with this clause, you cannot use or quote any codes and files in the software package. See root directory Agreement-LICENSE.txt for details.",
"模型推理": "Model inference",
"推理音色": "Inferencing voice",
"刷新音色列表和索引路径": "Refresh voice list and index path",
"卸载音色省显存": "Unload voice to save GPU memory",
- "请选择说话人id": "Please select a speaker id",
+ "请选择说话人id": "Select Singer/Speaker ID",
"男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "It is recommended +12key for male to female conversion, and -12key for female to male conversion. If the sound range goes too far and the voice is distorted, you can also adjust it to the appropriate range by yourself. ",
"变调(整数, 半音数量, 升八度12降八度-12)": "transpose(integer, number of semitones, octave sharp 12 octave flat -12)",
"输入待处理音频文件路径(默认是正确格式示例)": "Enter the path of the audio file to be processed (the default is the correct format example)",
- "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "Select the algorithm for pitch extraction. Use 'pm' for fast conversions, or 'harvest' for better pitch accuracy, but with longer conversion times.",
- ">=3则使用对harvest音高识别的结果使用中值滤波，数值为滤波半径，使用可以削弱哑音": ">=3:using median filter for f0. The number is median filter radius.",
+ "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "Select the algorithm for pitch extraction. 'pm': fast conversions; 'harvest': better pitch accuracy, but conversion might be extremely slow.",
+ ">=3则使用对harvest音高识别的结果使用中值滤波，数值为滤波半径，使用可以削弱哑音": "If >=3: using median filter for f0. The number is median filter radius.",
"特征检索库文件路径,为空则使用下拉的选择结果": "Feature index file path. If null, use dropdown result.",
- "自动检测index路径,下拉式选择(dropdown)": "Auto detect index path in logs directory. Pick the matching file from the dropdown.",
+ "自动检测index路径,下拉式选择(dropdown)": "Path to the '.index' file in 'logs' directory is auto detected. Pick the matching file from the dropdown.",
"特征文件路径": "Feature file path",
"检索特征占比": "Search feature ratio",
"后处理重采样至最终采样率，0为不进行重采样": "Resample the audio in post to a different sample rate. Default: don't use post resample.",
"输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络": "Use volume envelope of input to mix or replace the volume envelope of output, the closer the rate is to 1, the more output envelope is used. Default 1 (don't mix input envelope)",
"F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0 curve file, optional, one pitch per line, instead of the default F0 and ups and downs",
"转换": "Convert",
- "输出信息": "Export message",
- "输出音频(右下角三个点,点了可以下载)": "Export audio (three dots in the lower right corner, click to download)",
- "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "For batch conversion, input the audio folder to be converted, or upload multiple audio files, and output the converted audio in the specified folder (opt by default). ",
+ "输出信息": "Output message",
+ "输出音频(右下角三个点,点了可以下载)": "Export audio (Click on the three dots in the bottom right corner to download)",
+ "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "For batch conversion, input the audio folder to be converted, or upload multiple audio files, and output the converted audio in the specified folder ('opt' by default). ",
"指定输出文件夹": "Specify output folder",
"输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "Enter the path of the audio folder to be processed (just go to the address bar of the file manager and copy it)",
"也可批量输入音频文件, 二选一, 优先读文件夹": "You can also input audio files in batches, choose one of the two, and read the folder first",
@@ -39,54 +39,54 @@
"指定输出人声文件夹": "Specify vocals output folder",
"指定输出乐器文件夹": "Specify instrumentals output folder",
"训练": "Train",
- "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "step1: Fill in the experimental configuration. The experimental data is placed under logs, and each experiment has a folder. You need to manually enter the experimental name path, which contains the experimental configuration, logs, and model files obtained from training. ",
+ "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "step1: Fill in the experimental configuration. The experimental data is placed under 'logs', and each experiment has a folder. You need to manually enter the experimental name path, which contains the experimental configuration, logs, and model files obtained from training. ",
"输入实验名": "Input experiment name",
"目标采样率": "Target sample rate",
"模型是否带音高指导(唱歌一定要, 语音可以不要)": "Does the model have pitch guidance (required for singing; optional for speech, but recommended)",
"版本(目前仅40k支持了v2)": "Model architecture version (v2 version only supports 40k sample rate for testing purposes)",
- "提取音高和处理数据使用的CPU进程数": "Number of CPU threads to use for pitch extraction and dataset processing",
- "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "step2a: Automatically traverse all files that can be decoded into audio in the training folder and perform slice normalization, and generate 2 wav folders in the experiment directory; only single-person training is supported for the time being. ",
+ "提取音高和处理数据使用的CPU进程数": "Threads of CPU to use, for pitch extraction and dataset processing",
+ "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "step2a: Automatically traverse all files that can be decoded into audio in the training folder and perform slice normalization. Generates 2 wav folders in the experiment directory; Only single-singer/speaker training is supported for the time being. ",
"输入训练文件夹路径": "Input training folder path",
"请指定说话人id": "Please specify speaker ID",
"处理数据": "Process data",
- "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "step2b: Use CPU to extract pitch (if the model has pitch), use GPU to extract features (select card number)",
- "以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2": "Enter the card numbers used separated by -, for example 0-1-2 use card 0 and card 1 and card 2",
- "显卡信息": "GPU information",
- "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "Select pitch extraction algorithm: Use 'pm' for fastest extraction but lower-quality speech, 'dio' for improved speech but slower extraction, and 'harvest' for the best quality but slowest extraction.",
+ "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "step2b: Use CPU to extract pitch (if the model has pitch), use GPU to extract features (must specify GPU)",
+ "以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2": "Enter GPU Index(es),separated by '-'. Example: 0-1-2 to select card 1, 2 and 3 ",
+ "显卡信息": "GPU Information",
+ "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "Select pitch extraction algorithm. 'pm': fastest extraction but lower-quality speech; 'dio': improved speech but slower extraction; 'harvest': best quality but slowest extraction.",
"特征提取": "Feature extraction",
"step3: 填写训练设置, 开始训练模型和索引": "step3: Fill in the training settings, start training the model and index",
- "保存频率save_every_epoch": "Save frequency (save_every_epoch)",
+ "保存频率save_every_epoch": "Saving frequency (save_every_epoch)",
"总训练轮数total_epoch": "Total training epochs (total_epoch)",
"每张显卡的batch_size": "batch_size for every GPU",
- "是否仅保存最新的ckpt文件以节省硬盘空间": "Whether to save only the latest ckpt file to save disk space",
+ "是否仅保存最新的ckpt文件以节省硬盘空间": "Save only the latest ckpt file to reduce disk usage",
"否": "no",
- "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "Whether to cache all training sets to video memory. Small data under 10 minutes can be cached to speed up training, and large data cache will blow up video memory and not increase the speed much",
- "是否在每次保存时间点将最终小模型保存至weights文件夹": "Save a small finished model to the weights dir for every 'save frequency' epoch",
+ "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "Cache all training sets to GPU Memory. Small data(~under 10 minutes) can be cached to speed up training, but large data caching will eats up the GPU Memory and may not increase the speed",
+ "是否在每次保存时间点将最终小模型保存至weights文件夹": "Save a small finished model to the 'weights' directory for every epoch matching the specified 'save frequency'",
"加载预训练底模G路径": "Load pre-trained base model G path.",
"加载预训练底模D路径": "Load pre-trained base model D path.",
"训练模型": "Train model.",
"训练特征索引": "Train feature index.",
"一键训练": "One-click training.",
- "ckpt处理": "ckpt processing.",
- "模型融合, 可用于测试音色融合": "Model Fusion, which can be used to test sound fusion",
+ "ckpt处理": "ckpt Processing.",
+ "模型融合, 可用于测试音色融合": "Model Fusion, which can be used to test timbre fusion",
"A模型路径": "A model path.",
"B模型路径": "B model path.",
- "A模型权重": "A model weight for model A.",
+ "A模型权重": "Weight(w) for model A.",
"模型是否带音高指导": "Whether the model has pitch guidance.",
"要置入的模型信息": "Model information to be placed.",
- "保存的模型名不带后缀": "Saved model name without extension.",
+ "保存的模型名不带后缀": "Saved modelname without extension.",
"模型版本型号": "model architecture version",
"融合": "Fusion.",
- "修改模型信息(仅支持weights文件夹下提取的小模型文件)": "Modify model information (only small model files extracted from the weights folder are supported)",
+ "修改模型信息(仅支持weights文件夹下提取的小模型文件)": "Modify model information (only small model files extracted from the 'weights' folder are supported)",
"模型路径": "Model path",
"要改的模型信息": "Model information to be modified",
- "保存的文件名, 默认空为和源文件同名": "The saved file name, the default is empty and the same name as the source file",
+ "保存的文件名, 默认空为和源文件同名": "Savefile Name. If empty, name is the same as the source file; Default: empty",
"修改": "Modify",
- "查看模型信息(仅支持weights文件夹下提取的小模型文件)": "View model information (only small model files extracted from the weights folder are supported)",
+ "查看模型信息(仅支持weights文件夹下提取的小模型文件)": "View model information (only small model files extracted from the 'weights' folder are supported)",
"查看": "View",
"模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况": "Model extraction (enter the path of the large file model under the logs folder), which is suitable for half of the training and does not want to train the model without automatically extracting and saving the small file model, or if you want to test the intermediate model",
- "保存名": "Save Name",
- "模型是否带音高指导,1是0否": "Whether the model has pitch guidance, 1 for yes, 0 for no",
+ "保存名": "Savefile Name",
+ "模型是否带音高指导,1是0否": "Whether the model has pitch guidance, 1: yes, 0: no",
"提取": "Extract",
"Onnx导出": "Export Onnx",
"RVC模型路径": "RVC Model Path",
@@ -95,7 +95,7 @@
"导出Onnx模型": "Export Onnx Model",
"常见问题解答": "FAQ (Frequently Asked Questions)",
"招募音高曲线前端编辑器": "Recruit front-end editors for pitch curves",
- "加开发群联系我xxxxx": "Add development group to contact me xxxxx",
+ "加开发群联系我xxxxx": "Want to join the development chat group? contact me xxxxx",
"点击查看交流、问题反馈群号": "Click to view the communication and problem feedback group number",
"xxxxx": "xxxxx",
"加载模型": "load model",
@@ -115,8 +115,8 @@
"额外推理时长": "extra inference time",
"输入降噪": "Input Noise Reduction",
"输出降噪": "Output Noise Reduction",
- "性能设置": "performance settings",
+ "性能设置": "Compute Performance settings",
"开始音频转换": "start audio conversion",
"停止音频转换": "stop audio conversion",
- "推理时间(ms):": "Infer Time(ms):"
+ "推理时间(ms):": "Inference Time(ms):"
}
From 3f17356c114742a6433443efdd7b3e08e726f5b0 Mon Sep 17 00:00:00 2001
From: Rilm2525 <61257810+Rilm2525@users.noreply.github.com>
Date: Sat, 20 May 2023 19:46:39 +0900
Subject: [PATCH 02/16] Japanese translation added and corrected. (#317)
* Update infer-web.py
* Update ja_JP.json
---
i18n/ja_JP.json | 18 +++++++++---------
infer-web.py | 2 +-
2 files changed, 10 insertions(+), 10 deletions(-)
diff --git a/i18n/ja_JP.json b/i18n/ja_JP.json
index e333da7..87fcca5 100644
--- a/i18n/ja_JP.json
+++ b/i18n/ja_JP.json
@@ -1,12 +1,12 @@
{
"很遗憾您这没有能用的显卡来支持您训练": "トレーニングに対応したGPUが動作しないのは残念です。",
- "是": "Yes",
+ "是": "はい",
"step1:正在处理数据": "step1:処理中のデータ",
"step2a:无需提取音高": "step2a:ピッチの抽出は不要",
"step2b:正在提取特征": "step2b:抽出される特徴量",
"step3a:正在训练模型": "step3a:トレーニング中のモデル",
"训练结束, 您可查看控制台训练日志或实验文件夹下的train.log": "トレーニング終了時に、トレーニングログやフォルダ内のtrain.logを確認することができます",
- "全流程结束！": "全流程结束！",
+ "全流程结束！": "全工程が完了！",
"本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责.
如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录使用需遵守的协议-LICENSE.txt.": "本ソフトウェアはMITライセンスに基づくオープンソースであり、作者は本ソフトウェアに対していかなる強制力も持ちません。本ソフトウェアの利用者および本ソフトウェアから派生した音源(成果物)を配布する者は、本ソフトウェアに対して自身で責任を負うものとします。
この条項に同意しない場合、パッケージ内のコードやファイルを使用や参照を禁じます。詳しくは使用需遵守的协议-LICENSE.txtをご覧ください.",
"模型推理": "モデル推論",
"推理音色": "音源推論",
@@ -49,17 +49,17 @@
"输入训练文件夹路径": "トレーニング用フォルダのパスを入力してください",
"请指定说话人id": "話者IDを指定してください",
"处理数据": "データ処理",
- "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "ステップ2b: CPUを使用して音高を抽出する(モデルに音高がある場合)、GPUを使用して特徴を抽出する(カード番号を選択する)",
- "以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2": "ハイフンで区切って使用するカード番号を入力します。例えば0-1-2はカード0、カード1、カード2を使用します",
- "显卡信息": "カード情報",
+ "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "ステップ2b: CPUを使用して音高を抽出する(モデルに音高がある場合)、GPUを使用して特徴を抽出する(GPUの番号を選択する)",
+ "以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2": "ハイフンで区切って使用するGPUの番号を入力します。例えば0-1-2はGPU0、GPU1、GPU2を使用します",
+ "显卡信息": "GPU情報",
"选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "音高抽出アルゴリズムの選択:歌声を入力する場合は、pmを使用して速度を上げることができます。CPUが低い場合はdioを使用して速度を上げることができます。harvestは品質が高く、精度が高いですが、遅いです。",
"特征提取": "特徴抽出",
"step3: 填写训练设置, 开始训练模型和索引": "ステップ3: トレーニング設定を入力して、モデルとインデックスのトレーニングを開始します",
"保存频率save_every_epoch": "エポックごとの保存頻度",
"总训练轮数total_epoch": "総トレーニング回数",
- "每张显卡的batch_size": "每张显卡的batch_size",
+ "每张显卡的batch_size": "GPUごとのbatch_size",
"是否仅保存最新的ckpt文件以节省硬盘空间": "ハードディスク容量を節約するため、最新のckptファイルのみを保存するかどうか",
- "否": "否",
+ "否": "いいえ",
"是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "すべてのトレーニングデータをメモリにキャッシュするかどうか。10分以下の小さなデータはキャッシュしてトレーニングを高速化できますが、大きなデータをキャッシュするとメモリが破裂し、あまり速度が上がりません。",
"是否在每次保存时间点将最终小模型保存至weights文件夹": "是否在每次保存时间点将最终小模型保存至weights文件夹",
"加载预训练底模G路径": "事前学習済みのGモデルのパスをロードしてください",
@@ -93,13 +93,13 @@
"Onnx输出路径": "Onnx出力パス",
"MoeVS模型": "MoeSS？",
"导出Onnx模型": "Onnxに変換",
- "常见问题解答": "常见问题解答",
+ "常见问题解答": "よくある質問",
"招募音高曲线前端编辑器": "音高曲線フロントエンドエディターを募集",
"加开发群联系我xxxxx": "開発グループに参加して私に連絡してくださいxxxxx",
"点击查看交流、问题反馈群号": "クリックして交流、問題フィードバックグループ番号を表示",
"xxxxx": "xxxxx",
"加载模型": "モデルをロード",
- "Hubert模型": "Hubert模型",
+ "Hubert模型": "Hubertモデル",
"选择.pth文件": ".pthファイルを選択",
"选择.index文件": ".indexファイルを選択",
"选择.npy文件": ".npyファイルを選択",
diff --git a/infer-web.py b/infer-web.py
index 01554b6..f4bbd4f 100644
--- a/infer-web.py
+++ b/infer-web.py
@@ -1770,7 +1770,7 @@ with gr.Blocks() as app:
with open("docs/faq.md", "r", encoding="utf8") as f:
info = f.read()
else:
- with open("docs/faq_en.md", "r") as f:
+ with open("docs/faq_en.md", "r", encoding="utf8") as f:
info = f.read()
gr.Markdown(value=info)
except:
From 50a121fc7425209e7b8fffe3f0c9df1aa25b4e5d Mon Sep 17 00:00:00 2001
From: tzshao <66196038+shaotz@users.noreply.github.com>
Date: Sat, 20 May 2023 20:14:23 +0800
Subject: [PATCH 03/16] Update of en_US.json and faq_en.md. Proposal for i18n
standard. (#318)
* Update en_US.json
1. Severe mistake fixed: certain translation is previously incomplete.
* Update faq_en.md
1. Modified 1 entry for context consistency with lately merged en_US translation
* Update en_US.json
1. Attached colons to all Input Prompts as proposed.
2. Minor changes to translation expressions.
* Update en_US.json
1. Removed trailing periods on button texts
---
docs/faq_en.md | 2 +-
i18n/en_US.json | 108 ++++++++++++++++++++++++------------------------
2 files changed, 55 insertions(+), 55 deletions(-)
diff --git a/docs/faq_en.md b/docs/faq_en.md
index ab7d6a3..0124387 100644
--- a/docs/faq_en.md
+++ b/docs/faq_en.md
@@ -87,7 +87,7 @@ Save via model extraction at the bottom of the ckpt processing tab.
## Q14:File/memory error(when training)?
Too many processes and your memory is not enough. You may fix it by:
-1、decrease "Number of CPU threads".
+1、decrease the input in field "Threads of CPU".
2、pre-cut trainset to shorter audio files.
diff --git a/i18n/en_US.json b/i18n/en_US.json
index ad3171b..c9fb5cc 100644
--- a/i18n/en_US.json
+++ b/i18n/en_US.json
@@ -1,5 +1,5 @@
{
- "很遗憾您这没有能用的显卡来支持您训练": "No supported GPU is found. Training may be ",
+ "很遗憾您这没有能用的显卡来支持您训练": "No supported GPU is found. Training may be slow or unavailable.",
"是": "yes",
"step1:正在处理数据": "step 1: processing data",
"step2a:无需提取音高": "step 2a: skipping pitch extraction",
@@ -8,89 +8,89 @@
"训练结束, 您可查看控制台训练日志或实验文件夹下的train.log": "Training complete. Logs are available in the console, or the 'train.log' under experiment folder",
"全流程结束！": "all processes have been completed!",
"本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责.
如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录使用需遵守的协议-LICENSE.txt.": "This software is open source under the MIT license, the author does not have any control over the software, and those who use the software and spread the sounds exported by the software are solely responsible.
If you do not agree with this clause, you cannot use or quote any codes and files in the software package. See root directory Agreement-LICENSE.txt for details.",
- "模型推理": "Model inference",
- "推理音色": "Inferencing voice",
+ "模型推理": "Model Inference",
+ "推理音色": "Inferencing voice:",
"刷新音色列表和索引路径": "Refresh voice list and index path",
- "卸载音色省显存": "Unload voice to save GPU memory",
- "请选择说话人id": "Select Singer/Speaker ID",
+ "卸载音色省显存": "Unload voice to save GPU memory:",
+ "请选择说话人id": "Select Singer/Speaker ID:",
"男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "It is recommended +12key for male to female conversion, and -12key for female to male conversion. If the sound range goes too far and the voice is distorted, you can also adjust it to the appropriate range by yourself. ",
- "变调(整数, 半音数量, 升八度12降八度-12)": "transpose(integer, number of semitones, octave sharp 12 octave flat -12)",
- "输入待处理音频文件路径(默认是正确格式示例)": "Enter the path of the audio file to be processed (the default is the correct format example)",
- "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "Select the algorithm for pitch extraction. 'pm': fast conversions; 'harvest': better pitch accuracy, but conversion might be extremely slow.",
+ "变调(整数, 半音数量, 升八度12降八度-12)": "transpose(Input must be integer, represents number of semitones. Example: octave sharp: 12;octave flat: -12):",
+ "输入待处理音频文件路径(默认是正确格式示例)": "Enter the path of the audio file to be processed (the default is example of the correct format(Windows)):",
+ "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "Select the algorithm for pitch extraction.('pm': fast conversions; 'harvest': better pitch accuracy, but conversion might be extremely slow):",
">=3则使用对harvest音高识别的结果使用中值滤波，数值为滤波半径，使用可以削弱哑音": "If >=3: using median filter for f0. The number is median filter radius.",
- "特征检索库文件路径,为空则使用下拉的选择结果": "Feature index file path. If null, use dropdown result.",
- "自动检测index路径,下拉式选择(dropdown)": "Path to the '.index' file in 'logs' directory is auto detected. Pick the matching file from the dropdown.",
- "特征文件路径": "Feature file path",
- "检索特征占比": "Search feature ratio",
- "后处理重采样至最终采样率，0为不进行重采样": "Resample the audio in post to a different sample rate. Default: don't use post resample.",
- "输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络": "Use volume envelope of input to mix or replace the volume envelope of output, the closer the rate is to 1, the more output envelope is used. Default 1 (don't mix input envelope)",
- "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0 curve file, optional, one pitch per line, instead of the default F0 and ups and downs",
+ "特征检索库文件路径,为空则使用下拉的选择结果": "Path to Feature index file(If null, use dropdown result):",
+ "自动检测index路径,下拉式选择(dropdown)": "Path to the '.index' file in 'logs' directory is auto detected. Pick the matching file from the dropdown:",
+ "特征文件路径": "Path to Feature file:",
+ "检索特征占比": "Search feature ratio:",
+ "后处理重采样至最终采样率，0为不进行重采样": "Resample the audio in post-processing to a different sample rate.(Default(0): No post-resampling):",
+ "输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络": "Use volume envelope of input to mix or replace the volume envelope of output, the closer the rate is to 1, the more output envelope is used.(Default(1): don't mix input envelope):",
+ "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0 curve file(optional),one pitch per line. Overrides the default F0 and ups and downs :",
"转换": "Convert",
"输出信息": "Output message",
"输出音频(右下角三个点,点了可以下载)": "Export audio (Click on the three dots in the bottom right corner to download)",
"批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "For batch conversion, input the audio folder to be converted, or upload multiple audio files, and output the converted audio in the specified folder ('opt' by default). ",
- "指定输出文件夹": "Specify output folder",
+ "指定输出文件夹": "Path to output folder:",
"输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "Enter the path of the audio folder to be processed (just go to the address bar of the file manager and copy it)",
"也可批量输入音频文件, 二选一, 优先读文件夹": "You can also input audio files in batches, choose one of the two, and read the folder first",
- "伴奏人声分离": "Accompaniment and vocal separation",
- "人声伴奏分离批量处理, 使用UVR5模型.
不带和声用HP2, 带和声且提取的人声不需要和声用HP5
合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "Batch processing of vocal accompaniment separation, using UVR5 model.
Without harmony, use HP2, with harmony and extracted vocals do not need harmony, use HP5
Example of qualified folder path format: E:\\ codes\\py39\\vits_vc_gpu\\Egret Shuanghua test sample (just go to the address bar of the file manager and copy it)",
- "输入待处理音频文件夹路径": "Input audio folder path",
+ "伴奏人声分离": "Seperation of Accompaniment and Vocal",
+ "人声伴奏分离批量处理, 使用UVR5模型.
不带和声用HP2, 带和声且提取的人声不需要和声用HP5
合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "Batch processing of vocal accompaniment separation using UVR5 Model.
If input is without harmony, use HP2; If with harmony and the extracted vocals do not need harmony, use HP5
Example of legal folder path format: E:\\ codes\\py39\\vits_vc_gpu\\Egret Shuanghua test sample (just go to the address bar of the file manager and copy it)",
+ "输入待处理音频文件夹路径": "Path to Input audio folder:",
"模型": "Model",
- "指定输出人声文件夹": "Specify vocals output folder",
- "指定输出乐器文件夹": "Specify instrumentals output folder",
+ "指定输出人声文件夹": "Path to vocals output folder:",
+ "指定输出乐器文件夹": "Path to instrumentals output folder:",
"训练": "Train",
"step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "step1: Fill in the experimental configuration. The experimental data is placed under 'logs', and each experiment has a folder. You need to manually enter the experimental name path, which contains the experimental configuration, logs, and model files obtained from training. ",
- "输入实验名": "Input experiment name",
- "目标采样率": "Target sample rate",
- "模型是否带音高指导(唱歌一定要, 语音可以不要)": "Does the model have pitch guidance (required for singing; optional for speech, but recommended)",
- "版本(目前仅40k支持了v2)": "Model architecture version (v2 version only supports 40k sample rate for testing purposes)",
- "提取音高和处理数据使用的CPU进程数": "Threads of CPU to use, for pitch extraction and dataset processing",
+ "输入实验名": "Experiment name:",
+ "目标采样率": "Target sample rate:",
+ "模型是否带音高指导(唱歌一定要, 语音可以不要)": "If the model have pitch guidance (Required for singing as Input; Optional for speech as Input, but recommended):",
+ "版本(目前仅40k支持了v2)": "Model architecture version (v2 version only supports 40k sample rate for testing purposes):",
+ "提取音高和处理数据使用的CPU进程数": "Threads of CPU, for pitch extraction and dataset processing:",
"step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "step2a: Automatically traverse all files that can be decoded into audio in the training folder and perform slice normalization. Generates 2 wav folders in the experiment directory; Only single-singer/speaker training is supported for the time being. ",
- "输入训练文件夹路径": "Input training folder path",
- "请指定说话人id": "Please specify speaker ID",
+ "输入训练文件夹路径": "Path to training folder:",
+ "请指定说话人id": "Specify Singer/Speaker ID:",
"处理数据": "Process data",
"step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "step2b: Use CPU to extract pitch (if the model has pitch), use GPU to extract features (must specify GPU)",
- "以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2": "Enter GPU Index(es),separated by '-'. Example: 0-1-2 to select card 1, 2 and 3 ",
+ "以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2": "Enter GPU Index(es),separated by '-'.(Example: 0-1-2 to select card 1, 2 and 3):",
"显卡信息": "GPU Information",
- "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "Select pitch extraction algorithm. 'pm': fastest extraction but lower-quality speech; 'dio': improved speech but slower extraction; 'harvest': best quality but slowest extraction.",
+ "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "Select pitch extraction algorithm.('pm': fastest extraction but lower-quality speech; 'dio': improved speech but slower extraction; 'harvest': best quality but slowest extraction):",
"特征提取": "Feature extraction",
"step3: 填写训练设置, 开始训练模型和索引": "step3: Fill in the training settings, start training the model and index",
- "保存频率save_every_epoch": "Saving frequency (save_every_epoch)",
- "总训练轮数total_epoch": "Total training epochs (total_epoch)",
- "每张显卡的batch_size": "batch_size for every GPU",
- "是否仅保存最新的ckpt文件以节省硬盘空间": "Save only the latest ckpt file to reduce disk usage",
+ "保存频率save_every_epoch": "Saving frequency (save_every_epoch):",
+ "总训练轮数total_epoch": "Total training epochs (total_epoch):",
+ "每张显卡的batch_size": "batch_size for every GPU:",
+ "是否仅保存最新的ckpt文件以节省硬盘空间": "Save only the latest ckpt file to reduce disk usage:",
"否": "no",
- "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "Cache all training sets to GPU Memory. Small data(~under 10 minutes) can be cached to speed up training, but large data caching will eats up the GPU Memory and may not increase the speed",
- "是否在每次保存时间点将最终小模型保存至weights文件夹": "Save a small finished model to the 'weights' directory for every epoch matching the specified 'save frequency'",
+ "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "Cache all training sets to GPU Memory. Small data(~under 10 minutes) can be cached to speed up training, but large data caching will eats up the GPU Memory and may not increase the speed :",
+ "是否在每次保存时间点将最终小模型保存至weights文件夹": "Save a small finished model to the 'weights' directory for every epoch matching the specified 'save frequency' :",
"加载预训练底模G路径": "Load pre-trained base model G path.",
"加载预训练底模D路径": "Load pre-trained base model D path.",
"训练模型": "Train model.",
- "训练特征索引": "Train feature index.",
- "一键训练": "One-click training.",
- "ckpt处理": "ckpt Processing.",
+ "训练特征索引": "Train feature index",
+ "一键训练": "One-click training",
+ "ckpt处理": "ckpt Processing",
"模型融合, 可用于测试音色融合": "Model Fusion, which can be used to test timbre fusion",
- "A模型路径": "A model path.",
- "B模型路径": "B model path.",
- "A模型权重": "Weight(w) for model A.",
- "模型是否带音高指导": "Whether the model has pitch guidance.",
- "要置入的模型信息": "Model information to be placed.",
- "保存的模型名不带后缀": "Saved modelname without extension.",
- "模型版本型号": "model architecture version",
- "融合": "Fusion.",
+ "A模型路径": "Path to Model A:",
+ "B模型路径": "Path to Model B:",
+ "A模型权重": "Weight(w) for model A:",
+ "模型是否带音高指导": "Whether the model has pitch guidance:",
+ "要置入的模型信息": "Model information to be placed:",
+ "保存的模型名不带后缀": "Saved modelname(without extension):",
+ "模型版本型号": "Model architecture version:",
+ "融合": "Fusion",
"修改模型信息(仅支持weights文件夹下提取的小模型文件)": "Modify model information (only small model files extracted from the 'weights' folder are supported)",
- "模型路径": "Model path",
- "要改的模型信息": "Model information to be modified",
- "保存的文件名, 默认空为和源文件同名": "Savefile Name. If empty, name is the same as the source file; Default: empty",
+ "模型路径": "Path to Model:",
+ "要改的模型信息": "Model information to be modified:",
+ "保存的文件名, 默认空为和源文件同名": "Savefile Name. Default(empty): Name is the same as the source file :",
"修改": "Modify",
"查看模型信息(仅支持weights文件夹下提取的小模型文件)": "View model information (only small model files extracted from the 'weights' folder are supported)",
"查看": "View",
"模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况": "Model extraction (enter the path of the large file model under the logs folder), which is suitable for half of the training and does not want to train the model without automatically extracting and saving the small file model, or if you want to test the intermediate model",
- "保存名": "Savefile Name",
- "模型是否带音高指导,1是0否": "Whether the model has pitch guidance, 1: yes, 0: no",
+ "保存名": "Savefile Name:",
+ "模型是否带音高指导,1是0否": "Whether the model has pitch guidance(1: yes, 0: no):",
"提取": "Extract",
"Onnx导出": "Export Onnx",
- "RVC模型路径": "RVC Model Path",
- "Onnx输出路径": "Onnx Export Path",
+ "RVC模型路径": "RVC Model Path:",
+ "Onnx输出路径": "Onnx Export Path:",
"MoeVS模型": "MoeVS Model",
"导出Onnx模型": "Export Onnx Model",
"常见问题解答": "FAQ (Frequently Asked Questions)",
From 19cc9062b02aff583a252cdb1eb700380d5b9cfc Mon Sep 17 00:00:00 2001
From: RVC-Boss <129054828+RVC-Boss@users.noreply.github.com>
Date: Sun, 21 May 2023 03:10:07 +0000
Subject: [PATCH 04/16] Update i18n.py
---
i18n.py | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/i18n.py b/i18n.py
index 1d7fe71..9deba42 100644
--- a/i18n.py
+++ b/i18n.py
@@ -18,8 +18,11 @@ class I18nAuto:
if not os.path.exists(f"./i18n/{language}.json"):
language = "en_US"
self.language = language
- print("Use Language:", language)
+ #print("Use Language:", language)
self.language_map = load_language_list(language)
def __call__(self, key):
return self.language_map.get(key, key)
+
+ def print(self):
+ print("Use Language:", self.language)
From 28948f8961e7530974aef3480f9d7f98ae11244c Mon Sep 17 00:00:00 2001
From: RVC-Boss <129054828+RVC-Boss@users.noreply.github.com>
Date: Sun, 21 May 2023 03:10:20 +0000
Subject: [PATCH 05/16] Update infer-web.py
---
infer-web.py | 3585 +++++++++++++++++++++++++-------------------------
1 file changed, 1793 insertions(+), 1792 deletions(-)
diff --git a/infer-web.py b/infer-web.py
index f4bbd4f..6a238da 100644
--- a/infer-web.py
+++ b/infer-web.py
@@ -1,1792 +1,1793 @@
-import torch, os, traceback, sys, warnings, shutil, numpy as np
-
-os.environ["no_proxy"] = "localhost, 127.0.0.1, ::1"
-import threading
-from time import sleep
-from subprocess import Popen
-import faiss
-from random import shuffle
-
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-tmp = os.path.join(now_dir, "TEMP")
-shutil.rmtree(tmp, ignore_errors=True)
-shutil.rmtree("%s/runtime/Lib/site-packages/infer_pack" % (now_dir), ignore_errors=True)
-shutil.rmtree("%s/runtime/Lib/site-packages/uvr5_pack" % (now_dir), ignore_errors=True)
-os.makedirs(tmp, exist_ok=True)
-os.makedirs(os.path.join(now_dir, "logs"), exist_ok=True)
-os.makedirs(os.path.join(now_dir, "weights"), exist_ok=True)
-os.environ["TEMP"] = tmp
-warnings.filterwarnings("ignore")
-torch.manual_seed(114514)
-from i18n import I18nAuto
-import ffmpeg
-
-i18n = I18nAuto()
-# 判断是否有能用来训练和加速推理的N卡
-ngpu = torch.cuda.device_count()
-gpu_infos = []
-mem = []
-if (not torch.cuda.is_available()) 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 (
- "10" in gpu_name
- or "16" in gpu_name
- or "20" in gpu_name
- or "30" in gpu_name
- or "40" in gpu_name
- or "A2" in gpu_name.upper()
- or "A3" in gpu_name.upper()
- or "A4" in gpu_name.upper()
- or "P4" in gpu_name.upper()
- 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.upper()
- or "T4" in gpu_name.upper()
- or "TITAN" in gpu_name.upper()
- ): # A10#A100#V100#A40#P40#M40#K80#A4500
- if_gpu_ok = True # 至少有一张能用的N卡
- gpu_infos.append("%s\t%s" % (i, gpu_name))
- mem.append(
- int(
- torch.cuda.get_device_properties(i).total_memory
- / 1024
- / 1024
- / 1024
- + 0.4
- )
- )
-if if_gpu_ok == True and len(gpu_infos) > 0:
- gpu_info = "\n".join(gpu_infos)
- default_batch_size = min(mem) // 2
-else:
- gpu_info = i18n("很遗憾您这没有能用的显卡来支持您训练")
- default_batch_size = 1
-gpus = "-".join([i[0] for i in gpu_infos])
-from infer_pack.models import (
- SynthesizerTrnMs256NSFsid,
- SynthesizerTrnMs256NSFsid_nono,
- SynthesizerTrnMs768NSFsid,
- SynthesizerTrnMs768NSFsid_nono,
-)
-from scipy.io import wavfile
-from fairseq import checkpoint_utils
-import gradio as gr
-import logging
-from vc_infer_pipeline import VC
-from config import Config
-from infer_uvr5 import _audio_pre_
-from my_utils import load_audio
-from train.process_ckpt import show_info, change_info, merge, extract_small_model
-
-config = Config()
-# from trainset_preprocess_pipeline import PreProcess
-logging.getLogger("numba").setLevel(logging.WARNING)
-
-
-class ToolButton(gr.Button, gr.components.FormComponent):
- """Small button with single emoji as text, fits inside gradio forms"""
-
- def __init__(self, **kwargs):
- super().__init__(variant="tool", **kwargs)
-
- def get_block_name(self):
- return "button"
-
-
-hubert_model = None
-
-
-def load_hubert():
- global hubert_model
- models, _, _ = checkpoint_utils.load_model_ensemble_and_task(
- ["hubert_base.pt"],
- suffix="",
- )
- hubert_model = models[0]
- hubert_model = hubert_model.to(config.device)
- if config.is_half:
- hubert_model = hubert_model.half()
- else:
- hubert_model = hubert_model.float()
- hubert_model.eval()
-
-
-weight_root = "weights"
-weight_uvr5_root = "uvr5_weights"
-index_root = "logs"
-names = []
-for name in os.listdir(weight_root):
- if name.endswith(".pth"):
- names.append(name)
-index_paths = []
-for root, dirs, files in os.walk(index_root, topdown=False):
- for name in files:
- if name.endswith(".index") and "trained" not in name:
- index_paths.append("%s/%s" % (root, name))
-uvr5_names = []
-for name in os.listdir(weight_uvr5_root):
- if name.endswith(".pth"):
- uvr5_names.append(name.replace(".pth", ""))
-
-
-def vc_single(
- sid,
- input_audio_path,
- f0_up_key,
- f0_file,
- f0_method,
- file_index,
- file_index2,
- # file_big_npy,
- index_rate,
- filter_radius,
- resample_sr,
- rms_mix_rate,
-): # spk_item, input_audio0, vc_transform0,f0_file,f0method0
- global tgt_sr, net_g, vc, hubert_model, version
- if input_audio_path is None:
- return "You need to upload an audio", None
- f0_up_key = int(f0_up_key)
- try:
- audio = load_audio(input_audio_path, 16000)
- audio_max = np.abs(audio).max() / 0.95
- if audio_max > 1:
- audio /= audio_max
- times = [0, 0, 0]
- if hubert_model == None:
- load_hubert()
- if_f0 = cpt.get("f0", 1)
- file_index = (
- (
- file_index.strip(" ")
- .strip('"')
- .strip("\n")
- .strip('"')
- .strip(" ")
- .replace("trained", "added")
- )
- if file_index != ""
- else file_index2
- ) # 防止小白写错，自动帮他替换掉
- # file_big_npy = (
- # file_big_npy.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
- # )
- audio_opt = vc.pipeline(
- hubert_model,
- net_g,
- sid,
- audio,
- input_audio_path,
- times,
- f0_up_key,
- f0_method,
- file_index,
- # file_big_npy,
- index_rate,
- if_f0,
- filter_radius,
- tgt_sr,
- resample_sr,
- rms_mix_rate,
- version,
- f0_file=f0_file,
- )
- if resample_sr >= 16000 and tgt_sr != resample_sr:
- tgt_sr = resample_sr
- index_info = (
- "Using index:%s." % file_index
- if os.path.exists(file_index)
- else "Index not used."
- )
- return "Success.\n %s\nTime:\n npy:%ss, f0:%ss, infer:%ss" % (
- index_info,
- times[0],
- times[1],
- times[2],
- ), (tgt_sr, audio_opt)
- except:
- info = traceback.format_exc()
- print(info)
- return info, (None, None)
-
-
-def vc_multi(
- sid,
- dir_path,
- opt_root,
- paths,
- f0_up_key,
- f0_method,
- file_index,
- file_index2,
- # file_big_npy,
- index_rate,
- filter_radius,
- resample_sr,
- rms_mix_rate,
-):
- try:
- dir_path = (
- dir_path.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
- ) # 防止小白拷路径头尾带了空格和"和回车
- opt_root = opt_root.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
- os.makedirs(opt_root, exist_ok=True)
- try:
- if dir_path != "":
- paths = [os.path.join(dir_path, name) for name in os.listdir(dir_path)]
- else:
- paths = [path.name for path in paths]
- except:
- traceback.print_exc()
- paths = [path.name for path in paths]
- infos = []
- for path in paths:
- info, opt = vc_single(
- sid,
- path,
- f0_up_key,
- None,
- f0_method,
- file_index,
- file_index2,
- # file_big_npy,
- index_rate,
- filter_radius,
- resample_sr,
- rms_mix_rate,
- )
- if "Success" in info:
- try:
- tgt_sr, audio_opt = opt
- wavfile.write(
- "%s/%s" % (opt_root, os.path.basename(path)), tgt_sr, audio_opt
- )
- except:
- info += traceback.format_exc()
- infos.append("%s->%s" % (os.path.basename(path), info))
- yield "\n".join(infos)
- yield "\n".join(infos)
- except:
- yield traceback.format_exc()
-
-
-def uvr(model_name, inp_root, save_root_vocal, paths, save_root_ins, agg):
- infos = []
- try:
- inp_root = inp_root.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
- save_root_vocal = (
- save_root_vocal.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
- )
- save_root_ins = (
- save_root_ins.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
- )
- pre_fun = _audio_pre_(
- agg=int(agg),
- model_path=os.path.join(weight_uvr5_root, model_name + ".pth"),
- device=config.device,
- is_half=config.is_half,
- )
- if inp_root != "":
- paths = [os.path.join(inp_root, name) for name in os.listdir(inp_root)]
- else:
- paths = [path.name for path in paths]
- for path in paths:
- inp_path = os.path.join(inp_root, path)
- need_reformat = 1
- done = 0
- try:
- info = ffmpeg.probe(inp_path, cmd="ffprobe")
- if (
- info["streams"][0]["channels"] == 2
- and info["streams"][0]["sample_rate"] == "44100"
- ):
- need_reformat = 0
- pre_fun._path_audio_(inp_path, save_root_ins, save_root_vocal)
- done = 1
- except:
- need_reformat = 1
- traceback.print_exc()
- if need_reformat == 1:
- tmp_path = "%s/%s.reformatted.wav" % (tmp, os.path.basename(inp_path))
- os.system(
- "ffmpeg -i %s -vn -acodec pcm_s16le -ac 2 -ar 44100 %s -y"
- % (inp_path, tmp_path)
- )
- inp_path = tmp_path
- try:
- if done == 0:
- pre_fun._path_audio_(inp_path, save_root_ins, save_root_vocal)
- infos.append("%s->Success" % (os.path.basename(inp_path)))
- yield "\n".join(infos)
- except:
- infos.append(
- "%s->%s" % (os.path.basename(inp_path), traceback.format_exc())
- )
- yield "\n".join(infos)
- except:
- infos.append(traceback.format_exc())
- yield "\n".join(infos)
- finally:
- try:
- del pre_fun.model
- del pre_fun
- except:
- traceback.print_exc()
- print("clean_empty_cache")
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- yield "\n".join(infos)
-
-
-# 一个选项卡全局只能有一个音色
-def get_vc(sid):
- global n_spk, tgt_sr, net_g, vc, cpt, version
- if sid == "" or sid == []:
- global hubert_model
- if hubert_model != None: # 考虑到轮询, 需要加个判断看是否 sid 是由有模型切换到无模型的
- print("clean_empty_cache")
- del net_g, n_spk, vc, hubert_model, tgt_sr # ,cpt
- hubert_model = net_g = n_spk = vc = hubert_model = tgt_sr = None
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- ###楼下不这么折腾清理不干净
- if_f0 = cpt.get("f0", 1)
- version = cpt.get("version", "v1")
- if version == "v1":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs256NSFsid(
- *cpt["config"], is_half=config.is_half
- )
- else:
- net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- elif version == "v2":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs768NSFsid(
- *cpt["config"], is_half=config.is_half
- )
- else:
- net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
- del net_g, cpt
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- cpt = None
- return {"visible": False, "__type__": "update"}
- person = "%s/%s" % (weight_root, sid)
- print("loading %s" % person)
- cpt = torch.load(person, map_location="cpu")
- tgt_sr = cpt["config"][-1]
- cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
- if_f0 = cpt.get("f0", 1)
- version = cpt.get("version", "v1")
- if version == "v1":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
- else:
- net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- elif version == "v2":
- if if_f0 == 1:
- net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
- else:
- net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
- del net_g.enc_q
- print(net_g.load_state_dict(cpt["weight"], strict=False))
- net_g.eval().to(config.device)
- if config.is_half:
- net_g = net_g.half()
- else:
- net_g = net_g.float()
- vc = VC(tgt_sr, config)
- n_spk = cpt["config"][-3]
- return {"visible": True, "maximum": n_spk, "__type__": "update"}
-
-
-def change_choices():
- names = []
- for name in os.listdir(weight_root):
- if name.endswith(".pth"):
- names.append(name)
- index_paths = []
- for root, dirs, files in os.walk(index_root, topdown=False):
- for name in files:
- if name.endswith(".index") and "trained" not in name:
- index_paths.append("%s/%s" % (root, name))
- return {"choices": sorted(names), "__type__": "update"}, {
- "choices": sorted(index_paths),
- "__type__": "update",
- }
-
-
-def clean():
- return {"value": "", "__type__": "update"}
-
-
-sr_dict = {
- "32k": 32000,
- "40k": 40000,
- "48k": 48000,
-}
-
-
-def if_done(done, p):
- while 1:
- if p.poll() == None:
- sleep(0.5)
- else:
- break
- done[0] = True
-
-
-def if_done_multi(done, ps):
- while 1:
- # poll==None代表进程未结束
- # 只要有一个进程未结束都不停
- flag = 1
- for p in ps:
- if p.poll() == None:
- flag = 0
- sleep(0.5)
- break
- if flag == 1:
- break
- done[0] = True
-
-
-def preprocess_dataset(trainset_dir, exp_dir, sr, n_p):
- sr = sr_dict[sr]
- os.makedirs("%s/logs/%s" % (now_dir, exp_dir), exist_ok=True)
- f = open("%s/logs/%s/preprocess.log" % (now_dir, exp_dir), "w")
- f.close()
- cmd = (
- config.python_cmd
- + " trainset_preprocess_pipeline_print.py %s %s %s %s/logs/%s "
- % (trainset_dir, sr, n_p, now_dir, exp_dir)
- + str(config.noparallel)
- )
- print(cmd)
- p = Popen(cmd, shell=True) # , stdin=PIPE, stdout=PIPE,stderr=PIPE,cwd=now_dir
- ###煞笔gr, popen read都非得全跑完了再一次性读取, 不用gr就正常读一句输出一句;只能额外弄出一个文本流定时读
- done = [False]
- threading.Thread(
- target=if_done,
- args=(
- done,
- p,
- ),
- ).start()
- while 1:
- with open("%s/logs/%s/preprocess.log" % (now_dir, exp_dir), "r") as f:
- yield (f.read())
- sleep(1)
- if done[0] == True:
- break
- with open("%s/logs/%s/preprocess.log" % (now_dir, exp_dir), "r") as f:
- log = f.read()
- print(log)
- yield log
-
-
-# but2.click(extract_f0,[gpus6,np7,f0method8,if_f0_3,trainset_dir4],[info2])
-def extract_f0_feature(gpus, n_p, f0method, if_f0, exp_dir, version19):
- gpus = gpus.split("-")
- os.makedirs("%s/logs/%s" % (now_dir, exp_dir), exist_ok=True)
- f = open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "w")
- f.close()
- if if_f0:
- cmd = config.python_cmd + " extract_f0_print.py %s/logs/%s %s %s" % (
- now_dir,
- exp_dir,
- n_p,
- f0method,
- )
- print(cmd)
- p = Popen(cmd, shell=True, cwd=now_dir) # , stdin=PIPE, stdout=PIPE,stderr=PIPE
- ###煞笔gr, popen read都非得全跑完了再一次性读取, 不用gr就正常读一句输出一句;只能额外弄出一个文本流定时读
- done = [False]
- threading.Thread(
- target=if_done,
- args=(
- done,
- p,
- ),
- ).start()
- while 1:
- with open(
- "%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r"
- ) as f:
- yield (f.read())
- sleep(1)
- if done[0] == True:
- break
- with open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r") as f:
- log = f.read()
- print(log)
- yield log
- ####对不同part分别开多进程
- """
- n_part=int(sys.argv[1])
- i_part=int(sys.argv[2])
- i_gpu=sys.argv[3]
- exp_dir=sys.argv[4]
- os.environ["CUDA_VISIBLE_DEVICES"]=str(i_gpu)
- """
- leng = len(gpus)
- ps = []
- for idx, n_g in enumerate(gpus):
- cmd = (
- config.python_cmd
- + " extract_feature_print.py %s %s %s %s %s/logs/%s %s"
- % (
- config.device,
- leng,
- idx,
- n_g,
- now_dir,
- exp_dir,
- version19,
- )
- )
- print(cmd)
- p = Popen(
- cmd, shell=True, cwd=now_dir
- ) # , shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, cwd=now_dir
- ps.append(p)
- ###煞笔gr, popen read都非得全跑完了再一次性读取, 不用gr就正常读一句输出一句;只能额外弄出一个文本流定时读
- done = [False]
- threading.Thread(
- target=if_done_multi,
- args=(
- done,
- ps,
- ),
- ).start()
- while 1:
- with open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r") as f:
- yield (f.read())
- sleep(1)
- if done[0] == True:
- break
- with open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r") as f:
- log = f.read()
- print(log)
- yield log
-
-
-def change_sr2(sr2, if_f0_3, version19):
- vis_v = True if sr2 == "40k" else False
- if sr2 != "40k":
- version19 = "v1"
- path_str = "" if version19 == "v1" else "_v2"
- version_state = {"visible": vis_v, "__type__": "update"}
- if vis_v == False:
- version_state["value"] = "v1"
- f0_str = "f0" if if_f0_3 else ""
- return (
- "pretrained%s/%sG%s.pth" % (path_str, f0_str, sr2),
- "pretrained%s/%sD%s.pth" % (path_str, f0_str, sr2),
- version_state,
- )
-
-
-def change_version19(sr2, if_f0_3, version19):
- path_str = "" if version19 == "v1" else "_v2"
- f0_str = "f0" if if_f0_3 else ""
- return "pretrained%s/%sG%s.pth" % (
- path_str,
- f0_str,
- sr2,
- ), "pretrained%s/%sD%s.pth" % (path_str, f0_str, sr2)
-
-
-def change_f0(if_f0_3, sr2, version19): # f0method8,pretrained_G14,pretrained_D15
- path_str = "" if version19 == "v1" else "_v2"
- if if_f0_3:
- return (
- {"visible": True, "__type__": "update"},
- "pretrained%s/f0G%s.pth" % (path_str, sr2),
- "pretrained%s/f0D%s.pth" % (path_str, sr2),
- )
- return (
- {"visible": False, "__type__": "update"},
- "pretrained%s/G%s.pth" % (path_str, sr2),
- "pretrained%s/D%s.pth" % (path_str, sr2),
- )
-
-
-# but3.click(click_train,[exp_dir1,sr2,if_f0_3,save_epoch10,total_epoch11,batch_size12,if_save_latest13,pretrained_G14,pretrained_D15,gpus16])
-def click_train(
- exp_dir1,
- sr2,
- if_f0_3,
- spk_id5,
- save_epoch10,
- total_epoch11,
- batch_size12,
- if_save_latest13,
- pretrained_G14,
- pretrained_D15,
- gpus16,
- if_cache_gpu17,
- if_save_every_weights18,
- version19,
-):
- # 生成filelist
- exp_dir = "%s/logs/%s" % (now_dir, exp_dir1)
- os.makedirs(exp_dir, exist_ok=True)
- gt_wavs_dir = "%s/0_gt_wavs" % (exp_dir)
- feature_dir = (
- "%s/3_feature256" % (exp_dir)
- if version19 == "v1"
- else "%s/3_feature768" % (exp_dir)
- )
- if if_f0_3:
- f0_dir = "%s/2a_f0" % (exp_dir)
- f0nsf_dir = "%s/2b-f0nsf" % (exp_dir)
- names = (
- set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)])
- & set([name.split(".")[0] for name in os.listdir(feature_dir)])
- & set([name.split(".")[0] for name in os.listdir(f0_dir)])
- & set([name.split(".")[0] for name in os.listdir(f0nsf_dir)])
- )
- else:
- names = set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)]) & set(
- [name.split(".")[0] for name in os.listdir(feature_dir)]
- )
- opt = []
- for name in names:
- if if_f0_3:
- opt.append(
- "%s/%s.wav|%s/%s.npy|%s/%s.wav.npy|%s/%s.wav.npy|%s"
- % (
- gt_wavs_dir.replace("\\", "\\\\"),
- name,
- feature_dir.replace("\\", "\\\\"),
- name,
- f0_dir.replace("\\", "\\\\"),
- name,
- f0nsf_dir.replace("\\", "\\\\"),
- name,
- spk_id5,
- )
- )
- else:
- opt.append(
- "%s/%s.wav|%s/%s.npy|%s"
- % (
- gt_wavs_dir.replace("\\", "\\\\"),
- name,
- feature_dir.replace("\\", "\\\\"),
- name,
- spk_id5,
- )
- )
- fea_dim = 256 if version19 == "v1" else 768
- if if_f0_3:
- for _ in range(2):
- opt.append(
- "%s/logs/mute/0_gt_wavs/mute%s.wav|%s/logs/mute/3_feature%s/mute.npy|%s/logs/mute/2a_f0/mute.wav.npy|%s/logs/mute/2b-f0nsf/mute.wav.npy|%s"
- % (now_dir, sr2, now_dir, fea_dim, now_dir, now_dir, spk_id5)
- )
- else:
- for _ in range(2):
- opt.append(
- "%s/logs/mute/0_gt_wavs/mute%s.wav|%s/logs/mute/3_feature%s/mute.npy|%s"
- % (now_dir, sr2, now_dir, fea_dim, spk_id5)
- )
- shuffle(opt)
- with open("%s/filelist.txt" % exp_dir, "w") as f:
- f.write("\n".join(opt))
- print("write filelist done")
- # 生成config#无需生成config
- # cmd = python_cmd + " train_nsf_sim_cache_sid_load_pretrain.py -e mi-test -sr 40k -f0 1 -bs 4 -g 0 -te 10 -se 5 -pg pretrained/f0G40k.pth -pd pretrained/f0D40k.pth -l 1 -c 0"
- print("use gpus:", gpus16)
- if gpus16:
- cmd = (
- config.python_cmd
- + " train_nsf_sim_cache_sid_load_pretrain.py -e %s -sr %s -f0 %s -bs %s -g %s -te %s -se %s -pg %s -pd %s -l %s -c %s -sw %s -v %s"
- % (
- exp_dir1,
- sr2,
- 1 if if_f0_3 else 0,
- batch_size12,
- gpus16,
- total_epoch11,
- save_epoch10,
- pretrained_G14,
- pretrained_D15,
- 1 if if_save_latest13 == i18n("是") else 0,
- 1 if if_cache_gpu17 == i18n("是") else 0,
- 1 if if_save_every_weights18 == i18n("是") else 0,
- version19,
- )
- )
- else:
- cmd = (
- config.python_cmd
- + " train_nsf_sim_cache_sid_load_pretrain.py -e %s -sr %s -f0 %s -bs %s -te %s -se %s -pg %s -pd %s -l %s -c %s -sw %s -v %s"
- % (
- exp_dir1,
- sr2,
- 1 if if_f0_3 else 0,
- batch_size12,
- total_epoch11,
- save_epoch10,
- pretrained_G14,
- pretrained_D15,
- 1 if if_save_latest13 == i18n("是") else 0,
- 1 if if_cache_gpu17 == i18n("是") else 0,
- 1 if if_save_every_weights18 == i18n("是") else 0,
- version19,
- )
- )
- print(cmd)
- p = Popen(cmd, shell=True, cwd=now_dir)
- p.wait()
- return "训练结束, 您可查看控制台训练日志或实验文件夹下的train.log"
-
-
-# but4.click(train_index, [exp_dir1], info3)
-def train_index(exp_dir1, version19):
- exp_dir = "%s/logs/%s" % (now_dir, exp_dir1)
- os.makedirs(exp_dir, exist_ok=True)
- feature_dir = (
- "%s/3_feature256" % (exp_dir)
- if version19 == "v1"
- else "%s/3_feature768" % (exp_dir)
- )
- if os.path.exists(feature_dir) == False:
- return "请先进行特征提取!"
- listdir_res = list(os.listdir(feature_dir))
- if len(listdir_res) == 0:
- return "请先进行特征提取！"
- npys = []
- for name in sorted(listdir_res):
- phone = np.load("%s/%s" % (feature_dir, name))
- npys.append(phone)
- big_npy = np.concatenate(npys, 0)
- big_npy_idx = np.arange(big_npy.shape[0])
- np.random.shuffle(big_npy_idx)
- big_npy = big_npy[big_npy_idx]
- np.save("%s/total_fea.npy" % exp_dir, big_npy)
- # n_ivf = big_npy.shape[0] // 39
- n_ivf = min(int(16 * np.sqrt(big_npy.shape[0])), big_npy.shape[0] // 39)
- infos = []
- infos.append("%s,%s" % (big_npy.shape, n_ivf))
- yield "\n".join(infos)
- index = faiss.index_factory(256 if version19 == "v1" else 768, "IVF%s,Flat" % n_ivf)
- # index = faiss.index_factory(256if version19=="v1"else 768, "IVF%s,PQ128x4fs,RFlat"%n_ivf)
- infos.append("training")
- yield "\n".join(infos)
- index_ivf = faiss.extract_index_ivf(index) #
- index_ivf.nprobe = 1
- index.train(big_npy)
- faiss.write_index(
- index,
- "%s/trained_IVF%s_Flat_nprobe_%s_%s.index"
- % (exp_dir, n_ivf, index_ivf.nprobe, version19),
- )
- # faiss.write_index(index, '%s/trained_IVF%s_Flat_FastScan_%s.index'%(exp_dir,n_ivf,version19))
- infos.append("adding")
- yield "\n".join(infos)
- batch_size_add = 8192
- for i in range(0, big_npy.shape[0], batch_size_add):
- index.add(big_npy[i : i + batch_size_add])
- faiss.write_index(
- index,
- "%s/added_IVF%s_Flat_nprobe_%s_%s.index"
- % (exp_dir, n_ivf, index_ivf.nprobe, version19),
- )
- infos.append(
- "成功构建索引，added_IVF%s_Flat_nprobe_%s_%s.index"
- % (n_ivf, index_ivf.nprobe, version19)
- )
- # faiss.write_index(index, '%s/added_IVF%s_Flat_FastScan_%s.index'%(exp_dir,n_ivf,version19))
- # infos.append("成功构建索引，added_IVF%s_Flat_FastScan_%s.index"%(n_ivf,version19))
- yield "\n".join(infos)
-
-
-# but5.click(train1key, [exp_dir1, sr2, if_f0_3, trainset_dir4, spk_id5, gpus6, np7, f0method8, save_epoch10, total_epoch11, batch_size12, if_save_latest13, pretrained_G14, pretrained_D15, gpus16, if_cache_gpu17], info3)
-def train1key(
- exp_dir1,
- sr2,
- if_f0_3,
- trainset_dir4,
- spk_id5,
- np7,
- f0method8,
- save_epoch10,
- total_epoch11,
- batch_size12,
- if_save_latest13,
- pretrained_G14,
- pretrained_D15,
- gpus16,
- if_cache_gpu17,
- if_save_every_weights18,
- version19,
-):
- infos = []
-
- def get_info_str(strr):
- infos.append(strr)
- return "\n".join(infos)
-
- model_log_dir = "%s/logs/%s" % (now_dir, exp_dir1)
- preprocess_log_path = "%s/preprocess.log" % model_log_dir
- extract_f0_feature_log_path = "%s/extract_f0_feature.log" % model_log_dir
- gt_wavs_dir = "%s/0_gt_wavs" % model_log_dir
- feature_dir = (
- "%s/3_feature256" % model_log_dir
- if version19 == "v1"
- else "%s/3_feature768" % model_log_dir
- )
-
- os.makedirs(model_log_dir, exist_ok=True)
- #########step1:处理数据
- open(preprocess_log_path, "w").close()
- cmd = (
- config.python_cmd
- + " trainset_preprocess_pipeline_print.py %s %s %s %s "
- % (trainset_dir4, sr_dict[sr2], np7, model_log_dir)
- + str(config.noparallel)
- )
- yield get_info_str(i18n("step1:正在处理数据"))
- yield get_info_str(cmd)
- p = Popen(cmd, shell=True)
- p.wait()
- with open(preprocess_log_path, "r") as f:
- print(f.read())
- #########step2a:提取音高
- open(extract_f0_feature_log_path, "w")
- if if_f0_3:
- yield get_info_str("step2a:正在提取音高")
- cmd = config.python_cmd + " extract_f0_print.py %s %s %s" % (
- model_log_dir,
- np7,
- f0method8,
- )
- yield get_info_str(cmd)
- p = Popen(cmd, shell=True, cwd=now_dir)
- p.wait()
- with open(extract_f0_feature_log_path, "r") as f:
- print(f.read())
- else:
- yield get_info_str(i18n("step2a:无需提取音高"))
- #######step2b:提取特征
- yield get_info_str(i18n("step2b:正在提取特征"))
- gpus = gpus16.split("-")
- leng = len(gpus)
- ps = []
- for idx, n_g in enumerate(gpus):
- cmd = config.python_cmd + " extract_feature_print.py %s %s %s %s %s %s" % (
- config.device,
- leng,
- idx,
- n_g,
- model_log_dir,
- version19,
- )
- yield get_info_str(cmd)
- p = Popen(
- cmd, shell=True, cwd=now_dir
- ) # , shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, cwd=now_dir
- ps.append(p)
- for p in ps:
- p.wait()
- with open(extract_f0_feature_log_path, "r") as f:
- print(f.read())
- #######step3a:训练模型
- yield get_info_str(i18n("step3a:正在训练模型"))
- # 生成filelist
- if if_f0_3:
- f0_dir = "%s/2a_f0" % model_log_dir
- f0nsf_dir = "%s/2b-f0nsf" % model_log_dir
- names = (
- set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)])
- & set([name.split(".")[0] for name in os.listdir(feature_dir)])
- & set([name.split(".")[0] for name in os.listdir(f0_dir)])
- & set([name.split(".")[0] for name in os.listdir(f0nsf_dir)])
- )
- else:
- names = set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)]) & set(
- [name.split(".")[0] for name in os.listdir(feature_dir)]
- )
- opt = []
- for name in names:
- if if_f0_3:
- opt.append(
- "%s/%s.wav|%s/%s.npy|%s/%s.wav.npy|%s/%s.wav.npy|%s"
- % (
- gt_wavs_dir.replace("\\", "\\\\"),
- name,
- feature_dir.replace("\\", "\\\\"),
- name,
- f0_dir.replace("\\", "\\\\"),
- name,
- f0nsf_dir.replace("\\", "\\\\"),
- name,
- spk_id5,
- )
- )
- else:
- opt.append(
- "%s/%s.wav|%s/%s.npy|%s"
- % (
- gt_wavs_dir.replace("\\", "\\\\"),
- name,
- feature_dir.replace("\\", "\\\\"),
- name,
- spk_id5,
- )
- )
- fea_dim = 256 if version19 == "v1" else 768
- if if_f0_3:
- for _ in range(2):
- opt.append(
- "%s/logs/mute/0_gt_wavs/mute%s.wav|%s/logs/mute/3_feature%s/mute.npy|%s/logs/mute/2a_f0/mute.wav.npy|%s/logs/mute/2b-f0nsf/mute.wav.npy|%s"
- % (now_dir, sr2, now_dir, fea_dim, now_dir, now_dir, spk_id5)
- )
- else:
- for _ in range(2):
- opt.append(
- "%s/logs/mute/0_gt_wavs/mute%s.wav|%s/logs/mute/3_feature%s/mute.npy|%s"
- % (now_dir, sr2, now_dir, fea_dim, spk_id5)
- )
- shuffle(opt)
- with open("%s/filelist.txt" % model_log_dir, "w") as f:
- f.write("\n".join(opt))
- yield get_info_str("write filelist done")
- if gpus16:
- cmd = (
- config.python_cmd
- + " train_nsf_sim_cache_sid_load_pretrain.py -e %s -sr %s -f0 %s -bs %s -g %s -te %s -se %s -pg %s -pd %s -l %s -c %s -sw %s -v %s"
- % (
- exp_dir1,
- sr2,
- 1 if if_f0_3 else 0,
- batch_size12,
- gpus16,
- total_epoch11,
- save_epoch10,
- pretrained_G14,
- pretrained_D15,
- 1 if if_save_latest13 == i18n("是") else 0,
- 1 if if_cache_gpu17 == i18n("是") else 0,
- 1 if if_save_every_weights18 == i18n("是") else 0,
- version19,
- )
- )
- else:
- cmd = (
- config.python_cmd
- + " train_nsf_sim_cache_sid_load_pretrain.py -e %s -sr %s -f0 %s -bs %s -te %s -se %s -pg %s -pd %s -l %s -c %s -sw %s -v %s"
- % (
- exp_dir1,
- sr2,
- 1 if if_f0_3 else 0,
- batch_size12,
- total_epoch11,
- save_epoch10,
- pretrained_G14,
- pretrained_D15,
- 1 if if_save_latest13 == i18n("是") else 0,
- 1 if if_cache_gpu17 == i18n("是") else 0,
- 1 if if_save_every_weights18 == i18n("是") else 0,
- version19,
- )
- )
- yield get_info_str(cmd)
- p = Popen(cmd, shell=True, cwd=now_dir)
- p.wait()
- yield get_info_str(i18n("训练结束, 您可查看控制台训练日志或实验文件夹下的train.log"))
- #######step3b:训练索引
- npys = []
- listdir_res = list(os.listdir(feature_dir))
- for name in sorted(listdir_res):
- phone = np.load("%s/%s" % (feature_dir, name))
- npys.append(phone)
- big_npy = np.concatenate(npys, 0)
-
- big_npy_idx = np.arange(big_npy.shape[0])
- np.random.shuffle(big_npy_idx)
- big_npy = big_npy[big_npy_idx]
- np.save("%s/total_fea.npy" % model_log_dir, big_npy)
-
- # n_ivf = big_npy.shape[0] // 39
- n_ivf = min(int(16 * np.sqrt(big_npy.shape[0])), big_npy.shape[0] // 39)
- yield get_info_str("%s,%s" % (big_npy.shape, n_ivf))
- index = faiss.index_factory(256 if version19 == "v1" else 768, "IVF%s,Flat" % n_ivf)
- yield get_info_str("training index")
- index_ivf = faiss.extract_index_ivf(index) #
- index_ivf.nprobe = 1
- index.train(big_npy)
- faiss.write_index(
- index,
- "%s/trained_IVF%s_Flat_nprobe_%s_%s.index"
- % (model_log_dir, n_ivf, index_ivf.nprobe, version19),
- )
- yield get_info_str("adding index")
- batch_size_add = 8192
- for i in range(0, big_npy.shape[0], batch_size_add):
- index.add(big_npy[i : i + batch_size_add])
- faiss.write_index(
- index,
- "%s/added_IVF%s_Flat_nprobe_%s_%s.index"
- % (model_log_dir, n_ivf, index_ivf.nprobe, version19),
- )
- yield get_info_str(
- "成功构建索引, added_IVF%s_Flat_nprobe_%s_%s.index"
- % (n_ivf, index_ivf.nprobe, version19)
- )
- yield get_info_str(i18n("全流程结束！"))
-
-
-# ckpt_path2.change(change_info_,[ckpt_path2],[sr__,if_f0__])
-def change_info_(ckpt_path):
- if (
- os.path.exists(ckpt_path.replace(os.path.basename(ckpt_path), "train.log"))
- == False
- ):
- return {"__type__": "update"}, {"__type__": "update"}, {"__type__": "update"}
- try:
- with open(
- ckpt_path.replace(os.path.basename(ckpt_path), "train.log"), "r"
- ) as f:
- info = eval(f.read().strip("\n").split("\n")[0].split("\t")[-1])
- sr, f0 = info["sample_rate"], info["if_f0"]
- version = "v2" if ("version" in info and info["version"] == "v2") else "v1"
- return sr, str(f0), version
- except:
- traceback.print_exc()
- return {"__type__": "update"}, {"__type__": "update"}, {"__type__": "update"}
-
-
-from infer_pack.models_onnx_moess import SynthesizerTrnMs256NSFsidM
-from infer_pack.models_onnx import SynthesizerTrnMs256NSFsidO
-
-
-def export_onnx(ModelPath, ExportedPath, MoeVS=True):
- hidden_channels = 256 # hidden_channels，为768Vec做准备
- cpt = torch.load(ModelPath, map_location="cpu")
- cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
- print(*cpt["config"])
-
- test_phone = torch.rand(1, 200, hidden_channels) # hidden unit
- test_phone_lengths = torch.tensor([200]).long() # hidden unit 长度（貌似没啥用）
- test_pitch = torch.randint(size=(1, 200), low=5, high=255) # 基频（单位赫兹）
- test_pitchf = torch.rand(1, 200) # nsf基频
- test_ds = torch.LongTensor([0]) # 说话人ID
- test_rnd = torch.rand(1, 192, 200) # 噪声（加入随机因子）
-
- device = "cpu" # 导出时设备（不影响使用模型）
-
- if MoeVS:
- net_g = SynthesizerTrnMs256NSFsidM(
- *cpt["config"], is_half=False
- ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
- net_g.load_state_dict(cpt["weight"], strict=False)
- input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
- output_names = [
- "audio",
- ]
- torch.onnx.export(
- net_g,
- (
- test_phone.to(device),
- test_phone_lengths.to(device),
- test_pitch.to(device),
- test_pitchf.to(device),
- test_ds.to(device),
- test_rnd.to(device),
- ),
- ExportedPath,
- dynamic_axes={
- "phone": [1],
- "pitch": [1],
- "pitchf": [1],
- "rnd": [2],
- },
- do_constant_folding=False,
- opset_version=16,
- verbose=False,
- input_names=input_names,
- output_names=output_names,
- )
- else:
- net_g = SynthesizerTrnMs256NSFsidO(
- *cpt["config"], is_half=False
- ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
- net_g.load_state_dict(cpt["weight"], strict=False)
- input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds"]
- output_names = [
- "audio",
- ]
- torch.onnx.export(
- net_g,
- (
- test_phone.to(device),
- test_phone_lengths.to(device),
- test_pitch.to(device),
- test_pitchf.to(device),
- test_ds.to(device),
- ),
- ExportedPath,
- dynamic_axes={
- "phone": [1],
- "pitch": [1],
- "pitchf": [1],
- },
- do_constant_folding=False,
- opset_version=16,
- verbose=False,
- input_names=input_names,
- output_names=output_names,
- )
- return "Finished"
-
-
-with gr.Blocks() as app:
- gr.Markdown(
- value=i18n(
- "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责.
如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录使用需遵守的协议-LICENSE.txt."
- )
- )
- with gr.Tabs():
- with gr.TabItem(i18n("模型推理")):
- with gr.Row():
- sid0 = gr.Dropdown(label=i18n("推理音色"), choices=sorted(names))
- refresh_button = gr.Button(i18n("刷新音色列表和索引路径"), variant="primary")
- clean_button = gr.Button(i18n("卸载音色省显存"), variant="primary")
- spk_item = gr.Slider(
- minimum=0,
- maximum=2333,
- step=1,
- label=i18n("请选择说话人id"),
- value=0,
- visible=False,
- interactive=True,
- )
- clean_button.click(fn=clean, inputs=[], outputs=[sid0])
- sid0.change(
- fn=get_vc,
- inputs=[sid0],
- outputs=[spk_item],
- )
- with gr.Group():
- gr.Markdown(
- value=i18n("男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ")
- )
- with gr.Row():
- with gr.Column():
- vc_transform0 = gr.Number(
- label=i18n("变调(整数, 半音数量, 升八度12降八度-12)"), value=0
- )
- input_audio0 = gr.Textbox(
- label=i18n("输入待处理音频文件路径(默认是正确格式示例)"),
- value="E:\\codes\\py39\\test-20230416b\\todo-songs\\冬之花clip1.wav",
- )
- f0method0 = gr.Radio(
- label=i18n("选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比"),
- choices=["pm", "harvest"],
- value="pm",
- interactive=True,
- )
- filter_radius0 = gr.Slider(
- minimum=0,
- maximum=7,
- label=i18n(">=3则使用对harvest音高识别的结果使用中值滤波，数值为滤波半径，使用可以削弱哑音"),
- value=3,
- step=1,
- interactive=True,
- )
- with gr.Column():
- file_index1 = gr.Textbox(
- label=i18n("特征检索库文件路径,为空则使用下拉的选择结果"),
- value="",
- interactive=True,
- )
- file_index2 = gr.Dropdown(
- label=i18n("自动检测index路径,下拉式选择(dropdown)"),
- choices=sorted(index_paths),
- interactive=True,
- )
- refresh_button.click(
- fn=change_choices, inputs=[], outputs=[sid0, file_index2]
- )
- # file_big_npy1 = gr.Textbox(
- # label=i18n("特征文件路径"),
- # value="E:\\codes\py39\\vits_vc_gpu_train\\logs\\mi-test-1key\\total_fea.npy",
- # interactive=True,
- # )
- index_rate1 = gr.Slider(
- minimum=0,
- maximum=1,
- label=i18n("检索特征占比"),
- value=0.76,
- interactive=True,
- )
- resample_sr0 = gr.Slider(
- minimum=0,
- maximum=48000,
- label=i18n("后处理重采样至最终采样率，0为不进行重采样"),
- value=0,
- step=1,
- interactive=True,
- )
- rms_mix_rate0 = gr.Slider(
- minimum=0,
- maximum=1,
- label=i18n("输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络"),
- value=1,
- interactive=True,
- )
- f0_file = gr.File(label=i18n("F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调"))
- but0 = gr.Button(i18n("转换"), variant="primary")
- with gr.Column():
- vc_output1 = gr.Textbox(label=i18n("输出信息"))
- vc_output2 = gr.Audio(label=i18n("输出音频(右下角三个点,点了可以下载)"))
- but0.click(
- vc_single,
- [
- spk_item,
- input_audio0,
- vc_transform0,
- f0_file,
- f0method0,
- file_index1,
- file_index2,
- # file_big_npy1,
- index_rate1,
- filter_radius0,
- resample_sr0,
- rms_mix_rate0,
- ],
- [vc_output1, vc_output2],
- )
- with gr.Group():
- gr.Markdown(
- value=i18n("批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ")
- )
- with gr.Row():
- with gr.Column():
- vc_transform1 = gr.Number(
- label=i18n("变调(整数, 半音数量, 升八度12降八度-12)"), value=0
- )
- opt_input = gr.Textbox(label=i18n("指定输出文件夹"), value="opt")
- f0method1 = gr.Radio(
- label=i18n("选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比"),
- choices=["pm", "harvest"],
- value="pm",
- interactive=True,
- )
- filter_radius1 = gr.Slider(
- minimum=0,
- maximum=7,
- label=i18n(">=3则使用对harvest音高识别的结果使用中值滤波，数值为滤波半径，使用可以削弱哑音"),
- value=3,
- step=1,
- interactive=True,
- )
- with gr.Column():
- file_index3 = gr.Textbox(
- label=i18n("特征检索库文件路径,为空则使用下拉的选择结果"),
- value="",
- interactive=True,
- )
- file_index4 = gr.Dropdown(
- label=i18n("自动检测index路径,下拉式选择(dropdown)"),
- choices=sorted(index_paths),
- interactive=True,
- )
- # file_big_npy2 = gr.Textbox(
- # label=i18n("特征文件路径"),
- # value="E:\\codes\\py39\\vits_vc_gpu_train\\logs\\mi-test-1key\\total_fea.npy",
- # interactive=True,
- # )
- index_rate2 = gr.Slider(
- minimum=0,
- maximum=1,
- label=i18n("检索特征占比"),
- value=1,
- interactive=True,
- )
- resample_sr1 = gr.Slider(
- minimum=0,
- maximum=48000,
- label=i18n("后处理重采样至最终采样率，0为不进行重采样"),
- value=0,
- step=1,
- interactive=True,
- )
- rms_mix_rate1 = gr.Slider(
- minimum=0,
- maximum=1,
- label=i18n("输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络"),
- value=1,
- interactive=True,
- )
- with gr.Column():
- dir_input = gr.Textbox(
- label=i18n("输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)"),
- value="E:\codes\py39\\test-20230416b\\todo-songs",
- )
- inputs = gr.File(
- file_count="multiple", label=i18n("也可批量输入音频文件, 二选一, 优先读文件夹")
- )
- but1 = gr.Button(i18n("转换"), variant="primary")
- vc_output3 = gr.Textbox(label=i18n("输出信息"))
- but1.click(
- vc_multi,
- [
- spk_item,
- dir_input,
- opt_input,
- inputs,
- vc_transform1,
- f0method1,
- file_index3,
- file_index4,
- # file_big_npy2,
- index_rate2,
- filter_radius1,
- resample_sr1,
- rms_mix_rate1,
- ],
- [vc_output3],
- )
- with gr.TabItem(i18n("伴奏人声分离")):
- with gr.Group():
- gr.Markdown(
- value=i18n(
- "人声伴奏分离批量处理, 使用UVR5模型.
不带和声用HP2, 带和声且提取的人声不需要和声用HP5
合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)"
- )
- )
- with gr.Row():
- with gr.Column():
- dir_wav_input = gr.Textbox(
- label=i18n("输入待处理音频文件夹路径"),
- value="E:\\codes\\py39\\test-20230416b\\todo-songs\\todo-songs",
- )
- wav_inputs = gr.File(
- file_count="multiple", label=i18n("也可批量输入音频文件, 二选一, 优先读文件夹")
- )
- with gr.Column():
- model_choose = gr.Dropdown(label=i18n("模型"), choices=uvr5_names)
- agg = gr.Slider(
- minimum=0,
- maximum=20,
- step=1,
- label="人声提取激进程度",
- value=10,
- interactive=True,
- visible=False, # 先不开放调整
- )
- opt_vocal_root = gr.Textbox(
- label=i18n("指定输出人声文件夹"), value="opt"
- )
- opt_ins_root = gr.Textbox(label=i18n("指定输出乐器文件夹"), value="opt")
- but2 = gr.Button(i18n("转换"), variant="primary")
- vc_output4 = gr.Textbox(label=i18n("输出信息"))
- but2.click(
- uvr,
- [
- model_choose,
- dir_wav_input,
- opt_vocal_root,
- wav_inputs,
- opt_ins_root,
- agg,
- ],
- [vc_output4],
- )
- with gr.TabItem(i18n("训练")):
- gr.Markdown(
- value=i18n(
- "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. "
- )
- )
- with gr.Row():
- exp_dir1 = gr.Textbox(label=i18n("输入实验名"), value="mi-test")
- sr2 = gr.Radio(
- label=i18n("目标采样率"),
- choices=["32k", "40k", "48k"],
- value="40k",
- interactive=True,
- )
- if_f0_3 = gr.Radio(
- label=i18n("模型是否带音高指导(唱歌一定要, 语音可以不要)"),
- choices=[True, False],
- value=True,
- interactive=True,
- )
- version19 = gr.Radio(
- label=i18n("版本(目前仅40k支持了v2)"),
- choices=["v1", "v2"],
- value="v1",
- interactive=True,
- visible=True,
- )
- np7 = gr.Slider(
- minimum=0,
- maximum=config.n_cpu,
- step=1,
- label=i18n("提取音高和处理数据使用的CPU进程数"),
- value=config.n_cpu,
- interactive=True,
- )
- with gr.Group(): # 暂时单人的, 后面支持最多4人的#数据处理
- gr.Markdown(
- value=i18n(
- "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. "
- )
- )
- with gr.Row():
- trainset_dir4 = gr.Textbox(
- label=i18n("输入训练文件夹路径"), value="E:\\语音音频+标注\\米津玄师\\src"
- )
- spk_id5 = gr.Slider(
- minimum=0,
- maximum=4,
- step=1,
- label=i18n("请指定说话人id"),
- value=0,
- interactive=True,
- )
- but1 = gr.Button(i18n("处理数据"), variant="primary")
- info1 = gr.Textbox(label=i18n("输出信息"), value="")
- but1.click(
- preprocess_dataset, [trainset_dir4, exp_dir1, sr2, np7], [info1]
- )
- with gr.Group():
- gr.Markdown(value=i18n("step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)"))
- with gr.Row():
- with gr.Column():
- gpus6 = gr.Textbox(
- label=i18n("以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2"),
- value=gpus,
- interactive=True,
- )
- gpu_info9 = gr.Textbox(label=i18n("显卡信息"), value=gpu_info)
- with gr.Column():
- f0method8 = gr.Radio(
- label=i18n(
- "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢"
- ),
- choices=["pm", "harvest", "dio"],
- value="harvest",
- interactive=True,
- )
- but2 = gr.Button(i18n("特征提取"), variant="primary")
- info2 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
- but2.click(
- extract_f0_feature,
- [gpus6, np7, f0method8, if_f0_3, exp_dir1, version19],
- [info2],
- )
- with gr.Group():
- gr.Markdown(value=i18n("step3: 填写训练设置, 开始训练模型和索引"))
- with gr.Row():
- save_epoch10 = gr.Slider(
- minimum=0,
- maximum=50,
- step=1,
- label=i18n("保存频率save_every_epoch"),
- value=5,
- interactive=True,
- )
- total_epoch11 = gr.Slider(
- minimum=0,
- maximum=1000,
- step=1,
- label=i18n("总训练轮数total_epoch"),
- value=20,
- interactive=True,
- )
- batch_size12 = gr.Slider(
- minimum=1,
- maximum=40,
- step=1,
- label=i18n("每张显卡的batch_size"),
- value=default_batch_size,
- interactive=True,
- )
- if_save_latest13 = gr.Radio(
- label=i18n("是否仅保存最新的ckpt文件以节省硬盘空间"),
- choices=[i18n("是"), i18n("否")],
- value=i18n("否"),
- interactive=True,
- )
- if_cache_gpu17 = gr.Radio(
- label=i18n(
- "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速"
- ),
- choices=[i18n("是"), i18n("否")],
- value=i18n("否"),
- interactive=True,
- )
- if_save_every_weights18 = gr.Radio(
- label=i18n("是否在每次保存时间点将最终小模型保存至weights文件夹"),
- choices=[i18n("是"), i18n("否")],
- value=i18n("否"),
- interactive=True,
- )
- with gr.Row():
- pretrained_G14 = gr.Textbox(
- label=i18n("加载预训练底模G路径"),
- value="pretrained/f0G40k.pth",
- interactive=True,
- )
- pretrained_D15 = gr.Textbox(
- label=i18n("加载预训练底模D路径"),
- value="pretrained/f0D40k.pth",
- interactive=True,
- )
- sr2.change(
- change_sr2,
- [sr2, if_f0_3, version19],
- [pretrained_G14, pretrained_D15, version19],
- )
- version19.change(
- change_version19,
- [sr2, if_f0_3, version19],
- [pretrained_G14, pretrained_D15],
- )
- if_f0_3.change(
- change_f0,
- [if_f0_3, sr2, version19],
- [f0method8, pretrained_G14, pretrained_D15],
- )
- gpus16 = gr.Textbox(
- label=i18n("以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2"),
- value=gpus,
- interactive=True,
- )
- but3 = gr.Button(i18n("训练模型"), variant="primary")
- but4 = gr.Button(i18n("训练特征索引"), variant="primary")
- but5 = gr.Button(i18n("一键训练"), variant="primary")
- info3 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=10)
- but3.click(
- click_train,
- [
- exp_dir1,
- sr2,
- if_f0_3,
- spk_id5,
- save_epoch10,
- total_epoch11,
- batch_size12,
- if_save_latest13,
- pretrained_G14,
- pretrained_D15,
- gpus16,
- if_cache_gpu17,
- if_save_every_weights18,
- version19,
- ],
- info3,
- )
- but4.click(train_index, [exp_dir1, version19], info3)
- but5.click(
- train1key,
- [
- exp_dir1,
- sr2,
- if_f0_3,
- trainset_dir4,
- spk_id5,
- np7,
- f0method8,
- save_epoch10,
- total_epoch11,
- batch_size12,
- if_save_latest13,
- pretrained_G14,
- pretrained_D15,
- gpus16,
- if_cache_gpu17,
- if_save_every_weights18,
- version19,
- ],
- info3,
- )
-
- with gr.TabItem(i18n("ckpt处理")):
- with gr.Group():
- gr.Markdown(value=i18n("模型融合, 可用于测试音色融合"))
- with gr.Row():
- ckpt_a = gr.Textbox(label=i18n("A模型路径"), value="", interactive=True)
- ckpt_b = gr.Textbox(label=i18n("B模型路径"), value="", interactive=True)
- alpha_a = gr.Slider(
- minimum=0,
- maximum=1,
- label=i18n("A模型权重"),
- value=0.5,
- interactive=True,
- )
- with gr.Row():
- sr_ = gr.Radio(
- label=i18n("目标采样率"),
- choices=["32k", "40k", "48k"],
- value="40k",
- interactive=True,
- )
- if_f0_ = gr.Radio(
- label=i18n("模型是否带音高指导"),
- choices=[i18n("是"), i18n("否")],
- value=i18n("是"),
- interactive=True,
- )
- info__ = gr.Textbox(
- label=i18n("要置入的模型信息"), value="", max_lines=8, interactive=True
- )
- name_to_save0 = gr.Textbox(
- label=i18n("保存的模型名不带后缀"),
- value="",
- max_lines=1,
- interactive=True,
- )
- version_2 = gr.Radio(
- label=i18n("模型版本型号"),
- choices=["v1", "v2"],
- value="v1",
- interactive=True,
- )
- with gr.Row():
- but6 = gr.Button(i18n("融合"), variant="primary")
- info4 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
- but6.click(
- merge,
- [
- ckpt_a,
- ckpt_b,
- alpha_a,
- sr_,
- if_f0_,
- info__,
- name_to_save0,
- version_2,
- ],
- info4,
- ) # def merge(path1,path2,alpha1,sr,f0,info):
- with gr.Group():
- gr.Markdown(value=i18n("修改模型信息(仅支持weights文件夹下提取的小模型文件)"))
- with gr.Row():
- ckpt_path0 = gr.Textbox(
- label=i18n("模型路径"), value="", interactive=True
- )
- info_ = gr.Textbox(
- label=i18n("要改的模型信息"), value="", max_lines=8, interactive=True
- )
- name_to_save1 = gr.Textbox(
- label=i18n("保存的文件名, 默认空为和源文件同名"),
- value="",
- max_lines=8,
- interactive=True,
- )
- with gr.Row():
- but7 = gr.Button(i18n("修改"), variant="primary")
- info5 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
- but7.click(change_info, [ckpt_path0, info_, name_to_save1], info5)
- with gr.Group():
- gr.Markdown(value=i18n("查看模型信息(仅支持weights文件夹下提取的小模型文件)"))
- with gr.Row():
- ckpt_path1 = gr.Textbox(
- label=i18n("模型路径"), value="", interactive=True
- )
- but8 = gr.Button(i18n("查看"), variant="primary")
- info6 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
- but8.click(show_info, [ckpt_path1], info6)
- with gr.Group():
- gr.Markdown(
- value=i18n(
- "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况"
- )
- )
- with gr.Row():
- ckpt_path2 = gr.Textbox(
- label=i18n("模型路径"),
- value="E:\\codes\\py39\\logs\\mi-test_f0_48k\\G_23333.pth",
- interactive=True,
- )
- save_name = gr.Textbox(
- label=i18n("保存名"), value="", interactive=True
- )
- sr__ = gr.Radio(
- label=i18n("目标采样率"),
- choices=["32k", "40k", "48k"],
- value="40k",
- interactive=True,
- )
- if_f0__ = gr.Radio(
- label=i18n("模型是否带音高指导,1是0否"),
- choices=["1", "0"],
- value="1",
- interactive=True,
- )
- version_1 = gr.Radio(
- label=i18n("模型版本型号"),
- choices=["v1", "v2"],
- value="v1",
- interactive=True,
- )
- info___ = gr.Textbox(
- label=i18n("要置入的模型信息"), value="", max_lines=8, interactive=True
- )
- but9 = gr.Button(i18n("提取"), variant="primary")
- info7 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
- ckpt_path2.change(
- change_info_, [ckpt_path2], [sr__, if_f0__, version_1]
- )
- but9.click(
- extract_small_model,
- [ckpt_path2, save_name, sr__, if_f0__, info___, version_1],
- info7,
- )
-
- with gr.TabItem(i18n("Onnx导出")):
- with gr.Row():
- ckpt_dir = gr.Textbox(label=i18n("RVC模型路径"), value="", interactive=True)
- with gr.Row():
- onnx_dir = gr.Textbox(
- label=i18n("Onnx输出路径"), value="", interactive=True
- )
- with gr.Row():
- moevs = gr.Checkbox(label=i18n("MoeVS模型"), value=True)
- infoOnnx = gr.Label(label="Null")
- with gr.Row():
- butOnnx = gr.Button(i18n("导出Onnx模型"), variant="primary")
- butOnnx.click(export_onnx, [ckpt_dir, onnx_dir, moevs], infoOnnx)
-
- tab_faq = i18n("常见问题解答")
- with gr.TabItem(tab_faq):
- try:
- if tab_faq == "常见问题解答":
- with open("docs/faq.md", "r", encoding="utf8") as f:
- info = f.read()
- else:
- with open("docs/faq_en.md", "r", encoding="utf8") as f:
- info = f.read()
- gr.Markdown(value=info)
- except:
- gr.Markdown(traceback.format_exc())
-
- # with gr.TabItem(i18n("招募音高曲线前端编辑器")):
- # gr.Markdown(value=i18n("加开发群联系我xxxxx"))
- # with gr.TabItem(i18n("点击查看交流、问题反馈群号")):
- # gr.Markdown(value=i18n("xxxxx"))
-
- if config.iscolab:
- app.queue(concurrency_count=511, max_size=1022).launch(share=True)
- else:
- app.queue(concurrency_count=511, max_size=1022).launch(
- server_name="0.0.0.0",
- inbrowser=not config.noautoopen,
- server_port=config.listen_port,
- quiet=True,
- )
+import torch, os, traceback, sys, warnings, shutil, numpy as np
+
+os.environ["no_proxy"] = "localhost, 127.0.0.1, ::1"
+import threading
+from time import sleep
+from subprocess import Popen
+import faiss
+from random import shuffle
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+tmp = os.path.join(now_dir, "TEMP")
+shutil.rmtree(tmp, ignore_errors=True)
+shutil.rmtree("%s/runtime/Lib/site-packages/infer_pack" % (now_dir), ignore_errors=True)
+shutil.rmtree("%s/runtime/Lib/site-packages/uvr5_pack" % (now_dir), ignore_errors=True)
+os.makedirs(tmp, exist_ok=True)
+os.makedirs(os.path.join(now_dir, "logs"), exist_ok=True)
+os.makedirs(os.path.join(now_dir, "weights"), exist_ok=True)
+os.environ["TEMP"] = tmp
+warnings.filterwarnings("ignore")
+torch.manual_seed(114514)
+from i18n import I18nAuto
+import ffmpeg
+
+i18n = I18nAuto()
+i18n.print()
+# 判断是否有能用来训练和加速推理的N卡
+ngpu = torch.cuda.device_count()
+gpu_infos = []
+mem = []
+if (not torch.cuda.is_available()) 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 (
+ "10" in gpu_name
+ or "16" in gpu_name
+ or "20" in gpu_name
+ or "30" in gpu_name
+ or "40" in gpu_name
+ or "A2" in gpu_name.upper()
+ or "A3" in gpu_name.upper()
+ or "A4" in gpu_name.upper()
+ or "P4" in gpu_name.upper()
+ 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.upper()
+ or "T4" in gpu_name.upper()
+ or "TITAN" in gpu_name.upper()
+ ): # A10#A100#V100#A40#P40#M40#K80#A4500
+ if_gpu_ok = True # 至少有一张能用的N卡
+ gpu_infos.append("%s\t%s" % (i, gpu_name))
+ mem.append(
+ int(
+ torch.cuda.get_device_properties(i).total_memory
+ / 1024
+ / 1024
+ / 1024
+ + 0.4
+ )
+ )
+if if_gpu_ok == True and len(gpu_infos) > 0:
+ gpu_info = "\n".join(gpu_infos)
+ default_batch_size = min(mem) // 2
+else:
+ gpu_info = i18n("很遗憾您这没有能用的显卡来支持您训练")
+ default_batch_size = 1
+gpus = "-".join([i[0] for i in gpu_infos])
+from infer_pack.models import (
+ SynthesizerTrnMs256NSFsid,
+ SynthesizerTrnMs256NSFsid_nono,
+ SynthesizerTrnMs768NSFsid,
+ SynthesizerTrnMs768NSFsid_nono,
+)
+from scipy.io import wavfile
+from fairseq import checkpoint_utils
+import gradio as gr
+import logging
+from vc_infer_pipeline import VC
+from config import Config
+from infer_uvr5 import _audio_pre_
+from my_utils import load_audio
+from train.process_ckpt import show_info, change_info, merge, extract_small_model
+
+config = Config()
+# from trainset_preprocess_pipeline import PreProcess
+logging.getLogger("numba").setLevel(logging.WARNING)
+
+
+class ToolButton(gr.Button, gr.components.FormComponent):
+ """Small button with single emoji as text, fits inside gradio forms"""
+
+ def __init__(self, **kwargs):
+ super().__init__(variant="tool", **kwargs)
+
+ def get_block_name(self):
+ return "button"
+
+
+hubert_model = None
+
+
+def load_hubert():
+ global hubert_model
+ models, _, _ = checkpoint_utils.load_model_ensemble_and_task(
+ ["hubert_base.pt"],
+ suffix="",
+ )
+ hubert_model = models[0]
+ hubert_model = hubert_model.to(config.device)
+ if config.is_half:
+ hubert_model = hubert_model.half()
+ else:
+ hubert_model = hubert_model.float()
+ hubert_model.eval()
+
+
+weight_root = "weights"
+weight_uvr5_root = "uvr5_weights"
+index_root = "logs"
+names = []
+for name in os.listdir(weight_root):
+ if name.endswith(".pth"):
+ names.append(name)
+index_paths = []
+for root, dirs, files in os.walk(index_root, topdown=False):
+ for name in files:
+ if name.endswith(".index") and "trained" not in name:
+ index_paths.append("%s/%s" % (root, name))
+uvr5_names = []
+for name in os.listdir(weight_uvr5_root):
+ if name.endswith(".pth"):
+ uvr5_names.append(name.replace(".pth", ""))
+
+
+def vc_single(
+ sid,
+ input_audio_path,
+ f0_up_key,
+ f0_file,
+ f0_method,
+ file_index,
+ file_index2,
+ # file_big_npy,
+ index_rate,
+ filter_radius,
+ resample_sr,
+ rms_mix_rate,
+): # spk_item, input_audio0, vc_transform0,f0_file,f0method0
+ global tgt_sr, net_g, vc, hubert_model, version
+ if input_audio_path is None:
+ return "You need to upload an audio", None
+ f0_up_key = int(f0_up_key)
+ try:
+ audio = load_audio(input_audio_path, 16000)
+ audio_max = np.abs(audio).max() / 0.95
+ if audio_max > 1:
+ audio /= audio_max
+ times = [0, 0, 0]
+ if hubert_model == None:
+ load_hubert()
+ if_f0 = cpt.get("f0", 1)
+ file_index = (
+ (
+ file_index.strip(" ")
+ .strip('"')
+ .strip("\n")
+ .strip('"')
+ .strip(" ")
+ .replace("trained", "added")
+ )
+ if file_index != ""
+ else file_index2
+ ) # 防止小白写错，自动帮他替换掉
+ # file_big_npy = (
+ # file_big_npy.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+ # )
+ audio_opt = vc.pipeline(
+ hubert_model,
+ net_g,
+ sid,
+ audio,
+ input_audio_path,
+ times,
+ f0_up_key,
+ f0_method,
+ file_index,
+ # file_big_npy,
+ index_rate,
+ if_f0,
+ filter_radius,
+ tgt_sr,
+ resample_sr,
+ rms_mix_rate,
+ version,
+ f0_file=f0_file,
+ )
+ if resample_sr >= 16000 and tgt_sr != resample_sr:
+ tgt_sr = resample_sr
+ index_info = (
+ "Using index:%s." % file_index
+ if os.path.exists(file_index)
+ else "Index not used."
+ )
+ return "Success.\n %s\nTime:\n npy:%ss, f0:%ss, infer:%ss" % (
+ index_info,
+ times[0],
+ times[1],
+ times[2],
+ ), (tgt_sr, audio_opt)
+ except:
+ info = traceback.format_exc()
+ print(info)
+ return info, (None, None)
+
+
+def vc_multi(
+ sid,
+ dir_path,
+ opt_root,
+ paths,
+ f0_up_key,
+ f0_method,
+ file_index,
+ file_index2,
+ # file_big_npy,
+ index_rate,
+ filter_radius,
+ resample_sr,
+ rms_mix_rate,
+):
+ try:
+ dir_path = (
+ dir_path.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+ ) # 防止小白拷路径头尾带了空格和"和回车
+ opt_root = opt_root.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+ os.makedirs(opt_root, exist_ok=True)
+ try:
+ if dir_path != "":
+ paths = [os.path.join(dir_path, name) for name in os.listdir(dir_path)]
+ else:
+ paths = [path.name for path in paths]
+ except:
+ traceback.print_exc()
+ paths = [path.name for path in paths]
+ infos = []
+ for path in paths:
+ info, opt = vc_single(
+ sid,
+ path,
+ f0_up_key,
+ None,
+ f0_method,
+ file_index,
+ file_index2,
+ # file_big_npy,
+ index_rate,
+ filter_radius,
+ resample_sr,
+ rms_mix_rate,
+ )
+ if "Success" in info:
+ try:
+ tgt_sr, audio_opt = opt
+ wavfile.write(
+ "%s/%s" % (opt_root, os.path.basename(path)), tgt_sr, audio_opt
+ )
+ except:
+ info += traceback.format_exc()
+ infos.append("%s->%s" % (os.path.basename(path), info))
+ yield "\n".join(infos)
+ yield "\n".join(infos)
+ except:
+ yield traceback.format_exc()
+
+
+def uvr(model_name, inp_root, save_root_vocal, paths, save_root_ins, agg):
+ infos = []
+ try:
+ inp_root = inp_root.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+ save_root_vocal = (
+ save_root_vocal.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+ )
+ save_root_ins = (
+ save_root_ins.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+ )
+ pre_fun = _audio_pre_(
+ agg=int(agg),
+ model_path=os.path.join(weight_uvr5_root, model_name + ".pth"),
+ device=config.device,
+ is_half=config.is_half,
+ )
+ if inp_root != "":
+ paths = [os.path.join(inp_root, name) for name in os.listdir(inp_root)]
+ else:
+ paths = [path.name for path in paths]
+ for path in paths:
+ inp_path = os.path.join(inp_root, path)
+ need_reformat = 1
+ done = 0
+ try:
+ info = ffmpeg.probe(inp_path, cmd="ffprobe")
+ if (
+ info["streams"][0]["channels"] == 2
+ and info["streams"][0]["sample_rate"] == "44100"
+ ):
+ need_reformat = 0
+ pre_fun._path_audio_(inp_path, save_root_ins, save_root_vocal)
+ done = 1
+ except:
+ need_reformat = 1
+ traceback.print_exc()
+ if need_reformat == 1:
+ tmp_path = "%s/%s.reformatted.wav" % (tmp, os.path.basename(inp_path))
+ os.system(
+ "ffmpeg -i %s -vn -acodec pcm_s16le -ac 2 -ar 44100 %s -y"
+ % (inp_path, tmp_path)
+ )
+ inp_path = tmp_path
+ try:
+ if done == 0:
+ pre_fun._path_audio_(inp_path, save_root_ins, save_root_vocal)
+ infos.append("%s->Success" % (os.path.basename(inp_path)))
+ yield "\n".join(infos)
+ except:
+ infos.append(
+ "%s->%s" % (os.path.basename(inp_path), traceback.format_exc())
+ )
+ yield "\n".join(infos)
+ except:
+ infos.append(traceback.format_exc())
+ yield "\n".join(infos)
+ finally:
+ try:
+ del pre_fun.model
+ del pre_fun
+ except:
+ traceback.print_exc()
+ print("clean_empty_cache")
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ yield "\n".join(infos)
+
+
+# 一个选项卡全局只能有一个音色
+def get_vc(sid):
+ global n_spk, tgt_sr, net_g, vc, cpt, version
+ if sid == "" or sid == []:
+ global hubert_model
+ if hubert_model != None: # 考虑到轮询, 需要加个判断看是否 sid 是由有模型切换到无模型的
+ print("clean_empty_cache")
+ del net_g, n_spk, vc, hubert_model, tgt_sr # ,cpt
+ hubert_model = net_g = n_spk = vc = hubert_model = tgt_sr = None
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ ###楼下不这么折腾清理不干净
+ if_f0 = cpt.get("f0", 1)
+ version = cpt.get("version", "v1")
+ if version == "v1":
+ if if_f0 == 1:
+ net_g = SynthesizerTrnMs256NSFsid(
+ *cpt["config"], is_half=config.is_half
+ )
+ else:
+ net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
+ elif version == "v2":
+ if if_f0 == 1:
+ net_g = SynthesizerTrnMs768NSFsid(
+ *cpt["config"], is_half=config.is_half
+ )
+ else:
+ net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
+ del net_g, cpt
+ if torch.cuda.is_available():
+ torch.cuda.empty_cache()
+ cpt = None
+ return {"visible": False, "__type__": "update"}
+ person = "%s/%s" % (weight_root, sid)
+ print("loading %s" % person)
+ cpt = torch.load(person, map_location="cpu")
+ tgt_sr = cpt["config"][-1]
+ cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
+ if_f0 = cpt.get("f0", 1)
+ version = cpt.get("version", "v1")
+ if version == "v1":
+ if if_f0 == 1:
+ net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
+ else:
+ net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
+ elif version == "v2":
+ if if_f0 == 1:
+ net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
+ else:
+ net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
+ del net_g.enc_q
+ print(net_g.load_state_dict(cpt["weight"], strict=False))
+ net_g.eval().to(config.device)
+ if config.is_half:
+ net_g = net_g.half()
+ else:
+ net_g = net_g.float()
+ vc = VC(tgt_sr, config)
+ n_spk = cpt["config"][-3]
+ return {"visible": True, "maximum": n_spk, "__type__": "update"}
+
+
+def change_choices():
+ names = []
+ for name in os.listdir(weight_root):
+ if name.endswith(".pth"):
+ names.append(name)
+ index_paths = []
+ for root, dirs, files in os.walk(index_root, topdown=False):
+ for name in files:
+ if name.endswith(".index") and "trained" not in name:
+ index_paths.append("%s/%s" % (root, name))
+ return {"choices": sorted(names), "__type__": "update"}, {
+ "choices": sorted(index_paths),
+ "__type__": "update",
+ }
+
+
+def clean():
+ return {"value": "", "__type__": "update"}
+
+
+sr_dict = {
+ "32k": 32000,
+ "40k": 40000,
+ "48k": 48000,
+}
+
+
+def if_done(done, p):
+ while 1:
+ if p.poll() == None:
+ sleep(0.5)
+ else:
+ break
+ done[0] = True
+
+
+def if_done_multi(done, ps):
+ while 1:
+ # poll==None代表进程未结束
+ # 只要有一个进程未结束都不停
+ flag = 1
+ for p in ps:
+ if p.poll() == None:
+ flag = 0
+ sleep(0.5)
+ break
+ if flag == 1:
+ break
+ done[0] = True
+
+
+def preprocess_dataset(trainset_dir, exp_dir, sr, n_p):
+ sr = sr_dict[sr]
+ os.makedirs("%s/logs/%s" % (now_dir, exp_dir), exist_ok=True)
+ f = open("%s/logs/%s/preprocess.log" % (now_dir, exp_dir), "w")
+ f.close()
+ cmd = (
+ config.python_cmd
+ + " trainset_preprocess_pipeline_print.py %s %s %s %s/logs/%s "
+ % (trainset_dir, sr, n_p, now_dir, exp_dir)
+ + str(config.noparallel)
+ )
+ print(cmd)
+ p = Popen(cmd, shell=True) # , stdin=PIPE, stdout=PIPE,stderr=PIPE,cwd=now_dir
+ ###煞笔gr, popen read都非得全跑完了再一次性读取, 不用gr就正常读一句输出一句;只能额外弄出一个文本流定时读
+ done = [False]
+ threading.Thread(
+ target=if_done,
+ args=(
+ done,
+ p,
+ ),
+ ).start()
+ while 1:
+ with open("%s/logs/%s/preprocess.log" % (now_dir, exp_dir), "r") as f:
+ yield (f.read())
+ sleep(1)
+ if done[0] == True:
+ break
+ with open("%s/logs/%s/preprocess.log" % (now_dir, exp_dir), "r") as f:
+ log = f.read()
+ print(log)
+ yield log
+
+
+# but2.click(extract_f0,[gpus6,np7,f0method8,if_f0_3,trainset_dir4],[info2])
+def extract_f0_feature(gpus, n_p, f0method, if_f0, exp_dir, version19):
+ gpus = gpus.split("-")
+ os.makedirs("%s/logs/%s" % (now_dir, exp_dir), exist_ok=True)
+ f = open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "w")
+ f.close()
+ if if_f0:
+ cmd = config.python_cmd + " extract_f0_print.py %s/logs/%s %s %s" % (
+ now_dir,
+ exp_dir,
+ n_p,
+ f0method,
+ )
+ print(cmd)
+ p = Popen(cmd, shell=True, cwd=now_dir) # , stdin=PIPE, stdout=PIPE,stderr=PIPE
+ ###煞笔gr, popen read都非得全跑完了再一次性读取, 不用gr就正常读一句输出一句;只能额外弄出一个文本流定时读
+ done = [False]
+ threading.Thread(
+ target=if_done,
+ args=(
+ done,
+ p,
+ ),
+ ).start()
+ while 1:
+ with open(
+ "%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r"
+ ) as f:
+ yield (f.read())
+ sleep(1)
+ if done[0] == True:
+ break
+ with open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r") as f:
+ log = f.read()
+ print(log)
+ yield log
+ ####对不同part分别开多进程
+ """
+ n_part=int(sys.argv[1])
+ i_part=int(sys.argv[2])
+ i_gpu=sys.argv[3]
+ exp_dir=sys.argv[4]
+ os.environ["CUDA_VISIBLE_DEVICES"]=str(i_gpu)
+ """
+ leng = len(gpus)
+ ps = []
+ for idx, n_g in enumerate(gpus):
+ cmd = (
+ config.python_cmd
+ + " extract_feature_print.py %s %s %s %s %s/logs/%s %s"
+ % (
+ config.device,
+ leng,
+ idx,
+ n_g,
+ now_dir,
+ exp_dir,
+ version19,
+ )
+ )
+ print(cmd)
+ p = Popen(
+ cmd, shell=True, cwd=now_dir
+ ) # , shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, cwd=now_dir
+ ps.append(p)
+ ###煞笔gr, popen read都非得全跑完了再一次性读取, 不用gr就正常读一句输出一句;只能额外弄出一个文本流定时读
+ done = [False]
+ threading.Thread(
+ target=if_done_multi,
+ args=(
+ done,
+ ps,
+ ),
+ ).start()
+ while 1:
+ with open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r") as f:
+ yield (f.read())
+ sleep(1)
+ if done[0] == True:
+ break
+ with open("%s/logs/%s/extract_f0_feature.log" % (now_dir, exp_dir), "r") as f:
+ log = f.read()
+ print(log)
+ yield log
+
+
+def change_sr2(sr2, if_f0_3, version19):
+ vis_v = True if sr2 == "40k" else False
+ if sr2 != "40k":
+ version19 = "v1"
+ path_str = "" if version19 == "v1" else "_v2"
+ version_state = {"visible": vis_v, "__type__": "update"}
+ if vis_v == False:
+ version_state["value"] = "v1"
+ f0_str = "f0" if if_f0_3 else ""
+ return (
+ "pretrained%s/%sG%s.pth" % (path_str, f0_str, sr2),
+ "pretrained%s/%sD%s.pth" % (path_str, f0_str, sr2),
+ version_state,
+ )
+
+
+def change_version19(sr2, if_f0_3, version19):
+ path_str = "" if version19 == "v1" else "_v2"
+ f0_str = "f0" if if_f0_3 else ""
+ return "pretrained%s/%sG%s.pth" % (
+ path_str,
+ f0_str,
+ sr2,
+ ), "pretrained%s/%sD%s.pth" % (path_str, f0_str, sr2)
+
+
+def change_f0(if_f0_3, sr2, version19): # f0method8,pretrained_G14,pretrained_D15
+ path_str = "" if version19 == "v1" else "_v2"
+ if if_f0_3:
+ return (
+ {"visible": True, "__type__": "update"},
+ "pretrained%s/f0G%s.pth" % (path_str, sr2),
+ "pretrained%s/f0D%s.pth" % (path_str, sr2),
+ )
+ return (
+ {"visible": False, "__type__": "update"},
+ "pretrained%s/G%s.pth" % (path_str, sr2),
+ "pretrained%s/D%s.pth" % (path_str, sr2),
+ )
+
+
+# but3.click(click_train,[exp_dir1,sr2,if_f0_3,save_epoch10,total_epoch11,batch_size12,if_save_latest13,pretrained_G14,pretrained_D15,gpus16])
+def click_train(
+ exp_dir1,
+ sr2,
+ if_f0_3,
+ spk_id5,
+ save_epoch10,
+ total_epoch11,
+ batch_size12,
+ if_save_latest13,
+ pretrained_G14,
+ pretrained_D15,
+ gpus16,
+ if_cache_gpu17,
+ if_save_every_weights18,
+ version19,
+):
+ # 生成filelist
+ exp_dir = "%s/logs/%s" % (now_dir, exp_dir1)
+ os.makedirs(exp_dir, exist_ok=True)
+ gt_wavs_dir = "%s/0_gt_wavs" % (exp_dir)
+ feature_dir = (
+ "%s/3_feature256" % (exp_dir)
+ if version19 == "v1"
+ else "%s/3_feature768" % (exp_dir)
+ )
+ if if_f0_3:
+ f0_dir = "%s/2a_f0" % (exp_dir)
+ f0nsf_dir = "%s/2b-f0nsf" % (exp_dir)
+ names = (
+ set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)])
+ & set([name.split(".")[0] for name in os.listdir(feature_dir)])
+ & set([name.split(".")[0] for name in os.listdir(f0_dir)])
+ & set([name.split(".")[0] for name in os.listdir(f0nsf_dir)])
+ )
+ else:
+ names = set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)]) & set(
+ [name.split(".")[0] for name in os.listdir(feature_dir)]
+ )
+ opt = []
+ for name in names:
+ if if_f0_3:
+ opt.append(
+ "%s/%s.wav|%s/%s.npy|%s/%s.wav.npy|%s/%s.wav.npy|%s"
+ % (
+ gt_wavs_dir.replace("\\", "\\\\"),
+ name,
+ feature_dir.replace("\\", "\\\\"),
+ name,
+ f0_dir.replace("\\", "\\\\"),
+ name,
+ f0nsf_dir.replace("\\", "\\\\"),
+ name,
+ spk_id5,
+ )
+ )
+ else:
+ opt.append(
+ "%s/%s.wav|%s/%s.npy|%s"
+ % (
+ gt_wavs_dir.replace("\\", "\\\\"),
+ name,
+ feature_dir.replace("\\", "\\\\"),
+ name,
+ spk_id5,
+ )
+ )
+ fea_dim = 256 if version19 == "v1" else 768
+ if if_f0_3:
+ for _ in range(2):
+ opt.append(
+ "%s/logs/mute/0_gt_wavs/mute%s.wav|%s/logs/mute/3_feature%s/mute.npy|%s/logs/mute/2a_f0/mute.wav.npy|%s/logs/mute/2b-f0nsf/mute.wav.npy|%s"
+ % (now_dir, sr2, now_dir, fea_dim, now_dir, now_dir, spk_id5)
+ )
+ else:
+ for _ in range(2):
+ opt.append(
+ "%s/logs/mute/0_gt_wavs/mute%s.wav|%s/logs/mute/3_feature%s/mute.npy|%s"
+ % (now_dir, sr2, now_dir, fea_dim, spk_id5)
+ )
+ shuffle(opt)
+ with open("%s/filelist.txt" % exp_dir, "w") as f:
+ f.write("\n".join(opt))
+ print("write filelist done")
+ # 生成config#无需生成config
+ # cmd = python_cmd + " train_nsf_sim_cache_sid_load_pretrain.py -e mi-test -sr 40k -f0 1 -bs 4 -g 0 -te 10 -se 5 -pg pretrained/f0G40k.pth -pd pretrained/f0D40k.pth -l 1 -c 0"
+ print("use gpus:", gpus16)
+ if gpus16:
+ cmd = (
+ config.python_cmd
+ + " train_nsf_sim_cache_sid_load_pretrain.py -e %s -sr %s -f0 %s -bs %s -g %s -te %s -se %s -pg %s -pd %s -l %s -c %s -sw %s -v %s"
+ % (
+ exp_dir1,
+ sr2,
+ 1 if if_f0_3 else 0,
+ batch_size12,
+ gpus16,
+ total_epoch11,
+ save_epoch10,
+ pretrained_G14,
+ pretrained_D15,
+ 1 if if_save_latest13 == i18n("是") else 0,
+ 1 if if_cache_gpu17 == i18n("是") else 0,
+ 1 if if_save_every_weights18 == i18n("是") else 0,
+ version19,
+ )
+ )
+ else:
+ cmd = (
+ config.python_cmd
+ + " train_nsf_sim_cache_sid_load_pretrain.py -e %s -sr %s -f0 %s -bs %s -te %s -se %s -pg %s -pd %s -l %s -c %s -sw %s -v %s"
+ % (
+ exp_dir1,
+ sr2,
+ 1 if if_f0_3 else 0,
+ batch_size12,
+ total_epoch11,
+ save_epoch10,
+ pretrained_G14,
+ pretrained_D15,
+ 1 if if_save_latest13 == i18n("是") else 0,
+ 1 if if_cache_gpu17 == i18n("是") else 0,
+ 1 if if_save_every_weights18 == i18n("是") else 0,
+ version19,
+ )
+ )
+ print(cmd)
+ p = Popen(cmd, shell=True, cwd=now_dir)
+ p.wait()
+ return "训练结束, 您可查看控制台训练日志或实验文件夹下的train.log"
+
+
+# but4.click(train_index, [exp_dir1], info3)
+def train_index(exp_dir1, version19):
+ exp_dir = "%s/logs/%s" % (now_dir, exp_dir1)
+ os.makedirs(exp_dir, exist_ok=True)
+ feature_dir = (
+ "%s/3_feature256" % (exp_dir)
+ if version19 == "v1"
+ else "%s/3_feature768" % (exp_dir)
+ )
+ if os.path.exists(feature_dir) == False:
+ return "请先进行特征提取!"
+ listdir_res = list(os.listdir(feature_dir))
+ if len(listdir_res) == 0:
+ return "请先进行特征提取！"
+ npys = []
+ for name in sorted(listdir_res):
+ phone = np.load("%s/%s" % (feature_dir, name))
+ npys.append(phone)
+ big_npy = np.concatenate(npys, 0)
+ big_npy_idx = np.arange(big_npy.shape[0])
+ np.random.shuffle(big_npy_idx)
+ big_npy = big_npy[big_npy_idx]
+ np.save("%s/total_fea.npy" % exp_dir, big_npy)
+ # n_ivf = big_npy.shape[0] // 39
+ n_ivf = min(int(16 * np.sqrt(big_npy.shape[0])), big_npy.shape[0] // 39)
+ infos = []
+ infos.append("%s,%s" % (big_npy.shape, n_ivf))
+ yield "\n".join(infos)
+ index = faiss.index_factory(256 if version19 == "v1" else 768, "IVF%s,Flat" % n_ivf)
+ # index = faiss.index_factory(256if version19=="v1"else 768, "IVF%s,PQ128x4fs,RFlat"%n_ivf)
+ infos.append("training")
+ yield "\n".join(infos)
+ index_ivf = faiss.extract_index_ivf(index) #
+ index_ivf.nprobe = 1
+ index.train(big_npy)
+ faiss.write_index(
+ index,
+ "%s/trained_IVF%s_Flat_nprobe_%s_%s.index"
+ % (exp_dir, n_ivf, index_ivf.nprobe, version19),
+ )
+ # faiss.write_index(index, '%s/trained_IVF%s_Flat_FastScan_%s.index'%(exp_dir,n_ivf,version19))
+ infos.append("adding")
+ yield "\n".join(infos)
+ batch_size_add = 8192
+ for i in range(0, big_npy.shape[0], batch_size_add):
+ index.add(big_npy[i : i + batch_size_add])
+ faiss.write_index(
+ index,
+ "%s/added_IVF%s_Flat_nprobe_%s_%s.index"
+ % (exp_dir, n_ivf, index_ivf.nprobe, version19),
+ )
+ infos.append(
+ "成功构建索引，added_IVF%s_Flat_nprobe_%s_%s.index"
+ % (n_ivf, index_ivf.nprobe, version19)
+ )
+ # faiss.write_index(index, '%s/added_IVF%s_Flat_FastScan_%s.index'%(exp_dir,n_ivf,version19))
+ # infos.append("成功构建索引，added_IVF%s_Flat_FastScan_%s.index"%(n_ivf,version19))
+ yield "\n".join(infos)
+
+
+# but5.click(train1key, [exp_dir1, sr2, if_f0_3, trainset_dir4, spk_id5, gpus6, np7, f0method8, save_epoch10, total_epoch11, batch_size12, if_save_latest13, pretrained_G14, pretrained_D15, gpus16, if_cache_gpu17], info3)
+def train1key(
+ exp_dir1,
+ sr2,
+ if_f0_3,
+ trainset_dir4,
+ spk_id5,
+ np7,
+ f0method8,
+ save_epoch10,
+ total_epoch11,
+ batch_size12,
+ if_save_latest13,
+ pretrained_G14,
+ pretrained_D15,
+ gpus16,
+ if_cache_gpu17,
+ if_save_every_weights18,
+ version19,
+):
+ infos = []
+
+ def get_info_str(strr):
+ infos.append(strr)
+ return "\n".join(infos)
+
+ model_log_dir = "%s/logs/%s" % (now_dir, exp_dir1)
+ preprocess_log_path = "%s/preprocess.log" % model_log_dir
+ extract_f0_feature_log_path = "%s/extract_f0_feature.log" % model_log_dir
+ gt_wavs_dir = "%s/0_gt_wavs" % model_log_dir
+ feature_dir = (
+ "%s/3_feature256" % model_log_dir
+ if version19 == "v1"
+ else "%s/3_feature768" % model_log_dir
+ )
+
+ os.makedirs(model_log_dir, exist_ok=True)
+ #########step1:处理数据
+ open(preprocess_log_path, "w").close()
+ cmd = (
+ config.python_cmd
+ + " trainset_preprocess_pipeline_print.py %s %s %s %s "
+ % (trainset_dir4, sr_dict[sr2], np7, model_log_dir)
+ + str(config.noparallel)
+ )
+ yield get_info_str(i18n("step1:正在处理数据"))
+ yield get_info_str(cmd)
+ p = Popen(cmd, shell=True)
+ p.wait()
+ with open(preprocess_log_path, "r") as f:
+ print(f.read())
+ #########step2a:提取音高
+ open(extract_f0_feature_log_path, "w")
+ if if_f0_3:
+ yield get_info_str("step2a:正在提取音高")
+ cmd = config.python_cmd + " extract_f0_print.py %s %s %s" % (
+ model_log_dir,
+ np7,
+ f0method8,
+ )
+ yield get_info_str(cmd)
+ p = Popen(cmd, shell=True, cwd=now_dir)
+ p.wait()
+ with open(extract_f0_feature_log_path, "r") as f:
+ print(f.read())
+ else:
+ yield get_info_str(i18n("step2a:无需提取音高"))
+ #######step2b:提取特征
+ yield get_info_str(i18n("step2b:正在提取特征"))
+ gpus = gpus16.split("-")
+ leng = len(gpus)
+ ps = []
+ for idx, n_g in enumerate(gpus):
+ cmd = config.python_cmd + " extract_feature_print.py %s %s %s %s %s %s" % (
+ config.device,
+ leng,
+ idx,
+ n_g,
+ model_log_dir,
+ version19,
+ )
+ yield get_info_str(cmd)
+ p = Popen(
+ cmd, shell=True, cwd=now_dir
+ ) # , shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, cwd=now_dir
+ ps.append(p)
+ for p in ps:
+ p.wait()
+ with open(extract_f0_feature_log_path, "r") as f:
+ print(f.read())
+ #######step3a:训练模型
+ yield get_info_str(i18n("step3a:正在训练模型"))
+ # 生成filelist
+ if if_f0_3:
+ f0_dir = "%s/2a_f0" % model_log_dir
+ f0nsf_dir = "%s/2b-f0nsf" % model_log_dir
+ names = (
+ set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)])
+ & set([name.split(".")[0] for name in os.listdir(feature_dir)])
+ & set([name.split(".")[0] for name in os.listdir(f0_dir)])
+ & set([name.split(".")[0] for name in os.listdir(f0nsf_dir)])
+ )
+ else:
+ names = set([name.split(".")[0] for name in os.listdir(gt_wavs_dir)]) & set(
+ [name.split(".")[0] for name in os.listdir(feature_dir)]
+ )
+ opt = []
+ for name in names:
+ if if_f0_3:
+ opt.append(
+ "%s/%s.wav|%s/%s.npy|%s/%s.wav.npy|%s/%s.wav.npy|%s"
+ % (
+ gt_wavs_dir.replace("\\", "\\\\"),
+ name,
+ feature_dir.replace("\\", "\\\\"),
+ name,
+ f0_dir.replace("\\", "\\\\"),
+ name,
+ f0nsf_dir.replace("\\", "\\\\"),
+ name,
+ spk_id5,
+ )
+ )
+ else:
+ opt.append(
+ "%s/%s.wav|%s/%s.npy|%s"
+ % (
+ gt_wavs_dir.replace("\\", "\\\\"),
+ name,
+ feature_dir.replace("\\", "\\\\"),
+ name,
+ spk_id5,
+ )
+ )
+ fea_dim = 256 if version19 == "v1" else 768
+ if if_f0_3:
+ for _ in range(2):
+ opt.append(
+ "%s/logs/mute/0_gt_wavs/mute%s.wav|%s/logs/mute/3_feature%s/mute.npy|%s/logs/mute/2a_f0/mute.wav.npy|%s/logs/mute/2b-f0nsf/mute.wav.npy|%s"
+ % (now_dir, sr2, now_dir, fea_dim, now_dir, now_dir, spk_id5)
+ )
+ else:
+ for _ in range(2):
+ opt.append(
+ "%s/logs/mute/0_gt_wavs/mute%s.wav|%s/logs/mute/3_feature%s/mute.npy|%s"
+ % (now_dir, sr2, now_dir, fea_dim, spk_id5)
+ )
+ shuffle(opt)
+ with open("%s/filelist.txt" % model_log_dir, "w") as f:
+ f.write("\n".join(opt))
+ yield get_info_str("write filelist done")
+ if gpus16:
+ cmd = (
+ config.python_cmd
+ + " train_nsf_sim_cache_sid_load_pretrain.py -e %s -sr %s -f0 %s -bs %s -g %s -te %s -se %s -pg %s -pd %s -l %s -c %s -sw %s -v %s"
+ % (
+ exp_dir1,
+ sr2,
+ 1 if if_f0_3 else 0,
+ batch_size12,
+ gpus16,
+ total_epoch11,
+ save_epoch10,
+ pretrained_G14,
+ pretrained_D15,
+ 1 if if_save_latest13 == i18n("是") else 0,
+ 1 if if_cache_gpu17 == i18n("是") else 0,
+ 1 if if_save_every_weights18 == i18n("是") else 0,
+ version19,
+ )
+ )
+ else:
+ cmd = (
+ config.python_cmd
+ + " train_nsf_sim_cache_sid_load_pretrain.py -e %s -sr %s -f0 %s -bs %s -te %s -se %s -pg %s -pd %s -l %s -c %s -sw %s -v %s"
+ % (
+ exp_dir1,
+ sr2,
+ 1 if if_f0_3 else 0,
+ batch_size12,
+ total_epoch11,
+ save_epoch10,
+ pretrained_G14,
+ pretrained_D15,
+ 1 if if_save_latest13 == i18n("是") else 0,
+ 1 if if_cache_gpu17 == i18n("是") else 0,
+ 1 if if_save_every_weights18 == i18n("是") else 0,
+ version19,
+ )
+ )
+ yield get_info_str(cmd)
+ p = Popen(cmd, shell=True, cwd=now_dir)
+ p.wait()
+ yield get_info_str(i18n("训练结束, 您可查看控制台训练日志或实验文件夹下的train.log"))
+ #######step3b:训练索引
+ npys = []
+ listdir_res = list(os.listdir(feature_dir))
+ for name in sorted(listdir_res):
+ phone = np.load("%s/%s" % (feature_dir, name))
+ npys.append(phone)
+ big_npy = np.concatenate(npys, 0)
+
+ big_npy_idx = np.arange(big_npy.shape[0])
+ np.random.shuffle(big_npy_idx)
+ big_npy = big_npy[big_npy_idx]
+ np.save("%s/total_fea.npy" % model_log_dir, big_npy)
+
+ # n_ivf = big_npy.shape[0] // 39
+ n_ivf = min(int(16 * np.sqrt(big_npy.shape[0])), big_npy.shape[0] // 39)
+ yield get_info_str("%s,%s" % (big_npy.shape, n_ivf))
+ index = faiss.index_factory(256 if version19 == "v1" else 768, "IVF%s,Flat" % n_ivf)
+ yield get_info_str("training index")
+ index_ivf = faiss.extract_index_ivf(index) #
+ index_ivf.nprobe = 1
+ index.train(big_npy)
+ faiss.write_index(
+ index,
+ "%s/trained_IVF%s_Flat_nprobe_%s_%s.index"
+ % (model_log_dir, n_ivf, index_ivf.nprobe, version19),
+ )
+ yield get_info_str("adding index")
+ batch_size_add = 8192
+ for i in range(0, big_npy.shape[0], batch_size_add):
+ index.add(big_npy[i : i + batch_size_add])
+ faiss.write_index(
+ index,
+ "%s/added_IVF%s_Flat_nprobe_%s_%s.index"
+ % (model_log_dir, n_ivf, index_ivf.nprobe, version19),
+ )
+ yield get_info_str(
+ "成功构建索引, added_IVF%s_Flat_nprobe_%s_%s.index"
+ % (n_ivf, index_ivf.nprobe, version19)
+ )
+ yield get_info_str(i18n("全流程结束！"))
+
+
+# ckpt_path2.change(change_info_,[ckpt_path2],[sr__,if_f0__])
+def change_info_(ckpt_path):
+ if (
+ os.path.exists(ckpt_path.replace(os.path.basename(ckpt_path), "train.log"))
+ == False
+ ):
+ return {"__type__": "update"}, {"__type__": "update"}, {"__type__": "update"}
+ try:
+ with open(
+ ckpt_path.replace(os.path.basename(ckpt_path), "train.log"), "r"
+ ) as f:
+ info = eval(f.read().strip("\n").split("\n")[0].split("\t")[-1])
+ sr, f0 = info["sample_rate"], info["if_f0"]
+ version = "v2" if ("version" in info and info["version"] == "v2") else "v1"
+ return sr, str(f0), version
+ except:
+ traceback.print_exc()
+ return {"__type__": "update"}, {"__type__": "update"}, {"__type__": "update"}
+
+
+from infer_pack.models_onnx_moess import SynthesizerTrnMs256NSFsidM
+from infer_pack.models_onnx import SynthesizerTrnMs256NSFsidO
+
+
+def export_onnx(ModelPath, ExportedPath, MoeVS=True):
+ hidden_channels = 256 # hidden_channels，为768Vec做准备
+ cpt = torch.load(ModelPath, map_location="cpu")
+ cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
+ print(*cpt["config"])
+
+ test_phone = torch.rand(1, 200, hidden_channels) # hidden unit
+ test_phone_lengths = torch.tensor([200]).long() # hidden unit 长度（貌似没啥用）
+ test_pitch = torch.randint(size=(1, 200), low=5, high=255) # 基频（单位赫兹）
+ test_pitchf = torch.rand(1, 200) # nsf基频
+ test_ds = torch.LongTensor([0]) # 说话人ID
+ test_rnd = torch.rand(1, 192, 200) # 噪声（加入随机因子）
+
+ device = "cpu" # 导出时设备（不影响使用模型）
+
+ if MoeVS:
+ net_g = SynthesizerTrnMs256NSFsidM(
+ *cpt["config"], is_half=False
+ ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
+ net_g.load_state_dict(cpt["weight"], strict=False)
+ input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
+ output_names = [
+ "audio",
+ ]
+ torch.onnx.export(
+ net_g,
+ (
+ test_phone.to(device),
+ test_phone_lengths.to(device),
+ test_pitch.to(device),
+ test_pitchf.to(device),
+ test_ds.to(device),
+ test_rnd.to(device),
+ ),
+ ExportedPath,
+ dynamic_axes={
+ "phone": [1],
+ "pitch": [1],
+ "pitchf": [1],
+ "rnd": [2],
+ },
+ do_constant_folding=False,
+ opset_version=16,
+ verbose=False,
+ input_names=input_names,
+ output_names=output_names,
+ )
+ else:
+ net_g = SynthesizerTrnMs256NSFsidO(
+ *cpt["config"], is_half=False
+ ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
+ net_g.load_state_dict(cpt["weight"], strict=False)
+ input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds"]
+ output_names = [
+ "audio",
+ ]
+ torch.onnx.export(
+ net_g,
+ (
+ test_phone.to(device),
+ test_phone_lengths.to(device),
+ test_pitch.to(device),
+ test_pitchf.to(device),
+ test_ds.to(device),
+ ),
+ ExportedPath,
+ dynamic_axes={
+ "phone": [1],
+ "pitch": [1],
+ "pitchf": [1],
+ },
+ do_constant_folding=False,
+ opset_version=16,
+ verbose=False,
+ input_names=input_names,
+ output_names=output_names,
+ )
+ return "Finished"
+
+
+with gr.Blocks() as app:
+ gr.Markdown(
+ value=i18n(
+ "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责.
如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录使用需遵守的协议-LICENSE.txt."
+ )
+ )
+ with gr.Tabs():
+ with gr.TabItem(i18n("模型推理")):
+ with gr.Row():
+ sid0 = gr.Dropdown(label=i18n("推理音色"), choices=sorted(names))
+ refresh_button = gr.Button(i18n("刷新音色列表和索引路径"), variant="primary")
+ clean_button = gr.Button(i18n("卸载音色省显存"), variant="primary")
+ spk_item = gr.Slider(
+ minimum=0,
+ maximum=2333,
+ step=1,
+ label=i18n("请选择说话人id"),
+ value=0,
+ visible=False,
+ interactive=True,
+ )
+ clean_button.click(fn=clean, inputs=[], outputs=[sid0])
+ sid0.change(
+ fn=get_vc,
+ inputs=[sid0],
+ outputs=[spk_item],
+ )
+ with gr.Group():
+ gr.Markdown(
+ value=i18n("男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ")
+ )
+ with gr.Row():
+ with gr.Column():
+ vc_transform0 = gr.Number(
+ label=i18n("变调(整数, 半音数量, 升八度12降八度-12)"), value=0
+ )
+ input_audio0 = gr.Textbox(
+ label=i18n("输入待处理音频文件路径(默认是正确格式示例)"),
+ value="E:\\codes\\py39\\test-20230416b\\todo-songs\\冬之花clip1.wav",
+ )
+ f0method0 = gr.Radio(
+ label=i18n("选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比"),
+ choices=["pm", "harvest"],
+ value="pm",
+ interactive=True,
+ )
+ filter_radius0 = gr.Slider(
+ minimum=0,
+ maximum=7,
+ label=i18n(">=3则使用对harvest音高识别的结果使用中值滤波，数值为滤波半径，使用可以削弱哑音"),
+ value=3,
+ step=1,
+ interactive=True,
+ )
+ with gr.Column():
+ file_index1 = gr.Textbox(
+ label=i18n("特征检索库文件路径,为空则使用下拉的选择结果"),
+ value="",
+ interactive=True,
+ )
+ file_index2 = gr.Dropdown(
+ label=i18n("自动检测index路径,下拉式选择(dropdown)"),
+ choices=sorted(index_paths),
+ interactive=True,
+ )
+ refresh_button.click(
+ fn=change_choices, inputs=[], outputs=[sid0, file_index2]
+ )
+ # file_big_npy1 = gr.Textbox(
+ # label=i18n("特征文件路径"),
+ # value="E:\\codes\py39\\vits_vc_gpu_train\\logs\\mi-test-1key\\total_fea.npy",
+ # interactive=True,
+ # )
+ index_rate1 = gr.Slider(
+ minimum=0,
+ maximum=1,
+ label=i18n("检索特征占比"),
+ value=0.76,
+ interactive=True,
+ )
+ resample_sr0 = gr.Slider(
+ minimum=0,
+ maximum=48000,
+ label=i18n("后处理重采样至最终采样率，0为不进行重采样"),
+ value=0,
+ step=1,
+ interactive=True,
+ )
+ rms_mix_rate0 = gr.Slider(
+ minimum=0,
+ maximum=1,
+ label=i18n("输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络"),
+ value=1,
+ interactive=True,
+ )
+ f0_file = gr.File(label=i18n("F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调"))
+ but0 = gr.Button(i18n("转换"), variant="primary")
+ with gr.Column():
+ vc_output1 = gr.Textbox(label=i18n("输出信息"))
+ vc_output2 = gr.Audio(label=i18n("输出音频(右下角三个点,点了可以下载)"))
+ but0.click(
+ vc_single,
+ [
+ spk_item,
+ input_audio0,
+ vc_transform0,
+ f0_file,
+ f0method0,
+ file_index1,
+ file_index2,
+ # file_big_npy1,
+ index_rate1,
+ filter_radius0,
+ resample_sr0,
+ rms_mix_rate0,
+ ],
+ [vc_output1, vc_output2],
+ )
+ with gr.Group():
+ gr.Markdown(
+ value=i18n("批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ")
+ )
+ with gr.Row():
+ with gr.Column():
+ vc_transform1 = gr.Number(
+ label=i18n("变调(整数, 半音数量, 升八度12降八度-12)"), value=0
+ )
+ opt_input = gr.Textbox(label=i18n("指定输出文件夹"), value="opt")
+ f0method1 = gr.Radio(
+ label=i18n("选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比"),
+ choices=["pm", "harvest"],
+ value="pm",
+ interactive=True,
+ )
+ filter_radius1 = gr.Slider(
+ minimum=0,
+ maximum=7,
+ label=i18n(">=3则使用对harvest音高识别的结果使用中值滤波，数值为滤波半径，使用可以削弱哑音"),
+ value=3,
+ step=1,
+ interactive=True,
+ )
+ with gr.Column():
+ file_index3 = gr.Textbox(
+ label=i18n("特征检索库文件路径,为空则使用下拉的选择结果"),
+ value="",
+ interactive=True,
+ )
+ file_index4 = gr.Dropdown(
+ label=i18n("自动检测index路径,下拉式选择(dropdown)"),
+ choices=sorted(index_paths),
+ interactive=True,
+ )
+ # file_big_npy2 = gr.Textbox(
+ # label=i18n("特征文件路径"),
+ # value="E:\\codes\\py39\\vits_vc_gpu_train\\logs\\mi-test-1key\\total_fea.npy",
+ # interactive=True,
+ # )
+ index_rate2 = gr.Slider(
+ minimum=0,
+ maximum=1,
+ label=i18n("检索特征占比"),
+ value=1,
+ interactive=True,
+ )
+ resample_sr1 = gr.Slider(
+ minimum=0,
+ maximum=48000,
+ label=i18n("后处理重采样至最终采样率，0为不进行重采样"),
+ value=0,
+ step=1,
+ interactive=True,
+ )
+ rms_mix_rate1 = gr.Slider(
+ minimum=0,
+ maximum=1,
+ label=i18n("输入源音量包络替换输出音量包络融合比例，越靠近1越使用输出包络"),
+ value=1,
+ interactive=True,
+ )
+ with gr.Column():
+ dir_input = gr.Textbox(
+ label=i18n("输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)"),
+ value="E:\codes\py39\\test-20230416b\\todo-songs",
+ )
+ inputs = gr.File(
+ file_count="multiple", label=i18n("也可批量输入音频文件, 二选一, 优先读文件夹")
+ )
+ but1 = gr.Button(i18n("转换"), variant="primary")
+ vc_output3 = gr.Textbox(label=i18n("输出信息"))
+ but1.click(
+ vc_multi,
+ [
+ spk_item,
+ dir_input,
+ opt_input,
+ inputs,
+ vc_transform1,
+ f0method1,
+ file_index3,
+ file_index4,
+ # file_big_npy2,
+ index_rate2,
+ filter_radius1,
+ resample_sr1,
+ rms_mix_rate1,
+ ],
+ [vc_output3],
+ )
+ with gr.TabItem(i18n("伴奏人声分离")):
+ with gr.Group():
+ gr.Markdown(
+ value=i18n(
+ "人声伴奏分离批量处理, 使用UVR5模型.
不带和声用HP2, 带和声且提取的人声不需要和声用HP5
合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)"
+ )
+ )
+ with gr.Row():
+ with gr.Column():
+ dir_wav_input = gr.Textbox(
+ label=i18n("输入待处理音频文件夹路径"),
+ value="E:\\codes\\py39\\test-20230416b\\todo-songs\\todo-songs",
+ )
+ wav_inputs = gr.File(
+ file_count="multiple", label=i18n("也可批量输入音频文件, 二选一, 优先读文件夹")
+ )
+ with gr.Column():
+ model_choose = gr.Dropdown(label=i18n("模型"), choices=uvr5_names)
+ agg = gr.Slider(
+ minimum=0,
+ maximum=20,
+ step=1,
+ label="人声提取激进程度",
+ value=10,
+ interactive=True,
+ visible=False, # 先不开放调整
+ )
+ opt_vocal_root = gr.Textbox(
+ label=i18n("指定输出人声文件夹"), value="opt"
+ )
+ opt_ins_root = gr.Textbox(label=i18n("指定输出乐器文件夹"), value="opt")
+ but2 = gr.Button(i18n("转换"), variant="primary")
+ vc_output4 = gr.Textbox(label=i18n("输出信息"))
+ but2.click(
+ uvr,
+ [
+ model_choose,
+ dir_wav_input,
+ opt_vocal_root,
+ wav_inputs,
+ opt_ins_root,
+ agg,
+ ],
+ [vc_output4],
+ )
+ with gr.TabItem(i18n("训练")):
+ gr.Markdown(
+ value=i18n(
+ "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. "
+ )
+ )
+ with gr.Row():
+ exp_dir1 = gr.Textbox(label=i18n("输入实验名"), value="mi-test")
+ sr2 = gr.Radio(
+ label=i18n("目标采样率"),
+ choices=["32k", "40k", "48k"],
+ value="40k",
+ interactive=True,
+ )
+ if_f0_3 = gr.Radio(
+ label=i18n("模型是否带音高指导(唱歌一定要, 语音可以不要)"),
+ choices=[True, False],
+ value=True,
+ interactive=True,
+ )
+ version19 = gr.Radio(
+ label=i18n("版本(目前仅40k支持了v2)"),
+ choices=["v1", "v2"],
+ value="v1",
+ interactive=True,
+ visible=True,
+ )
+ np7 = gr.Slider(
+ minimum=0,
+ maximum=config.n_cpu,
+ step=1,
+ label=i18n("提取音高和处理数据使用的CPU进程数"),
+ value=config.n_cpu,
+ interactive=True,
+ )
+ with gr.Group(): # 暂时单人的, 后面支持最多4人的#数据处理
+ gr.Markdown(
+ value=i18n(
+ "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. "
+ )
+ )
+ with gr.Row():
+ trainset_dir4 = gr.Textbox(
+ label=i18n("输入训练文件夹路径"), value="E:\\语音音频+标注\\米津玄师\\src"
+ )
+ spk_id5 = gr.Slider(
+ minimum=0,
+ maximum=4,
+ step=1,
+ label=i18n("请指定说话人id"),
+ value=0,
+ interactive=True,
+ )
+ but1 = gr.Button(i18n("处理数据"), variant="primary")
+ info1 = gr.Textbox(label=i18n("输出信息"), value="")
+ but1.click(
+ preprocess_dataset, [trainset_dir4, exp_dir1, sr2, np7], [info1]
+ )
+ with gr.Group():
+ gr.Markdown(value=i18n("step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)"))
+ with gr.Row():
+ with gr.Column():
+ gpus6 = gr.Textbox(
+ label=i18n("以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2"),
+ value=gpus,
+ interactive=True,
+ )
+ gpu_info9 = gr.Textbox(label=i18n("显卡信息"), value=gpu_info)
+ with gr.Column():
+ f0method8 = gr.Radio(
+ label=i18n(
+ "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢"
+ ),
+ choices=["pm", "harvest", "dio"],
+ value="harvest",
+ interactive=True,
+ )
+ but2 = gr.Button(i18n("特征提取"), variant="primary")
+ info2 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
+ but2.click(
+ extract_f0_feature,
+ [gpus6, np7, f0method8, if_f0_3, exp_dir1, version19],
+ [info2],
+ )
+ with gr.Group():
+ gr.Markdown(value=i18n("step3: 填写训练设置, 开始训练模型和索引"))
+ with gr.Row():
+ save_epoch10 = gr.Slider(
+ minimum=0,
+ maximum=50,
+ step=1,
+ label=i18n("保存频率save_every_epoch"),
+ value=5,
+ interactive=True,
+ )
+ total_epoch11 = gr.Slider(
+ minimum=0,
+ maximum=1000,
+ step=1,
+ label=i18n("总训练轮数total_epoch"),
+ value=20,
+ interactive=True,
+ )
+ batch_size12 = gr.Slider(
+ minimum=1,
+ maximum=40,
+ step=1,
+ label=i18n("每张显卡的batch_size"),
+ value=default_batch_size,
+ interactive=True,
+ )
+ if_save_latest13 = gr.Radio(
+ label=i18n("是否仅保存最新的ckpt文件以节省硬盘空间"),
+ choices=[i18n("是"), i18n("否")],
+ value=i18n("否"),
+ interactive=True,
+ )
+ if_cache_gpu17 = gr.Radio(
+ label=i18n(
+ "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速"
+ ),
+ choices=[i18n("是"), i18n("否")],
+ value=i18n("否"),
+ interactive=True,
+ )
+ if_save_every_weights18 = gr.Radio(
+ label=i18n("是否在每次保存时间点将最终小模型保存至weights文件夹"),
+ choices=[i18n("是"), i18n("否")],
+ value=i18n("否"),
+ interactive=True,
+ )
+ with gr.Row():
+ pretrained_G14 = gr.Textbox(
+ label=i18n("加载预训练底模G路径"),
+ value="pretrained/f0G40k.pth",
+ interactive=True,
+ )
+ pretrained_D15 = gr.Textbox(
+ label=i18n("加载预训练底模D路径"),
+ value="pretrained/f0D40k.pth",
+ interactive=True,
+ )
+ sr2.change(
+ change_sr2,
+ [sr2, if_f0_3, version19],
+ [pretrained_G14, pretrained_D15, version19],
+ )
+ version19.change(
+ change_version19,
+ [sr2, if_f0_3, version19],
+ [pretrained_G14, pretrained_D15],
+ )
+ if_f0_3.change(
+ change_f0,
+ [if_f0_3, sr2, version19],
+ [f0method8, pretrained_G14, pretrained_D15],
+ )
+ gpus16 = gr.Textbox(
+ label=i18n("以-分隔输入使用的卡号, 例如 0-1-2 使用卡0和卡1和卡2"),
+ value=gpus,
+ interactive=True,
+ )
+ but3 = gr.Button(i18n("训练模型"), variant="primary")
+ but4 = gr.Button(i18n("训练特征索引"), variant="primary")
+ but5 = gr.Button(i18n("一键训练"), variant="primary")
+ info3 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=10)
+ but3.click(
+ click_train,
+ [
+ exp_dir1,
+ sr2,
+ if_f0_3,
+ spk_id5,
+ save_epoch10,
+ total_epoch11,
+ batch_size12,
+ if_save_latest13,
+ pretrained_G14,
+ pretrained_D15,
+ gpus16,
+ if_cache_gpu17,
+ if_save_every_weights18,
+ version19,
+ ],
+ info3,
+ )
+ but4.click(train_index, [exp_dir1, version19], info3)
+ but5.click(
+ train1key,
+ [
+ exp_dir1,
+ sr2,
+ if_f0_3,
+ trainset_dir4,
+ spk_id5,
+ np7,
+ f0method8,
+ save_epoch10,
+ total_epoch11,
+ batch_size12,
+ if_save_latest13,
+ pretrained_G14,
+ pretrained_D15,
+ gpus16,
+ if_cache_gpu17,
+ if_save_every_weights18,
+ version19,
+ ],
+ info3,
+ )
+
+ with gr.TabItem(i18n("ckpt处理")):
+ with gr.Group():
+ gr.Markdown(value=i18n("模型融合, 可用于测试音色融合"))
+ with gr.Row():
+ ckpt_a = gr.Textbox(label=i18n("A模型路径"), value="", interactive=True)
+ ckpt_b = gr.Textbox(label=i18n("B模型路径"), value="", interactive=True)
+ alpha_a = gr.Slider(
+ minimum=0,
+ maximum=1,
+ label=i18n("A模型权重"),
+ value=0.5,
+ interactive=True,
+ )
+ with gr.Row():
+ sr_ = gr.Radio(
+ label=i18n("目标采样率"),
+ choices=["32k", "40k", "48k"],
+ value="40k",
+ interactive=True,
+ )
+ if_f0_ = gr.Radio(
+ label=i18n("模型是否带音高指导"),
+ choices=[i18n("是"), i18n("否")],
+ value=i18n("是"),
+ interactive=True,
+ )
+ info__ = gr.Textbox(
+ label=i18n("要置入的模型信息"), value="", max_lines=8, interactive=True
+ )
+ name_to_save0 = gr.Textbox(
+ label=i18n("保存的模型名不带后缀"),
+ value="",
+ max_lines=1,
+ interactive=True,
+ )
+ version_2 = gr.Radio(
+ label=i18n("模型版本型号"),
+ choices=["v1", "v2"],
+ value="v1",
+ interactive=True,
+ )
+ with gr.Row():
+ but6 = gr.Button(i18n("融合"), variant="primary")
+ info4 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
+ but6.click(
+ merge,
+ [
+ ckpt_a,
+ ckpt_b,
+ alpha_a,
+ sr_,
+ if_f0_,
+ info__,
+ name_to_save0,
+ version_2,
+ ],
+ info4,
+ ) # def merge(path1,path2,alpha1,sr,f0,info):
+ with gr.Group():
+ gr.Markdown(value=i18n("修改模型信息(仅支持weights文件夹下提取的小模型文件)"))
+ with gr.Row():
+ ckpt_path0 = gr.Textbox(
+ label=i18n("模型路径"), value="", interactive=True
+ )
+ info_ = gr.Textbox(
+ label=i18n("要改的模型信息"), value="", max_lines=8, interactive=True
+ )
+ name_to_save1 = gr.Textbox(
+ label=i18n("保存的文件名, 默认空为和源文件同名"),
+ value="",
+ max_lines=8,
+ interactive=True,
+ )
+ with gr.Row():
+ but7 = gr.Button(i18n("修改"), variant="primary")
+ info5 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
+ but7.click(change_info, [ckpt_path0, info_, name_to_save1], info5)
+ with gr.Group():
+ gr.Markdown(value=i18n("查看模型信息(仅支持weights文件夹下提取的小模型文件)"))
+ with gr.Row():
+ ckpt_path1 = gr.Textbox(
+ label=i18n("模型路径"), value="", interactive=True
+ )
+ but8 = gr.Button(i18n("查看"), variant="primary")
+ info6 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
+ but8.click(show_info, [ckpt_path1], info6)
+ with gr.Group():
+ gr.Markdown(
+ value=i18n(
+ "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况"
+ )
+ )
+ with gr.Row():
+ ckpt_path2 = gr.Textbox(
+ label=i18n("模型路径"),
+ value="E:\\codes\\py39\\logs\\mi-test_f0_48k\\G_23333.pth",
+ interactive=True,
+ )
+ save_name = gr.Textbox(
+ label=i18n("保存名"), value="", interactive=True
+ )
+ sr__ = gr.Radio(
+ label=i18n("目标采样率"),
+ choices=["32k", "40k", "48k"],
+ value="40k",
+ interactive=True,
+ )
+ if_f0__ = gr.Radio(
+ label=i18n("模型是否带音高指导,1是0否"),
+ choices=["1", "0"],
+ value="1",
+ interactive=True,
+ )
+ version_1 = gr.Radio(
+ label=i18n("模型版本型号"),
+ choices=["v1", "v2"],
+ value="v1",
+ interactive=True,
+ )
+ info___ = gr.Textbox(
+ label=i18n("要置入的模型信息"), value="", max_lines=8, interactive=True
+ )
+ but9 = gr.Button(i18n("提取"), variant="primary")
+ info7 = gr.Textbox(label=i18n("输出信息"), value="", max_lines=8)
+ ckpt_path2.change(
+ change_info_, [ckpt_path2], [sr__, if_f0__, version_1]
+ )
+ but9.click(
+ extract_small_model,
+ [ckpt_path2, save_name, sr__, if_f0__, info___, version_1],
+ info7,
+ )
+
+ with gr.TabItem(i18n("Onnx导出")):
+ with gr.Row():
+ ckpt_dir = gr.Textbox(label=i18n("RVC模型路径"), value="", interactive=True)
+ with gr.Row():
+ onnx_dir = gr.Textbox(
+ label=i18n("Onnx输出路径"), value="", interactive=True
+ )
+ with gr.Row():
+ moevs = gr.Checkbox(label=i18n("MoeVS模型"), value=True)
+ infoOnnx = gr.Label(label="Null")
+ with gr.Row():
+ butOnnx = gr.Button(i18n("导出Onnx模型"), variant="primary")
+ butOnnx.click(export_onnx, [ckpt_dir, onnx_dir, moevs], infoOnnx)
+
+ tab_faq = i18n("常见问题解答")
+ with gr.TabItem(tab_faq):
+ try:
+ if tab_faq == "常见问题解答":
+ with open("docs/faq.md", "r", encoding="utf8") as f:
+ info = f.read()
+ else:
+ with open("docs/faq_en.md", "r", encoding="utf8") as f:
+ info = f.read()
+ gr.Markdown(value=info)
+ except:
+ gr.Markdown(traceback.format_exc())
+
+ # with gr.TabItem(i18n("招募音高曲线前端编辑器")):
+ # gr.Markdown(value=i18n("加开发群联系我xxxxx"))
+ # with gr.TabItem(i18n("点击查看交流、问题反馈群号")):
+ # gr.Markdown(value=i18n("xxxxx"))
+
+ if config.iscolab:
+ app.queue(concurrency_count=511, max_size=1022).launch(share=True)
+ else:
+ app.queue(concurrency_count=511, max_size=1022).launch(
+ server_name="0.0.0.0",
+ inbrowser=not config.noautoopen,
+ server_port=config.listen_port,
+ quiet=True,
+ )
From 79a79c3b99cfe4d0e27d4c2bcd26dd420f190583 Mon Sep 17 00:00:00 2001
From: RVC-Boss <129054828+RVC-Boss@users.noreply.github.com>
Date: Sun, 21 May 2023 03:30:27 +0000
Subject: [PATCH 06/16] Update config.py
---
config.py | 22 +++++++++++++---------
1 file changed, 13 insertions(+), 9 deletions(-)
diff --git a/config.py b/config.py
index 7ea4c06..8e6fa22 100644
--- a/config.py
+++ b/config.py
@@ -2,6 +2,16 @@ import argparse
import torch
from multiprocessing import cpu_count
+def config_file_change_fp32():
+ for config_file in ["32k.json", "40k.json", "48k.json"]:
+ with open(f"configs/{config_file}", "r") as f:
+ strr = f.read().replace("true", "false")
+ with open(f"configs/{config_file}", "w") as f:
+ f.write(strr)
+ with open("trainset_preprocess_pipeline_print.py", "r") as f:
+ strr = f.read().replace("3.7", "3.0")
+ with open("trainset_preprocess_pipeline_print.py", "w") as f:
+ f.write(strr)
class Config:
def __init__(self):
@@ -60,15 +70,7 @@ class Config:
):
print("16系/10系显卡和P40强制单精度")
self.is_half = False
- for config_file in ["32k.json", "40k.json", "48k.json"]:
- with open(f"configs/{config_file}", "r") as f:
- strr = f.read().replace("true", "false")
- with open(f"configs/{config_file}", "w") as f:
- f.write(strr)
- with open("trainset_preprocess_pipeline_print.py", "r") as f:
- strr = f.read().replace("3.7", "3.0")
- with open("trainset_preprocess_pipeline_print.py", "w") as f:
- f.write(strr)
+ config_file_change_fp32()
else:
self.gpu_name = None
self.gpu_mem = int(
@@ -87,10 +89,12 @@ class Config:
print("没有发现支持的N卡, 使用MPS进行推理")
self.device = "mps"
self.is_half = False
+ config_file_change_fp32()
else:
print("没有发现支持的N卡, 使用CPU进行推理")
self.device = "cpu"
self.is_half = False
+ config_file_change_fp32()
if self.n_cpu == 0:
self.n_cpu = cpu_count()
From 615c30c17b771691e827bf3085e042d4162cf367 Mon Sep 17 00:00:00 2001
From: RVC-Boss <129054828+RVC-Boss@users.noreply.github.com>
Date: Sun, 21 May 2023 06:57:16 +0000
Subject: [PATCH 07/16] Update gui.py
---
gui.py | 85 +++++++++++++++++++++++++++++++++++++---------------------
1 file changed, 55 insertions(+), 30 deletions(-)
diff --git a/gui.py b/gui.py
index 1aed430..81d4d73 100644
--- a/gui.py
+++ b/gui.py
@@ -1,7 +1,20 @@
-import os, sys, traceback
+'''
+0416后的更新：
+ 引入config中half
+ 重建npy而不用填写
+ v2支持
+ 无f0模型支持
+ 修复
+ int16：
+ 增加无索引支持
+ f0算法改harvest(怎么看就只有这个会影响CPU占用)，但是不这么改效果不好
+'''
+import os, sys, traceback
now_dir = os.getcwd()
sys.path.append(now_dir)
+from config import Config
+is_half=Config().is_half
import PySimpleGUI as sg
import sounddevice as sd
import noisereduce as nr
@@ -13,7 +26,7 @@ import torchaudio.transforms as tat
import scipy.signal as signal
# import matplotlib.pyplot as plt
-from infer_pack.models import SynthesizerTrnMs256NSFsid, SynthesizerTrnMs256NSFsid_nono
+from infer_pack.models import SynthesizerTrnMs256NSFsid, SynthesizerTrnMs256NSFsid_nono,SynthesizerTrnMs768NSFsid,SynthesizerTrnMs768NSFsid_nono
from i18n import I18nAuto
i18n = I18nAuto()
@@ -50,20 +63,33 @@ class RVC:
)
self.model = models[0]
self.model = self.model.to(device)
- self.model = self.model.half()
+ if(is_half==True):
+ self.model = self.model.half()
+ else:
+ self.model = self.model.float()
self.model.eval()
cpt = torch.load(pth_path, map_location="cpu")
self.tgt_sr = cpt["config"][-1]
cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
self.if_f0 = cpt.get("f0", 1)
- if self.if_f0 == 1:
- self.net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=True)
- else:
- self.net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
+ self.version = cpt.get("version", "v1")
+ if version == "v1":
+ if if_f0 == 1:
+ net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
+ else:
+ net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
+ elif version == "v2":
+ if if_f0 == 1:
+ net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
+ else:
+ net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
del self.net_g.enc_q
print(self.net_g.load_state_dict(cpt["weight"], strict=False))
self.net_g.eval().to(device)
- self.net_g.half()
+ if(is_half==True):
+ self.net_g=self.net_g.half()
+ else:
+ self.net_g=self.net_g.float()
except:
print(traceback.format_exc())
@@ -116,34 +142,33 @@ class RVC:
inputs = {
"source": feats.half().to(device),
"padding_mask": padding_mask.to(device),
- "output_layer": 9, # layer 9
+ "output_layer": 9 if self.version == "v1" else 12,
}
torch.cuda.synchronize()
with torch.no_grad():
logits = self.model.extract_features(**inputs)
- feats = self.model.final_proj(logits[0])
+ feats = model.final_proj(logits[0]) if self.version == "v1" else logits[0]
####索引优化
- if hasattr(self, "index") and hasattr(self, "big_npy") and self.index_rate != 0:
- npy = feats[0].cpu().numpy().astype("float32")
-
- # _, I = self.index.search(npy, 1)
- # npy = self.big_npy[I.squeeze()].astype("float16")
-
- score, ix = self.index.search(npy, k=8)
- weight = np.square(1 / score)
- weight /= weight.sum(axis=1, keepdims=True)
- npy = np.sum(
- self.big_npy[ix] * np.expand_dims(weight, axis=2), axis=1
- ).astype("float16")
-
- feats = (
- torch.from_numpy(npy).unsqueeze(0).to(device) * self.index_rate
- + (1 - self.index_rate) * feats
- )
- else:
- print("index search FAIL or disabled")
-
+ try:
+ if hasattr(self, "index") and hasattr(self, "big_npy") and self.index_rate != 0:
+ npy = feats[0].cpu().numpy().astype("float32")
+ score, ix = self.index.search(npy, k=8)
+ weight = np.square(1 / score)
+ weight /= weight.sum(axis=1, keepdims=True)
+ npy = np.sum(
+ self.big_npy[ix] * np.expand_dims(weight, axis=2), axis=1
+ )
+ if(is_half==True):npy=npy.astype("float16")
+ feats = (
+ torch.from_numpy(npy).unsqueeze(0).to(device) * self.index_rate
+ + (1 - self.index_rate) * feats
+ )
+ else:
+ print("index search FAIL or disabled")
+ except:
+ traceback.print_exc()
+ print("index search FAIL")
feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
torch.cuda.synchronize()
print(feats.shape)
From f6e55485d99463b89cbd317396763369515616a3 Mon Sep 17 00:00:00 2001
From: RVC-Boss <129054828+RVC-Boss@users.noreply.github.com>
Date: Sun, 21 May 2023 07:01:34 +0000
Subject: [PATCH 08/16] Update gui.py
---
gui.py | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/gui.py b/gui.py
index 81d4d73..e80f4de 100644
--- a/gui.py
+++ b/gui.py
@@ -75,14 +75,14 @@ class RVC:
self.version = cpt.get("version", "v1")
if version == "v1":
if if_f0 == 1:
- net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
+ self.net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
else:
- net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
+ self.net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
elif version == "v2":
if if_f0 == 1:
- net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
+ self.net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
else:
- net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
+ self.net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
del self.net_g.enc_q
print(self.net_g.load_state_dict(cpt["weight"], strict=False))
self.net_g.eval().to(device)
From c3de24f2e0e50c53b103a1e22fb43667904ecf1e Mon Sep 17 00:00:00 2001
From: pcunwa <102950377+pcunwa@users.noreply.github.com>
Date: Sun, 21 May 2023 20:06:11 +0900
Subject: [PATCH 09/16] Corrected Japanese translation. (#319)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
* Update ja_JP.json
Incorrect or incomplete translations have been corrected.
* Update ja_JP.json
---------
Co-authored-by: 源文雨 <41315874+fumiama@users.noreply.github.com>
---
i18n/ja_JP.json | 22 +++++++++++-----------
1 file changed, 11 insertions(+), 11 deletions(-)
diff --git a/i18n/ja_JP.json b/i18n/ja_JP.json
index 87fcca5..8bd6f99 100644
--- a/i18n/ja_JP.json
+++ b/i18n/ja_JP.json
@@ -18,7 +18,7 @@
"输入待处理音频文件路径(默认是正确格式示例)": "処理対象音声ファイルのパスを入力してください(デフォルトは正しいフォーマットの例です)",
"选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "ピッチ抽出アルゴリズムを選択してください。歌声の場合は、pmを使用して速度を上げることができます。低音が重要な場合は、harvestを使用できますが、非常に遅くなります。",
">=3则使用对harvest音高识别的结果使用中值滤波，数值为滤波半径，使用可以削弱哑音": ">=3 次に、harvestピッチの認識結果に対してメディアンフィルタを使用します。値はフィルター半径で、ミュートを減衰させるために使用します。",
- "特征检索库文件路径,为空则使用下拉的选择结果": "特徴検索ライブラリへのパス 空の場合はドロップダウンで択",
+ "特征检索库文件路径,为空则使用下拉的选择结果": "特徴検索ライブラリへのパス 空の場合はドロップダウンで選択",
"自动检测index路径,下拉式选择(dropdown)": "インデックスパスの自動検出 ドロップダウンで選択",
"特征文件路径": "特徴量ファイルのパス",
"检索特征占比": "検索特徴率",
@@ -40,11 +40,11 @@
"指定输出乐器文件夹": "楽器の出力フォルダを指定してください",
"训练": "トレーニング",
"step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "ステップ1:実験設定を入力します。実験データはlogsに保存され、各実験にはフォルダーがあります。実験名のパスを手動で入力する必要があり、実験設定、ログ、トレーニングされたモデルファイルが含まれます。",
- "输入实验名": "実験名を入力してください",
+ "输入实验名": "モデル名",
"目标采样率": "目標サンプリングレート",
"模型是否带音高指导(唱歌一定要, 语音可以不要)": "モデルに音高ガイドがあるかどうか(歌唱には必要ですが、音声には必要ありません)",
- "版本(目前仅40k支持了v2)": "版本(目前仅40k支持了v2)",
- "提取音高和处理数据使用的CPU进程数": "提取音高和处理数据使用的CPU进程数",
+ "版本(目前仅40k支持了v2)": "バージョン（現在v2をサポートしているのは40kのみ）",
+ "提取音高和处理数据使用的CPU进程数": "ピッチの抽出やデータ処理に使用するCPUスレッド数",
"step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "ステップ2a: 訓練フォルダー内のすべての音声ファイルを自動的に探索し、スライスと正規化を行い、2つのwavフォルダーを実験ディレクトリに生成します。現在は一人でのトレーニングのみをサポートしています。",
"输入训练文件夹路径": "トレーニング用フォルダのパスを入力してください",
"请指定说话人id": "話者IDを指定してください",
@@ -56,14 +56,14 @@
"特征提取": "特徴抽出",
"step3: 填写训练设置, 开始训练模型和索引": "ステップ3: トレーニング設定を入力して、モデルとインデックスのトレーニングを開始します",
"保存频率save_every_epoch": "エポックごとの保存頻度",
- "总训练轮数total_epoch": "総トレーニング回数",
- "每张显卡的batch_size": "GPUごとのbatch_size",
+ "总训练轮数total_epoch": "総エポック数",
+ "每张显卡的batch_size": "GPUごとのバッチサイズ",
"是否仅保存最新的ckpt文件以节省硬盘空间": "ハードディスク容量を節約するため、最新のckptファイルのみを保存するかどうか",
"否": "いいえ",
"是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "すべてのトレーニングデータをメモリにキャッシュするかどうか。10分以下の小さなデータはキャッシュしてトレーニングを高速化できますが、大きなデータをキャッシュするとメモリが破裂し、あまり速度が上がりません。",
- "是否在每次保存时间点将最终小模型保存至weights文件夹": "是否在每次保存时间点将最终小模型保存至weights文件夹",
- "加载预训练底模G路径": "事前学習済みのGモデルのパスをロードしてください",
- "加载预训练底模D路径": "事前学習済みのDモデルのパスをロードしてください",
+ "是否在每次保存时间点将最终小模型保存至weights文件夹": "各保存時点の小モデルを全部weightsフォルダに保存するかどうか",
+ "加载预训练底模G路径": "事前学習済みのGモデルのパス",
+ "加载预训练底模D路径": "事前学習済みのDモデルのパス",
"训练模型": "モデルのトレーニング",
"训练特征索引": "特徴インデックスのトレーニング",
"一键训练": "ワンクリックトレーニング",
@@ -75,7 +75,7 @@
"模型是否带音高指导": "モデルに音高ガイドを付けるかどうか",
"要置入的模型信息": "挿入するモデル情報",
"保存的模型名不带后缀": "拡張子のない保存するモデル名",
- "模型版本型号": "模型版本型号",
+ "模型版本型号": "モデルのバージョン",
"融合": "フュージョン",
"修改模型信息(仅支持weights文件夹下提取的小模型文件)": "モデル情報の修正(weightsフォルダから抽出された小さなモデルファイルのみ対応)",
"模型路径": "モデルパス",
@@ -89,7 +89,7 @@
"模型是否带音高指导,1是0否": "モデルに音高ガイドを付けるかどうか、1は付ける、0は付けない",
"提取": "抽出",
"Onnx导出": "Onnx",
- "RVC模型路径": "RVCルパス",
+ "RVC模型路径": "RVCモデルパス",
"Onnx输出路径": "Onnx出力パス",
"MoeVS模型": "MoeSS？",
"导出Onnx模型": "Onnxに変換",
From 067731db9b5d5921f9ff3390680efb15114c7c3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=CE=9D=CE=B1=CF=81=CE=BF=CF=85=CF=83=CE=AD=C2=B7=CE=BC?=
=?UTF-8?q?=C2=B7=CE=B3=CE=B9=CE=BF=CF=85=CE=BC=CE=B5=CE=BC=CE=AF=C2=B7?=
=?UTF-8?q?=CE=A7=CE=B9=CE=BD=CE=B1=CE=BA=CE=AC=CE=BD=CE=BD=CE=B1?=
<40709280+NaruseMioShirakana@users.noreply.github.com>
Date: Sun, 21 May 2023 19:11:29 +0800
Subject: [PATCH 10/16] 768VecOnnxExport (#328)
* Delete export_onnx.py
* Delete export_onnx_old.py
* Delete models_onnx_moess.py
* Support 768 Vec
* Add files via upload
* Support 768 Vec
Support 768 Vec
* Support 768 Vec Onnx Export
Support 768 Vec Onnx Export
---
export_onnx.py | 98 ++--
export_onnx_old.py | 47 --
infer-web.py | 102 ++--
infer_pack/models_onnx.py | 94 +++-
infer_pack/models_onnx_moess.py | 849 --------------------------------
5 files changed, 144 insertions(+), 1046 deletions(-)
delete mode 100644 export_onnx_old.py
delete mode 100644 infer_pack/models_onnx_moess.py
diff --git a/export_onnx.py b/export_onnx.py
index 719aa7b..2ec6509 100644
--- a/export_onnx.py
+++ b/export_onnx.py
@@ -1,5 +1,4 @@
-from infer_pack.models_onnx_moess import SynthesizerTrnMs256NSFsidM
-from infer_pack.models_onnx import SynthesizerTrnMs256NSFsidO
+from infer_pack.models_onnx import SynthesizerTrnMsNSFsidM
import torch
if __name__ == "__main__":
@@ -21,65 +20,36 @@ if __name__ == "__main__":
device = "cpu" # 导出时设备（不影响使用模型）
- if MoeVS:
- net_g = SynthesizerTrnMs256NSFsidM(
- *cpt["config"], is_half=False
- ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
- net_g.load_state_dict(cpt["weight"], strict=False)
- input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
- output_names = [
- "audio",
- ]
- torch.onnx.export(
- net_g,
- (
- test_phone.to(device),
- test_phone_lengths.to(device),
- test_pitch.to(device),
- test_pitchf.to(device),
- test_ds.to(device),
- test_rnd.to(device),
- ),
- ExportedPath,
- dynamic_axes={
- "phone": [1],
- "pitch": [1],
- "pitchf": [1],
- "rnd": [2],
- },
- do_constant_folding=False,
- opset_version=16,
- verbose=False,
- input_names=input_names,
- output_names=output_names,
- )
- else:
- net_g = SynthesizerTrnMs256NSFsidO(
- *cpt["config"], is_half=False
- ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
- net_g.load_state_dict(cpt["weight"], strict=False)
- input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds"]
- output_names = [
- "audio",
- ]
- torch.onnx.export(
- net_g,
- (
- test_phone.to(device),
- test_phone_lengths.to(device),
- test_pitch.to(device),
- test_pitchf.to(device),
- test_ds.to(device),
- ),
- ExportedPath,
- dynamic_axes={
- "phone": [1],
- "pitch": [1],
- "pitchf": [1],
- },
- do_constant_folding=False,
- opset_version=16,
- verbose=False,
- input_names=input_names,
- output_names=output_names,
- )
+ net_g = SynthesizerTrnMsNSFsidM(
+ *cpt["config"], is_half=False
+ ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
+ net_g.load_state_dict(cpt["weight"], strict=False)
+ input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
+ output_names = [
+ "audio",
+ ]
+ # net_g.construct_spkmixmap(n_speaker) 多角色混合轨道导出
+ torch.onnx.export(
+ net_g,
+ (
+ test_phone.to(device),
+ test_phone_lengths.to(device),
+ test_pitch.to(device),
+ test_pitchf.to(device),
+ test_ds.to(device),
+ test_rnd.to(device),
+ ),
+ ExportedPath,
+ dynamic_axes={
+ "phone": [1],
+ "pitch": [1],
+ "pitchf": [1],
+ "rnd": [2],
+ },
+ do_constant_folding=False,
+ opset_version=16,
+ verbose=False,
+ input_names=input_names,
+ output_names=output_names,
+ )
+
diff --git a/export_onnx_old.py b/export_onnx_old.py
deleted file mode 100644
index bff6d06..0000000
--- a/export_onnx_old.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from infer_pack.models_onnx_moess import SynthesizerTrnMs256NSFsidM
-import torch
-
-person = "Shiroha/shiroha.pth"
-exported_path = "model.onnx"
-
-
-cpt = torch.load(person, map_location="cpu")
-cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
-print(*cpt["config"])
-net_g = SynthesizerTrnMs256NSFsidM(*cpt["config"], is_half=False)
-net_g.load_state_dict(cpt["weight"], strict=False)
-
-test_phone = torch.rand(1, 200, 256)
-test_phone_lengths = torch.tensor([200]).long()
-test_pitch = torch.randint(size=(1, 200), low=5, high=255)
-test_pitchf = torch.rand(1, 200)
-test_ds = torch.LongTensor([0])
-test_rnd = torch.rand(1, 192, 200)
-input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
-output_names = [
- "audio",
-]
-device = "cpu"
-torch.onnx.export(
- net_g,
- (
- test_phone.to(device),
- test_phone_lengths.to(device),
- test_pitch.to(device),
- test_pitchf.to(device),
- test_ds.to(device),
- test_rnd.to(device),
- ),
- exported_path,
- dynamic_axes={
- "phone": [1],
- "pitch": [1],
- "pitchf": [1],
- "rnd": [2],
- },
- do_constant_folding=False,
- opset_version=16,
- verbose=False,
- input_names=input_names,
- output_names=output_names,
-)
diff --git a/infer-web.py b/infer-web.py
index 6a238da..851c76c 100644
--- a/infer-web.py
+++ b/infer-web.py
@@ -1068,15 +1068,11 @@ def change_info_(ckpt_path):
return {"__type__": "update"}, {"__type__": "update"}, {"__type__": "update"}
-from infer_pack.models_onnx_moess import SynthesizerTrnMs256NSFsidM
-from infer_pack.models_onnx import SynthesizerTrnMs256NSFsidO
-
-
+from infer_pack.models_onnx import SynthesizerTrnMsNSFsidM
def export_onnx(ModelPath, ExportedPath, MoeVS=True):
- hidden_channels = 256 # hidden_channels，为768Vec做准备
cpt = torch.load(ModelPath, map_location="cpu")
cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
- print(*cpt["config"])
+ hidden_channels = cpt["config"][-2] # hidden_channels，为768Vec做准备
test_phone = torch.rand(1, 200, hidden_channels) # hidden unit
test_phone_lengths = torch.tensor([200]).long() # hidden unit 长度（貌似没啥用）
@@ -1087,68 +1083,38 @@ def export_onnx(ModelPath, ExportedPath, MoeVS=True):
device = "cpu" # 导出时设备（不影响使用模型）
- if MoeVS:
- net_g = SynthesizerTrnMs256NSFsidM(
- *cpt["config"], is_half=False
- ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
- net_g.load_state_dict(cpt["weight"], strict=False)
- input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
- output_names = [
- "audio",
- ]
- torch.onnx.export(
- net_g,
- (
- test_phone.to(device),
- test_phone_lengths.to(device),
- test_pitch.to(device),
- test_pitchf.to(device),
- test_ds.to(device),
- test_rnd.to(device),
- ),
- ExportedPath,
- dynamic_axes={
- "phone": [1],
- "pitch": [1],
- "pitchf": [1],
- "rnd": [2],
- },
- do_constant_folding=False,
- opset_version=16,
- verbose=False,
- input_names=input_names,
- output_names=output_names,
- )
- else:
- net_g = SynthesizerTrnMs256NSFsidO(
- *cpt["config"], is_half=False
- ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
- net_g.load_state_dict(cpt["weight"], strict=False)
- input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds"]
- output_names = [
- "audio",
- ]
- torch.onnx.export(
- net_g,
- (
- test_phone.to(device),
- test_phone_lengths.to(device),
- test_pitch.to(device),
- test_pitchf.to(device),
- test_ds.to(device),
- ),
- ExportedPath,
- dynamic_axes={
- "phone": [1],
- "pitch": [1],
- "pitchf": [1],
- },
- do_constant_folding=False,
- opset_version=16,
- verbose=False,
- input_names=input_names,
- output_names=output_names,
- )
+ net_g = SynthesizerTrnMsNSFsidM(
+ *cpt["config"], is_half=False
+ ) # fp32导出（C++要支持fp16必须手动将内存重新排列所以暂时不用fp16）
+ net_g.load_state_dict(cpt["weight"], strict=False)
+ input_names = ["phone", "phone_lengths", "pitch", "pitchf", "ds", "rnd"]
+ output_names = [
+ "audio",
+ ]
+ # net_g.construct_spkmixmap(n_speaker) 多角色混合轨道导出
+ torch.onnx.export(
+ net_g,
+ (
+ test_phone.to(device),
+ test_phone_lengths.to(device),
+ test_pitch.to(device),
+ test_pitchf.to(device),
+ test_ds.to(device),
+ test_rnd.to(device),
+ ),
+ ExportedPath,
+ dynamic_axes={
+ "phone": [1],
+ "pitch": [1],
+ "pitchf": [1],
+ "rnd": [2],
+ },
+ do_constant_folding=False,
+ opset_version=16,
+ verbose=False,
+ input_names=input_names,
+ output_names=output_names,
+ )
return "Finished"
diff --git a/infer_pack/models_onnx.py b/infer_pack/models_onnx.py
index 18991b5..cd463a7 100644
--- a/infer_pack/models_onnx.py
+++ b/infer_pack/models_onnx.py
@@ -61,7 +61,7 @@ class TextEncoder256(nn.Module):
return m, logs, x_mask
-class TextEncoder256Sim(nn.Module):
+class TextEncoder768(nn.Module):
def __init__(
self,
out_channels,
@@ -81,14 +81,14 @@ class TextEncoder256Sim(nn.Module):
self.n_layers = n_layers
self.kernel_size = kernel_size
self.p_dropout = p_dropout
- self.emb_phone = nn.Linear(256, hidden_channels)
+ self.emb_phone = nn.Linear(768, hidden_channels)
self.lrelu = nn.LeakyReLU(0.1, inplace=True)
if f0 == True:
self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
self.encoder = attentions.Encoder(
hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
)
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
+ self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
def forward(self, phone, pitch, lengths):
if pitch == None:
@@ -102,8 +102,10 @@ class TextEncoder256Sim(nn.Module):
x.dtype
)
x = self.encoder(x * x_mask, x_mask)
- x = self.proj(x) * x_mask
- return x, x_mask
+ stats = self.proj(x) * x_mask
+
+ m, logs = torch.split(stats, self.out_channels, dim=1)
+ return m, logs, x_mask
class ResidualCouplingBlock(nn.Module):
@@ -527,7 +529,7 @@ sr2sr = {
}
-class SynthesizerTrnMs256NSFsidO(nn.Module):
+class SynthesizerTrnMsNSFsidM(nn.Module):
def __init__(
self,
spec_channels,
@@ -571,15 +573,26 @@ class SynthesizerTrnMs256NSFsidO(nn.Module):
self.gin_channels = gin_channels
# self.hop_length = hop_length#
self.spk_embed_dim = spk_embed_dim
- self.enc_p = TextEncoder256(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
+ if self.gin_channels == 256:
+ self.enc_p = TextEncoder256(
+ inter_channels,
+ hidden_channels,
+ filter_channels,
+ n_heads,
+ n_layers,
+ kernel_size,
+ p_dropout,
+ )
+ else:
+ self.enc_p = TextEncoder768(
+ inter_channels,
+ hidden_channels,
+ filter_channels,
+ n_heads,
+ n_layers,
+ kernel_size,
+ p_dropout,
+ )
self.dec = GeneratorNSF(
inter_channels,
resblock,
@@ -605,6 +618,7 @@ class SynthesizerTrnMs256NSFsidO(nn.Module):
inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
)
self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
+ self.speaker_map = None
print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
def remove_weight_norm(self):
@@ -612,10 +626,24 @@ class SynthesizerTrnMs256NSFsidO(nn.Module):
self.flow.remove_weight_norm()
self.enc_q.remove_weight_norm()
- def forward(self, phone, phone_lengths, pitch, nsff0, sid, max_len=None):
- g = self.emb_g(sid).unsqueeze(-1)
+ def construct_spkmixmap(self, n_speaker):
+ self.speaker_map = torch.zeros((n_speaker, 1, 1, self.gin_channels))
+ for i in range(n_speaker):
+ self.speaker_map[i] = self.emb_g(torch.LongTensor([[i]]))
+ self.speaker_map = self.speaker_map.unsqueeze(0)
+
+ def forward(self, phone, phone_lengths, pitch, nsff0, g, rnd, max_len=None):
+ if self.speaker_map is not None: # [N, S] * [S, B, 1, H]
+ g = g.reshape((g.shape[0], g.shape[1], 1, 1, 1)) # [N, S, B, 1, 1]
+ g = g * self.speaker_map # [N, S, B, 1, H]
+ g = torch.sum(g, dim=1) # [N, 1, B, 1, H]
+ g = g.transpose(0, -1).transpose(0, -2).squeeze(0) # [B, H, N]
+ else:
+ g = g.unsqueeze(0)
+ g = self.emb_g(g).transpose(1,2)
+
m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
- z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
+ z_p = (m_p + torch.exp(logs_p) * rnd) * x_mask
z = self.flow(z_p, x_mask, g=g, reverse=True)
o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
return o
@@ -651,6 +679,36 @@ class MultiPeriodDiscriminator(torch.nn.Module):
return y_d_rs, y_d_gs, fmap_rs, fmap_gs
+class MultiPeriodDiscriminatorV2(torch.nn.Module):
+ def __init__(self, use_spectral_norm=False):
+ super(MultiPeriodDiscriminatorV2, self).__init__()
+ # periods = [2, 3, 5, 7, 11, 17]
+ periods = [2, 3, 5, 7, 11, 17, 23, 37]
+
+ 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)
+ # for j in range(len(fmap_r)):
+ # print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
+ 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 DiscriminatorS(torch.nn.Module):
def __init__(self, use_spectral_norm=False):
super(DiscriminatorS, self).__init__()
diff --git a/infer_pack/models_onnx_moess.py b/infer_pack/models_onnx_moess.py
deleted file mode 100644
index ea33489..0000000
--- a/infer_pack/models_onnx_moess.py
+++ /dev/null
@@ -1,849 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from infer_pack import modules
-from infer_pack import attentions
-from infer_pack import commons
-from infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from infer_pack.commons import init_weights
-import numpy as np
-from infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
- def __init__(
- self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=True,
- ):
- 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.emb_phone = nn.Linear(256, hidden_channels)
- self.lrelu = nn.LeakyReLU(0.1, inplace=True)
- if f0 == True:
- self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
- self.encoder = attentions.Encoder(
- hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, phone, pitch, lengths):
- if pitch == None:
- x = self.emb_phone(phone)
- else:
- x = self.emb_phone(phone) + self.emb_pitch(pitch)
- x = x * math.sqrt(self.hidden_channels) # [b, t, h]
- x = self.lrelu(x)
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return m, logs, x_mask
-
-
-class TextEncoder256Sim(nn.Module):
- def __init__(
- self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=True,
- ):
- 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.emb_phone = nn.Linear(256, hidden_channels)
- self.lrelu = nn.LeakyReLU(0.1, inplace=True)
- if f0 == True:
- self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
- self.encoder = attentions.Encoder(
- hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-
- def forward(self, phone, pitch, lengths):
- if pitch == None:
- x = self.emb_phone(phone)
- else:
- x = self.emb_phone(phone) + self.emb_pitch(pitch)
- x = x * math.sqrt(self.hidden_channels) # [b, t, h]
- x = self.lrelu(x)
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.encoder(x * x_mask, x_mask)
- x = self.proj(x) * x_mask
- return x, x_mask
-
-
-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
-
- def remove_weight_norm(self):
- for i in range(self.n_flows):
- self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(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):
- 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
-
- def remove_weight_norm(self):
- self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
- def __init__(
- self,
- initial_channel,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=0,
- ):
- super(Generator, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
- self.conv_pre = Conv1d(
- initial_channel, upsample_initial_channel, 7, 1, padding=3
- )
- resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- self.ups.append(
- weight_norm(
- ConvTranspose1d(
- upsample_initial_channel // (2**i),
- upsample_initial_channel // (2 ** (i + 1)),
- k,
- u,
- padding=(k - u) // 2,
- )
- )
- )
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(
- zip(resblock_kernel_sizes, resblock_dilation_sizes)
- ):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- def forward(self, x, g=None):
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
-
- return x
-
- def remove_weight_norm(self):
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
- """Definition of sine generator
- SineGen(samp_rate, harmonic_num = 0,
- sine_amp = 0.1, noise_std = 0.003,
- voiced_threshold = 0,
- flag_for_pulse=False)
- samp_rate: sampling rate in Hz
- harmonic_num: number of harmonic overtones (default 0)
- sine_amp: amplitude of sine-wavefrom (default 0.1)
- noise_std: std of Gaussian noise (default 0.003)
- voiced_thoreshold: F0 threshold for U/V classification (default 0)
- flag_for_pulse: this SinGen is used inside PulseGen (default False)
- Note: when flag_for_pulse is True, the first time step of a voiced
- segment is always sin(np.pi) or cos(0)
- """
-
- def __init__(
- self,
- samp_rate,
- harmonic_num=0,
- sine_amp=0.1,
- noise_std=0.003,
- voiced_threshold=0,
- flag_for_pulse=False,
- ):
- super(SineGen, self).__init__()
- self.sine_amp = sine_amp
- self.noise_std = noise_std
- self.harmonic_num = harmonic_num
- self.dim = self.harmonic_num + 1
- self.sampling_rate = samp_rate
- self.voiced_threshold = voiced_threshold
-
- def _f02uv(self, f0):
- # generate uv signal
- uv = torch.ones_like(f0)
- uv = uv * (f0 > self.voiced_threshold)
- return uv
-
- def forward(self, f0, upp):
- """sine_tensor, uv = forward(f0)
- input F0: tensor(batchsize=1, length, dim=1)
- f0 for unvoiced steps should be 0
- output sine_tensor: tensor(batchsize=1, length, dim)
- output uv: tensor(batchsize=1, length, 1)
- """
- with torch.no_grad():
- f0 = f0[:, None].transpose(1, 2)
- f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
- # fundamental component
- f0_buf[:, :, 0] = f0[:, :, 0]
- for idx in np.arange(self.harmonic_num):
- f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
- idx + 2
- ) # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
- rad_values = (f0_buf / self.sampling_rate) % 1 ###%1意味着n_har的乘积无法后处理优化
- rand_ini = torch.rand(
- f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
- )
- rand_ini[:, 0] = 0
- rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
- tmp_over_one = torch.cumsum(rad_values, 1) # % 1 #####%1意味着后面的cumsum无法再优化
- tmp_over_one *= upp
- tmp_over_one = F.interpolate(
- tmp_over_one.transpose(2, 1),
- scale_factor=upp,
- mode="linear",
- align_corners=True,
- ).transpose(2, 1)
- rad_values = F.interpolate(
- rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
- ).transpose(
- 2, 1
- ) #######
- tmp_over_one %= 1
- tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
- cumsum_shift = torch.zeros_like(rad_values)
- cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
- sine_waves = torch.sin(
- torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
- )
- sine_waves = sine_waves * self.sine_amp
- uv = self._f02uv(f0)
- uv = F.interpolate(
- uv.transpose(2, 1), scale_factor=upp, mode="nearest"
- ).transpose(2, 1)
- noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
- noise = noise_amp * torch.randn_like(sine_waves)
- sine_waves = sine_waves * uv + noise
- return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
- """SourceModule for hn-nsf
- SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
- add_noise_std=0.003, voiced_threshod=0)
- sampling_rate: sampling_rate in Hz
- harmonic_num: number of harmonic above F0 (default: 0)
- sine_amp: amplitude of sine source signal (default: 0.1)
- add_noise_std: std of additive Gaussian noise (default: 0.003)
- note that amplitude of noise in unvoiced is decided
- by sine_amp
- voiced_threshold: threhold to set U/V given F0 (default: 0)
- Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
- F0_sampled (batchsize, length, 1)
- Sine_source (batchsize, length, 1)
- noise_source (batchsize, length 1)
- uv (batchsize, length, 1)
- """
-
- def __init__(
- self,
- sampling_rate,
- harmonic_num=0,
- sine_amp=0.1,
- add_noise_std=0.003,
- voiced_threshod=0,
- is_half=True,
- ):
- super(SourceModuleHnNSF, self).__init__()
-
- self.sine_amp = sine_amp
- self.noise_std = add_noise_std
- self.is_half = is_half
- # to produce sine waveforms
- self.l_sin_gen = SineGen(
- sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
- )
-
- # to merge source harmonics into a single excitation
- self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
- self.l_tanh = torch.nn.Tanh()
-
- def forward(self, x, upp=None):
- sine_wavs, uv, _ = self.l_sin_gen(x, upp)
- if self.is_half:
- sine_wavs = sine_wavs.half()
- sine_merge = self.l_tanh(self.l_linear(sine_wavs))
- return sine_merge, None, None # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
- def __init__(
- self,
- initial_channel,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels,
- sr,
- is_half=False,
- ):
- super(GeneratorNSF, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
-
- self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
- self.m_source = SourceModuleHnNSF(
- sampling_rate=sr, harmonic_num=0, is_half=is_half
- )
- self.noise_convs = nn.ModuleList()
- self.conv_pre = Conv1d(
- initial_channel, upsample_initial_channel, 7, 1, padding=3
- )
- resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- c_cur = upsample_initial_channel // (2 ** (i + 1))
- self.ups.append(
- weight_norm(
- ConvTranspose1d(
- upsample_initial_channel // (2**i),
- upsample_initial_channel // (2 ** (i + 1)),
- k,
- u,
- padding=(k - u) // 2,
- )
- )
- )
- if i + 1 < len(upsample_rates):
- stride_f0 = np.prod(upsample_rates[i + 1 :])
- self.noise_convs.append(
- Conv1d(
- 1,
- c_cur,
- kernel_size=stride_f0 * 2,
- stride=stride_f0,
- padding=stride_f0 // 2,
- )
- )
- else:
- self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(
- zip(resblock_kernel_sizes, resblock_dilation_sizes)
- ):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- self.upp = np.prod(upsample_rates)
-
- def forward(self, x, f0, g=None):
- har_source, noi_source, uv = self.m_source(f0, self.upp)
- har_source = har_source.transpose(1, 2)
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- x_source = self.noise_convs[i](har_source)
- x = x + x_source
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
- return x
-
- def remove_weight_norm(self):
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-sr2sr = {
- "32k": 32000,
- "40k": 40000,
- "48k": 48000,
-}
-
-
-class SynthesizerTrnMs256NSFsidM(nn.Module):
- 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,
- spk_embed_dim,
- gin_channels,
- sr,
- **kwargs
- ):
- super().__init__()
- if type(sr) == type("strr"):
- sr = sr2sr[sr]
- 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.hop_length = hop_length#
- self.spk_embed_dim = spk_embed_dim
- self.enc_p = TextEncoder256(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
- self.dec = GeneratorNSF(
- inter_channels,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=gin_channels,
- sr=sr,
- is_half=kwargs["is_half"],
- )
- self.enc_q = PosteriorEncoder(
- spec_channels,
- inter_channels,
- hidden_channels,
- 5,
- 1,
- 16,
- gin_channels=gin_channels,
- )
- self.flow = ResidualCouplingBlock(
- inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
- )
- self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
- print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
- def remove_weight_norm(self):
- self.dec.remove_weight_norm()
- self.flow.remove_weight_norm()
- self.enc_q.remove_weight_norm()
-
- def forward(self, phone, phone_lengths, pitch, nsff0, sid, rnd, max_len=None):
- g = self.emb_g(sid).unsqueeze(-1)
- m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
- z_p = (m_p + torch.exp(logs_p) * rnd) * x_mask
- z = self.flow(z_p, x_mask, g=g, reverse=True)
- o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
- return o
-
-
-class SynthesizerTrnMs256NSFsid_sim(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,
- spk_embed_dim,
- # hop_length,
- gin_channels=0,
- use_sdp=True,
- **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.hop_length = hop_length#
- self.spk_embed_dim = spk_embed_dim
- self.enc_p = TextEncoder256Sim(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
- self.dec = GeneratorNSF(
- inter_channels,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=gin_channels,
- is_half=kwargs["is_half"],
- )
-
- self.flow = ResidualCouplingBlock(
- inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
- )
- self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
- print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
- def remove_weight_norm(self):
- self.dec.remove_weight_norm()
- self.flow.remove_weight_norm()
- self.enc_q.remove_weight_norm()
-
- def forward(
- self, phone, phone_lengths, pitch, pitchf, ds, max_len=None
- ): # y是spec不需要了现在
- g = self.emb_g(ds.unsqueeze(0)).unsqueeze(-1) # [b, 256, 1]##1是t，广播的
- x, x_mask = self.enc_p(phone, pitch, phone_lengths)
- x = self.flow(x, x_mask, g=g, reverse=True)
- o = self.dec((x * x_mask)[:, :, :max_len], pitchf, g=g)
- return o
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2, 3, 5, 7, 11, 17]
- # periods = [3, 5, 7, 11, 17, 23, 37]
-
- 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)
- # for j in range(len(fmap_r)):
- # print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
- 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 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 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
From cfd984812804ddc9247d65b14c82cd32e56c1133 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
<41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 21 May 2023 19:19:53 +0800
Subject: [PATCH 11/16] Format code (#330)
Co-authored-by: github-actions[bot]
---
config.py | 2 ++
export_onnx.py | 1 -
gui.py | 44 ++++++++++++++++++++++++++-------------
i18n.py | 4 ++--
infer-web.py | 2 ++
infer_pack/models_onnx.py | 8 +++----
6 files changed, 39 insertions(+), 22 deletions(-)
diff --git a/config.py b/config.py
index 8e6fa22..48187f5 100644
--- a/config.py
+++ b/config.py
@@ -2,6 +2,7 @@ import argparse
import torch
from multiprocessing import cpu_count
+
def config_file_change_fp32():
for config_file in ["32k.json", "40k.json", "48k.json"]:
with open(f"configs/{config_file}", "r") as f:
@@ -13,6 +14,7 @@ def config_file_change_fp32():
with open("trainset_preprocess_pipeline_print.py", "w") as f:
f.write(strr)
+
class Config:
def __init__(self):
self.device = "cuda:0"
diff --git a/export_onnx.py b/export_onnx.py
index 2ec6509..34938fe 100644
--- a/export_onnx.py
+++ b/export_onnx.py
@@ -52,4 +52,3 @@ if __name__ == "__main__":
input_names=input_names,
output_names=output_names,
)
-
diff --git a/gui.py b/gui.py
index e80f4de..852f0ca 100644
--- a/gui.py
+++ b/gui.py
@@ -1,4 +1,4 @@
-'''
+"""
0416后的更新：
引入config中half
重建npy而不用填写
@@ -9,12 +9,14 @@
int16：
增加无索引支持
f0算法改harvest(怎么看就只有这个会影响CPU占用)，但是不这么改效果不好
-'''
+"""
import os, sys, traceback
+
now_dir = os.getcwd()
sys.path.append(now_dir)
from config import Config
-is_half=Config().is_half
+
+is_half = Config().is_half
import PySimpleGUI as sg
import sounddevice as sd
import noisereduce as nr
@@ -26,7 +28,12 @@ import torchaudio.transforms as tat
import scipy.signal as signal
# import matplotlib.pyplot as plt
-from infer_pack.models import SynthesizerTrnMs256NSFsid, SynthesizerTrnMs256NSFsid_nono,SynthesizerTrnMs768NSFsid,SynthesizerTrnMs768NSFsid_nono
+from infer_pack.models import (
+ SynthesizerTrnMs256NSFsid,
+ SynthesizerTrnMs256NSFsid_nono,
+ SynthesizerTrnMs768NSFsid,
+ SynthesizerTrnMs768NSFsid_nono,
+)
from i18n import I18nAuto
i18n = I18nAuto()
@@ -63,7 +70,7 @@ class RVC:
)
self.model = models[0]
self.model = self.model.to(device)
- if(is_half==True):
+ if is_half == True:
self.model = self.model.half()
else:
self.model = self.model.float()
@@ -75,21 +82,25 @@ class RVC:
self.version = cpt.get("version", "v1")
if version == "v1":
if if_f0 == 1:
- self.net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=config.is_half)
+ self.net_g = SynthesizerTrnMs256NSFsid(
+ *cpt["config"], is_half=config.is_half
+ )
else:
self.net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
elif version == "v2":
if if_f0 == 1:
- self.net_g = SynthesizerTrnMs768NSFsid(*cpt["config"], is_half=config.is_half)
+ self.net_g = SynthesizerTrnMs768NSFsid(
+ *cpt["config"], is_half=config.is_half
+ )
else:
self.net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
del self.net_g.enc_q
print(self.net_g.load_state_dict(cpt["weight"], strict=False))
self.net_g.eval().to(device)
- if(is_half==True):
- self.net_g=self.net_g.half()
+ if is_half == True:
+ self.net_g = self.net_g.half()
else:
- self.net_g=self.net_g.float()
+ self.net_g = self.net_g.float()
except:
print(traceback.format_exc())
@@ -151,15 +162,18 @@ class RVC:
####索引优化
try:
- if hasattr(self, "index") and hasattr(self, "big_npy") and self.index_rate != 0:
+ if (
+ hasattr(self, "index")
+ and hasattr(self, "big_npy")
+ and self.index_rate != 0
+ ):
npy = feats[0].cpu().numpy().astype("float32")
score, ix = self.index.search(npy, k=8)
weight = np.square(1 / score)
weight /= weight.sum(axis=1, keepdims=True)
- npy = np.sum(
- self.big_npy[ix] * np.expand_dims(weight, axis=2), axis=1
- )
- if(is_half==True):npy=npy.astype("float16")
+ npy = np.sum(self.big_npy[ix] * np.expand_dims(weight, axis=2), axis=1)
+ if is_half == True:
+ npy = npy.astype("float16")
feats = (
torch.from_numpy(npy).unsqueeze(0).to(device) * self.index_rate
+ (1 - self.index_rate) * feats
diff --git a/i18n.py b/i18n.py
index 9deba42..37f310f 100644
--- a/i18n.py
+++ b/i18n.py
@@ -18,11 +18,11 @@ class I18nAuto:
if not os.path.exists(f"./i18n/{language}.json"):
language = "en_US"
self.language = language
- #print("Use Language:", language)
+ # print("Use Language:", language)
self.language_map = load_language_list(language)
def __call__(self, key):
return self.language_map.get(key, key)
-
+
def print(self):
print("Use Language:", self.language)
diff --git a/infer-web.py b/infer-web.py
index 851c76c..305e03e 100644
--- a/infer-web.py
+++ b/infer-web.py
@@ -1069,6 +1069,8 @@ def change_info_(ckpt_path):
from infer_pack.models_onnx import SynthesizerTrnMsNSFsidM
+
+
def export_onnx(ModelPath, ExportedPath, MoeVS=True):
cpt = torch.load(ModelPath, map_location="cpu")
cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
diff --git a/infer_pack/models_onnx.py b/infer_pack/models_onnx.py
index cd463a7..8cb1b18 100644
--- a/infer_pack/models_onnx.py
+++ b/infer_pack/models_onnx.py
@@ -633,14 +633,14 @@ class SynthesizerTrnMsNSFsidM(nn.Module):
self.speaker_map = self.speaker_map.unsqueeze(0)
def forward(self, phone, phone_lengths, pitch, nsff0, g, rnd, max_len=None):
- if self.speaker_map is not None: # [N, S] * [S, B, 1, H]
+ if self.speaker_map is not None: # [N, S] * [S, B, 1, H]
g = g.reshape((g.shape[0], g.shape[1], 1, 1, 1)) # [N, S, B, 1, 1]
g = g * self.speaker_map # [N, S, B, 1, H]
- g = torch.sum(g, dim=1) # [N, 1, B, 1, H]
- g = g.transpose(0, -1).transpose(0, -2).squeeze(0) # [B, H, N]
+ g = torch.sum(g, dim=1) # [N, 1, B, 1, H]
+ g = g.transpose(0, -1).transpose(0, -2).squeeze(0) # [B, H, N]
else:
g = g.unsqueeze(0)
- g = self.emb_g(g).transpose(1,2)
+ g = self.emb_g(g).transpose(1, 2)
m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
z_p = (m_p + torch.exp(logs_p) * rnd) * x_mask
From 9cee20f40292b00a4b7fc3379d4f07af0f6c74b0 Mon Sep 17 00:00:00 2001
From: Yugo Ogura <15419227+Spice-Z@users.noreply.github.com>
Date: Tue, 23 May 2023 13:58:05 +0900
Subject: [PATCH 12/16] feat: ipynb for v2 (#332)
---
...eval_based_Voice_Conversion_WebUI_v2.ipynb | 400 ++++++++++++++++++
1 file changed, 400 insertions(+)
create mode 100644 Retrieval_based_Voice_Conversion_WebUI_v2.ipynb
diff --git a/Retrieval_based_Voice_Conversion_WebUI_v2.ipynb b/Retrieval_based_Voice_Conversion_WebUI_v2.ipynb
new file mode 100644
index 0000000..de7bc88
--- /dev/null
+++ b/Retrieval_based_Voice_Conversion_WebUI_v2.ipynb
@@ -0,0 +1,400 @@
+{
+ "cells": [
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZFFCx5J80SGa"
+ },
+ "source": [
+ "[](https://colab.research.google.com/github/RVC-Project/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI_v2.ipynb)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "GmFP6bN9dvOq"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 查看显卡\n",
+ "!nvidia-smi"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "wjddIFr1oS3W"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 安装依赖\n",
+ "!apt-get -y install build-essential python3-dev ffmpeg\n",
+ "!pip3 install --upgrade setuptools wheel\n",
+ "!pip3 install --upgrade pip\n",
+ "!pip3 install faiss-gpu fairseq gradio ffmpeg ffmpeg-python praat-parselmouth pyworld numpy==1.23.5 numba==0.56.4 librosa==0.9.2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ge_97mfpgqTm"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 克隆仓库\n",
+ "\n",
+ "!git init\n",
+ "!git remote add origin https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git\n",
+ "!git fetch origin cfd984812804ddc9247d65b14c82cd32e56c1133 --depth=1 \n",
+ "!git reset --hard FETCH_HEAD\n",
+ "%cd /content/Retrieval-based-Voice-Conversion-WebUI"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "BLDEZADkvlw1"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 更新仓库（一般无需执行）\n",
+ "!git pull"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "pqE0PrnuRqI2"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 安装aria2\n",
+ "!apt -y install -qq aria2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "UG3XpUwEomUz"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 下载底模\n",
+ "\n",
+ "# v1\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/D32k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o D32k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/D40k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o D40k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/D48k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o D48k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/G32k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o G32k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/G40k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o G40k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/G48k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o G48k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/f0D32k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o f0D32k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/f0D40k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o f0D40k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/f0D48k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o f0D48k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/f0G32k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o f0G32k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/f0G40k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o f0G40k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained/f0G48k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained -o f0G48k.pth\n",
+ "\n",
+ "#v2\n",
+ "# !aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/D32k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o D32k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/D40k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o D40k.pth\n",
+ "# !aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/D48k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o D48k.pth\n",
+ "# !aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/G32k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o G32k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/G40k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o G40k.pth\n",
+ "# !aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/G48k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o G48k.pth\n",
+ "# !aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0D32k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o f0D32k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0D40k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o f0D40k.pth\n",
+ "# !aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0D48k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o f0D48k.pth\n",
+ "# !aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0G32k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o f0G32k.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0G40k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o f0G40k.pth\n",
+ "# !aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0G48k.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/pretrained_v2 -o f0G48k.pth"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "HugjmZqZRuiF"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 下载人声分离模型\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/uvr5_weights/HP2-人声vocals+非人声instrumentals.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/uvr5_weights -o HP2-人声vocals+非人声instrumentals.pth\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/uvr5_weights/HP5-主旋律人声vocals+其他instrumentals.pth -d /content/Retrieval-based-Voice-Conversion-WebUI/uvr5_weights -o HP5-主旋律人声vocals+其他instrumentals.pth"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "2RCaT9FTR0ej"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 下载hubert_base\n",
+ "!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/hubert_base.pt -d /content/Retrieval-based-Voice-Conversion-WebUI -o hubert_base.pt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "jwu07JgqoFON"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 挂载谷歌云盘\n",
+ "\n",
+ "from google.colab import drive\n",
+ "drive.mount('/content/drive')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "Mwk7Q0Loqzjx"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 从谷歌云盘加载打包好的数据集到/content/dataset\n",
+ "\n",
+ "#@markdown 数据集位置\n",
+ "DATASET = \"/content/drive/MyDrive/dataset/lulu20230327_32k.zip\" #@param {type:\"string\"}\n",
+ "\n",
+ "!mkdir -p /content/dataset\n",
+ "!unzip -d /content/dataset -B {DATASET}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "PDlFxWHWEynD"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 重命名数据集中的重名文件\n",
+ "!ls -a /content/dataset/\n",
+ "!rename 's/(\\w+)\\.(\\w+)~(\\d*)/$1_$3.$2/' /content/dataset/*.*~*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "7vh6vphDwO0b"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 启动web\n",
+ "%cd /content/Retrieval-based-Voice-Conversion-WebUI\n",
+ "# %load_ext tensorboard\n",
+ "# %tensorboard --logdir /content/Retrieval-based-Voice-Conversion-WebUI/logs\n",
+ "!python3 infer-web.py --colab --pycmd python3"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "FgJuNeAwx5Y_"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 手动将训练后的模型文件备份到谷歌云盘\n",
+ "#@markdown 需要自己查看logs文件夹下模型的文件名，手动修改下方命令末尾的文件名\n",
+ "\n",
+ "#@markdown 模型名\n",
+ "MODELNAME = \"lulu\" #@param {type:\"string\"}\n",
+ "#@markdown 模型epoch\n",
+ "MODELEPOCH = 9600 #@param {type:\"integer\"}\n",
+ "\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/G_{MODELEPOCH}.pth /content/drive/MyDrive/{MODELNAME}_D_{MODELEPOCH}.pth\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/D_{MODELEPOCH}.pth /content/drive/MyDrive/{MODELNAME}_G_{MODELEPOCH}.pth\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/added_*.index /content/drive/MyDrive/\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/total_*.npy /content/drive/MyDrive/\n",
+ "\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/weights/{MODELNAME}.pth /content/drive/MyDrive/{MODELNAME}{MODELEPOCH}.pth"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "OVQoLQJXS7WX"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 从谷歌云盘恢复pth\n",
+ "#@markdown 需要自己查看logs文件夹下模型的文件名，手动修改下方命令末尾的文件名\n",
+ "\n",
+ "#@markdown 模型名\n",
+ "MODELNAME = \"lulu\" #@param {type:\"string\"}\n",
+ "#@markdown 模型epoch\n",
+ "MODELEPOCH = 7500 #@param {type:\"integer\"}\n",
+ "\n",
+ "!mkdir -p /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}\n",
+ "\n",
+ "!cp /content/drive/MyDrive/{MODELNAME}_D_{MODELEPOCH}.pth /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/G_{MODELEPOCH}.pth\n",
+ "!cp /content/drive/MyDrive/{MODELNAME}_G_{MODELEPOCH}.pth /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/D_{MODELEPOCH}.pth\n",
+ "!cp /content/drive/MyDrive/*.index /content/\n",
+ "!cp /content/drive/MyDrive/*.npy /content/\n",
+ "!cp /content/drive/MyDrive/{MODELNAME}{MODELEPOCH}.pth /content/Retrieval-based-Voice-Conversion-WebUI/weights/{MODELNAME}.pth"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "ZKAyuKb9J6dz"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 手动预处理（不推荐）\n",
+ "#@markdown 模型名\n",
+ "MODELNAME = \"lulu\" #@param {type:\"string\"}\n",
+ "#@markdown 采样率\n",
+ "BITRATE = 48000 #@param {type:\"integer\"}\n",
+ "#@markdown 使用的进程数\n",
+ "THREADCOUNT = 8 #@param {type:\"integer\"}\n",
+ "\n",
+ "!python3 trainset_preprocess_pipeline_print.py /content/dataset {BITRATE} {THREADCOUNT} logs/{MODELNAME} True\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "CrxJqzAUKmPJ"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 手动提取特征（不推荐）\n",
+ "#@markdown 模型名\n",
+ "MODELNAME = \"lulu\" #@param {type:\"string\"}\n",
+ "#@markdown 使用的进程数\n",
+ "THREADCOUNT = 8 #@param {type:\"integer\"}\n",
+ "#@markdown 音高提取算法\n",
+ "ALGO = \"harvest\" #@param {type:\"string\"}\n",
+ "\n",
+ "!python3 extract_f0_print.py logs/{MODELNAME} {THREADCOUNT} {ALGO}\n",
+ "\n",
+ "!python3 extract_feature_print.py cpu 1 0 0 logs/{MODELNAME}\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "IMLPLKOaKj58"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 手动训练（不推荐）\n",
+ "#@markdown 模型名\n",
+ "MODELNAME = \"lulu\" #@param {type:\"string\"}\n",
+ "#@markdown 使用的GPU\n",
+ "USEGPU = \"0\" #@param {type:\"string\"}\n",
+ "#@markdown 批大小\n",
+ "BATCHSIZE = 32 #@param {type:\"integer\"}\n",
+ "#@markdown 停止的epoch\n",
+ "MODELEPOCH = 3200 #@param {type:\"integer\"}\n",
+ "#@markdown 保存epoch间隔\n",
+ "EPOCHSAVE = 100 #@param {type:\"integer\"}\n",
+ "#@markdown 采样率\n",
+ "MODELSAMPLE = \"48k\" #@param {type:\"string\"}\n",
+ "#@markdown 是否缓存训练集\n",
+ "CACHEDATA = 1 #@param {type:\"integer\"}\n",
+ "#@markdown 是否仅保存最新的ckpt文件\n",
+ "ONLYLATEST = 0 #@param {type:\"integer\"}\n",
+ "\n",
+ "!python3 train_nsf_sim_cache_sid_load_pretrain.py -e lulu -sr {MODELSAMPLE} -f0 1 -bs {BATCHSIZE} -g {USEGPU} -te {MODELEPOCH} -se {EPOCHSAVE} -pg pretrained/f0G{MODELSAMPLE}.pth -pd pretrained/f0D{MODELSAMPLE}.pth -l {ONLYLATEST} -c {CACHEDATA}\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "haYA81hySuDl"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 删除其它pth，只留选中的（慎点，仔细看代码）\n",
+ "#@markdown 模型名\n",
+ "MODELNAME = \"lulu\" #@param {type:\"string\"}\n",
+ "#@markdown 选中模型epoch\n",
+ "MODELEPOCH = 9600 #@param {type:\"integer\"}\n",
+ "\n",
+ "!echo \"备份选中的模型。。。\"\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/G_{MODELEPOCH}.pth /content/{MODELNAME}_D_{MODELEPOCH}.pth\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/D_{MODELEPOCH}.pth /content/{MODELNAME}_G_{MODELEPOCH}.pth\n",
+ "\n",
+ "!echo \"正在删除。。。\"\n",
+ "!ls /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}\n",
+ "!rm /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/*.pth\n",
+ "\n",
+ "!echo \"恢复选中的模型。。。\"\n",
+ "!mv /content/{MODELNAME}_D_{MODELEPOCH}.pth /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/G_{MODELEPOCH}.pth \n",
+ "!mv /content/{MODELNAME}_G_{MODELEPOCH}.pth /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/D_{MODELEPOCH}.pth\n",
+ "\n",
+ "!echo \"删除完成\"\n",
+ "!ls /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "QhSiPTVPoIRh"
+ },
+ "outputs": [],
+ "source": [
+ "#@title 清除项目下所有文件，只留选中的模型（慎点，仔细看代码）\n",
+ "#@markdown 模型名\n",
+ "MODELNAME = \"lulu\" #@param {type:\"string\"}\n",
+ "#@markdown 选中模型epoch\n",
+ "MODELEPOCH = 9600 #@param {type:\"integer\"}\n",
+ "\n",
+ "!echo \"备份选中的模型。。。\"\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/G_{MODELEPOCH}.pth /content/{MODELNAME}_D_{MODELEPOCH}.pth\n",
+ "!cp /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/D_{MODELEPOCH}.pth /content/{MODELNAME}_G_{MODELEPOCH}.pth\n",
+ "\n",
+ "!echo \"正在删除。。。\"\n",
+ "!ls /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}\n",
+ "!rm -rf /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/*\n",
+ "\n",
+ "!echo \"恢复选中的模型。。。\"\n",
+ "!mv /content/{MODELNAME}_D_{MODELEPOCH}.pth /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/G_{MODELEPOCH}.pth \n",
+ "!mv /content/{MODELNAME}_G_{MODELEPOCH}.pth /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}/D_{MODELEPOCH}.pth\n",
+ "\n",
+ "!echo \"删除完成\"\n",
+ "!ls /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}"
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "private_outputs": true,
+ "provenance": []
+ },
+ "gpuClass": "standard",
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
From a4c86a3aa123e11e31f46db52211a656dc93e20d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 23 May 2023 22:51:51 +0800
Subject: [PATCH 13/16] Bump requests from 2.28.2 to 2.31.0 (#339)
Bumps [requests](https://github.com/psf/requests) from 2.28.2 to 2.31.0.
- [Release notes](https://github.com/psf/requests/releases)
- [Changelog](https://github.com/psf/requests/blob/main/HISTORY.md)
- [Commits](https://github.com/psf/requests/compare/v2.28.2...v2.31.0)
---
updated-dependencies:
- dependency-name: requests
dependency-type: indirect
...
Signed-off-by: dependabot[bot]
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
poetry.lock | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/poetry.lock b/poetry.lock
index c60f6cd..47e5461 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -3095,21 +3095,21 @@ files = [
[[package]]
name = "requests"
-version = "2.28.2"
+version = "2.31.0"
description = "Python HTTP for Humans."
category = "main"
optional = false
-python-versions = ">=3.7, <4"
+python-versions = ">=3.7"
files = [
- {file = "requests-2.28.2-py3-none-any.whl", hash = "sha256:64299f4909223da747622c030b781c0d7811e359c37124b4bd368fb8c6518baa"},
- {file = "requests-2.28.2.tar.gz", hash = "sha256:98b1b2782e3c6c4904938b84c0eb932721069dfdb9134313beff7c83c2df24bf"},
+ {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"},
+ {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"},
]
[package.dependencies]
certifi = ">=2017.4.17"
charset-normalizer = ">=2,<4"
idna = ">=2.5,<4"
-urllib3 = ">=1.21.1,<1.27"
+urllib3 = ">=1.21.1,<3"
[package.extras]
socks = ["PySocks (>=1.5.6,!=1.5.7)"]
From 8efb101401e99fdfceb46a9e5c6cac3369c120ff Mon Sep 17 00:00:00 2001
From: Rice Cake
Date: Wed, 24 May 2023 20:26:35 +0800
Subject: [PATCH 14/16] upload RVC v2 index training script (#343)
* Add files via upload
* Apply Code Formatter Change
---------
Co-authored-by: gak123
---
infer/train-index -v2.py | 44 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 44 insertions(+)
create mode 100644 infer/train-index -v2.py
diff --git a/infer/train-index -v2.py b/infer/train-index -v2.py
new file mode 100644
index 0000000..656a5a6
--- /dev/null
+++ b/infer/train-index -v2.py
@@ -0,0 +1,44 @@
+"""
+格式：直接cid为自带的index位；aid放不下了，通过字典来查，反正就5w个
+"""
+import faiss, numpy as np, os
+
+# ###########如果是原始特征要先写save
+inp_root = r"./logs/nene/3_feature768"
+npys = []
+listdir_res = list(os.listdir(inp_root))
+for name in sorted(listdir_res):
+ phone = np.load("%s/%s" % (inp_root, name))
+ npys.append(phone)
+big_npy = np.concatenate(npys, 0)
+big_npy_idx = np.arange(big_npy.shape[0])
+np.random.shuffle(big_npy_idx)
+big_npy = big_npy[big_npy_idx]
+print(big_npy.shape) # (6196072, 192)#fp32#4.43G
+np.save("infer/big_src_feature_mi.npy", big_npy)
+
+##################train+add
+# big_npy=np.load("/bili-coeus/jupyter/jupyterhub-liujing04/vits_ch/inference_f0/big_src_feature_mi.npy")
+n_ivf = min(int(16 * np.sqrt(big_npy.shape[0])), big_npy.shape[0] // 39)
+index = faiss.index_factory(768, "IVF%s,Flat" % n_ivf) # mi
+print("training")
+index_ivf = faiss.extract_index_ivf(index) #
+index_ivf.nprobe = 1
+index.train(big_npy)
+faiss.write_index(
+ index, "infer/trained_IVF%s_Flat_baseline_src_feat_v2.index" % (n_ivf)
+)
+print("adding")
+batch_size_add = 8192
+for i in range(0, big_npy.shape[0], batch_size_add):
+ index.add(big_npy[i : i + batch_size_add])
+faiss.write_index(index, "infer/added_IVF%s_Flat_mi_baseline_src_feat.index" % (n_ivf))
+"""
+大小（都是FP32）
+big_src_feature 2.95G
+ (3098036, 256)
+big_emb 4.43G
+ (6196072, 192)
+big_emb双倍是因为求特征要repeat后再加pitch
+
+"""
From e0813eb282ad4dc9436f3c7eb9f430d859f333d0 Mon Sep 17 00:00:00 2001
From: RVC-Boss <129054828+RVC-Boss@users.noreply.github.com>
Date: Wed, 24 May 2023 12:27:15 +0000
Subject: [PATCH 15/16] Update train_nsf_sim_cache_sid_load_pretrain.py
---
train_nsf_sim_cache_sid_load_pretrain.py | 1169 +++++++++++-----------
1 file changed, 585 insertions(+), 584 deletions(-)
diff --git a/train_nsf_sim_cache_sid_load_pretrain.py b/train_nsf_sim_cache_sid_load_pretrain.py
index 23f2355..e657023 100644
--- a/train_nsf_sim_cache_sid_load_pretrain.py
+++ b/train_nsf_sim_cache_sid_load_pretrain.py
@@ -1,584 +1,585 @@
-import sys, os
-
-now_dir = os.getcwd()
-sys.path.append(os.path.join(now_dir))
-sys.path.append(os.path.join(now_dir, "train"))
-import utils
-import datetime
-
-hps = utils.get_hparams()
-os.environ["CUDA_VISIBLE_DEVICES"] = hps.gpus.replace("-", ",")
-n_gpus = len(hps.gpus.split("-"))
-from random import shuffle
-import traceback, json, argparse, itertools, math, torch, pdb
-
-torch.backends.cudnn.deterministic = False
-torch.backends.cudnn.benchmark = False
-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
-from infer_pack import commons
-from time import sleep
-from time import time as ttime
-from data_utils import (
- TextAudioLoaderMultiNSFsid,
- TextAudioLoader,
- TextAudioCollateMultiNSFsid,
- TextAudioCollate,
- DistributedBucketSampler,
-)
-
-if hps.version == "v1":
- from infer_pack.models import (
- SynthesizerTrnMs256NSFsid as RVC_Model_f0,
- SynthesizerTrnMs256NSFsid_nono as RVC_Model_nof0,
- MultiPeriodDiscriminator,
- )
-else:
- from infer_pack.models import (
- SynthesizerTrnMs768NSFsid as RVC_Model_f0,
- SynthesizerTrnMs768NSFsid_nono as RVC_Model_nof0,
- MultiPeriodDiscriminatorV2 as MultiPeriodDiscriminator,
- )
-from losses import generator_loss, discriminator_loss, feature_loss, kl_loss
-from mel_processing import mel_spectrogram_torch, spec_to_mel_torch
-from process_ckpt import savee
-
-global_step = 0
-
-
-class EpochRecorder:
- def __init__(self):
- self.last_time = ttime()
-
- def record(self):
- now_time = ttime()
- elapsed_time = now_time - self.last_time
- self.last_time = now_time
- elapsed_time_str = str(datetime.timedelta(seconds=elapsed_time))
- current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
- return f"[{current_time}] | ({elapsed_time_str})"
-
-
-def main():
- n_gpus = torch.cuda.device_count()
- os.environ["MASTER_ADDR"] = "localhost"
- os.environ["MASTER_PORT"] = "51545"
-
- children = []
- for i in range(n_gpus):
- subproc = mp.Process(
- target=run,
- args=(
- i,
- n_gpus,
- hps,
- ),
- )
- children.append(subproc)
- subproc.start()
-
- for i in range(n_gpus):
- children[i].join()
-
-
-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"))
-
- dist.init_process_group(
- backend="gloo", init_method="env://", world_size=n_gpus, rank=rank
- )
- torch.manual_seed(hps.train.seed)
- if torch.cuda.is_available():
- torch.cuda.set_device(rank)
-
- if hps.if_f0 == 1:
- train_dataset = TextAudioLoaderMultiNSFsid(hps.data.training_files, hps.data)
- else:
- train_dataset = TextAudioLoader(hps.data.training_files, hps.data)
- train_sampler = DistributedBucketSampler(
- train_dataset,
- hps.train.batch_size * n_gpus,
- # [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1200,1400], # 16s
- [100, 200, 300, 400, 500, 600, 700, 800, 900], # 16s
- num_replicas=n_gpus,
- rank=rank,
- shuffle=True,
- )
- # It is possible that dataloader's workers are out of shared memory. Please try to raise your shared memory limit.
- # num_workers=8 -> num_workers=4
- if hps.if_f0 == 1:
- collate_fn = TextAudioCollateMultiNSFsid()
- else:
- collate_fn = TextAudioCollate()
- train_loader = DataLoader(
- train_dataset,
- num_workers=4,
- shuffle=False,
- pin_memory=True,
- collate_fn=collate_fn,
- batch_sampler=train_sampler,
- persistent_workers=True,
- prefetch_factor=8,
- )
- if hps.if_f0 == 1:
- net_g = RVC_Model_f0(
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- **hps.model,
- is_half=hps.train.fp16_run,
- sr=hps.sample_rate,
- )
- else:
- net_g = RVC_Model_nof0(
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- **hps.model,
- is_half=hps.train.fp16_run,
- )
- if torch.cuda.is_available():
- net_g = net_g.cuda(rank)
- net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm)
- if torch.cuda.is_available():
- net_d = net_d.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], find_unused_parameters=True)
- if torch.cuda.is_available():
- net_g = DDP(net_g, device_ids=[rank])
- net_d = DDP(net_d, device_ids=[rank])
- else:
- net_g = DDP(net_g)
- net_d = DDP(net_d)
-
- try: # 如果能加载自动resume
- _, _, _, epoch_str = utils.load_checkpoint(
- utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d, optim_d
- ) # D多半加载没事
- if rank == 0:
- logger.info("loaded D")
- # _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g, optim_g,load_opt=0)
- _, _, _, epoch_str = utils.load_checkpoint(
- utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g, optim_g
- )
- global_step = (epoch_str - 1) * len(train_loader)
- # epoch_str = 1
- # global_step = 0
- except: # 如果首次不能加载，加载pretrain
- # traceback.print_exc()
- epoch_str = 1
- global_step = 0
- if rank == 0:
- logger.info("loaded pretrained %s %s" % (hps.pretrainG, hps.pretrainD))
- print(
- net_g.module.load_state_dict(
- torch.load(hps.pretrainG, map_location="cpu")["model"]
- )
- ) ##测试不加载优化器
- print(
- net_d.module.load_state_dict(
- torch.load(hps.pretrainD, map_location="cpu")["model"]
- )
- )
-
- 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)
-
- cache = []
- 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, None],
- logger,
- [writer, writer_eval],
- cache,
- )
- 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,
- cache,
- )
- scheduler_g.step()
- scheduler_d.step()
-
-
-def train_and_evaluate(
- rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers, cache
-):
- net_g, net_d = nets
- optim_g, optim_d = optims
- 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()
-
- # Prepare data iterator
- if hps.if_cache_data_in_gpu == True:
- # Use Cache
- data_iterator = cache
- if cache == []:
- # Make new cache
- for batch_idx, info in enumerate(train_loader):
- # Unpack
- if hps.if_f0 == 1:
- (
- phone,
- phone_lengths,
- pitch,
- pitchf,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ) = info
- else:
- (
- phone,
- phone_lengths,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ) = info
- # Load on CUDA
- if torch.cuda.is_available():
- phone = phone.cuda(rank, non_blocking=True)
- phone_lengths = phone_lengths.cuda(rank, non_blocking=True)
- if hps.if_f0 == 1:
- pitch = pitch.cuda(rank, non_blocking=True)
- pitchf = pitchf.cuda(rank, non_blocking=True)
- sid = sid.cuda(rank, non_blocking=True)
- spec = spec.cuda(rank, non_blocking=True)
- spec_lengths = spec_lengths.cuda(rank, non_blocking=True)
- wave = wave.cuda(rank, non_blocking=True)
- wave_lengths = wave_lengths.cuda(rank, non_blocking=True)
- # Cache on list
- if hps.if_f0 == 1:
- cache.append(
- (
- batch_idx,
- (
- phone,
- phone_lengths,
- pitch,
- pitchf,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ),
- )
- )
- else:
- cache.append(
- (
- batch_idx,
- (
- phone,
- phone_lengths,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ),
- )
- )
- else:
- # Load shuffled cache
- shuffle(cache)
- else:
- # Loader
- data_iterator = enumerate(train_loader)
-
- # Run steps
- epoch_recorder = EpochRecorder()
- for batch_idx, info in data_iterator:
- # Data
- ## Unpack
- if hps.if_f0 == 1:
- (
- phone,
- phone_lengths,
- pitch,
- pitchf,
- spec,
- spec_lengths,
- wave,
- wave_lengths,
- sid,
- ) = info
- else:
- phone, phone_lengths, spec, spec_lengths, wave, wave_lengths, sid = info
- ## Load on CUDA
- if (hps.if_cache_data_in_gpu == False) and torch.cuda.is_available():
- phone = phone.cuda(rank, non_blocking=True)
- phone_lengths = phone_lengths.cuda(rank, non_blocking=True)
- if hps.if_f0 == 1:
- pitch = pitch.cuda(rank, non_blocking=True)
- pitchf = pitchf.cuda(rank, non_blocking=True)
- sid = sid.cuda(rank, non_blocking=True)
- spec = spec.cuda(rank, non_blocking=True)
- spec_lengths = spec_lengths.cuda(rank, non_blocking=True)
- wave = wave.cuda(rank, non_blocking=True)
- # wave_lengths = wave_lengths.cuda(rank, non_blocking=True)
-
- # Calculate
- with autocast(enabled=hps.train.fp16_run):
- if hps.if_f0 == 1:
- (
- y_hat,
- ids_slice,
- x_mask,
- z_mask,
- (z, z_p, m_p, logs_p, m_q, logs_q),
- ) = net_g(phone, phone_lengths, pitch, pitchf, spec, spec_lengths, sid)
- else:
- (
- y_hat,
- ids_slice,
- x_mask,
- z_mask,
- (z, z_p, m_p, logs_p, m_q, logs_q),
- ) = net_g(phone, phone_lengths, spec, spec_lengths, sid)
- 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_mel = commons.slice_segments(
- mel, ids_slice, hps.train.segment_size // hps.data.hop_length
- )
- with autocast(enabled=False):
- y_hat_mel = mel_spectrogram_torch(
- y_hat.float().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,
- )
- if hps.train.fp16_run == True:
- y_hat_mel = y_hat_mel.half()
- wave = commons.slice_segments(
- wave, ids_slice * hps.data.hop_length, hps.train.segment_size
- ) # slice
-
- # Discriminator
- y_d_hat_r, y_d_hat_g, _, _ = net_d(wave, 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
- )
- optim_d.zero_grad()
- scaler.scale(loss_disc).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(wave, 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_gen_all = loss_gen + loss_fm + loss_mel + loss_kl
- 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"]
- logger.info(
- "Train Epoch: {} [{:.0f}%]".format(
- epoch, 100.0 * batch_idx / len(train_loader)
- )
- )
- # Amor For Tensorboard display
- if loss_mel > 75:
- loss_mel = 75
- if loss_kl > 9:
- loss_kl = 9
-
- logger.info([global_step, lr])
- logger.info(
- f"loss_disc={loss_disc:.3f}, loss_gen={loss_gen:.3f}, loss_fm={loss_fm:.3f},loss_mel={loss_mel:.3f}, loss_kl={loss_kl:.3f}"
- )
- scalar_dict = {
- "loss/g/total": loss_gen_all,
- "loss/d/total": loss_disc,
- "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,
- }
- )
-
- 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()
- ),
- }
- utils.summarize(
- writer=writer,
- global_step=global_step,
- images=image_dict,
- scalars=scalar_dict,
- )
- global_step += 1
- # /Run steps
-
- if epoch % hps.save_every_epoch == 0 and rank == 0:
- if hps.if_latest == 0:
- 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)),
- )
- else:
- utils.save_checkpoint(
- net_g,
- optim_g,
- hps.train.learning_rate,
- epoch,
- os.path.join(hps.model_dir, "G_{}.pth".format(2333333)),
- )
- utils.save_checkpoint(
- net_d,
- optim_d,
- hps.train.learning_rate,
- epoch,
- os.path.join(hps.model_dir, "D_{}.pth".format(2333333)),
- )
- if rank == 0 and hps.save_every_weights == "1":
- if hasattr(net_g, "module"):
- ckpt = net_g.module.state_dict()
- else:
- ckpt = net_g.state_dict()
- logger.info(
- "saving ckpt %s_e%s:%s"
- % (
- hps.name,
- epoch,
- savee(
- ckpt,
- hps.sample_rate,
- hps.if_f0,
- hps.name + "_e%s" % epoch,
- epoch,
- hps.version,
- ),
- )
- )
-
- if rank == 0:
- logger.info("====> Epoch: {} {}".format(epoch, epoch_recorder.record()))
- if epoch >= hps.total_epoch and rank == 0:
- logger.info("Training is done. The program is closed.")
-
- if hasattr(net_g, "module"):
- ckpt = net_g.module.state_dict()
- else:
- ckpt = net_g.state_dict()
- logger.info(
- "saving final ckpt:%s"
- % (savee(ckpt, hps.sample_rate, hps.if_f0, hps.name, epoch, hps.version))
- )
- sleep(1)
- os._exit(2333333)
-
-
-if __name__ == "__main__":
- main()
+import sys, os
+
+now_dir = os.getcwd()
+sys.path.append(os.path.join(now_dir))
+sys.path.append(os.path.join(now_dir, "train"))
+import utils
+import datetime
+
+hps = utils.get_hparams()
+os.environ["CUDA_VISIBLE_DEVICES"] = hps.gpus.replace("-", ",")
+n_gpus = len(hps.gpus.split("-"))
+from random import shuffle
+import traceback, json, argparse, itertools, math, torch, pdb
+
+torch.backends.cudnn.deterministic = False
+torch.backends.cudnn.benchmark = False
+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
+from infer_pack import commons
+from time import sleep
+from time import time as ttime
+from data_utils import (
+ TextAudioLoaderMultiNSFsid,
+ TextAudioLoader,
+ TextAudioCollateMultiNSFsid,
+ TextAudioCollate,
+ DistributedBucketSampler,
+)
+
+if hps.version == "v1":
+ from infer_pack.models import (
+ SynthesizerTrnMs256NSFsid as RVC_Model_f0,
+ SynthesizerTrnMs256NSFsid_nono as RVC_Model_nof0,
+ MultiPeriodDiscriminator,
+ )
+else:
+ from infer_pack.models import (
+ SynthesizerTrnMs768NSFsid as RVC_Model_f0,
+ SynthesizerTrnMs768NSFsid_nono as RVC_Model_nof0,
+ MultiPeriodDiscriminatorV2 as MultiPeriodDiscriminator,
+ )
+from losses import generator_loss, discriminator_loss, feature_loss, kl_loss
+from mel_processing import mel_spectrogram_torch, spec_to_mel_torch
+from process_ckpt import savee
+
+global_step = 0
+
+
+class EpochRecorder:
+ def __init__(self):
+ self.last_time = ttime()
+
+ def record(self):
+ now_time = ttime()
+ elapsed_time = now_time - self.last_time
+ self.last_time = now_time
+ elapsed_time_str = str(datetime.timedelta(seconds=elapsed_time))
+ current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+ return f"[{current_time}] | ({elapsed_time_str})"
+
+
+def main():
+ n_gpus = torch.cuda.device_count()
+ os.environ["MASTER_ADDR"] = "localhost"
+ os.environ["MASTER_PORT"] = "51545"
+
+ children = []
+ for i in range(n_gpus):
+ subproc = mp.Process(
+ target=run,
+ args=(
+ i,
+ n_gpus,
+ hps,
+ ),
+ )
+ children.append(subproc)
+ subproc.start()
+
+ for i in range(n_gpus):
+ children[i].join()
+
+
+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"))
+
+ dist.init_process_group(
+ backend="gloo", init_method="env://", world_size=n_gpus, rank=rank
+ )
+ torch.manual_seed(hps.train.seed)
+ if torch.cuda.is_available():
+ torch.cuda.set_device(rank)
+
+ if hps.if_f0 == 1:
+ train_dataset = TextAudioLoaderMultiNSFsid(hps.data.training_files, hps.data)
+ else:
+ train_dataset = TextAudioLoader(hps.data.training_files, hps.data)
+ train_sampler = DistributedBucketSampler(
+ train_dataset,
+ hps.train.batch_size * n_gpus,
+ # [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1200,1400], # 16s
+ [100, 200, 300, 400, 500, 600, 700, 800, 900], # 16s
+ num_replicas=n_gpus,
+ rank=rank,
+ shuffle=True,
+ )
+ # It is possible that dataloader's workers are out of shared memory. Please try to raise your shared memory limit.
+ # num_workers=8 -> num_workers=4
+ if hps.if_f0 == 1:
+ collate_fn = TextAudioCollateMultiNSFsid()
+ else:
+ collate_fn = TextAudioCollate()
+ train_loader = DataLoader(
+ train_dataset,
+ num_workers=4,
+ shuffle=False,
+ pin_memory=True,
+ collate_fn=collate_fn,
+ batch_sampler=train_sampler,
+ persistent_workers=True,
+ prefetch_factor=8,
+ )
+ if hps.if_f0 == 1:
+ net_g = RVC_Model_f0(
+ hps.data.filter_length // 2 + 1,
+ hps.train.segment_size // hps.data.hop_length,
+ **hps.model,
+ is_half=hps.train.fp16_run,
+ sr=hps.sample_rate,
+ )
+ else:
+ net_g = RVC_Model_nof0(
+ hps.data.filter_length // 2 + 1,
+ hps.train.segment_size // hps.data.hop_length,
+ **hps.model,
+ is_half=hps.train.fp16_run,
+ )
+ if torch.cuda.is_available():
+ net_g = net_g.cuda(rank)
+ net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm)
+ if torch.cuda.is_available():
+ net_d = net_d.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], find_unused_parameters=True)
+ if torch.cuda.is_available():
+ net_g = DDP(net_g, device_ids=[rank])
+ net_d = DDP(net_d, device_ids=[rank])
+ else:
+ net_g = DDP(net_g)
+ net_d = DDP(net_d)
+
+ try: # 如果能加载自动resume
+ _, _, _, epoch_str = utils.load_checkpoint(
+ utils.latest_checkpoint_path(hps.model_dir, "D_*.pth"), net_d, optim_d
+ ) # D多半加载没事
+ if rank == 0:
+ logger.info("loaded D")
+ # _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g, optim_g,load_opt=0)
+ _, _, _, epoch_str = utils.load_checkpoint(
+ utils.latest_checkpoint_path(hps.model_dir, "G_*.pth"), net_g, optim_g
+ )
+ global_step = (epoch_str - 1) * len(train_loader)
+ # epoch_str = 1
+ # global_step = 0
+ except: # 如果首次不能加载，加载pretrain
+ # traceback.print_exc()
+ epoch_str = 1
+ global_step = 0
+ if rank == 0:
+ logger.info("loaded pretrained %s %s" % (hps.pretrainG, hps.pretrainD))
+ print(
+ net_g.module.load_state_dict(
+ torch.load(hps.pretrainG, map_location="cpu")["model"]
+ )
+ ) ##测试不加载优化器
+ print(
+ net_d.module.load_state_dict(
+ torch.load(hps.pretrainD, map_location="cpu")["model"]
+ )
+ )
+
+ 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)
+
+ cache = []
+ 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, None],
+ logger,
+ [writer, writer_eval],
+ cache,
+ )
+ 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,
+ cache,
+ )
+ scheduler_g.step()
+ scheduler_d.step()
+
+
+def train_and_evaluate(
+ rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers, cache
+):
+ net_g, net_d = nets
+ optim_g, optim_d = optims
+ 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()
+
+ # Prepare data iterator
+ if hps.if_cache_data_in_gpu == True:
+ # Use Cache
+ data_iterator = cache
+ if cache == []:
+ # Make new cache
+ for batch_idx, info in enumerate(train_loader):
+ # Unpack
+ if hps.if_f0 == 1:
+ (
+ phone,
+ phone_lengths,
+ pitch,
+ pitchf,
+ spec,
+ spec_lengths,
+ wave,
+ wave_lengths,
+ sid,
+ ) = info
+ else:
+ (
+ phone,
+ phone_lengths,
+ spec,
+ spec_lengths,
+ wave,
+ wave_lengths,
+ sid,
+ ) = info
+ # Load on CUDA
+ if torch.cuda.is_available():
+ phone = phone.cuda(rank, non_blocking=True)
+ phone_lengths = phone_lengths.cuda(rank, non_blocking=True)
+ if hps.if_f0 == 1:
+ pitch = pitch.cuda(rank, non_blocking=True)
+ pitchf = pitchf.cuda(rank, non_blocking=True)
+ sid = sid.cuda(rank, non_blocking=True)
+ spec = spec.cuda(rank, non_blocking=True)
+ spec_lengths = spec_lengths.cuda(rank, non_blocking=True)
+ wave = wave.cuda(rank, non_blocking=True)
+ wave_lengths = wave_lengths.cuda(rank, non_blocking=True)
+ # Cache on list
+ if hps.if_f0 == 1:
+ cache.append(
+ (
+ batch_idx,
+ (
+ phone,
+ phone_lengths,
+ pitch,
+ pitchf,
+ spec,
+ spec_lengths,
+ wave,
+ wave_lengths,
+ sid,
+ ),
+ )
+ )
+ else:
+ cache.append(
+ (
+ batch_idx,
+ (
+ phone,
+ phone_lengths,
+ spec,
+ spec_lengths,
+ wave,
+ wave_lengths,
+ sid,
+ ),
+ )
+ )
+ else:
+ # Load shuffled cache
+ shuffle(cache)
+ else:
+ # Loader
+ data_iterator = enumerate(train_loader)
+
+ # Run steps
+ epoch_recorder = EpochRecorder()
+ for batch_idx, info in data_iterator:
+ # Data
+ ## Unpack
+ if hps.if_f0 == 1:
+ (
+ phone,
+ phone_lengths,
+ pitch,
+ pitchf,
+ spec,
+ spec_lengths,
+ wave,
+ wave_lengths,
+ sid,
+ ) = info
+ else:
+ phone, phone_lengths, spec, spec_lengths, wave, wave_lengths, sid = info
+ ## Load on CUDA
+ if (hps.if_cache_data_in_gpu == False) and torch.cuda.is_available():
+ phone = phone.cuda(rank, non_blocking=True)
+ phone_lengths = phone_lengths.cuda(rank, non_blocking=True)
+ if hps.if_f0 == 1:
+ pitch = pitch.cuda(rank, non_blocking=True)
+ pitchf = pitchf.cuda(rank, non_blocking=True)
+ sid = sid.cuda(rank, non_blocking=True)
+ spec = spec.cuda(rank, non_blocking=True)
+ spec_lengths = spec_lengths.cuda(rank, non_blocking=True)
+ wave = wave.cuda(rank, non_blocking=True)
+ # wave_lengths = wave_lengths.cuda(rank, non_blocking=True)
+
+ # Calculate
+ with autocast(enabled=hps.train.fp16_run):
+ if hps.if_f0 == 1:
+ (
+ y_hat,
+ ids_slice,
+ x_mask,
+ z_mask,
+ (z, z_p, m_p, logs_p, m_q, logs_q),
+ ) = net_g(phone, phone_lengths, pitch, pitchf, spec, spec_lengths, sid)
+ else:
+ (
+ y_hat,
+ ids_slice,
+ x_mask,
+ z_mask,
+ (z, z_p, m_p, logs_p, m_q, logs_q),
+ ) = net_g(phone, phone_lengths, spec, spec_lengths, sid)
+ 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_mel = commons.slice_segments(
+ mel, ids_slice, hps.train.segment_size // hps.data.hop_length
+ )
+ with autocast(enabled=False):
+ y_hat_mel = mel_spectrogram_torch(
+ y_hat.float().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,
+ )
+ if hps.train.fp16_run == True:
+ y_hat_mel = y_hat_mel.half()
+ wave = commons.slice_segments(
+ wave, ids_slice * hps.data.hop_length, hps.train.segment_size
+ ) # slice
+
+ # Discriminator
+ y_d_hat_r, y_d_hat_g, _, _ = net_d(wave, 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
+ )
+ optim_d.zero_grad()
+ scaler.scale(loss_disc).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(wave, 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_gen_all = loss_gen + loss_fm + loss_mel + loss_kl
+ 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"]
+ logger.info(
+ "Train Epoch: {} [{:.0f}%]".format(
+ epoch, 100.0 * batch_idx / len(train_loader)
+ )
+ )
+ # Amor For Tensorboard display
+ if loss_mel > 75:
+ loss_mel = 75
+ if loss_kl > 9:
+ loss_kl = 9
+
+ logger.info([global_step, lr])
+ logger.info(
+ f"loss_disc={loss_disc:.3f}, loss_gen={loss_gen:.3f}, loss_fm={loss_fm:.3f},loss_mel={loss_mel:.3f}, loss_kl={loss_kl:.3f}"
+ )
+ scalar_dict = {
+ "loss/g/total": loss_gen_all,
+ "loss/d/total": loss_disc,
+ "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,
+ }
+ )
+
+ 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()
+ ),
+ }
+ utils.summarize(
+ writer=writer,
+ global_step=global_step,
+ images=image_dict,
+ scalars=scalar_dict,
+ )
+ global_step += 1
+ # /Run steps
+
+ if epoch % hps.save_every_epoch == 0 and rank == 0:
+ if hps.if_latest == 0:
+ 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)),
+ )
+ else:
+ utils.save_checkpoint(
+ net_g,
+ optim_g,
+ hps.train.learning_rate,
+ epoch,
+ os.path.join(hps.model_dir, "G_{}.pth".format(2333333)),
+ )
+ utils.save_checkpoint(
+ net_d,
+ optim_d,
+ hps.train.learning_rate,
+ epoch,
+ os.path.join(hps.model_dir, "D_{}.pth".format(2333333)),
+ )
+ if rank == 0 and hps.save_every_weights == "1":
+ if hasattr(net_g, "module"):
+ ckpt = net_g.module.state_dict()
+ else:
+ ckpt = net_g.state_dict()
+ logger.info(
+ "saving ckpt %s_e%s:%s"
+ % (
+ hps.name,
+ epoch,
+ savee(
+ ckpt,
+ hps.sample_rate,
+ hps.if_f0,
+ hps.name + "_e%s" % epoch,
+ epoch,
+ hps.version,
+ ),
+ )
+ )
+
+ if rank == 0:
+ logger.info("====> Epoch: {} {}".format(epoch, epoch_recorder.record()))
+ if epoch >= hps.total_epoch and rank == 0:
+ logger.info("Training is done. The program is closed.")
+
+ if hasattr(net_g, "module"):
+ ckpt = net_g.module.state_dict()
+ else:
+ ckpt = net_g.state_dict()
+ logger.info(
+ "saving final ckpt:%s"
+ % (savee(ckpt, hps.sample_rate, hps.if_f0, hps.name, epoch, hps.version))
+ )
+ sleep(1)
+ os._exit(2333333)
+
+
+if __name__ == "__main__":
+ torch.multiprocessing.set_start_method('spawn')
+ main()
From 039e7afb853f048e6bc11c894e2d783cd9a77359 Mon Sep 17 00:00:00 2001
From: JackEllie <119565920+JackEllie@users.noreply.github.com>
Date: Thu, 25 May 2023 08:27:40 +0800
Subject: [PATCH 16/16] Update gui.py (#338)
---
gui.py | 18 ++++++++++--------
1 file changed, 10 insertions(+), 8 deletions(-)
diff --git a/gui.py b/gui.py
index 852f0ca..b25335a 100644
--- a/gui.py
+++ b/gui.py
@@ -14,9 +14,9 @@ import os, sys, traceback
now_dir = os.getcwd()
sys.path.append(now_dir)
-from config import Config
+from config import Config as MyConfig
-is_half = Config().is_half
+is_half = MyConfig().is_half
import PySimpleGUI as sg
import sounddevice as sd
import noisereduce as nr
@@ -48,6 +48,7 @@ class RVC:
初始化
"""
try:
+ self.config = MyConfig()
self.f0_up_key = key
self.time_step = 160 / 16000 * 1000
self.f0_min = 50
@@ -80,17 +81,18 @@ class RVC:
cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0] # n_spk
self.if_f0 = cpt.get("f0", 1)
self.version = cpt.get("version", "v1")
- if version == "v1":
- if if_f0 == 1:
+
+ if self.version == "v1":
+ if self.if_f0 == 1:
self.net_g = SynthesizerTrnMs256NSFsid(
- *cpt["config"], is_half=config.is_half
+ *cpt["config"], is_half=self.config.is_half
)
else:
self.net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- elif version == "v2":
- if if_f0 == 1:
+ elif self.version == "v2":
+ if self.if_f0 == 1:
self.net_g = SynthesizerTrnMs768NSFsid(
- *cpt["config"], is_half=config.is_half
+ *cpt["config"], is_half=self.config.is_half
)
else:
self.net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])