Update README.md

Co-authored-by: EntropyRiser <1832783120@qq.com>

.github/workflows/genlocale.yml

@@ -0,0 +1,32 @@
+name: genlocale
+on:
+  push:
+    branches:
+      - main
+jobs:
+  golangci:
+    name: genlocale
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out
+        uses: actions/checkout@master
+
+      - name: Run locale generation
+        run: |
+          python3 extract_locale.py
+          cd i18n && python3 locale_diff.py
+
+      - name: Commit back
+        if: ${{ !github.head_ref }}
+        continue-on-error: true
+        run: |
+          git config --local user.name 'github-actions[bot]'
+          git config --local user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git add --all
+          git commit -m "🎨 同步 locale"
+
+      - name: Create Pull Request
+        if: ${{ !github.head_ref }}
+        continue-on-error: true
+        uses: peter-evans/create-pull-request@v4
+  

.github/workflows/pull_format.yml

@@ -0,0 +1,35 @@
+name: pull format
+
+on: [pull_request]
+
+permissions:
+  contents: write
+jobs:
+  pull_format:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - name: checkout
+        continue-on-error: true
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.head_ref }}
+          fetch-depth: 0
+      
+          
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Black
+        run: pip install black
+
+      - name: Run Black
+        # run: black $(git ls-files '*.py')
+        run: black .
+
+      - name: Commit Back
+        uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: Apply Code Formatter Change

.github/workflows/push_format.yml

@@ -0,0 +1,46 @@
+name: push format
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+  pull-requests: write
+jobs:
+  push_format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: ${{github.ref_name}}
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Black
+        run: pip install black
+
+      - name: Run Black
+        # run: black $(git ls-files '*.py')
+        run: black .
+
+      - name: Commit Back
+        continue-on-error: true
+        id: commitback
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git add --all
+          git commit -m "Format code"
+      
+      - name: Create Pull Request
+        if: steps.commitback.outcome == 'success'
+        continue-on-error: true
+        uses: peter-evans/create-pull-request@v4
+        with:
+          body: Apply Code Formatter Change
+          commit-message: Automatic code format

.github/workflows/unitest.yml

@@ -0,0 +1,36 @@
+name: unitest
+on: [ push, pull_request ]
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-latest]
+      fail-fast: false
+
+    steps:
+    - uses: actions/checkout@master
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt -y install ffmpeg
+        sudo apt -y install -qq aria2
+        aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/hubert_base.pt -d ./ -o hubert_base.pt
+        python -m pip install --upgrade pip
+        python -m pip install --upgrade setuptools
+        python -m pip install --upgrade wheel
+        pip install torch torchvision torchaudio
+        pip install -r requirements.txt
+    - name: Test step 1 & 2
+      run: |
+        mkdir -p logs/mi-test
+        touch logs/mi-test/preprocess.log
+        python trainset_preprocess_pipeline_print.py logs/mute/0_gt_wavs 48000 8 logs/mi-test True
+        touch logs/mi-test/extract_f0_feature.log
+        python extract_f0_print.py logs/mi-test $(nproc) pm
+        python extract_feature_print.py cpu 1 0 0 logs/mi-test

Changelog_CN.md

@@ -1,15 +1,34 @@
-20230409
+### 20230409
+- 修正训练参数，提升显卡平均利用率，A100最高从25%提升至90%左右，V100:50%->90%左右，2060S:60%->85%左右，P40:25%->95%左右，训练速度显著提升
+- 修正参数：总batch_size改为每张卡的batch_size
+- 修正total_epoch：最大限制100解锁至1000；默认10提升至默认20
+- 修复ckpt提取识别是否带音高错误导致推理异常的问题
+- 修复分布式训练每个rank都保存一次ckpt的问题
+- 特征提取进行nan特征过滤
+- 修复静音输入输出随机辅音or噪声的问题（老版模型需要重做训练集重训）
 
-修正训练参数，提升显卡平均利用率，A100最高从25%提升至90%左右，V100:50%->90%左右，2060S:60%->85%左右，P40:25%->95%左右，训练速度显著提升
+### 20230416更新
+- 新增本地实时变声迷你GUI，双击go-realtime-gui.bat启动
+- 训练推理均对<50Hz的频段进行滤波过滤
+- 训练推理音高提取pyworld最低音高从默认80下降至50,50-80hz间的男声低音不会哑
+- WebUI支持根据系统区域变更语言（现支持en_US，ja_JP，zh_CN，zh_HK，zh_SG，zh_TW，不支持的默认en_US）
+- 修正部分显卡识别（例如V100-16G识别失败，P4识别失败）
 
-修正参数：总batch_size改为每张卡的batch_size
+### 20230428更新
+- 升级faiss索引设置，速度更快，质量更高
+- 取消total_npy依赖，后续分享模型不再需要填写total_npy
+- 解锁16系限制。4G显存GPU给到4G的推理设置。
+- 修复部分音频格式下UVR5人声伴奏分离的bug
+- 实时变声迷你gui增加对非40k与不懈怠音高模型的支持
 
-修正total_epoch：最大限制100解锁至1000；默认10提升至默认20
 
-修复ckpt提取识别是否带音高错误导致推理异常的问题
+### 后续计划：
+功能：
+- 增加选项:每次epoch保存的小模型均进行提取
+- 增加选项:推理额外导出mp3至填写的路径
 
-修复分布式训练每个rank都保存一次ckpt的问题
-
-特征提取进行nan特征过滤
-
-修复静音输入输出随机辅音or噪声的问题（老版模型需要重做训练集重训）
+底模：
+- 收集呼吸wav加入训练集修正呼吸变声电音的问题
+- 我们正在训练增加了歌声训练集的底模，未来会公开
+- 升级鉴别器
+- 升级自监督特征结构

README.md

@@ -1,91 +1,108 @@
-# Retrieval-based-Voice-Conversion-WebUI
-
-[![madewithlove](https://forthebadge.com/images/badges/built-with-love.svg)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI)
-
-[![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/github/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb)
-[![Licence](https://img.shields.io/github/license/liujing04/Retrieval-based-Voice-Conversion-WebUI?style=for-the-badge)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/%E4%BD%BF%E7%94%A8%E9%9C%80%E9%81%B5%E5%AE%88%E7%9A%84%E5%8D%8F%E8%AE%AE-LICENSE.txt)
-[![Huggingface](https://img.shields.io/badge/🤗%20-Spaces-blue.svg?style=for-the-badge)](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)
-
-### 使用了RVC的实时语音转换 : [w-okada/voice-changer](https://github.com/w-okada/voice-changer)
-------
-
-一个基于VITS的简单易用的语音转换（变声器）框架。
-
-[**更新日志**](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Changelog_CN.md)
-
-[**English**](./README_en.md) | [**中文简体**](./README.md)
-
-> 点此查看我们的[演示视频](https://www.bilibili.com/video/BV1pm4y1z7Gm/) !
-## 简介
-本仓库具有以下特点:
-+ 使用top1特征模型检索来杜绝音色泄漏；
-+ 即便在相对较差的显卡上也能快速训练;
-+ 使用少量数据进行训练也能得到较好结果;
-+ 可以通过模型融合来改变音色;
-+ 简单易用的WebUI界面;
-+ 可调用UVR5模型来快速分离人声和伴奏。
-+ 底模训练集使用接近50小时的高质量VCTK开源，后续会陆续加入高质量有授权歌声训练集供大家放心使用。
-## 环境配置
-我们推荐你使用poetry来配置环境。
-
-以下指令需在Python版本大于3.8的环境当中执行:
-```bash
-# 安装Pytorch及其核心依赖，若已安装则跳过
-# 参考自: https://pytorch.org/get-started/locally/
-pip install torch torchvision torchaudio
-
-如果是win系统+30系显卡，根据https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/issues/21的经验，需要指定pytorch对应的cuda版本
-
-pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117
-
-# 安装 Poetry 依赖管理工具, 若已安装则跳过
-# 参考自: https://python-poetry.org/docs/#installation
-curl -sSL https://install.python-poetry.org | python3 -
-
-# 通过poetry安装依赖
-poetry install
-```
-
-你也可以通过pip来安装依赖：
-```bash
-pip install -r requirements.txt
-```
-## 其他预模型准备
-RVC需要其他的一些预模型来推理和训练。
-
-你可以从我们的[Huggingface space](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)下载到这些模型。
-
-以下是一份清单，包括了所有RVC所需的预模型和其他文件的名称:
-```bash
-hubert_base.pt
-
-./pretrained 
-
-./uvr5_weights
-
-#如果你正在使用Windows，则你可能需要这个文件夹，若FFmpeg已安装则跳过
-./ffmpeg
-```
-之后使用以下指令来调用Webui:
-```bash
-python infer-web.py
-```
-如果你正在使用Windows，你可以直接下载并解压`RVC-beta.7z` 来使用RVC，运行`go-web.bat`来启动WebUI。
-
-我们将在两周内推出一个英文版本的WebUI.
-
-仓库内还有一份`小白简易教程.doc`以供参考。
-
-## 参考项目
-+ [ContentVec](https://github.com/auspicious3000/contentvec/)
-+ [VITS](https://github.com/jaywalnut310/vits)
-+ [HIFIGAN](https://github.com/jik876/hifi-gan)
-+ [Gradio](https://github.com/gradio-app/gradio)
-+ [FFmpeg](https://github.com/FFmpeg/FFmpeg)
-+ [Ultimate Vocal Remover](https://github.com/Anjok07/ultimatevocalremovergui)
-+ [audio-slicer](https://github.com/openvpi/audio-slicer)
-## 感谢所有贡献者作出的努力
-<a href="https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/graphs/contributors" target="_blank">
-  <img src="https://contrib.rocks/image?repo=liujing04/Retrieval-based-Voice-Conversion-WebUI" />
-</a>
-
+<div align="center">
+
+<h1>Retrieval-based-Voice-Conversion-WebUI</h1>
+一个基于VITS的简单易用的语音转换（变声器）框架<br><br>
+
+[![madewithlove](https://forthebadge.com/images/badges/built-with-love.svg)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI)
+
+<img src="https://counter.seku.su/cmoe?name=rvc&theme=r34" /><br>
+
+[![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/github/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb)
+[![Licence](https://img.shields.io/github/license/liujing04/Retrieval-based-Voice-Conversion-WebUI?style=for-the-badge)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/%E4%BD%BF%E7%94%A8%E9%9C%80%E9%81%B5%E5%AE%88%E7%9A%84%E5%8D%8F%E8%AE%AE-LICENSE.txt)
+[![Huggingface](https://img.shields.io/badge/🤗%20-Spaces-yellow.svg?style=for-the-badge)](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)
+
+[![Discord](https://img.shields.io/badge/RVC%20Developers-Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/HcsmBBGyVk)
+
+</div>
+
+------
+
+[**更新日志**](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Changelog_CN.md)
+
+[**English**](./docs/README.en.md) | [**中文简体**](./README.md) | [**日本語**](./docs/README.ja.md) | [**한국어**](./docs/README.ko.md)
+
+
+> 点此查看我们的[演示视频](https://www.bilibili.com/video/BV1pm4y1z7Gm/) !
+
+> 使用了RVC的实时语音转换: [w-okada/voice-changer](https://github.com/w-okada/voice-changer)
+
+> 底模使用接近50小时的开源高质量VCTK训练集训练，无版权方面的顾虑，请大家放心使用
+
+> 后续会陆续加入高质量有授权歌声训练集训练底模
+
+## 简介
+本仓库具有以下特点
++ 使用top1检索替换输入源特征为训练集特征来杜绝音色泄漏
++ 即便在相对较差的显卡上也能快速训练
++ 使用少量数据进行训练也能得到较好结果(推荐至少收集10分钟低底噪语音数据)
++ 可以通过模型融合来改变音色(借助ckpt处理选项卡中的ckpt-merge)
++ 简单易用的网页界面
++ 可调用UVR5模型来快速分离人声和伴奏
+
+## 环境配置
+推荐使用poetry配置环境。
+
+以下指令需在Python版本大于3.8的环境中执行:
+```bash
+# 安装Pytorch及其核心依赖，若已安装则跳过
+# 参考自: https://pytorch.org/get-started/locally/
+pip install torch torchvision torchaudio
+
+#如果是win系统+Nvidia Ampere架构(RTX30xx)，根据 #21 的经验，需要指定pytorch对应的cuda版本
+#pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117
+
+# 安装 Poetry 依赖管理工具, 若已安装则跳过
+# 参考自: https://python-poetry.org/docs/#installation
+curl -sSL https://install.python-poetry.org | python3 -
+
+# 通过poetry安装依赖
+poetry install
+```
+
+你也可以通过pip来安装依赖：
+
+**注意**: `MacOS`下`faiss 1.7.2`版本会导致抛出段错误，在手动安装时请使用命令`pip install faiss-cpu==1.7.0`指定使用`1.7.0`版本
+
+```bash
+pip install -r requirements.txt
+```
+
+## 其他预模型准备
+RVC需要其他一些预模型来推理和训练。
+
+你可以从我们的[Hugging Face space](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)下载到这些模型。
+
+以下是一份清单，包括了所有RVC所需的预模型和其他文件的名称:
+```bash
+hubert_base.pt
+
+./pretrained 
+
+./uvr5_weights
+
+#如果你正在使用Windows，则你可能需要这个文件，若ffmpeg和ffprobe已安装则跳过; ubuntu/debian 用户可以通过apt install ffmpeg来安装这2个库
+./ffmpeg
+
+./ffprobe
+```
+之后使用以下指令来启动WebUI:
+```bash
+python infer-web.py
+```
+如果你正在使用Windows，你可以直接下载并解压`RVC-beta.7z`，运行`go-web.bat`以启动WebUI。
+
+仓库内还有一份`小白简易教程.doc`以供参考。
+
+## 参考项目
++ [ContentVec](https://github.com/auspicious3000/contentvec/)
++ [VITS](https://github.com/jaywalnut310/vits)
++ [HIFIGAN](https://github.com/jik876/hifi-gan)
++ [Gradio](https://github.com/gradio-app/gradio)
++ [FFmpeg](https://github.com/FFmpeg/FFmpeg)
++ [Ultimate Vocal Remover](https://github.com/Anjok07/ultimatevocalremovergui)
++ [audio-slicer](https://github.com/openvpi/audio-slicer)
+
+## 感谢所有贡献者作出的努力
+<a href="https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/graphs/contributors" target="_blank">
+  <img src="https://contrib.rocks/image?repo=liujing04/Retrieval-based-Voice-Conversion-WebUI" />
+</a>

README_v0.md

@@ -1,32 +0,0 @@
-# Retrieval-based-Voice-Conversion-WebUI
-
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb)
-
-缺失的2个文件夹和2个文件：
-
-hubert_base.pt
-
-ffmpeg（自己确保ffmpeg命令能执行就行）
-
-pretrained文件夹
-
-uvr5_weights文件夹
-
-文件太大github传不动，去huggingface上下https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main
-
-当然你也可以直接看看RVC-beta.7z这个文件→_→
-
-按照requirements.txt用pip装好环境，python infer-web.py就能用了
-
-根据经验，librosa numpy和numba三个包最好写死版本否则容易有坑，其他的包版本不太重要
-
-宣传视频：https://www.bilibili.com/video/BV1pm4y1z7Gm/
-
-教程见小白简易教程.doc
-
-We will develop an English version windows WebUI APP in 2 weeks.
-
-
-### Realtime Voice Conversion Software using RVC
-
-https://github.com/w-okada/voice-changer

RVC改进意见.txt

@@ -1,36 +0,0 @@
-ToDo：
-
-停车按钮
-
-根据每E时间推测训练剩余时间
-
-记录点Demo:
-推理时可以选择哪些记录点，然后批量自动推理出demo以便对比节点过拟合和欠拟合情况
-训练时可以自动推理每个保存节点的Demo便于实时听过拟合和欠拟合[可单独选择一张推理用卡]
-
-训练队列:
-可以队列训练列表，训练结束后自动进行下一个训练
-
-配置文件保存:
-WebUI的预设可以保存为配置文件，下次启动时自动读取
-
-推理自动选择特征库检索文件
-
-Epoch和保存频率、Batch size等可以从滑条改为一个纵向的输入数字的配置面板
-
-WebUI可以重新布局？ 详情参考目录下的WebUI_参考(目前尚未建立)
-
-模型推理可以做成单次拖拽类的
-
-
-个人的小想法:
-可以试着接入一些类似于Vocaloid的工程文件来读取F0音高曲线？
-比如SV,ACE,Vocaloid,Cevio Studio这种歌声合成软件
-然后再给到f0编辑器(如果有了)
-
-能暴露接口然后可以用QT做个桌面程序？毕竟QT也是跨平台的
-可以给到一个端口，让他们在云端跑，本地跑这个QT程序桌面程序来控制云端的训练和推理？
-
-
-
-IsDo:

Retrieval_based_Voice_Conversion_WebUI.ipynb

@@ -1,12 +1,30 @@
 {
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "private_outputs": true,
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU",
+    "gpuClass": "standard"
+  },
   "cells": [
     {
-      "attachments": {},
       "cell_type": "markdown",
-      "metadata": {},
       "source": [
         "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb)"
-      ]
+      ],
+      "metadata": {
+        "id": "ZFFCx5J80SGa"
+      }
     },
     {
       "cell_type": "code",
@@ -22,56 +40,62 @@
     },
     {
       "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"
-      ]
+      ],
+      "metadata": {
+        "id": "wjddIFr1oS3W"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "ge_97mfpgqTm"
-      },
-      "outputs": [],
       "source": [
         "#@title 克隆仓库\n",
         "\n",
-        "!git clone --depth=1 https://github.com/fumiama/Retrieval-based-Voice-Conversion-WebUI\n",
+        "!git clone --depth=1 -b stable https://github.com/fumiama/Retrieval-based-Voice-Conversion-WebUI\n",
         "%cd /content/Retrieval-based-Voice-Conversion-WebUI\n",
         "!mkdir -p pretrained uvr5_weights"
-      ]
+      ],
+      "metadata": {
+        "id": "ge_97mfpgqTm"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "BLDEZADkvlw1"
-      },
-      "outputs": [],
       "source": [
         "#@title 更新仓库（一般无需执行）\n",
         "!git pull"
-      ]
+      ],
+      "metadata": {
+        "id": "BLDEZADkvlw1"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "source": [
+        "#@title 安装aria2\n",
+        "!apt -y install -qq aria2"
+      ],
       "metadata": {
-        "id": "UG3XpUwEomUz"
+        "id": "pqE0PrnuRqI2"
       },
-      "outputs": [],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
       "source": [
         "#@title 下载底模\n",
-        "!apt -y install -qq aria2\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",
@@ -83,53 +107,100 @@
         "!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",
-        "!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\n",
-        "\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"
-      ]
+        "!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"
+      ],
+      "metadata": {
+        "id": "UG3XpUwEomUz"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "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"
+      ],
       "metadata": {
-        "id": "Mwk7Q0Loqzjx"
+        "id": "HugjmZqZRuiF"
       },
-      "outputs": [],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "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"
+      ],
+      "metadata": {
+        "id": "2RCaT9FTR0ej"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title 挂载谷歌云盘\n",
+        "\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "id": "jwu07JgqoFON"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
       "source": [
         "#@title 从谷歌云盘加载打包好的数据集到/content/dataset\n",
         "\n",
         "#@markdown 数据集位置\n",
         "DATASET = \"/content/drive/MyDrive/dataset/lulu20230327_32k.zip\"  #@param {type:\"string\"}\n",
         "\n",
-        "from google.colab import drive\n",
-        "drive.mount('/content/drive')\n",
         "!mkdir -p /content/dataset\n",
-        "!unzip -d /content/dataset {DATASET}"
-      ]
+        "!unzip -d /content/dataset -B {DATASET}"
+      ],
+      "metadata": {
+        "id": "Mwk7Q0Loqzjx"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "source": [
+        "#@title 重命名数据集中的重名文件\n",
+        "!ls -a /content/dataset/\n",
+        "!rename 's/(\\w+)\\.(\\w+)~(\\d*)/$1_$3.$2/' /content/dataset/*.*~*"
+      ],
       "metadata": {
-        "id": "7vh6vphDwO0b"
+        "id": "PDlFxWHWEynD"
       },
-      "outputs": [],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
       "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"
-      ]
+      ],
+      "metadata": {
+        "id": "7vh6vphDwO0b"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "FgJuNeAwx5Y_"
-      },
-      "outputs": [],
       "source": [
         "#@title 手动将训练后的模型文件备份到谷歌云盘\n",
         "#@markdown 需要自己查看logs文件夹下模型的文件名，手动修改下方命令末尾的文件名\n",
@@ -137,7 +208,7 @@
         "#@markdown 模型名\n",
         "MODELNAME = \"lulu\"  #@param {type:\"string\"}\n",
         "#@markdown 模型epoch\n",
-        "MODELEPOCH = 6600  #@param {type:\"integer\"}\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",
@@ -145,15 +216,15 @@
         "!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"
-      ]
+      ],
+      "metadata": {
+        "id": "FgJuNeAwx5Y_"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "OVQoLQJXS7WX"
-      },
-      "outputs": [],
       "source": [
         "#@title 从谷歌云盘恢复pth\n",
         "#@markdown 需要自己查看logs文件夹下模型的文件名，手动修改下方命令末尾的文件名\n",
@@ -161,7 +232,7 @@
         "#@markdown 模型名\n",
         "MODELNAME = \"lulu\"  #@param {type:\"string\"}\n",
         "#@markdown 模型epoch\n",
-        "MODELEPOCH = 250  #@param {type:\"integer\"}\n",
+        "MODELEPOCH = 7500  #@param {type:\"integer\"}\n",
         "\n",
         "!mkdir -p /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}\n",
         "\n",
@@ -170,72 +241,90 @@
         "!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"
-      ]
+      ],
+      "metadata": {
+        "id": "OVQoLQJXS7WX"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "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 32000 8 logs/{MODELNAME} True\n"
-      ]
+        "!python3 trainset_preprocess_pipeline_print.py /content/dataset {BITRATE} {THREADCOUNT} logs/{MODELNAME} True\n"
+      ],
+      "metadata": {
+        "id": "ZKAyuKb9J6dz"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "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_feature_print.py 1 0 0 logs/{MODELNAME}\n"
-      ]
+        "!python3 extract_f0_print.py logs/{MODELNAME} {THREADCOUNT} {ALGO}\n",
+        "\n",
+        "!python3 extract_feature_print.py cpu 1 0 0 logs/{MODELNAME}\n"
+      ],
+      "metadata": {
+        "id": "CrxJqzAUKmPJ"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "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 = 700  #@param {type:\"integer\"}\n",
+        "MODELEPOCH = 3200  #@param {type:\"integer\"}\n",
         "#@markdown 保存epoch间隔\n",
-        "EPOCHSAVE = 20  #@param {type:\"integer\"}\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 32 -g 0 -te {MODELEPOCH} -se {EPOCHSAVE} -pg pretrained/f0G{MODELSAMPLE}.pth -pd pretrained/f0D{MODELSAMPLE}.pth -l 0 -c 1\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"
+      ],
+      "metadata": {
+        "id": "IMLPLKOaKj58"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "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 = 6600  #@param {type:\"integer\"}\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",
@@ -251,21 +340,21 @@
         "\n",
         "!echo \"删除完成\"\n",
         "!ls /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}"
-      ]
+      ],
+      "metadata": {
+        "id": "haYA81hySuDl"
+      },
+      "execution_count": null,
+      "outputs": []
     },
     {
       "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 = 1500  #@param {type:\"integer\"}\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",
@@ -281,24 +370,12 @@
         "\n",
         "!echo \"删除完成\"\n",
         "!ls /content/Retrieval-based-Voice-Conversion-WebUI/logs/{MODELNAME}"
-      ]
+      ],
+      "metadata": {
+        "id": "QhSiPTVPoIRh"
+      },
+      "execution_count": null,
+      "outputs": []
     }
-  ],
-  "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
-}
+  ]
+}

config.py

@@ -1,50 +1,106 @@
+########################硬件参数########################
+
+# 填写cuda:x, cpu 或 mps, x指代第几张卡，只支持 N卡 / Apple Silicon 加速
+device = "cuda:0"
+
+# 9-10-20-30-40系显卡无脑True，不影响质量，>=20显卡开启有加速
+is_half = True
+
+# 默认0用上所有线程，写数字限制CPU资源使用
+n_cpu = 0
+
+########################硬件参数########################
+
+
+##################下为参数处理逻辑，勿动##################
+
+########################命令行参数########################
 import argparse
+
 parser = argparse.ArgumentParser()
 parser.add_argument("--port", type=int, default=7865, help="Listen port")
 parser.add_argument("--pycmd", type=str, default="python", help="Python command")
-parser.add_argument("--colab", action='store_true', help="Launch in colab")
-parser.add_argument("--noparallel", action='store_true', help="Disable parallel processing")
+parser.add_argument("--colab", action="store_true", help="Launch in colab")
+parser.add_argument(
+    "--noparallel", action="store_true", help="Disable parallel processing"
+)
+parser.add_argument(
+    "--noautoopen", action="store_true", help="Do not open in browser automatically"
+)
 cmd_opts = parser.parse_args()
-############离线VC参数
-inp_root=r"白鹭霜华长条"#对输入目录下所有音频进行转换，别放非音频文件
-opt_root=r"opt"#输出目录
-f0_up_key=0#升降调，整数，男转女12，女转男-12
-person=r"weights\洛天依v3.pt"#目前只有洛天依v3
-############硬件参数
-device = "cuda:0"#填写cuda:x或cpu，x指代第几张卡，只支持N卡加速
-is_half=True#9-10-20-30-40系显卡无脑True，不影响质量，>=20显卡开启有加速
-n_cpu=0#默认0用上所有线程，写数字限制CPU资源使用
-############python命令路径
-python_cmd=cmd_opts.pycmd
-listen_port=cmd_opts.port
-iscolab=cmd_opts.colab
-noparallel=cmd_opts.noparallel
-############下头别动
+
+python_cmd = cmd_opts.pycmd
+listen_port = cmd_opts.port if 0 <= cmd_opts.port <= 65535 else 7865
+iscolab = cmd_opts.colab
+noparallel = cmd_opts.noparallel
+noautoopen = cmd_opts.noautoopen
+########################命令行参数########################
+
+import sys
 import torch
-if(torch.cuda.is_available()==False):
-    print("没有发现支持的N卡, 使用CPU进行推理")
-    device="cpu"
-    is_half=False
-if(device!="cpu"):
-    gpu_name=torch.cuda.get_device_name(int(device.split(":")[-1]))
-    if("16"in gpu_name or "MX"in gpu_name):
-        print("16系显卡/MX系显卡强制单精度")
-        is_half=False
+
+
+# has_mps is only available in nightly pytorch (for now) and MasOS 12.3+.
+# check `getattr` and try it for compatibility
+def has_mps() -> bool:
+    if sys.platform != "darwin":
+        return False
+    else:
+        if not getattr(torch, "has_mps", False):
+            return False
+        try:
+            torch.zeros(1).to(torch.device("mps"))
+            return True
+        except Exception:
+            return False
+
+
+if not torch.cuda.is_available():
+    if has_mps():
+        print("没有发现支持的N卡, 使用MPS进行推理")
+        device = "mps"
+    else:
+        print("没有发现支持的N卡, 使用CPU进行推理")
+        device = "cpu"
+        is_half = False
+
+gpu_mem=None
+if device not in ["cpu", "mps"]:
+    i_device=int(device.split(":")[-1])
+    gpu_name = torch.cuda.get_device_name(i_device)
+    if "16" in gpu_name or "P40"in gpu_name.upper() or "1070"in gpu_name or "1080"in gpu_name:
+        print("16系显卡强制单精度")
+        is_half = False
+        with open("configs/32k.json","r")as f:strr=f.read().replace("true","false")
+        with open("configs/32k.json","w")as f:f.write(strr)
+        with open("configs/40k.json","r")as f:strr=f.read().replace("true","false")
+        with open("configs/40k.json","w")as f:f.write(strr)
+        with open("configs/48k.json","r")as f:strr=f.read().replace("true","false")
+        with open("configs/48k.json","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)
+    gpu_mem=int(torch.cuda.get_device_properties(i_device).total_memory/1024/1024/1024+0.4)
+    if(gpu_mem<=4):
+        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)
 from multiprocessing import cpu_count
-if(n_cpu==0):n_cpu=cpu_count()
-if(is_half==True):
-    #6G显存配置
-    x_pad       =   3
-    x_query     =   10
-    x_center    =   60
-    x_max       =   65
+
+if n_cpu == 0:
+    n_cpu = cpu_count()
+if is_half:
+    # 6G显存配置
+    x_pad = 3
+    x_query = 10
+    x_center = 60
+    x_max = 65
 else:
-    #5G显存配置
-    x_pad       =   1
-    # x_query     =   6
-    # x_center    =   30
-    # x_max       =   32
-    #6G显存配置
-    x_query     =   6
-    x_center    =   38
-    x_max       =   41
+    # 5G显存配置
+    x_pad = 1
+    x_query = 6
+    x_center = 38
+    x_max = 41
+if(gpu_mem!=None and gpu_mem<=4):
+    x_pad = 1
+    x_query = 5
+    x_center = 30
+    x_max = 32

docs/README.en.md

@@ -1,79 +1,102 @@
-# Retrieval-based-Voice-Conversion-WebUI
-
-[![madewithlove](https://forthebadge.com/images/badges/built-with-love.svg)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI)
-
-[![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/github/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb)
-[![Licence](https://img.shields.io/github/license/liujing04/Retrieval-based-Voice-Conversion-WebUI?style=for-the-badge)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/%E4%BD%BF%E7%94%A8%E9%9C%80%E9%81%B5%E5%AE%88%E7%9A%84%E5%8D%8F%E8%AE%AE-LICENSE.txt)
-[![Huggingface](https://img.shields.io/badge/🤗%20-Spaces-blue.svg?style=for-the-badge)](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)
-
-### Realtime Voice Conversion Software using RVC : [w-okada/voice-changer](https://github.com/w-okada/voice-changer)
-------
-
-An easy-to-use SVC framework based on VITS.
-
-[**English**](./README.md) | [**中文简体**](./README_zh_CN.md)
-
-> Check our [Demo Video](https://www.bilibili.com/video/BV1pm4y1z7Gm/) here!
-## Summary
-This repository has the following features:
-+ Using top1 feature model retrieval to reduce tone leakage;
-+ Easy and fast training, even on relatively poor graphics cards;
-+ Training with a small amount of data also obtains relatively good results;
-+ Supporting model fusion to change timbres;
-+ Easy-to-use Webui interface;
-+ Use the UVR5 model to quickly separate vocals and instruments.
-## Preparing the environment
-We recommend you install the dependencies through poetry.
-
-The following commands need to be executed in the environment of Python version 3.8 or higher:
-```bash
-# Install PyTorch-related core dependencies, skip if installed
-# Reference: https://pytorch.org/get-started/locally/
-pip install torch torchvision torchaudio
-
-# Install the Poetry dependency management tool, skip if installed
-# Reference: https://python-poetry.org/docs/#installation
-curl -sSL https://install.python-poetry.org | python3 -
-
-# Install the project dependencies
-poetry install
-```
-You can also use pip to install the dependencies
-
-```bash
-pip install -r requirements.txt
-```
-## Preparation of other Pre-models
-RVC requires other pre-models to infer and train.
-
-You need to download them from our [Huggingface space](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/).
-
-Here's a list of Pre-models and other files that RVC needs:
-```bash
-hubert_base.pt
-
-./pretrained 
-
-./uvr5_weights
-
-#If you are using Windows, you may also need this dictionary, skip if FFmpeg is installed
-ffmpeg.exe
-```
-Then use this command to start Webui:
-```bash
-python infer-web.py
-```
-If you are using Windows, you can download and extract `RVC-beta.7z` to use RVC directly and use `go-web.bat` to start Webui.
-
-We will develop an English version of the WebUI in 2 weeks.
-
-There's also a tutorial on RVC in Chinese and you can check it out if needed.
-
-## Credits
-
-## Thanks to all contributors for their efforts
-
-<a href="https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/graphs/contributors" target="_blank">
-  <img src="https://contrib.rocks/image?repo=liujing04/Retrieval-based-Voice-Conversion-WebUI" />
-</a>
-
+<div align="center">
+
+<h1>Retrieval-based-Voice-Conversion-WebUI</h1>
+An easy-to-use SVC framework based on VITS.<br><br>
+
+[![madewithlove](https://forthebadge.com/images/badges/built-with-love.svg)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI)
+  
+<img src="https://counter.seku.su/cmoe?name=rvc&theme=r34" /><br>
+  
+[![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/github/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb)
+[![Licence](https://img.shields.io/github/license/liujing04/Retrieval-based-Voice-Conversion-WebUI?style=for-the-badge)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/%E4%BD%BF%E7%94%A8%E9%9C%80%E9%81%B5%E5%AE%88%E7%9A%84%E5%8D%8F%E8%AE%AE-LICENSE.txt)
+[![Huggingface](https://img.shields.io/badge/🤗%20-Spaces-yellow.svg?style=for-the-badge)](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)
+
+[![Discord](https://img.shields.io/badge/RVC%20Developers-Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/HcsmBBGyVk)
+
+</div>
+
+------
+[**Changelog**](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Changelog_CN.md)
+
+[**English**](./README.en.md) | [**中文简体**](../README.md) | [**日本語**](./README.ja.md) | [**한국어**](./README.ko.md)
+
+> Check our [Demo Video](https://www.bilibili.com/video/BV1pm4y1z7Gm/) here!
+
+> Realtime Voice Conversion Software using RVC : [w-okada/voice-changer](https://github.com/w-okada/voice-changer)
+
+> The dataset for the pre-training model uses nearly 50 hours of high quality VCTK open source dataset.
+
+> High quality licensed song datasets will be added to training-set one after another for your use, without worrying about copyright infringement.
+## Summary
+This repository has the following features:
++ Reduce tone leakage by replacing source feature to training-set feature using top1 retrieval;
++ Easy and fast training, even on relatively poor graphics cards;
++ Training with a small amount of data also obtains relatively good results (>=10min low noise speech recommended);
++ Supporting model fusion to change timbres (using ckpt processing tab->ckpt merge);
++ Easy-to-use Webui interface;
++ Use the UVR5 model to quickly separate vocals and instruments.
+## Preparing the environment
+We recommend you install the dependencies through poetry.
+
+The following commands need to be executed in the environment of Python version 3.8 or higher:
+```bash
+# Install PyTorch-related core dependencies, skip if installed
+# Reference: https://pytorch.org/get-started/locally/
+pip install torch torchvision torchaudio
+
+#For Windows + Nvidia Ampere Architecture(RTX30xx), you need to specify the cuda version corresponding to pytorch according to the experience of https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/issues/21
+#pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117
+
+# Install the Poetry dependency management tool, skip if installed
+# Reference: https://python-poetry.org/docs/#installation
+curl -sSL https://install.python-poetry.org | python3 -
+
+# Install the project dependencies
+poetry install
+```
+You can also use pip to install the dependencies
+
+**Notice**: `faiss 1.7.2` will raise Segmentation Fault: 11 under `MacOS`, please use `pip install faiss-cpu==1.7.0` if you use pip to install it manually.
+
+```bash
+pip install -r requirements.txt
+```
+
+## Preparation of other Pre-models
+RVC requires other pre-models to infer and train.
+
+You need to download them from our [Huggingface space](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/).
+
+Here's a list of Pre-models and other files that RVC needs:
+```bash
+hubert_base.pt
+
+./pretrained 
+
+./uvr5_weights
+
+#If you are using Windows, you may also need this dictionary, skip if FFmpeg is installed
+ffmpeg.exe
+```
+Then use this command to start Webui:
+```bash
+python infer-web.py
+```
+If you are using Windows, you can download and extract `RVC-beta.7z` to use RVC directly and use `go-web.bat` to start Webui.
+
+There's also a tutorial on RVC in Chinese and you can check it out if needed.
+
+## Credits
++ [ContentVec](https://github.com/auspicious3000/contentvec/)
++ [VITS](https://github.com/jaywalnut310/vits)
++ [HIFIGAN](https://github.com/jik876/hifi-gan)
++ [Gradio](https://github.com/gradio-app/gradio)
++ [FFmpeg](https://github.com/FFmpeg/FFmpeg)
++ [Ultimate Vocal Remover](https://github.com/Anjok07/ultimatevocalremovergui)
++ [audio-slicer](https://github.com/openvpi/audio-slicer)
+## Thanks to all contributors for their efforts
+
+<a href="https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/graphs/contributors" target="_blank">
+  <img src="https://contrib.rocks/image?repo=liujing04/Retrieval-based-Voice-Conversion-WebUI" />
+</a>
+

docs/README.ja.md

@@ -0,0 +1,106 @@
+<div align="center">
+
+<h1>Retrieval-based-Voice-Conversion-WebUI</h1>
+VITSに基づく使いやすい音声変換（voice changer）framework<br><br>
+
+[![madewithlove](https://forthebadge.com/images/badges/built-with-love.svg)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI)
+
+<img src="https://counter.seku.su/cmoe?name=rvc&theme=r34" /><br>
+
+[![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/github/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb)
+[![Licence](https://img.shields.io/github/license/liujing04/Retrieval-based-Voice-Conversion-WebUI?style=for-the-badge)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/%E4%BD%BF%E7%94%A8%E9%9C%80%E9%81%B5%E5%AE%88%E7%9A%84%E5%8D%8F%E8%AE%AE-LICENSE.txt)
+[![Huggingface](https://img.shields.io/badge/🤗%20-Spaces-yellow.svg?style=for-the-badge)](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)
+
+[![Discord](https://img.shields.io/badge/RVC%20Developers-Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/HcsmBBGyVk)
+
+</div>
+
+------
+
+[**更新日誌**](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Changelog_CN.md)
+
+[**English**](./README.en.md) | [**中文简体**](../README.md) | [**日本語**](./README.ja.md) | [**한국어**](./README.ko.md)
+
+> デモ動画は[こちら](https://www.bilibili.com/video/BV1pm4y1z7Gm/)でご覧ください。
+
+> RVCによるリアルタイム音声変換: [w-okada/voice-changer](https://github.com/w-okada/voice-changer)
+
+> 著作権侵害を心配することなく使用できるように、基底モデルは約50時間の高品質なオープンソースデータセットで訓練されています。
+
+> 今後も、次々と使用許可のある高品質な歌声の資料集を追加し、基底モデルを訓練する予定です。
+
+## はじめに
+本リポジトリには下記の特徴があります。
+
++ Top1検索を用いることで、生の特徴量を訓練用データセット特徴量に変換し、トーンリーケージを削減します。
++ 比較的貧弱なGPUでも、高速かつ簡単に訓練できます。
++ 少量のデータセットからでも、比較的良い結果を得ることができます。（10分以上のノイズの少ない音声を推奨します。）
++ モデルを融合することで、音声を混ぜることができます。（ckpt processingタブの、ckpt mergeを使用します。）
++ 使いやすいWebUI。
++ UVR5 Modelも含んでいるため、人の声とBGMを素早く分離できます。
+
+## 環境構築
+Poetryで依存関係をインストールすることをお勧めします。
+
+下記のコマンドは、Python3.8以上の環境で実行する必要があります:
+```bash
+# PyTorch関連の依存関係をインストール。インストール済の場合は省略。
+# 参照先: https://pytorch.org/get-started/locally/
+pip install torch torchvision torchaudio
+
+#Windows＋ Nvidia Ampere Architecture(RTX30xx)の場合、 #21 に従い、pytorchに対応するcuda versionを指定する必要があります。
+#pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117
+
+# PyTorch関連の依存関係をインストール。インストール済の場合は省略。
+# 参照先: https://python-poetry.org/docs/#installation
+curl -sSL https://install.python-poetry.org | python3 -
+
+# Poetry経由で依存関係をインストール
+poetry install
+```
+
+pipでも依存関係のインストールが可能です:
+
+**注意**:`faiss 1.7.2`は`macOS`で`Segmentation Fault: 11`を起こすので、マニュアルインストールする場合は、 `pip install faiss-cpu==1.7.0`を実行してください。
+
+```bash
+pip install -r requirements.txt
+```
+
+## 基底modelsを準備
+RVCは推論/訓練のために、様々な事前訓練を行った基底モデルを必要とします。
+
+modelsは[Hugging Face space](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)からダウンロードできます。
+
+以下は、RVCに必要な基底モデルやその他のファイルの一覧です。
+```bash
+hubert_base.pt
+
+./pretrained 
+
+./uvr5_weights
+
+# ffmpegがすでにinstallされている場合は省略
+./ffmpeg
+```
+その後、下記のコマンドでWebUIを起動します。
+```bash
+python infer-web.py
+```
+Windowsをお使いの方は、直接`RVC-beta.7z`をダウンロード後に展開し、`go-web.bat`をクリックすることで、WebUIを起動することができます。(7zipが必要です。)
+
+また、リポジトリに[小白简易教程.doc](./小白简易教程.doc)がありますので、参考にしてください（中国語版のみ）。
+
+## 参考プロジェクト
++ [ContentVec](https://github.com/auspicious3000/contentvec/)
++ [VITS](https://github.com/jaywalnut310/vits)
++ [HIFIGAN](https://github.com/jik876/hifi-gan)
++ [Gradio](https://github.com/gradio-app/gradio)
++ [FFmpeg](https://github.com/FFmpeg/FFmpeg)
++ [Ultimate Vocal Remover](https://github.com/Anjok07/ultimatevocalremovergui)
++ [audio-slicer](https://github.com/openvpi/audio-slicer)
+
+## 貢献者(contributor)の皆様の尽力に感謝します
+<a href="https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/graphs/contributors" target="_blank">
+  <img src="https://contrib.rocks/image?repo=liujing04/Retrieval-based-Voice-Conversion-WebUI" />
+</a>

docs/README.ko.md

@@ -0,0 +1,104 @@
+<div align="center">
+
+<h1>Retrieval-based-Voice-Conversion-WebUI</h1>
+VITS 기반의 간단하고 사용하기 쉬운 음성 변환 프레임워크.<br><br>
+
+[![madewithlove](https://forthebadge.com/images/badges/built-with-love.svg)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI)
+  
+<img src="https://counter.seku.su/cmoe?name=rvc&theme=r34" /><br>
+  
+[![Open In Colab](https://img.shields.io/badge/Colab-F9AB00?style=for-the-badge&logo=googlecolab&color=525252)](https://colab.research.google.com/github/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Retrieval_based_Voice_Conversion_WebUI.ipynb)
+[![Licence](https://img.shields.io/github/license/liujing04/Retrieval-based-Voice-Conversion-WebUI?style=for-the-badge)](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/%E4%BD%BF%E7%94%A8%E9%9C%80%E9%81%B5%E5%AE%88%E7%9A%84%E5%8D%8F%E8%AE%AE-LICENSE.txt)
+[![Huggingface](https://img.shields.io/badge/🤗%20-Spaces-yellow.svg?style=for-the-badge)](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)
+
+[![Discord](https://img.shields.io/badge/RVC%20Developers-Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/HcsmBBGyVk)
+
+</div>
+
+------
+[**업데이트 로그**](https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/blob/main/Changelog_CN.md)
+
+[**English**](./README.en.md) | [**中文简体**](../README.md) | [**日本語**](./README.ja.md) | [**한국어**](./README.ko.md)
+
+> [데모 영상](https://www.bilibili.com/video/BV1pm4y1z7Gm/)을 확인해 보세요!
+
+> RVC를 활용한 실시간 음성변환: [w-okada/voice-changer](https://github.com/w-okada/voice-changer)
+
+> 기본 모델은 50시간 가량의 고퀄리티 오픈 소스 VCTK 데이터셋을 사용하였으므로, 저작권상의 염려가 없으니 안심하고 사용하시기 바랍니다.
+
+> 저작권 문제가 없는 고퀄리티의 노래를 이후에도 계속해서 훈련할 예정입니다.
+
+## 소개
+본 Repo는 다음과 같은 특징을 가지고 있습니다:
++ top1 검색을 이용하여 입력 소스 기능을 훈련 세트 기능으로 대체하여 음색의 누출을 방지;
++ 상대적으로 낮은 성능의 GPU에서도 빠른 훈련 가능;
++ 적은 양의 데이터로 훈련해도 좋은 결과를 얻을 수 있음 (최소 10분 이상의 저잡음 음성 데이터를 사용하는 것을 권장);
++ 모델 융합을 통한 음색의 변조 가능 (ckpt 처리 탭->ckpt 병합 선택);
++ 사용하기 쉬운 WebUI (웹 인터페이스);
++ UVR5 모델을 이용하여 목소리와 배경음악의 빠른 분리;
+
+## 환경의 준비
+poetry를 통해 dependecies를 설치하는 것을 권장합니다.
+
+다음 명령은 Python 버전 3.8 이상의 환경에서 실행되어야 합니다:
+```bash
+# PyTorch 관련 주요 dependencies 설치, 이미 설치되어 있는 경우 건너뛰기 가능
+# 참조: https://pytorch.org/get-started/locally/
+pip install torch torchvision torchaudio
+
+# Windows + Nvidia Ampere Architecture(RTX30xx)를 사용하고 있다면, https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/issues/21 에서 명시된 것과 같이 PyTorch에 맞는 CUDA 버전을 지정해야 합니다.
+#pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117
+
+# Poetry 설치, 이미 설치되어 있는 경우 건너뛰기 가능
+# Reference: https://python-poetry.org/docs/#installation
+curl -sSL https://install.python-poetry.org | python3 -
+
+# Dependecies 설치
+poetry install
+```
+pip를 활용하여 dependencies를 설치하여도 무방합니다.
+
+**공지**: `MacOS`에서 `faiss 1.7.2`를 사용하면 Segmentation Fault: 11 오류가 발생할 수 있습니다. 수동으로 pip를 사용하여 설치하는 경우 `pip install faiss-cpu==1.7.0`을 사용해야 합니다.
+
+```bash
+pip install -r requirements.txt
+```
+
+## 기타 사전 모델 준비
+RVC 모델은 추론과 훈련을 위하여 다른 사전 모델이 필요합니다.
+
+[Huggingface space](https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main/)를 통해서 다운로드 할 수 있습니다.
+
+다음은 RVC에 필요한 사전 모델 및 기타 파일 목록입니다:
+```bash
+hubert_base.pt
+
+./pretrained 
+
+./uvr5_weights
+
+# Windows를 사용하는 경우 이 사전도 필요할 수 있습니다. FFmpeg가 설치되어 있으면 건너뛰어도 됩니다.
+ffmpeg.exe
+```
+그 후 이하의 명령을 사용하여 WebUI를 시작할 수 있습니다:
+```bash
+python infer-web.py
+```
+Windows를 사용하는 경우 `RVC-beta.7z`를 다운로드 및 압축 해제하여 RVC를 직접 사용하거나 `go-web.bat`을 사용하여 WebUi를 시작할 수 있습니다.
+
+중국어로 된 RVC에 대한 튜토리얼도 있으니 필요하다면 확인할 수 있습니다.
+
+## 크레딧
++ [ContentVec](https://github.com/auspicious3000/contentvec/)
++ [VITS](https://github.com/jaywalnut310/vits)
++ [HIFIGAN](https://github.com/jik876/hifi-gan)
++ [Gradio](https://github.com/gradio-app/gradio)
++ [FFmpeg](https://github.com/FFmpeg/FFmpeg)
++ [Ultimate Vocal Remover](https://github.com/Anjok07/ultimatevocalremovergui)
++ [audio-slicer](https://github.com/openvpi/audio-slicer)
+## 모든 기여자 분들의 노력에 감사드립니다.
+
+<a href="https://github.com/liujing04/Retrieval-based-Voice-Conversion-WebUI/graphs/contributors" target="_blank">
+  <img src="https://contrib.rocks/image?repo=liujing04/Retrieval-based-Voice-Conversion-WebUI" />
+</a>
+

docs/faiss_tips_en.md

@@ -0,0 +1,146 @@
+faiss tuning TIPS
+==================
+# about faiss
+faiss is a library of neighborhood searches for dense vectors, developed by facebook research, which efficiently implements many approximate neighborhood search methods.
+Approximate Neighbor Search finds similar vectors quickly while sacrificing some accuracy.
+
+## faiss in RVC
+In RVC, for the embedding of features converted by HuBERT, we search for embeddings similar to the embedding generated from the training data and mix them to achieve a conversion that is closer to the original speech. However, since this search takes time if performed naively, high-speed conversion is realized by using approximate neighborhood search.
+
+# implementation overview
+In '/logs/your-experiment/3_feature256' where the model is located, features extracted by HuBERT from each voice data are located.
+From here we read the npy files in order sorted by filename and concatenate the vectors to create big_npy. (This vector has shape [N, 256].)
+After saving big_npy as /logs/your-experiment/total_fea.npy, train it with faiss.
+
+As of 2023/04/18, IVF based on L2 distance is used using the index factory function of faiss.
+The number of IVF divisions (n_ivf) is N//39, and n_probe uses int(np.power(n_ivf, 0.3)). (Look around train_index in infer-web.py.)
+
+In this article, I will first explain the meaning of these parameters, and then write advice for developers to create a better index.
+
+# Explanation of the method
+## index factory
+An index factory is a unique faiss notation that expresses a pipeline that connects multiple approximate neighborhood search methods as a string.
+This allows you to try various approximate neighborhood search methods simply by changing the index factory string.
+In RVC it is used like this:
+
+```python
+index = faiss.index_factory(256, "IVF%s,Flat" % n_ivf)
+```
+Among the arguments of index_factory, the first is the number of dimensions of the vector, the second is the index factory string, and the third is the distance to use.
+
+For more detailed notation
+https://github.com/facebookresearch/faiss/wiki/The-index-factory
+
+## index for distance
+There are two typical indexes used as similarity of embedding as follows.
+
+- Euclidean distance (METRIC_L2)
+- inner product (METRIC_INNER_PRODUCT)
+
+Euclidean distance takes the squared difference in each dimension, sums the differences in all dimensions, and then takes the square root. This is the same as the distance in 2D and 3D that we use on a daily basis.
+The inner product is not used as an index of similarity as it is, and the cosine similarity that takes the inner product after being normalized by the L2 norm is generally used.
+
+Which is better depends on the case, but cosine similarity is often used in embedding obtained by word2vec and similar image retrieval models learned by ArcFace. If you want to do l2 normalization on vector X with numpy, you can do it with the following code with eps small enough to avoid 0 division.
+
+```python
+X_normed = X / np.maximum(eps, np.linalg.norm(X, ord=2, axis=-1, keepdims=True))
+```
+
+Also, for the index factory, you can change the distance index used for calculation by choosing the value to pass as the third argument.
+
+```python
+index = faiss.index_factory(dimention, text, faiss.METRIC_INNER_PRODUCT)
+```
+
+## IVF
+IVF (Inverted file indexes) is an algorithm similar to the inverted index in full-text search.
+During learning, the search target is clustered with kmeans, and Voronoi partitioning is performed using the cluster center. Each data point is assigned a cluster, so we create a dictionary that looks up the data points from the clusters.
+
+For example, if clusters are assigned as follows
+|index|Cluster|
+|-----|-------|
+|1|A|
+|2|B|
+|3|A|
+|4|C|
+|5|B|
+
+The resulting inverted index looks like this:
+
+|cluster|index|
+|-------|-----|
+|A|1, 3|
+|B|2, 5|
+|C|4|
+
+When searching, we first search n_probe clusters from the clusters, and then calculate the distances for the data points belonging to each cluster.
+
+# recommend parameter
+There are official guidelines on how to choose an index, so I will explain accordingly.
+https://github.com/facebookresearch/faiss/wiki/Guidelines-to-choose-an-index
+
+For datasets below 1M, 4bit-PQ is the most efficient method available in faiss as of April 2023.
+Combining this with IVF, narrowing down the candidates with 4bit-PQ, and finally recalculating the distance with an accurate index can be described by using the following index factory.
+
+```python
+index = faiss.index_factory(256, "IVF1024,PQ128x4fs,RFlat")
+```
+
+## Recommended parameters for IVF
+Consider the case of too many IVFs. For example, if coarse quantization by IVF is performed for the number of data, this is the same as a naive exhaustive search and is inefficient.
+For 1M or less, IVF values are recommended between 4*sqrt(N) ~ 16*sqrt(N) for N number of data points.
+
+Since the calculation time increases in proportion to the number of n_probes, please consult with the accuracy and choose appropriately. Personally, I don't think RVC needs that much accuracy, so n_probe = 1 is fine.
+
+## FastScan
+FastScan is a method that enables high-speed approximation of distances by Cartesian product quantization by performing them in registers.
+Cartesian product quantization performs clustering independently for each d dimension (usually d = 2) during learning, calculates the distance between clusters in advance, and creates a lookup table. At the time of prediction, the distance of each dimension can be calculated in O(1) by looking at the lookup table.
+So the number you specify after PQ usually specifies half the dimension of the vector.
+
+For a more detailed description of FastScan, please refer to the official documentation.
+https://github.com/facebookresearch/faiss/wiki/Fast-accumulation-of-PQ-and-AQ-codes-(FastScan)
+
+## RFlat
+RFlat is an instruction to recalculate the rough distance calculated by FastScan with the exact distance specified by the third argument of index factory.
+When getting k neighbors, k*k_factor points are recalculated.
+
+# Techniques for embedding
+## alpha query expansion
+Query expansion is a technique used in searches, for example in full-text searches, where a few words are added to the entered search sentence to improve search accuracy. Several methods have also been proposed for vector search, among which α-query expansion is known as a highly effective method that does not require additional learning. In the paper, it is introduced in [Attention-Based Query Expansion Learning](https://arxiv.org/abs/2007.08019), etc., and [2nd place solution of kaggle shopee competition](https://www.kaggle.com/code/lyakaap/2nd-place-solution/notebook).
+
+α-query expansion can be done by summing a vector with neighboring vectors with weights raised to the power of similarity. How to paste the code example. Replace big_npy with α query expansion.
+
+```python
+alpha = 3.
+index = faiss.index_factory(256, "IVF512,PQ128x4fs,RFlat")
+original_norm = np.maximum(np.linalg.norm(big_npy, ord=2, axis=1, keepdims=True), 1e-9)
+big_npy /= original_norm
+index.train(big_npy)
+index.add(big_npy)
+dist, neighbor = index.search(big_npy, num_expand)
+
+expand_arrays = []
+ixs = np.arange(big_npy.shape[0])
+for i in range(-(-big_npy.shape[0]//batch_size)):
+    ix = ixs[i*batch_size:(i+1)*batch_size]
+    weight = np.power(np.einsum("nd,nmd->nm", big_npy[ix], big_npy[neighbor[ix]]), alpha)
+    expand_arrays.append(np.sum(big_npy[neighbor[ix]] * np.expand_dims(weight, axis=2),axis=1))
+big_npy = np.concatenate(expand_arrays, axis=0)
+
+# normalize index version
+big_npy = big_npy / np.maximum(np.linalg.norm(big_npy, ord=2, axis=1, keepdims=True), 1e-9)
+```
+
+This is a technique that can be applied both to the query that does the search and to the DB being searched.
+
+## Compress embedding with MiniBatch KMeans
+If total_fea.npy is too large, it is possible to shrink the vector using KMeans.
+Compression of embedding is possible with the following code. Specify the size you want to compress for n_clusters, and specify 256 * number of CPU cores for batch_size to fully benefit from CPU parallelization.
+
+```python
+import multiprocessing
+from sklearn.cluster import MiniBatchKMeans
+kmeans = MiniBatchKMeans(n_clusters=10000, batch_size=256 * multiprocessing.cpu_count(), init="random")
+kmeans.fit(big_npy)
+sample_npy = kmeans.cluster_centers_
+```

docs/faiss_tips_ja.md

@@ -0,0 +1,146 @@
+faiss tuning TIPS
+==================
+# about faiss
+faissはfacebook researchの開発する、密なベクトルに対する近傍探索をまとめたライブラリで、多くの近似近傍探索の手法を効率的に実装しています。
+近似近傍探索はある程度精度を犠牲にしながら高速に類似するベクトルを探します。
+
+## faiss in RVC
+RVCではHuBERTで変換した特徴量のEmbeddingに対し、学習データから生成されたEmbeddingと類似するものを検索し、混ぜることでより元の音声に近い変換を実現しています。ただ、この検索は愚直に行うと時間がかかるため、近似近傍探索を用いることで高速な変換を実現しています。
+
+# 実装のoverview
+モデルが配置されている '/logs/your-experiment/3_feature256'には各音声データからHuBERTで抽出された特徴量が配置されています。
+ここからnpyファイルをファイル名でソートした順番で読み込み、ベクトルを連結してbig_npyを作成します。(このベクトルのshapeは[N, 256]です。)
+big_npyを/logs/your-experiment/total_fea.npyとして保存した後、faissを学習させます。
+
+2023/04/18時点ではfaissのindex factoryの機能を用いて、L2距離に基づくIVFを用いています。
+IVFの分割数(n_ivf)はN//39で、n_probeはint(np.power(n_ivf, 0.3))が採用されています。(infer-web.pyのtrain_index周りを探してください。)
+
+本Tipsではまずこれらのパラメータの意味を解説し、その後よりよいindexを作成するための開発者向けアドバイスを書きます。
+
+# 手法の解説
+## index factory
+index factoryは複数の近似近傍探索の手法を繋げるパイプラインをstringで表記するfaiss独自の記法です。
+これにより、index factoryの文字列を変更するだけで様々な近似近傍探索の手法を試せます。
+RVCでは以下のように使われています。
+
+```python
+index = faiss.index_factory(256, "IVF%s,Flat" % n_ivf)
+```
+index_factoryの引数のうち、1つ目はベクトルの次元数、2つ目はindex factoryの文字列で、3つ目には用いる距離を指定することができます。
+
+より詳細な記法については
+https://github.com/facebookresearch/faiss/wiki/The-index-factory
+
+## 距離指標
+embeddingの類似度として用いられる代表的な指標として以下の二つがあります。
+
+- ユークリッド距離(METRIC_L2)
+- 内積(METRIC_INNER_PRODUCT)
+
+ユークリッド距離では各次元において二乗の差をとり、全次元の差を足してから平方根をとります。これは日常的に用いる2次元、3次元での距離と同じです。
+内積はこのままでは類似度の指標として用いず、一般的にはL2ノルムで正規化してから内積をとるコサイン類似度を用います。
+
+どちらがよいかは場合によりますが、word2vec等で得られるembeddingやArcFace等で学習した類似画像検索のモデルではコサイン類似度が用いられることが多いです。ベクトルXに対してl2正規化をnumpyで行う場合は、0 divisionを避けるために十分に小さな値をepsとして以下のコードで可能です。
+
+```python
+X_normed = X / np.maximum(eps, np.linalg.norm(X, ord=2, axis=-1, keepdims=True))
+```
+
+また、index factoryには第3引数に渡す値を選ぶことで計算に用いる距離指標を変更できます。
+
+```python
+index = faiss.index_factory(dimention, text, faiss.METRIC_INNER_PRODUCT)
+```
+
+## IVF
+IVF(Inverted file indexes)は全文検索における転置インデックスと似たようなアルゴリズムです。
+学習時には検索対象に対してkmeansでクラスタリングを行い、クラスタ中心を用いてボロノイ分割を行います。各データ点には一つずつクラスタが割り当てられるので、クラスタからデータ点を逆引きする辞書を作成します。
+
+例えば以下のようにクラスタが割り当てられた場合
+|index|クラスタ|
+|-----|-------|
+|1|A|
+|2|B|
+|3|A|
+|4|C|
+|5|B|
+
+作成される転置インデックスは以下のようになります。
+
+|クラスタ|index|
+|-------|-----|
+|A|1, 3|
+|B|2, 5|
+|C|4|
+
+検索時にはまずクラスタからn_probe個のクラスタを検索し、次にそれぞれのクラスタに属するデータ点について距離を計算します。
+
+# 推奨されるパラメータ
+indexの選び方については公式にガイドラインがあるので、それに準じて説明します。
+https://github.com/facebookresearch/faiss/wiki/Guidelines-to-choose-an-index
+
+1M以下のデータセットにおいては4bit-PQが2023年4月時点ではfaissで利用できる最も効率的な手法です。
+これをIVFと組み合わせ、4bit-PQで候補を絞り、最後に正確な指標で距離を再計算するには以下のindex factoryを用いることで記載できます。
+
+```python
+index = faiss.index_factory(256, "IVF1024,PQ128x4fs,RFlat")
+```
+
+## IVFの推奨パラメータ
+IVFの数が多すぎる場合、たとえばデータ数の数だけIVFによる粗量子化を行うと、これは愚直な全探索と同じになり効率が悪いです。
+1M以下の場合ではIVFの値はデータ点の数Nに対して4*sqrt(N) ~ 16*sqrt(N)に推奨しています。
+
+n_probeはn_probeの数に比例して計算時間が増えるので、精度と相談して適切に選んでください。個人的にはRVCにおいてそこまで精度は必要ないと思うのでn_probe = 1で良いと思います。
+
+## FastScan
+FastScanは直積量子化で大まかに距離を近似するのを、レジスタ内で行うことにより高速に行うようにした手法です。
+直積量子化は学習時にd次元ごと(通常はd=2)に独立してクラスタリングを行い、クラスタ同士の距離を事前計算してlookup tableを作成します。予測時はlookup tableを見ることで各次元の距離をO(1)で計算できます。
+そのため、PQの次に指定する数字は通常ベクトルの半分の次元を指定します。
+
+FastScanに関するより詳細な説明は公式のドキュメントを参照してください。
+https://github.com/facebookresearch/faiss/wiki/Fast-accumulation-of-PQ-and-AQ-codes-(FastScan)
+
+## RFlat
+RFlatはFastScanで計算した大まかな距離を、index factoryの第三引数で指定した正確な距離で再計算する指示です。
+k個の近傍を取得する際は、k*k_factor個の点について再計算が行われます。
+
+# Embeddingに関するテクニック
+## alpha query expansion
+クエリ拡張は検索で使われるテクニックで、例えば全文検索では入力された検索文に単語を幾つか追加することで検索精度を上げることがあります。ベクトル検索にもいくつか提唱されていて、その内追加の学習がいらず効果が高い手法としてα-query expansionが知られています。論文では[Attention-Based Query Expansion Learning](https://arxiv.org/abs/2007.08019)などで紹介されていて、[kaggleのshopeeコンペの2位の解法](https://www.kaggle.com/code/lyakaap/2nd-place-solution/notebook)にも用いられていました。
+
+α-query expansionはあるベクトルに対し、近傍のベクトルを類似度のα乗した重みで足し合わせることでできます。いかにコードの例を張ります。big_npyをα query expansionしたものに置き換えます。
+
+```python
+alpha = 3.
+index = faiss.index_factory(256, "IVF512,PQ128x4fs,RFlat")
+original_norm = np.maximum(np.linalg.norm(big_npy, ord=2, axis=1, keepdims=True), 1e-9)
+big_npy /= original_norm
+index.train(big_npy)
+index.add(big_npy)
+dist, neighbor = index.search(big_npy, num_expand)
+
+expand_arrays = []
+ixs = np.arange(big_npy.shape[0])
+for i in range(-(-big_npy.shape[0]//batch_size)):
+    ix = ixs[i*batch_size:(i+1)*batch_size]
+    weight = np.power(np.einsum("nd,nmd->nm", big_npy[ix], big_npy[neighbor[ix]]), alpha)
+    expand_arrays.append(np.sum(big_npy[neighbor[ix]] * np.expand_dims(weight, axis=2),axis=1))
+big_npy = np.concatenate(expand_arrays, axis=0)
+
+# normalize index version
+big_npy = big_npy / np.maximum(np.linalg.norm(big_npy, ord=2, axis=1, keepdims=True), 1e-9)
+```
+
+これは、検索を行うクエリにも、検索対象のDBにも適応可能なテクニックです。
+
+## MiniBatch KMeansによるembeddingの圧縮
+total_fea.npyが大きすぎる場合、KMeansを用いてベクトルを小さくすることが可能です。
+以下のコードで、embeddingの圧縮が可能です。n_clustersは圧縮したい大きさを指定し、batch_sizeは256 * CPUのコア数を指定することでCPUの並列化の恩恵を十分に得ることができます。
+
+```python
+import multiprocessing
+from sklearn.cluster import MiniBatchKMeans
+kmeans = MiniBatchKMeans(n_clusters=10000, batch_size=256 * multiprocessing.cpu_count(), init="random")
+kmeans.fit(big_npy)
+sample_npy = kmeans.cluster_centers_
+```

docs/faiss_tips_ko.md

@@ -0,0 +1,132 @@
+Facebook AI Similarity Search (Faiss) 팁
+==================
+# Faiss에 대하여
+Faiss 는 Facebook Research가 개발하는, 고밀도 벡터 이웃 검색 라이브러리입니다. 근사 근접 탐색법 (Approximate Neigbor Search)은 약간의 정확성을 희생하여 유사 벡터를 고속으로 찾습니다.
+
+## RVC에 있어서 Faiss
+RVC에서는 HuBERT로 변환한 feature의 embedding을 위해 훈련 데이터에서 생성된 embedding과 유사한 embadding을 검색하고 혼합하여 원래의 음성에 더욱 가까운 변환을 달성합니다. 그러나, 이 탐색법은 단순히 수행하면 시간이 다소 소모되므로, 근사 근접 탐색법을 통해 고속 변환을 가능케 하고 있습니다.
+
+# 구현 개요
+모델이 위치한 `/logs/your-experiment/3_feature256`에는 각 음성 데이터에서 HuBERT가 추출한 feature들이 있습니다. 여기에서 파일 이름별로 정렬된 npy 파일을 읽고, 벡터를 연결하여 big_npy ([N, 256] 모양의 벡터) 를 만듭니다. big_npy를 `/logs/your-experiment/total_fea.npy`로 저장한 후, Faiss로 학습시킵니다.
+
+2023/04/18 기준으로, Faiss의 Index Factory 기능을 이용해, L2 거리에 근거하는 IVF를 이용하고 있습니다. IVF의 분할수(n_ivf)는 N//39로, n_probe는 int(np.power(n_ivf, 0.3))가 사용되고 있습니다. (infer-web.py의 train_index 주위를 찾으십시오.)
+
+이 팁에서는 먼저 이러한 매개 변수의 의미를 설명하고, 개발자가 추후 더 나은 index를 작성할 수 있도록 하는 조언을 작성합니다.
+
+# 방법의 설명
+## Index factory
+index factory는 여러 근사 근접 탐색법을 문자열로 연결하는 pipeline을 문자열로 표기하는 Faiss만의 독자적인 기법입니다. 이를 통해 index factory의 문자열을 변경하는 것만으로 다양한 근사 근접 탐색을 시도해 볼 수 있습니다. RVC에서는 다음과 같이 사용됩니다:
+
+```python
+index = Faiss.index_factory(256, "IVF%s,Flat" % n_ivf)
+```
+`index_factory`의 인수들 중 첫 번째는 벡터의 차원 수이고, 두번째는 index factory 문자열이며, 세번째에는 사용할 거리를 지정할 수 있습니다.
+
+기법의 보다 자세한 설명은 https://github.com/facebookresearch/Faiss/wiki/The-index-factory 를 확인해 주십시오.
+
+## 거리에 대한 index
+embedding의 유사도로서 사용되는 대표적인 지표로서 이하의 2개가 있습니다.
+
+- 유클리드 거리 (METRIC_L2)
+- 내적(内積) (METRIC_INNER_PRODUCT)
+
+유클리드 거리에서는 각 차원에서 제곱의 차를 구하고, 각 차원에서 구한 차를 모두 더한 후 제곱근을 취합니다. 이것은 일상적으로 사용되는 2차원, 3차원에서의 거리의 연산법과 같습니다. 내적은 그 값을 그대로 유사도 지표로 사용하지 않고, L2 정규화를 한 이후 내적을 취하는 코사인 유사도를 사용합니다.
+
+어느 쪽이 더 좋은지는 경우에 따라 다르지만, word2vec에서 얻은 embedding 및 ArcFace를 활용한 이미지 검색 모델은 코사인 유사성이 이용되는 경우가 많습니다. numpy를 사용하여 벡터 X에 대해 L2 정규화를 하고자 하는 경우, 0 division을 피하기 위해 충분히 작은 값을 eps로 한 뒤 이하에 코드를 활용하면 됩니다.
+
+```python
+X_normed = X / np.maximum(eps, np.linalg.norm(X, ord=2, axis=-1, keepdims=True))
+```
+
+또한, `index factory`의 3번째 인수에 건네주는 값을 선택하는 것을 통해 계산에 사용하는 거리 index를 변경할 수 있습니다.
+
+```python
+index = Faiss.index_factory(dimention, text, Faiss.METRIC_INNER_PRODUCT)
+```
+
+## IVF
+IVF (Inverted file indexes)는 역색인 탐색법과 유사한 알고리즘입니다. 학습시에는 검색 대상에 대해 k-평균 군집법을 실시하고 클러스터 중심을 이용해 보로노이 분할을 실시합니다. 각 데이터 포인트에는 클러스터가 할당되므로, 클러스터에서 데이터 포인트를 조회하는 dictionary를 만듭니다.
+
+예를 들어, 클러스터가 다음과 같이 할당된 경우
+|index|Cluster|
+|-----|-------|
+|1|A|
+|2|B|
+|3|A|
+|4|C|
+|5|B|
+
+IVF 이후의 결과는 다음과 같습니다:
+
+|cluster|index|
+|-------|-----|
+|A|1, 3|
+|B|2, 5|
+|C|4|
+
+탐색 시, 우선 클러스터에서 `n_probe`개의 클러스터를 탐색한 다음, 각 클러스터에 속한 데이터 포인트의 거리를 계산합니다.
+
+# 권장 매개변수
+index의 선택 방법에 대해서는 공식적으로 가이드 라인이 있으므로, 거기에 준해 설명합니다.
+https://github.com/facebookresearch/Faiss/wiki/Guidelines-to-choose-an-index
+
+1M 이하의 데이터 세트에 있어서는 4bit-PQ가 2023년 4월 시점에서는 Faiss로 이용할 수 있는 가장 효율적인 수법입니다. 이것을 IVF와 조합해, 4bit-PQ로 후보를 추려내고, 마지막으로 이하의 index factory를 이용하여 정확한 지표로 거리를 재계산하면 됩니다.
+
+```python
+index = Faiss.index_factory(256, "IVF1024,PQ128x4fs,RFlat")
+```
+
+## IVF 권장 매개변수
+IVF의 수가 너무 많으면, 가령 데이터 수의 수만큼 IVF로 양자화(Quantization)를 수행하면, 이것은 완전탐색과 같아져 효율이 나빠지게 됩니다. 1M 이하의 경우 IVF 값은 데이터 포인트 수 N에 대해 4sqrt(N) ~ 16sqrt(N)를 사용하는 것을 권장합니다.
+
+n_probe는 n_probe의 수에 비례하여 계산 시간이 늘어나므로 정확도와 시간을 적절히 균형을 맞추어 주십시오. 개인적으로 RVC에 있어서 그렇게까지 정확도는 필요 없다고 생각하기 때문에 n_probe = 1이면 된다고 생각합니다.
+
+## FastScan
+FastScan은 직적 양자화를 레지스터에서 수행함으로써 거리의 고속 근사를 가능하게 하는 방법입니다.직적 양자화는 학습시에 d차원마다(보통 d=2)에 독립적으로 클러스터링을 실시해, 클러스터끼리의 거리를 사전 계산해 lookup table를 작성합니다. 예측시는 lookup table을 보면 각 차원의 거리를 O(1)로 계산할 수 있습니다. 따라서 PQ 다음에 지정하는 숫자는 일반적으로 벡터의 절반 차원을 지정합니다.
+
+FastScan에 대한 자세한 설명은 공식 문서를 참조하십시오.
+https://github.com/facebookresearch/Faiss/wiki/Fast-accumulation-of-PQ-and-AQ-codes-(FastScan)
+
+## RFlat
+RFlat은 FastScan이 계산한 대략적인 거리를 index factory의 3번째 인수로 지정한 정확한 거리로 다시 계산하라는 인스트럭션입니다. k개의 근접 변수를 가져올 때 k*k_factor개의 점에 대해 재계산이 이루어집니다.
+
+# Embedding 테크닉
+## Alpha 쿼리 확장
+퀴리 확장이란 탐색에서 사용되는 기술로, 예를 들어 전문 탐색 시, 입력된 검색문에 단어를 몇 개를 추가함으로써 검색 정확도를 올리는 방법입니다. 백터 탐색을 위해서도 몇가지 방법이 제안되었는데, 그 중 α-쿼리 확장은 추가 학습이 필요 없는 매우 효과적인 방법으로 알려져 있습니다. [Attention-Based Query Expansion Learning](https://arxiv.org/abs/2007.08019)와 [2nd place solution of kaggle shopee competition](https://www.kaggle.com/code/lyakaap/2nd-place-solution/notebook) 논문에서 소개된 바 있습니다..
+
+α-쿼리 확장은 한 벡터에 인접한 벡터를 유사도의 α곱한 가중치로 더해주면 됩니다. 코드로 예시를 들어 보겠습니다. big_npy를 α query expansion로 대체합니다.
+
+```python
+alpha = 3.
+index = Faiss.index_factory(256, "IVF512,PQ128x4fs,RFlat")
+original_norm = np.maximum(np.linalg.norm(big_npy, ord=2, axis=1, keepdims=True), 1e-9)
+big_npy /= original_norm
+index.train(big_npy)
+index.add(big_npy)
+dist, neighbor = index.search(big_npy, num_expand)
+
+expand_arrays = []
+ixs = np.arange(big_npy.shape[0])
+for i in range(-(-big_npy.shape[0]//batch_size)):
+    ix = ixs[i*batch_size:(i+1)*batch_size]
+    weight = np.power(np.einsum("nd,nmd->nm", big_npy[ix], big_npy[neighbor[ix]]), alpha)
+    expand_arrays.append(np.sum(big_npy[neighbor[ix]] * np.expand_dims(weight, axis=2),axis=1))
+big_npy = np.concatenate(expand_arrays, axis=0)
+
+# index version 정규화
+big_npy = big_npy / np.maximum(np.linalg.norm(big_npy, ord=2, axis=1, keepdims=True), 1e-9)
+```
+
+위 테크닉은 탐색을 수행하는 쿼리에도, 탐색 대상 DB에도 적응 가능한 테크닉입니다.
+
+## MiniBatch KMeans에 의한 embedding 압축
+
+total_fea.npy가 너무 클 경우 K-means를 이용하여 벡터를 작게 만드는 것이 가능합니다. 이하 코드로 embedding의 압축이 가능합니다. n_clusters에 압축하고자 하는 크기를 지정하고 batch_size에 256 * CPU의 코어 수를 지정함으로써 CPU 병렬화의 혜택을 충분히 얻을 수 있습니다.
+
+```python
+import multiprocessing
+from sklearn.cluster import MiniBatchKMeans
+kmeans = MiniBatchKMeans(n_clusters=10000, batch_size=256 * multiprocessing.cpu_count(), init="random")
+kmeans.fit(big_npy)
+sample_npy = kmeans.cluster_centers_
+```

docs/training_tips_en.md

@@ -0,0 +1,52 @@
+Instructions and tips for RVC training
+======================================
+This TIPS explains how data training is done.
+
+# Training flow
+I will explain along the steps in the training tab of the GUI.
+
+## step1
+Set the experiment name here. You can also set here whether the model should take pitch into account.
+Data for each experiment is placed in `/logs/experiment name/`.
+
+## step2a
+Loads and preprocesses audio.
+
+### load audio
+If you specify a folder with audio, the audio files in that folder will be read automatically.
+For example, if you specify `C:Users\hoge\voices`, `C:Users\hoge\voices\voice.mp3` will be loaded, but `C:Users\hoge\voices\dir\voice.mp3` will Not loaded.
+
+Since ffmpeg is used internally for reading audio, if the extension is supported by ffmpeg, it will be read automatically.
+After converting to int16 with ffmpeg, convert to float32 and normalize between -1 to 1.
+
+### denoising
+The audio is smoothed by scipy's filtfilt.
+
+### Audio Split
+First, the input audio is divided by detecting parts of silence that last longer than a certain period (max_sil_kept=5 seconds?). After splitting the audio on silence, split the audio every 4 seconds with an overlap of 0.3 seconds. For audio separated within 4 seconds, after normalizing the volume, convert the wav file to `/logs/experiment name/0_gt_wavs` and then convert it to 16k sampling rate to `/logs/experiment name/1_16k_wavs ` as a wav file.
+
+## step2b
+### Extract pitch
+Extract pitch information from wav files. Extract the pitch information (=f0) using the method built into parselmouth or pyworld and save it in `/logs/experiment name/2a_f0`. Then logarithmically convert the pitch information to an integer between 1 and 255 and save it in `/logs/experiment name/2b-f0nsf`.
+
+### Extract feature_print
+Convert the wav file to embedding in advance using HuBERT. Read the wav file saved in `/logs/experiment name/1_16k_wavs`, convert the wav file to 256-dimensional features with HuBERT, and save in npy format in `/logs/experiment name/3_feature256`.
+
+## step3
+train the model.
+### Glossary for Beginners
+In deep learning, the data set is divided and the learning proceeds little by little. In one model update (step), batch_size data are retrieved and predictions and error corrections are performed. Doing this once for a dataset counts as one epoch.
+
+Therefore, the learning time is the learning time per step x (the number of data in the dataset / batch size) x the number of epochs. In general, the larger the batch size, the more stable the learning becomes (learning time per step ÷ batch size) becomes smaller, but it uses more GPU memory. GPU RAM can be checked with the nvidia-smi command. Learning can be done in a short time by increasing the batch size as much as possible according to the machine of the execution environment.
+
+### Specify pretrained model
+RVC starts training the model from pretrained weights instead of from 0, so it can be trained with a small dataset. By default it loads `rvc-location/pretrained/f0G40k.pth` and `rvc-location/pretrained/f0D40k.pth`. When learning, model parameters are saved in `logs/experiment name/G_{}.pth` and `logs/experiment name/D_{}.pth` for each save_every_epoch, but by specifying this path, you can start learning. You can restart or start training from model weights learned in a different experiment.
+
+### learning index
+RVC saves the HuBERT feature values used during training, and during inference, searches for feature values that are similar to the feature values used during learning to perform inference. In order to perform this search at high speed, the index is learned in advance.
+For index learning, we use the approximate neighborhood search library faiss. Read the feature value of `/logs/experiment name/3_feature256`, save the combined feature value as `/logs/experiment name/total_fea.npy`, and use it to learn the index `/logs/experiment name Save it as /add_XXX.index`.
+
+### Button description
+- Train model: After executing step2b, press this button to train the model.
+- Train feature index: After training the model, perform index learning.
+- One-click training: step2b, model training and feature index training all at once.

docs/training_tips_ja.md

@@ -0,0 +1,53 @@
+RVCの訓練における説明、およびTIPS
+===============================
+本TIPSではどのようにデータの訓練が行われているかを説明します。
+
+# 訓練の流れ
+GUIの訓練タブのstepに沿って説明します。
+
+## step1 
+実験名の設定を行います。また、モデルにピッチを考慮させるかもここで設定できます。
+各実験のデータは`/logs/実験名/`に配置されます。
+
+## step2a
+音声の読み込みと前処理を行います。
+
+### load audio
+音声のあるフォルダを指定すると、そのフォルダ内にある音声ファイルを自動で読み込みます。
+例えば`C:Users\hoge\voices`を指定した場合、`C:Users\hoge\voices\voice.mp3`は読み込まれますが、`C:Users\hoge\voices\dir\voice.mp3`は読み込まれません。
+
+音声の読み込みには内部でffmpegを利用しているので、ffmpegで対応している拡張子であれば自動的に読み込まれます。
+ffmpegでint16に変換した後、float32に変換し、-1 ~ 1の間に正規化されます。
+
+### denoising
+音声についてscipyのfiltfiltによる平滑化を行います。
+
+### 音声の分割
+入力した音声はまず、一定期間(max_sil_kept=5秒?)より長く無音が続く部分を検知して音声を分割します。無音で音声を分割した後は、0.3秒のoverlapを含む4秒ごとに音声を分割します。4秒以内に区切られた音声は、音量の正規化を行った後wavファイルを`/logs/実験名/0_gt_wavs`に、そこから16kのサンプリングレートに変換して`/logs/実験名/1_16k_wavs`にwavファイルで保存します。
+
+## step2b
+### ピッチの抽出
+wavファイルからピッチ(音の高低)の情報を抽出します。parselmouthやpyworldに内蔵されている手法でピッチ情報(=f0)を抽出し、`/logs/実験名/2a_f0`に保存します。その後、ピッチ情報を対数で変換して1~255の整数に変換し、`/logs/実験名/2b-f0nsf`に保存します。
+
+### feature_printの抽出
+HuBERTを用いてwavファイルを事前にembeddingに変換します。`/logs/実験名/1_16k_wavs`に保存したwavファイルを読み込み、HuBERTでwavファイルを256次元の特徴量に変換し、npy形式で`/logs/実験名/3_feature256`に保存します。
+
+## step3
+モデルのトレーニングを行います。
+### 初心者向け用語解説
+深層学習ではデータセットを分割し、少しずつ学習を進めていきます。一回のモデルの更新(step)では、batch_size個のデータを取り出し予測と誤差の修正を行います。これをデータセットに対して一通り行うと一epochと数えます。
+
+そのため、学習時間は 1step当たりの学習時間 x (データセット内のデータ数 ÷ バッチサイズ) x epoch数 かかります。一般にバッチサイズを大きくするほど学習は安定し、(1step当たりの学習時間÷バッチサイズ)は小さくなりますが、その分GPUのメモリを多く使用します。GPUのRAMはnvidia-smiコマンド等で確認できます。実行環境のマシンに合わせてバッチサイズをできるだけ大きくするとより短時間で学習が可能です。
+
+### pretrained modelの指定
+RVCではモデルの訓練を0からではなく、事前学習済みの重みから開始するため、少ないデータセットで学習を行えます。デフォルトでは`RVCのある場所/pretrained/f0G40k.pth`と`RVCのある場所/pretrained/f0D40k.pth`を読み込みます。学習時はsave_every_epochごとにモデルのパラメータが`logs/実験名/G_{}.pth`と`logs/実験名/D_{}.pth`に保存されますが、このパスを指定することで学習を再開したり、もしくは違う実験で学習したモデルの重みから学習を開始できます。
+
+### indexの学習
+RVCでは学習時に使われたHuBERTの特徴量を保存し、推論時は学習時の特徴量から近い特徴量を探してきて推論を行います。この検索を高速に行うために事前にindexの学習を行います。
+indexの学習には近似近傍探索ライブラリのfaissを用います。`/logs/実験名/3_feature256`の特徴量を読み込み、全て結合させた特徴量を`/logs/実験名/total_fea.npy`として保存、それを用いて学習したindexを`/logs/実験名/add_XXX.index`として保存します。
+
+### ボタンの説明
+- モデルのトレーニング: step2bまでを実行した後、このボタンを押すとモデルの学習を行います。
+- 特徴インデックスのトレーニング: モデルのトレーニング後、indexの学習を行います。
+- ワンクリックトレーニング: step2bまでとモデルのトレーニング、特徴インデックスのトレーニングを一括で行います。
+

docs/training_tips_ko.md

@@ -0,0 +1,53 @@
+RVC 훈련에 대한 설명과 팁들
+======================================
+본 팁에서는 어떻게 데이터 훈련이 이루어지고 있는지 설명합니다.
+
+# 훈련의 흐름
+GUI의 훈련 탭의 단계를 따라 설명합니다.
+
+## step1
+실험 이름을 지정합니다. 또한, 모델이 피치(소리의 높낮이)를 고려해야 하는지 여부를 여기에서 설정할 수도 있습니다..
+각 실험을 위한 데이터는 `/logs/experiment name/`에 배치됩니다..
+
+## step2a
+음성 파일을 불러오고 전처리합니다.
+
+### 음성 파일 불러오기
+음성 파일이 있는 폴더를 지정하면 해당 폴더에 있는 음성 파일이 자동으로 가져와집니다.
+예를 들어 `C:Users\hoge\voices`를 지정하면 `C:Users\hoge\voices\voice.mp3`가 읽히지만 `C:Users\hoge\voices\dir\voice.mp3`는 읽히지 않습니다.
+
+음성 로드에는 내부적으로 ffmpeg를 이용하고 있으므로, ffmpeg로 대응하고 있는 확장자라면 자동적으로 읽힙니다.
+ffmpeg에서 int16으로 변환한 후 float32로 변환하고 -1과 1 사이에 정규화됩니다.
+
+### 잡음 제거
+음성 파일에 대해 scipy의 filtfilt를 이용하여 잡음을 처리합니다.
+
+### 음성 분할
+입력한 음성 파일은 먼저 일정 기간(max_sil_kept=5초?)보다 길게 무음이 지속되는 부분을 감지하여 음성을 분할합니다.무음으로 음성을 분할한 후에는 0.3초의 overlap을 포함하여 4초마다 음성을 분할합니다.4초 이내에 구분된 음성은 음량의 정규화를 실시한 후 wav 파일을 `/logs/실험명/0_gt_wavs`로, 거기에서 16k의 샘플링 레이트로 변환해 `/logs/실험명/1_16k_wavs`에 wav 파일로 저장합니다.
+
+## step2b
+### 피치 추출
+wav 파일에서 피치(소리의 높낮이) 정보를 추출합니다. parselmouth나 pyworld에 내장되어 있는 메서드으로 피치 정보(=f0)를 추출해, `/logs/실험명/2a_f0`에 저장합니다. 그 후 피치 정보를 로그로 변환하여 1~255 정수로 변환하고 `/logs/실험명/2b-f0nsf`에 저장합니다.
+
+### feature_print 추출
+HuBERT를 이용하여 wav 파일을 미리 embedding으로 변환합니다. `/logs/실험명/1_16k_wavs`에 저장한 wav 파일을 읽고 HuBERT에서 wav 파일을 256차원 feature들로 변환한 후 npy 형식으로 `/logs/실험명/3_feature256`에 저장합니다.
+
+## step3
+모델의 훈련을 진행합니다.
+
+### 초보자용 용어 해설
+심층학습(딥러닝)에서는 데이터셋을 분할하여 조금씩 학습을 진행합니다.한 번의 모델 업데이트(step) 단계 당 batch_size개의 데이터를 탐색하여 예측과 오차를 수정합니다. 데이터셋 전부에 대해 이 작업을 한 번 수행하는 이를 하나의 epoch라고 계산합니다.
+
+따라서 학습 시간은 단계당 학습 시간 x (데이터셋 내 데이터의 수 / batch size) x epoch 수가 소요됩니다. 일반적으로 batch size가 클수록 학습이 안정적이게 됩니다. (step당 학습 시간 ÷ batch size)는 작아지지만 GPU 메모리를 더 많이 사용합니다. GPU RAM은 nvidia-smi 명령어를 통해 확인할 수 있습니다. 실행 환경에 따라 배치 크기를 최대한 늘리면 짧은 시간 내에 학습이 가능합니다.
+
+### 사전 학습된 모델 지정
+RVC는 적은 데이터셋으로도 훈련이 가능하도록 사전 훈련된 가중치에서 모델 훈련을 시작합니다. 기본적으로 `rvc-location/pretrained/f0G40k.pth` 및 `rvc-location/pretrained/f0D40k.pth`를 불러옵니다. 학습을 할 시에, 모델 파라미터는 각 save_every_epoch별로 `logs/experiment name/G_{}.pth` 와 `logs/experiment name/D_{}.pth`로 저장이 되는데, 이 경로를 지정함으로써 학습을 재개하거나, 다른 실험에서 학습한 모델의 가중치에서 학습을 시작할 수 있습니다.
+
+### index의 학습
+RVC에서는 학습시에 사용된 HuBERT의 feature값을 저장하고, 추론 시에는 학습 시 사용한 feature값과 유사한 feature 값을 탐색해 추론을 진행합니다. 이 탐색을 고속으로 수행하기 위해 사전에 index을 학습하게 됩니다.
+Index 학습에는 근사 근접 탐색법 라이브러리인 Faiss를 사용하게 됩니다. `/logs/실험명/3_feature256`의 feature값을 불러와, 이를 모두 결합시킨 feature값을 `/logs/실험명/total_fea.npy`로서 저장, 그것을 사용해 학습한 index를`/logs/실험명/add_XXX.index`로 저장합니다.
+
+### 버튼 설명
+- モデルのトレーニング (모델 학습): step2b까지 실행한 후, 이 버튼을 눌러 모델을 학습합니다.
+- 特徴インデックスのトレーニング (특징 지수 훈련): 모델의 훈련 후, index를 학습합니다.
+- ワンクリックトレーニング (원클릭 트레이닝): step2b까지의 모델 훈련, feature index 훈련을 일괄로 실시합니다.

export_onnx.py

@@ -1,36 +1,46 @@
-from infer_pack.models_onnx import SynthesizerTrnMs256NSFsid
+from infer_pack.models_onnx_moess import SynthesizerTrnMs256NSFsidM
+from infer_pack.models_onnx import SynthesizerTrnMs256NSFsidO
 import torch
 
-person = "Shiroha/shiroha.pth"
-exported_path = "model.onnx"
+if __name__ == "__main__":
+    MoeVS = True  # 模型是否为MoeVoiceStudio（原MoeSS）使用
 
+    ModelPath = "Shiroha/shiroha.pth"  # 模型路径
+    ExportedPath = "model.onnx"  # 输出路径
+    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)  # 噪声（加入随机因子）
 
-cpt = torch.load(person, map_location="cpu")
-cpt["config"][-3]=cpt["weight"]["emb_g.weight"].shape[0]#n_spk
-print(*cpt["config"])
-net_g = SynthesizerTrnMs256NSFsid(*cpt["config"], is_half=False)
-net_g.load_state_dict(cpt["weight"], strict=False)
+    device = "cpu"  # 导出时设备（不影响使用模型）
 
-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,
+    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)
+                test_rnd.to(device),
             ),
-            exported_path,
+            ExportedPath,
             dynamic_axes={
                 "phone": [1],
                 "pitch": [1],
@@ -41,4 +51,35 @@ torch.onnx.export(net_g,
             opset_version=16,
             verbose=False,
             input_names=input_names,
-            output_names=output_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,
+        )

export_onnx_old.py

@@ -0,0 +1,47 @@
+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,
+)

extract_f0_print.py

@@ -1,21 +1,26 @@
-import os,traceback,sys,parselmouth
+import os, traceback, sys, parselmouth
 import librosa
 import pyworld
 from scipy.io import wavfile
-import numpy as np,logging
-logging.getLogger('numba').setLevel(logging.WARNING)
+import numpy as np, logging
+
+logging.getLogger("numba").setLevel(logging.WARNING)
 from multiprocessing import Process
 
 exp_dir = sys.argv[1]
-f = open("%s/extract_f0_feature.log"%exp_dir, "a+")
+f = open("%s/extract_f0_feature.log" % exp_dir, "a+")
+
+
 def printt(strr):
     print(strr)
     f.write("%s\n" % strr)
     f.flush()
 
+
 n_p = int(sys.argv[2])
 f0method = sys.argv[3]
 
+
 class FeatureInput(object):
     def __init__(self, samplerate=16000, hop_size=160):
         self.fs = samplerate
@@ -27,33 +32,46 @@ class FeatureInput(object):
         self.f0_mel_min = 1127 * np.log(1 + self.f0_min / 700)
         self.f0_mel_max = 1127 * np.log(1 + self.f0_max / 700)
 
-    def compute_f0(self, path,f0_method):
-        x, sr = librosa.load(path, self.fs)
-        p_len=x.shape[0]//self.hop
+    def compute_f0(self, path, f0_method):
+        # default resample type of librosa.resample is "soxr_hq".
+        # Quality: soxr_vhq > soxr_hq
+        x, sr = librosa.load(path, self.fs)  # , res_type='soxr_vhq'
+        p_len = x.shape[0] // self.hop
         assert sr == self.fs
-        if(f0_method=="pm"):
+        if f0_method == "pm":
             time_step = 160 / 16000 * 1000
             f0_min = 50
             f0_max = 1100
-            f0 = parselmouth.Sound(x, sr).to_pitch_ac(
-                time_step=time_step / 1000, voicing_threshold=0.6,
-                pitch_floor=f0_min, pitch_ceiling=f0_max).selected_array['frequency']
-            pad_size=(p_len - len(f0) + 1) // 2
-            if(pad_size>0 or p_len - len(f0) - pad_size>0):
-                f0 = np.pad(f0,[[pad_size,p_len - len(f0) - pad_size]], mode='constant')
-        elif(f0_method=="harvest"):
+            f0 = (
+                parselmouth.Sound(x, sr)
+                .to_pitch_ac(
+                    time_step=time_step / 1000,
+                    voicing_threshold=0.6,
+                    pitch_floor=f0_min,
+                    pitch_ceiling=f0_max,
+                )
+                .selected_array["frequency"]
+            )
+            pad_size = (p_len - len(f0) + 1) // 2
+            if pad_size > 0 or p_len - len(f0) - pad_size > 0:
+                f0 = np.pad(
+                    f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant"
+                )
+        elif f0_method == "harvest":
             f0, t = pyworld.harvest(
                 x.astype(np.double),
                 fs=sr,
-                f0_ceil=1100,
+                f0_ceil=self.f0_max,
+                f0_floor=self.f0_min,
                 frame_period=1000 * self.hop / sr,
             )
             f0 = pyworld.stonemask(x.astype(np.double), f0, t, self.fs)
-        elif(f0_method=="dio"):
+        elif f0_method == "dio":
             f0, t = pyworld.dio(
                 x.astype(np.double),
                 fs=sr,
-                f0_ceil=1100,
+                f0_ceil=self.f0_max,
+                f0_floor=self.f0_min,
                 frame_period=1000 * self.hop / sr,
             )
             f0 = pyworld.stonemask(x.astype(np.double), f0, t, self.fs)
@@ -75,45 +93,67 @@ class FeatureInput(object):
         )
         return f0_coarse
 
-    def go(self,paths,f0_method):
-        if (len(paths) == 0): printt("no-f0-todo")
+    def go(self, paths, f0_method):
+        if len(paths) == 0:
+            printt("no-f0-todo")
         else:
-            printt("todo-f0-%s"%len(paths))
-            n=max(len(paths)//5,1)#每个进程最多打印5条
-            for idx,(inp_path,opt_path1,opt_path2) in enumerate(paths):
+            printt("todo-f0-%s" % len(paths))
+            n = max(len(paths) // 5, 1)  # 每个进程最多打印5条
+            for idx, (inp_path, opt_path1, opt_path2) in enumerate(paths):
                 try:
-                    if(idx%n==0):printt("f0ing,now-%s,all-%s,-%s"%(idx,len(paths),inp_path))
-                    if(os.path.exists(opt_path1+".npy")==True and os.path.exists(opt_path2+".npy")==True):continue
-                    featur_pit = self.compute_f0(inp_path,f0_method)
-                    np.save(opt_path2,featur_pit,allow_pickle=False,)#nsf
+                    if idx % n == 0:
+                        printt("f0ing,now-%s,all-%s,-%s" % (idx, len(paths), inp_path))
+                    if (
+                        os.path.exists(opt_path1 + ".npy") == True
+                        and os.path.exists(opt_path2 + ".npy") == True
+                    ):
+                        continue
+                    featur_pit = self.compute_f0(inp_path, f0_method)
+                    np.save(
+                        opt_path2,
+                        featur_pit,
+                        allow_pickle=False,
+                    )  # nsf
                     coarse_pit = self.coarse_f0(featur_pit)
-                    np.save(opt_path1,coarse_pit,allow_pickle=False,)#ori
+                    np.save(
+                        opt_path1,
+                        coarse_pit,
+                        allow_pickle=False,
+                    )  # ori
                 except:
-                    printt("f0fail-%s-%s-%s" % (idx, inp_path,traceback.format_exc()))
+                    printt("f0fail-%s-%s-%s" % (idx, inp_path, traceback.format_exc()))
 
-if __name__=='__main__':
+
+if __name__ == "__main__":
     # exp_dir=r"E:\codes\py39\dataset\mi-test"
     # n_p=16
     # f = open("%s/log_extract_f0.log"%exp_dir, "w")
     printt(sys.argv)
     featureInput = FeatureInput()
-    paths=[]
-    inp_root= "%s/1_16k_wavs"%(exp_dir)
-    opt_root1="%s/2a_f0"%(exp_dir)
-    opt_root2="%s/2b-f0nsf"%(exp_dir)
+    paths = []
+    inp_root = "%s/1_16k_wavs" % (exp_dir)
+    opt_root1 = "%s/2a_f0" % (exp_dir)
+    opt_root2 = "%s/2b-f0nsf" % (exp_dir)
 
-    os.makedirs(opt_root1,exist_ok=True)
-    os.makedirs(opt_root2,exist_ok=True)
+    os.makedirs(opt_root1, exist_ok=True)
+    os.makedirs(opt_root2, exist_ok=True)
     for name in sorted(list(os.listdir(inp_root))):
-        inp_path="%s/%s"%(inp_root,name)
-        if ("spec" in inp_path): continue
-        opt_path1="%s/%s"%(opt_root1,name)
-        opt_path2="%s/%s"%(opt_root2,name)
-        paths.append([inp_path,opt_path1,opt_path2])
+        inp_path = "%s/%s" % (inp_root, name)
+        if "spec" in inp_path:
+            continue
+        opt_path1 = "%s/%s" % (opt_root1, name)
+        opt_path2 = "%s/%s" % (opt_root2, name)
+        paths.append([inp_path, opt_path1, opt_path2])
 
-    ps=[]
+    ps = []
     for i in range(n_p):
-        p=Process(target=featureInput.go,args=(paths[i::n_p],f0method,))
+        p = Process(
+            target=featureInput.go,
+            args=(
+                paths[i::n_p],
+                f0method,
+            ),
+        )
         p.start()
         ps.append(p)
     for p in ps:

extract_feature_print.py

@@ -1,34 +1,41 @@
-import os,sys,traceback
-if len(sys.argv) == 4:
-    n_part=int(sys.argv[1])
-    i_part=int(sys.argv[2])
-    exp_dir=sys.argv[3]
+import os, sys, traceback
+
+# device=sys.argv[1]
+n_part = int(sys.argv[2])
+i_part = int(sys.argv[3])
+if len(sys.argv) == 5:
+    exp_dir = sys.argv[4]
 else:
-    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)
+    i_gpu = sys.argv[4]
+    exp_dir = sys.argv[5]
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(i_gpu)
 
 import torch
 import torch.nn.functional as F
 import soundfile as sf
 import numpy as np
 from fairseq import checkpoint_utils
+
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-f = open("%s/extract_f0_feature.log"%exp_dir, "a+")
+f = open("%s/extract_f0_feature.log" % exp_dir, "a+")
+
+
 def printt(strr):
     print(strr)
     f.write("%s\n" % strr)
     f.flush()
+
+
 printt(sys.argv)
 model_path = "hubert_base.pt"
 
 printt(exp_dir)
-wavPath = "%s/1_16k_wavs"%exp_dir
-outPath = "%s/3_feature256"%exp_dir
-os.makedirs(outPath,exist_ok=True)
+wavPath = "%s/1_16k_wavs" % exp_dir
+outPath = "%s/3_feature256" % exp_dir
+os.makedirs(outPath, exist_ok=True)
+
+
 # wave must be 16k, hop_size=320
 def readwave(wav_path, normalize=False):
     wav, sr = sf.read(wav_path)
@@ -42,6 +49,8 @@ def readwave(wav_path, normalize=False):
             feats = F.layer_norm(feats, feats.shape)
     feats = feats.view(1, -1)
     return feats
+
+
 # HuBERT model
 printt("load model(s) from {}".format(model_path))
 models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
@@ -50,27 +59,32 @@ models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
 )
 model = models[0]
 model = model.to(device)
-if torch.cuda.is_available():
+printt("move model to %s" % device)
+if device != "cpu":
     model = model.half()
 model.eval()
 
-todo=sorted(list(os.listdir(wavPath)))[i_part::n_part]
-n = max(1,len(todo) // 10)  # 最多打印十条
-if(len(todo)==0):printt("no-feature-todo")
+todo = sorted(list(os.listdir(wavPath)))[i_part::n_part]
+n = max(1, len(todo) // 10)  # 最多打印十条
+if len(todo) == 0:
+    printt("no-feature-todo")
 else:
-    printt("all-feature-%s"%len(todo))
-    for idx,file in enumerate(todo):
+    printt("all-feature-%s" % len(todo))
+    for idx, file in enumerate(todo):
         try:
             if file.endswith(".wav"):
-                wav_path = "%s/%s"%(wavPath,file)
-                out_path = "%s/%s"%(outPath,file.replace("wav","npy"))
+                wav_path = "%s/%s" % (wavPath, file)
+                out_path = "%s/%s" % (outPath, file.replace("wav", "npy"))
 
-                if(os.path.exists(out_path)):continue
+                if os.path.exists(out_path):
+                    continue
 
                 feats = readwave(wav_path, normalize=saved_cfg.task.normalize)
                 padding_mask = torch.BoolTensor(feats.shape).fill_(False)
                 inputs = {
-                    "source": feats.half().to(device) if torch.cuda.is_available() else feats.to(device),
+                    "source": feats.half().to(device)
+                    if device != "cpu"
+                    else feats.to(device),
                     "padding_mask": padding_mask.to(device),
                     "output_layer": 9,  # layer 9
                 }
@@ -79,11 +93,12 @@ else:
                     feats = model.final_proj(logits[0])
 
                 feats = feats.squeeze(0).float().cpu().numpy()
-                if(np.isnan(feats).sum()==0):
+                if np.isnan(feats).sum() == 0:
                     np.save(out_path, feats, allow_pickle=False)
                 else:
-                    printt("%s-contains nan"%file)
-                if (idx % n == 0):printt("now-%s,all-%s,%s,%s"%(len(todo),idx,file,feats.shape))
+                    printt("%s-contains nan" % file)
+                if idx % n == 0:
+                    printt("now-%s,all-%s,%s,%s" % (len(todo), idx, file, feats.shape))
         except:
             printt(traceback.format_exc())
     printt("all-feature-done")

extract_locale.py

@@ -0,0 +1,31 @@
+import json
+import re
+
+# Define regular expression patterns
+pattern = r"""i18n\([\s\n\t]*(["'][^"']+["'])[\s\n\t]*\)"""
+
+# Initialize the dictionary to store key-value pairs
+data = {}
+
+
+def process(fn: str):
+    global data
+    with open(fn, "r", encoding="utf-8") as f:
+        contents = f.read()
+        matches = re.findall(pattern, contents)
+        for key in matches:
+            key = eval(key)
+            print("extract:", key)
+            data[key] = key
+
+
+print("processing infer-web.py")
+process("infer-web.py")
+
+print("processing gui.py")
+process("gui.py")
+
+# Save as a JSON file
+with open("./i18n/zh_CN.json", "w", encoding="utf-8") as f:
+    json.dump(data, f, ensure_ascii=False, indent=4)
+    f.write("\n")

go-realtime-gui.bat

@@ -0,0 +1,2 @@
+runtime\python.exe gui.py
+pause

go-web.bat

@@ -0,0 +1,2 @@
+runtime\python.exe infer-web.py --pycmd runtime\python.exe --port 7897
+pause

gui.py

@@ -0,0 +1,562 @@
+import os, sys
+
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+import PySimpleGUI as sg
+import sounddevice as sd
+import noisereduce as nr
+import numpy as np
+from fairseq import checkpoint_utils
+import librosa, torch, pyworld, faiss, time, threading
+import torch.nn.functional as F
+import torchaudio.transforms as tat
+import scipy.signal as signal
+
+# import matplotlib.pyplot as plt
+from infer_pack.models import SynthesizerTrnMs256NSFsid, SynthesizerTrnMs256NSFsid_nono
+from i18n import I18nAuto
+
+i18n = I18nAuto()
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+class RVC:
+    def __init__(
+        self, key, hubert_path, pth_path, index_path, npy_path, index_rate
+    ) -> None:
+        """
+        初始化
+        """
+        try:
+            self.f0_up_key = key
+            self.time_step = 160 / 16000 * 1000
+            self.f0_min = 50
+            self.f0_max = 1100
+            self.f0_mel_min = 1127 * np.log(1 + self.f0_min / 700)
+            self.f0_mel_max = 1127 * np.log(1 + self.f0_max / 700)
+            self.sr = 16000
+            self.window = 160
+            if index_rate != 0:
+                self.index = faiss.read_index(index_path)
+                self.big_npy = np.load(npy_path)
+                print("index search enabled")
+            self.index_rate = index_rate
+            model_path = hubert_path
+            print("load model(s) from {}".format(model_path))
+            models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
+                [model_path],
+                suffix="",
+            )
+            self.model = models[0]
+            self.model = self.model.to(device)
+            self.model = self.model.half()
+            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"])
+            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()
+        except Exception as e:
+            print(e)
+
+    def get_f0(self, x, f0_up_key, inp_f0=None):
+        x_pad = 1
+        f0_min = 50
+        f0_max = 1100
+        f0_mel_min = 1127 * np.log(1 + f0_min / 700)
+        f0_mel_max = 1127 * np.log(1 + f0_max / 700)
+        f0, t = pyworld.harvest(
+            x.astype(np.double),
+            fs=self.sr,
+            f0_ceil=f0_max,
+            f0_floor=f0_min,
+            frame_period=10,
+        )
+        f0 = pyworld.stonemask(x.astype(np.double), f0, t, self.sr)
+        f0 = signal.medfilt(f0, 3)
+        f0 *= pow(2, f0_up_key / 12)
+        # with open("test.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
+        tf0 = self.sr // self.window  # 每秒f0点数
+        if inp_f0 is not None:
+            delta_t = np.round(
+                (inp_f0[:, 0].max() - inp_f0[:, 0].min()) * tf0 + 1
+            ).astype("int16")
+            replace_f0 = np.interp(
+                list(range(delta_t)), inp_f0[:, 0] * 100, inp_f0[:, 1]
+            )
+            shape = f0[x_pad * tf0 : x_pad * tf0 + len(replace_f0)].shape[0]
+            f0[x_pad * tf0 : x_pad * tf0 + len(replace_f0)] = replace_f0[:shape]
+        # with open("test_opt.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
+        f0bak = f0.copy()
+        f0_mel = 1127 * np.log(1 + f0 / 700)
+        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
+            f0_mel_max - f0_mel_min
+        ) + 1
+        f0_mel[f0_mel <= 1] = 1
+        f0_mel[f0_mel > 255] = 255
+        f0_coarse = np.rint(f0_mel).astype(np.int)
+        return f0_coarse, f0bak  # 1-0
+
+    def infer(self, feats: torch.Tensor) -> np.ndarray:
+        """
+        推理函数
+        """
+        audio = feats.clone().cpu().numpy()
+        assert feats.dim() == 1, feats.dim()
+        feats = feats.view(1, -1)
+        padding_mask = torch.BoolTensor(feats.shape).fill_(False)
+        inputs = {
+            "source": feats.half().to(device),
+            "padding_mask": padding_mask.to(device),
+            "output_layer": 9,  # layer 9
+        }
+        torch.cuda.synchronize()
+        with torch.no_grad():
+            logits = self.model.extract_features(**inputs)
+            feats = self.model.final_proj(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")
+            feats = (
+                torch.from_numpy(npy).unsqueeze(0).to(device) * self.index_rate
+                + (1 - self.index_rate) * feats
+            )
+        else:
+            print("index search FAIL or disabled")
+
+        feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
+        torch.cuda.synchronize()
+        print(feats.shape)
+        if self.if_f0 == 1:
+            pitch, pitchf = self.get_f0(audio, self.f0_up_key)
+            p_len = min(feats.shape[1], 13000, pitch.shape[0])  # 太大了爆显存
+        else:
+            pitch, pitchf = None, None
+            p_len = min(feats.shape[1], 13000)  # 太大了爆显存
+        torch.cuda.synchronize()
+        # print(feats.shape,pitch.shape)
+        feats = feats[:, :p_len, :]
+        if self.if_f0 == 1:
+            pitch = pitch[:p_len]
+            pitchf = pitchf[:p_len]
+            pitch = torch.LongTensor(pitch).unsqueeze(0).to(device)
+            pitchf = torch.FloatTensor(pitchf).unsqueeze(0).to(device)
+        p_len = torch.LongTensor([p_len]).to(device)
+        ii = 0  # sid
+        sid = torch.LongTensor([ii]).to(device)
+        with torch.no_grad():
+            if self.if_f0 == 1:
+                infered_audio = (
+                    self.net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0]
+                    .data.cpu()
+                    .float()
+                )
+            else:
+                infered_audio = (
+                    self.net_g.infer(feats, p_len, sid)[0][0, 0].data.cpu().float()
+                )
+        torch.cuda.synchronize()
+        return infered_audio
+
+
+class Config:
+    def __init__(self) -> None:
+        self.hubert_path: str = ""
+        self.pth_path: str = ""
+        self.index_path: str = ""
+        self.npy_path: str = ""
+        self.pitch: int = 12
+        self.samplerate: int = 44100
+        self.block_time: float = 1.0  # s
+        self.buffer_num: int = 1
+        self.threhold: int = -30
+        self.crossfade_time: float = 0.08
+        self.extra_time: float = 0.04
+        self.I_noise_reduce = False
+        self.O_noise_reduce = False
+        self.index_rate = 0.3
+
+
+class GUI:
+    def __init__(self) -> None:
+        self.config = Config()
+        self.flag_vc = False
+
+        self.launcher()
+
+    def launcher(self):
+        sg.theme("LightBlue3")
+        input_devices, output_devices, _, _ = self.get_devices()
+        layout = [
+            [
+                sg.Frame(
+                    title=i18n("加载模型"),
+                    layout=[
+                        [
+                            sg.Input(
+                                default_text="TEMP\\hubert_base.pt", key="hubert_path"
+                            ),
+                            sg.FileBrowse(i18n("Hubert模型")),
+                        ],
+                        [
+                            sg.Input(default_text="TEMP\\atri.pth", key="pth_path"),
+                            sg.FileBrowse(i18n("选择.pth文件")),
+                        ],
+                        [
+                            sg.Input(
+                                default_text="TEMP\\added_IVF512_Flat_atri_baseline_src_feat.index",
+                                key="index_path",
+                            ),
+                            sg.FileBrowse(i18n("选择.index文件")),
+                        ],
+                        [
+                            sg.Input(
+                                default_text="TEMP\\big_src_feature_atri.npy",
+                                key="npy_path",
+                            ),
+                            sg.FileBrowse(i18n("选择.npy文件")),
+                        ],
+                    ],
+                )
+            ],
+            [
+                sg.Frame(
+                    layout=[
+                        [
+                            sg.Text(i18n("输入设备")),
+                            sg.Combo(
+                                input_devices,
+                                key="sg_input_device",
+                                default_value=input_devices[sd.default.device[0]],
+                            ),
+                        ],
+                        [
+                            sg.Text(i18n("输出设备")),
+                            sg.Combo(
+                                output_devices,
+                                key="sg_output_device",
+                                default_value=output_devices[sd.default.device[1]],
+                            ),
+                        ],
+                    ],
+                    title=i18n("音频设备(请使用同种类驱动)"),
+                )
+            ],
+            [
+                sg.Frame(
+                    layout=[
+                        [
+                            sg.Text(i18n("响应阈值")),
+                            sg.Slider(
+                                range=(-60, 0),
+                                key="threhold",
+                                resolution=1,
+                                orientation="h",
+                                default_value=-30,
+                            ),
+                        ],
+                        [
+                            sg.Text(i18n("音调设置")),
+                            sg.Slider(
+                                range=(-24, 24),
+                                key="pitch",
+                                resolution=1,
+                                orientation="h",
+                                default_value=12,
+                            ),
+                        ],
+                        [
+                            sg.Text(i18n("Index Rate")),
+                            sg.Slider(
+                                range=(0.0, 1.0),
+                                key="index_rate",
+                                resolution=0.01,
+                                orientation="h",
+                                default_value=0.5,
+                            ),
+                        ],
+                    ],
+                    title=i18n("常规设置"),
+                ),
+                sg.Frame(
+                    layout=[
+                        [
+                            sg.Text(i18n("采样长度")),
+                            sg.Slider(
+                                range=(0.1, 3.0),
+                                key="block_time",
+                                resolution=0.1,
+                                orientation="h",
+                                default_value=1.0,
+                            ),
+                        ],
+                        [
+                            sg.Text(i18n("淡入淡出长度")),
+                            sg.Slider(
+                                range=(0.01, 0.15),
+                                key="crossfade_length",
+                                resolution=0.01,
+                                orientation="h",
+                                default_value=0.08,
+                            ),
+                        ],
+                        [
+                            sg.Text(i18n("额外推理时长")),
+                            sg.Slider(
+                                range=(0.05, 3.00),
+                                key="extra_time",
+                                resolution=0.01,
+                                orientation="h",
+                                default_value=0.05,
+                            ),
+                        ],
+                        [
+                            sg.Checkbox(i18n("输入降噪"), key="I_noise_reduce"),
+                            sg.Checkbox(i18n("输出降噪"), key="O_noise_reduce"),
+                        ],
+                    ],
+                    title=i18n("性能设置"),
+                ),
+            ],
+            [
+                sg.Button(i18n("开始音频转换"), key="start_vc"),
+                sg.Button(i18n("停止音频转换"), key="stop_vc"),
+                sg.Text(i18n("推理时间(ms):")),
+                sg.Text("0", key="infer_time"),
+            ],
+        ]
+
+        self.window = sg.Window("RVC - GUI", layout=layout)
+        self.event_handler()
+
+    def event_handler(self):
+        while True:
+            event, values = self.window.read()
+            if event == sg.WINDOW_CLOSED:
+                self.flag_vc = False
+                exit()
+            if event == "start_vc" and self.flag_vc == False:
+                self.set_values(values)
+                print(str(self.config.__dict__))
+                print("using_cuda:" + str(torch.cuda.is_available()))
+                self.start_vc()
+            if event == "stop_vc" and self.flag_vc == True:
+                self.flag_vc = False
+
+    def set_values(self, values):
+        self.set_devices(values["sg_input_device"], values["sg_output_device"])
+        self.config.hubert_path = values["hubert_path"]
+        self.config.pth_path = values["pth_path"]
+        self.config.index_path = values["index_path"]
+        self.config.npy_path = values["npy_path"]
+        self.config.threhold = values["threhold"]
+        self.config.pitch = values["pitch"]
+        self.config.block_time = values["block_time"]
+        self.config.crossfade_time = values["crossfade_length"]
+        self.config.extra_time = values["extra_time"]
+        self.config.I_noise_reduce = values["I_noise_reduce"]
+        self.config.O_noise_reduce = values["O_noise_reduce"]
+        self.config.index_rate = values["index_rate"]
+
+    def start_vc(self):
+        torch.cuda.empty_cache()
+        self.flag_vc = True
+        self.block_frame = int(self.config.block_time * self.config.samplerate)
+        self.crossfade_frame = int(self.config.crossfade_time * self.config.samplerate)
+        self.sola_search_frame = int(0.012 * self.config.samplerate)
+        self.delay_frame = int(0.01 * self.config.samplerate)  # 往前预留0.02s
+        self.extra_frame = int(
+            self.config.extra_time * self.config.samplerate
+        )  
+        self.rvc = None
+        self.rvc = RVC(
+            self.config.pitch,
+            self.config.hubert_path,
+            self.config.pth_path,
+            self.config.index_path,
+            self.config.npy_path,
+            self.config.index_rate,
+        )
+        self.input_wav: np.ndarray = np.zeros(
+            self.extra_frame
+            + self.crossfade_frame
+            + self.sola_search_frame
+            + self.block_frame,
+            dtype="float32",
+        )
+        self.output_wav: torch.Tensor = torch.zeros(
+            self.block_frame, device=device, dtype=torch.float32
+        )
+        self.sola_buffer: torch.Tensor = torch.zeros(
+            self.crossfade_frame, device=device, dtype=torch.float32
+        )
+        self.fade_in_window: torch.Tensor = torch.linspace(
+            0.0, 1.0, steps=self.crossfade_frame, device=device, dtype=torch.float32
+        )
+        self.fade_out_window: torch.Tensor = 1 - self.fade_in_window
+        self.resampler1 = tat.Resample(
+            orig_freq=self.config.samplerate, new_freq=16000, dtype=torch.float32
+        )
+        self.resampler2 = tat.Resample(
+            orig_freq=self.rvc.tgt_sr, new_freq=self.config.samplerate, dtype=torch.float32
+        )
+        thread_vc = threading.Thread(target=self.soundinput)
+        thread_vc.start()
+
+    def soundinput(self):
+        """
+        接受音频输入
+        """
+        with sd.Stream(
+            callback=self.audio_callback,
+            blocksize=self.block_frame,
+            samplerate=self.config.samplerate,
+            dtype="float32",
+        ):
+            while self.flag_vc:
+                time.sleep(self.config.block_time)
+                print("Audio block passed.")
+        print("ENDing VC")
+
+    def audio_callback(
+        self, indata: np.ndarray, outdata: np.ndarray, frames, times, status
+    ):
+        """
+        音频处理
+        """
+        start_time = time.perf_counter()
+        indata = librosa.to_mono(indata.T)
+        if self.config.I_noise_reduce:
+            indata[:] = nr.reduce_noise(y=indata, sr=self.config.samplerate)
+
+        """noise gate"""
+        frame_length = 2048
+        hop_length = 1024
+        rms = librosa.feature.rms(
+            y=indata, frame_length=frame_length, hop_length=hop_length
+        )
+        db_threhold = librosa.amplitude_to_db(rms, ref=1.0)[0] < self.config.threhold
+        # print(rms.shape,db.shape,db)
+        for i in range(db_threhold.shape[0]):
+            if db_threhold[i]:
+                indata[i * hop_length : (i + 1) * hop_length] = 0
+        self.input_wav[:] = np.append(self.input_wav[self.block_frame :], indata)
+
+        # infer
+        print("input_wav:" + str(self.input_wav.shape))
+        # print('infered_wav:'+str(infer_wav.shape))
+        infer_wav: torch.Tensor = self.resampler2(
+            self.rvc.infer(self.resampler1(torch.from_numpy(self.input_wav)))
+        )[-self.crossfade_frame - self.sola_search_frame - self.block_frame :].to(
+            device
+        )
+        print("infer_wav:" + str(infer_wav.shape))
+
+        # SOLA algorithm from https://github.com/yxlllc/DDSP-SVC
+        cor_nom = F.conv1d(
+            infer_wav[None, None, : self.crossfade_frame + self.sola_search_frame],
+            self.sola_buffer[None, None, :],
+        )
+        cor_den = torch.sqrt(
+            F.conv1d(
+                infer_wav[None, None, : self.crossfade_frame + self.sola_search_frame]
+                ** 2,
+                torch.ones(1, 1, self.crossfade_frame, device=device),
+            )
+            + 1e-8
+        )
+        sola_offset = torch.argmax(cor_nom[0, 0] / cor_den[0, 0])
+        print("sola offset: " + str(int(sola_offset)))
+
+        # crossfade
+        self.output_wav[:] = infer_wav[sola_offset : sola_offset + self.block_frame]
+        self.output_wav[: self.crossfade_frame] *= self.fade_in_window
+        self.output_wav[: self.crossfade_frame] += self.sola_buffer[:]
+        if sola_offset < self.sola_search_frame:
+            self.sola_buffer[:] = (
+                infer_wav[
+                    -self.sola_search_frame
+                    - self.crossfade_frame
+                    + sola_offset : -self.sola_search_frame
+                    + sola_offset
+                ]
+                * self.fade_out_window
+            )
+        else:
+            self.sola_buffer[:] = (
+                infer_wav[-self.crossfade_frame :] * self.fade_out_window
+            )
+
+        if self.config.O_noise_reduce:
+            outdata[:] = np.tile(
+                nr.reduce_noise(
+                    y=self.output_wav[:].cpu().numpy(), sr=self.config.samplerate
+                ),
+                (2, 1),
+            ).T
+        else:
+            outdata[:] = self.output_wav[:].repeat(2, 1).t().cpu().numpy()
+        total_time = time.perf_counter() - start_time
+        self.window["infer_time"].update(int(total_time * 1000))
+        print("infer time:" + str(total_time))
+
+    def get_devices(self, update: bool = True):
+        """获取设备列表"""
+        if update:
+            sd._terminate()
+            sd._initialize()
+        devices = sd.query_devices()
+        hostapis = sd.query_hostapis()
+        for hostapi in hostapis:
+            for device_idx in hostapi["devices"]:
+                devices[device_idx]["hostapi_name"] = hostapi["name"]
+        input_devices = [
+            f"{d['name']} ({d['hostapi_name']})"
+            for d in devices
+            if d["max_input_channels"] > 0
+        ]
+        output_devices = [
+            f"{d['name']} ({d['hostapi_name']})"
+            for d in devices
+            if d["max_output_channels"] > 0
+        ]
+        input_devices_indices = [
+            d["index"] for d in devices if d["max_input_channels"] > 0
+        ]
+        output_devices_indices = [
+            d["index"] for d in devices if d["max_output_channels"] > 0
+        ]
+        return (
+            input_devices,
+            output_devices,
+            input_devices_indices,
+            output_devices_indices,
+        )
+
+    def set_devices(self, input_device, output_device):
+        """设置输出设备"""
+        (
+            input_devices,
+            output_devices,
+            input_device_indices,
+            output_device_indices,
+        ) = self.get_devices()
+        sd.default.device[0] = input_device_indices[input_devices.index(input_device)]
+        sd.default.device[1] = output_device_indices[
+            output_devices.index(output_device)
+        ]
+        print("input device:" + str(sd.default.device[0]) + ":" + str(input_device))
+        print("output device:" + str(sd.default.device[1]) + ":" + str(output_device))
+
+
+gui = GUI()

i18n.py

@@ -0,0 +1,25 @@
+import locale
+import json
+import os
+
+
+def load_language_list(language):
+    with open(f"./i18n/{language}.json", "r", encoding="utf-8") as f:
+        language_list = json.load(f)
+    return language_list
+
+
+class I18nAuto:
+    def __init__(self, language=None):
+        if language in ["Auto", None]:
+            language = locale.getdefaultlocale()[
+                0
+            ]  # getlocale can't identify the system's language ((None, None))
+        if not os.path.exists(f"./i18n/{language}.json"):
+            language = "en_US"
+        self.language = language
+        print("Use Language:", language)
+        self.language_map = load_language_list(language)
+
+    def __call__(self, key):
+        return self.language_map[key]

i18n/en_US.json

@@ -0,0 +1,104 @@
+{
+    "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.": "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. <br>If you do not agree with this clause, you cannot use or quote any codes and files in the software package . See root directory <b>Agreement-LICENSE.txt</b> for details.",
+    "模型推理": "Model inference",
+    "推理音色": "Inferencing timbre",
+    "刷新音色列表": "Refresh timbre list",
+    "卸载音色省显存": "Unload timbre to save GPU memory",
+    "请选择说话人id": "Please select a speaker id",
+    "男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "It is recommended +12key for male to female conversion, and -12key for female to male conversion. If the sound range explodes and the timbre 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' to speed up for singing voices, or use 'harvest' for better low-pitched voices, but it is extremely slow.",
+    "特征检索库文件路径": "Feature search database file path",
+    "特征文件路径": "Feature file path",
+    "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0 curve file, optional, one pitch per line, instead of the default F0 and ups and downs",
+    "转换": "Conversion",
+    "输出信息": "Output information",
+    "输出音频(右下角三个点,点了可以下载)": "Output 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). ",
+    "指定输出文件夹": "Specify output folder",
+    "检索特征占比": "Search feature ratio",
+    "输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "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模型. <br>不带和声用HP2, 带和声且提取的人声不需要和声用HP5<br>合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "Batch processing of vocal accompaniment separation, using UVR5 model. <br>Without harmony, use HP2, with harmony and extracted vocals do not need harmony, use HP5<br>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",
+    "模型": "Model",
+    "指定输出人声文件夹": "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. ",
+    "输入实验名": "Input experiment name",
+    "目标采样率": "Target sample rate",
+    "模型是否带音高指导(唱歌一定要, 语音可以不要)": "Does the model have pitch guidance (singing must, voice can not.)",
+    "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. ",
+    "输入训练文件夹路径": "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",
+    "提取音高使用的CPU进程数": "Number of CPU threads to use for pitch extraction",
+    "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "Select pitch extraction algorithm: Use 'pm' for faster processing of singing voice, 'dio' for high-quality speech but slower processing, and 'harvest' for the best quality but slowest processing.",
+    "特征提取": "Feature extraction",
+    "step3: 填写训练设置, 开始训练模型和索引": "step3: Fill in the training settings, start training the model and index",
+    "保存频率save_every_epoch": "Save frequency (save_every_epoch)",
+    "总训练轮数total_epoch": "Total training epochs (total_epoch)",
+    "是否仅保存最新的ckpt文件以节省硬盘空间": "Whether to save only the latest ckpt file to save disk space",
+    "是否缓存所有训练集至显存. 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",
+    "加载预训练底模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",
+    "A模型路径": "A model path.",
+    "B模型路径": "B model path.",
+    "A模型权重": "A model weight for model A.",
+    "模型是否带音高指导": "Whether the model has pitch guidance.",
+    "要置入的模型信息": "Model information to be placed.",
+    "保存的模型名不带后缀": "Saved model name without extension.",
+    "融合": "Fusion.",
+    "修改模型信息(仅支持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",
+    "修改": "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",
+    "保存名": "Save Name",
+    "模型是否带音高指导,1是0否": "Whether the model has pitch guidance, 1 for yes, 0 for no",
+    "提取": "Extract",
+    "Onnx导出": "Onnx",
+    "RVC模型路径": "RVC Path",
+    "Onnx输出路径": "Onnx Export Path",
+    "MoeVS模型": "MoeSS?",
+    "导出Onnx模型": "Export Onnx Model",
+    "招募音高曲线前端编辑器": "Recruit front-end editors for pitch curves",
+    "加开发群联系我xxxxx": "Add development group to contact me xxxxx",
+    "点击查看交流、问题反馈群号": "Click to view the communication and problem feedback group number",
+    "xxxxx": "xxxxx",
+    "加载模型": "load model",
+    "Hubert模型": "Hubert File",
+    "选择.pth文件": "Select the .pth file",
+    "选择.index文件": "Select the .index file",
+    "选择.npy文件": "Select the .npy file",
+    "输入设备": "input device",
+    "输出设备": "output device",
+    "音频设备(请使用同种类驱动)": "Audio device (please use the same type of driver)",
+    "响应阈值": "response threshold",
+    "音调设置": "tone setting",
+    "Index Rate": "Index Rate",
+    "常规设置": "general settings",
+    "采样长度": "Sample length",
+    "淡入淡出长度": "fade length",
+    "额外推理时长": "extra inference time",
+    "输入降噪": "Input Noisereduce",
+    "输出降噪": "Output Noisereduce",
+    "性能设置": "performance settings",
+    "开始音频转换": "start audio conversion",
+    "停止音频转换": "stop audio conversion",
+    "推理时间(ms):": "Infer Time(ms):"
+}

i18n/es_ES.json

@@ -0,0 +1,104 @@
+{
+    "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.": "Este software es de código abierto bajo la licencia MIT, el autor no tiene ningún control sobre el software, y aquellos que usan el software y difunden los sonidos exportados por el software son los únicos responsables.<br>Si no está de acuerdo con esta cláusula , no puede utilizar ni citar ningún código ni archivo del paquete de software Consulte el directorio raíz <b>Agreement-LICENSE.txt</b> para obtener más información.",
+    "模型推理": "inferencia del modelo",
+    "推理音色": "inferencia de voz",
+    "刷新音色列表": "Actualizar lista de voces",
+    "卸载音色省显存": "Descargue la voz para ahorrar memoria GPU",
+    "请选择说话人id": "seleccione una identificación de altavoz",
+    "男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "Tecla +12 recomendada para conversión de voz de hombre a mujer, tecla -12 para conversión de voz de mujer a hombre. Si el rango de tono es demasiado amplio y causa distorsión, ajústelo usted mismo a un rango adecuado.",
+    "变调(整数, 半音数量, 升八度12降八度-12)": "Cambio de tono (entero, número de semitonos, subir una octava +12 o bajar una octava -12)",
+    "输入待处理音频文件路径(默认是正确格式示例)": "Ingrese la ruta del archivo del audio que se procesará (el formato predeterminado es el ejemplo correcto)",
+    "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "Seleccione el algoritmo para la extracción de tono. Use 'pm' para acelerar las voces cantadas, o use 'harvest' para mejorar las voces bajas, pero es extremadamente lento.",
+    "特征检索库文件路径": "Ruta del archivo de la base de datos de búsqueda de características",
+    "特征文件路径": "Ruta del archivo de características",
+    "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "Archivo de curva F0, opcional, un tono por línea, en lugar de F0 predeterminado y cambio de tono",
+    "转换": "Conversión",
+    "输出信息": "Información de salida",
+    "输出音频(右下角三个点,点了可以下载)": "Salida de audio (haga clic en los tres puntos en la esquina inferior derecha para descargar)",
+    "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "Conversión por lotes, ingrese la carpeta que contiene los archivos de audio para convertir o cargue varios archivos de audio. El audio convertido se emitirá en la carpeta especificada (opción predeterminada).",
+    "指定输出文件夹": "Especificar carpeta de salida",
+    "检索特征占比": "Proporción de función de búsqueda",
+    "输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "Ingrese la ruta a la carpeta de audio que se procesará (simplemente cópiela desde la barra de direcciones del administrador de archivos)",
+    "也可批量输入音频文件, 二选一, 优先读文件夹": "También se pueden ingresar múltiples archivos de audio, cualquiera de las dos opciones, con prioridad dada a la carpeta",
+    "伴奏人声分离": "Instrumental and vocal separation",
+    "人声伴奏分离批量处理, 使用UVR5模型. <br>不带和声用HP2, 带和声且提取的人声不需要和声用HP5<br>合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "Procesamiento por lotes de separación instrumental y vocal utilizando el modelo UVR5. <br>Utilice HP2 para la separación vocal sin armónicos, y utilice HP5 para la separación vocal con armónicos y las voces extraídas no necesitan tener armónicos. <br>Ejemplo de una ruta de carpeta calificada: E:\\codes\\py39\\vits_vc_gpu\\test_sample (simplemente cópielo desde la barra de direcciones del administrador de archivos)",
+    "输入待处理音频文件夹路径": "Ingrese la ruta a la carpeta de audio que se procesará",
+    "模型": "Modelo",
+    "指定输出人声文件夹": "Especificar la carpeta de salida de voces",
+    "指定输出乐器文件夹": "Especificar la carpeta de salida de instrumentales",
+    "训练": "Entrenamiento",
+    "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "paso 1: Complete la configuración del experimento. Los datos del experimento se almacenan en el directorio 'logs', con cada experimento en una carpeta separada. La ruta del nombre del experimento debe ingresarse manualmente y debe contener la configuración del experimento, los registros y los archivos del modelo entrenado.",
+    "输入实验名": "Ingrese el nombre del modelo",
+    "目标采样率": "Tasa de muestreo objetivo",
+    "模型是否带音高指导(唱歌一定要, 语音可以不要)": "Si el modelo tiene guía de tono (necesaria para cantar, pero no para hablar)",
+    "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "paso 2a: recorra automáticamente la carpeta de capacitación y corte y normalice todos los archivos de audio que se pueden decodificar en audio. Se generarán dos carpetas 'wav' en el directorio del experimento. Actualmente, solo se admite la capacitación de una sola persona.",
+    "输入训练文件夹路径": "Introduzca la ruta de la carpeta de entrenamiento",
+    "请指定说话人id": "Especifique el ID del hablante",
+    "处理数据": "Procesar datos",
+    "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "paso 2b: use la CPU para extraer el tono (si el modelo tiene guía de tono) y la GPU para extraer características (seleccione el número de tarjeta).",
+    "以-分隔输入使用的卡号, 例如   0-1-2   使用卡0和卡1和卡2": "Separe los números de identificación de la GPU con '-' al ingresarlos. Por ejemplo, '0-1-2' significa usar GPU 0, GPU 1 y GPU 2.",
+    "显卡信息": "información de la GPU",
+    "提取音高使用的CPU进程数": "Número de subprocesos de CPU que se utilizarán para la extracción de tono",
+    "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "Seleccione el algoritmo de extracción de tono: utilice 'pm' para un procesamiento más rápido de la voz cantada, 'dio' para un discurso de alta calidad pero un procesamiento más lento y 'cosecha' para obtener la mejor calidad pero un procesamiento más lento.",
+    "特征提取": "Extracción de características",
+    "step3: 填写训练设置, 开始训练模型和索引": "Paso 3: complete la configuración de entrenamiento y comience a entrenar el modelo y el índice.",
+    "保存频率save_every_epoch": "Frecuencia de guardado (save_every_epoch)",
+    "总训练轮数total_epoch": "Total de épocas de entrenamiento (total_epoch)",
+    "是否仅保存最新的ckpt文件以节省硬盘空间": "Si guardar solo el archivo ckpt más reciente para ahorrar espacio en disco",
+    "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "Si almacenar en caché todos los conjuntos de entrenamiento en la memoria de la GPU. Los conjuntos de datos pequeños (menos de 10 minutos) se pueden almacenar en caché para acelerar el entrenamiento, pero el almacenamiento en caché de conjuntos de datos grandes puede causar errores de memoria en la GPU y no aumenta la velocidad de manera significativa.",
+    "加载预训练底模G路径": "Cargue la ruta G del modelo base preentrenada.",
+    "加载预训练底模D路径": "Cargue la ruta del modelo D base preentrenada.",
+    "训练模型": "Entrenar Modelo",
+    "训练特征索引": "Índice de características del Entrenamiento",
+    "一键训练": "Entrenamiento con un clic.",
+    "ckpt处理": "Procesamiento de recibos",
+    "模型融合, 可用于测试音色融合": "Fusión de modelos, se puede utilizar para fusionar diferentes voces",
+    "A模型路径": "Modelo A ruta.",
+    "B模型路径": "Modelo B ruta.",
+    "A模型权重": "Un peso modelo para el modelo A.",
+    "模型是否带音高指导": "Si el modelo tiene guía de tono.",
+    "要置入的模型信息": "Información del modelo a colocar.",
+    "保存的模型名不带后缀": "Nombre del modelo guardado sin extensión.",
+    "融合": "Fusión.",
+    "修改模型信息(仅支持weights文件夹下提取的小模型文件)": "Modificar la información del modelo (solo admite archivos de modelos pequeños extraídos en la carpeta de pesos).",
+    "模型路径": "Ruta del modelo",
+    "要改的模型信息": "Información del modelo a modificar",
+    "保存的文件名, 默认空为和源文件同名": "Nombre del archivo que se guardará, el valor predeterminado es el mismo que el nombre del archivo de origen",
+    "修改": "Modificar",
+    "查看模型信息(仅支持weights文件夹下提取的小模型文件)": "Ver información del modelo (solo aplicable a archivos de modelos pequeños extraídos de la carpeta 'pesos')",
+    "查看": "Ver",
+    "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况": "Extracción de modelo (ingrese la ruta de un archivo de modelo grande en la carpeta 'logs'), aplicable cuando desea extraer un archivo de modelo pequeño después de entrenar a mitad de camino y no se guardó automáticamente, o cuando desea probar un modelo intermedio",
+    "保存名": "Guardar nombre",
+    "模型是否带音高指导,1是0否": "Si el modelo tiene guía de tono, 1 para sí, 0 para no",
+    "提取": "Extracter",
+    "Onnx导出": "Onnx导出",
+    "RVC模型路径": "RVC模型路径",
+    "Onnx输出路径": "Onnx输出路径",
+    "MoeVS模型": "MoeVS模型",
+    "导出Onnx模型": "导出Onnx模型",
+    "招募音高曲线前端编辑器": "Reclutar editores front-end para curvas de tono",
+    "加开发群联系我xxxxx": "Únase al grupo de desarrollo para contactarme en xxxxx",
+    "点击查看交流、问题反馈群号": "Haga clic para ver el número de grupo de comunicación y comentarios sobre problemas",
+    "xxxxx": "xxxxx",
+    "加载模型": "Cargar modelo",
+    "Hubert模型": "Modelo de Hubert ",
+    "选择.pth文件": "Seleccionar archivo .pth",
+    "选择.index文件": "Select .index file",
+    "选择.npy文件": "Seleccionar archivo .npy",
+    "输入设备": "Dispositivo de entrada",
+    "输出设备": "Dispositivo de salida",
+    "音频设备(请使用同种类驱动)": "Dispositivo de audio (utilice el mismo tipo de controlador)",
+    "响应阈值": "Umbral de respuesta",
+    "音调设置": "Ajuste de tono",
+    "Index Rate": "Tasa de índice",
+    "常规设置": "Configuración general",
+    "采样长度": "Longitud de muestreo",
+    "淡入淡出长度": "Duración del fundido de entrada/salida",
+    "额外推理时长": "Tiempo de inferencia adicional",
+    "输入降噪": "Reducción de ruido de entrada",
+    "输出降噪": "Reducción de ruido de salida",
+    "性能设置": "Configuración de rendimiento",
+    "开始音频转换": "Iniciar conversión de audio",
+    "停止音频转换": "Detener la conversión de audio",
+    "推理时间(ms):": "Inferir tiempo (ms):"
+}

i18n/ja_JP.json

@@ -0,0 +1,104 @@
+{
+    "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.": "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.",
+    "模型推理": "モデル推論",
+    "推理音色": "音源推論",
+    "刷新音色列表": "音源リストを更新",
+    "卸载音色省显存": "音源を削除してメモリを節約",
+    "请选择说话人id": "話者IDを選択してください",
+    "男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "男性から女性へは+12キーをお勧めします。女性から男性へは-12キーをお勧めします。音域が広すぎて音質が劣化した場合は、適切な音域に自分で調整することもできます。",
+    "变调(整数, 半音数量, 升八度12降八度-12)": "ピッチ変更(整数、半音数、上下オクターブ12-12)",
+    "输入待处理音频文件路径(默认是正确格式示例)": "処理対象音声ファイルのパスを入力してください(デフォルトは正しいフォーマットの例です)",
+    "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "ピッチ抽出アルゴリズムを選択してください。歌声の場合は、pmを使用して速度を上げることができます。低音が重要な場合は、harvestを使用できますが、非常に遅くなります。",
+    "特征检索库文件路径": "特徴量検索データベースのファイルパス",
+    "特征文件路径": "特徴量ファイルのパス",
+    "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0(最低共振周波数)カーブファイル(オプション、1行に1ピッチ、デフォルトのF0(最低共振周波数)とエレベーションを置き換えます。)",
+    "转换": "変換",
+    "输出信息": "出力情報",
+    "输出音频(右下角三个点,点了可以下载)": "出力音声(右下の三点をクリックしてダウンロードできます)",
+    "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "一括変換、変換する音声フォルダを入力、または複数の音声ファイルをアップロードし、指定したフォルダ(デフォルトのopt)に変換した音声を出力します。",
+    "指定输出文件夹": "出力フォルダを指定してください",
+    "检索特征占比": "検索特徴率",
+    "输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "処理対象音声フォルダーのパスを入力してください(ファイルマネージャのアドレスバーからコピーしてください)",
+    "也可批量输入音频文件, 二选一, 优先读文件夹": "複数の音声ファイルを一括で入力することもできますが、フォルダーを優先して読み込みます",
+    "伴奏人声分离": "伴奏とボーカルの分離",
+    "人声伴奏分离批量处理, 使用UVR5模型. <br>不带和声用HP2, 带和声且提取的人声不需要和声用HP5<br>合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "UVR5モデルを使用した、声帯分離バッチ処理です。<br>HP2はハーモニー、ハーモニーのあるボーカルとハーモニーのないボーカルを抽出したものはHP5を使ってください <br>フォルダーパスの形式例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(エクスプローラーのアドレスバーからコピーするだけです)",
+    "输入待处理音频文件夹路径": "処理するオーディオファイルのフォルダパスを入力してください",
+    "模型": "モデル",
+    "指定输出人声文件夹": "人の声を出力するフォルダを指定してください",
+    "指定输出乐器文件夹": "楽器の出力フォルダを指定してください",
+    "训练": "トレーニング",
+    "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "ステップ1:実験設定を入力します。実験データはlogsに保存され、各実験にはフォルダーがあります。実験名のパスを手動で入力する必要があり、実験設定、ログ、トレーニングされたモデルファイルが含まれます。",
+    "输入实验名": "実験名を入力してください",
+    "目标采样率": "目標サンプリングレート",
+    "模型是否带音高指导(唱歌一定要, 语音可以不要)": "モデルに音高ガイドがあるかどうか(歌唱には必要ですが、音声には必要ありません)",
+    "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "ステップ2a: 訓練フォルダー内のすべての音声ファイルを自動的に探索し、スライスと正規化を行い、2つのwavフォルダーを実験ディレクトリに生成します。現在は一人でのトレーニングのみをサポートしています。",
+    "输入训练文件夹路径": "トレーニング用フォルダのパスを入力してください",
+    "请指定说话人id": "話者IDを指定してください",
+    "处理数据": "データ処理",
+    "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "ステップ2b: CPUを使用して音高を抽出する(モデルに音高がある場合)、GPUを使用して特徴を抽出する(カード番号を選択する)",
+    "以-分隔输入使用的卡号, 例如   0-1-2   使用卡0和卡1和卡2": "ハイフンで区切って使用するカード番号を入力します。例えば0-1-2はカード0、カード1、カード2を使用します",
+    "显卡信息": "カード情報",
+    "提取音高使用的CPU进程数": "抽出に使用するCPUプロセス数",
+    "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "音高抽出アルゴリズムの選択:歌声を入力する場合は、pmを使用して速度を上げることができます。CPUが低い場合はdioを使用して速度を上げることができます。harvestは品質が高く、精度が高いですが、遅いです。",
+    "特征提取": "特徴抽出",
+    "step3: 填写训练设置, 开始训练模型和索引": "ステップ3: トレーニング設定を入力して、モデルとインデックスのトレーニングを開始します",
+    "保存频率save_every_epoch": "エポックごとの保存頻度",
+    "总训练轮数total_epoch": "総トレーニング回数",
+    "是否仅保存最新的ckpt文件以节省硬盘空间": "ハードディスク容量を節約するため、最新のckptファイルのみを保存するかどうか",
+    "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "すべてのトレーニングデータをメモリにキャッシュするかどうか。10分以下の小さなデータはキャッシュしてトレーニングを高速化できますが、大きなデータをキャッシュするとメモリが破裂し、あまり速度が上がりません。",
+    "加载预训练底模G路径": "事前学習済みのGモデルのパスをロードしてください",
+    "加载预训练底模D路径": "事前学習済みのDモデルのパスをロードしてください",
+    "训练模型": "モデルのトレーニング",
+    "训练特征索引": "特徴インデックスのトレーニング",
+    "一键训练": "ワンクリックトレーニング",
+    "ckpt处理": "ckptファイルの処理",
+    "模型融合, 可用于测试音色融合": "モデルのマージ、音源のマージテストに使用できます",
+    "A模型路径": "Aモデルのパス",
+    "B模型路径": "Bモデルのパス",
+    "A模型权重": "Aモデルの重み",
+    "模型是否带音高指导": "モデルに音高ガイドを付けるかどうか",
+    "要置入的模型信息": "挿入するモデル情報",
+    "保存的模型名不带后缀": "拡張子のない保存するモデル名",
+    "融合": "フュージョン",
+    "修改模型信息(仅支持weights文件夹下提取的小模型文件)": "モデル情報の修正(weightsフォルダから抽出された小さなモデルファイルのみ対応)",
+    "模型路径": "モデルパス",
+    "要改的模型信息": "変更するモデル情報",
+    "保存的文件名, 默认空为和源文件同名": "保存するファイル名、デフォルトでは空欄で元のファイル名と同じ名前になります",
+    "修改": "変更",
+    "查看模型信息(仅支持weights文件夹下提取的小模型文件)": "モデル情報を表示する(小さいモデルファイルはweightsフォルダーからのみサポートされています)",
+    "查看": "表示",
+    "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况": "モデル抽出(ログフォルダー内の大きなファイルのモデルパスを入力)、モデルを半分までトレーニングし、自動的に小さいファイルモデルを保存しなかったり、中間モデルをテストしたい場合に適用されます。",
+    "保存名": "保存ファイル名",
+    "模型是否带音高指导,1是0否": "モデルに音高ガイドを付けるかどうか、1は付ける、0は付けない",
+    "提取": "抽出",
+    "Onnx导出": "Onnx",
+    "RVC模型路径": "RVCルパス",
+    "Onnx输出路径": "Onnx出力パス",
+    "MoeVS模型": "MoeSS？",
+    "导出Onnx模型": "Onnxに変換",
+    "招募音高曲线前端编辑器": "音高曲線フロントエンドエディターを募集",
+    "加开发群联系我xxxxx": "開発グループに参加して私に連絡してくださいxxxxx",
+    "点击查看交流、问题反馈群号": "クリックして交流、問題フィードバックグループ番号を表示",
+    "xxxxx": "xxxxx",
+    "加载模型": "モデルをロード",
+    "Hubert模型": "Hubert模型",
+    "选择.pth文件": ".pthファイルを選択",
+    "选择.index文件": ".indexファイルを選択",
+    "选择.npy文件": ".npyファイルを選択",
+    "输入设备": "入力デバイス",
+    "输出设备": "出力デバイス",
+    "音频设备(请使用同种类驱动)": "オーディオデバイス(同じ種類のドライバーを使用してください)",
+    "响应阈值": "反応閾値",
+    "音调设置": "音程設定",
+    "Index Rate": "Index Rate",
+    "常规设置": "一般設定",
+    "采样长度": "サンプル長",
+    "淡入淡出长度": "フェードイン/フェードアウト長",
+    "额外推理时长": "追加推論時間",
+    "输入降噪": "入力ノイズの低減",
+    "输出降噪": "出力ノイズの低減",
+    "性能设置": "パフォーマンス設定",
+    "开始音频转换": "音声変換を開始",
+    "停止音频转换": "音声変換を停止",
+    "推理时间(ms):": "推論時間(ms):"
+}

i18n/locale_diff.py

@@ -0,0 +1,45 @@
+import json
+import os
+from collections import OrderedDict
+
+# Define the standard file name
+standard_file = "zh_CN.json"
+
+# Find all JSON files in the directory
+dir_path = "./"
+languages = [
+    f for f in os.listdir(dir_path) if f.endswith(".json") and f != standard_file
+]
+
+# Load the standard file
+with open(standard_file, "r", encoding="utf-8") as f:
+    standard_data = json.load(f, object_pairs_hook=OrderedDict)
+
+# Loop through each language file
+for lang_file in languages:
+    # Load the language file
+    with open(lang_file, "r", encoding="utf-8") as f:
+        lang_data = json.load(f, object_pairs_hook=OrderedDict)
+
+    # Find the difference between the language file and the standard file
+    diff = set(standard_data.keys()) - set(lang_data.keys())
+
+    miss = set(lang_data.keys()) - set(standard_data.keys())
+
+    # Add any missing keys to the language file
+    for key in diff:
+        lang_data[key] = key
+
+    # Del any extra keys to the language file
+    for key in miss:
+        del lang_data[key]
+
+    # Sort the keys of the language file to match the order of the standard file
+    lang_data = OrderedDict(
+        sorted(lang_data.items(), key=lambda x: list(standard_data.keys()).index(x[0]))
+    )
+
+    # Save the updated language file
+    with open(lang_file, "w", encoding="utf-8") as f:
+        json.dump(lang_data, f, ensure_ascii=False, indent=4)
+        f.write("\n")

i18n/zh_CN.json

@@ -0,0 +1,104 @@
+{
+    "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.": "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.",
+    "模型推理": "模型推理",
+    "推理音色": "推理音色",
+    "刷新音色列表": "刷新音色列表",
+    "卸载音色省显存": "卸载音色省显存",
+    "请选择说话人id": "请选择说话人id",
+    "男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ",
+    "变调(整数, 半音数量, 升八度12降八度-12)": "变调(整数, 半音数量, 升八度12降八度-12)",
+    "输入待处理音频文件路径(默认是正确格式示例)": "输入待处理音频文件路径(默认是正确格式示例)",
+    "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比",
+    "特征检索库文件路径": "特征检索库文件路径",
+    "特征文件路径": "特征文件路径",
+    "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调",
+    "转换": "转换",
+    "输出信息": "输出信息",
+    "输出音频(右下角三个点,点了可以下载)": "输出音频(右下角三个点,点了可以下载)",
+    "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ",
+    "指定输出文件夹": "指定输出文件夹",
+    "检索特征占比": "检索特征占比",
+    "输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)",
+    "也可批量输入音频文件, 二选一, 优先读文件夹": "也可批量输入音频文件, 二选一, 优先读文件夹",
+    "伴奏人声分离": "伴奏人声分离",
+    "人声伴奏分离批量处理, 使用UVR5模型. <br>不带和声用HP2, 带和声且提取的人声不需要和声用HP5<br>合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "人声伴奏分离批量处理, 使用UVR5模型. <br>不带和声用HP2, 带和声且提取的人声不需要和声用HP5<br>合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)",
+    "输入待处理音频文件夹路径": "输入待处理音频文件夹路径",
+    "模型": "模型",
+    "指定输出人声文件夹": "指定输出人声文件夹",
+    "指定输出乐器文件夹": "指定输出乐器文件夹",
+    "训练": "训练",
+    "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ",
+    "输入实验名": "输入实验名",
+    "目标采样率": "目标采样率",
+    "模型是否带音高指导(唱歌一定要, 语音可以不要)": "模型是否带音高指导(唱歌一定要, 语音可以不要)",
+    "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ",
+    "输入训练文件夹路径": "输入训练文件夹路径",
+    "请指定说话人id": "请指定说话人id",
+    "处理数据": "处理数据",
+    "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)",
+    "以-分隔输入使用的卡号, 例如   0-1-2   使用卡0和卡1和卡2": "以-分隔输入使用的卡号, 例如   0-1-2   使用卡0和卡1和卡2",
+    "显卡信息": "显卡信息",
+    "提取音高使用的CPU进程数": "提取音高使用的CPU进程数",
+    "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢",
+    "特征提取": "特征提取",
+    "step3: 填写训练设置, 开始训练模型和索引": "step3: 填写训练设置, 开始训练模型和索引",
+    "保存频率save_every_epoch": "保存频率save_every_epoch",
+    "总训练轮数total_epoch": "总训练轮数total_epoch",
+    "是否仅保存最新的ckpt文件以节省硬盘空间": "是否仅保存最新的ckpt文件以节省硬盘空间",
+    "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速",
+    "加载预训练底模G路径": "加载预训练底模G路径",
+    "加载预训练底模D路径": "加载预训练底模D路径",
+    "训练模型": "训练模型",
+    "训练特征索引": "训练特征索引",
+    "一键训练": "一键训练",
+    "ckpt处理": "ckpt处理",
+    "模型融合, 可用于测试音色融合": "模型融合, 可用于测试音色融合",
+    "A模型路径": "A模型路径",
+    "B模型路径": "B模型路径",
+    "A模型权重": "A模型权重",
+    "模型是否带音高指导": "模型是否带音高指导",
+    "要置入的模型信息": "要置入的模型信息",
+    "保存的模型名不带后缀": "保存的模型名不带后缀",
+    "融合": "融合",
+    "修改模型信息(仅支持weights文件夹下提取的小模型文件)": "修改模型信息(仅支持weights文件夹下提取的小模型文件)",
+    "模型路径": "模型路径",
+    "要改的模型信息": "要改的模型信息",
+    "保存的文件名, 默认空为和源文件同名": "保存的文件名, 默认空为和源文件同名",
+    "修改": "修改",
+    "查看模型信息(仅支持weights文件夹下提取的小模型文件)": "查看模型信息(仅支持weights文件夹下提取的小模型文件)",
+    "查看": "查看",
+    "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况": "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况",
+    "保存名": "保存名",
+    "模型是否带音高指导,1是0否": "模型是否带音高指导,1是0否",
+    "提取": "提取",
+    "Onnx导出": "Onnx导出",
+    "RVC模型路径": "RVC模型路径",
+    "Onnx输出路径": "Onnx输出路径",
+    "MoeVS模型": "MoeVS模型",
+    "导出Onnx模型": "导出Onnx模型",
+    "招募音高曲线前端编辑器": "招募音高曲线前端编辑器",
+    "加开发群联系我xxxxx": "加开发群联系我xxxxx",
+    "点击查看交流、问题反馈群号": "点击查看交流、问题反馈群号",
+    "xxxxx": "xxxxx",
+    "加载模型": "加载模型",
+    "Hubert模型": "Hubert模型",
+    "选择.pth文件": "选择.pth文件",
+    "选择.index文件": "选择.index文件",
+    "选择.npy文件": "选择.npy文件",
+    "输入设备": "输入设备",
+    "输出设备": "输出设备",
+    "音频设备(请使用同种类驱动)": "音频设备(请使用同种类驱动)",
+    "响应阈值": "响应阈值",
+    "音调设置": "音调设置",
+    "Index Rate": "Index Rate",
+    "常规设置": "常规设置",
+    "采样长度": "采样长度",
+    "淡入淡出长度": "淡入淡出长度",
+    "额外推理时长": "额外推理时长",
+    "输入降噪": "输入降噪",
+    "输出降噪": "输出降噪",
+    "性能设置": "性能设置",
+    "开始音频转换": "开始音频转换",
+    "停止音频转换": "停止音频转换",
+    "推理时间(ms):": "推理时间(ms):"
+}

i18n/zh_HK.json

@@ -0,0 +1,104 @@
+{
+    "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.": "本軟體以MIT協議開源，作者不對軟體具備任何控制力，使用軟體者、傳播軟體導出的聲音者自負全責。<br>如不認可該條款，則不能使用或引用軟體包內任何程式碼和檔案。詳見根目錄<b>使用需遵守的協議-LICENSE.txt</b>。",
+    "模型推理": "模型推理",
+    "推理音色": "推理音色",
+    "刷新音色列表": "重新整理音色列表",
+    "卸载音色省显存": "卸載音色節省 VRAM",
+    "请选择说话人id": "請選擇說話人ID",
+    "男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "男性轉女性推薦+12key，女性轉男性推薦-12key，如果音域爆炸導致音色失真也可以自己調整到合適音域。",
+    "变调(整数, 半音数量, 升八度12降八度-12)": "變調(整數、半音數量、升八度12降八度-12)",
+    "输入待处理音频文件路径(默认是正确格式示例)": "輸入待處理音頻檔案路徑（預設是正確格式示例）",
+    "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "選擇音高提取演算法，輸入歌聲可用 pm 提速，harvest 低音好但巨慢無比",
+    "特征检索库文件路径": "特徵檢索庫檔案路徑",
+    "特征文件路径": "特徵檔案路徑",
+    "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0曲線檔案，可選，一行一個音高，代替預設的F0及升降調",
+    "转换": "轉換",
+    "输出信息": "輸出訊息",
+    "输出音频(右下角三个点,点了可以下载)": "輸出音頻(右下角三個點，點了可以下載)",
+    "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "批量轉換，輸入待轉換音頻資料夾，或上傳多個音頻檔案，在指定資料夾(默認opt)下輸出轉換的音頻。",
+    "指定输出文件夹": "指定輸出資料夾",
+    "检索特征占比": "檢索特徵佔比",
+    "输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "輸入待處理音頻資料夾路徑(去檔案管理器地址欄拷貝即可)",
+    "也可批量输入音频文件, 二选一, 优先读文件夹": "也可批量輸入音頻檔案，二選一，優先讀資料夾",
+    "伴奏人声分离": "伴奏人聲分離",
+    "人声伴奏分离批量处理, 使用UVR5模型. <br>不带和声用HP2, 带和声且提取的人声不需要和声用HP5<br>合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "人聲伴奏分離批量處理，使用UVR5模型。<br>不帶和聲用HP2，帶和聲且提取的人聲不需要和聲用HP5<br>合格的資料夾路徑格式舉例：E:\\codes\\py39\\vits_vc_gpu\\白鷺霜華測試樣例（去檔案管理員地址欄複製就行了）",
+    "输入待处理音频文件夹路径": "輸入待處理音頻資料夾路徑",
+    "模型": "模型",
+    "指定输出人声文件夹": "指定輸出人聲資料夾",
+    "指定输出乐器文件夹": "指定輸出樂器資料夾",
+    "训练": "訓練",
+    "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "step1：填寫實驗配置。實驗數據放在logs下，每個實驗一個資料夾，需手動輸入實驗名路徑，內含實驗配置、日誌、訓練得到的模型檔案。",
+    "输入实验名": "輸入實驗名稱",
+    "目标采样率": "目標取樣率",
+    "模型是否带音高指导(唱歌一定要, 语音可以不要)": "模型是否帶音高指導（唱歌一定要，語音可以不要）",
+    "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "step2a：自動遍歷訓練資料夾下所有可解碼成音頻的檔案並進行切片歸一化，在實驗目錄下生成2個wav資料夾；暫時只支援單人訓練。",
+    "输入训练文件夹路径": "輸入訓練檔案夾路徑",
+    "请指定说话人id": "請指定說話人id",
+    "处理数据": "處理資料",
+    "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "步驟2b: 使用CPU提取音高(如果模型帶音高), 使用GPU提取特徵(選擇卡號)",
+    "以-分隔输入使用的卡号, 例如   0-1-2   使用卡0和卡1和卡2": "以-分隔輸入使用的卡號, 例如 0-1-2 使用卡0和卡1和卡2",
+    "显卡信息": "顯示卡資訊",
+    "提取音高使用的CPU进程数": "提取音高使用的CPU進程數",
+    "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "選擇音高提取算法:輸入歌聲可用pm提速,高品質語音但CPU差可用dio提速,harvest品質更好但較慢",
+    "特征提取": "特徵提取",
+    "step3: 填写训练设置, 开始训练模型和索引": "步驟3: 填寫訓練設定, 開始訓練模型和索引",
+    "保存频率save_every_epoch": "保存頻率save_every_epoch",
+    "总训练轮数total_epoch": "總訓練輪數total_epoch",
+    "是否仅保存最新的ckpt文件以节省硬盘空间": "是否僅保存最新的ckpt檔案以節省硬碟空間",
+    "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "是否緩存所有訓練集至 VRAM。小於10分鐘的小數據可緩存以加速訓練，大數據緩存會爆 VRAM 也加不了多少速度",
+    "加载预训练底模G路径": "加載預訓練底模G路徑",
+    "加载预训练底模D路径": "加載預訓練底模D路徑",
+    "训练模型": "訓練模型",
+    "训练特征索引": "訓練特徵索引",
+    "一键训练": "一鍵訓練",
+    "ckpt处理": "ckpt處理",
+    "模型融合, 可用于测试音色融合": "模型融合，可用於測試音色融合",
+    "A模型路径": "A模型路徑",
+    "B模型路径": "B模型路徑",
+    "A模型权重": "A模型權重",
+    "模型是否带音高指导": "模型是否帶音高指導",
+    "要置入的模型信息": "要置入的模型資訊",
+    "保存的模型名不带后缀": "儲存的模型名不帶副檔名",
+    "融合": "融合",
+    "修改模型信息(仅支持weights文件夹下提取的小模型文件)": "修改模型資訊(僅支援weights資料夾下提取的小模型檔案)",
+    "模型路径": "模型路徑",
+    "要改的模型信息": "要改的模型資訊",
+    "保存的文件名, 默认空为和源文件同名": "儲存的檔案名，預設空為與來源檔案同名",
+    "修改": "修改",
+    "查看模型信息(仅支持weights文件夹下提取的小模型文件)": "查看模型資訊(僅支援weights資料夾下提取的小模型檔案)",
+    "查看": "查看",
+    "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况": "模型提取(輸入logs資料夾下大檔案模型路徑)，適用於訓一半不想訓了模型沒有自動提取儲存小檔案模型，或者想測試中間模型的情況",
+    "保存名": "儲存名",
+    "模型是否带音高指导,1是0否": "模型是否帶音高指導，1是0否",
+    "提取": "提取",
+    "Onnx导出": "Onnx导出",
+    "RVC模型路径": "RVC模型路径",
+    "Onnx输出路径": "Onnx输出路径",
+    "MoeVS模型": "MoeSS模型",
+    "导出Onnx模型": "导出Onnx模型",
+    "招募音高曲线前端编辑器": "招募音高曲線前端編輯器",
+    "加开发群联系我xxxxx": "加開發群聯繫我xxxxx",
+    "点击查看交流、问题反馈群号": "點擊查看交流、問題反饋群號",
+    "xxxxx": "xxxxx",
+    "加载模型": "載入模型",
+    "Hubert模型": "Hubert 模型",
+    "选择.pth文件": "選擇 .pth 檔案",
+    "选择.index文件": "選擇 .index 檔案",
+    "选择.npy文件": "選擇 .npy 檔案",
+    "输入设备": "輸入設備",
+    "输出设备": "輸出設備",
+    "音频设备(请使用同种类驱动)": "音訊設備 (請使用同種類驅動)",
+    "响应阈值": "響應閾值",
+    "音调设置": "音調設定",
+    "Index Rate": "Index Rate",
+    "常规设置": "一般設定",
+    "采样长度": "取樣長度",
+    "淡入淡出长度": "淡入淡出長度",
+    "额外推理时长": "額外推理時長",
+    "输入降噪": "輸入降噪",
+    "输出降噪": "輸出降噪",
+    "性能设置": "效能設定",
+    "开始音频转换": "開始音訊轉換",
+    "停止音频转换": "停止音訊轉換",
+    "推理时间(ms):": "推理時間(ms):"
+}

i18n/zh_SG.json

@@ -0,0 +1,104 @@
+{
+    "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.": "本軟體以MIT協議開源，作者不對軟體具備任何控制力，使用軟體者、傳播軟體導出的聲音者自負全責。<br>如不認可該條款，則不能使用或引用軟體包內任何程式碼和檔案。詳見根目錄<b>使用需遵守的協議-LICENSE.txt</b>。",
+    "模型推理": "模型推理",
+    "推理音色": "推理音色",
+    "刷新音色列表": "重新整理音色列表",
+    "卸载音色省显存": "卸載音色節省 VRAM",
+    "请选择说话人id": "請選擇說話人ID",
+    "男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "男性轉女性推薦+12key，女性轉男性推薦-12key，如果音域爆炸導致音色失真也可以自己調整到合適音域。",
+    "变调(整数, 半音数量, 升八度12降八度-12)": "變調(整數、半音數量、升八度12降八度-12)",
+    "输入待处理音频文件路径(默认是正确格式示例)": "輸入待處理音頻檔案路徑（預設是正確格式示例）",
+    "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "選擇音高提取演算法，輸入歌聲可用 pm 提速，harvest 低音好但巨慢無比",
+    "特征检索库文件路径": "特徵檢索庫檔案路徑",
+    "特征文件路径": "特徵檔案路徑",
+    "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0曲線檔案，可選，一行一個音高，代替預設的F0及升降調",
+    "转换": "轉換",
+    "输出信息": "輸出訊息",
+    "输出音频(右下角三个点,点了可以下载)": "輸出音頻(右下角三個點，點了可以下載)",
+    "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "批量轉換，輸入待轉換音頻資料夾，或上傳多個音頻檔案，在指定資料夾(默認opt)下輸出轉換的音頻。",
+    "指定输出文件夹": "指定輸出資料夾",
+    "检索特征占比": "檢索特徵佔比",
+    "输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "輸入待處理音頻資料夾路徑(去檔案管理器地址欄拷貝即可)",
+    "也可批量输入音频文件, 二选一, 优先读文件夹": "也可批量輸入音頻檔案，二選一，優先讀資料夾",
+    "伴奏人声分离": "伴奏人聲分離",
+    "人声伴奏分离批量处理, 使用UVR5模型. <br>不带和声用HP2, 带和声且提取的人声不需要和声用HP5<br>合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "人聲伴奏分離批量處理，使用UVR5模型。<br>不帶和聲用HP2，帶和聲且提取的人聲不需要和聲用HP5<br>合格的資料夾路徑格式舉例：E:\\codes\\py39\\vits_vc_gpu\\白鷺霜華測試樣例（去檔案管理員地址欄複製就行了）",
+    "输入待处理音频文件夹路径": "輸入待處理音頻資料夾路徑",
+    "模型": "模型",
+    "指定输出人声文件夹": "指定輸出人聲資料夾",
+    "指定输出乐器文件夹": "指定輸出樂器資料夾",
+    "训练": "訓練",
+    "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "step1：填寫實驗配置。實驗數據放在logs下，每個實驗一個資料夾，需手動輸入實驗名路徑，內含實驗配置、日誌、訓練得到的模型檔案。",
+    "输入实验名": "輸入實驗名稱",
+    "目标采样率": "目標取樣率",
+    "模型是否带音高指导(唱歌一定要, 语音可以不要)": "模型是否帶音高指導（唱歌一定要，語音可以不要）",
+    "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "step2a：自動遍歷訓練資料夾下所有可解碼成音頻的檔案並進行切片歸一化，在實驗目錄下生成2個wav資料夾；暫時只支援單人訓練。",
+    "输入训练文件夹路径": "輸入訓練檔案夾路徑",
+    "请指定说话人id": "請指定說話人id",
+    "处理数据": "處理資料",
+    "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "步驟2b: 使用CPU提取音高(如果模型帶音高), 使用GPU提取特徵(選擇卡號)",
+    "以-分隔输入使用的卡号, 例如   0-1-2   使用卡0和卡1和卡2": "以-分隔輸入使用的卡號, 例如 0-1-2 使用卡0和卡1和卡2",
+    "显卡信息": "顯示卡資訊",
+    "提取音高使用的CPU进程数": "提取音高使用的CPU進程數",
+    "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "選擇音高提取算法:輸入歌聲可用pm提速,高品質語音但CPU差可用dio提速,harvest品質更好但較慢",
+    "特征提取": "特徵提取",
+    "step3: 填写训练设置, 开始训练模型和索引": "步驟3: 填寫訓練設定, 開始訓練模型和索引",
+    "保存频率save_every_epoch": "保存頻率save_every_epoch",
+    "总训练轮数total_epoch": "總訓練輪數total_epoch",
+    "是否仅保存最新的ckpt文件以节省硬盘空间": "是否僅保存最新的ckpt檔案以節省硬碟空間",
+    "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "是否緩存所有訓練集至 VRAM。小於10分鐘的小數據可緩存以加速訓練，大數據緩存會爆 VRAM 也加不了多少速度",
+    "加载预训练底模G路径": "加載預訓練底模G路徑",
+    "加载预训练底模D路径": "加載預訓練底模D路徑",
+    "训练模型": "訓練模型",
+    "训练特征索引": "訓練特徵索引",
+    "一键训练": "一鍵訓練",
+    "ckpt处理": "ckpt處理",
+    "模型融合, 可用于测试音色融合": "模型融合，可用於測試音色融合",
+    "A模型路径": "A模型路徑",
+    "B模型路径": "B模型路徑",
+    "A模型权重": "A模型權重",
+    "模型是否带音高指导": "模型是否帶音高指導",
+    "要置入的模型信息": "要置入的模型資訊",
+    "保存的模型名不带后缀": "儲存的模型名不帶副檔名",
+    "融合": "融合",
+    "修改模型信息(仅支持weights文件夹下提取的小模型文件)": "修改模型資訊(僅支援weights資料夾下提取的小模型檔案)",
+    "模型路径": "模型路徑",
+    "要改的模型信息": "要改的模型資訊",
+    "保存的文件名, 默认空为和源文件同名": "儲存的檔案名，預設空為與來源檔案同名",
+    "修改": "修改",
+    "查看模型信息(仅支持weights文件夹下提取的小模型文件)": "查看模型資訊(僅支援weights資料夾下提取的小模型檔案)",
+    "查看": "查看",
+    "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况": "模型提取(輸入logs資料夾下大檔案模型路徑)，適用於訓一半不想訓了模型沒有自動提取儲存小檔案模型，或者想測試中間模型的情況",
+    "保存名": "儲存名",
+    "模型是否带音高指导,1是0否": "模型是否帶音高指導，1是0否",
+    "提取": "提取",
+    "Onnx导出": "Onnx导出",
+    "RVC模型路径": "RVC模型路径",
+    "Onnx输出路径": "Onnx输出路径",
+    "MoeVS模型": "MoeSS模型",
+    "导出Onnx模型": "导出Onnx模型",
+    "招募音高曲线前端编辑器": "招募音高曲線前端編輯器",
+    "加开发群联系我xxxxx": "加開發群聯繫我xxxxx",
+    "点击查看交流、问题反馈群号": "點擊查看交流、問題反饋群號",
+    "xxxxx": "xxxxx",
+    "加载模型": "載入模型",
+    "Hubert模型": "Hubert 模型",
+    "选择.pth文件": "選擇 .pth 檔案",
+    "选择.index文件": "選擇 .index 檔案",
+    "选择.npy文件": "選擇 .npy 檔案",
+    "输入设备": "輸入設備",
+    "输出设备": "輸出設備",
+    "音频设备(请使用同种类驱动)": "音訊設備 (請使用同種類驅動)",
+    "响应阈值": "響應閾值",
+    "音调设置": "音調設定",
+    "Index Rate": "Index Rate",
+    "常规设置": "一般設定",
+    "采样长度": "取樣長度",
+    "淡入淡出长度": "淡入淡出長度",
+    "额外推理时长": "額外推理時長",
+    "输入降噪": "輸入降噪",
+    "输出降噪": "輸出降噪",
+    "性能设置": "效能設定",
+    "开始音频转换": "開始音訊轉換",
+    "停止音频转换": "停止音訊轉換",
+    "推理时间(ms):": "推理時間(ms):"
+}

i18n/zh_TW.json

@@ -0,0 +1,104 @@
+{
+    "本软件以MIT协议开源, 作者不对软件具备任何控制力, 使用软件者、传播软件导出的声音者自负全责. <br>如不认可该条款, 则不能使用或引用软件包内任何代码和文件. 详见根目录<b>使用需遵守的协议-LICENSE.txt</b>.": "本軟體以MIT協議開源，作者不對軟體具備任何控制力，使用軟體者、傳播軟體導出的聲音者自負全責。<br>如不認可該條款，則不能使用或引用軟體包內任何程式碼和檔案。詳見根目錄<b>使用需遵守的協議-LICENSE.txt</b>。",
+    "模型推理": "模型推理",
+    "推理音色": "推理音色",
+    "刷新音色列表": "重新整理音色列表",
+    "卸载音色省显存": "卸載音色節省 VRAM",
+    "请选择说话人id": "請選擇說話人ID",
+    "男转女推荐+12key, 女转男推荐-12key, 如果音域爆炸导致音色失真也可以自己调整到合适音域. ": "男性轉女性推薦+12key，女性轉男性推薦-12key，如果音域爆炸導致音色失真也可以自己調整到合適音域。",
+    "变调(整数, 半音数量, 升八度12降八度-12)": "變調(整數、半音數量、升八度12降八度-12)",
+    "输入待处理音频文件路径(默认是正确格式示例)": "輸入待處理音頻檔案路徑（預設是正確格式示例）",
+    "选择音高提取算法,输入歌声可用pm提速,harvest低音好但巨慢无比": "選擇音高提取演算法，輸入歌聲可用 pm 提速，harvest 低音好但巨慢無比",
+    "特征检索库文件路径": "特徵檢索庫檔案路徑",
+    "特征文件路径": "特徵檔案路徑",
+    "F0曲线文件, 可选, 一行一个音高, 代替默认F0及升降调": "F0曲線檔案，可選，一行一個音高，代替預設的F0及升降調",
+    "转换": "轉換",
+    "输出信息": "輸出訊息",
+    "输出音频(右下角三个点,点了可以下载)": "輸出音頻(右下角三個點，點了可以下載)",
+    "批量转换, 输入待转换音频文件夹, 或上传多个音频文件, 在指定文件夹(默认opt)下输出转换的音频. ": "批量轉換，輸入待轉換音頻資料夾，或上傳多個音頻檔案，在指定資料夾(默認opt)下輸出轉換的音頻。",
+    "指定输出文件夹": "指定輸出資料夾",
+    "检索特征占比": "檢索特徵佔比",
+    "输入待处理音频文件夹路径(去文件管理器地址栏拷就行了)": "輸入待處理音頻資料夾路徑(去檔案管理器地址欄拷貝即可)",
+    "也可批量输入音频文件, 二选一, 优先读文件夹": "也可批量輸入音頻檔案，二選一，優先讀資料夾",
+    "伴奏人声分离": "伴奏人聲分離",
+    "人声伴奏分离批量处理, 使用UVR5模型. <br>不带和声用HP2, 带和声且提取的人声不需要和声用HP5<br>合格的文件夹路径格式举例: E:\\codes\\py39\\vits_vc_gpu\\白鹭霜华测试样例(去文件管理器地址栏拷就行了)": "人聲伴奏分離批量處理，使用UVR5模型。<br>不帶和聲用HP2，帶和聲且提取的人聲不需要和聲用HP5<br>合格的資料夾路徑格式舉例：E:\\codes\\py39\\vits_vc_gpu\\白鷺霜華測試樣例（去檔案管理員地址欄複製就行了）",
+    "输入待处理音频文件夹路径": "輸入待處理音頻資料夾路徑",
+    "模型": "模型",
+    "指定输出人声文件夹": "指定輸出人聲資料夾",
+    "指定输出乐器文件夹": "指定輸出樂器資料夾",
+    "训练": "訓練",
+    "step1: 填写实验配置. 实验数据放在logs下, 每个实验一个文件夹, 需手工输入实验名路径, 内含实验配置, 日志, 训练得到的模型文件. ": "step1：填寫實驗配置。實驗數據放在logs下，每個實驗一個資料夾，需手動輸入實驗名路徑，內含實驗配置、日誌、訓練得到的模型檔案。",
+    "输入实验名": "輸入實驗名稱",
+    "目标采样率": "目標取樣率",
+    "模型是否带音高指导(唱歌一定要, 语音可以不要)": "模型是否帶音高指導（唱歌一定要，語音可以不要）",
+    "step2a: 自动遍历训练文件夹下所有可解码成音频的文件并进行切片归一化, 在实验目录下生成2个wav文件夹; 暂时只支持单人训练. ": "step2a：自動遍歷訓練資料夾下所有可解碼成音頻的檔案並進行切片歸一化，在實驗目錄下生成2個wav資料夾；暫時只支援單人訓練。",
+    "输入训练文件夹路径": "輸入訓練檔案夾路徑",
+    "请指定说话人id": "請指定說話人id",
+    "处理数据": "處理資料",
+    "step2b: 使用CPU提取音高(如果模型带音高), 使用GPU提取特征(选择卡号)": "步驟2b: 使用CPU提取音高(如果模型帶音高), 使用GPU提取特徵(選擇卡號)",
+    "以-分隔输入使用的卡号, 例如   0-1-2   使用卡0和卡1和卡2": "以-分隔輸入使用的卡號, 例如 0-1-2 使用卡0和卡1和卡2",
+    "显卡信息": "顯示卡資訊",
+    "提取音高使用的CPU进程数": "提取音高使用的CPU進程數",
+    "选择音高提取算法:输入歌声可用pm提速,高质量语音但CPU差可用dio提速,harvest质量更好但慢": "選擇音高提取算法:輸入歌聲可用pm提速,高品質語音但CPU差可用dio提速,harvest品質更好但較慢",
+    "特征提取": "特徵提取",
+    "step3: 填写训练设置, 开始训练模型和索引": "步驟3: 填寫訓練設定, 開始訓練模型和索引",
+    "保存频率save_every_epoch": "保存頻率save_every_epoch",
+    "总训练轮数total_epoch": "總訓練輪數total_epoch",
+    "是否仅保存最新的ckpt文件以节省硬盘空间": "是否僅保存最新的ckpt檔案以節省硬碟空間",
+    "是否缓存所有训练集至显存. 10min以下小数据可缓存以加速训练, 大数据缓存会炸显存也加不了多少速": "是否緩存所有訓練集至 VRAM。小於10分鐘的小數據可緩存以加速訓練，大數據緩存會爆 VRAM 也加不了多少速度",
+    "加载预训练底模G路径": "加載預訓練底模G路徑",
+    "加载预训练底模D路径": "加載預訓練底模D路徑",
+    "训练模型": "訓練模型",
+    "训练特征索引": "訓練特徵索引",
+    "一键训练": "一鍵訓練",
+    "ckpt处理": "ckpt處理",
+    "模型融合, 可用于测试音色融合": "模型融合，可用於測試音色融合",
+    "A模型路径": "A模型路徑",
+    "B模型路径": "B模型路徑",
+    "A模型权重": "A模型權重",
+    "模型是否带音高指导": "模型是否帶音高指導",
+    "要置入的模型信息": "要置入的模型資訊",
+    "保存的模型名不带后缀": "儲存的模型名不帶副檔名",
+    "融合": "融合",
+    "修改模型信息(仅支持weights文件夹下提取的小模型文件)": "修改模型資訊(僅支援weights資料夾下提取的小模型檔案)",
+    "模型路径": "模型路徑",
+    "要改的模型信息": "要改的模型資訊",
+    "保存的文件名, 默认空为和源文件同名": "儲存的檔案名，預設空為與來源檔案同名",
+    "修改": "修改",
+    "查看模型信息(仅支持weights文件夹下提取的小模型文件)": "查看模型資訊(僅支援weights資料夾下提取的小模型檔案)",
+    "查看": "查看",
+    "模型提取(输入logs文件夹下大文件模型路径),适用于训一半不想训了模型没有自动提取保存小文件模型,或者想测试中间模型的情况": "模型提取(輸入logs資料夾下大檔案模型路徑)，適用於訓一半不想訓了模型沒有自動提取儲存小檔案模型，或者想測試中間模型的情況",
+    "保存名": "儲存名",
+    "模型是否带音高指导,1是0否": "模型是否帶音高指導，1是0否",
+    "提取": "提取",
+    "Onnx导出": "Onnx导出",
+    "RVC模型路径": "RVC模型路径",
+    "Onnx输出路径": "Onnx输出路径",
+    "MoeVS模型": "MoeSS模型",
+    "导出Onnx模型": "导出Onnx模型",
+    "招募音高曲线前端编辑器": "招募音高曲線前端編輯器",
+    "加开发群联系我xxxxx": "加開發群聯繫我xxxxx",
+    "点击查看交流、问题反馈群号": "點擊查看交流、問題反饋群號",
+    "xxxxx": "xxxxx",
+    "加载模型": "載入模型",
+    "Hubert模型": "Hubert 模型",
+    "选择.pth文件": "選擇 .pth 檔案",
+    "选择.index文件": "選擇 .index 檔案",
+    "选择.npy文件": "選擇 .npy 檔案",
+    "输入设备": "輸入設備",
+    "输出设备": "輸出設備",
+    "音频设备(请使用同种类驱动)": "音訊設備 (請使用同種類驅動)",
+    "响应阈值": "響應閾值",
+    "音调设置": "音調設定",
+    "Index Rate": "Index Rate",
+    "常规设置": "一般設定",
+    "采样长度": "取樣長度",
+    "淡入淡出长度": "淡入淡出長度",
+    "额外推理时长": "額外推理時長",
+    "输入降噪": "輸入降噪",
+    "输出降噪": "輸出降噪",
+    "性能设置": "效能設定",
+    "开始音频转换": "開始音訊轉換",
+    "停止音频转换": "停止音訊轉換",
+    "推理时间(ms):": "推理時間(ms):"
+}

infer/infer-pm-index256.py

@@ -1,14 +1,19 @@
-'''
+"""
 
 对源特征进行检索
-'''
-import torch, pdb, os,parselmouth
-os.environ["CUDA_VISIBLE_DEVICES"]="0"
+"""
+import torch, pdb, os, parselmouth
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
 import numpy as np
 import soundfile as sf
+
 # from models import SynthesizerTrn256#hifigan_nonsf
 # from infer_pack.models import SynthesizerTrn256NSF as SynthesizerTrn256#hifigan_nsf
-from infer_pack.models import SynthesizerTrnMs256NSFsid as SynthesizerTrn256#hifigan_nsf
+from infer_pack.models import (
+    SynthesizerTrnMs256NSFsid as SynthesizerTrn256,
+)  # hifigan_nsf
+
 # from infer_pack.models import SynthesizerTrnMs256NSFsid_sim as SynthesizerTrn256#hifigan_nsf
 # from models import SynthesizerTrn256NSFsim as SynthesizerTrn256#hifigan_nsf
 # from models import SynthesizerTrn256NSFsimFlow as SynthesizerTrn256#hifigan_nsf
@@ -16,15 +21,17 @@ from infer_pack.models import SynthesizerTrnMs256NSFsid as SynthesizerTrn256#hif
 
 from scipy.io import wavfile
 from fairseq import checkpoint_utils
+
 # import pyworld
 import librosa
 import torch.nn.functional as F
 import scipy.signal as signal
+
 # import torchcrepe
 from time import time as ttime
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model_path = r"E:\codes\py39\vits_vc_gpu_train\hubert_base.pt"#
+model_path = r"E:\codes\py39\vits_vc_gpu_train\hubert_base.pt"  #
 print("load model(s) from {}".format(model_path))
 models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
     [model_path],
@@ -37,7 +44,26 @@ model.eval()
 
 # net_g = SynthesizerTrn256(1025,32,192,192,768,2,6,3,0.1,"1", [3,7,11],[[1,3,5], [1,3,5], [1,3,5]],[10,10,2,2],512,[16,16,4,4],183,256,is_half=True)#hifigan#512#256
 # net_g = SynthesizerTrn256(1025,32,192,192,768,2,6,3,0.1,"1", [3,7,11],[[1,3,5], [1,3,5], [1,3,5]],[10,10,2,2],512,[16,16,4,4],109,256,is_half=True)#hifigan#512#256
-net_g = SynthesizerTrn256(1025,32,192,192,768,2,6,3,0,"1", [3,7,11],[[1,3,5], [1,3,5], [1,3,5]],[10,10,2,2],512,[16,16,4,4],183,256,is_half=True)#hifigan#512#256#no_dropout
+net_g = SynthesizerTrn256(
+    1025,
+    32,
+    192,
+    192,
+    768,
+    2,
+    6,
+    3,
+    0,
+    "1",
+    [3, 7, 11],
+    [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+    [10, 10, 2, 2],
+    512,
+    [16, 16, 4, 4],
+    183,
+    256,
+    is_half=True,
+)  # hifigan#512#256#no_dropout
 # net_g = SynthesizerTrn256(1025,32,192,192,768,2,3,3,0.1,"1", [3,7,11],[[1,3,5], [1,3,5], [1,3,5]],[10,10,2,2],512,[16,16,4,4],0)#ts3
 # net_g = SynthesizerTrn256(1025,32,192,192,768,2,6,3,0.1,"1", [3,7,11],[[1,3,5], [1,3,5], [1,3,5]],[10,10,2],512,[16,16,4],0)#hifigan-ps-sr
 #
@@ -48,51 +74,66 @@ net_g = SynthesizerTrn256(1025,32,192,192,768,2,6,3,0,"1", [3,7,11],[[1,3,5], [1
 # weights=torch.load("infer/ft-mi-freeze-vocoder-flow-enc_q_1k.pt")
 # weights=torch.load("infer/ft-mi-freeze-vocoder_true_1k.pt")
 # weights=torch.load("infer/ft-mi-sim1k.pt")
-weights=torch.load("infer/ft-mi-no_opt-no_dropout.pt")
-print(net_g.load_state_dict(weights,strict=True))
+weights = torch.load("infer/ft-mi-no_opt-no_dropout.pt")
+print(net_g.load_state_dict(weights, strict=True))
 
 net_g.eval().to(device)
 net_g.half()
-def get_f0(x, p_len,f0_up_key=0):
 
+
+def get_f0(x, p_len, f0_up_key=0):
     time_step = 160 / 16000 * 1000
     f0_min = 50
     f0_max = 1100
     f0_mel_min = 1127 * np.log(1 + f0_min / 700)
     f0_mel_max = 1127 * np.log(1 + f0_max / 700)
 
-    f0 = parselmouth.Sound(x, 16000).to_pitch_ac(
-        time_step=time_step / 1000, voicing_threshold=0.6,
-        pitch_floor=f0_min, pitch_ceiling=f0_max).selected_array['frequency']
+    f0 = (
+        parselmouth.Sound(x, 16000)
+        .to_pitch_ac(
+            time_step=time_step / 1000,
+            voicing_threshold=0.6,
+            pitch_floor=f0_min,
+            pitch_ceiling=f0_max,
+        )
+        .selected_array["frequency"]
+    )
 
-    pad_size=(p_len - len(f0) + 1) // 2
-    if(pad_size>0 or p_len - len(f0) - pad_size>0):
-        f0 = np.pad(f0,[[pad_size,p_len - len(f0) - pad_size]], mode='constant')
+    pad_size = (p_len - len(f0) + 1) // 2
+    if pad_size > 0 or p_len - len(f0) - pad_size > 0:
+        f0 = np.pad(f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant")
     f0 *= pow(2, f0_up_key / 12)
     f0bak = f0.copy()
 
     f0_mel = 1127 * np.log(1 + f0 / 700)
-    f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (f0_mel_max - f0_mel_min) + 1
+    f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
+        f0_mel_max - f0_mel_min
+    ) + 1
     f0_mel[f0_mel <= 1] = 1
     f0_mel[f0_mel > 255] = 255
     # f0_mel[f0_mel > 188] = 188
     f0_coarse = np.rint(f0_mel).astype(np.int)
     return f0_coarse, f0bak
 
+
 import faiss
-index=faiss.read_index("infer/added_IVF512_Flat_mi_baseline_src_feat.index")
-big_npy=np.load("infer/big_src_feature_mi.npy")
-ta0=ta1=ta2=0
-for idx,name in enumerate(["冬之花clip1.wav",]):##
-    wav_path = "todo-songs/%s" % name#
-    f0_up_key=-2#
+
+index = faiss.read_index("infer/added_IVF512_Flat_mi_baseline_src_feat.index")
+big_npy = np.load("infer/big_src_feature_mi.npy")
+ta0 = ta1 = ta2 = 0
+for idx, name in enumerate(
+    [
+        "冬之花clip1.wav",
+    ]
+):  ##
+    wav_path = "todo-songs/%s" % name  #
+    f0_up_key = -2  #
     audio, sampling_rate = sf.read(wav_path)
     if len(audio.shape) > 1:
         audio = librosa.to_mono(audio.transpose(1, 0))
     if sampling_rate != 16000:
         audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
 
-
     feats = torch.from_numpy(audio).float()
     if feats.dim() == 2:  # double channels
         feats = feats.mean(-1)
@@ -104,8 +145,9 @@ for idx,name in enumerate(["冬之花clip1.wav",]):##
         "padding_mask": padding_mask.to(device),
         "output_layer": 9,  # layer 9
     }
-    torch.cuda.synchronize()
-    t0=ttime()
+    if torch.cuda.is_available():
+        torch.cuda.synchronize()
+    t0 = ttime()
     with torch.no_grad():
         logits = model.extract_features(**inputs)
         feats = model.final_proj(logits[0])
@@ -113,35 +155,45 @@ for idx,name in enumerate(["冬之花clip1.wav",]):##
     ####索引优化
     npy = feats[0].cpu().numpy().astype("float32")
     D, I = index.search(npy, 1)
-    feats = torch.from_numpy(big_npy[I.squeeze()].astype("float16")).unsqueeze(0).to(device)
+    feats = (
+        torch.from_numpy(big_npy[I.squeeze()].astype("float16")).unsqueeze(0).to(device)
+    )
 
-    feats=F.interpolate(feats.permute(0,2,1),scale_factor=2).permute(0,2,1)
-    torch.cuda.synchronize()
-    t1=ttime()
+    feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
+    if torch.cuda.is_available():
+        torch.cuda.synchronize()
+    t1 = ttime()
     # p_len = min(feats.shape[1],10000,pitch.shape[0])#太大了爆显存
-    p_len = min(feats.shape[1],10000)#
-    pitch, pitchf = get_f0(audio, p_len,f0_up_key)
-    p_len = min(feats.shape[1],10000,pitch.shape[0])#太大了爆显存
-    torch.cuda.synchronize()
-    t2=ttime()
-    feats = feats[:,:p_len, :]
+    p_len = min(feats.shape[1], 10000)  #
+    pitch, pitchf = get_f0(audio, p_len, f0_up_key)
+    p_len = min(feats.shape[1], 10000, pitch.shape[0])  # 太大了爆显存
+    if torch.cuda.is_available():
+        torch.cuda.synchronize()
+    t2 = ttime()
+    feats = feats[:, :p_len, :]
     pitch = pitch[:p_len]
     pitchf = pitchf[:p_len]
     p_len = torch.LongTensor([p_len]).to(device)
     pitch = torch.LongTensor(pitch).unsqueeze(0).to(device)
-    sid=torch.LongTensor([0]).to(device)
+    sid = torch.LongTensor([0]).to(device)
     pitchf = torch.FloatTensor(pitchf).unsqueeze(0).to(device)
     with torch.no_grad():
-        audio = net_g.infer(feats, p_len,pitch,pitchf,sid)[0][0, 0].data.cpu().float().numpy()#nsf
-    torch.cuda.synchronize()
-    t3=ttime()
-    ta0+=(t1-t0)
-    ta1+=(t2-t1)
-    ta2+=(t3-t2)
+        audio = (
+            net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0]
+            .data.cpu()
+            .float()
+            .numpy()
+        )  # nsf
+    if torch.cuda.is_available():
+        torch.cuda.synchronize()
+    t3 = ttime()
+    ta0 += t1 - t0
+    ta1 += t2 - t1
+    ta2 += t3 - t2
     # wavfile.write("ft-mi_1k-index256-noD-%s.wav"%name, 40000, audio)##
     # wavfile.write("ft-mi-freeze-vocoder-flow-enc_q_1k-%s.wav"%name, 40000, audio)##
     # wavfile.write("ft-mi-sim1k-%s.wav"%name, 40000, audio)##
-    wavfile.write("ft-mi-no_opt-no_dropout-%s.wav"%name, 40000, audio)##
+    wavfile.write("ft-mi-no_opt-no_dropout-%s.wav" % name, 40000, audio)  ##
 
 
-print(ta0,ta1,ta2)#
+print(ta0, ta1, ta2)  #

infer/train-index.py

@@ -1,31 +1,31 @@
-'''
+"""
 格式：直接cid为自带的index位；aid放不下了，通过字典来查，反正就5w个
-'''
-import faiss,numpy as np,os
+"""
+import faiss, numpy as np, os
 
 # ###########如果是原始特征要先写save
-inp_root=r"E:\codes\py39\dataset\mi\2-co256"
-npys=[]
+inp_root = r"E:\codes\py39\dataset\mi\2-co256"
+npys = []
 for name in sorted(list(os.listdir(inp_root))):
-    phone=np.load("%s/%s"%(inp_root,name))
+    phone = np.load("%s/%s" % (inp_root, name))
     npys.append(phone)
-big_npy=np.concatenate(npys,0)
-print(big_npy.shape)#(6196072, 192)#fp32#4.43G
-np.save("infer/big_src_feature_mi.npy",big_npy)
+big_npy = np.concatenate(npys, 0)
+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")
 print(big_npy.shape)
-index = faiss.index_factory(256, "IVF512,Flat")#mi
+index = faiss.index_factory(256, "IVF512,Flat")  # mi
 print("training")
-index_ivf = faiss.extract_index_ivf(index)#
+index_ivf = faiss.extract_index_ivf(index)  #
 index_ivf.nprobe = 9
 index.train(big_npy)
-faiss.write_index(index, 'infer/trained_IVF512_Flat_mi_baseline_src_feat.index')
+faiss.write_index(index, "infer/trained_IVF512_Flat_mi_baseline_src_feat.index")
 print("adding")
 index.add(big_npy)
-faiss.write_index(index,"infer/added_IVF512_Flat_mi_baseline_src_feat.index")
-'''
+faiss.write_index(index, "infer/added_IVF512_Flat_mi_baseline_src_feat.index")
+"""
 大小（都是FP32）
 big_src_feature 2.95G
     (3098036, 256)
@@ -33,4 +33,4 @@ big_emb         4.43G
     (6196072, 192)
 big_emb双倍是因为求特征要repeat后再加pitch
 
-'''
+"""

infer/trans_weights.py

@@ -1,11 +1,16 @@
-import torch,pdb
+import torch, pdb
 
 # a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-suc\G_1000.pth")["model"]#sim_nsf#
 # a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-freeze-vocoder-flow-enc_q\G_1000.pth")["model"]#sim_nsf#
 # a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-freeze-vocoder\G_1000.pth")["model"]#sim_nsf#
 # a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-test\G_1000.pth")["model"]#sim_nsf#
-a=torch.load(r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-no_opt-no_dropout\G_1000.pth")["model"]#sim_nsf#
-for key in a.keys():a[key]=a[key].half()
+a = torch.load(
+    r"E:\codes\py39\vits_vc_gpu_train\logs\ft-mi-no_opt-no_dropout\G_1000.pth"
+)[
+    "model"
+]  # sim_nsf#
+for key in a.keys():
+    a[key] = a[key].half()
 # torch.save(a,"ft-mi-freeze-vocoder_true_1k.pt")#
 # torch.save(a,"ft-mi-sim1k.pt")#
-torch.save(a,"ft-mi-no_opt-no_dropout.pt")#
+torch.save(a, "ft-mi-no_opt-no_dropout.pt")  #

infer_pack/commons.py

@@ -48,8 +48,10 @@ def slice_segments(x, ids_str, segment_size=4):
         idx_end = idx_str + segment_size
         ret[i] = x[i, :, idx_str:idx_end]
     return ret
+
+
 def slice_segments2(x, ids_str, segment_size=4):
-    ret = torch.zeros_like(x[:,  :segment_size])
+    ret = torch.zeros_like(x[:, :segment_size])
     for i in range(x.size(0)):
         idx_str = ids_str[i]
         idx_end = idx_str + segment_size

infer_pack/models.py

@@ -1,4 +1,4 @@
-import math,pdb,os
+import math, pdb, os
 from time import time as ttime
 import torch
 from torch import nn
@@ -12,9 +12,20 @@ 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    ):
+        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
@@ -24,8 +35,8 @@ class TextEncoder256(nn.Module):
         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.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
@@ -33,12 +44,12 @@ class TextEncoder256(nn.Module):
         self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
 
     def forward(self, phone, pitch, lengths):
-        if(pitch==None):
+        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 = 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
@@ -48,8 +59,20 @@ class TextEncoder256(nn.Module):
 
         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):
+    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
@@ -59,8 +82,8 @@ class TextEncoder256Sim(nn.Module):
         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.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
@@ -68,17 +91,21 @@ class TextEncoder256Sim(nn.Module):
         self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
 
     def forward(self, phone, pitch, lengths):
-        if(pitch==None):
+        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 = 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_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
+        return x, x_mask
+
+
 class ResidualCouplingBlock(nn.Module):
     def __init__(
         self,
@@ -126,6 +153,8 @@ class ResidualCouplingBlock(nn.Module):
     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,
@@ -169,6 +198,8 @@ class PosteriorEncoder(nn.Module):
 
     def remove_weight_norm(self):
         self.enc.remove_weight_norm()
+
+
 class Generator(torch.nn.Module):
     def __init__(
         self,
@@ -243,8 +274,10 @@ class Generator(torch.nn.Module):
             remove_weight_norm(l)
         for l in self.resblocks:
             l.remove_weight_norm()
+
+
 class SineGen(torch.nn.Module):
-    """ Definition of sine generator
+    """Definition of sine generator
     SineGen(samp_rate, harmonic_num = 0,
             sine_amp = 0.1, noise_std = 0.003,
             voiced_threshold = 0,
@@ -259,10 +292,15 @@ class SineGen(torch.nn.Module):
         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):
+    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
@@ -277,8 +315,8 @@ class SineGen(torch.nn.Module):
         uv = uv * (f0 > self.voiced_threshold)
         return uv
 
-    def forward(self, f0,upp):
-        """ sine_tensor, uv = forward(f0)
+    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)
@@ -286,32 +324,52 @@ class SineGen(torch.nn.Module):
         """
         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)
+            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)
+            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 = 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 = 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)
+            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 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
@@ -328,26 +386,37 @@ class SourceModuleHnNSF(torch.nn.Module):
     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):
+    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
+        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)
+        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==True):sine_wavs=sine_wavs.half()
+    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
+        return sine_merge, None, None  # noise, uv
+
+
 class GeneratorNSF(torch.nn.Module):
     def __init__(
         self,
@@ -360,7 +429,7 @@ class GeneratorNSF(torch.nn.Module):
         upsample_kernel_sizes,
         gin_channels,
         sr,
-        is_half=False
+        is_half=False,
     ):
         super(GeneratorNSF, self).__init__()
         self.num_kernels = len(resblock_kernel_sizes)
@@ -368,9 +437,7 @@ class GeneratorNSF(torch.nn.Module):
 
         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
+            sampling_rate=sr, harmonic_num=0, is_half=is_half
         )
         self.noise_convs = nn.ModuleList()
         self.conv_pre = Conv1d(
@@ -393,9 +460,16 @@ class GeneratorNSF(torch.nn.Module):
                 )
             )
             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))
+                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))
 
@@ -413,10 +487,10 @@ class GeneratorNSF(torch.nn.Module):
         if gin_channels != 0:
             self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
 
-        self.upp=np.prod(upsample_rates)
+        self.upp = np.prod(upsample_rates)
 
-    def forward(self, x, f0,g=None):
-        har_source, noi_source, uv = self.m_source(f0,self.upp)
+    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:
@@ -444,11 +518,15 @@ class GeneratorNSF(torch.nn.Module):
             remove_weight_norm(l)
         for l in self.resblocks:
             l.remove_weight_norm()
-sr2sr={
-    "32k":32000,
-    "40k":40000,
-    "48k":48000,
+
+
+sr2sr = {
+    "32k": 32000,
+    "40k": 40000,
+    "48k": 48000,
 }
+
+
 class SynthesizerTrnMs256NSFsid(nn.Module):
     def __init__(
         self,
@@ -472,10 +550,9 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
         sr,
         **kwargs
     ):
-
         super().__init__()
-        if(type(sr)==type("strr")):
-            sr=sr2sr[sr]
+        if type(sr) == type("strr"):
+            sr = sr2sr[sr]
         self.spec_channels = spec_channels
         self.inter_channels = inter_channels
         self.hidden_channels = hidden_channels
@@ -493,7 +570,7 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
         self.segment_size = segment_size
         self.gin_channels = gin_channels
         # self.hop_length = hop_length#
-        self.spk_embed_dim=spk_embed_dim
+        self.spk_embed_dim = spk_embed_dim
         self.enc_p = TextEncoder256(
             inter_channels,
             hidden_channels,
@@ -511,7 +588,9 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
             upsample_rates,
             upsample_initial_channel,
             upsample_kernel_sizes,
-            gin_channels=gin_channels,   sr=sr,         is_half=kwargs["is_half"]
+            gin_channels=gin_channels,
+            sr=sr,
+            is_half=kwargs["is_half"],
         )
         self.enc_q = PosteriorEncoder(
             spec_channels,
@@ -526,13 +605,16 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
             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)
+        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, y, y_lengths,ds):#这里ds是id，[bs,1]
+    def forward(
+        self, phone, phone_lengths, pitch, pitchf, y, y_lengths, ds
+    ):  # 这里ds是id，[bs,1]
         # print(1,pitch.shape)#[bs,t]
         g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
         m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
@@ -542,20 +624,20 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
             z, y_lengths, self.segment_size
         )
         # print(-1,pitchf.shape,ids_slice,self.segment_size,self.hop_length,self.segment_size//self.hop_length)
-        pitchf = commons.slice_segments2(
-            pitchf, ids_slice, self.segment_size
-        )
+        pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
         # print(-2,pitchf.shape,z_slice.shape)
-        o = self.dec(z_slice,pitchf, g=g)
+        o = self.dec(z_slice, pitchf, g=g)
         return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
 
-    def infer(self, phone, phone_lengths, pitch, nsff0,sid,max_len=None):
+    def infer(self, phone, phone_lengths, pitch, nsff0, sid, 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) * torch.randn_like(m_p) * 0.66666) * x_mask
         z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], nsff0,g=g)
+        o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
         return o, x_mask, (z, z_p, m_p, logs_p)
+
+
 class SynthesizerTrnMs256NSFsid_nono(nn.Module):
     def __init__(
         self,
@@ -579,7 +661,6 @@ class SynthesizerTrnMs256NSFsid_nono(nn.Module):
         sr=None,
         **kwargs
     ):
-
         super().__init__()
         self.spec_channels = spec_channels
         self.inter_channels = inter_channels
@@ -598,7 +679,7 @@ class SynthesizerTrnMs256NSFsid_nono(nn.Module):
         self.segment_size = segment_size
         self.gin_channels = gin_channels
         # self.hop_length = hop_length#
-        self.spk_embed_dim=spk_embed_dim
+        self.spk_embed_dim = spk_embed_dim
         self.enc_p = TextEncoder256(
             inter_channels,
             hidden_channels,
@@ -606,7 +687,8 @@ class SynthesizerTrnMs256NSFsid_nono(nn.Module):
             n_heads,
             n_layers,
             kernel_size,
-            p_dropout,f0=False
+            p_dropout,
+            f0=False,
         )
         self.dec = Generator(
             inter_channels,
@@ -616,7 +698,7 @@ class SynthesizerTrnMs256NSFsid_nono(nn.Module):
             upsample_rates,
             upsample_initial_channel,
             upsample_kernel_sizes,
-            gin_channels=gin_channels
+            gin_channels=gin_channels,
         )
         self.enc_q = PosteriorEncoder(
             spec_channels,
@@ -631,14 +713,14 @@ class SynthesizerTrnMs256NSFsid_nono(nn.Module):
             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)
+        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, y, y_lengths,ds):#这里ds是id，[bs,1]
+    def forward(self, phone, phone_lengths, y, y_lengths, ds):  # 这里ds是id，[bs,1]
         g = self.emb_g(ds).unsqueeze(-1)  # [b, 256, 1]##1是t，广播的
         m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
         z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
@@ -649,13 +731,15 @@ class SynthesizerTrnMs256NSFsid_nono(nn.Module):
         o = self.dec(z_slice, g=g)
         return o, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
 
-    def infer(self, phone, phone_lengths,sid,max_len=None):
+    def infer(self, phone, phone_lengths, sid, max_len=None):
         g = self.emb_g(sid).unsqueeze(-1)
         m_p, logs_p, x_mask = self.enc_p(phone, None, phone_lengths)
         z_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
         z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len],g=g)
+        o = self.dec((z * x_mask)[:, :, :max_len], g=g)
         return o, x_mask, (z, z_p, m_p, logs_p)
+
+
 class SynthesizerTrnMs256NSFsid_sim(nn.Module):
     """
     Synthesizer for Training
@@ -684,7 +768,6 @@ class SynthesizerTrnMs256NSFsid_sim(nn.Module):
         use_sdp=True,
         **kwargs
     ):
-
         super().__init__()
         self.spec_channels = spec_channels
         self.inter_channels = inter_channels
@@ -703,7 +786,7 @@ class SynthesizerTrnMs256NSFsid_sim(nn.Module):
         self.segment_size = segment_size
         self.gin_channels = gin_channels
         # self.hop_length = hop_length#
-        self.spk_embed_dim=spk_embed_dim
+        self.spk_embed_dim = spk_embed_dim
         self.enc_p = TextEncoder256Sim(
             inter_channels,
             hidden_channels,
@@ -721,20 +804,24 @@ class SynthesizerTrnMs256NSFsid_sim(nn.Module):
             upsample_rates,
             upsample_initial_channel,
             upsample_kernel_sizes,
-            gin_channels=gin_channels,is_half=kwargs["is_half"]
+            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)
+        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, y_lengths,ds):  # y是spec不需要了现在
+    def forward(
+        self, phone, phone_lengths, pitch, pitchf, y_lengths, ds
+    ):  # y是spec不需要了现在
         g = self.emb_g(ds).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)
@@ -742,22 +829,24 @@ class SynthesizerTrnMs256NSFsid_sim(nn.Module):
             x, y_lengths, self.segment_size
         )
 
-        pitchf = commons.slice_segments2(
-            pitchf, ids_slice, self.segment_size
-        )
+        pitchf = commons.slice_segments2(pitchf, ids_slice, self.segment_size)
         o = self.dec(z_slice, pitchf, g=g)
         return o, ids_slice
-    def infer(self, phone, phone_lengths, pitch, pitchf, ds,max_len=None):  # y是spec不需要了现在
+
+    def infer(
+        self, phone, phone_lengths, pitch, pitchf, ds, max_len=None
+    ):  # y是spec不需要了现在
         g = self.emb_g(ds).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)
+        o = self.dec((x * x_mask)[:, :, :max_len], pitchf, g=g)
         return o, 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 = [2, 3, 5, 7, 11, 17]
         # periods = [3, 5, 7, 11, 17, 23, 37]
 
         discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
@@ -767,7 +856,7 @@ class MultiPeriodDiscriminator(torch.nn.Module):
         self.discriminators = nn.ModuleList(discs)
 
     def forward(self, y, y_hat):
-        y_d_rs = []#
+        y_d_rs = []  #
         y_d_gs = []
         fmap_rs = []
         fmap_gs = []
@@ -783,6 +872,7 @@ class MultiPeriodDiscriminator(torch.nn.Module):
 
         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__()
@@ -812,6 +902,7 @@ class DiscriminatorS(torch.nn.Module):
 
         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__()
@@ -889,4 +980,3 @@ class DiscriminatorP(torch.nn.Module):
         x = torch.flatten(x, 1, -1)
 
         return x, fmap
-

infer_pack/models_onnx.py

@@ -1,4 +1,4 @@
-import math,pdb,os
+import math, pdb, os
 from time import time as ttime
 import torch
 from torch import nn
@@ -12,9 +12,20 @@ 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    ):
+        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
@@ -24,8 +35,8 @@ class TextEncoder256(nn.Module):
         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.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
@@ -33,12 +44,12 @@ class TextEncoder256(nn.Module):
         self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
 
     def forward(self, phone, pitch, lengths):
-        if(pitch==None):
+        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 = 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
@@ -48,8 +59,20 @@ class TextEncoder256(nn.Module):
 
         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):
+    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
@@ -59,8 +82,8 @@ class TextEncoder256Sim(nn.Module):
         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.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
@@ -68,17 +91,21 @@ class TextEncoder256Sim(nn.Module):
         self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
 
     def forward(self, phone, pitch, lengths):
-        if(pitch==None):
+        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 = 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_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
+        return x, x_mask
+
+
 class ResidualCouplingBlock(nn.Module):
     def __init__(
         self,
@@ -126,6 +153,8 @@ class ResidualCouplingBlock(nn.Module):
     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,
@@ -169,6 +198,8 @@ class PosteriorEncoder(nn.Module):
 
     def remove_weight_norm(self):
         self.enc.remove_weight_norm()
+
+
 class Generator(torch.nn.Module):
     def __init__(
         self,
@@ -243,8 +274,10 @@ class Generator(torch.nn.Module):
             remove_weight_norm(l)
         for l in self.resblocks:
             l.remove_weight_norm()
+
+
 class SineGen(torch.nn.Module):
-    """ Definition of sine generator
+    """Definition of sine generator
     SineGen(samp_rate, harmonic_num = 0,
             sine_amp = 0.1, noise_std = 0.003,
             voiced_threshold = 0,
@@ -259,10 +292,15 @@ class SineGen(torch.nn.Module):
         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):
+    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
@@ -277,8 +315,8 @@ class SineGen(torch.nn.Module):
         uv = uv * (f0 > self.voiced_threshold)
         return uv
 
-    def forward(self, f0,upp):
-        """ sine_tensor, uv = forward(f0)
+    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)
@@ -286,32 +324,52 @@ class SineGen(torch.nn.Module):
         """
         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)
+            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)
+            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 = 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 = 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)
+            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 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
@@ -328,26 +386,37 @@ class SourceModuleHnNSF(torch.nn.Module):
     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):
+    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
+        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)
+        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==True):sine_wavs=sine_wavs.half()
+    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
+        return sine_merge, None, None  # noise, uv
+
+
 class GeneratorNSF(torch.nn.Module):
     def __init__(
         self,
@@ -360,7 +429,7 @@ class GeneratorNSF(torch.nn.Module):
         upsample_kernel_sizes,
         gin_channels,
         sr,
-        is_half=False
+        is_half=False,
     ):
         super(GeneratorNSF, self).__init__()
         self.num_kernels = len(resblock_kernel_sizes)
@@ -368,9 +437,7 @@ class GeneratorNSF(torch.nn.Module):
 
         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
+            sampling_rate=sr, harmonic_num=0, is_half=is_half
         )
         self.noise_convs = nn.ModuleList()
         self.conv_pre = Conv1d(
@@ -393,9 +460,16 @@ class GeneratorNSF(torch.nn.Module):
                 )
             )
             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))
+                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))
 
@@ -413,10 +487,10 @@ class GeneratorNSF(torch.nn.Module):
         if gin_channels != 0:
             self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
 
-        self.upp=np.prod(upsample_rates)
+        self.upp = np.prod(upsample_rates)
 
-    def forward(self, x, f0,g=None):
-        har_source, noi_source, uv = self.m_source(f0,self.upp)
+    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:
@@ -444,12 +518,16 @@ class GeneratorNSF(torch.nn.Module):
             remove_weight_norm(l)
         for l in self.resblocks:
             l.remove_weight_norm()
-sr2sr={
-    "32k":32000,
-    "40k":40000,
-    "48k":48000,
+
+
+sr2sr = {
+    "32k": 32000,
+    "40k": 40000,
+    "48k": 48000,
 }
-class SynthesizerTrnMs256NSFsid(nn.Module):
+
+
+class SynthesizerTrnMs256NSFsidO(nn.Module):
     def __init__(
         self,
         spec_channels,
@@ -472,10 +550,9 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
         sr,
         **kwargs
     ):
-
         super().__init__()
-        if(type(sr)==type("strr")):
-            sr=sr2sr[sr]
+        if type(sr) == type("strr"):
+            sr = sr2sr[sr]
         self.spec_channels = spec_channels
         self.inter_channels = inter_channels
         self.hidden_channels = hidden_channels
@@ -493,7 +570,7 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
         self.segment_size = segment_size
         self.gin_channels = gin_channels
         # self.hop_length = hop_length#
-        self.spk_embed_dim=spk_embed_dim
+        self.spk_embed_dim = spk_embed_dim
         self.enc_p = TextEncoder256(
             inter_channels,
             hidden_channels,
@@ -511,7 +588,9 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
             upsample_rates,
             upsample_initial_channel,
             upsample_kernel_sizes,
-            gin_channels=gin_channels,   sr=sr,         is_half=kwargs["is_half"]
+            gin_channels=gin_channels,
+            sr=sr,
+            is_half=kwargs["is_half"],
         )
         self.enc_q = PosteriorEncoder(
             spec_channels,
@@ -526,110 +605,26 @@ class SynthesizerTrnMs256NSFsid(nn.Module):
             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)
+        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):
-    
+    def forward(self, phone, phone_lengths, pitch, nsff0, sid, 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_p = (m_p + torch.exp(logs_p) * torch.randn_like(m_p) * 0.66666) * x_mask
         z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], nsff0,g=g)
+        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 = [2, 3, 5, 7, 11, 17]
         # periods = [3, 5, 7, 11, 17, 23, 37]
 
         discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
@@ -639,7 +634,7 @@ class MultiPeriodDiscriminator(torch.nn.Module):
         self.discriminators = nn.ModuleList(discs)
 
     def forward(self, y, y_hat):
-        y_d_rs = []#
+        y_d_rs = []  #
         y_d_gs = []
         fmap_rs = []
         fmap_gs = []
@@ -655,6 +650,7 @@ class MultiPeriodDiscriminator(torch.nn.Module):
 
         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__()
@@ -684,6 +680,7 @@ class DiscriminatorS(torch.nn.Module):
 
         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__()
@@ -761,4 +758,3 @@ class DiscriminatorP(torch.nn.Module):
         x = torch.flatten(x, 1, -1)
 
         return x, fmap
-

infer_pack/models_onnx_moess.py

@@ -0,0 +1,849 @@
+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

infer_pack/transforms.py

@@ -9,66 +9,63 @@ DEFAULT_MIN_BIN_HEIGHT = 1e-3
 DEFAULT_MIN_DERIVATIVE = 1e-3
 
 
-def piecewise_rational_quadratic_transform(inputs, 
-                                           unnormalized_widths,
-                                           unnormalized_heights,
-                                           unnormalized_derivatives,
-                                           inverse=False,
-                                           tails=None, 
-                                           tail_bound=1.,
-                                           min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                                           min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                                           min_derivative=DEFAULT_MIN_DERIVATIVE):
-
+def piecewise_rational_quadratic_transform(
+    inputs,
+    unnormalized_widths,
+    unnormalized_heights,
+    unnormalized_derivatives,
+    inverse=False,
+    tails=None,
+    tail_bound=1.0,
+    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
+    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
+    min_derivative=DEFAULT_MIN_DERIVATIVE,
+):
     if tails is None:
         spline_fn = rational_quadratic_spline
         spline_kwargs = {}
     else:
         spline_fn = unconstrained_rational_quadratic_spline
-        spline_kwargs = {
-            'tails': tails,
-            'tail_bound': tail_bound
-        }
+        spline_kwargs = {"tails": tails, "tail_bound": tail_bound}
 
     outputs, logabsdet = spline_fn(
-            inputs=inputs,
-            unnormalized_widths=unnormalized_widths,
-            unnormalized_heights=unnormalized_heights,
-            unnormalized_derivatives=unnormalized_derivatives,
-            inverse=inverse,
-            min_bin_width=min_bin_width,
-            min_bin_height=min_bin_height,
-            min_derivative=min_derivative,
-            **spline_kwargs
+        inputs=inputs,
+        unnormalized_widths=unnormalized_widths,
+        unnormalized_heights=unnormalized_heights,
+        unnormalized_derivatives=unnormalized_derivatives,
+        inverse=inverse,
+        min_bin_width=min_bin_width,
+        min_bin_height=min_bin_height,
+        min_derivative=min_derivative,
+        **spline_kwargs
     )
     return outputs, logabsdet
 
 
 def searchsorted(bin_locations, inputs, eps=1e-6):
     bin_locations[..., -1] += eps
-    return torch.sum(
-        inputs[..., None] >= bin_locations,
-        dim=-1
-    ) - 1
+    return torch.sum(inputs[..., None] >= bin_locations, dim=-1) - 1
 
 
-def unconstrained_rational_quadratic_spline(inputs,
-                                            unnormalized_widths,
-                                            unnormalized_heights,
-                                            unnormalized_derivatives,
-                                            inverse=False,
-                                            tails='linear',
-                                            tail_bound=1.,
-                                            min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                                            min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                                            min_derivative=DEFAULT_MIN_DERIVATIVE):
+def unconstrained_rational_quadratic_spline(
+    inputs,
+    unnormalized_widths,
+    unnormalized_heights,
+    unnormalized_derivatives,
+    inverse=False,
+    tails="linear",
+    tail_bound=1.0,
+    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
+    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
+    min_derivative=DEFAULT_MIN_DERIVATIVE,
+):
     inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
     outside_interval_mask = ~inside_interval_mask
 
     outputs = torch.zeros_like(inputs)
     logabsdet = torch.zeros_like(inputs)
 
-    if tails == 'linear':
+    if tails == "linear":
         unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
         constant = np.log(np.exp(1 - min_derivative) - 1)
         unnormalized_derivatives[..., 0] = constant
@@ -77,45 +74,57 @@ def unconstrained_rational_quadratic_spline(inputs,
         outputs[outside_interval_mask] = inputs[outside_interval_mask]
         logabsdet[outside_interval_mask] = 0
     else:
-        raise RuntimeError('{} tails are not implemented.'.format(tails))
+        raise RuntimeError("{} tails are not implemented.".format(tails))
 
-    outputs[inside_interval_mask], logabsdet[inside_interval_mask] = rational_quadratic_spline(
+    (
+        outputs[inside_interval_mask],
+        logabsdet[inside_interval_mask],
+    ) = rational_quadratic_spline(
         inputs=inputs[inside_interval_mask],
         unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
         unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
         unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
         inverse=inverse,
-        left=-tail_bound, right=tail_bound, bottom=-tail_bound, top=tail_bound,
+        left=-tail_bound,
+        right=tail_bound,
+        bottom=-tail_bound,
+        top=tail_bound,
         min_bin_width=min_bin_width,
         min_bin_height=min_bin_height,
-        min_derivative=min_derivative
+        min_derivative=min_derivative,
     )
 
     return outputs, logabsdet
 
-def rational_quadratic_spline(inputs,
-                              unnormalized_widths,
-                              unnormalized_heights,
-                              unnormalized_derivatives,
-                              inverse=False,
-                              left=0., right=1., bottom=0., top=1.,
-                              min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-                              min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-                              min_derivative=DEFAULT_MIN_DERIVATIVE):
+
+def rational_quadratic_spline(
+    inputs,
+    unnormalized_widths,
+    unnormalized_heights,
+    unnormalized_derivatives,
+    inverse=False,
+    left=0.0,
+    right=1.0,
+    bottom=0.0,
+    top=1.0,
+    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
+    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
+    min_derivative=DEFAULT_MIN_DERIVATIVE,
+):
     if torch.min(inputs) < left or torch.max(inputs) > right:
-        raise ValueError('Input to a transform is not within its domain')
+        raise ValueError("Input to a transform is not within its domain")
 
     num_bins = unnormalized_widths.shape[-1]
 
     if min_bin_width * num_bins > 1.0:
-        raise ValueError('Minimal bin width too large for the number of bins')
+        raise ValueError("Minimal bin width too large for the number of bins")
     if min_bin_height * num_bins > 1.0:
-        raise ValueError('Minimal bin height too large for the number of bins')
+        raise ValueError("Minimal bin height too large for the number of bins")
 
     widths = F.softmax(unnormalized_widths, dim=-1)
     widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
     cumwidths = torch.cumsum(widths, dim=-1)
-    cumwidths = F.pad(cumwidths, pad=(1, 0), mode='constant', value=0.0)
+    cumwidths = F.pad(cumwidths, pad=(1, 0), mode="constant", value=0.0)
     cumwidths = (right - left) * cumwidths + left
     cumwidths[..., 0] = left
     cumwidths[..., -1] = right
@@ -126,7 +135,7 @@ def rational_quadratic_spline(inputs,
     heights = F.softmax(unnormalized_heights, dim=-1)
     heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
     cumheights = torch.cumsum(heights, dim=-1)
-    cumheights = F.pad(cumheights, pad=(1, 0), mode='constant', value=0.0)
+    cumheights = F.pad(cumheights, pad=(1, 0), mode="constant", value=0.0)
     cumheights = (top - bottom) * cumheights + bottom
     cumheights[..., 0] = bottom
     cumheights[..., -1] = top
@@ -150,15 +159,13 @@ def rational_quadratic_spline(inputs,
     input_heights = heights.gather(-1, bin_idx)[..., 0]
 
     if inverse:
-        a = (((inputs - input_cumheights) * (input_derivatives
-                                             + input_derivatives_plus_one
-                                             - 2 * input_delta)
-              + input_heights * (input_delta - input_derivatives)))
-        b = (input_heights * input_derivatives
-             - (inputs - input_cumheights) * (input_derivatives
-                                              + input_derivatives_plus_one
-                                              - 2 * input_delta))
-        c = - input_delta * (inputs - input_cumheights)
+        a = (inputs - input_cumheights) * (
+            input_derivatives + input_derivatives_plus_one - 2 * input_delta
+        ) + input_heights * (input_delta - input_derivatives)
+        b = input_heights * input_derivatives - (inputs - input_cumheights) * (
+            input_derivatives + input_derivatives_plus_one - 2 * input_delta
+        )
+        c = -input_delta * (inputs - input_cumheights)
 
         discriminant = b.pow(2) - 4 * a * c
         assert (discriminant >= 0).all()
@@ -167,11 +174,15 @@ def rational_quadratic_spline(inputs,
         outputs = root * input_bin_widths + input_cumwidths
 
         theta_one_minus_theta = root * (1 - root)
-        denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-                                     * theta_one_minus_theta)
-        derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * root.pow(2)
-                                                     + 2 * input_delta * theta_one_minus_theta
-                                                     + input_derivatives * (1 - root).pow(2))
+        denominator = input_delta + (
+            (input_derivatives + input_derivatives_plus_one - 2 * input_delta)
+            * theta_one_minus_theta
+        )
+        derivative_numerator = input_delta.pow(2) * (
+            input_derivatives_plus_one * root.pow(2)
+            + 2 * input_delta * theta_one_minus_theta
+            + input_derivatives * (1 - root).pow(2)
+        )
         logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
 
         return outputs, -logabsdet
@@ -179,15 +190,20 @@ def rational_quadratic_spline(inputs,
         theta = (inputs - input_cumwidths) / input_bin_widths
         theta_one_minus_theta = theta * (1 - theta)
 
-        numerator = input_heights * (input_delta * theta.pow(2)
-                                     + input_derivatives * theta_one_minus_theta)
-        denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-                                     * theta_one_minus_theta)
+        numerator = input_heights * (
+            input_delta * theta.pow(2) + input_derivatives * theta_one_minus_theta
+        )
+        denominator = input_delta + (
+            (input_derivatives + input_derivatives_plus_one - 2 * input_delta)
+            * theta_one_minus_theta
+        )
         outputs = input_cumheights + numerator / denominator
 
-        derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * theta.pow(2)
-                                                     + 2 * input_delta * theta_one_minus_theta
-                                                     + input_derivatives * (1 - theta).pow(2))
+        derivative_numerator = input_delta.pow(2) * (
+            input_derivatives_plus_one * theta.pow(2)
+            + 2 * input_delta * theta_one_minus_theta
+            + input_derivatives * (1 - theta).pow(2)
+        )
         logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
 
         return outputs, logabsdet

infer_uvr5.py

@@ -1,108 +1,171 @@
-import os,sys,torch,warnings,pdb
+import os, sys, torch, warnings, pdb
+
 warnings.filterwarnings("ignore")
 import librosa
 import importlib
-import  numpy as np
-import hashlib , math
+import numpy as np
+import hashlib, math
 from tqdm import tqdm
 from uvr5_pack.lib_v5 import spec_utils
-from uvr5_pack.utils import _get_name_params,inference
+from uvr5_pack.utils import _get_name_params, inference
 from uvr5_pack.lib_v5.model_param_init import ModelParameters
 from scipy.io import wavfile
 
-class  _audio_pre_():
-    def __init__(self, model_path,device,is_half):
+
+class _audio_pre_:
+    def __init__(self, agg,model_path, device, is_half):
         self.model_path = model_path
         self.device = device
         self.data = {
             # Processing Options
-            'postprocess': False,
-            'tta': False,
+            "postprocess": False,
+            "tta": False,
             # Constants
-            'window_size': 512,
-            'agg': 10,
-            'high_end_process': 'mirroring',
+            "window_size": 512,
+            "agg": agg,
+            "high_end_process": "mirroring",
         }
         nn_arch_sizes = [
-            31191, # default
-            33966,61968, 123821, 123812, 537238 # custom
+            31191,  # default
+            33966,
+            61968,
+            123821,
+            123812,
+            537238,  # custom
         ]
-        self.nn_architecture = list('{}KB'.format(s) for s in nn_arch_sizes)
-        model_size = math.ceil(os.stat(model_path ).st_size / 1024)
-        nn_architecture = '{}KB'.format(min(nn_arch_sizes, key=lambda x:abs(x-model_size)))
-        nets = importlib.import_module('uvr5_pack.lib_v5.nets' + f'_{nn_architecture}'.replace('_{}KB'.format(nn_arch_sizes[0]), ''), package=None)
-        model_hash = hashlib.md5(open(model_path,'rb').read()).hexdigest()
-        param_name ,model_params_d = _get_name_params(model_path , model_hash)
+        self.nn_architecture = list("{}KB".format(s) for s in nn_arch_sizes)
+        model_size = math.ceil(os.stat(model_path).st_size / 1024)
+        nn_architecture = "{}KB".format(
+            min(nn_arch_sizes, key=lambda x: abs(x - model_size))
+        )
+        nets = importlib.import_module(
+            "uvr5_pack.lib_v5.nets"
+            + f"_{nn_architecture}".replace("_{}KB".format(nn_arch_sizes[0]), ""),
+            package=None,
+        )
+        model_hash = hashlib.md5(open(model_path, "rb").read()).hexdigest()
+        param_name, model_params_d = _get_name_params(model_path, model_hash)
 
         mp = ModelParameters(model_params_d)
-        model = nets.CascadedASPPNet(mp.param['bins'] * 2)
-        cpk = torch.load( model_path , map_location='cpu')  
+        model = nets.CascadedASPPNet(mp.param["bins"] * 2)
+        cpk = torch.load(model_path, map_location="cpu")
         model.load_state_dict(cpk)
         model.eval()
-        if(is_half==True):model = model.half().to(device)
-        else:model = model.to(device)
+        if is_half:
+            model = model.half().to(device)
+        else:
+            model = model.to(device)
 
         self.mp = mp
         self.model = model
 
-    def _path_audio_(self, music_file ,ins_root=None,vocal_root=None):
-        if(ins_root is None and vocal_root is None):return "No save root."
-        name=os.path.basename(music_file)
-        if(ins_root is not None):os.makedirs(ins_root, exist_ok=True)
-        if(vocal_root is not None):os.makedirs(vocal_root , exist_ok=True)
+    def _path_audio_(self, music_file, ins_root=None, vocal_root=None):
+        if ins_root is None and vocal_root is None:
+            return "No save root."
+        name = os.path.basename(music_file)
+        if ins_root is not None:
+            os.makedirs(ins_root, exist_ok=True)
+        if vocal_root is not None:
+            os.makedirs(vocal_root, exist_ok=True)
         X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
-        bands_n = len(self.mp.param['band'])
+        bands_n = len(self.mp.param["band"])
         # print(bands_n)
-        for d in range(bands_n, 0, -1): 
-            bp = self.mp.param['band'][d]
-            if d == bands_n: # high-end band
-                X_wave[d], _ = librosa.core.load(#理论上librosa读取可能对某些音频有bug，应该上ffmpeg读取，但是太麻烦了弃坑
-                    music_file, bp['sr'], False, dtype=np.float32, res_type=bp['res_type'])
+        for d in range(bands_n, 0, -1):
+            bp = self.mp.param["band"][d]
+            if d == bands_n:  # high-end band
+                (
+                    X_wave[d],
+                    _,
+                ) = librosa.core.load(  # 理论上librosa读取可能对某些音频有bug，应该上ffmpeg读取，但是太麻烦了弃坑
+                    music_file,
+                    bp["sr"],
+                    False,
+                    dtype=np.float32,
+                    res_type=bp["res_type"],
+                )
                 if X_wave[d].ndim == 1:
                     X_wave[d] = np.asfortranarray([X_wave[d], X_wave[d]])
-            else: # lower bands
-                X_wave[d] = librosa.core.resample(X_wave[d+1], self.mp.param['band'][d+1]['sr'], bp['sr'], res_type=bp['res_type'])
+            else:  # lower bands
+                X_wave[d] = librosa.core.resample(
+                    X_wave[d + 1],
+                    self.mp.param["band"][d + 1]["sr"],
+                    bp["sr"],
+                    res_type=bp["res_type"],
+                )
             # Stft of wave source
-            X_spec_s[d] = spec_utils.wave_to_spectrogram_mt(X_wave[d], bp['hl'], bp['n_fft'], self.mp.param['mid_side'], self.mp.param['mid_side_b2'], self.mp.param['reverse'])
+            X_spec_s[d] = spec_utils.wave_to_spectrogram_mt(
+                X_wave[d],
+                bp["hl"],
+                bp["n_fft"],
+                self.mp.param["mid_side"],
+                self.mp.param["mid_side_b2"],
+                self.mp.param["reverse"],
+            )
             # pdb.set_trace()
-            if d == bands_n and self.data['high_end_process'] != 'none':
-                input_high_end_h = (bp['n_fft']//2 - bp['crop_stop']) + ( self.mp.param['pre_filter_stop'] - self.mp.param['pre_filter_start'])
-                input_high_end = X_spec_s[d][:, bp['n_fft']//2-input_high_end_h:bp['n_fft']//2, :]
+            if d == bands_n and self.data["high_end_process"] != "none":
+                input_high_end_h = (bp["n_fft"] // 2 - bp["crop_stop"]) + (
+                    self.mp.param["pre_filter_stop"] - self.mp.param["pre_filter_start"]
+                )
+                input_high_end = X_spec_s[d][
+                    :, bp["n_fft"] // 2 - input_high_end_h : bp["n_fft"] // 2, :
+                ]
 
         X_spec_m = spec_utils.combine_spectrograms(X_spec_s, self.mp)
-        aggresive_set = float(self.data['agg']/100)
-        aggressiveness = {'value': aggresive_set, 'split_bin': self.mp.param['band'][1]['crop_stop']}
+        aggresive_set = float(self.data["agg"] / 100)
+        aggressiveness = {
+            "value": aggresive_set,
+            "split_bin": self.mp.param["band"][1]["crop_stop"],
+        }
         with torch.no_grad():
-            pred, X_mag, X_phase = inference(X_spec_m,self.device,self.model, aggressiveness,self.data)
+            pred, X_mag, X_phase = inference(
+                X_spec_m, self.device, self.model, aggressiveness, self.data
+            )
         # Postprocess
-        if self.data['postprocess']:
+        if self.data["postprocess"]:
             pred_inv = np.clip(X_mag - pred, 0, np.inf)
             pred = spec_utils.mask_silence(pred, pred_inv)
         y_spec_m = pred * X_phase
         v_spec_m = X_spec_m - y_spec_m
 
-        if (ins_root is not None):
-            if self.data['high_end_process'].startswith('mirroring'):
-                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'], y_spec_m, input_high_end, self.mp)
-                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp,input_high_end_h, input_high_end_)
+        if ins_root is not None:
+            if self.data["high_end_process"].startswith("mirroring"):
+                input_high_end_ = spec_utils.mirroring(
+                    self.data["high_end_process"], y_spec_m, input_high_end, self.mp
+                )
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(
+                    y_spec_m, self.mp, input_high_end_h, input_high_end_
+                )
             else:
                 wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp)
-            print ('%s instruments done'%name)
-            wavfile.write(os.path.join(ins_root, 'instrument_{}.wav'.format(name) ), self.mp.param['sr'], (np.array(wav_instrument)*32768).astype("int16"))  #
-        if (vocal_root is not None):
-            if self.data['high_end_process'].startswith('mirroring'):
-                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'],  v_spec_m, input_high_end, self.mp)
-                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp, input_high_end_h, input_high_end_)
+            print("%s instruments done" % name)
+            wavfile.write(
+                os.path.join(ins_root, "instrument_{}_{}.wav".format(name,self.data["agg"])),
+                self.mp.param["sr"],
+                (np.array(wav_instrument) * 32768).astype("int16"),
+            )  #
+        if vocal_root is not None:
+            if self.data["high_end_process"].startswith("mirroring"):
+                input_high_end_ = spec_utils.mirroring(
+                    self.data["high_end_process"], v_spec_m, input_high_end, self.mp
+                )
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(
+                    v_spec_m, self.mp, input_high_end_h, input_high_end_
+                )
             else:
                 wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp)
-            print ('%s vocals done'%name)
-            wavfile.write(os.path.join(vocal_root , 'vocal_{}.wav'.format(name) ), self.mp.param['sr'], (np.array(wav_vocals)*32768).astype("int16"))
+            print("%s vocals done" % name)
+            wavfile.write(
+                os.path.join(vocal_root, "vocal_{}_{}.wav".format(name,self.data["agg"])),
+                self.mp.param["sr"],
+                (np.array(wav_vocals) * 32768).astype("int16"),
+            )
 
-if __name__ == '__main__':
-    device = 'cuda'
-    is_half=True
-    model_path='uvr5_weights/2_HP-UVR.pth'
-    pre_fun = _audio_pre_(model_path=model_path,device=device,is_half=True)
-    audio_path = '神女劈观.aac'
-    save_path = 'opt'
-    pre_fun._path_audio_(audio_path , save_path,save_path)
+
+if __name__ == "__main__":
+    device = "cuda"
+    is_half = True
+    model_path = "uvr5_weights/2_HP-UVR.pth"
+    pre_fun = _audio_pre_(model_path=model_path, device=device, is_half=True)
+    audio_path = "神女劈观.aac"
+    save_path = "opt"
+    pre_fun._path_audio_(audio_path, save_path, save_path)

my_utils.py

@@ -1,17 +1,21 @@
 import ffmpeg
 import numpy as np
-def load_audio(file,sr):
+
+
+def load_audio(file, sr):
     try:
         # https://github.com/openai/whisper/blob/main/whisper/audio.py#L26
         # This launches a subprocess to decode audio while down-mixing and resampling as necessary.
         # Requires the ffmpeg CLI and `ffmpeg-python` package to be installed.
-        file=file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")#防止小白拷路径头尾带了空格和"和回车
+        file = (
+            file.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
+        )  # 防止小白拷路径头尾带了空格和"和回车
         out, _ = (
             ffmpeg.input(file, threads=0)
-            .output("-", format="s16le", acodec="pcm_s16le", ac=1, ar=sr)
+            .output("-", format="f32le", acodec="pcm_f32le", ac=1, ar=sr)
             .run(cmd=["ffmpeg", "-nostdin"], capture_stdout=True, capture_stderr=True)
         )
     except Exception as e:
         raise RuntimeError(f"Failed to load audio: {e}")
 
-    return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0
+    return np.frombuffer(out, np.float32).flatten()

pyproject.toml

@@ -18,8 +18,7 @@ ffmpeg-python = "^0.2.0"
 tensorboardX = "^2.6"
 functorch = "^2.0.0"
 fairseq = "^0.12.2"
-faiss-gpu = "^1.7.2"
-faiss-cpu = "^1.7.3"
+faiss-cpu = "^1.7.2"
 Jinja2 = "^3.1.2"
 json5 = "^0.9.11"
 librosa = "0.9.2"

requirements-win-for-realtime_vc_gui.txt

@@ -0,0 +1,28 @@
+#1.Install torch from pytorch.org:
+#torch 2.0 with cuda 11.8
+#pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
+#torch 1.11.0 with cuda 11.3
+#pip install torch==1.11.0+cu113 torchvision==0.12.0+cu113 torchaudio==0.11.0 --extra-index-url https://download.pytorch.org/whl/cu113
+einops
+fairseq
+flask
+flask_cors
+gin
+gin_config
+librosa
+local_attention
+matplotlib
+praat-parselmouth
+pyworld
+PyYAML
+resampy
+scikit_learn
+scipy
+SoundFile
+tensorboard
+tqdm
+wave
+PySimpleGUI
+sounddevice
+gradio
+noisereduce

requirements.txt

@@ -4,7 +4,8 @@ scipy==1.9.3
 librosa==0.9.2
 llvmlite==0.39.0
 fairseq==0.12.2
-faiss-cpu==1.7.2
+faiss-cpu==1.7.0; sys_platform == "darwin"
+faiss-cpu==1.7.2; sys_platform != "darwin"
 gradio
 Cython
 future>=0.18.3

slicer2.py

@@ -18,9 +18,7 @@ def get_rms(
     x_shape_trimmed = list(y.shape)
     x_shape_trimmed[axis] -= frame_length - 1
     out_shape = tuple(x_shape_trimmed) + tuple([frame_length])
-    xw = np.lib.stride_tricks.as_strided(
-        y, shape=out_shape, strides=out_strides
-    )
+    xw = np.lib.stride_tricks.as_strided(y, shape=out_shape, strides=out_strides)
     if axis < 0:
         target_axis = axis - 1
     else:
@@ -38,19 +36,25 @@ def get_rms(
 
 
 class Slicer:
-    def __init__(self,
-                 sr: int,
-                 threshold: float = -40.,
-                 min_length: int = 5000,
-                 min_interval: int = 300,
-                 hop_size: int = 20,
-                 max_sil_kept: int = 5000):
+    def __init__(
+        self,
+        sr: int,
+        threshold: float = -40.0,
+        min_length: int = 5000,
+        min_interval: int = 300,
+        hop_size: int = 20,
+        max_sil_kept: int = 5000,
+    ):
         if not min_length >= min_interval >= hop_size:
-            raise ValueError('The following condition must be satisfied: min_length >= min_interval >= hop_size')
+            raise ValueError(
+                "The following condition must be satisfied: min_length >= min_interval >= hop_size"
+            )
         if not max_sil_kept >= hop_size:
-            raise ValueError('The following condition must be satisfied: max_sil_kept >= hop_size')
+            raise ValueError(
+                "The following condition must be satisfied: max_sil_kept >= hop_size"
+            )
         min_interval = sr * min_interval / 1000
-        self.threshold = 10 ** (threshold / 20.)
+        self.threshold = 10 ** (threshold / 20.0)
         self.hop_size = round(sr * hop_size / 1000)
         self.win_size = min(round(min_interval), 4 * self.hop_size)
         self.min_length = round(sr * min_length / 1000 / self.hop_size)
@@ -59,9 +63,13 @@ class Slicer:
 
     def _apply_slice(self, waveform, begin, end):
         if len(waveform.shape) > 1:
-            return waveform[:, begin * self.hop_size: min(waveform.shape[1], end * self.hop_size)]
+            return waveform[
+                :, begin * self.hop_size : min(waveform.shape[1], end * self.hop_size)
+            ]
         else:
-            return waveform[begin * self.hop_size: min(waveform.shape[0], end * self.hop_size)]
+            return waveform[
+                begin * self.hop_size : min(waveform.shape[0], end * self.hop_size)
+            ]
 
     # @timeit
     def slice(self, waveform):
@@ -71,7 +79,9 @@ class Slicer:
             samples = waveform
         if samples.shape[0] <= self.min_length:
             return [waveform]
-        rms_list = get_rms(y=samples, frame_length=self.win_size, hop_length=self.hop_size).squeeze(0)
+        rms_list = get_rms(
+            y=samples, frame_length=self.win_size, hop_length=self.hop_size
+        ).squeeze(0)
         sil_tags = []
         silence_start = None
         clip_start = 0
@@ -87,23 +97,37 @@ class Slicer:
                 continue
             # Clear recorded silence start if interval is not enough or clip is too short
             is_leading_silence = silence_start == 0 and i > self.max_sil_kept
-            need_slice_middle = i - silence_start >= self.min_interval and i - clip_start >= self.min_length
+            need_slice_middle = (
+                i - silence_start >= self.min_interval
+                and i - clip_start >= self.min_length
+            )
             if not is_leading_silence and not need_slice_middle:
                 silence_start = None
                 continue
             # Need slicing. Record the range of silent frames to be removed.
             if i - silence_start <= self.max_sil_kept:
-                pos = rms_list[silence_start: i + 1].argmin() + silence_start
+                pos = rms_list[silence_start : i + 1].argmin() + silence_start
                 if silence_start == 0:
                     sil_tags.append((0, pos))
                 else:
                     sil_tags.append((pos, pos))
                 clip_start = pos
             elif i - silence_start <= self.max_sil_kept * 2:
-                pos = rms_list[i - self.max_sil_kept: silence_start + self.max_sil_kept + 1].argmin()
+                pos = rms_list[
+                    i - self.max_sil_kept : silence_start + self.max_sil_kept + 1
+                ].argmin()
                 pos += i - self.max_sil_kept
-                pos_l = rms_list[silence_start: silence_start + self.max_sil_kept + 1].argmin() + silence_start
-                pos_r = rms_list[i - self.max_sil_kept: i + 1].argmin() + i - self.max_sil_kept
+                pos_l = (
+                    rms_list[
+                        silence_start : silence_start + self.max_sil_kept + 1
+                    ].argmin()
+                    + silence_start
+                )
+                pos_r = (
+                    rms_list[i - self.max_sil_kept : i + 1].argmin()
+                    + i
+                    - self.max_sil_kept
+                )
                 if silence_start == 0:
                     sil_tags.append((0, pos_r))
                     clip_start = pos_r
@@ -111,8 +135,17 @@ class Slicer:
                     sil_tags.append((min(pos_l, pos), max(pos_r, pos)))
                     clip_start = max(pos_r, pos)
             else:
-                pos_l = rms_list[silence_start: silence_start + self.max_sil_kept + 1].argmin() + silence_start
-                pos_r = rms_list[i - self.max_sil_kept: i + 1].argmin() + i - self.max_sil_kept
+                pos_l = (
+                    rms_list[
+                        silence_start : silence_start + self.max_sil_kept + 1
+                    ].argmin()
+                    + silence_start
+                )
+                pos_r = (
+                    rms_list[i - self.max_sil_kept : i + 1].argmin()
+                    + i
+                    - self.max_sil_kept
+                )
                 if silence_start == 0:
                     sil_tags.append((0, pos_r))
                 else:
@@ -121,9 +154,12 @@ class Slicer:
             silence_start = None
         # Deal with trailing silence.
         total_frames = rms_list.shape[0]
-        if silence_start is not None and total_frames - silence_start >= self.min_interval:
+        if (
+            silence_start is not None
+            and total_frames - silence_start >= self.min_interval
+        ):
             silence_end = min(total_frames, silence_start + self.max_sil_kept)
-            pos = rms_list[silence_start: silence_end + 1].argmin() + silence_start
+            pos = rms_list[silence_start : silence_end + 1].argmin() + silence_start
             sil_tags.append((pos, total_frames + 1))
         # Apply and return slices.
         if len(sil_tags) == 0:
@@ -133,9 +169,13 @@ class Slicer:
             if sil_tags[0][0] > 0:
                 chunks.append(self._apply_slice(waveform, 0, sil_tags[0][0]))
             for i in range(len(sil_tags) - 1):
-                chunks.append(self._apply_slice(waveform, sil_tags[i][1], sil_tags[i + 1][0]))
+                chunks.append(
+                    self._apply_slice(waveform, sil_tags[i][1], sil_tags[i + 1][0])
+                )
             if sil_tags[-1][1] < total_frames:
-                chunks.append(self._apply_slice(waveform, sil_tags[-1][1], total_frames))
+                chunks.append(
+                    self._apply_slice(waveform, sil_tags[-1][1], total_frames)
+                )
             return chunks
 
 
@@ -147,18 +187,45 @@ def main():
     import soundfile
 
     parser = ArgumentParser()
-    parser.add_argument('audio', type=str, help='The audio to be sliced')
-    parser.add_argument('--out', type=str, help='Output directory of the sliced audio clips')
-    parser.add_argument('--db_thresh', type=float, required=False, default=-40,
-                        help='The dB threshold for silence detection')
-    parser.add_argument('--min_length', type=int, required=False, default=5000,
-                        help='The minimum milliseconds required for each sliced audio clip')
-    parser.add_argument('--min_interval', type=int, required=False, default=300,
-                        help='The minimum milliseconds for a silence part to be sliced')
-    parser.add_argument('--hop_size', type=int, required=False, default=10,
-                        help='Frame length in milliseconds')
-    parser.add_argument('--max_sil_kept', type=int, required=False, default=500,
-                        help='The maximum silence length kept around the sliced clip, presented in milliseconds')
+    parser.add_argument("audio", type=str, help="The audio to be sliced")
+    parser.add_argument(
+        "--out", type=str, help="Output directory of the sliced audio clips"
+    )
+    parser.add_argument(
+        "--db_thresh",
+        type=float,
+        required=False,
+        default=-40,
+        help="The dB threshold for silence detection",
+    )
+    parser.add_argument(
+        "--min_length",
+        type=int,
+        required=False,
+        default=5000,
+        help="The minimum milliseconds required for each sliced audio clip",
+    )
+    parser.add_argument(
+        "--min_interval",
+        type=int,
+        required=False,
+        default=300,
+        help="The minimum milliseconds for a silence part to be sliced",
+    )
+    parser.add_argument(
+        "--hop_size",
+        type=int,
+        required=False,
+        default=10,
+        help="Frame length in milliseconds",
+    )
+    parser.add_argument(
+        "--max_sil_kept",
+        type=int,
+        required=False,
+        default=500,
+        help="The maximum silence length kept around the sliced clip, presented in milliseconds",
+    )
     args = parser.parse_args()
     out = args.out
     if out is None:
@@ -170,7 +237,7 @@ def main():
         min_length=args.min_length,
         min_interval=args.min_interval,
         hop_size=args.hop_size,
-        max_sil_kept=args.max_sil_kept
+        max_sil_kept=args.max_sil_kept,
     )
     chunks = slicer.slice(audio)
     if not os.path.exists(out):
@@ -178,8 +245,16 @@ def main():
     for i, chunk in enumerate(chunks):
         if len(chunk.shape) > 1:
             chunk = chunk.T
-        soundfile.write(os.path.join(out, f'%s_%d.wav' % (os.path.basename(args.audio).rsplit('.', maxsplit=1)[0], i)), chunk, sr)
+        soundfile.write(
+            os.path.join(
+                out,
+                f"%s_%d.wav"
+                % (os.path.basename(args.audio).rsplit(".", maxsplit=1)[0], i),
+            ),
+            chunk,
+            sr,
+        )
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    main()

train/data_utils.py

@@ -1,4 +1,4 @@
-import os,traceback
+import os, traceback
 import numpy as np
 import torch
 import torch.utils.data
@@ -6,6 +6,7 @@ import torch.utils.data
 from mel_processing import spectrogram_torch
 from utils import load_wav_to_torch, load_filepaths_and_text
 
+
 class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
     """
     1) loads audio, text pairs
@@ -15,14 +16,14 @@ class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
 
     def __init__(self, audiopaths_and_text, hparams):
         self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text)
-        self.max_wav_value  = hparams.max_wav_value
-        self.sampling_rate  = hparams.sampling_rate
-        self.filter_length  = hparams.filter_length
-        self.hop_length     = hparams.hop_length
-        self.win_length     = hparams.win_length
-        self.sampling_rate  = hparams.sampling_rate
-        self.min_text_len   = getattr(hparams, "min_text_len", 1)
-        self.max_text_len   = getattr(hparams, "max_text_len", 5000)
+        self.max_wav_value = hparams.max_wav_value
+        self.sampling_rate = hparams.sampling_rate
+        self.filter_length = hparams.filter_length
+        self.hop_length = hparams.hop_length
+        self.win_length = hparams.win_length
+        self.sampling_rate = hparams.sampling_rate
+        self.min_text_len = getattr(hparams, "min_text_len", 1)
+        self.max_text_len = getattr(hparams, "max_text_len", 5000)
         self._filter()
 
     def _filter(self):
@@ -34,12 +35,13 @@ class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
         # spec_length = wav_length // hop_length
         audiopaths_and_text_new = []
         lengths = []
-        for audiopath, text, pitch,pitchf,dv in self.audiopaths_and_text:
+        for audiopath, text, pitch, pitchf, dv in self.audiopaths_and_text:
             if self.min_text_len <= len(text) and len(text) <= self.max_text_len:
-                audiopaths_and_text_new.append([audiopath, text, pitch,pitchf,dv])
+                audiopaths_and_text_new.append([audiopath, text, pitch, pitchf, dv])
                 lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
         self.audiopaths_and_text = audiopaths_and_text_new
         self.lengths = lengths
+
     def get_sid(self, sid):
         sid = torch.LongTensor([int(sid)])
         return sid
@@ -54,7 +56,7 @@ class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
 
         phone, pitch, pitchf = self.get_labels(phone, pitch, pitchf)
         spec, wav = self.get_audio(file)
-        dv=self.get_sid(dv)
+        dv = self.get_sid(dv)
 
         len_phone = phone.size()[0]
         len_spec = spec.size()[-1]
@@ -71,9 +73,9 @@ class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
             pitch = pitch[:len_min]
             pitchf = pitchf[:len_min]
 
-        return (spec, wav, phone, pitch,pitchf,dv)
+        return (spec, wav, phone, pitch, pitchf, dv)
 
-    def get_labels(self, phone, pitch,pitchf):
+    def get_labels(self, phone, pitch, pitchf):
         phone = np.load(phone)
         phone = np.repeat(phone, 2, axis=0)
         pitch = np.load(pitch)
@@ -86,7 +88,7 @@ class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
         phone = torch.FloatTensor(phone)
         pitch = torch.LongTensor(pitch)
         pitchf = torch.FloatTensor(pitchf)
-        return phone, pitch,pitchf
+        return phone, pitch, pitchf
 
     def get_audio(self, filename):
         audio, sampling_rate = load_wav_to_torch(filename)
@@ -96,17 +98,25 @@ class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
                     sampling_rate, self.sampling_rate
                 )
             )
-        audio_norm = audio / self.max_wav_value
+        audio_norm = audio
+        #        audio_norm = audio / self.max_wav_value
+        #        audio_norm = audio / np.abs(audio).max()
+
         audio_norm = audio_norm.unsqueeze(0)
         spec_filename = filename.replace(".wav", ".spec.pt")
         if os.path.exists(spec_filename):
             try:
                 spec = torch.load(spec_filename)
             except:
-                print (spec_filename,traceback.format_exc())
-                spec = spectrogram_torch(audio_norm, self.filter_length,
-                                         self.sampling_rate, self.hop_length, self.win_length,
-                                         center=False)
+                print(spec_filename, traceback.format_exc())
+                spec = spectrogram_torch(
+                    audio_norm,
+                    self.filter_length,
+                    self.sampling_rate,
+                    self.hop_length,
+                    self.win_length,
+                    center=False,
+                )
                 spec = torch.squeeze(spec, 0)
                 torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
         else:
@@ -127,6 +137,8 @@ class TextAudioLoaderMultiNSFsid(torch.utils.data.Dataset):
 
     def __len__(self):
         return len(self.audiopaths_and_text)
+
+
 class TextAudioCollateMultiNSFsid:
     """Zero-pads model inputs and targets"""
 
@@ -155,7 +167,9 @@ class TextAudioCollateMultiNSFsid:
 
         max_phone_len = max([x[2].size(0) for x in batch])
         phone_lengths = torch.LongTensor(len(batch))
-        phone_padded = torch.FloatTensor(len(batch), max_phone_len, batch[0][2].shape[1])#(spec, wav, phone, pitch)
+        phone_padded = torch.FloatTensor(
+            len(batch), max_phone_len, batch[0][2].shape[1]
+        )  # (spec, wav, phone, pitch)
         pitch_padded = torch.LongTensor(len(batch), max_phone_len)
         pitchf_padded = torch.FloatTensor(len(batch), max_phone_len)
         phone_padded.zero_()
@@ -187,7 +201,6 @@ class TextAudioCollateMultiNSFsid:
             # dv[i] = row[5]
             sid[i] = row[5]
 
-
         return (
             phone_padded,
             phone_lengths,
@@ -198,9 +211,10 @@ class TextAudioCollateMultiNSFsid:
             wave_padded,
             wave_lengths,
             # dv
-            sid
+            sid,
         )
 
+
 class TextAudioLoader(torch.utils.data.Dataset):
     """
     1) loads audio, text pairs
@@ -210,14 +224,14 @@ class TextAudioLoader(torch.utils.data.Dataset):
 
     def __init__(self, audiopaths_and_text, hparams):
         self.audiopaths_and_text = load_filepaths_and_text(audiopaths_and_text)
-        self.max_wav_value  = hparams.max_wav_value
-        self.sampling_rate  = hparams.sampling_rate
-        self.filter_length  = hparams.filter_length
-        self.hop_length     = hparams.hop_length
-        self.win_length     = hparams.win_length
-        self.sampling_rate  = hparams.sampling_rate
-        self.min_text_len   = getattr(hparams, "min_text_len", 1)
-        self.max_text_len   = getattr(hparams, "max_text_len", 5000)
+        self.max_wav_value = hparams.max_wav_value
+        self.sampling_rate = hparams.sampling_rate
+        self.filter_length = hparams.filter_length
+        self.hop_length = hparams.hop_length
+        self.win_length = hparams.win_length
+        self.sampling_rate = hparams.sampling_rate
+        self.min_text_len = getattr(hparams, "min_text_len", 1)
+        self.max_text_len = getattr(hparams, "max_text_len", 5000)
         self._filter()
 
     def _filter(self):
@@ -229,12 +243,13 @@ class TextAudioLoader(torch.utils.data.Dataset):
         # spec_length = wav_length // hop_length
         audiopaths_and_text_new = []
         lengths = []
-        for audiopath, text,dv in self.audiopaths_and_text:
+        for audiopath, text, dv in self.audiopaths_and_text:
             if self.min_text_len <= len(text) and len(text) <= self.max_text_len:
-                audiopaths_and_text_new.append([audiopath, text,dv])
+                audiopaths_and_text_new.append([audiopath, text, dv])
                 lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
         self.audiopaths_and_text = audiopaths_and_text_new
         self.lengths = lengths
+
     def get_sid(self, sid):
         sid = torch.LongTensor([int(sid)])
         return sid
@@ -247,7 +262,7 @@ class TextAudioLoader(torch.utils.data.Dataset):
 
         phone = self.get_labels(phone)
         spec, wav = self.get_audio(file)
-        dv=self.get_sid(dv)
+        dv = self.get_sid(dv)
 
         len_phone = phone.size()[0]
         len_spec = spec.size()[-1]
@@ -257,7 +272,7 @@ class TextAudioLoader(torch.utils.data.Dataset):
             spec = spec[:, :len_min]
             wav = wav[:, :len_wav]
             phone = phone[:len_min, :]
-        return (spec, wav, phone,dv)
+        return (spec, wav, phone, dv)
 
     def get_labels(self, phone):
         phone = np.load(phone)
@@ -275,17 +290,25 @@ class TextAudioLoader(torch.utils.data.Dataset):
                     sampling_rate, self.sampling_rate
                 )
             )
-        audio_norm = audio / self.max_wav_value
+        audio_norm = audio
+        #        audio_norm = audio / self.max_wav_value
+        #        audio_norm = audio / np.abs(audio).max()
+
         audio_norm = audio_norm.unsqueeze(0)
         spec_filename = filename.replace(".wav", ".spec.pt")
         if os.path.exists(spec_filename):
             try:
                 spec = torch.load(spec_filename)
             except:
-                print (spec_filename,traceback.format_exc())
-                spec = spectrogram_torch(audio_norm, self.filter_length,
-                                         self.sampling_rate, self.hop_length, self.win_length,
-                                         center=False)
+                print(spec_filename, traceback.format_exc())
+                spec = spectrogram_torch(
+                    audio_norm,
+                    self.filter_length,
+                    self.sampling_rate,
+                    self.hop_length,
+                    self.win_length,
+                    center=False,
+                )
                 spec = torch.squeeze(spec, 0)
                 torch.save(spec, spec_filename, _use_new_zipfile_serialization=False)
         else:
@@ -306,6 +329,8 @@ class TextAudioLoader(torch.utils.data.Dataset):
 
     def __len__(self):
         return len(self.audiopaths_and_text)
+
+
 class TextAudioCollate:
     """Zero-pads model inputs and targets"""
 
@@ -334,7 +359,9 @@ class TextAudioCollate:
 
         max_phone_len = max([x[2].size(0) for x in batch])
         phone_lengths = torch.LongTensor(len(batch))
-        phone_padded = torch.FloatTensor(len(batch), max_phone_len, batch[0][2].shape[1])
+        phone_padded = torch.FloatTensor(
+            len(batch), max_phone_len, batch[0][2].shape[1]
+        )
         phone_padded.zero_()
         sid = torch.LongTensor(len(batch))
 
@@ -355,7 +382,6 @@ class TextAudioCollate:
 
             sid[i] = row[3]
 
-
         return (
             phone_padded,
             phone_lengths,
@@ -363,9 +389,10 @@ class TextAudioCollate:
             spec_lengths,
             wave_padded,
             wave_lengths,
-            sid
+            sid,
         )
 
+
 class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
     """
     Maintain similar input lengths in a batch.
@@ -402,7 +429,7 @@ class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
             if idx_bucket != -1:
                 buckets[idx_bucket].append(i)
 
-        for i in range(len(buckets) - 1, -1, -1):#
+        for i in range(len(buckets) - 1, -1, -1):  #
             if len(buckets[i]) == 0:
                 buckets.pop(i)
                 self.boundaries.pop(i + 1)

train/losses.py

@@ -1,6 +1,7 @@
 import torch
 from torch.nn import functional as F
 
+
 def feature_loss(fmap_r, fmap_g):
     loss = 0
     for dr, dg in zip(fmap_r, fmap_g):

train/mel_processing.py

@@ -1,18 +1,8 @@
-import math
-import os
-import random
 import torch
-from torch import nn
-import torch.nn.functional as F
 import torch.utils.data
-import numpy as np
-import librosa
-import librosa.util as librosa_util
-from librosa.util import normalize, pad_center, tiny
-from scipy.signal import get_window
-from scipy.io.wavfile import read
 from librosa.filters import mel as librosa_mel_fn
 
+
 MAX_WAV_VALUE = 32768.0
 
 
@@ -35,25 +25,38 @@ def dynamic_range_decompression_torch(x, C=1):
 
 
 def spectral_normalize_torch(magnitudes):
-    output = dynamic_range_compression_torch(magnitudes)
-    return output
+    return dynamic_range_compression_torch(magnitudes)
 
 
 def spectral_de_normalize_torch(magnitudes):
-    output = dynamic_range_decompression_torch(magnitudes)
-    return output
+    return dynamic_range_decompression_torch(magnitudes)
 
 
+# Reusable banks
 mel_basis = {}
 hann_window = {}
 
 
 def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
+    """Convert waveform into Linear-frequency Linear-amplitude spectrogram.
+
+    Args:
+        y             :: (B, T) - Audio waveforms
+        n_fft
+        sampling_rate
+        hop_size
+        win_size
+        center
+    Returns:
+        :: (B, Freq, Frame) - Linear-frequency Linear-amplitude spectrogram
+    """
+    # Validation
     if torch.min(y) < -1.0:
         print("min value is ", torch.min(y))
     if torch.max(y) > 1.0:
         print("max value is ", torch.max(y))
 
+    # Window - Cache if needed
     global hann_window
     dtype_device = str(y.dtype) + "_" + str(y.device)
     wnsize_dtype_device = str(win_size) + "_" + dtype_device
@@ -62,6 +65,7 @@ def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False)
             dtype=y.dtype, device=y.device
         )
 
+    # Padding
     y = torch.nn.functional.pad(
         y.unsqueeze(1),
         (int((n_fft - hop_size) / 2), int((n_fft - hop_size) / 2)),
@@ -69,6 +73,7 @@ def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False)
     )
     y = y.squeeze(1)
 
+    # Complex Spectrogram :: (B, T) -> (B, Freq, Frame, RealComplex=2)
     spec = torch.stft(
         y,
         n_fft,
@@ -78,72 +83,48 @@ def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False)
         center=center,
         pad_mode="reflect",
         normalized=False,
-        onesided=True,return_complex=False
+        onesided=True,
+        return_complex=False,
     )
 
+    # Linear-frequency Linear-amplitude spectrogram :: (B, Freq, Frame, RealComplex=2) -> (B, Freq, Frame)
     spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
     return spec
 
 
 def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
+    # MelBasis - Cache if needed
     global mel_basis
     dtype_device = str(spec.dtype) + "_" + str(spec.device)
     fmax_dtype_device = str(fmax) + "_" + dtype_device
     if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
+        mel = librosa_mel_fn(
+            sr=sampling_rate, n_fft=n_fft, n_mels=num_mels, fmin=fmin, fmax=fmax
+        )
         mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(
             dtype=spec.dtype, device=spec.device
         )
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-    return spec
+
+    # Mel-frequency Log-amplitude spectrogram :: (B, Freq=num_mels, Frame)
+    melspec = torch.matmul(mel_basis[fmax_dtype_device], spec)
+    melspec = spectral_normalize_torch(melspec)
+    return melspec
 
 
 def mel_spectrogram_torch(
     y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False
 ):
-    if torch.min(y) < -1.0:
-        print("min value is ", torch.min(y))
-    if torch.max(y) > 1.0:
-        print("max value is ", torch.max(y))
+    """Convert waveform into Mel-frequency Log-amplitude spectrogram.
 
-    global mel_basis, hann_window
-    dtype_device = str(y.dtype) + "_" + str(y.device)
-    fmax_dtype_device = str(fmax) + "_" + dtype_device
-    wnsize_dtype_device = str(win_size) + "_" + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(
-            dtype=y.dtype, device=y.device
-        )
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(
-            dtype=y.dtype, device=y.device
-        )
+    Args:
+        y       :: (B, T)           - Waveforms
+    Returns:
+        melspec :: (B, Freq, Frame) - Mel-frequency Log-amplitude spectrogram
+    """
+    # Linear-frequency Linear-amplitude spectrogram :: (B, T) -> (B, Freq, Frame)
+    spec = spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center)
 
-    y = torch.nn.functional.pad(
-        y.unsqueeze(1),
-        (int((n_fft - hop_size) / 2), int((n_fft - hop_size) / 2)),
-        mode="reflect",
-    )
-    y = y.squeeze(1)
+    # Mel-frequency Log-amplitude spectrogram :: (B, Freq, Frame) -> (B, Freq=num_mels, Frame)
+    melspec = spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax)
 
-    # spec = torch.stft(
-    #     y,
-    #     n_fft,
-    #     hop_length=hop_size,
-    #     win_length=win_size,
-    #     window=hann_window[wnsize_dtype_device],
-    #     center=center,
-    #     pad_mode="reflect",
-    #     normalized=False,
-    #     onesided=True,
-    # )
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-
-    return spec
+    return melspec

train/process_ckpt.py

@@ -1,97 +1,248 @@
-import torch,traceback,os,pdb
+import torch, traceback, os, pdb
 from collections import OrderedDict
 
-def savee(ckpt,sr,if_f0,name,epoch):
+
+def savee(ckpt, sr, if_f0, name, epoch):
     try:
         opt = OrderedDict()
         opt["weight"] = {}
         for key in ckpt.keys():
-            if ("enc_q" in key): continue
+            if "enc_q" in key:
+                continue
             opt["weight"][key] = ckpt[key].half()
-        if(sr=="40k"):opt["config"] = [1025, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10, 10, 2, 2], 512, [16, 16, 4, 4], 109, 256, 40000]
-        elif(sr=="48k"):opt["config"] = [1025, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10,6,2,2,2], 512, [16, 16, 4, 4,4], 109, 256, 48000]
-        elif(sr=="32k"):opt["config"] = [513, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10, 4, 2, 2, 2], 512, [16, 16, 4, 4,4], 109, 256, 32000]
-        opt["info"] = "%sepoch"%epoch
+        if sr == "40k":
+            opt["config"] = [
+                1025,
+                32,
+                192,
+                192,
+                768,
+                2,
+                6,
+                3,
+                0,
+                "1",
+                [3, 7, 11],
+                [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+                [10, 10, 2, 2],
+                512,
+                [16, 16, 4, 4],
+                109,
+                256,
+                40000,
+            ]
+        elif sr == "48k":
+            opt["config"] = [
+                1025,
+                32,
+                192,
+                192,
+                768,
+                2,
+                6,
+                3,
+                0,
+                "1",
+                [3, 7, 11],
+                [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+                [10, 6, 2, 2, 2],
+                512,
+                [16, 16, 4, 4, 4],
+                109,
+                256,
+                48000,
+            ]
+        elif sr == "32k":
+            opt["config"] = [
+                513,
+                32,
+                192,
+                192,
+                768,
+                2,
+                6,
+                3,
+                0,
+                "1",
+                [3, 7, 11],
+                [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+                [10, 4, 2, 2, 2],
+                512,
+                [16, 16, 4, 4, 4],
+                109,
+                256,
+                32000,
+            ]
+        opt["info"] = "%sepoch" % epoch
         opt["sr"] = sr
-        opt["f0"] =if_f0
-        torch.save(opt, "weights/%s.pth"%name)
+        opt["f0"] = if_f0
+        torch.save(opt, "weights/%s.pth" % name)
         return "Success."
     except:
         return traceback.format_exc()
 
+
 def show_info(path):
     try:
         a = torch.load(path, map_location="cpu")
-        return "模型信息:%s\n采样率:%s\n模型是否输入音高引导:%s"%(a.get("info","None"),a.get("sr","None"),a.get("f0","None"),)
+        return "模型信息:%s\n采样率:%s\n模型是否输入音高引导:%s" % (
+            a.get("info", "None"),
+            a.get("sr", "None"),
+            a.get("f0", "None"),
+        )
     except:
         return traceback.format_exc()
 
-def extract_small_model(path,name,sr,if_f0,info):
+
+def extract_small_model(path, name, sr, if_f0, info):
     try:
         ckpt = torch.load(path, map_location="cpu")
-        if("model"in ckpt):ckpt=ckpt["model"]
+        if "model" in ckpt:
+            ckpt = ckpt["model"]
         opt = OrderedDict()
         opt["weight"] = {}
         for key in ckpt.keys():
-            if ("enc_q" in key): continue
+            if "enc_q" in key:
+                continue
             opt["weight"][key] = ckpt[key].half()
-        if(sr=="40k"):opt["config"] = [1025, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10, 10, 2, 2], 512, [16, 16, 4, 4], 109, 256, 40000]
-        elif(sr=="48k"):opt["config"] = [1025, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10,6,2,2,2], 512, [16, 16, 4, 4,4], 109, 256, 48000]
-        elif(sr=="32k"):opt["config"] = [513, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10, 4, 2, 2, 2], 512, [16, 16, 4, 4,4], 109, 256, 32000]
-        if(info==""):info="Extracted model."
+        if sr == "40k":
+            opt["config"] = [
+                1025,
+                32,
+                192,
+                192,
+                768,
+                2,
+                6,
+                3,
+                0,
+                "1",
+                [3, 7, 11],
+                [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+                [10, 10, 2, 2],
+                512,
+                [16, 16, 4, 4],
+                109,
+                256,
+                40000,
+            ]
+        elif sr == "48k":
+            opt["config"] = [
+                1025,
+                32,
+                192,
+                192,
+                768,
+                2,
+                6,
+                3,
+                0,
+                "1",
+                [3, 7, 11],
+                [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+                [10, 6, 2, 2, 2],
+                512,
+                [16, 16, 4, 4, 4],
+                109,
+                256,
+                48000,
+            ]
+        elif sr == "32k":
+            opt["config"] = [
+                513,
+                32,
+                192,
+                192,
+                768,
+                2,
+                6,
+                3,
+                0,
+                "1",
+                [3, 7, 11],
+                [[1, 3, 5], [1, 3, 5], [1, 3, 5]],
+                [10, 4, 2, 2, 2],
+                512,
+                [16, 16, 4, 4, 4],
+                109,
+                256,
+                32000,
+            ]
+        if info == "":
+            info = "Extracted model."
         opt["info"] = info
         opt["sr"] = sr
-        opt["f0"] =int(if_f0)
-        torch.save(opt, "weights/%s.pth"%name)
+        opt["f0"] = int(if_f0)
+        torch.save(opt, "weights/%s.pth" % name)
         return "Success."
     except:
         return traceback.format_exc()
 
-def change_info(path,info,name):
+
+def change_info(path, info, name):
     try:
         ckpt = torch.load(path, map_location="cpu")
-        ckpt["info"]=info
-        if(name==""):name=os.path.basename(path)
-        torch.save(ckpt, "weights/%s"%name)
+        ckpt["info"] = info
+        if name == "":
+            name = os.path.basename(path)
+        torch.save(ckpt, "weights/%s" % name)
         return "Success."
     except:
         return traceback.format_exc()
 
-def merge(path1,path2,alpha1,sr,f0,info,name):
+
+def merge(path1, path2, alpha1, sr, f0, info, name):
     try:
+
         def extract(ckpt):
             a = ckpt["model"]
             opt = OrderedDict()
             opt["weight"] = {}
             for key in a.keys():
-                if ("enc_q" in key): continue
+                if "enc_q" in key:
+                    continue
                 opt["weight"][key] = a[key]
             return opt
+
         ckpt1 = torch.load(path1, map_location="cpu")
         ckpt2 = torch.load(path2, map_location="cpu")
-        if("model"in ckpt1):ckpt1=extract(ckpt1)
-        else:ckpt1=ckpt1["weight"]
-        if("model"in ckpt2):ckpt2=extract(ckpt2)
-        else:ckpt2=ckpt2["weight"]
-        if(sorted(list(ckpt1.keys()))!=sorted(list(ckpt2.keys()))):return "Fail to merge the models. The model architectures are not the same."
+        cfg = ckpt1["config"]
+        if "model" in ckpt1:
+            ckpt1 = extract(ckpt1)
+        else:
+            ckpt1 = ckpt1["weight"]
+        if "model" in ckpt2:
+            ckpt2 = extract(ckpt2)
+        else:
+            ckpt2 = ckpt2["weight"]
+        if sorted(list(ckpt1.keys())) != sorted(list(ckpt2.keys())):
+            return "Fail to merge the models. The model architectures are not the same."
         opt = OrderedDict()
         opt["weight"] = {}
         for key in ckpt1.keys():
             # try:
-                if(key=="emb_g.weight"and ckpt1[key].shape!=ckpt2[key].shape):
-                    min_shape0=min(ckpt1[key].shape[0],ckpt2[key].shape[0])
-                    opt["weight"][key] = (alpha1 * (ckpt1[key][:min_shape0].float()) + (1 - alpha1) * (ckpt2[key][:min_shape0].float())).half()
-                else:
-                    opt["weight"][key] = (alpha1*(ckpt1[key].float())+(1-alpha1)*(ckpt2[key].float())).half()
-            # except:
-            #     pdb.set_trace()
+            if key == "emb_g.weight" and ckpt1[key].shape != ckpt2[key].shape:
+                min_shape0 = min(ckpt1[key].shape[0], ckpt2[key].shape[0])
+                opt["weight"][key] = (
+                    alpha1 * (ckpt1[key][:min_shape0].float())
+                    + (1 - alpha1) * (ckpt2[key][:min_shape0].float())
+                ).half()
+            else:
+                opt["weight"][key] = (
+                    alpha1 * (ckpt1[key].float()) + (1 - alpha1) * (ckpt2[key].float())
+                ).half()
+        # except:
+        #     pdb.set_trace()
+        opt["config"] = cfg
+        """
         if(sr=="40k"):opt["config"] = [1025, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10, 10, 2, 2], 512, [16, 16, 4, 4,4], 109, 256, 40000]
         elif(sr=="48k"):opt["config"] = [1025, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10,6,2,2,2], 512, [16, 16, 4, 4], 109, 256, 48000]
         elif(sr=="32k"):opt["config"] = [513, 32, 192, 192, 768, 2, 6, 3, 0, "1", [3, 7, 11], [[1, 3, 5], [1, 3, 5], [1, 3, 5]], [10, 4, 2, 2, 2], 512, [16, 16, 4, 4,4], 109, 256, 32000]
-        opt["sr"]=sr
-        opt["f0"]=1 if f0=="是"else 0
-        opt["info"]=info
-        torch.save(opt, "weights/%s.pth"%name)
+        """
+        opt["sr"] = sr
+        opt["f0"] = 1 if f0 == "是" else 0
+        opt["info"] = info
+        torch.save(opt, "weights/%s.pth" % name)
         return "Success."
     except:
         return traceback.format_exc()

train/utils.py

@@ -1,4 +1,4 @@
-import os,traceback
+import os, traceback
 import glob
 import sys
 import argparse
@@ -14,44 +14,53 @@ MATPLOTLIB_FLAG = False
 logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
 logger = logging
 
-def load_checkpoint_d(checkpoint_path, combd,sbd, optimizer=None,load_opt=1):
-  assert os.path.isfile(checkpoint_path)
-  checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
 
-  ##################
-  def go(model,bkey):
-    saved_state_dict = checkpoint_dict[bkey]
-    if hasattr(model, 'module'):state_dict = model.module.state_dict()
-    else:state_dict = model.state_dict()
-    new_state_dict= {}
-    for k, v in state_dict.items():#模型需要的shape
-      try:
-        new_state_dict[k] = saved_state_dict[k]
-        if(saved_state_dict[k].shape!=state_dict[k].shape):
-          print("shape-%s-mismatch|need-%s|get-%s"%(k,state_dict[k].shape,saved_state_dict[k].shape))#
-          raise KeyError
-      except:
-        # logger.info(traceback.format_exc())
-        logger.info("%s is not in the checkpoint" % k)#pretrain缺失的
-        new_state_dict[k] = v#模型自带的随机值
-    if hasattr(model, 'module'):
-      model.module.load_state_dict(new_state_dict,strict=False)
-    else:
-      model.load_state_dict(new_state_dict,strict=False)
-  go(combd,"combd")
-  go(sbd,"sbd")
-  #############
-  logger.info("Loaded model weights")
+def load_checkpoint_d(checkpoint_path, combd, sbd, optimizer=None, load_opt=1):
+    assert os.path.isfile(checkpoint_path)
+    checkpoint_dict = torch.load(checkpoint_path, map_location="cpu")
 
-  iteration = checkpoint_dict['iteration']
-  learning_rate = checkpoint_dict['learning_rate']
-  if optimizer is not None and load_opt==1:###加载不了，如果是空的的话，重新初始化，可能还会影响lr时间表的更新，因此在train文件最外围catch
-  #   try:
-      optimizer.load_state_dict(checkpoint_dict['optimizer'])
-  #   except:
-  #     traceback.print_exc()
-  logger.info("Loaded checkpoint '{}' (epoch {})" .format(checkpoint_path, iteration))
-  return model, optimizer, learning_rate, iteration
+    ##################
+    def go(model, bkey):
+        saved_state_dict = checkpoint_dict[bkey]
+        if hasattr(model, "module"):
+            state_dict = model.module.state_dict()
+        else:
+            state_dict = model.state_dict()
+        new_state_dict = {}
+        for k, v in state_dict.items():  # 模型需要的shape
+            try:
+                new_state_dict[k] = saved_state_dict[k]
+                if saved_state_dict[k].shape != state_dict[k].shape:
+                    print(
+                        "shape-%s-mismatch|need-%s|get-%s"
+                        % (k, state_dict[k].shape, saved_state_dict[k].shape)
+                    )  #
+                    raise KeyError
+            except:
+                # logger.info(traceback.format_exc())
+                logger.info("%s is not in the checkpoint" % k)  # pretrain缺失的
+                new_state_dict[k] = v  # 模型自带的随机值
+        if hasattr(model, "module"):
+            model.module.load_state_dict(new_state_dict, strict=False)
+        else:
+            model.load_state_dict(new_state_dict, strict=False)
+
+    go(combd, "combd")
+    go(sbd, "sbd")
+    #############
+    logger.info("Loaded model weights")
+
+    iteration = checkpoint_dict["iteration"]
+    learning_rate = checkpoint_dict["learning_rate"]
+    if (
+        optimizer is not None and load_opt == 1
+    ):  ###加载不了，如果是空的的话，重新初始化，可能还会影响lr时间表的更新，因此在train文件最外围catch
+        #   try:
+        optimizer.load_state_dict(checkpoint_dict["optimizer"])
+    #   except:
+    #     traceback.print_exc()
+    logger.info("Loaded checkpoint '{}' (epoch {})".format(checkpoint_path, iteration))
+    return model, optimizer, learning_rate, iteration
 
 
 # def load_checkpoint(checkpoint_path, model, optimizer=None):
@@ -83,303 +92,380 @@ def load_checkpoint_d(checkpoint_path, combd,sbd, optimizer=None,load_opt=1):
 #   logger.info("Loaded checkpoint '{}' (epoch {})" .format(
 #     checkpoint_path, iteration))
 #   return model, optimizer, learning_rate, iteration
-def load_checkpoint(checkpoint_path, model, optimizer=None,load_opt=1):
-  assert os.path.isfile(checkpoint_path)
-  checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
+def load_checkpoint(checkpoint_path, model, optimizer=None, load_opt=1):
+    assert os.path.isfile(checkpoint_path)
+    checkpoint_dict = torch.load(checkpoint_path, map_location="cpu")
 
-  saved_state_dict = checkpoint_dict['model']
-  if hasattr(model, 'module'):
-    state_dict = model.module.state_dict()
-  else:
-    state_dict = model.state_dict()
-  new_state_dict= {}
-  for k, v in state_dict.items():#模型需要的shape
-    try:
-      new_state_dict[k] = saved_state_dict[k]
-      if(saved_state_dict[k].shape!=state_dict[k].shape):
-        print("shape-%s-mismatch|need-%s|get-%s"%(k,state_dict[k].shape,saved_state_dict[k].shape))#
-        raise KeyError
-    except:
-      # logger.info(traceback.format_exc())
-      logger.info("%s is not in the checkpoint" % k)#pretrain缺失的
-      new_state_dict[k] = v#模型自带的随机值
-  if hasattr(model, 'module'):
-    model.module.load_state_dict(new_state_dict,strict=False)
-  else:
-    model.load_state_dict(new_state_dict,strict=False)
-  logger.info("Loaded model weights")
+    saved_state_dict = checkpoint_dict["model"]
+    if hasattr(model, "module"):
+        state_dict = model.module.state_dict()
+    else:
+        state_dict = model.state_dict()
+    new_state_dict = {}
+    for k, v in state_dict.items():  # 模型需要的shape
+        try:
+            new_state_dict[k] = saved_state_dict[k]
+            if saved_state_dict[k].shape != state_dict[k].shape:
+                print(
+                    "shape-%s-mismatch|need-%s|get-%s"
+                    % (k, state_dict[k].shape, saved_state_dict[k].shape)
+                )  #
+                raise KeyError
+        except:
+            # logger.info(traceback.format_exc())
+            logger.info("%s is not in the checkpoint" % k)  # pretrain缺失的
+            new_state_dict[k] = v  # 模型自带的随机值
+    if hasattr(model, "module"):
+        model.module.load_state_dict(new_state_dict, strict=False)
+    else:
+        model.load_state_dict(new_state_dict, strict=False)
+    logger.info("Loaded model weights")
 
-  iteration = checkpoint_dict['iteration']
-  learning_rate = checkpoint_dict['learning_rate']
-  if optimizer is not None and load_opt==1:###加载不了，如果是空的的话，重新初始化，可能还会影响lr时间表的更新，因此在train文件最外围catch
-  #   try:
-      optimizer.load_state_dict(checkpoint_dict['optimizer'])
-  #   except:
-  #     traceback.print_exc()
-  logger.info("Loaded checkpoint '{}' (epoch {})" .format(checkpoint_path, iteration))
-  return model, optimizer, learning_rate, iteration
+    iteration = checkpoint_dict["iteration"]
+    learning_rate = checkpoint_dict["learning_rate"]
+    if (
+        optimizer is not None and load_opt == 1
+    ):  ###加载不了，如果是空的的话，重新初始化，可能还会影响lr时间表的更新，因此在train文件最外围catch
+        #   try:
+        optimizer.load_state_dict(checkpoint_dict["optimizer"])
+    #   except:
+    #     traceback.print_exc()
+    logger.info("Loaded checkpoint '{}' (epoch {})".format(checkpoint_path, iteration))
+    return model, optimizer, learning_rate, iteration
 
 
 def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path):
-  logger.info("Saving model and optimizer state at epoch {} to {}".format(
-    iteration, checkpoint_path))
-  if hasattr(model, 'module'):
-    state_dict = model.module.state_dict()
-  else:
-    state_dict = model.state_dict()
-  torch.save({'model': state_dict,
-              'iteration': iteration,
-              'optimizer': optimizer.state_dict(),
-              'learning_rate': learning_rate}, checkpoint_path)
+    logger.info(
+        "Saving model and optimizer state at epoch {} to {}".format(
+            iteration, checkpoint_path
+        )
+    )
+    if hasattr(model, "module"):
+        state_dict = model.module.state_dict()
+    else:
+        state_dict = model.state_dict()
+    torch.save(
+        {
+            "model": state_dict,
+            "iteration": iteration,
+            "optimizer": optimizer.state_dict(),
+            "learning_rate": learning_rate,
+        },
+        checkpoint_path,
+    )
+
+
 def save_checkpoint_d(combd, sbd, optimizer, learning_rate, iteration, checkpoint_path):
-  logger.info("Saving model and optimizer state at epoch {} to {}".format(
-    iteration, checkpoint_path))
-  if hasattr(combd, 'module'): state_dict_combd = combd.module.state_dict()
-  else:state_dict_combd = combd.state_dict()
-  if hasattr(sbd, 'module'): state_dict_sbd = sbd.module.state_dict()
-  else:state_dict_sbd = sbd.state_dict()
-  torch.save({
-              'combd': state_dict_combd,
-              'sbd': state_dict_sbd,
-              'iteration': iteration,
-              'optimizer': optimizer.state_dict(),
-              'learning_rate': learning_rate}, checkpoint_path)
+    logger.info(
+        "Saving model and optimizer state at epoch {} to {}".format(
+            iteration, checkpoint_path
+        )
+    )
+    if hasattr(combd, "module"):
+        state_dict_combd = combd.module.state_dict()
+    else:
+        state_dict_combd = combd.state_dict()
+    if hasattr(sbd, "module"):
+        state_dict_sbd = sbd.module.state_dict()
+    else:
+        state_dict_sbd = sbd.state_dict()
+    torch.save(
+        {
+            "combd": state_dict_combd,
+            "sbd": state_dict_sbd,
+            "iteration": iteration,
+            "optimizer": optimizer.state_dict(),
+            "learning_rate": learning_rate,
+        },
+        checkpoint_path,
+    )
 
 
-def summarize(writer, global_step, scalars={}, histograms={}, images={}, audios={}, audio_sampling_rate=22050):
-  for k, v in scalars.items():
-    writer.add_scalar(k, v, global_step)
-  for k, v in histograms.items():
-    writer.add_histogram(k, v, global_step)
-  for k, v in images.items():
-    writer.add_image(k, v, global_step, dataformats='HWC')
-  for k, v in audios.items():
-    writer.add_audio(k, v, global_step, audio_sampling_rate)
+def summarize(
+    writer,
+    global_step,
+    scalars={},
+    histograms={},
+    images={},
+    audios={},
+    audio_sampling_rate=22050,
+):
+    for k, v in scalars.items():
+        writer.add_scalar(k, v, global_step)
+    for k, v in histograms.items():
+        writer.add_histogram(k, v, global_step)
+    for k, v in images.items():
+        writer.add_image(k, v, global_step, dataformats="HWC")
+    for k, v in audios.items():
+        writer.add_audio(k, v, global_step, audio_sampling_rate)
 
 
 def latest_checkpoint_path(dir_path, regex="G_*.pth"):
-  f_list = glob.glob(os.path.join(dir_path, regex))
-  f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
-  x = f_list[-1]
-  print(x)
-  return x
+    f_list = glob.glob(os.path.join(dir_path, regex))
+    f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
+    x = f_list[-1]
+    print(x)
+    return x
 
 
 def plot_spectrogram_to_numpy(spectrogram):
-  global MATPLOTLIB_FLAG
-  if not MATPLOTLIB_FLAG:
-    import matplotlib
-    matplotlib.use("Agg")
-    MATPLOTLIB_FLAG = True
-    mpl_logger = logging.getLogger('matplotlib')
-    mpl_logger.setLevel(logging.WARNING)
-  import matplotlib.pylab as plt
-  import numpy as np
-  
-  fig, ax = plt.subplots(figsize=(10,2))
-  im = ax.imshow(spectrogram, aspect="auto", origin="lower",
-                  interpolation='none')
-  plt.colorbar(im, ax=ax)
-  plt.xlabel("Frames")
-  plt.ylabel("Channels")
-  plt.tight_layout()
+    global MATPLOTLIB_FLAG
+    if not MATPLOTLIB_FLAG:
+        import matplotlib
 
-  fig.canvas.draw()
-  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-  plt.close()
-  return data
+        matplotlib.use("Agg")
+        MATPLOTLIB_FLAG = True
+        mpl_logger = logging.getLogger("matplotlib")
+        mpl_logger.setLevel(logging.WARNING)
+    import matplotlib.pylab as plt
+    import numpy as np
+
+    fig, ax = plt.subplots(figsize=(10, 2))
+    im = ax.imshow(spectrogram, aspect="auto", origin="lower", interpolation="none")
+    plt.colorbar(im, ax=ax)
+    plt.xlabel("Frames")
+    plt.ylabel("Channels")
+    plt.tight_layout()
+
+    fig.canvas.draw()
+    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep="")
+    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+    plt.close()
+    return data
 
 
 def plot_alignment_to_numpy(alignment, info=None):
-  global MATPLOTLIB_FLAG
-  if not MATPLOTLIB_FLAG:
-    import matplotlib
-    matplotlib.use("Agg")
-    MATPLOTLIB_FLAG = True
-    mpl_logger = logging.getLogger('matplotlib')
-    mpl_logger.setLevel(logging.WARNING)
-  import matplotlib.pylab as plt
-  import numpy as np
+    global MATPLOTLIB_FLAG
+    if not MATPLOTLIB_FLAG:
+        import matplotlib
 
-  fig, ax = plt.subplots(figsize=(6, 4))
-  im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
-                  interpolation='none')
-  fig.colorbar(im, ax=ax)
-  xlabel = 'Decoder timestep'
-  if info is not None:
-      xlabel += '\n\n' + info
-  plt.xlabel(xlabel)
-  plt.ylabel('Encoder timestep')
-  plt.tight_layout()
+        matplotlib.use("Agg")
+        MATPLOTLIB_FLAG = True
+        mpl_logger = logging.getLogger("matplotlib")
+        mpl_logger.setLevel(logging.WARNING)
+    import matplotlib.pylab as plt
+    import numpy as np
 
-  fig.canvas.draw()
-  data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-  data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-  plt.close()
-  return data
+    fig, ax = plt.subplots(figsize=(6, 4))
+    im = ax.imshow(
+        alignment.transpose(), aspect="auto", origin="lower", interpolation="none"
+    )
+    fig.colorbar(im, ax=ax)
+    xlabel = "Decoder timestep"
+    if info is not None:
+        xlabel += "\n\n" + info
+    plt.xlabel(xlabel)
+    plt.ylabel("Encoder timestep")
+    plt.tight_layout()
+
+    fig.canvas.draw()
+    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep="")
+    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+    plt.close()
+    return data
 
 
 def load_wav_to_torch(full_path):
-  sampling_rate, data = read(full_path)
-  return torch.FloatTensor(data.astype(np.float32)), sampling_rate
+    sampling_rate, data = read(full_path)
+    return torch.FloatTensor(data.astype(np.float32)), sampling_rate
 
 
 def load_filepaths_and_text(filename, split="|"):
-  with open(filename, encoding='utf-8') as f:
-    filepaths_and_text = [line.strip().split(split) for line in f]
-  return filepaths_and_text
+    with open(filename, encoding="utf-8") as f:
+        filepaths_and_text = [line.strip().split(split) for line in f]
+    return filepaths_and_text
 
 
 def get_hparams(init=True):
-  '''
-todo:
-  结尾七人组：
-    保存频率、总epoch                     done
-    bs                                    done
-    pretrainG、pretrainD                  done
-    卡号：os.en["CUDA_VISIBLE_DEVICES"]   done
-    if_latest                             todo
-  模型：if_f0                             todo
-  采样率：自动选择config                  done
-  是否缓存数据集进GPU:if_cache_data_in_gpu done
+    """
+    todo:
+      结尾七人组：
+        保存频率、总epoch                     done
+        bs                                    done
+        pretrainG、pretrainD                  done
+        卡号：os.en["CUDA_VISIBLE_DEVICES"]   done
+        if_latest                             todo
+      模型：if_f0                             todo
+      采样率：自动选择config                  done
+      是否缓存数据集进GPU:if_cache_data_in_gpu done
 
-  -m:
-    自动决定training_files路径,改掉train_nsf_load_pretrain.py里的hps.data.training_files    done
-  -c不要了
-  '''
-  parser = argparse.ArgumentParser()
-  # parser.add_argument('-c', '--config', type=str, default="configs/40k.json",help='JSON file for configuration')
-  parser.add_argument('-se', '--save_every_epoch', type=int, required=True,help='checkpoint save frequency (epoch)')
-  parser.add_argument('-te', '--total_epoch', type=int, required=True,help='total_epoch')
-  parser.add_argument('-pg', '--pretrainG', type=str, default="",help='Pretrained Discriminator path')
-  parser.add_argument('-pd', '--pretrainD', type=str, default="",help='Pretrained Generator path')
-  parser.add_argument('-g', '--gpus', type=str, default="0",help='split by -')
-  parser.add_argument('-bs', '--batch_size', type=int, required=True,help='batch size')
-  parser.add_argument('-e', '--experiment_dir', type=str, required=True,help='experiment dir')#-m
-  parser.add_argument('-sr', '--sample_rate', type=str, required=True,help='sample rate, 32k/40k/48k')
-  parser.add_argument('-f0', '--if_f0', type=int, required=True,help='use f0 as one of the inputs of the model, 1 or 0')
-  parser.add_argument('-l', '--if_latest', type=int, required=True,help='if only save the latest G/D pth file, 1 or 0')
-  parser.add_argument('-c', '--if_cache_data_in_gpu', type=int, required=True,help='if caching the dataset in GPU memory, 1 or 0')
+      -m:
+        自动决定training_files路径,改掉train_nsf_load_pretrain.py里的hps.data.training_files    done
+      -c不要了
+    """
+    parser = argparse.ArgumentParser()
+    # parser.add_argument('-c', '--config', type=str, default="configs/40k.json",help='JSON file for configuration')
+    parser.add_argument(
+        "-se",
+        "--save_every_epoch",
+        type=int,
+        required=True,
+        help="checkpoint save frequency (epoch)",
+    )
+    parser.add_argument(
+        "-te", "--total_epoch", type=int, required=True, help="total_epoch"
+    )
+    parser.add_argument(
+        "-pg", "--pretrainG", type=str, default="", help="Pretrained Discriminator path"
+    )
+    parser.add_argument(
+        "-pd", "--pretrainD", type=str, default="", help="Pretrained Generator path"
+    )
+    parser.add_argument("-g", "--gpus", type=str, default="0", help="split by -")
+    parser.add_argument(
+        "-bs", "--batch_size", type=int, required=True, help="batch size"
+    )
+    parser.add_argument(
+        "-e", "--experiment_dir", type=str, required=True, help="experiment dir"
+    )  # -m
+    parser.add_argument(
+        "-sr", "--sample_rate", type=str, required=True, help="sample rate, 32k/40k/48k"
+    )
+    parser.add_argument(
+        "-f0",
+        "--if_f0",
+        type=int,
+        required=True,
+        help="use f0 as one of the inputs of the model, 1 or 0",
+    )
+    parser.add_argument(
+        "-l",
+        "--if_latest",
+        type=int,
+        required=True,
+        help="if only save the latest G/D pth file, 1 or 0",
+    )
+    parser.add_argument(
+        "-c",
+        "--if_cache_data_in_gpu",
+        type=int,
+        required=True,
+        help="if caching the dataset in GPU memory, 1 or 0",
+    )
 
-  args = parser.parse_args()
-  name = args.experiment_dir
-  experiment_dir = os.path.join("./logs", args.experiment_dir)
+    args = parser.parse_args()
+    name = args.experiment_dir
+    experiment_dir = os.path.join("./logs", args.experiment_dir)
 
-  if not os.path.exists(experiment_dir):
-    os.makedirs(experiment_dir)
+    if not os.path.exists(experiment_dir):
+        os.makedirs(experiment_dir)
 
-  config_path = "configs/%s.json"%args.sample_rate
-  config_save_path = os.path.join(experiment_dir, "config.json")
-  if init:
-    with open(config_path, "r") as f:
-      data = f.read()
-    with open(config_save_path, "w") as f:
-      f.write(data)
-  else:
-    with open(config_save_path, "r") as f:
-      data = f.read()
-  config = json.loads(data)
+    config_path = "configs/%s.json" % args.sample_rate
+    config_save_path = os.path.join(experiment_dir, "config.json")
+    if init:
+        with open(config_path, "r") as f:
+            data = f.read()
+        with open(config_save_path, "w") as f:
+            f.write(data)
+    else:
+        with open(config_save_path, "r") as f:
+            data = f.read()
+    config = json.loads(data)
 
-  hparams = HParams(**config)
-  hparams.model_dir = hparams.experiment_dir = experiment_dir
-  hparams.save_every_epoch = args.save_every_epoch
-  hparams.name = name
-  hparams.total_epoch = args.total_epoch
-  hparams.pretrainG = args.pretrainG
-  hparams.pretrainD = args.pretrainD
-  hparams.gpus = args.gpus
-  hparams.train.batch_size = args.batch_size
-  hparams.sample_rate = args.sample_rate
-  hparams.if_f0 = args.if_f0
-  hparams.if_latest = args.if_latest
-  hparams.if_cache_data_in_gpu = args.if_cache_data_in_gpu
-  hparams.data.training_files = "%s/filelist.txt"%experiment_dir
-  return hparams
+    hparams = HParams(**config)
+    hparams.model_dir = hparams.experiment_dir = experiment_dir
+    hparams.save_every_epoch = args.save_every_epoch
+    hparams.name = name
+    hparams.total_epoch = args.total_epoch
+    hparams.pretrainG = args.pretrainG
+    hparams.pretrainD = args.pretrainD
+    hparams.gpus = args.gpus
+    hparams.train.batch_size = args.batch_size
+    hparams.sample_rate = args.sample_rate
+    hparams.if_f0 = args.if_f0
+    hparams.if_latest = args.if_latest
+    hparams.if_cache_data_in_gpu = args.if_cache_data_in_gpu
+    hparams.data.training_files = "%s/filelist.txt" % experiment_dir
+    return hparams
 
 
 def get_hparams_from_dir(model_dir):
-  config_save_path = os.path.join(model_dir, "config.json")
-  with open(config_save_path, "r") as f:
-    data = f.read()
-  config = json.loads(data)
+    config_save_path = os.path.join(model_dir, "config.json")
+    with open(config_save_path, "r") as f:
+        data = f.read()
+    config = json.loads(data)
 
-  hparams =HParams(**config)
-  hparams.model_dir = model_dir
-  return hparams
+    hparams = HParams(**config)
+    hparams.model_dir = model_dir
+    return hparams
 
 
 def get_hparams_from_file(config_path):
-  with open(config_path, "r") as f:
-    data = f.read()
-  config = json.loads(data)
+    with open(config_path, "r") as f:
+        data = f.read()
+    config = json.loads(data)
 
-  hparams =HParams(**config)
-  return hparams
+    hparams = HParams(**config)
+    return hparams
 
 
 def check_git_hash(model_dir):
-  source_dir = os.path.dirname(os.path.realpath(__file__))
-  if not os.path.exists(os.path.join(source_dir, ".git")):
-    logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
-      source_dir
-    ))
-    return
+    source_dir = os.path.dirname(os.path.realpath(__file__))
+    if not os.path.exists(os.path.join(source_dir, ".git")):
+        logger.warn(
+            "{} is not a git repository, therefore hash value comparison will be ignored.".format(
+                source_dir
+            )
+        )
+        return
 
-  cur_hash = subprocess.getoutput("git rev-parse HEAD")
+    cur_hash = subprocess.getoutput("git rev-parse HEAD")
 
-  path = os.path.join(model_dir, "githash")
-  if os.path.exists(path):
-    saved_hash = open(path).read()
-    if saved_hash != cur_hash:
-      logger.warn("git hash values are different. {}(saved) != {}(current)".format(
-        saved_hash[:8], cur_hash[:8]))
-  else:
-    open(path, "w").write(cur_hash)
+    path = os.path.join(model_dir, "githash")
+    if os.path.exists(path):
+        saved_hash = open(path).read()
+        if saved_hash != cur_hash:
+            logger.warn(
+                "git hash values are different. {}(saved) != {}(current)".format(
+                    saved_hash[:8], cur_hash[:8]
+                )
+            )
+    else:
+        open(path, "w").write(cur_hash)
 
 
 def get_logger(model_dir, filename="train.log"):
-  global logger
-  logger = logging.getLogger(os.path.basename(model_dir))
-  logger.setLevel(logging.DEBUG)
-  
-  formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
-  if not os.path.exists(model_dir):
-    os.makedirs(model_dir)
-  h = logging.FileHandler(os.path.join(model_dir, filename))
-  h.setLevel(logging.DEBUG)
-  h.setFormatter(formatter)
-  logger.addHandler(h)
-  return logger
+    global logger
+    logger = logging.getLogger(os.path.basename(model_dir))
+    logger.setLevel(logging.DEBUG)
+
+    formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
+    if not os.path.exists(model_dir):
+        os.makedirs(model_dir)
+    h = logging.FileHandler(os.path.join(model_dir, filename))
+    h.setLevel(logging.DEBUG)
+    h.setFormatter(formatter)
+    logger.addHandler(h)
+    return logger
 
 
-class HParams():
-  def __init__(self, **kwargs):
-    for k, v in kwargs.items():
-      if type(v) == dict:
-        v = HParams(**v)
-      self[k] = v
-    
-  def keys(self):
-    return self.__dict__.keys()
+class HParams:
+    def __init__(self, **kwargs):
+        for k, v in kwargs.items():
+            if type(v) == dict:
+                v = HParams(**v)
+            self[k] = v
 
-  def items(self):
-    return self.__dict__.items()
+    def keys(self):
+        return self.__dict__.keys()
 
-  def values(self):
-    return self.__dict__.values()
+    def items(self):
+        return self.__dict__.items()
 
-  def __len__(self):
-    return len(self.__dict__)
+    def values(self):
+        return self.__dict__.values()
 
-  def __getitem__(self, key):
-    return getattr(self, key)
+    def __len__(self):
+        return len(self.__dict__)
 
-  def __setitem__(self, key, value):
-    return setattr(self, key, value)
+    def __getitem__(self, key):
+        return getattr(self, key)
 
-  def __contains__(self, key):
-    return key in self.__dict__
+    def __setitem__(self, key, value):
+        return setattr(self, key, value)
 
-  def __repr__(self):
-    return self.__dict__.__repr__()
+    def __contains__(self, key):
+        return key in self.__dict__
+
+    def __repr__(self):
+        return self.__dict__.__repr__()

train_nsf_sim_cache_sid_load_pretrain.py

@@ -1,12 +1,15 @@
-import sys,os
-now_dir=os.getcwd()
-sys.path.append(os.path.join(now_dir,"train"))
+import sys, os
+
+now_dir = os.getcwd()
+sys.path.append(os.path.join(now_dir, "train"))
 import utils
+
 hps = utils.get_hparams()
-os.environ["CUDA_VISIBLE_DEVICES"]=hps.gpus.replace("-",",")
-n_gpus=len(hps.gpus.split("-"))
+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
+import traceback, json, argparse, itertools, math, torch, pdb
+
 torch.backends.cudnn.deterministic = False
 torch.backends.cudnn.benchmark = False
 from torch import nn, optim
@@ -18,11 +21,18 @@ 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
+from data_utils import (
+    TextAudioLoaderMultiNSFsid,
+    TextAudioLoader,
+    TextAudioCollateMultiNSFsid,
+    TextAudioCollate,
+    DistributedBucketSampler,
+)
 from infer_pack.models import (
-    SynthesizerTrnMs256NSFsid,SynthesizerTrnMs256NSFsid_nono,
+    SynthesizerTrnMs256NSFsid,
+    SynthesizerTrnMs256NSFsid_nono,
     MultiPeriodDiscriminator,
 )
 from losses import generator_loss, discriminator_loss, feature_loss, kl_loss
@@ -32,12 +42,10 @@ from mel_processing import mel_spectrogram_torch, spec_to_mel_torch
 global_step = 0
 
 
-
 def main():
     # n_gpus = torch.cuda.device_count()
     os.environ["MASTER_ADDR"] = "localhost"
-    os.environ["MASTER_PORT"] = "5555"
-
+    os.environ["MASTER_PORT"] = "51545"
 
     mp.spawn(
         run,
@@ -62,13 +70,16 @@ def run(rank, n_gpus, hps):
         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 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)
+    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,
+        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,
@@ -77,8 +88,10 @@ def run(rank, n_gpus, hps):
     )
     # 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()
+    if hps.if_f0 == 1:
+        collate_fn = TextAudioCollateMultiNSFsid()
+    else:
+        collate_fn = TextAudioCollate()
     train_loader = DataLoader(
         train_dataset,
         num_workers=4,
@@ -89,13 +102,26 @@ def run(rank, n_gpus, hps):
         persistent_workers=True,
         prefetch_factor=8,
     )
-    if(hps.if_f0==1):
-        net_g = SynthesizerTrnMs256NSFsid(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)
+    if hps.if_f0 == 1:
+        net_g = SynthesizerTrnMs256NSFsid(
+            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 = SynthesizerTrnMs256NSFsid_nono(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_g = SynthesizerTrnMs256NSFsid_nono(
+            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)
+    if torch.cuda.is_available():
+        net_d = net_d.cuda(rank)
     optim_g = torch.optim.AdamW(
         net_g.parameters(),
         hps.train.learning_rate,
@@ -110,30 +136,42 @@ def run(rank, n_gpus, hps):
     )
     # 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(): 
+    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多半加载没事
+    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)
+        _, _, _, 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()
+    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"]))
+            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
@@ -144,7 +182,7 @@ def run(rank, n_gpus, hps):
 
     scaler = GradScaler(enabled=hps.train.fp16_run)
 
-    cache=[]
+    cache = []
     for epoch in range(epoch_str, hps.train.epochs + 1):
         if rank == 0:
             train_and_evaluate(
@@ -157,7 +195,8 @@ def run(rank, n_gpus, hps):
                 scaler,
                 [train_loader, None],
                 logger,
-                [writer, writer_eval],cache
+                [writer, writer_eval],
+                cache,
             )
         else:
             train_and_evaluate(
@@ -170,14 +209,15 @@ def run(rank, n_gpus, hps):
                 scaler,
                 [train_loader, None],
                 None,
-                None,cache
+                None,
+                cache,
             )
         scheduler_g.step()
         scheduler_d.step()
 
 
 def train_and_evaluate(
-    rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers,cache
+    rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers, cache
 ):
     net_g, net_d = nets
     optim_g, optim_d = optims
@@ -190,324 +230,303 @@ def train_and_evaluate(
 
     net_g.train()
     net_d.train()
-    if(cache==[]or hps.if_cache_data_in_gpu==False):#第一个epoch把cache全部填满训练集
-        # print("caching")
-        for batch_idx, info in enumerate(train_loader):
-            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
-            if torch.cuda.is_available():
-                phone, phone_lengths = phone.cuda(rank, non_blocking=True), phone_lengths.cuda(rank, non_blocking=True )
-                if (hps.if_f0 == 1):pitch,pitchf = pitch.cuda(rank, non_blocking=True),pitchf.cuda(rank, non_blocking=True)
-                sid = sid.cuda(rank, non_blocking=True)
-                spec, spec_lengths = spec.cuda(rank, non_blocking=True), spec_lengths.cuda(rank, non_blocking=True)
-                wave, wave_lengths = wave.cuda(rank, non_blocking=True), wave_lengths.cuda(rank, non_blocking=True)
-            if(hps.if_cache_data_in_gpu==True):
-                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)))
-            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)
+    # 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,
+                            ),
                         )
                     )
-                    # Amor For Tensorboard display
-                    if loss_mel > 50:
-                        loss_mel = 50
-                    if loss_kl > 5:
-                        loss_kl = 5
+                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)
 
-                    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}
-                    )
+    # Run steps
+    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)
 
-                    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
-        # if global_step % hps.train.eval_interval == 0:
-        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)),
-                )
+        # 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:
-                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)),
-                )
-
-    else:#后续的epoch直接使用打乱的cache
-        shuffle(cache)
-        # print("using cache")
-        for batch_idx, info in cache:
-            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
-            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,
+                (
+                    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,
                 )
-                y_mel = commons.slice_segments(
-                    mel, ids_slice, hps.train.segment_size // hps.data.hop_length
+            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
                 )
-                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,
+        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)
                     )
-                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
+                )
+                # Amor For Tensorboard display
+                if loss_mel > 50:
+                    loss_mel = 50
+                if loss_kl > 5:
+                    loss_kl = 5
 
-                # 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 > 50:
-                        loss_mel = 50
-                    if loss_kl > 5:
-                        loss_kl = 5
-
-                    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,
+                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/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
-        # if global_step % hps.train.eval_interval == 0:
-        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)),
                 )
 
+                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:
         logger.info("====> Epoch: {}".format(epoch))
-    if(epoch>=hps.total_epoch):
-        if rank == 0:
-            logger.info("Training is done. The program is closed.")
-            from process_ckpt import savee#def savee(ckpt,sr,if_f0,name,epoch):
-            if hasattr(net_g, 'module'):ckpt = net_g.module.state_dict()
-            else:ckpt = net_g.state_dict()
-            print("saving final ckpt:",savee(ckpt,hps.sample_rate,hps.if_f0,hps.name,epoch))
+    if epoch >= hps.total_epoch and rank == 0:
+        logger.info("Training is done. The program is closed.")
+        from process_ckpt import savee  # def savee(ckpt,sr,if_f0,name,epoch):
+
+        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))
+        )
+        sleep(1)
         os._exit(2333333)
 
 

trainset_preprocess_pipeline_print.py

@@ -1,5 +1,7 @@
-import sys,os,multiprocessing
-now_dir=os.getcwd()
+import sys, os, multiprocessing
+from scipy import signal
+
+now_dir = os.getcwd()
 sys.path.append(now_dir)
 
 inp_root = sys.argv[1]
@@ -7,98 +9,127 @@ sr = int(sys.argv[2])
 n_p = int(sys.argv[3])
 exp_dir = sys.argv[4]
 noparallel = sys.argv[5] == "True"
-import numpy as np,os,traceback
+import numpy as np, os, traceback
 from slicer2 import Slicer
-import librosa,traceback
-from  scipy.io import wavfile
+import librosa, traceback
+from scipy.io import wavfile
 import multiprocessing
 from my_utils import load_audio
 
 mutex = multiprocessing.Lock()
+f = open("%s/preprocess.log" % exp_dir, "a+")
 
-class PreProcess():
-    def __init__(self,sr,exp_dir):
+
+def println(strr):
+    mutex.acquire()
+    print(strr)
+    f.write("%s\n" % strr)
+    f.flush()
+    mutex.release()
+
+
+class PreProcess:
+    def __init__(self, sr, exp_dir):
         self.slicer = Slicer(
             sr=sr,
-            threshold=-32,
+            threshold=-40,
             min_length=800,
             min_interval=400,
             hop_size=15,
-            max_sil_kept=150
+            max_sil_kept=150,
         )
-        self.sr=sr
-        self.per=3.7
-        self.overlap=0.3
-        self.tail=self.per+self.overlap
-        self.max=0.95
-        self.alpha=0.8
-        self.exp_dir=exp_dir
-        self.gt_wavs_dir="%s/0_gt_wavs"%exp_dir
-        self.wavs16k_dir="%s/1_16k_wavs"%exp_dir
-        self.f = open("%s/preprocess.log"%exp_dir, "a+")
-        os.makedirs(self.exp_dir,exist_ok=True)
-        os.makedirs(self.gt_wavs_dir,exist_ok=True)
-        os.makedirs(self.wavs16k_dir,exist_ok=True)
+        self.sr = sr
+        self.bh, self.ah = signal.butter(N=5, Wn=48, btype="high", fs=self.sr)
+        self.per = 3.7
+        self.overlap = 0.3
+        self.tail = self.per + self.overlap
+        self.max = 0.95
+        self.alpha = 0.8
+        self.exp_dir = exp_dir
+        self.gt_wavs_dir = "%s/0_gt_wavs" % exp_dir
+        self.wavs16k_dir = "%s/1_16k_wavs" % exp_dir
+        os.makedirs(self.exp_dir, exist_ok=True)
+        os.makedirs(self.gt_wavs_dir, exist_ok=True)
+        os.makedirs(self.wavs16k_dir, exist_ok=True)
 
-    def print(self, strr):
-        mutex.acquire()
-        print(strr)
-        self.f.write("%s\n" % strr)
-        self.f.flush()
-        mutex.release()
+    def norm_write(self, tmp_audio, idx0, idx1):
+        tmp_audio = (tmp_audio / np.abs(tmp_audio).max() * (self.max * self.alpha)) + (
+            1 - self.alpha
+        ) * tmp_audio
+        wavfile.write(
+            "%s/%s_%s.wav" % (self.gt_wavs_dir, idx0, idx1),
+            self.sr,
+            tmp_audio.astype(np.float32),
+        )
+        tmp_audio = librosa.resample(
+            tmp_audio, orig_sr=self.sr, target_sr=16000
+        )  # , res_type="soxr_vhq"
+        wavfile.write(
+            "%s/%s_%s.wav" % (self.wavs16k_dir, idx0, idx1),
+            16000,
+            tmp_audio.astype(np.float32),
+        )
 
-    def norm_write(self,tmp_audio,idx0,idx1):
-        tmp_audio = (tmp_audio / np.abs(tmp_audio).max() * (self.max * self.alpha)) + (1 - self.alpha) * tmp_audio
-        wavfile.write("%s/%s_%s.wav" % (self.gt_wavs_dir, idx0, idx1), self.sr, (tmp_audio*32768).astype(np.int16))
-        tmp_audio = librosa.resample(tmp_audio, orig_sr=self.sr, target_sr=16000)
-        wavfile.write("%s/%s_%s.wav" % (self.wavs16k_dir, idx0, idx1), 16000, (tmp_audio*32768).astype(np.int16))
-
-    def pipeline(self,path, idx0):
+    def pipeline(self, path, idx0):
         try:
-            audio = load_audio(path,self.sr)
-            idx1=0
+            audio = load_audio(path, self.sr)
+            # zero phased digital filter cause pre-ringing noise...
+            # audio = signal.filtfilt(self.bh, self.ah, audio)
+            audio = signal.lfilter(self.bh, self.ah, audio)
+
+            idx1 = 0
             for audio in self.slicer.slice(audio):
                 i = 0
-                while (1):
+                while 1:
                     start = int(self.sr * (self.per - self.overlap) * i)
                     i += 1
-                    if (len(audio[start:]) > self.tail * self.sr):
-                        tmp_audio = audio[start:start + int(self.per * self.sr)]
-                        self.norm_write(tmp_audio,idx0,idx1)
+                    if len(audio[start:]) > self.tail * self.sr:
+                        tmp_audio = audio[start : start + int(self.per * self.sr)]
+                        self.norm_write(tmp_audio, idx0, idx1)
                         idx1 += 1
                     else:
                         tmp_audio = audio[start:]
+                        idx1 += 1
                         break
                 self.norm_write(tmp_audio, idx0, idx1)
-            self.print("%s->Suc."%path)
+            println("%s->Suc." % path)
         except:
-            self.print("%s->%s"%(path,traceback.format_exc()))
+            println("%s->%s" % (path, traceback.format_exc()))
 
-    def pipeline_mp(self,infos):
+    def pipeline_mp(self, infos):
         for path, idx0 in infos:
-            self.pipeline(path,idx0)
+            self.pipeline(path, idx0)
 
-    def pipeline_mp_inp_dir(self,inp_root,n_p):
+    def pipeline_mp_inp_dir(self, inp_root, n_p):
         try:
-            infos = [("%s/%s" % (inp_root, name), idx) for idx, name in enumerate(sorted(list(os.listdir(inp_root))))]
+            infos = [
+                ("%s/%s" % (inp_root, name), idx)
+                for idx, name in enumerate(sorted(list(os.listdir(inp_root))))
+            ]
             if noparallel:
-                for i in range(n_p): self.pipeline_mp(infos[i::n_p])
-            else:
-                ps=[]
                 for i in range(n_p):
-                    p=multiprocessing.Process(target=self.pipeline_mp,args=(infos[i::n_p],))
+                    self.pipeline_mp(infos[i::n_p])
+            else:
+                ps = []
+                for i in range(n_p):
+                    p = multiprocessing.Process(
+                        target=self.pipeline_mp, args=(infos[i::n_p],)
+                    )
                     p.start()
                     ps.append(p)
-                    for p in ps:p.join()
+                    for p in ps:
+                        p.join()
         except:
-            self.print("Fail. %s"%traceback.format_exc())
+            println("Fail. %s" % traceback.format_exc())
+
 
 def preprocess_trainset(inp_root, sr, n_p, exp_dir):
-    pp=PreProcess(sr,exp_dir)
-    pp.print("start preprocess")
-    pp.print(sys.argv)
-    pp.pipeline_mp_inp_dir(inp_root,n_p)
-    pp.print("end preprocess")
+    pp = PreProcess(sr, exp_dir)
+    println("start preprocess")
+    println(sys.argv)
+    pp.pipeline_mp_inp_dir(inp_root, n_p)
+    println("end preprocess")
 
-if __name__=='__main__':
+
+if __name__ == "__main__":
     preprocess_trainset(inp_root, sr, n_p, exp_dir)

uvr5_pack/lib_v5/dataset.py

@@ -10,7 +10,6 @@ from uvr5_pack.lib_v5 import spec_utils
 
 
 class VocalRemoverValidationSet(torch.utils.data.Dataset):
-
     def __init__(self, patch_list):
         self.patch_list = patch_list
 
@@ -21,7 +20,7 @@ class VocalRemoverValidationSet(torch.utils.data.Dataset):
         path = self.patch_list[idx]
         data = np.load(path)
 
-        X, y = data['X'], data['y']
+        X, y = data["X"], data["y"]
 
         X_mag = np.abs(X)
         y_mag = np.abs(y)
@@ -30,16 +29,22 @@ class VocalRemoverValidationSet(torch.utils.data.Dataset):
 
 
 def make_pair(mix_dir, inst_dir):
-    input_exts = ['.wav', '.m4a', '.mp3', '.mp4', '.flac']
+    input_exts = [".wav", ".m4a", ".mp3", ".mp4", ".flac"]
 
-    X_list = sorted([
-        os.path.join(mix_dir, fname)
-        for fname in os.listdir(mix_dir)
-        if os.path.splitext(fname)[1] in input_exts])
-    y_list = sorted([
-        os.path.join(inst_dir, fname)
-        for fname in os.listdir(inst_dir)
-        if os.path.splitext(fname)[1] in input_exts])
+    X_list = sorted(
+        [
+            os.path.join(mix_dir, fname)
+            for fname in os.listdir(mix_dir)
+            if os.path.splitext(fname)[1] in input_exts
+        ]
+    )
+    y_list = sorted(
+        [
+            os.path.join(inst_dir, fname)
+            for fname in os.listdir(inst_dir)
+            if os.path.splitext(fname)[1] in input_exts
+        ]
+    )
 
     filelist = list(zip(X_list, y_list))
 
@@ -47,10 +52,11 @@ def make_pair(mix_dir, inst_dir):
 
 
 def train_val_split(dataset_dir, split_mode, val_rate, val_filelist):
-    if split_mode == 'random':
+    if split_mode == "random":
         filelist = make_pair(
-            os.path.join(dataset_dir, 'mixtures'),
-            os.path.join(dataset_dir, 'instruments'))
+            os.path.join(dataset_dir, "mixtures"),
+            os.path.join(dataset_dir, "instruments"),
+        )
 
         random.shuffle(filelist)
 
@@ -60,19 +66,23 @@ def train_val_split(dataset_dir, split_mode, val_rate, val_filelist):
             val_filelist = filelist[-val_size:]
         else:
             train_filelist = [
-                pair for pair in filelist
-                if list(pair) not in val_filelist]
-    elif split_mode == 'subdirs':
+                pair for pair in filelist if list(pair) not in val_filelist
+            ]
+    elif split_mode == "subdirs":
         if len(val_filelist) != 0:
-            raise ValueError('The `val_filelist` option is not available in `subdirs` mode')
+            raise ValueError(
+                "The `val_filelist` option is not available in `subdirs` mode"
+            )
 
         train_filelist = make_pair(
-            os.path.join(dataset_dir, 'training/mixtures'),
-            os.path.join(dataset_dir, 'training/instruments'))
+            os.path.join(dataset_dir, "training/mixtures"),
+            os.path.join(dataset_dir, "training/instruments"),
+        )
 
         val_filelist = make_pair(
-            os.path.join(dataset_dir, 'validation/mixtures'),
-            os.path.join(dataset_dir, 'validation/instruments'))
+            os.path.join(dataset_dir, "validation/mixtures"),
+            os.path.join(dataset_dir, "validation/instruments"),
+        )
 
     return train_filelist, val_filelist
 
@@ -81,7 +91,9 @@ def augment(X, y, reduction_rate, reduction_mask, mixup_rate, mixup_alpha):
     perm = np.random.permutation(len(X))
     for i, idx in enumerate(tqdm(perm)):
         if np.random.uniform() < reduction_rate:
-            y[idx] = spec_utils.reduce_vocal_aggressively(X[idx], y[idx], reduction_mask)
+            y[idx] = spec_utils.reduce_vocal_aggressively(
+                X[idx], y[idx], reduction_mask
+            )
 
         if np.random.uniform() < 0.5:
             # swap channel
@@ -116,10 +128,8 @@ def make_padding(width, cropsize, offset):
 def make_training_set(filelist, cropsize, patches, sr, hop_length, n_fft, offset):
     len_dataset = patches * len(filelist)
 
-    X_dataset = np.zeros(
-        (len_dataset, 2, n_fft // 2 + 1, cropsize), dtype=np.complex64)
-    y_dataset = np.zeros(
-        (len_dataset, 2, n_fft // 2 + 1, cropsize), dtype=np.complex64)
+    X_dataset = np.zeros((len_dataset, 2, n_fft // 2 + 1, cropsize), dtype=np.complex64)
+    y_dataset = np.zeros((len_dataset, 2, n_fft // 2 + 1, cropsize), dtype=np.complex64)
 
     for i, (X_path, y_path) in enumerate(tqdm(filelist)):
         X, y = spec_utils.cache_or_load(X_path, y_path, sr, hop_length, n_fft)
@@ -127,22 +137,24 @@ def make_training_set(filelist, cropsize, patches, sr, hop_length, n_fft, offset
         X, y = X / coef, y / coef
 
         l, r, roi_size = make_padding(X.shape[2], cropsize, offset)
-        X_pad = np.pad(X, ((0, 0), (0, 0), (l, r)), mode='constant')
-        y_pad = np.pad(y, ((0, 0), (0, 0), (l, r)), mode='constant')
+        X_pad = np.pad(X, ((0, 0), (0, 0), (l, r)), mode="constant")
+        y_pad = np.pad(y, ((0, 0), (0, 0), (l, r)), mode="constant")
 
         starts = np.random.randint(0, X_pad.shape[2] - cropsize, patches)
         ends = starts + cropsize
         for j in range(patches):
             idx = i * patches + j
-            X_dataset[idx] = X_pad[:, :, starts[j]:ends[j]]
-            y_dataset[idx] = y_pad[:, :, starts[j]:ends[j]]
+            X_dataset[idx] = X_pad[:, :, starts[j] : ends[j]]
+            y_dataset[idx] = y_pad[:, :, starts[j] : ends[j]]
 
     return X_dataset, y_dataset
 
 
 def make_validation_set(filelist, cropsize, sr, hop_length, n_fft, offset):
     patch_list = []
-    patch_dir = 'cs{}_sr{}_hl{}_nf{}_of{}'.format(cropsize, sr, hop_length, n_fft, offset)
+    patch_dir = "cs{}_sr{}_hl{}_nf{}_of{}".format(
+        cropsize, sr, hop_length, n_fft, offset
+    )
     os.makedirs(patch_dir, exist_ok=True)
 
     for i, (X_path, y_path) in enumerate(tqdm(filelist)):
@@ -153,18 +165,19 @@ def make_validation_set(filelist, cropsize, sr, hop_length, n_fft, offset):
         X, y = X / coef, y / coef
 
         l, r, roi_size = make_padding(X.shape[2], cropsize, offset)
-        X_pad = np.pad(X, ((0, 0), (0, 0), (l, r)), mode='constant')
-        y_pad = np.pad(y, ((0, 0), (0, 0), (l, r)), mode='constant')
+        X_pad = np.pad(X, ((0, 0), (0, 0), (l, r)), mode="constant")
+        y_pad = np.pad(y, ((0, 0), (0, 0), (l, r)), mode="constant")
 
         len_dataset = int(np.ceil(X.shape[2] / roi_size))
         for j in range(len_dataset):
-            outpath = os.path.join(patch_dir, '{}_p{}.npz'.format(basename, j))
+            outpath = os.path.join(patch_dir, "{}_p{}.npz".format(basename, j))
             start = j * roi_size
             if not os.path.exists(outpath):
                 np.savez(
                     outpath,
-                    X=X_pad[:, :, start:start + cropsize],
-                    y=y_pad[:, :, start:start + cropsize])
+                    X=X_pad[:, :, start : start + cropsize],
+                    y=y_pad[:, :, start : start + cropsize],
+                )
             patch_list.append(outpath)
 
     return VocalRemoverValidationSet(patch_list)

uvr5_pack/lib_v5/layers.py

@@ -6,19 +6,20 @@ from uvr5_pack.lib_v5 import spec_utils
 
 
 class Conv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(Conv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nout,
+                nin,
+                nout,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
-                bias=False),
+                bias=False,
+            ),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -26,24 +27,22 @@ class Conv2DBNActiv(nn.Module):
 
 
 class SeperableConv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(SeperableConv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nin,
+                nin,
+                nin,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
                 groups=nin,
-                bias=False),
-            nn.Conv2d(
-                nin, nout,
-                kernel_size=1,
-                bias=False),
+                bias=False,
+            ),
+            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -51,7 +50,6 @@ class SeperableConv2DBNActiv(nn.Module):
 
 
 class Encoder(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
         super(Encoder, self).__init__()
         self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
@@ -65,14 +63,15 @@ class Encoder(nn.Module):
 
 
 class Decoder(nn.Module):
-
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False):
+    def __init__(
+        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
+    ):
         super(Decoder, self).__init__()
         self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
         self.dropout = nn.Dropout2d(0.1) if dropout else None
 
     def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode='bilinear', align_corners=True)
+        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
         if skip is not None:
             skip = spec_utils.crop_center(skip, x)
             x = torch.cat([x, skip], dim=1)
@@ -85,28 +84,31 @@ class Decoder(nn.Module):
 
 
 class ASPPModule(nn.Module):
-
     def __init__(self, nin, nout, dilations=(4, 8, 16), activ=nn.ReLU):
         super(ASPPModule, self).__init__()
         self.conv1 = nn.Sequential(
             nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
+            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
         )
         self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
         self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ)
+            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
+        )
         self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ)
+            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
+        )
         self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ),
-            nn.Dropout2d(0.1)
+            Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
         )
 
     def forward(self, x):
         _, _, h, w = x.size()
-        feat1 = F.interpolate(self.conv1(x), size=(h, w), mode='bilinear', align_corners=True)
+        feat1 = F.interpolate(
+            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
+        )
         feat2 = self.conv2(x)
         feat3 = self.conv3(x)
         feat4 = self.conv4(x)

uvr5_pack/lib_v5/layers_123812KB .py

@@ -6,19 +6,20 @@ from uvr5_pack.lib_v5 import spec_utils
 
 
 class Conv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(Conv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nout,
+                nin,
+                nout,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
-                bias=False),
+                bias=False,
+            ),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -26,24 +27,22 @@ class Conv2DBNActiv(nn.Module):
 
 
 class SeperableConv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(SeperableConv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nin,
+                nin,
+                nin,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
                 groups=nin,
-                bias=False),
-            nn.Conv2d(
-                nin, nout,
-                kernel_size=1,
-                bias=False),
+                bias=False,
+            ),
+            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -51,7 +50,6 @@ class SeperableConv2DBNActiv(nn.Module):
 
 
 class Encoder(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
         super(Encoder, self).__init__()
         self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
@@ -65,14 +63,15 @@ class Encoder(nn.Module):
 
 
 class Decoder(nn.Module):
-
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False):
+    def __init__(
+        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
+    ):
         super(Decoder, self).__init__()
         self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
         self.dropout = nn.Dropout2d(0.1) if dropout else None
 
     def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode='bilinear', align_corners=True)
+        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
         if skip is not None:
             skip = spec_utils.crop_center(skip, x)
             x = torch.cat([x, skip], dim=1)
@@ -85,28 +84,31 @@ class Decoder(nn.Module):
 
 
 class ASPPModule(nn.Module):
-
     def __init__(self, nin, nout, dilations=(4, 8, 16), activ=nn.ReLU):
         super(ASPPModule, self).__init__()
         self.conv1 = nn.Sequential(
             nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
+            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
         )
         self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
         self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ)
+            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
+        )
         self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ)
+            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
+        )
         self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ),
-            nn.Dropout2d(0.1)
+            Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
         )
 
     def forward(self, x):
         _, _, h, w = x.size()
-        feat1 = F.interpolate(self.conv1(x), size=(h, w), mode='bilinear', align_corners=True)
+        feat1 = F.interpolate(
+            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
+        )
         feat2 = self.conv2(x)
         feat3 = self.conv3(x)
         feat4 = self.conv4(x)

uvr5_pack/lib_v5/layers_123821KB.py

@@ -6,19 +6,20 @@ from uvr5_pack.lib_v5 import spec_utils
 
 
 class Conv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(Conv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nout,
+                nin,
+                nout,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
-                bias=False),
+                bias=False,
+            ),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -26,24 +27,22 @@ class Conv2DBNActiv(nn.Module):
 
 
 class SeperableConv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(SeperableConv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nin,
+                nin,
+                nin,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
                 groups=nin,
-                bias=False),
-            nn.Conv2d(
-                nin, nout,
-                kernel_size=1,
-                bias=False),
+                bias=False,
+            ),
+            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -51,7 +50,6 @@ class SeperableConv2DBNActiv(nn.Module):
 
 
 class Encoder(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
         super(Encoder, self).__init__()
         self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
@@ -65,14 +63,15 @@ class Encoder(nn.Module):
 
 
 class Decoder(nn.Module):
-
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False):
+    def __init__(
+        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
+    ):
         super(Decoder, self).__init__()
         self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
         self.dropout = nn.Dropout2d(0.1) if dropout else None
 
     def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode='bilinear', align_corners=True)
+        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
         if skip is not None:
             skip = spec_utils.crop_center(skip, x)
             x = torch.cat([x, skip], dim=1)
@@ -85,28 +84,31 @@ class Decoder(nn.Module):
 
 
 class ASPPModule(nn.Module):
-
     def __init__(self, nin, nout, dilations=(4, 8, 16), activ=nn.ReLU):
         super(ASPPModule, self).__init__()
         self.conv1 = nn.Sequential(
             nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
+            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
         )
         self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
         self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ)
+            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
+        )
         self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ)
+            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
+        )
         self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ),
-            nn.Dropout2d(0.1)
+            Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
         )
 
     def forward(self, x):
         _, _, h, w = x.size()
-        feat1 = F.interpolate(self.conv1(x), size=(h, w), mode='bilinear', align_corners=True)
+        feat1 = F.interpolate(
+            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
+        )
         feat2 = self.conv2(x)
         feat3 = self.conv3(x)
         feat4 = self.conv4(x)

uvr5_pack/lib_v5/layers_33966KB.py

@@ -6,19 +6,20 @@ from uvr5_pack.lib_v5 import spec_utils
 
 
 class Conv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(Conv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nout,
+                nin,
+                nout,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
-                bias=False),
+                bias=False,
+            ),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -26,24 +27,22 @@ class Conv2DBNActiv(nn.Module):
 
 
 class SeperableConv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(SeperableConv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nin,
+                nin,
+                nin,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
                 groups=nin,
-                bias=False),
-            nn.Conv2d(
-                nin, nout,
-                kernel_size=1,
-                bias=False),
+                bias=False,
+            ),
+            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -51,7 +50,6 @@ class SeperableConv2DBNActiv(nn.Module):
 
 
 class Encoder(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
         super(Encoder, self).__init__()
         self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
@@ -65,14 +63,15 @@ class Encoder(nn.Module):
 
 
 class Decoder(nn.Module):
-
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False):
+    def __init__(
+        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
+    ):
         super(Decoder, self).__init__()
         self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
         self.dropout = nn.Dropout2d(0.1) if dropout else None
 
     def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode='bilinear', align_corners=True)
+        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
         if skip is not None:
             skip = spec_utils.crop_center(skip, x)
             x = torch.cat([x, skip], dim=1)
@@ -85,32 +84,37 @@ class Decoder(nn.Module):
 
 
 class ASPPModule(nn.Module):
-
     def __init__(self, nin, nout, dilations=(4, 8, 16, 32, 64), activ=nn.ReLU):
         super(ASPPModule, self).__init__()
         self.conv1 = nn.Sequential(
             nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
+            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
         )
         self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
         self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ)
+            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
+        )
         self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ)
+            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
+        )
         self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.conv6 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.conv7 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ),
-            nn.Dropout2d(0.1)
+            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
         )
 
     def forward(self, x):
         _, _, h, w = x.size()
-        feat1 = F.interpolate(self.conv1(x), size=(h, w), mode='bilinear', align_corners=True)
+        feat1 = F.interpolate(
+            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
+        )
         feat2 = self.conv2(x)
         feat3 = self.conv3(x)
         feat4 = self.conv4(x)

uvr5_pack/lib_v5/layers_537227KB.py

@@ -6,19 +6,20 @@ from uvr5_pack.lib_v5 import spec_utils
 
 
 class Conv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(Conv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nout,
+                nin,
+                nout,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
-                bias=False),
+                bias=False,
+            ),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -26,24 +27,22 @@ class Conv2DBNActiv(nn.Module):
 
 
 class SeperableConv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(SeperableConv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nin,
+                nin,
+                nin,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
                 groups=nin,
-                bias=False),
-            nn.Conv2d(
-                nin, nout,
-                kernel_size=1,
-                bias=False),
+                bias=False,
+            ),
+            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -51,7 +50,6 @@ class SeperableConv2DBNActiv(nn.Module):
 
 
 class Encoder(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
         super(Encoder, self).__init__()
         self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
@@ -65,14 +63,15 @@ class Encoder(nn.Module):
 
 
 class Decoder(nn.Module):
-
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False):
+    def __init__(
+        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
+    ):
         super(Decoder, self).__init__()
         self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
         self.dropout = nn.Dropout2d(0.1) if dropout else None
 
     def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode='bilinear', align_corners=True)
+        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
         if skip is not None:
             skip = spec_utils.crop_center(skip, x)
             x = torch.cat([x, skip], dim=1)
@@ -85,32 +84,37 @@ class Decoder(nn.Module):
 
 
 class ASPPModule(nn.Module):
-
     def __init__(self, nin, nout, dilations=(4, 8, 16, 32, 64), activ=nn.ReLU):
         super(ASPPModule, self).__init__()
         self.conv1 = nn.Sequential(
             nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
+            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
         )
         self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
         self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ)
+            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
+        )
         self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ)
+            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
+        )
         self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.conv6 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.conv7 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ),
-            nn.Dropout2d(0.1)
+            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
         )
 
     def forward(self, x):
         _, _, h, w = x.size()
-        feat1 = F.interpolate(self.conv1(x), size=(h, w), mode='bilinear', align_corners=True)
+        feat1 = F.interpolate(
+            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
+        )
         feat2 = self.conv2(x)
         feat3 = self.conv3(x)
         feat4 = self.conv4(x)

uvr5_pack/lib_v5/layers_537238KB.py

@@ -6,19 +6,20 @@ from uvr5_pack.lib_v5 import spec_utils
 
 
 class Conv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(Conv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nout,
+                nin,
+                nout,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
-                bias=False),
+                bias=False,
+            ),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -26,24 +27,22 @@ class Conv2DBNActiv(nn.Module):
 
 
 class SeperableConv2DBNActiv(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
         super(SeperableConv2DBNActiv, self).__init__()
         self.conv = nn.Sequential(
             nn.Conv2d(
-                nin, nin,
+                nin,
+                nin,
                 kernel_size=ksize,
                 stride=stride,
                 padding=pad,
                 dilation=dilation,
                 groups=nin,
-                bias=False),
-            nn.Conv2d(
-                nin, nout,
-                kernel_size=1,
-                bias=False),
+                bias=False,
+            ),
+            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
             nn.BatchNorm2d(nout),
-            activ()
+            activ(),
         )
 
     def __call__(self, x):
@@ -51,7 +50,6 @@ class SeperableConv2DBNActiv(nn.Module):
 
 
 class Encoder(nn.Module):
-
     def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
         super(Encoder, self).__init__()
         self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
@@ -65,14 +63,15 @@ class Encoder(nn.Module):
 
 
 class Decoder(nn.Module):
-
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False):
+    def __init__(
+        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
+    ):
         super(Decoder, self).__init__()
         self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
         self.dropout = nn.Dropout2d(0.1) if dropout else None
 
     def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode='bilinear', align_corners=True)
+        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
         if skip is not None:
             skip = spec_utils.crop_center(skip, x)
             x = torch.cat([x, skip], dim=1)
@@ -85,32 +84,37 @@ class Decoder(nn.Module):
 
 
 class ASPPModule(nn.Module):
-
     def __init__(self, nin, nout, dilations=(4, 8, 16, 32, 64), activ=nn.ReLU):
         super(ASPPModule, self).__init__()
         self.conv1 = nn.Sequential(
             nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
+            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
         )
         self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
         self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ)
+            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
+        )
         self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ)
+            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
+        )
         self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.conv6 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.conv7 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ)
+            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
+        )
         self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ),
-            nn.Dropout2d(0.1)
+            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
         )
 
     def forward(self, x):
         _, _, h, w = x.size()
-        feat1 = F.interpolate(self.conv1(x), size=(h, w), mode='bilinear', align_corners=True)
+        feat1 = F.interpolate(
+            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
+        )
         feat2 = self.conv2(x)
         feat3 = self.conv3(x)
         feat4 = self.conv4(x)

uvr5_pack/lib_v5/model_param_init.py

@@ -3,33 +3,33 @@ import os
 import pathlib
 
 default_param = {}
-default_param['bins'] = 768
-default_param['unstable_bins'] = 9 # training only
-default_param['reduction_bins'] = 762 # training only
-default_param['sr'] = 44100
-default_param['pre_filter_start'] = 757
-default_param['pre_filter_stop'] = 768
-default_param['band'] = {}
+default_param["bins"] = 768
+default_param["unstable_bins"] = 9  # training only
+default_param["reduction_bins"] = 762  # training only
+default_param["sr"] = 44100
+default_param["pre_filter_start"] = 757
+default_param["pre_filter_stop"] = 768
+default_param["band"] = {}
 
 
-default_param['band'][1] = {
-    'sr': 11025,
-    'hl': 128,
-    'n_fft': 960,
-    'crop_start': 0,
-    'crop_stop': 245,
-    'lpf_start': 61, # inference only
-    'res_type': 'polyphase'
+default_param["band"][1] = {
+    "sr": 11025,
+    "hl": 128,
+    "n_fft": 960,
+    "crop_start": 0,
+    "crop_stop": 245,
+    "lpf_start": 61,  # inference only
+    "res_type": "polyphase",
 }
 
-default_param['band'][2] = {
-    'sr': 44100,
-    'hl': 512,
-    'n_fft': 1536,
-    'crop_start': 24,
-    'crop_stop': 547,
-    'hpf_start': 81, # inference only
-    'res_type': 'sinc_best'
+default_param["band"][2] = {
+    "sr": 44100,
+    "hl": 512,
+    "n_fft": 1536,
+    "crop_start": 24,
+    "crop_stop": 547,
+    "hpf_start": 81,  # inference only
+    "res_type": "sinc_best",
 }
 
 
@@ -40,21 +40,30 @@ def int_keys(d):
             k = int(k)
         r[k] = v
     return r
-    
+
 
 class ModelParameters(object):
-    def __init__(self, config_path=''):
-        if '.pth' == pathlib.Path(config_path).suffix:
+    def __init__(self, config_path=""):
+        if ".pth" == pathlib.Path(config_path).suffix:
             import zipfile
-            
-            with zipfile.ZipFile(config_path, 'r') as zip:
-                self.param = json.loads(zip.read('param.json'), object_pairs_hook=int_keys)
-        elif '.json' == pathlib.Path(config_path).suffix:
-            with open(config_path, 'r') as f:
+
+            with zipfile.ZipFile(config_path, "r") as zip:
+                self.param = json.loads(
+                    zip.read("param.json"), object_pairs_hook=int_keys
+                )
+        elif ".json" == pathlib.Path(config_path).suffix:
+            with open(config_path, "r") as f:
                 self.param = json.loads(f.read(), object_pairs_hook=int_keys)
         else:
             self.param = default_param
-            
-        for k in ['mid_side', 'mid_side_b', 'mid_side_b2', 'stereo_w', 'stereo_n', 'reverse']:
+
+        for k in [
+            "mid_side",
+            "mid_side_b",
+            "mid_side_b2",
+            "stereo_w",
+            "stereo_n",
+            "reverse",
+        ]:
             if not k in self.param:
-                self.param[k] = False
+                self.param[k] = False

uvr5_pack/lib_v5/nets.py

@@ -7,7 +7,6 @@ from uvr5_pack.lib_v5 import spec_utils
 
 
 class BaseASPPNet(nn.Module):
-
     def __init__(self, nin, ch, dilations=(4, 8, 16)):
         super(BaseASPPNet, self).__init__()
         self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
@@ -39,7 +38,6 @@ class BaseASPPNet(nn.Module):
 
 
 class CascadedASPPNet(nn.Module):
-
     def __init__(self, n_fft):
         super(CascadedASPPNet, self).__init__()
         self.stg1_low_band_net = BaseASPPNet(2, 16)
@@ -64,13 +62,16 @@ class CascadedASPPNet(nn.Module):
         mix = x.detach()
         x = x.clone()
 
-        x = x[:, :, :self.max_bin]
+        x = x[:, :, : self.max_bin]
 
         bandw = x.size()[2] // 2
-        aux1 = torch.cat([
-            self.stg1_low_band_net(x[:, :, :bandw]),
-            self.stg1_high_band_net(x[:, :, bandw:])
-        ], dim=2)
+        aux1 = torch.cat(
+            [
+                self.stg1_low_band_net(x[:, :, :bandw]),
+                self.stg1_high_band_net(x[:, :, bandw:]),
+            ],
+            dim=2,
+        )
 
         h = torch.cat([x, aux1], dim=1)
         aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
@@ -82,24 +83,33 @@ class CascadedASPPNet(nn.Module):
         mask = F.pad(
             input=mask,
             pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode='replicate')
- 
+            mode="replicate",
+        )
+
         if self.training:
             aux1 = torch.sigmoid(self.aux1_out(aux1))
             aux1 = F.pad(
                 input=aux1,
                 pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             aux2 = torch.sigmoid(self.aux2_out(aux2))
             aux2 = F.pad(
                 input=aux2,
                 pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             return mask * mix, aux1 * mix, aux2 * mix
-        else:       
+        else:
             if aggressiveness:
-                mask[:, :, :aggressiveness['split_bin']] = torch.pow(mask[:, :, :aggressiveness['split_bin']], 1 + aggressiveness['value'] / 3)
-                mask[:, :, aggressiveness['split_bin']:] = torch.pow(mask[:, :, aggressiveness['split_bin']:], 1 + aggressiveness['value'])
+                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
+                    mask[:, :, : aggressiveness["split_bin"]],
+                    1 + aggressiveness["value"] / 3,
+                )
+                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
+                    mask[:, :, aggressiveness["split_bin"] :],
+                    1 + aggressiveness["value"],
+                )
 
             return mask * mix
 
@@ -107,7 +117,7 @@ class CascadedASPPNet(nn.Module):
         h = self.forward(x_mag, aggressiveness)
 
         if self.offset > 0:
-            h = h[:, :, :, self.offset:-self.offset]
+            h = h[:, :, :, self.offset : -self.offset]
             assert h.size()[3] > 0
 
         return h

uvr5_pack/lib_v5/nets_123812KB.py

@@ -6,7 +6,6 @@ from uvr5_pack.lib_v5 import layers_123821KB as layers
 
 
 class BaseASPPNet(nn.Module):
-
     def __init__(self, nin, ch, dilations=(4, 8, 16)):
         super(BaseASPPNet, self).__init__()
         self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
@@ -38,7 +37,6 @@ class BaseASPPNet(nn.Module):
 
 
 class CascadedASPPNet(nn.Module):
-
     def __init__(self, n_fft):
         super(CascadedASPPNet, self).__init__()
         self.stg1_low_band_net = BaseASPPNet(2, 32)
@@ -63,13 +61,16 @@ class CascadedASPPNet(nn.Module):
         mix = x.detach()
         x = x.clone()
 
-        x = x[:, :, :self.max_bin]
+        x = x[:, :, : self.max_bin]
 
         bandw = x.size()[2] // 2
-        aux1 = torch.cat([
-            self.stg1_low_band_net(x[:, :, :bandw]),
-            self.stg1_high_band_net(x[:, :, bandw:])
-        ], dim=2)
+        aux1 = torch.cat(
+            [
+                self.stg1_low_band_net(x[:, :, :bandw]),
+                self.stg1_high_band_net(x[:, :, bandw:]),
+            ],
+            dim=2,
+        )
 
         h = torch.cat([x, aux1], dim=1)
         aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
@@ -81,24 +82,33 @@ class CascadedASPPNet(nn.Module):
         mask = F.pad(
             input=mask,
             pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode='replicate')
- 
+            mode="replicate",
+        )
+
         if self.training:
             aux1 = torch.sigmoid(self.aux1_out(aux1))
             aux1 = F.pad(
                 input=aux1,
                 pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             aux2 = torch.sigmoid(self.aux2_out(aux2))
             aux2 = F.pad(
                 input=aux2,
                 pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             return mask * mix, aux1 * mix, aux2 * mix
         else:
             if aggressiveness:
-                mask[:, :, :aggressiveness['split_bin']] = torch.pow(mask[:, :, :aggressiveness['split_bin']], 1 + aggressiveness['value'] / 3)
-                mask[:, :, aggressiveness['split_bin']:] = torch.pow(mask[:, :, aggressiveness['split_bin']:], 1 + aggressiveness['value'])
+                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
+                    mask[:, :, : aggressiveness["split_bin"]],
+                    1 + aggressiveness["value"] / 3,
+                )
+                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
+                    mask[:, :, aggressiveness["split_bin"] :],
+                    1 + aggressiveness["value"],
+                )
 
             return mask * mix
 
@@ -106,7 +116,7 @@ class CascadedASPPNet(nn.Module):
         h = self.forward(x_mag, aggressiveness)
 
         if self.offset > 0:
-            h = h[:, :, :, self.offset:-self.offset]
+            h = h[:, :, :, self.offset : -self.offset]
             assert h.size()[3] > 0
 
         return h

uvr5_pack/lib_v5/nets_123821KB.py

@@ -6,7 +6,6 @@ from uvr5_pack.lib_v5 import layers_123821KB as layers
 
 
 class BaseASPPNet(nn.Module):
-
     def __init__(self, nin, ch, dilations=(4, 8, 16)):
         super(BaseASPPNet, self).__init__()
         self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
@@ -38,7 +37,6 @@ class BaseASPPNet(nn.Module):
 
 
 class CascadedASPPNet(nn.Module):
-
     def __init__(self, n_fft):
         super(CascadedASPPNet, self).__init__()
         self.stg1_low_band_net = BaseASPPNet(2, 32)
@@ -63,13 +61,16 @@ class CascadedASPPNet(nn.Module):
         mix = x.detach()
         x = x.clone()
 
-        x = x[:, :, :self.max_bin]
+        x = x[:, :, : self.max_bin]
 
         bandw = x.size()[2] // 2
-        aux1 = torch.cat([
-            self.stg1_low_band_net(x[:, :, :bandw]),
-            self.stg1_high_band_net(x[:, :, bandw:])
-        ], dim=2)
+        aux1 = torch.cat(
+            [
+                self.stg1_low_band_net(x[:, :, :bandw]),
+                self.stg1_high_band_net(x[:, :, bandw:]),
+            ],
+            dim=2,
+        )
 
         h = torch.cat([x, aux1], dim=1)
         aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
@@ -81,24 +82,33 @@ class CascadedASPPNet(nn.Module):
         mask = F.pad(
             input=mask,
             pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode='replicate')
- 
+            mode="replicate",
+        )
+
         if self.training:
             aux1 = torch.sigmoid(self.aux1_out(aux1))
             aux1 = F.pad(
                 input=aux1,
                 pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             aux2 = torch.sigmoid(self.aux2_out(aux2))
             aux2 = F.pad(
                 input=aux2,
                 pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             return mask * mix, aux1 * mix, aux2 * mix
         else:
             if aggressiveness:
-                mask[:, :, :aggressiveness['split_bin']] = torch.pow(mask[:, :, :aggressiveness['split_bin']], 1 + aggressiveness['value'] / 3)
-                mask[:, :, aggressiveness['split_bin']:] = torch.pow(mask[:, :, aggressiveness['split_bin']:], 1 + aggressiveness['value'])
+                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
+                    mask[:, :, : aggressiveness["split_bin"]],
+                    1 + aggressiveness["value"] / 3,
+                )
+                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
+                    mask[:, :, aggressiveness["split_bin"] :],
+                    1 + aggressiveness["value"],
+                )
 
             return mask * mix
 
@@ -106,7 +116,7 @@ class CascadedASPPNet(nn.Module):
         h = self.forward(x_mag, aggressiveness)
 
         if self.offset > 0:
-            h = h[:, :, :, self.offset:-self.offset]
+            h = h[:, :, :, self.offset : -self.offset]
             assert h.size()[3] > 0
 
         return h

uvr5_pack/lib_v5/nets_33966KB.py

@@ -6,7 +6,6 @@ from uvr5_pack.lib_v5 import layers_33966KB as layers
 
 
 class BaseASPPNet(nn.Module):
-
     def __init__(self, nin, ch, dilations=(4, 8, 16, 32)):
         super(BaseASPPNet, self).__init__()
         self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
@@ -38,7 +37,6 @@ class BaseASPPNet(nn.Module):
 
 
 class CascadedASPPNet(nn.Module):
-
     def __init__(self, n_fft):
         super(CascadedASPPNet, self).__init__()
         self.stg1_low_band_net = BaseASPPNet(2, 16)
@@ -63,13 +61,16 @@ class CascadedASPPNet(nn.Module):
         mix = x.detach()
         x = x.clone()
 
-        x = x[:, :, :self.max_bin]
+        x = x[:, :, : self.max_bin]
 
         bandw = x.size()[2] // 2
-        aux1 = torch.cat([
-            self.stg1_low_band_net(x[:, :, :bandw]),
-            self.stg1_high_band_net(x[:, :, bandw:])
-        ], dim=2)
+        aux1 = torch.cat(
+            [
+                self.stg1_low_band_net(x[:, :, :bandw]),
+                self.stg1_high_band_net(x[:, :, bandw:]),
+            ],
+            dim=2,
+        )
 
         h = torch.cat([x, aux1], dim=1)
         aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
@@ -81,24 +82,33 @@ class CascadedASPPNet(nn.Module):
         mask = F.pad(
             input=mask,
             pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode='replicate')
+            mode="replicate",
+        )
 
         if self.training:
             aux1 = torch.sigmoid(self.aux1_out(aux1))
             aux1 = F.pad(
                 input=aux1,
                 pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             aux2 = torch.sigmoid(self.aux2_out(aux2))
             aux2 = F.pad(
                 input=aux2,
                 pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             return mask * mix, aux1 * mix, aux2 * mix
         else:
             if aggressiveness:
-                mask[:, :, :aggressiveness['split_bin']] = torch.pow(mask[:, :, :aggressiveness['split_bin']], 1 + aggressiveness['value'] / 3)
-                mask[:, :, aggressiveness['split_bin']:] = torch.pow(mask[:, :, aggressiveness['split_bin']:], 1 + aggressiveness['value'])
+                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
+                    mask[:, :, : aggressiveness["split_bin"]],
+                    1 + aggressiveness["value"] / 3,
+                )
+                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
+                    mask[:, :, aggressiveness["split_bin"] :],
+                    1 + aggressiveness["value"],
+                )
 
             return mask * mix
 
@@ -106,7 +116,7 @@ class CascadedASPPNet(nn.Module):
         h = self.forward(x_mag, aggressiveness)
 
         if self.offset > 0:
-            h = h[:, :, :, self.offset:-self.offset]
+            h = h[:, :, :, self.offset : -self.offset]
             assert h.size()[3] > 0
 
         return h

uvr5_pack/lib_v5/nets_537227KB.py

@@ -7,7 +7,6 @@ from uvr5_pack.lib_v5 import layers_537238KB as layers
 
 
 class BaseASPPNet(nn.Module):
-
     def __init__(self, nin, ch, dilations=(4, 8, 16)):
         super(BaseASPPNet, self).__init__()
         self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
@@ -39,7 +38,6 @@ class BaseASPPNet(nn.Module):
 
 
 class CascadedASPPNet(nn.Module):
-
     def __init__(self, n_fft):
         super(CascadedASPPNet, self).__init__()
         self.stg1_low_band_net = BaseASPPNet(2, 64)
@@ -64,13 +62,16 @@ class CascadedASPPNet(nn.Module):
         mix = x.detach()
         x = x.clone()
 
-        x = x[:, :, :self.max_bin]
+        x = x[:, :, : self.max_bin]
 
         bandw = x.size()[2] // 2
-        aux1 = torch.cat([
-            self.stg1_low_band_net(x[:, :, :bandw]),
-            self.stg1_high_band_net(x[:, :, bandw:])
-        ], dim=2)
+        aux1 = torch.cat(
+            [
+                self.stg1_low_band_net(x[:, :, :bandw]),
+                self.stg1_high_band_net(x[:, :, bandw:]),
+            ],
+            dim=2,
+        )
 
         h = torch.cat([x, aux1], dim=1)
         aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
@@ -82,24 +83,33 @@ class CascadedASPPNet(nn.Module):
         mask = F.pad(
             input=mask,
             pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode='replicate')
- 
+            mode="replicate",
+        )
+
         if self.training:
             aux1 = torch.sigmoid(self.aux1_out(aux1))
             aux1 = F.pad(
                 input=aux1,
                 pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             aux2 = torch.sigmoid(self.aux2_out(aux2))
             aux2 = F.pad(
                 input=aux2,
                 pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             return mask * mix, aux1 * mix, aux2 * mix
         else:
             if aggressiveness:
-                mask[:, :, :aggressiveness['split_bin']] = torch.pow(mask[:, :, :aggressiveness['split_bin']], 1 + aggressiveness['value'] / 3)
-                mask[:, :, aggressiveness['split_bin']:] = torch.pow(mask[:, :, aggressiveness['split_bin']:], 1 + aggressiveness['value'])
+                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
+                    mask[:, :, : aggressiveness["split_bin"]],
+                    1 + aggressiveness["value"] / 3,
+                )
+                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
+                    mask[:, :, aggressiveness["split_bin"] :],
+                    1 + aggressiveness["value"],
+                )
 
             return mask * mix
 
@@ -107,7 +117,7 @@ class CascadedASPPNet(nn.Module):
         h = self.forward(x_mag, aggressiveness)
 
         if self.offset > 0:
-            h = h[:, :, :, self.offset:-self.offset]
+            h = h[:, :, :, self.offset : -self.offset]
             assert h.size()[3] > 0
 
         return h

uvr5_pack/lib_v5/nets_537238KB.py

@@ -7,7 +7,6 @@ from uvr5_pack.lib_v5 import layers_537238KB as layers
 
 
 class BaseASPPNet(nn.Module):
-
     def __init__(self, nin, ch, dilations=(4, 8, 16)):
         super(BaseASPPNet, self).__init__()
         self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
@@ -39,7 +38,6 @@ class BaseASPPNet(nn.Module):
 
 
 class CascadedASPPNet(nn.Module):
-
     def __init__(self, n_fft):
         super(CascadedASPPNet, self).__init__()
         self.stg1_low_band_net = BaseASPPNet(2, 64)
@@ -64,13 +62,16 @@ class CascadedASPPNet(nn.Module):
         mix = x.detach()
         x = x.clone()
 
-        x = x[:, :, :self.max_bin]
+        x = x[:, :, : self.max_bin]
 
         bandw = x.size()[2] // 2
-        aux1 = torch.cat([
-            self.stg1_low_band_net(x[:, :, :bandw]),
-            self.stg1_high_band_net(x[:, :, bandw:])
-        ], dim=2)
+        aux1 = torch.cat(
+            [
+                self.stg1_low_band_net(x[:, :, :bandw]),
+                self.stg1_high_band_net(x[:, :, bandw:]),
+            ],
+            dim=2,
+        )
 
         h = torch.cat([x, aux1], dim=1)
         aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
@@ -82,24 +83,33 @@ class CascadedASPPNet(nn.Module):
         mask = F.pad(
             input=mask,
             pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode='replicate')
- 
+            mode="replicate",
+        )
+
         if self.training:
             aux1 = torch.sigmoid(self.aux1_out(aux1))
             aux1 = F.pad(
                 input=aux1,
                 pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             aux2 = torch.sigmoid(self.aux2_out(aux2))
             aux2 = F.pad(
                 input=aux2,
                 pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             return mask * mix, aux1 * mix, aux2 * mix
         else:
             if aggressiveness:
-                mask[:, :, :aggressiveness['split_bin']] = torch.pow(mask[:, :, :aggressiveness['split_bin']], 1 + aggressiveness['value'] / 3)
-                mask[:, :, aggressiveness['split_bin']:] = torch.pow(mask[:, :, aggressiveness['split_bin']:], 1 + aggressiveness['value'])
+                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
+                    mask[:, :, : aggressiveness["split_bin"]],
+                    1 + aggressiveness["value"] / 3,
+                )
+                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
+                    mask[:, :, aggressiveness["split_bin"] :],
+                    1 + aggressiveness["value"],
+                )
 
             return mask * mix
 
@@ -107,7 +117,7 @@ class CascadedASPPNet(nn.Module):
         h = self.forward(x_mag, aggressiveness)
 
         if self.offset > 0:
-            h = h[:, :, :, self.offset:-self.offset]
+            h = h[:, :, :, self.offset : -self.offset]
             assert h.size()[3] > 0
 
         return h

uvr5_pack/lib_v5/nets_61968KB.py

@@ -6,7 +6,6 @@ from uvr5_pack.lib_v5 import layers_123821KB as layers
 
 
 class BaseASPPNet(nn.Module):
-
     def __init__(self, nin, ch, dilations=(4, 8, 16)):
         super(BaseASPPNet, self).__init__()
         self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
@@ -38,7 +37,6 @@ class BaseASPPNet(nn.Module):
 
 
 class CascadedASPPNet(nn.Module):
-
     def __init__(self, n_fft):
         super(CascadedASPPNet, self).__init__()
         self.stg1_low_band_net = BaseASPPNet(2, 32)
@@ -63,13 +61,16 @@ class CascadedASPPNet(nn.Module):
         mix = x.detach()
         x = x.clone()
 
-        x = x[:, :, :self.max_bin]
+        x = x[:, :, : self.max_bin]
 
         bandw = x.size()[2] // 2
-        aux1 = torch.cat([
-            self.stg1_low_band_net(x[:, :, :bandw]),
-            self.stg1_high_band_net(x[:, :, bandw:])
-        ], dim=2)
+        aux1 = torch.cat(
+            [
+                self.stg1_low_band_net(x[:, :, :bandw]),
+                self.stg1_high_band_net(x[:, :, bandw:]),
+            ],
+            dim=2,
+        )
 
         h = torch.cat([x, aux1], dim=1)
         aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
@@ -81,24 +82,33 @@ class CascadedASPPNet(nn.Module):
         mask = F.pad(
             input=mask,
             pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode='replicate')
- 
+            mode="replicate",
+        )
+
         if self.training:
             aux1 = torch.sigmoid(self.aux1_out(aux1))
             aux1 = F.pad(
                 input=aux1,
                 pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             aux2 = torch.sigmoid(self.aux2_out(aux2))
             aux2 = F.pad(
                 input=aux2,
                 pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode='replicate')
+                mode="replicate",
+            )
             return mask * mix, aux1 * mix, aux2 * mix
         else:
             if aggressiveness:
-                mask[:, :, :aggressiveness['split_bin']] = torch.pow(mask[:, :, :aggressiveness['split_bin']], 1 + aggressiveness['value'] / 3)
-                mask[:, :, aggressiveness['split_bin']:] = torch.pow(mask[:, :, aggressiveness['split_bin']:], 1 + aggressiveness['value'])
+                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
+                    mask[:, :, : aggressiveness["split_bin"]],
+                    1 + aggressiveness["value"] / 3,
+                )
+                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
+                    mask[:, :, aggressiveness["split_bin"] :],
+                    1 + aggressiveness["value"],
+                )
 
             return mask * mix
 
@@ -106,7 +116,7 @@ class CascadedASPPNet(nn.Module):
         h = self.forward(x_mag, aggressiveness)
 
         if self.offset > 0:
-            h = h[:, :, :, self.offset:-self.offset]
+            h = h[:, :, :, self.offset : -self.offset]
             assert h.size()[3] > 0
 
         return h

uvr5_pack/lib_v5/spec_utils.py

@@ -1,8 +1,9 @@
-import os,librosa
-import numpy  as  np
-import soundfile  as  sf
+import os, librosa
+import numpy as np
+import soundfile as sf
 from tqdm import tqdm
-import json,math ,hashlib
+import json, math, hashlib
+
 
 def crop_center(h1, h2):
     h1_shape = h1.size()
@@ -11,7 +12,7 @@ def crop_center(h1, h2):
     if h1_shape[3] == h2_shape[3]:
         return h1
     elif h1_shape[3] < h2_shape[3]:
-        raise ValueError('h1_shape[3] must be greater than h2_shape[3]')
+        raise ValueError("h1_shape[3] must be greater than h2_shape[3]")
 
     # s_freq = (h2_shape[2] - h1_shape[2]) // 2
     # e_freq = s_freq + h1_shape[2]
@@ -22,7 +23,9 @@ def crop_center(h1, h2):
     return h1
 
 
-def wave_to_spectrogram(wave, hop_length, n_fft, mid_side=False, mid_side_b2=False, reverse=False):
+def wave_to_spectrogram(
+    wave, hop_length, n_fft, mid_side=False, mid_side_b2=False, reverse=False
+):
     if reverse:
         wave_left = np.flip(np.asfortranarray(wave[0]))
         wave_right = np.flip(np.asfortranarray(wave[1]))
@@ -30,21 +33,23 @@ def wave_to_spectrogram(wave, hop_length, n_fft, mid_side=False, mid_side_b2=Fal
         wave_left = np.asfortranarray(np.add(wave[0], wave[1]) / 2)
         wave_right = np.asfortranarray(np.subtract(wave[0], wave[1]))
     elif mid_side_b2:
-        wave_left = np.asfortranarray(np.add(wave[1], wave[0] * .5))
-        wave_right = np.asfortranarray(np.subtract(wave[0], wave[1] * .5))
+        wave_left = np.asfortranarray(np.add(wave[1], wave[0] * 0.5))
+        wave_right = np.asfortranarray(np.subtract(wave[0], wave[1] * 0.5))
     else:
         wave_left = np.asfortranarray(wave[0])
         wave_right = np.asfortranarray(wave[1])
 
     spec_left = librosa.stft(wave_left, n_fft, hop_length=hop_length)
     spec_right = librosa.stft(wave_right, n_fft, hop_length=hop_length)
-    
+
     spec = np.asfortranarray([spec_left, spec_right])
 
     return spec
-   
-   
-def wave_to_spectrogram_mt(wave, hop_length, n_fft, mid_side=False, mid_side_b2=False, reverse=False):
+
+
+def wave_to_spectrogram_mt(
+    wave, hop_length, n_fft, mid_side=False, mid_side_b2=False, reverse=False
+):
     import threading
 
     if reverse:
@@ -54,62 +59,75 @@ def wave_to_spectrogram_mt(wave, hop_length, n_fft, mid_side=False, mid_side_b2=
         wave_left = np.asfortranarray(np.add(wave[0], wave[1]) / 2)
         wave_right = np.asfortranarray(np.subtract(wave[0], wave[1]))
     elif mid_side_b2:
-        wave_left = np.asfortranarray(np.add(wave[1], wave[0] * .5))
-        wave_right = np.asfortranarray(np.subtract(wave[0], wave[1] * .5))
+        wave_left = np.asfortranarray(np.add(wave[1], wave[0] * 0.5))
+        wave_right = np.asfortranarray(np.subtract(wave[0], wave[1] * 0.5))
     else:
         wave_left = np.asfortranarray(wave[0])
         wave_right = np.asfortranarray(wave[1])
-   
+
     def run_thread(**kwargs):
         global spec_left
         spec_left = librosa.stft(**kwargs)
 
-    thread = threading.Thread(target=run_thread, kwargs={'y': wave_left, 'n_fft': n_fft, 'hop_length': hop_length})
+    thread = threading.Thread(
+        target=run_thread,
+        kwargs={"y": wave_left, "n_fft": n_fft, "hop_length": hop_length},
+    )
     thread.start()
     spec_right = librosa.stft(wave_right, n_fft, hop_length=hop_length)
-    thread.join()   
-    
+    thread.join()
+
     spec = np.asfortranarray([spec_left, spec_right])
 
     return spec
-    
-    
+
+
 def combine_spectrograms(specs, mp):
-    l = min([specs[i].shape[2] for i in specs])    
-    spec_c = np.zeros(shape=(2, mp.param['bins'] + 1, l), dtype=np.complex64)
+    l = min([specs[i].shape[2] for i in specs])
+    spec_c = np.zeros(shape=(2, mp.param["bins"] + 1, l), dtype=np.complex64)
     offset = 0
-    bands_n = len(mp.param['band'])
-    
+    bands_n = len(mp.param["band"])
+
     for d in range(1, bands_n + 1):
-        h = mp.param['band'][d]['crop_stop'] - mp.param['band'][d]['crop_start']
-        spec_c[:, offset:offset+h, :l] = specs[d][:, mp.param['band'][d]['crop_start']:mp.param['band'][d]['crop_stop'], :l]
+        h = mp.param["band"][d]["crop_stop"] - mp.param["band"][d]["crop_start"]
+        spec_c[:, offset : offset + h, :l] = specs[d][
+            :, mp.param["band"][d]["crop_start"] : mp.param["band"][d]["crop_stop"], :l
+        ]
         offset += h
-        
-    if offset > mp.param['bins']:
-        raise ValueError('Too much bins')
-        
+
+    if offset > mp.param["bins"]:
+        raise ValueError("Too much bins")
+
     # lowpass fiter
-    if mp.param['pre_filter_start'] > 0: # and mp.param['band'][bands_n]['res_type'] in ['scipy', 'polyphase']:   
+    if (
+        mp.param["pre_filter_start"] > 0
+    ):  # and mp.param['band'][bands_n]['res_type'] in ['scipy', 'polyphase']:
         if bands_n == 1:
-            spec_c = fft_lp_filter(spec_c, mp.param['pre_filter_start'], mp.param['pre_filter_stop'])
+            spec_c = fft_lp_filter(
+                spec_c, mp.param["pre_filter_start"], mp.param["pre_filter_stop"]
+            )
         else:
-            gp = 1        
-            for b in range(mp.param['pre_filter_start'] + 1, mp.param['pre_filter_stop']):
-                g = math.pow(10, -(b - mp.param['pre_filter_start']) * (3.5 - gp) / 20.0)
+            gp = 1
+            for b in range(
+                mp.param["pre_filter_start"] + 1, mp.param["pre_filter_stop"]
+            ):
+                g = math.pow(
+                    10, -(b - mp.param["pre_filter_start"]) * (3.5 - gp) / 20.0
+                )
                 gp = g
                 spec_c[:, b, :] *= g
-                
-    return np.asfortranarray(spec_c)
-    
 
-def spectrogram_to_image(spec, mode='magnitude'):
-    if mode == 'magnitude':
+    return np.asfortranarray(spec_c)
+
+
+def spectrogram_to_image(spec, mode="magnitude"):
+    if mode == "magnitude":
         if np.iscomplexobj(spec):
             y = np.abs(spec)
         else:
             y = spec
-        y = np.log10(y ** 2 + 1e-8)
-    elif mode == 'phase':
+        y = np.log10(y**2 + 1e-8)
+    elif mode == "phase":
         if np.iscomplexobj(spec):
             y = np.angle(spec)
         else:
@@ -121,9 +139,7 @@ def spectrogram_to_image(spec, mode='magnitude'):
 
     if y.ndim == 3:
         img = img.transpose(1, 2, 0)
-        img = np.concatenate([
-            np.max(img, axis=2, keepdims=True), img
-        ], axis=2)
+        img = np.concatenate([np.max(img, axis=2, keepdims=True), img], axis=2)
 
     return img
 
@@ -136,12 +152,12 @@ def reduce_vocal_aggressively(X, y, softmask):
     v_mask = v_mag_tmp > y_mag_tmp
     y_mag = np.clip(y_mag_tmp - v_mag_tmp * v_mask * softmask, 0, np.inf)
 
-    return y_mag * np.exp(1.j * np.angle(y))
+    return y_mag * np.exp(1.0j * np.angle(y))
 
 
 def mask_silence(mag, ref, thres=0.2, min_range=64, fade_size=32):
     if min_range < fade_size * 2:
-        raise ValueError('min_range must be >= fade_area * 2')
+        raise ValueError("min_range must be >= fade_area * 2")
 
     mag = mag.copy()
 
@@ -159,72 +175,106 @@ def mask_silence(mag, ref, thres=0.2, min_range=64, fade_size=32):
 
             if s != 0:
                 weight = np.linspace(0, 1, fade_size)
-                mag[:, :, s:s + fade_size] += weight * ref[:, :, s:s + fade_size]
+                mag[:, :, s : s + fade_size] += weight * ref[:, :, s : s + fade_size]
             else:
                 s -= fade_size
 
             if e != mag.shape[2]:
                 weight = np.linspace(1, 0, fade_size)
-                mag[:, :, e - fade_size:e] += weight * ref[:, :, e - fade_size:e]
+                mag[:, :, e - fade_size : e] += weight * ref[:, :, e - fade_size : e]
             else:
                 e += fade_size
 
-            mag[:, :, s + fade_size:e - fade_size] += ref[:, :, s + fade_size:e - fade_size]
+            mag[:, :, s + fade_size : e - fade_size] += ref[
+                :, :, s + fade_size : e - fade_size
+            ]
             old_e = e
 
     return mag
-    
+
 
 def align_wave_head_and_tail(a, b):
-    l = min([a[0].size, b[0].size])  
-    
-    return a[:l,:l], b[:l,:l]
-    
+    l = min([a[0].size, b[0].size])
+
+    return a[:l, :l], b[:l, :l]
+
 
 def cache_or_load(mix_path, inst_path, mp):
     mix_basename = os.path.splitext(os.path.basename(mix_path))[0]
     inst_basename = os.path.splitext(os.path.basename(inst_path))[0]
 
-    cache_dir = 'mph{}'.format(hashlib.sha1(json.dumps(mp.param, sort_keys=True).encode('utf-8')).hexdigest())
-    mix_cache_dir = os.path.join('cache', cache_dir)
-    inst_cache_dir = os.path.join('cache', cache_dir)
+    cache_dir = "mph{}".format(
+        hashlib.sha1(json.dumps(mp.param, sort_keys=True).encode("utf-8")).hexdigest()
+    )
+    mix_cache_dir = os.path.join("cache", cache_dir)
+    inst_cache_dir = os.path.join("cache", cache_dir)
 
     os.makedirs(mix_cache_dir, exist_ok=True)
     os.makedirs(inst_cache_dir, exist_ok=True)
 
-    mix_cache_path = os.path.join(mix_cache_dir, mix_basename + '.npy')
-    inst_cache_path = os.path.join(inst_cache_dir, inst_basename + '.npy')
+    mix_cache_path = os.path.join(mix_cache_dir, mix_basename + ".npy")
+    inst_cache_path = os.path.join(inst_cache_dir, inst_basename + ".npy")
 
     if os.path.exists(mix_cache_path) and os.path.exists(inst_cache_path):
         X_spec_m = np.load(mix_cache_path)
         y_spec_m = np.load(inst_cache_path)
     else:
         X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
-         
-        for d in range(len(mp.param['band']), 0, -1):            
-            bp = mp.param['band'][d]
-                    
-            if d == len(mp.param['band']): # high-end band
+
+        for d in range(len(mp.param["band"]), 0, -1):
+            bp = mp.param["band"][d]
+
+            if d == len(mp.param["band"]):  # high-end band
                 X_wave[d], _ = librosa.load(
-                    mix_path, bp['sr'], False, dtype=np.float32, res_type=bp['res_type'])
+                    mix_path, bp["sr"], False, dtype=np.float32, res_type=bp["res_type"]
+                )
                 y_wave[d], _ = librosa.load(
-                    inst_path, bp['sr'], False, dtype=np.float32, res_type=bp['res_type'])
-            else: # lower bands
-                X_wave[d] = librosa.resample(X_wave[d+1], mp.param['band'][d+1]['sr'], bp['sr'], res_type=bp['res_type'])
-                y_wave[d] = librosa.resample(y_wave[d+1], mp.param['band'][d+1]['sr'], bp['sr'], res_type=bp['res_type'])
-            
+                    inst_path,
+                    bp["sr"],
+                    False,
+                    dtype=np.float32,
+                    res_type=bp["res_type"],
+                )
+            else:  # lower bands
+                X_wave[d] = librosa.resample(
+                    X_wave[d + 1],
+                    mp.param["band"][d + 1]["sr"],
+                    bp["sr"],
+                    res_type=bp["res_type"],
+                )
+                y_wave[d] = librosa.resample(
+                    y_wave[d + 1],
+                    mp.param["band"][d + 1]["sr"],
+                    bp["sr"],
+                    res_type=bp["res_type"],
+                )
+
             X_wave[d], y_wave[d] = align_wave_head_and_tail(X_wave[d], y_wave[d])
-            
-            X_spec_s[d] = wave_to_spectrogram(X_wave[d], bp['hl'], bp['n_fft'], mp.param['mid_side'], mp.param['mid_side_b2'], mp.param['reverse'])
-            y_spec_s[d] = wave_to_spectrogram(y_wave[d], bp['hl'], bp['n_fft'], mp.param['mid_side'], mp.param['mid_side_b2'], mp.param['reverse'])
-            
+
+            X_spec_s[d] = wave_to_spectrogram(
+                X_wave[d],
+                bp["hl"],
+                bp["n_fft"],
+                mp.param["mid_side"],
+                mp.param["mid_side_b2"],
+                mp.param["reverse"],
+            )
+            y_spec_s[d] = wave_to_spectrogram(
+                y_wave[d],
+                bp["hl"],
+                bp["n_fft"],
+                mp.param["mid_side"],
+                mp.param["mid_side_b2"],
+                mp.param["reverse"],
+            )
+
         del X_wave, y_wave
-                 
+
         X_spec_m = combine_spectrograms(X_spec_s, mp)
         y_spec_m = combine_spectrograms(y_spec_s, mp)
-        
+
         if X_spec_m.shape != y_spec_m.shape:
-            raise ValueError('The combined spectrograms are different: ' + mix_path)
+            raise ValueError("The combined spectrograms are different: " + mix_path)
 
         _, ext = os.path.splitext(mix_path)
 
@@ -244,72 +294,129 @@ def spectrogram_to_wave(spec, hop_length, mid_side, mid_side_b2, reverse):
     if reverse:
         return np.asfortranarray([np.flip(wave_left), np.flip(wave_right)])
     elif mid_side:
-        return np.asfortranarray([np.add(wave_left, wave_right / 2), np.subtract(wave_left, wave_right / 2)])
+        return np.asfortranarray(
+            [np.add(wave_left, wave_right / 2), np.subtract(wave_left, wave_right / 2)]
+        )
     elif mid_side_b2:
-        return np.asfortranarray([np.add(wave_right / 1.25, .4 * wave_left), np.subtract(wave_left / 1.25, .4 * wave_right)])
+        return np.asfortranarray(
+            [
+                np.add(wave_right / 1.25, 0.4 * wave_left),
+                np.subtract(wave_left / 1.25, 0.4 * wave_right),
+            ]
+        )
     else:
         return np.asfortranarray([wave_left, wave_right])
-    
-    
+
+
 def spectrogram_to_wave_mt(spec, hop_length, mid_side, reverse, mid_side_b2):
     import threading
 
     spec_left = np.asfortranarray(spec[0])
     spec_right = np.asfortranarray(spec[1])
-    
+
     def run_thread(**kwargs):
         global wave_left
         wave_left = librosa.istft(**kwargs)
-        
-    thread = threading.Thread(target=run_thread, kwargs={'stft_matrix': spec_left, 'hop_length': hop_length})
+
+    thread = threading.Thread(
+        target=run_thread, kwargs={"stft_matrix": spec_left, "hop_length": hop_length}
+    )
     thread.start()
     wave_right = librosa.istft(spec_right, hop_length=hop_length)
-    thread.join()   
-    
+    thread.join()
+
     if reverse:
         return np.asfortranarray([np.flip(wave_left), np.flip(wave_right)])
     elif mid_side:
-        return np.asfortranarray([np.add(wave_left, wave_right / 2), np.subtract(wave_left, wave_right / 2)])
+        return np.asfortranarray(
+            [np.add(wave_left, wave_right / 2), np.subtract(wave_left, wave_right / 2)]
+        )
     elif mid_side_b2:
-        return np.asfortranarray([np.add(wave_right / 1.25, .4 * wave_left), np.subtract(wave_left / 1.25, .4 * wave_right)])
+        return np.asfortranarray(
+            [
+                np.add(wave_right / 1.25, 0.4 * wave_left),
+                np.subtract(wave_left / 1.25, 0.4 * wave_right),
+            ]
+        )
     else:
         return np.asfortranarray([wave_left, wave_right])
-    
-    
+
+
 def cmb_spectrogram_to_wave(spec_m, mp, extra_bins_h=None, extra_bins=None):
     wave_band = {}
-    bands_n = len(mp.param['band'])    
+    bands_n = len(mp.param["band"])
     offset = 0
 
     for d in range(1, bands_n + 1):
-        bp = mp.param['band'][d]
-        spec_s = np.ndarray(shape=(2, bp['n_fft'] // 2 + 1, spec_m.shape[2]), dtype=complex)
-        h = bp['crop_stop'] - bp['crop_start']
-        spec_s[:, bp['crop_start']:bp['crop_stop'], :] = spec_m[:, offset:offset+h, :]
-        
+        bp = mp.param["band"][d]
+        spec_s = np.ndarray(
+            shape=(2, bp["n_fft"] // 2 + 1, spec_m.shape[2]), dtype=complex
+        )
+        h = bp["crop_stop"] - bp["crop_start"]
+        spec_s[:, bp["crop_start"] : bp["crop_stop"], :] = spec_m[
+            :, offset : offset + h, :
+        ]
+
         offset += h
-        if d == bands_n: # higher
-            if extra_bins_h: # if --high_end_process bypass
-                max_bin = bp['n_fft'] // 2
-                spec_s[:, max_bin-extra_bins_h:max_bin, :] = extra_bins[:, :extra_bins_h, :]
-            if bp['hpf_start'] > 0:
-                spec_s = fft_hp_filter(spec_s, bp['hpf_start'], bp['hpf_stop'] - 1)
+        if d == bands_n:  # higher
+            if extra_bins_h:  # if --high_end_process bypass
+                max_bin = bp["n_fft"] // 2
+                spec_s[:, max_bin - extra_bins_h : max_bin, :] = extra_bins[
+                    :, :extra_bins_h, :
+                ]
+            if bp["hpf_start"] > 0:
+                spec_s = fft_hp_filter(spec_s, bp["hpf_start"], bp["hpf_stop"] - 1)
             if bands_n == 1:
-                wave = spectrogram_to_wave(spec_s, bp['hl'], mp.param['mid_side'], mp.param['mid_side_b2'], mp.param['reverse'])
+                wave = spectrogram_to_wave(
+                    spec_s,
+                    bp["hl"],
+                    mp.param["mid_side"],
+                    mp.param["mid_side_b2"],
+                    mp.param["reverse"],
+                )
             else:
-                wave = np.add(wave, spectrogram_to_wave(spec_s, bp['hl'], mp.param['mid_side'], mp.param['mid_side_b2'], mp.param['reverse']))
+                wave = np.add(
+                    wave,
+                    spectrogram_to_wave(
+                        spec_s,
+                        bp["hl"],
+                        mp.param["mid_side"],
+                        mp.param["mid_side_b2"],
+                        mp.param["reverse"],
+                    ),
+                )
         else:
-            sr = mp.param['band'][d+1]['sr']
-            if d == 1: # lower
-                spec_s = fft_lp_filter(spec_s, bp['lpf_start'], bp['lpf_stop'])
-                wave = librosa.resample(spectrogram_to_wave(spec_s, bp['hl'], mp.param['mid_side'], mp.param['mid_side_b2'], mp.param['reverse']), bp['sr'], sr, res_type="sinc_fastest")
-            else: # mid
-                spec_s = fft_hp_filter(spec_s, bp['hpf_start'], bp['hpf_stop'] - 1)
-                spec_s = fft_lp_filter(spec_s, bp['lpf_start'], bp['lpf_stop'])
-                wave2 = np.add(wave, spectrogram_to_wave(spec_s, bp['hl'], mp.param['mid_side'], mp.param['mid_side_b2'], mp.param['reverse']))
+            sr = mp.param["band"][d + 1]["sr"]
+            if d == 1:  # lower
+                spec_s = fft_lp_filter(spec_s, bp["lpf_start"], bp["lpf_stop"])
+                wave = librosa.resample(
+                    spectrogram_to_wave(
+                        spec_s,
+                        bp["hl"],
+                        mp.param["mid_side"],
+                        mp.param["mid_side_b2"],
+                        mp.param["reverse"],
+                    ),
+                    bp["sr"],
+                    sr,
+                    res_type="sinc_fastest",
+                )
+            else:  # mid
+                spec_s = fft_hp_filter(spec_s, bp["hpf_start"], bp["hpf_stop"] - 1)
+                spec_s = fft_lp_filter(spec_s, bp["lpf_start"], bp["lpf_stop"])
+                wave2 = np.add(
+                    wave,
+                    spectrogram_to_wave(
+                        spec_s,
+                        bp["hl"],
+                        mp.param["mid_side"],
+                        mp.param["mid_side_b2"],
+                        mp.param["reverse"],
+                    ),
+                )
                 # wave = librosa.core.resample(wave2, bp['sr'], sr, res_type="sinc_fastest")
-                wave = librosa.core.resample(wave2, bp['sr'], sr,res_type='scipy')
-        
+                wave = librosa.core.resample(wave2, bp["sr"], sr, res_type="scipy")
+
     return wave.T
 
 
@@ -318,7 +425,7 @@ def fft_lp_filter(spec, bin_start, bin_stop):
     for b in range(bin_start, bin_stop):
         g -= 1 / (bin_stop - bin_start)
         spec[:, b, :] = g * spec[:, b, :]
-        
+
     spec[:, bin_stop:, :] *= 0
 
     return spec
@@ -329,42 +436,69 @@ def fft_hp_filter(spec, bin_start, bin_stop):
     for b in range(bin_start, bin_stop, -1):
         g -= 1 / (bin_start - bin_stop)
         spec[:, b, :] = g * spec[:, b, :]
-    
-    spec[:, 0:bin_stop+1, :] *= 0
+
+    spec[:, 0 : bin_stop + 1, :] *= 0
 
     return spec
 
 
 def mirroring(a, spec_m, input_high_end, mp):
-    if 'mirroring' == a:
-        mirror = np.flip(np.abs(spec_m[:, mp.param['pre_filter_start']-10-input_high_end.shape[1]:mp.param['pre_filter_start']-10, :]), 1)
-        mirror = mirror * np.exp(1.j * np.angle(input_high_end))
-        
-        return np.where(np.abs(input_high_end) <= np.abs(mirror), input_high_end, mirror)
-        
-    if 'mirroring2' == a:
-        mirror = np.flip(np.abs(spec_m[:, mp.param['pre_filter_start']-10-input_high_end.shape[1]:mp.param['pre_filter_start']-10, :]), 1)
+    if "mirroring" == a:
+        mirror = np.flip(
+            np.abs(
+                spec_m[
+                    :,
+                    mp.param["pre_filter_start"]
+                    - 10
+                    - input_high_end.shape[1] : mp.param["pre_filter_start"]
+                    - 10,
+                    :,
+                ]
+            ),
+            1,
+        )
+        mirror = mirror * np.exp(1.0j * np.angle(input_high_end))
+
+        return np.where(
+            np.abs(input_high_end) <= np.abs(mirror), input_high_end, mirror
+        )
+
+    if "mirroring2" == a:
+        mirror = np.flip(
+            np.abs(
+                spec_m[
+                    :,
+                    mp.param["pre_filter_start"]
+                    - 10
+                    - input_high_end.shape[1] : mp.param["pre_filter_start"]
+                    - 10,
+                    :,
+                ]
+            ),
+            1,
+        )
         mi = np.multiply(mirror, input_high_end * 1.7)
-        
+
         return np.where(np.abs(input_high_end) <= np.abs(mi), input_high_end, mi)
 
 
-def ensembling(a, specs):   
+def ensembling(a, specs):
     for i in range(1, len(specs)):
         if i == 1:
             spec = specs[0]
 
         ln = min([spec.shape[2], specs[i].shape[2]])
-        spec = spec[:,:,:ln]
-        specs[i] = specs[i][:,:,:ln]
+        spec = spec[:, :, :ln]
+        specs[i] = specs[i][:, :, :ln]
 
-        if 'min_mag' == a:
+        if "min_mag" == a:
             spec = np.where(np.abs(specs[i]) <= np.abs(spec), specs[i], spec)
-        if 'max_mag' == a:
-            spec = np.where(np.abs(specs[i]) >= np.abs(spec), specs[i], spec)  
+        if "max_mag" == a:
+            spec = np.where(np.abs(specs[i]) >= np.abs(spec), specs[i], spec)
 
     return spec
 
+
 def stft(wave, nfft, hl):
     wave_left = np.asfortranarray(wave[0])
     wave_right = np.asfortranarray(wave[1])
@@ -374,6 +508,7 @@ def stft(wave, nfft, hl):
 
     return spec
 
+
 def istft(spec, hl):
     spec_left = np.asfortranarray(spec[0])
     spec_right = np.asfortranarray(spec[1])
@@ -389,62 +524,94 @@ if __name__ == "__main__":
     import time
     import argparse
     from model_param_init import ModelParameters
-    
+
     p = argparse.ArgumentParser()
-    p.add_argument('--algorithm', '-a', type=str, choices=['invert', 'invert_p', 'min_mag', 'max_mag', 'deep', 'align'], default='min_mag')
-    p.add_argument('--model_params', '-m', type=str, default=os.path.join('modelparams', '1band_sr44100_hl512.json'))
-    p.add_argument('--output_name', '-o', type=str, default='output')
-    p.add_argument('--vocals_only', '-v', action='store_true')
-    p.add_argument('input', nargs='+')
+    p.add_argument(
+        "--algorithm",
+        "-a",
+        type=str,
+        choices=["invert", "invert_p", "min_mag", "max_mag", "deep", "align"],
+        default="min_mag",
+    )
+    p.add_argument(
+        "--model_params",
+        "-m",
+        type=str,
+        default=os.path.join("modelparams", "1band_sr44100_hl512.json"),
+    )
+    p.add_argument("--output_name", "-o", type=str, default="output")
+    p.add_argument("--vocals_only", "-v", action="store_true")
+    p.add_argument("input", nargs="+")
     args = p.parse_args()
-  
+
     start_time = time.time()
-    
-    if args.algorithm.startswith('invert') and len(args.input) != 2:
-        raise ValueError('There should be two input files.')    
-    
-    if not args.algorithm.startswith('invert') and len(args.input) < 2:
-        raise ValueError('There must be at least two input files.')
-    
+
+    if args.algorithm.startswith("invert") and len(args.input) != 2:
+        raise ValueError("There should be two input files.")
+
+    if not args.algorithm.startswith("invert") and len(args.input) < 2:
+        raise ValueError("There must be at least two input files.")
+
     wave, specs = {}, {}
     mp = ModelParameters(args.model_params)
-     
-    for i in range(len(args.input)):    
+
+    for i in range(len(args.input)):
         spec = {}
-        
-        for d in range(len(mp.param['band']), 0, -1):          
-            bp = mp.param['band'][d]            
-            
-            if d == len(mp.param['band']): # high-end band                
+
+        for d in range(len(mp.param["band"]), 0, -1):
+            bp = mp.param["band"][d]
+
+            if d == len(mp.param["band"]):  # high-end band
                 wave[d], _ = librosa.load(
-                    args.input[i], bp['sr'], False, dtype=np.float32, res_type=bp['res_type'])
-                
-                if len(wave[d].shape) == 1: # mono to stereo
+                    args.input[i],
+                    bp["sr"],
+                    False,
+                    dtype=np.float32,
+                    res_type=bp["res_type"],
+                )
+
+                if len(wave[d].shape) == 1:  # mono to stereo
                     wave[d] = np.array([wave[d], wave[d]])
-            else: # lower bands
-                wave[d] = librosa.resample(wave[d+1], mp.param['band'][d+1]['sr'], bp['sr'], res_type=bp['res_type'])
-                       
-            spec[d] = wave_to_spectrogram(wave[d], bp['hl'], bp['n_fft'], mp.param['mid_side'], mp.param['mid_side_b2'], mp.param['reverse'])
-            
+            else:  # lower bands
+                wave[d] = librosa.resample(
+                    wave[d + 1],
+                    mp.param["band"][d + 1]["sr"],
+                    bp["sr"],
+                    res_type=bp["res_type"],
+                )
+
+            spec[d] = wave_to_spectrogram(
+                wave[d],
+                bp["hl"],
+                bp["n_fft"],
+                mp.param["mid_side"],
+                mp.param["mid_side_b2"],
+                mp.param["reverse"],
+            )
+
         specs[i] = combine_spectrograms(spec, mp)
-        
+
     del wave
 
-    if args.algorithm == 'deep':
+    if args.algorithm == "deep":
         d_spec = np.where(np.abs(specs[0]) <= np.abs(spec[1]), specs[0], spec[1])
         v_spec = d_spec - specs[1]
-        sf.write(os.path.join('{}.wav'.format(args.output_name)), cmb_spectrogram_to_wave(v_spec, mp), mp.param['sr'])   
-        
-    if args.algorithm.startswith('invert'):
+        sf.write(
+            os.path.join("{}.wav".format(args.output_name)),
+            cmb_spectrogram_to_wave(v_spec, mp),
+            mp.param["sr"],
+        )
+
+    if args.algorithm.startswith("invert"):
         ln = min([specs[0].shape[2], specs[1].shape[2]])
-        specs[0] = specs[0][:,:,:ln]
-        specs[1] = specs[1][:,:,:ln]
-        
-        if 'invert_p' == args.algorithm:
+        specs[0] = specs[0][:, :, :ln]
+        specs[1] = specs[1][:, :, :ln]
+
+        if "invert_p" == args.algorithm:
             X_mag = np.abs(specs[0])
-            y_mag = np.abs(specs[1])            
-            max_mag = np.where(X_mag >= y_mag, X_mag, y_mag)  
-            v_spec = specs[1] - max_mag * np.exp(1.j * np.angle(specs[0]))
+            y_mag = np.abs(specs[1])
+            max_mag = np.where(X_mag >= y_mag, X_mag, y_mag)
+            v_spec = specs[1] - max_mag * np.exp(1.0j * np.angle(specs[0]))
         else:
             specs[1] = reduce_vocal_aggressively(specs[0], specs[1], 0.2)
             v_spec = specs[0] - specs[1]
@@ -458,28 +625,43 @@ if __name__ == "__main__":
                 y_image = spectrogram_to_image(y_mag)
                 v_image = spectrogram_to_image(v_mag)
 
-                cv2.imwrite('{}_X.png'.format(args.output_name), X_image)
-                cv2.imwrite('{}_y.png'.format(args.output_name), y_image)
-                cv2.imwrite('{}_v.png'.format(args.output_name), v_image)    
-                    
-                sf.write('{}_X.wav'.format(args.output_name), cmb_spectrogram_to_wave(specs[0], mp), mp.param['sr'])
-                sf.write('{}_y.wav'.format(args.output_name), cmb_spectrogram_to_wave(specs[1], mp), mp.param['sr'])
-            
-        sf.write('{}_v.wav'.format(args.output_name), cmb_spectrogram_to_wave(v_spec, mp), mp.param['sr'])    
-    else:    
-        if not args.algorithm == 'deep':
-            sf.write(os.path.join('ensembled','{}.wav'.format(args.output_name)), cmb_spectrogram_to_wave(ensembling(args.algorithm, specs), mp), mp.param['sr'])
+                cv2.imwrite("{}_X.png".format(args.output_name), X_image)
+                cv2.imwrite("{}_y.png".format(args.output_name), y_image)
+                cv2.imwrite("{}_v.png".format(args.output_name), v_image)
 
-    if args.algorithm == 'align':
+                sf.write(
+                    "{}_X.wav".format(args.output_name),
+                    cmb_spectrogram_to_wave(specs[0], mp),
+                    mp.param["sr"],
+                )
+                sf.write(
+                    "{}_y.wav".format(args.output_name),
+                    cmb_spectrogram_to_wave(specs[1], mp),
+                    mp.param["sr"],
+                )
 
+        sf.write(
+            "{}_v.wav".format(args.output_name),
+            cmb_spectrogram_to_wave(v_spec, mp),
+            mp.param["sr"],
+        )
+    else:
+        if not args.algorithm == "deep":
+            sf.write(
+                os.path.join("ensembled", "{}.wav".format(args.output_name)),
+                cmb_spectrogram_to_wave(ensembling(args.algorithm, specs), mp),
+                mp.param["sr"],
+            )
+
+    if args.algorithm == "align":
         trackalignment = [
             {
-                'file1':'"{}"'.format(args.input[0]),
-                'file2':'"{}"'.format(args.input[1])
+                "file1": '"{}"'.format(args.input[0]),
+                "file2": '"{}"'.format(args.input[1]),
             }
         ]
 
-        for i,e in tqdm(enumerate(trackalignment), desc="Performing Alignment..."):
+        for i, e in tqdm(enumerate(trackalignment), desc="Performing Alignment..."):
             os.system(f"python lib/align_tracks.py {e['file1']} {e['file2']}")
 
-    #print('Total time: {0:.{1}f}s'.format(time.time() - start_time, 1))
+    # print('Total time: {0:.{1}f}s'.format(time.time() - start_time, 1))

uvr5_pack/name_params.json

@@ -0,0 +1,263 @@
+{
+    "equivalent" : [
+        {
+            "model_hash_name" : [
+                {
+                    "hash_name": "47939caf0cfe52a0e81442b85b971dfd",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100.json",
+                    "param_name": "4band_44100"
+                },
+                {
+                    "hash_name": "4e4ecb9764c50a8c414fee6e10395bbe",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_v2.json",
+                    "param_name": "4band_v2"
+                },
+                {
+                    "hash_name": "ca106edd563e034bde0bdec4bb7a4b36",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_v2.json",
+                    "param_name": "4band_v2"
+                },
+                {
+                    "hash_name": "e60a1e84803ce4efc0a6551206cc4b71",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100.json",
+                    "param_name": "4band_44100"
+                },
+                {
+                    "hash_name": "a82f14e75892e55e994376edbf0c8435",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100.json",
+                    "param_name": "4band_44100"
+                },
+                {
+                    "hash_name": "6dd9eaa6f0420af9f1d403aaafa4cc06",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_v2_sn.json",
+                    "param_name": "4band_v2_sn"
+                },
+                {
+                    "hash_name": "08611fb99bd59eaa79ad27c58d137727",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_v2_sn.json",
+                    "param_name": "4band_v2_sn"
+                },
+                {
+                    "hash_name": "5c7bbca45a187e81abbbd351606164e5",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/3band_44100_msb2.json",
+                    "param_name": "3band_44100_msb2"
+                },
+                {
+                    "hash_name": "d6b2cb685a058a091e5e7098192d3233",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/3band_44100_msb2.json",
+                    "param_name": "3band_44100_msb2"
+                },
+                {
+                    "hash_name": "c1b9f38170a7c90e96f027992eb7c62b",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100.json",
+                    "param_name": "4band_44100"
+                },
+                {
+                    "hash_name": "c3448ec923fa0edf3d03a19e633faa53",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100.json",
+                    "param_name": "4band_44100"
+                },
+                {
+                    "hash_name": "68aa2c8093d0080704b200d140f59e54",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/3band_44100.json",
+                    "param_name": "3band_44100"
+                },
+                {
+                    "hash_name": "fdc83be5b798e4bd29fe00fe6600e147",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/3band_44100_mid.json",
+                    "param_name": "3band_44100_mid.json"
+                },
+                {
+                    "hash_name": "2ce34bc92fd57f55db16b7a4def3d745",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/3band_44100_mid.json",
+                    "param_name": "3band_44100_mid.json"
+                },
+                {
+                    "hash_name": "52fdca89576f06cf4340b74a4730ee5f",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100.json",
+                    "param_name": "4band_44100.json"
+                },
+                {
+                    "hash_name": "41191165b05d38fc77f072fa9e8e8a30",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100.json",
+                    "param_name": "4band_44100.json"
+                },
+                {
+                    "hash_name": "89e83b511ad474592689e562d5b1f80e",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/2band_32000.json",
+                    "param_name": "2band_32000.json"
+                },
+                {
+                    "hash_name": "0b954da81d453b716b114d6d7c95177f",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/2band_32000.json",
+                    "param_name": "2band_32000.json"
+                }
+
+            ],
+            "v4 Models": [
+                {
+                    "hash_name": "6a00461c51c2920fd68937d4609ed6c8",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr16000_hl512.json",
+                    "param_name": "1band_sr16000_hl512"
+                },
+                {
+                    "hash_name": "0ab504864d20f1bd378fe9c81ef37140",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr32000_hl512.json",
+                    "param_name": "1band_sr32000_hl512"
+                },
+                {
+                    "hash_name": "7dd21065bf91c10f7fccb57d7d83b07f",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr32000_hl512.json",
+                    "param_name": "1band_sr32000_hl512"
+                },
+                {
+                    "hash_name": "80ab74d65e515caa3622728d2de07d23",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr32000_hl512.json",
+                    "param_name": "1band_sr32000_hl512"
+                },
+                {
+                    "hash_name": "edc115e7fc523245062200c00caa847f",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr33075_hl384.json",
+                    "param_name": "1band_sr33075_hl384"
+                },
+                {
+                    "hash_name": "28063e9f6ab5b341c5f6d3c67f2045b7",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr33075_hl384.json",
+                    "param_name": "1band_sr33075_hl384"
+                },
+                {
+                    "hash_name": "b58090534c52cbc3e9b5104bad666ef2",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr44100_hl512.json",
+                    "param_name": "1band_sr44100_hl512"
+                },
+                {
+                    "hash_name": "0cdab9947f1b0928705f518f3c78ea8f",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr44100_hl512.json",
+                    "param_name": "1band_sr44100_hl512"
+                },
+                {
+                    "hash_name": "ae702fed0238afb5346db8356fe25f13",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr44100_hl1024.json",
+                    "param_name": "1band_sr44100_hl1024"
+                }
+            ]
+        }
+    ],
+    "User Models" : [
+        {
+            "1 Band": [
+                {
+                    "hash_name": "1band_sr16000_hl512",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr16000_hl512.json",
+                    "param_name": "1band_sr16000_hl512"
+                },
+                {
+                    "hash_name": "1band_sr32000_hl512",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr32000_hl512.json",
+                    "param_name": "1band_sr16000_hl512"
+                },
+                {
+                    "hash_name": "1band_sr33075_hl384",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr33075_hl384.json",
+                    "param_name": "1band_sr33075_hl384"
+                },
+                {
+                    "hash_name": "1band_sr44100_hl256",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr44100_hl256.json",
+                    "param_name": "1band_sr44100_hl256"
+                },
+                {
+                    "hash_name": "1band_sr44100_hl512",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr44100_hl512.json",
+                    "param_name": "1band_sr44100_hl512"
+                },
+                {
+                    "hash_name": "1band_sr44100_hl1024",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/1band_sr44100_hl1024.json",
+                    "param_name": "1band_sr44100_hl1024"
+                }
+            ],
+            "2 Band": [
+                {
+                    "hash_name": "2band_44100_lofi",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/2band_44100_lofi.json",
+                    "param_name": "2band_44100_lofi"
+                },
+                {
+                    "hash_name": "2band_32000",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/2band_32000.json",
+                    "param_name": "2band_32000"
+                },
+                {
+                    "hash_name": "2band_48000",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/2band_48000.json",
+                    "param_name": "2band_48000"
+                }
+            ],
+            "3 Band": [
+                {
+                    "hash_name": "3band_44100",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/3band_44100.json",
+                    "param_name": "3band_44100"
+                },
+                {
+                    "hash_name": "3band_44100_mid",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/3band_44100_mid.json",
+                    "param_name": "3band_44100_mid"
+                },
+                {
+                    "hash_name": "3band_44100_msb2",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/3band_44100_msb2.json",
+                    "param_name": "3band_44100_msb2"
+                }
+            ],
+            "4 Band": [
+                {
+                    "hash_name": "4band_44100",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100.json",
+                    "param_name": "4band_44100"
+                },
+                {
+                    "hash_name": "4band_44100_mid",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100_mid.json",
+                    "param_name": "4band_44100_mid"
+                },
+                {
+                    "hash_name": "4band_44100_msb",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100_msb.json",
+                    "param_name": "4band_44100_msb"
+                },
+                {
+                    "hash_name": "4band_44100_msb2",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100_msb2.json",
+                    "param_name": "4band_44100_msb2"
+                },
+                {
+                    "hash_name": "4band_44100_reverse",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100_reverse.json",
+                    "param_name": "4band_44100_reverse"
+                },
+                {
+                    "hash_name": "4band_44100_sw",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_44100_sw.json",
+                    "param_name": "4band_44100_sw"
+                },
+                {
+                    "hash_name": "4band_v2",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_v2.json",
+                    "param_name": "4band_v2"
+                },
+                {
+                    "hash_name": "4band_v2_sn",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/4band_v2_sn.json",
+                    "param_name": "4band_v2_sn"
+                },
+                {
+                    "hash_name": "tmodelparam",
+                    "model_params": "uvr5_pack/lib_v5/modelparams/tmodelparam.json",
+                    "param_name": "User Model Param Set"
+                }
+            ]
+        }
+    ]
+}

uvr5_pack/utils.py

@@ -1,6 +1,15 @@
 import torch
 import numpy as np
 from tqdm import tqdm
+import json
+
+
+def load_data(file_name: str = "./uvr5_pack/name_params.json") -> dict:
+    with open(file_name, "r") as f:
+        data = json.load(f)
+
+    return data
+
 
 def make_padding(width, cropsize, offset):
     left = offset
@@ -10,233 +19,102 @@ def make_padding(width, cropsize, offset):
     right = roi_size - (width % roi_size) + left
 
     return left, right, roi_size
-def inference(X_spec, device, model, aggressiveness,data):
-    '''
+
+
+def inference(X_spec, device, model, aggressiveness, data):
+    """
     data ： dic configs
-    '''
-    
-    def _execute(X_mag_pad, roi_size, n_window, device, model, aggressiveness,is_half=True):
+    """
+
+    def _execute(
+        X_mag_pad, roi_size, n_window, device, model, aggressiveness, is_half=True
+    ):
         model.eval()
         with torch.no_grad():
             preds = []
-            
+
             iterations = [n_window]
 
-            total_iterations = sum(iterations)            
-            for i in tqdm(range(n_window)): 
+            total_iterations = sum(iterations)
+            for i in tqdm(range(n_window)):
                 start = i * roi_size
-                X_mag_window = X_mag_pad[None, :, :, start:start + data['window_size']]
+                X_mag_window = X_mag_pad[
+                    None, :, :, start : start + data["window_size"]
+                ]
                 X_mag_window = torch.from_numpy(X_mag_window)
-                if(is_half==True):X_mag_window=X_mag_window.half()
-                X_mag_window=X_mag_window.to(device)
+                if is_half:
+                    X_mag_window = X_mag_window.half()
+                X_mag_window = X_mag_window.to(device)
 
                 pred = model.predict(X_mag_window, aggressiveness)
 
                 pred = pred.detach().cpu().numpy()
                 preds.append(pred[0])
-                
+
             pred = np.concatenate(preds, axis=2)
         return pred
-    
+
     def preprocess(X_spec):
         X_mag = np.abs(X_spec)
         X_phase = np.angle(X_spec)
 
         return X_mag, X_phase
-    
+
     X_mag, X_phase = preprocess(X_spec)
 
     coef = X_mag.max()
     X_mag_pre = X_mag / coef
 
     n_frame = X_mag_pre.shape[2]
-    pad_l, pad_r, roi_size = make_padding(n_frame,
-                                                data['window_size'], model.offset)
+    pad_l, pad_r, roi_size = make_padding(n_frame, data["window_size"], model.offset)
     n_window = int(np.ceil(n_frame / roi_size))
 
-    X_mag_pad = np.pad(
-        X_mag_pre, ((0, 0), (0, 0), (pad_l, pad_r)), mode='constant')
+    X_mag_pad = np.pad(X_mag_pre, ((0, 0), (0, 0), (pad_l, pad_r)), mode="constant")
 
-    if(list(model.state_dict().values())[0].dtype==torch.float16):is_half=True
-    else:is_half=False
-    pred = _execute(X_mag_pad, roi_size, n_window,
-                        device, model, aggressiveness,is_half)
+    if list(model.state_dict().values())[0].dtype == torch.float16:
+        is_half = True
+    else:
+        is_half = False
+    pred = _execute(
+        X_mag_pad, roi_size, n_window, device, model, aggressiveness, is_half
+    )
     pred = pred[:, :, :n_frame]
-    
-    if data['tta']:
+
+    if data["tta"]:
         pad_l += roi_size // 2
         pad_r += roi_size // 2
         n_window += 1
 
-        X_mag_pad = np.pad(
-            X_mag_pre, ((0, 0), (0, 0), (pad_l, pad_r)), mode='constant')
+        X_mag_pad = np.pad(X_mag_pre, ((0, 0), (0, 0), (pad_l, pad_r)), mode="constant")
 
-        pred_tta = _execute(X_mag_pad, roi_size, n_window,
-                                device, model, aggressiveness,is_half)
-        pred_tta = pred_tta[:, :, roi_size // 2:]
+        pred_tta = _execute(
+            X_mag_pad, roi_size, n_window, device, model, aggressiveness, is_half
+        )
+        pred_tta = pred_tta[:, :, roi_size // 2 :]
         pred_tta = pred_tta[:, :, :n_frame]
 
-        return (pred + pred_tta) * 0.5 * coef, X_mag, np.exp(1.j * X_phase)
+        return (pred + pred_tta) * 0.5 * coef, X_mag, np.exp(1.0j * X_phase)
     else:
-        return pred * coef, X_mag, np.exp(1.j * X_phase)
-            
+        return pred * coef, X_mag, np.exp(1.0j * X_phase)
 
 
-def  _get_name_params(model_path , model_hash):
+def _get_name_params(model_path, model_hash):
+    data = load_data()
+    flag = False
     ModelName = model_path
-    if model_hash == '47939caf0cfe52a0e81442b85b971dfd':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100.json')
-        param_name_auto=str('4band_44100')
-    if model_hash == '4e4ecb9764c50a8c414fee6e10395bbe':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_v2.json')
-        param_name_auto=str('4band_v2')
-    if model_hash == 'ca106edd563e034bde0bdec4bb7a4b36':
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_v2.json')
-        param_name_auto=str('4band_v2')
-    if model_hash == 'e60a1e84803ce4efc0a6551206cc4b71':
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100.json')
-        param_name_auto=str('4band_44100')
-    if model_hash == 'a82f14e75892e55e994376edbf0c8435':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100.json')
-        param_name_auto=str('4band_44100')
-    if model_hash == '6dd9eaa6f0420af9f1d403aaafa4cc06':   
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_v2_sn.json')
-        param_name_auto=str('4band_v2_sn')
-    if model_hash == '08611fb99bd59eaa79ad27c58d137727':
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_v2_sn.json')
-        param_name_auto=str('4band_v2_sn')
-    if model_hash == '5c7bbca45a187e81abbbd351606164e5':
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/3band_44100_msb2.json')
-        param_name_auto=str('3band_44100_msb2')
-    if model_hash == 'd6b2cb685a058a091e5e7098192d3233':    
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/3band_44100_msb2.json')
-        param_name_auto=str('3band_44100_msb2')
-    if model_hash == 'c1b9f38170a7c90e96f027992eb7c62b': 
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100.json')
-        param_name_auto=str('4band_44100')
-    if model_hash == 'c3448ec923fa0edf3d03a19e633faa53':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100.json')
-        param_name_auto=str('4band_44100')
-    if model_hash == '68aa2c8093d0080704b200d140f59e54':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/3band_44100.json')
-        param_name_auto=str('3band_44100.json')
-    if model_hash == 'fdc83be5b798e4bd29fe00fe6600e147':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/3band_44100_mid.json')
-        param_name_auto=str('3band_44100_mid.json')
-    if model_hash == '2ce34bc92fd57f55db16b7a4def3d745':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/3band_44100_mid.json')
-        param_name_auto=str('3band_44100_mid.json')
-    if model_hash == '52fdca89576f06cf4340b74a4730ee5f':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100.json')
-        param_name_auto=str('4band_44100.json')
-    if model_hash == '41191165b05d38fc77f072fa9e8e8a30':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100.json')
-        param_name_auto=str('4band_44100.json')
-    if model_hash == '89e83b511ad474592689e562d5b1f80e':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/2band_32000.json')
-        param_name_auto=str('2band_32000.json')
-    if model_hash == '0b954da81d453b716b114d6d7c95177f':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/2band_32000.json')
-        param_name_auto=str('2band_32000.json')
+    for type in list(data):
+        for model in list(data[type][0]):
+            for i in range(len(data[type][0][model])):
+                if str(data[type][0][model][i]["hash_name"]) == model_hash:
+                    flag = True
+                elif str(data[type][0][model][i]["hash_name"]) in ModelName:
+                    flag = True
 
-    #v4 Models    
-    if model_hash == '6a00461c51c2920fd68937d4609ed6c8':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr16000_hl512.json')
-        param_name_auto=str('1band_sr16000_hl512')
-    if model_hash == '0ab504864d20f1bd378fe9c81ef37140':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr32000_hl512.json')
-        param_name_auto=str('1band_sr32000_hl512')
-    if model_hash == '7dd21065bf91c10f7fccb57d7d83b07f':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr32000_hl512.json')
-        param_name_auto=str('1band_sr32000_hl512')
-    if model_hash == '80ab74d65e515caa3622728d2de07d23':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr32000_hl512.json')
-        param_name_auto=str('1band_sr32000_hl512')
-    if model_hash == 'edc115e7fc523245062200c00caa847f':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr33075_hl384.json')
-        param_name_auto=str('1band_sr33075_hl384')
-    if model_hash == '28063e9f6ab5b341c5f6d3c67f2045b7':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr33075_hl384.json')
-        param_name_auto=str('1band_sr33075_hl384')
-    if model_hash == 'b58090534c52cbc3e9b5104bad666ef2':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr44100_hl512.json')
-        param_name_auto=str('1band_sr44100_hl512')
-    if model_hash == '0cdab9947f1b0928705f518f3c78ea8f':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr44100_hl512.json')
-        param_name_auto=str('1band_sr44100_hl512')
-    if model_hash == 'ae702fed0238afb5346db8356fe25f13':  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr44100_hl1024.json')
-        param_name_auto=str('1band_sr44100_hl1024')                        
-    #User Models
-
-    #1 Band
-    if '1band_sr16000_hl512' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr16000_hl512.json')
-        param_name_auto=str('1band_sr16000_hl512')
-    if '1band_sr32000_hl512' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr32000_hl512.json')
-        param_name_auto=str('1band_sr32000_hl512')
-    if '1band_sr33075_hl384' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr33075_hl384.json')
-        param_name_auto=str('1band_sr33075_hl384')
-    if '1band_sr44100_hl256' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr44100_hl256.json')
-        param_name_auto=str('1band_sr44100_hl256')
-    if '1band_sr44100_hl512' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr44100_hl512.json')
-        param_name_auto=str('1band_sr44100_hl512')
-    if '1band_sr44100_hl1024' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/1band_sr44100_hl1024.json')
-        param_name_auto=str('1band_sr44100_hl1024')
-        
-    #2 Band
-    if '2band_44100_lofi' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/2band_44100_lofi.json')
-        param_name_auto=str('2band_44100_lofi')
-    if '2band_32000' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/2band_32000.json')
-        param_name_auto=str('2band_32000')
-    if '2band_48000' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/2band_48000.json')
-        param_name_auto=str('2band_48000')
-        
-    #3 Band   
-    if '3band_44100' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/3band_44100.json')
-        param_name_auto=str('3band_44100')
-    if '3band_44100_mid' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/3band_44100_mid.json')
-        param_name_auto=str('3band_44100_mid')
-    if '3band_44100_msb2' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/3band_44100_msb2.json')
-        param_name_auto=str('3band_44100_msb2')
-        
-    #4 Band    
-    if '4band_44100' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100.json')
-        param_name_auto=str('4band_44100')
-    if '4band_44100_mid' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100_mid.json')
-        param_name_auto=str('4band_44100_mid')
-    if '4band_44100_msb' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100_msb.json')
-        param_name_auto=str('4band_44100_msb')
-    if '4band_44100_msb2' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100_msb2.json')
-        param_name_auto=str('4band_44100_msb2')
-    if '4band_44100_reverse' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100_reverse.json')
-        param_name_auto=str('4band_44100_reverse')
-    if '4band_44100_sw' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_44100_sw.json') 
-        param_name_auto=str('4band_44100_sw')
-    if '4band_v2' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_v2.json')
-        param_name_auto=str('4band_v2')
-    if '4band_v2_sn' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/4band_v2_sn.json')
-        param_name_auto=str('4band_v2_sn')
-    if 'tmodelparam' in ModelName:  
-        model_params_auto=str('uvr5_pack/lib_v5/modelparams/tmodelparam.json')
-        param_name_auto=str('User Model Param Set')
-    return param_name_auto , model_params_auto
+                if flag:
+                    model_params_auto = data[type][0][model][i]["model_params"]
+                    param_name_auto = data[type][0][model][i]["param_name"]
+                    if type == "equivalent":
+                        return param_name_auto, model_params_auto
+                    else:
+                        flag = False
+    return param_name_auto, model_params_auto

vc_infer_pipeline.py

@@ -1,65 +1,100 @@
-import numpy as np,parselmouth,torch,pdb
+import numpy as np, parselmouth, torch, pdb
 from time import time as ttime
 import torch.nn.functional as F
-from config import x_pad,x_query,x_center,x_max
+from config import x_pad, x_query, x_center, x_max
 import scipy.signal as signal
-import pyworld,os,traceback,faiss
-class VC(object):
-    def __init__(self,tgt_sr,device,is_half):
-        self.sr=16000#hubert输入采样率
-        self.window=160#每帧点数
-        self.t_pad=self.sr*x_pad#每条前后pad时间
-        self.t_pad_tgt=tgt_sr*x_pad
-        self.t_pad2=self.t_pad*2
-        self.t_query=self.sr*x_query#查询切点前后查询时间
-        self.t_center=self.sr*x_center#查询切点位置
-        self.t_max=self.sr*x_max#免查询时长阈值
-        self.device=device
-        self.is_half=is_half
+import pyworld, os, traceback, faiss
+from scipy import signal
 
-    def get_f0(self,x, p_len,f0_up_key,f0_method,inp_f0=None):
+bh, ah = signal.butter(N=5, Wn=48, btype="high", fs=16000)
+
+
+class VC(object):
+    def __init__(self, tgt_sr, device, is_half):
+        self.sr = 16000  # hubert输入采样率
+        self.window = 160  # 每帧点数
+        self.t_pad = self.sr * x_pad  # 每条前后pad时间
+        self.t_pad_tgt = tgt_sr * x_pad
+        self.t_pad2 = self.t_pad * 2
+        self.t_query = self.sr * x_query  # 查询切点前后查询时间
+        self.t_center = self.sr * x_center  # 查询切点位置
+        self.t_max = self.sr * x_max  # 免查询时长阈值
+        self.device = device
+        self.is_half = is_half
+
+    def get_f0(self, x, p_len, f0_up_key, f0_method, inp_f0=None):
         time_step = self.window / self.sr * 1000
         f0_min = 50
         f0_max = 1100
         f0_mel_min = 1127 * np.log(1 + f0_min / 700)
         f0_mel_max = 1127 * np.log(1 + f0_max / 700)
-        if(f0_method=="pm"):
-            f0 = parselmouth.Sound(x, self.sr).to_pitch_ac(
-                time_step=time_step / 1000, voicing_threshold=0.6,
-                pitch_floor=f0_min, pitch_ceiling=f0_max).selected_array['frequency']
-            pad_size=(p_len - len(f0) + 1) // 2
-            if(pad_size>0 or p_len - len(f0) - pad_size>0):
-                f0 = np.pad(f0,[[pad_size,p_len - len(f0) - pad_size]], mode='constant')
-        elif(f0_method=="harvest"):
+        if f0_method == "pm":
+            f0 = (
+                parselmouth.Sound(x, self.sr)
+                .to_pitch_ac(
+                    time_step=time_step / 1000,
+                    voicing_threshold=0.6,
+                    pitch_floor=f0_min,
+                    pitch_ceiling=f0_max,
+                )
+                .selected_array["frequency"]
+            )
+            pad_size = (p_len - len(f0) + 1) // 2
+            if pad_size > 0 or p_len - len(f0) - pad_size > 0:
+                f0 = np.pad(
+                    f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant"
+                )
+        elif f0_method == "harvest":
             f0, t = pyworld.harvest(
                 x.astype(np.double),
                 fs=self.sr,
                 f0_ceil=f0_max,
+                f0_floor=f0_min,
                 frame_period=10,
             )
             f0 = pyworld.stonemask(x.astype(np.double), f0, t, self.sr)
             f0 = signal.medfilt(f0, 3)
         f0 *= pow(2, f0_up_key / 12)
         # with open("test.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
-        tf0=self.sr//self.window#每秒f0点数
-        if (inp_f0 is not None):
-            delta_t=np.round((inp_f0[:,0].max()-inp_f0[:,0].min())*tf0+1).astype("int16")
-            replace_f0=np.interp(list(range(delta_t)), inp_f0[:, 0]*100, inp_f0[:, 1])
-            shape=f0[x_pad*tf0:x_pad*tf0+len(replace_f0)].shape[0]
-            f0[x_pad*tf0:x_pad*tf0+len(replace_f0)]=replace_f0[:shape]
+        tf0 = self.sr // self.window  # 每秒f0点数
+        if inp_f0 is not None:
+            delta_t = np.round(
+                (inp_f0[:, 0].max() - inp_f0[:, 0].min()) * tf0 + 1
+            ).astype("int16")
+            replace_f0 = np.interp(
+                list(range(delta_t)), inp_f0[:, 0] * 100, inp_f0[:, 1]
+            )
+            shape = f0[x_pad * tf0 : x_pad * tf0 + len(replace_f0)].shape[0]
+            f0[x_pad * tf0 : x_pad * tf0 + len(replace_f0)] = replace_f0[:shape]
         # with open("test_opt.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
         f0bak = f0.copy()
         f0_mel = 1127 * np.log(1 + f0 / 700)
-        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (f0_mel_max - f0_mel_min) + 1
+        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
+            f0_mel_max - f0_mel_min
+        ) + 1
         f0_mel[f0_mel <= 1] = 1
         f0_mel[f0_mel > 255] = 255
         f0_coarse = np.rint(f0_mel).astype(np.int)
-        return f0_coarse, f0bak#1-0
+        return f0_coarse, f0bak  # 1-0
 
-    def vc(self,model,net_g,sid,audio0,pitch,pitchf,times,index,big_npy,index_rate):#,file_index,file_big_npy
+    def vc(
+        self,
+        model,
+        net_g,
+        sid,
+        audio0,
+        pitch,
+        pitchf,
+        times,
+        index,
+        big_npy,
+        index_rate,
+    ):  # ,file_index,file_big_npy
         feats = torch.from_numpy(audio0)
-        if(self.is_half==True):feats=feats.half()
-        else:feats=feats.float()
+        if self.is_half:
+            feats = feats.half()
+        else:
+            feats = feats.float()
         if feats.dim() == 2:  # double channels
             feats = feats.mean(-1)
         assert feats.dim() == 1, feats.dim()
@@ -74,91 +109,205 @@ class VC(object):
         t0 = ttime()
         with torch.no_grad():
             logits = model.extract_features(**inputs)
-            feats  = model.final_proj(logits[0])
+            feats = model.final_proj(logits[0])
 
-        if(isinstance(index,type(None))==False and isinstance(big_npy,type(None))==False and index_rate!=0):
+        if (
+            isinstance(index, type(None)) == False
+            and isinstance(big_npy, type(None)) == False
+            and index_rate != 0
+        ):
             npy = feats[0].cpu().numpy()
-            if(self.is_half==True):npy=npy.astype("float32")
-            D, I = index.search(npy, 1)
-            npy=big_npy[I.squeeze()]
-            if(self.is_half==True):npy=npy.astype("float16")
-            feats = torch.from_numpy(npy).unsqueeze(0).to(self.device)*index_rate + (1-index_rate)*feats
+            if self.is_half:
+                npy = npy.astype("float32")
+
+            # _, I = index.search(npy, 1)
+            # npy = big_npy[I.squeeze()]
+
+            score, ix = index.search(npy, k=8)
+            weight = np.square(1 / score)
+            weight /= weight.sum(axis=1, keepdims=True)
+            npy = np.sum(big_npy[ix] * np.expand_dims(weight, axis=2), axis=1)
+
+            if self.is_half:
+                npy = npy.astype("float16")
+            feats = (
+                torch.from_numpy(npy).unsqueeze(0).to(self.device) * index_rate
+                + (1 - index_rate) * feats
+            )
 
         feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
         t1 = ttime()
-        p_len = audio0.shape[0]//self.window
-        if(feats.shape[1]<p_len):
-            p_len=feats.shape[1]
-            if(pitch!=None and pitchf!=None):
-                pitch=pitch[:,:p_len]
-                pitchf=pitchf[:,:p_len]
-        p_len=torch.tensor([p_len],device=self.device).long()
+        p_len = audio0.shape[0] // self.window
+        if feats.shape[1] < p_len:
+            p_len = feats.shape[1]
+            if pitch != None and pitchf != None:
+                pitch = pitch[:, :p_len]
+                pitchf = pitchf[:, :p_len]
+        p_len = torch.tensor([p_len], device=self.device).long()
         with torch.no_grad():
-            if(pitch!=None and pitchf!=None):
-                audio1 = (net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0] * 32768).data.cpu().float().numpy().astype(np.int16)
+            if pitch != None and pitchf != None:
+                audio1 = (
+                    (net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0] * 32768)
+                    .data.cpu()
+                    .float()
+                    .numpy()
+                    .astype(np.int16)
+                )
             else:
-                audio1 = (net_g.infer(feats, p_len, sid)[0][0, 0] * 32768).data.cpu().float().numpy().astype(np.int16)
-        del feats,p_len,padding_mask
-        torch.cuda.empty_cache()
+                audio1 = (
+                    (net_g.infer(feats, p_len, sid)[0][0, 0] * 32768)
+                    .data.cpu()
+                    .float()
+                    .numpy()
+                    .astype(np.int16)
+                )
+        del feats, p_len, padding_mask
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
         t2 = ttime()
-        times[0] += (t1 - t0)
-        times[2] += (t2 - t1)
+        times[0] += t1 - t0
+        times[2] += t2 - t1
         return audio1
 
-    def pipeline(self,model,net_g,sid,audio,times,f0_up_key,f0_method,file_index,file_big_npy,index_rate,if_f0,f0_file=None):
-        if(file_big_npy!=""and file_index!=""and os.path.exists(file_big_npy)==True and os.path.exists(file_index)==True and index_rate!=0):
+    def pipeline(
+        self,
+        model,
+        net_g,
+        sid,
+        audio,
+        times,
+        f0_up_key,
+        f0_method,
+        file_index,
+        # file_big_npy,
+        index_rate,
+        if_f0,
+        f0_file=None,
+    ):
+        if (
+            file_index != ""
+            # and file_big_npy != ""
+            # and os.path.exists(file_big_npy) == True
+            and os.path.exists(file_index) == True
+            and index_rate != 0
+        ):
             try:
                 index = faiss.read_index(file_index)
-                big_npy = np.load(file_big_npy)
+                # big_npy = np.load(file_big_npy)
+                big_npy = index.reconstruct_n(0, index.ntotal)
             except:
                 traceback.print_exc()
-                index=big_npy=None
+                index = big_npy = None
         else:
-            index=big_npy=None
-        audio_pad = np.pad(audio, (self.window // 2, self.window // 2), mode='reflect')
+            index = big_npy = None
+        audio = signal.filtfilt(bh, ah, audio)
+        audio_pad = np.pad(audio, (self.window // 2, self.window // 2), mode="reflect")
         opt_ts = []
-        if(audio_pad.shape[0]>self.t_max):
+        if audio_pad.shape[0] > self.t_max:
             audio_sum = np.zeros_like(audio)
-            for i in range(self.window): audio_sum += audio_pad[i:i - self.window]
-            for t in range(self.t_center, audio.shape[0],self.t_center):opt_ts.append(t - self.t_query + np.where(np.abs(audio_sum[t - self.t_query:t + self.t_query]) == np.abs(audio_sum[t - self.t_query:t + self.t_query]).min())[0][0])
+            for i in range(self.window):
+                audio_sum += audio_pad[i : i - self.window]
+            for t in range(self.t_center, audio.shape[0], self.t_center):
+                opt_ts.append(
+                    t
+                    - self.t_query
+                    + np.where(
+                        np.abs(audio_sum[t - self.t_query : t + self.t_query])
+                        == np.abs(audio_sum[t - self.t_query : t + self.t_query]).min()
+                    )[0][0]
+                )
         s = 0
-        audio_opt=[]
-        t=None
-        t1=ttime()
-        audio_pad = np.pad(audio, (self.t_pad, self.t_pad), mode='reflect')
-        p_len=audio_pad.shape[0]//self.window
-        inp_f0=None
-        if(hasattr(f0_file,'name') ==True):
+        audio_opt = []
+        t = None
+        t1 = ttime()
+        audio_pad = np.pad(audio, (self.t_pad, self.t_pad), mode="reflect")
+        p_len = audio_pad.shape[0] // self.window
+        inp_f0 = None
+        if hasattr(f0_file, "name") == True:
             try:
-                with open(f0_file.name,"r")as f:
-                    lines=f.read().strip("\n").split("\n")
-                inp_f0=[]
-                for line in lines:inp_f0.append([float(i)for i in line.split(",")])
-                inp_f0=np.array(inp_f0,dtype="float32")
+                with open(f0_file.name, "r") as f:
+                    lines = f.read().strip("\n").split("\n")
+                inp_f0 = []
+                for line in lines:
+                    inp_f0.append([float(i) for i in line.split(",")])
+                inp_f0 = np.array(inp_f0, dtype="float32")
             except:
                 traceback.print_exc()
-        sid=torch.tensor(sid,device=self.device).unsqueeze(0).long()
-        pitch, pitchf=None,None
-        if(if_f0==1):
-            pitch, pitchf = self.get_f0(audio_pad, p_len, f0_up_key,f0_method,inp_f0)
+        sid = torch.tensor(sid, device=self.device).unsqueeze(0).long()
+        pitch, pitchf = None, None
+        if if_f0 == 1:
+            pitch, pitchf = self.get_f0(audio_pad, p_len, f0_up_key, f0_method, inp_f0)
             pitch = pitch[:p_len]
             pitchf = pitchf[:p_len]
-            pitch = torch.tensor(pitch,device=self.device).unsqueeze(0).long()
-            pitchf = torch.tensor(pitchf,device=self.device).unsqueeze(0).float()
-        t2=ttime()
-        times[1] += (t2 - t1)
+            pitch = torch.tensor(pitch, device=self.device).unsqueeze(0).long()
+            pitchf = torch.tensor(pitchf, device=self.device).unsqueeze(0).float()
+        t2 = ttime()
+        times[1] += t2 - t1
         for t in opt_ts:
-            t=t//self.window*self.window
-            if (if_f0 == 1):
-                audio_opt.append(self.vc(model,net_g,sid,audio_pad[s:t+self.t_pad2+self.window],pitch[:,s//self.window:(t+self.t_pad2)//self.window],pitchf[:,s//self.window:(t+self.t_pad2)//self.window],times,index,big_npy,index_rate)[self.t_pad_tgt:-self.t_pad_tgt])
+            t = t // self.window * self.window
+            if if_f0 == 1:
+                audio_opt.append(
+                    self.vc(
+                        model,
+                        net_g,
+                        sid,
+                        audio_pad[s : t + self.t_pad2 + self.window],
+                        pitch[:, s // self.window : (t + self.t_pad2) // self.window],
+                        pitchf[:, s // self.window : (t + self.t_pad2) // self.window],
+                        times,
+                        index,
+                        big_npy,
+                        index_rate,
+                    )[self.t_pad_tgt : -self.t_pad_tgt]
+                )
             else:
-                audio_opt.append(self.vc(model,net_g,sid,audio_pad[s:t+self.t_pad2+self.window],None,None,times,index,big_npy,index_rate)[self.t_pad_tgt:-self.t_pad_tgt])
+                audio_opt.append(
+                    self.vc(
+                        model,
+                        net_g,
+                        sid,
+                        audio_pad[s : t + self.t_pad2 + self.window],
+                        None,
+                        None,
+                        times,
+                        index,
+                        big_npy,
+                        index_rate,
+                    )[self.t_pad_tgt : -self.t_pad_tgt]
+                )
             s = t
-        if (if_f0 == 1):
-            audio_opt.append(self.vc(model,net_g,sid,audio_pad[t:],pitch[:,t//self.window:]if t is not None else pitch,pitchf[:,t//self.window:]if t is not None else pitchf,times,index,big_npy,index_rate)[self.t_pad_tgt:-self.t_pad_tgt])
+        if if_f0 == 1:
+            audio_opt.append(
+                self.vc(
+                    model,
+                    net_g,
+                    sid,
+                    audio_pad[t:],
+                    pitch[:, t // self.window :] if t is not None else pitch,
+                    pitchf[:, t // self.window :] if t is not None else pitchf,
+                    times,
+                    index,
+                    big_npy,
+                    index_rate,
+                )[self.t_pad_tgt : -self.t_pad_tgt]
+            )
         else:
-            audio_opt.append(self.vc(model,net_g,sid,audio_pad[t:],None,None,times,index,big_npy,index_rate)[self.t_pad_tgt:-self.t_pad_tgt])
-        audio_opt=np.concatenate(audio_opt)
-        del pitch,pitchf,sid
-        torch.cuda.empty_cache()
+            audio_opt.append(
+                self.vc(
+                    model,
+                    net_g,
+                    sid,
+                    audio_pad[t:],
+                    None,
+                    None,
+                    times,
+                    index,
+                    big_npy,
+                    index_rate,
+                )[self.t_pad_tgt : -self.t_pad_tgt]
+            )
+        audio_opt = np.concatenate(audio_opt)
+        del pitch, pitchf, sid
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
         return audio_opt