Duplicate from Lycoris53/VITS-TTS-Japanese-Only-Amitaro

.gitattributes

@@ -0,0 +1 @@
+*.pth filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+.ipynb_checkpoints/
+__pycache__/
+pretrained_models/

ConvertBitrate.ipynb

@@ -0,0 +1,165 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8775d691",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import librosa\n",
+    "import os\n",
+    "import soundfile\n",
+    "from tqdm import tqdm, tqdm_notebook"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bcd1f6dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 26%|█████████████████████████████████████████████▊                                                                                                                                  | 2606/10000 [01:01<02:54, 42.35it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total audio file written : 2606\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "base_dir = \"../data/amitaro\"\n",
+    "output_dir = \"../data/amitaro_22050hz\"\n",
+    "all_dir = [f for f in os.listdir(base_dir) if not os.path.isfile(os.path.join(base_dir, f))]\n",
+    "\n",
+    "file_list = []\n",
+    "\n",
+    "skip_dir = [\"301_dousa\",\n",
+    "            \"801_eng_suuji\",\n",
+    "            \"801_eng_jikan\",\n",
+    "            \"803_eng_others\",\n",
+    "            \"912_alphabet\",\n",
+    "            \"912_alphabet2\",\n",
+    "            \"913_web\",\n",
+    "            \"sample\"]\n",
+    "\n",
+    "total_file_write = 0\n",
+    "\n",
+    "def recursive_til_audio_file_found(path):\n",
+    "    listed_dir = [f for f in os.listdir(path)]\n",
+    "    if len(listed_dir) == 0:\n",
+    "        return\n",
+    "    test_path_first = os.path.join(path, listed_dir[0])\n",
+    "    \n",
+    "    # continue through the directory if not a file\n",
+    "    if not os.path.isfile(test_path_first):\n",
+    "        for next_dir in listed_dir:\n",
+    "            next_path = os.path.join(path, next_dir)\n",
+    "            # skip any directory specify in skip_dir\n",
+    "            for skip in skip_dir:\n",
+    "                if next_path.find(skip) != -1:\n",
+    "                    break\n",
+    "            else:\n",
+    "                recursive_til_audio_file_found(next_path)\n",
+    "        return\n",
+    "\n",
+    "    #for new_dir in tqdm_notebook(listed_dir, desc=f\"Processing : {path}\"):\n",
+    "    for new_dir in listed_dir:\n",
+    "        new_path = os.path.join(path, new_dir)\n",
+    "        \n",
+    "        #if it is file, convert the audio to 16k and write to output directory\n",
+    "#        output_path_base = path.replace(base_dir, output_dir)\n",
+    "#        if not os.path.exists(output_path_base):\n",
+    "#            os.makedirs(output_path_base, exist_ok=True)\n",
+    "\n",
+    "        # not an audio file\n",
+    "        if new_path.find(\".wav\") == -1 and new_path.find(\".mp3\") == -1:\n",
+    "            continue\n",
+    "\n",
+    "        global total_file_write\n",
+    "#        audio, rate = librosa.load(new_path, sr=16000)\n",
+    "        audio, rate = librosa.load(new_path, sr=22050)\n",
+    "#        output_path = os.path.join(output_path_base, new_dir)\n",
+    "        output_path = os.path.join(output_dir, new_dir)\n",
+    "#        output_path = os.path.join(output_dir, \"sakuramiko_\" + str(total_file_write) + \".wav\")\n",
+    "#        output_path = os.path.join(output_dir, new_dir[0:-4] + \".wav\")\n",
+    "        soundfile.write(output_path, audio, rate, format='wav', subtype=\"PCM_16\")\n",
+    "        file_list.append(new_dir)\n",
+    "        \n",
+    "        total_file_write += 1\n",
+    "        pbar.update(1)\n",
+    "        #print(f\"\\rWrite file{output_path}\", end=\"\")\n",
+    "        \n",
+    "with tqdm(total=10000) as pbar:\n",
+    "    recursive_til_audio_file_found(base_dir)\n",
+    "print(f\"Total audio file written : {total_file_write}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7efe2fec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "base_dir = \"../data/amitaro_22050hz\"\n",
+    "output_dir = \"./custom_character_voice/amitaro\"\n",
+    "listed_dir = [f for f in os.listdir(base_dir)]\n",
+    "for i, val in enumerate(listed_dir):\n",
+    "    os.rename(os.path.join(base_dir, val), os.path.join(output_dir, f\"amitaro_{i}.wav\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34c1fd46",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "out_json = {}\n",
+    "for val in file_list:\n",
+    "    out_json[val] = {\"path\":val, \"kana\":\"\"}\n",
+    "    \n",
+    "with open(\"./amitaro.json\", \"w\") as outfile:\n",
+    "    outfile.write(json.dumps(out_json))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

ConvertBitrate.py

@@ -0,0 +1,77 @@
+import librosa
+import os
+import soundfile
+from tqdm import tqdm, tqdm_notebook
+
+base_dir = "./data_sakuramiko_senbetsu"
+output_dir = "./plachta/VITS-fast-fine-tuning/custom_character_voice/sakuramiko"
+all_dir = [f for f in os.listdir(base_dir) if not os.path.isfile(os.path.join(base_dir, f))]
+
+file_list = []
+
+skip_dir = ["301_dousa",
+            "801_eng_suuji",
+            "801_eng_jikan",
+            "803_eng_others",
+            "912_alphabet",
+            "912_alphabet2",
+            "913_web",
+            "sample"]
+
+total_file_write = 0
+
+def recursive_til_audio_file_found(path):
+    listed_dir = [f for f in os.listdir(path)]
+    if len(listed_dir) == 0:
+        return
+    test_path_first = os.path.join(path, listed_dir[0])
+    
+    # continue through the directory if not a file
+    if not os.path.isfile(test_path_first):
+        for next_dir in listed_dir:
+            next_path = os.path.join(path, next_dir)
+            # skip any directory specify in skip_dir
+            for skip in skip_dir:
+                if next_path.find(skip) != -1:
+                    break
+            else:
+                recursive_til_audio_file_found(next_path)
+        return
+
+    #for new_dir in tqdm_notebook(listed_dir, desc=f"Processing : {path}"):
+    for new_dir in listed_dir:
+        new_path = os.path.join(path, new_dir)
+        
+        #if it is file, convert the audio to 16k and write to output directory
+#        output_path_base = path.replace(base_dir, output_dir)
+#        if not os.path.exists(output_path_base):
+#            os.makedirs(output_path_base, exist_ok=True)
+
+        # not an audio file
+        if new_path.find(".wav") == -1 and new_path.find(".mp3") == -1:
+            continue
+
+        global total_file_write
+#        audio, rate = librosa.load(new_path, sr=16000)
+        audio, rate = librosa.load(new_path, sr=22050)
+#        output_path = os.path.join(output_path_base, new_dir)
+        output_path = os.path.join(output_dir, "sakuramiko_" + str(total_file_write) + ".wav")
+#        output_path = os.path.join(output_dir, new_dir[0:-4] + ".wav")
+        soundfile.write(output_path, audio, rate, format='wav', subtype="PCM_16")
+        file_list.append(new_dir)
+        
+        total_file_write += 1
+        pbar.update(1)
+        #print(f"\rWrite file{output_path}", end="")
+        
+with tqdm(total=24778) as pbar:
+    recursive_til_audio_file_found(base_dir)
+print(f"Total audio file written : {total_file_write}")
+
+import json
+out_json = {}
+for val in file_list:
+    out_json[val] = {"path":val, "kana":""}
+    
+with open("./amitaro.json", "w") as outfile:
+    outfile.write(json.dumps(out_json))

LICENSE

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

OUTPUT_MODEL/D_Amitaro.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4610d88f7ce89c54e7bbee6fe1a60b9c98ade40dc8ec052624d0fcac67d6676c
+size 187027092

OUTPUT_MODEL/G_Amitaro.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7644eed4b2c8afd8102ba6ec231a81d620d3a9bd5b659c1481552a3b2d4fdbc9
+size 158888169

OUTPUT_MODEL/config.json

@@ -0,0 +1,56 @@
+{
+  "train": {
+    "log_interval": 200,
+    "eval_interval": 1000,
+    "seed": 1234,
+    "epochs": 10000,
+    "learning_rate": 2e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "batch_size": 1,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 8192,
+    "init_lr_ratio": 1,
+    "warmup_epochs": 0,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "training_files":"./final_annotation_train.txt",
+    "validation_files":"./final_annotation_val.txt",
+    "text_cleaners":["japanese_cleaners"],
+    "max_wav_value": 32768.0,
+    "sampling_rate": 22050,
+    "filter_length": 1024,
+    "hop_length": 256,
+    "win_length": 1024,
+    "n_mel_channels": 80,
+    "mel_fmin": 0.0,
+    "mel_fmax": null,
+    "add_blank": true,
+    "n_speakers": 1,
+    "cleaned_text": true
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0.1,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [8,8,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [16,16,4,4],
+    "n_layers_q": 3,
+    "use_spectral_norm": false,
+    "gin_channels": 256
+  },
+  "speakers": {"amitaro":0
+  },
+  "symbols": ["_", ",", ".", "!", "?", "-", "A", "E", "I", "N", "O", "Q", "U", "a", "b", "d", "e", "f", "g", "h", "i", "j", "k", "m", "n", "o", "p", "r", "s", "t", "u", "v", "w", "y", "z", "\u0283", "\u02a7", "\u2193", "\u2191", " "]
+}

ParseAmitaroHTML.py

@@ -0,0 +1,68 @@
+pip --cert /etc/pki/ca-trust/source/anchors/tri-ace-CA-2015.cer install --trusted-host pypi.org --trusted-host files.pythonhosted.org beautifulsoup4
+
+from bs4 import BeautifulSoup
+
+f = open("./amitaro.htm", "r")
+txt = f.read()
+soup = BeautifulSoup(txt)
+print(soup.prettify())
+
+import json
+f = open('amitaro.json')
+file_list = json.load(f)
+
+td = soup.find_all('td')
+for i, val in enumerate(td):
+    if len(val.contents) == 0:
+        continue
+    key = val.contents[0]
+    if key in file_list:
+        #print(td[i-1].contents[0])
+        if len(td[i-1].contents) > 0:
+            #print(td[i-1].contents[0])
+            temp = BeautifulSoup(str(td[i-1].contents[0]))
+            a = temp.find_all('a')
+            print(a[0].contents[0])
+            file_list[key]["kana"] = str(a[0].contents[0])
+
+with open("./amitaro_with_kana.json", "w") as outfile:
+    outfile.write(json.dumps(file_list, indent=4,ensure_ascii=False))
+
+for key, val in file_list.items():
+    val["path"] = "./data_amitaro22k/" + val["path"]
+
+with open("./amitaro_with_kana.json", "w") as outfile:
+    outfile.write(json.dumps(file_list, indent=4,ensure_ascii=False))
+
+file = []
+for key, val in file_list.items():
+    if len(val['kana']) == 0:
+        continue
+    if val['kana'].find("（") != -1:
+        continue
+    file.append(f"{val['path']}|10|{val['kana']}")
+    
+amitaro_train = []
+amitaro_val = []
+for val in file:
+    amitaro_train.append(val)
+
+import random
+
+rands = []    
+while len(rands) < len(file)/10:
+    rand_num = random.randint(0, len(file)-1)
+    if rand_num in rands:
+        continue
+    amitaro_val.append(file[rand_num])
+    rands.append(rand_num)
+
+f = open("amitaro_train.txt", "w")
+for val in amitaro_train:
+    f.write(f"{val}\n")
+f.close()
+
+f = open("amitaro_val.txt", "w")
+for val in amitaro_val:
+    f.write(f"{val}\n")
+f.close()

README.md

@@ -0,0 +1,13 @@
+---
+title: VITS-TTS-Japanese-Only-Amitaro
+emoji: 🚀
+colorFrom: blue
+colorTo: pink
+sdk: gradio
+sdk_version: 3.27.0
+app_file: app.py
+pinned: false
+python_version: '3.10'
+license: apache-2.0
+duplicated_from: Lycoris53/VITS-TTS-Japanese-Only-Amitaro
+---

Test_Inference.ipynb

@@ -0,0 +1,129 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5dde1b9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import utils\n",
+    "from models import SynthesizerTrn\n",
+    "import torch\n",
+    "from torch import no_grad, LongTensor\n",
+    "import librosa\n",
+    "from text import text_to_sequence, _clean_text\n",
+    "import commons\n",
+    "import scipy.io.wavfile as wavf\n",
+    "import os\n",
+    "\n",
+    "import IPython.display as ipd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f4bc040a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:root:Loaded checkpoint './OUTPUT_MODEL/G_latest.pth' (iteration 601)\n",
+      "o↑hayoogozaima↓sU.\n",
+      " length:18\n",
+      " length:18\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "                <audio  controls=\"controls\" >\n",
+       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
+       "                    Your browser does not support the audio element.\n",
+       "                </audio>\n",
+       "              "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.Audio object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model_path = \"./OUTPUT_MODEL/G_latest.pth\"\n",
+    "config_path = \"./OUTPUT_MODEL/config.json\"\n",
+    "\n",
+    "length = 1.0\n",
+    "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
+    "\n",
+    "def get_text(text, hps, is_symbol):\n",
+    "    text_norm = text_to_sequence(text, hps.symbols, [] if is_symbol else hps.data.text_cleaners)\n",
+    "    if hps.data.add_blank:\n",
+    "        text_norm = commons.intersperse(text_norm, 0)\n",
+    "    text_norm = LongTensor(text_norm)\n",
+    "    return text_norm\n",
+    "\n",
+    "hps = utils.get_hparams_from_file(config_path)\n",
+    "net_g = SynthesizerTrn(\n",
+    "    len(hps.symbols),\n",
+    "    hps.data.filter_length // 2 + 1,\n",
+    "    hps.train.segment_size // hps.data.hop_length,\n",
+    "    n_speakers=hps.data.n_speakers,\n",
+    "    **hps.model).to(device)\n",
+    "_ = net_g.eval()\n",
+    "_ = utils.load_checkpoint(model_path, net_g, None)\n",
+    "\n",
+    "speaker_ids = hps.speakers\n",
+    "\n",
+    "text = \"おはようございます。\"\n",
+    "#text = \"[JA]\" + text + \"[JA]\"\n",
+    "speaker_id = 0\n",
+    "stn_tst = get_text(text, hps, False)\n",
+    "with no_grad():\n",
+    "    x_tst = stn_tst.unsqueeze(0).to(device)\n",
+    "    x_tst_lengths = LongTensor([stn_tst.size(0)]).to(device)\n",
+    "    sid = LongTensor([speaker_id]).to(device)\n",
+    "    audio = net_g.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=.667, noise_scale_w=0.6,\n",
+    "                        length_scale=1.0 / length)[0][0, 0].data.cpu().float().numpy()\n",
+    "del stn_tst, x_tst, x_tst_lengths, sid\n",
+    "\n",
+    "ipd.display(ipd.Audio(audio, rate=hps.data.sampling_rate, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "032cc92d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

VC_inference.py

@@ -0,0 +1,146 @@
+import os
+import numpy as np
+import torch
+from torch import no_grad, LongTensor
+import argparse
+import commons
+from mel_processing import spectrogram_torch
+import utils
+from models import SynthesizerTrn
+import gradio as gr
+import librosa
+import webbrowser
+
+from text import text_to_sequence, _clean_text
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
+import logging
+logging.getLogger("PIL").setLevel(logging.WARNING)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+logging.getLogger("markdown_it").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("asyncio").setLevel(logging.WARNING)
+
+language_marks = {
+    "Japanese": "",
+    "日本語": "[JA]",
+    "简体中文": "[ZH]",
+    "English": "[EN]",
+    "Mix": "",
+}
+lang = ['日本語', '简体中文', 'English', 'Mix']
+def get_text(text, hps, is_symbol):
+    text_norm = text_to_sequence(text, hps.symbols, [] if is_symbol else hps.data.text_cleaners)
+    if hps.data.add_blank:
+        text_norm = commons.intersperse(text_norm, 0)
+    text_norm = LongTensor(text_norm)
+    return text_norm
+
+def create_tts_fn(model, hps, speaker_ids):
+    def tts_fn(text, speaker, language, speed):
+        if language is not None:
+            text = language_marks[language] + text + language_marks[language]
+        speaker_id = speaker_ids[speaker]
+        stn_tst = get_text(text, hps, False)
+        with no_grad():
+            x_tst = stn_tst.unsqueeze(0).to(device)
+            x_tst_lengths = LongTensor([stn_tst.size(0)]).to(device)
+            sid = LongTensor([speaker_id]).to(device)
+            audio = model.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=.667, noise_scale_w=0.8,
+                                length_scale=1.0 / speed)[0][0, 0].data.cpu().float().numpy()
+        del stn_tst, x_tst, x_tst_lengths, sid
+        return "Success", (hps.data.sampling_rate, audio)
+
+    return tts_fn
+
+def create_vc_fn(model, hps, speaker_ids):
+    def vc_fn(original_speaker, target_speaker, record_audio, upload_audio):
+        input_audio = record_audio if record_audio is not None else upload_audio
+        if input_audio is None:
+            return "You need to record or upload an audio", None
+        sampling_rate, audio = input_audio
+        original_speaker_id = speaker_ids[original_speaker]
+        target_speaker_id = speaker_ids[target_speaker]
+
+        audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
+        if len(audio.shape) > 1:
+            audio = librosa.to_mono(audio.transpose(1, 0))
+        if sampling_rate != hps.data.sampling_rate:
+            audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=hps.data.sampling_rate)
+        with no_grad():
+            y = torch.FloatTensor(audio)
+            y = y / max(-y.min(), y.max()) / 0.99
+            y = y.to(device)
+            y = y.unsqueeze(0)
+            spec = spectrogram_torch(y, hps.data.filter_length,
+                                     hps.data.sampling_rate, hps.data.hop_length, hps.data.win_length,
+                                     center=False).to(device)
+            spec_lengths = LongTensor([spec.size(-1)]).to(device)
+            sid_src = LongTensor([original_speaker_id]).to(device)
+            sid_tgt = LongTensor([target_speaker_id]).to(device)
+            audio = model.voice_conversion(spec, spec_lengths, sid_src=sid_src, sid_tgt=sid_tgt)[0][
+                0, 0].data.cpu().float().numpy()
+        del y, spec, spec_lengths, sid_src, sid_tgt
+        return "Success", (hps.data.sampling_rate, audio)
+
+    return vc_fn
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_dir", default="./G_latest.pth", help="directory to your fine-tuned model")
+    parser.add_argument("--config_dir", default="./finetune_speaker.json", help="directory to your model config file")
+    parser.add_argument("--share", default=False, help="make link public (used in colab)")
+
+    args = parser.parse_args()
+    hps = utils.get_hparams_from_file(args.config_dir)
+
+
+    net_g = SynthesizerTrn(
+        len(hps.symbols),
+        hps.data.filter_length // 2 + 1,
+        hps.train.segment_size // hps.data.hop_length,
+        n_speakers=hps.data.n_speakers,
+        **hps.model).to(device)
+    _ = net_g.eval()
+
+    _ = utils.load_checkpoint(args.model_dir, net_g, None)
+    speaker_ids = hps.speakers
+    speakers = list(hps.speakers.keys())
+    tts_fn = create_tts_fn(net_g, hps, speaker_ids)
+    vc_fn = create_vc_fn(net_g, hps, speaker_ids)
+    app = gr.Blocks()
+    with app:
+        with gr.Tab("Text-to-Speech"):
+            with gr.Row():
+                with gr.Column():
+                    textbox = gr.TextArea(label="Text",
+                                          placeholder="Type your sentence here",
+                                          value="こんにちわ。", elem_id=f"tts-input")
+                    # select character
+                    char_dropdown = gr.Dropdown(choices=speakers, value=speakers[0], label='character')
+                    language_dropdown = gr.Dropdown(choices=lang, value=lang[0], label='language')
+                    duration_slider = gr.Slider(minimum=0.1, maximum=5, value=1, step=0.1,
+                                                label='速度 Speed')
+                with gr.Column():
+                    text_output = gr.Textbox(label="Message")
+                    audio_output = gr.Audio(label="Output Audio", elem_id="tts-audio")
+                    btn = gr.Button("Generate!")
+                    btn.click(tts_fn,
+                              inputs=[textbox, char_dropdown, language_dropdown, duration_slider,],
+                              outputs=[text_output, audio_output])
+        with gr.Tab("Voice Conversion"):
+            gr.Markdown("""
+                            录制或上传声音，并选择要转换的音色。
+            """)
+            with gr.Column():
+                record_audio = gr.Audio(label="record your voice", source="microphone")
+                upload_audio = gr.Audio(label="or upload audio here", source="upload")
+                source_speaker = gr.Dropdown(choices=speakers, value=speakers[0], label="source speaker")
+                target_speaker = gr.Dropdown(choices=speakers, value=speakers[0], label="target speaker")
+            with gr.Column():
+                message_box = gr.Textbox(label="Message")
+                converted_audio = gr.Audio(label='converted audio')
+            btn = gr.Button("Convert!")
+            btn.click(vc_fn, inputs=[source_speaker, target_speaker, record_audio, upload_audio],
+                      outputs=[message_box, converted_audio])
+    webbrowser.open("http://127.0.0.1:7860")
+    app.launch(share=args.share)
+

amitaro_jp_base.json

@@ -0,0 +1,56 @@
+{
+  "train": {
+    "log_interval": 200,
+    "eval_interval": 1000,
+    "seed": 1234,
+    "epochs": 10000,
+    "learning_rate": 2e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "batch_size": 8,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 8192,
+    "init_lr_ratio": 1,
+    "warmup_epochs": 0,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "training_files":"./final_annotation_train.txt",
+    "validation_files":"./final_annotation_val.txt",
+    "text_cleaners":["japanese_cleaners"],
+    "max_wav_value": 32768.0,
+    "sampling_rate": 22050,
+    "filter_length": 1024,
+    "hop_length": 256,
+    "win_length": 1024,
+    "n_mel_channels": 80,
+    "mel_fmin": 0.0,
+    "mel_fmax": null,
+    "add_blank": true,
+    "n_speakers": 1,
+    "cleaned_text": true
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0.1,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [8,8,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [16,16,4,4],
+    "n_layers_q": 3,
+    "use_spectral_norm": false,
+    "gin_channels": 256
+  },
+  "speakers": {"amitaro":0
+  },
+  "symbols": ["_", ",", ".", "!", "?", "-", "A", "E", "I", "N", "O", "Q", "U", "a", "b", "d", "e", "f", "g", "h", "i", "j", "k", "m", "n", "o", "p", "r", "s", "t", "u", "v", "w", "y", "z", "\u0283", "\u02a7", "\u2193", "\u2191", " "]
+}

app.py

@@ -0,0 +1,66 @@
+import utils
+from models import SynthesizerTrn
+import torch
+from torch import no_grad, LongTensor
+from text import text_to_sequence
+import gradio as gr
+import commons
+
+model_path = "./OUTPUT_MODEL/G_Amitaro.pth"
+config_path = "./OUTPUT_MODEL/config.json"
+
+length = 1.0
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+def get_text(text, hps, is_symbol):
+    text_norm = text_to_sequence(text, hps.symbols, [] if is_symbol else hps.data.text_cleaners)
+    if hps.data.add_blank:
+        text_norm = commons.intersperse(text_norm, 0)
+    text_norm = LongTensor(text_norm)
+    return text_norm
+
+def get_vits_array(text):
+    hps = utils.get_hparams_from_file(config_path)
+    net_g = SynthesizerTrn(
+        len(hps.symbols),
+        hps.data.filter_length // 2 + 1,
+        hps.train.segment_size // hps.data.hop_length,
+        n_speakers=hps.data.n_speakers,
+        **hps.model).to(device)
+    _ = net_g.eval()
+    _ = utils.load_checkpoint(model_path, net_g, None)
+    
+    speaker_ids = hps.speakers
+    
+    #text = "[JA]" + text + "[JA]"
+    speaker_id = 0
+    stn_tst = get_text(text, hps, False)
+    with no_grad():
+        x_tst = stn_tst.unsqueeze(0).to(device)
+        x_tst_lengths = LongTensor([stn_tst.size(0)]).to(device)
+        sid = LongTensor([speaker_id]).to(device)
+        audio = net_g.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=.667, noise_scale_w=0.6,
+                            length_scale=1.0 / length)[0][0, 0].data.cpu().float().numpy()
+    del stn_tst, x_tst, x_tst_lengths, sid
+    
+    return (hps.data.sampling_rate, audio)
+
+app = gr.Blocks()
+with app:
+    gr.Markdown("# VITS-TTS-Japanese-Only-Amitaro\n\n"
+        		"Sample usage of Finetune model [Lycoris53/Vits-Japanese-Only-Amitaro](https://huggingface.co/Lycoris53/Vits-Japanese-Only-Amitaro) \n"
+                "Base finetuning code is from [Plachtaa/VITS-fast-fine-tuning](https://github.com/Plachtaa/VITS-fast-fine-tuning)"
+                )
+    with gr.Row():
+        with gr.Column():
+            textbox = gr.TextArea(label="Text",
+                                  placeholder="Type your sentence here (Maximum 150 words)",
+                                  value="おはようございます。")
+        with gr.Column():
+            audio_output = gr.Audio(label="Output Audio")
+            btn = gr.Button("Generate　Voice!")
+            btn.click(get_vits_array,
+                      inputs=[textbox],
+                      outputs=[audio_output])
+
+app.queue(concurrency_count=3).launch()

attentions.py

@@ -0,0 +1,303 @@
+import copy
+import math
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import commons
+import modules
+from modules import LayerNorm
+   
+
+class Encoder(nn.Module):
+  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **kwargs):
+    super().__init__()
+    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.window_size = window_size
+
+    self.drop = nn.Dropout(p_dropout)
+    self.attn_layers = nn.ModuleList()
+    self.norm_layers_1 = nn.ModuleList()
+    self.ffn_layers = nn.ModuleList()
+    self.norm_layers_2 = nn.ModuleList()
+    for i in range(self.n_layers):
+      self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
+      self.norm_layers_1.append(LayerNorm(hidden_channels))
+      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
+      self.norm_layers_2.append(LayerNorm(hidden_channels))
+
+  def forward(self, x, x_mask):
+    attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+    x = x * x_mask
+    for i in range(self.n_layers):
+      y = self.attn_layers[i](x, x, attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_1[i](x + y)
+
+      y = self.ffn_layers[i](x, x_mask)
+      y = self.drop(y)
+      x = self.norm_layers_2[i](x + y)
+    x = x * x_mask
+    return x
+
+
+class Decoder(nn.Module):
+  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
+    super().__init__()
+    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.proximal_bias = proximal_bias
+    self.proximal_init = proximal_init
+
+    self.drop = nn.Dropout(p_dropout)
+    self.self_attn_layers = nn.ModuleList()
+    self.norm_layers_0 = nn.ModuleList()
+    self.encdec_attn_layers = nn.ModuleList()
+    self.norm_layers_1 = nn.ModuleList()
+    self.ffn_layers = nn.ModuleList()
+    self.norm_layers_2 = nn.ModuleList()
+    for i in range(self.n_layers):
+      self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
+      self.norm_layers_0.append(LayerNorm(hidden_channels))
+      self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
+      self.norm_layers_1.append(LayerNorm(hidden_channels))
+      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
+      self.norm_layers_2.append(LayerNorm(hidden_channels))
+
+  def forward(self, x, x_mask, h, h_mask):
+    """
+    x: decoder input
+    h: encoder output
+    """
+    self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
+    encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+    x = x * x_mask
+    for i in range(self.n_layers):
+      y = self.self_attn_layers[i](x, x, self_attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_0[i](x + y)
+
+      y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_1[i](x + y)
+      
+      y = self.ffn_layers[i](x, x_mask)
+      y = self.drop(y)
+      x = self.norm_layers_2[i](x + y)
+    x = x * x_mask
+    return x
+
+
+class MultiHeadAttention(nn.Module):
+  def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
+    super().__init__()
+    assert channels % n_heads == 0
+
+    self.channels = channels
+    self.out_channels = out_channels
+    self.n_heads = n_heads
+    self.p_dropout = p_dropout
+    self.window_size = window_size
+    self.heads_share = heads_share
+    self.block_length = block_length
+    self.proximal_bias = proximal_bias
+    self.proximal_init = proximal_init
+    self.attn = None
+
+    self.k_channels = channels // n_heads
+    self.conv_q = nn.Conv1d(channels, channels, 1)
+    self.conv_k = nn.Conv1d(channels, channels, 1)
+    self.conv_v = nn.Conv1d(channels, channels, 1)
+    self.conv_o = nn.Conv1d(channels, out_channels, 1)
+    self.drop = nn.Dropout(p_dropout)
+
+    if window_size is not None:
+      n_heads_rel = 1 if heads_share else n_heads
+      rel_stddev = self.k_channels**-0.5
+      self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
+      self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
+
+    nn.init.xavier_uniform_(self.conv_q.weight)
+    nn.init.xavier_uniform_(self.conv_k.weight)
+    nn.init.xavier_uniform_(self.conv_v.weight)
+    if proximal_init:
+      with torch.no_grad():
+        self.conv_k.weight.copy_(self.conv_q.weight)
+        self.conv_k.bias.copy_(self.conv_q.bias)
+      
+  def forward(self, x, c, attn_mask=None):
+    q = self.conv_q(x)
+    k = self.conv_k(c)
+    v = self.conv_v(c)
+    
+    x, self.attn = self.attention(q, k, v, mask=attn_mask)
+
+    x = self.conv_o(x)
+    return x
+
+  def attention(self, query, key, value, mask=None):
+    # reshape [b, d, t] -> [b, n_h, t, d_k]
+    b, d, t_s, t_t = (*key.size(), query.size(2))
+    query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
+    key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+    value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+
+    scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
+    if self.window_size is not None:
+      assert t_s == t_t, "Relative attention is only available for self-attention."
+      key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
+      rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
+      scores_local = self._relative_position_to_absolute_position(rel_logits)
+      scores = scores + scores_local
+    if self.proximal_bias:
+      assert t_s == t_t, "Proximal bias is only available for self-attention."
+      scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
+    if mask is not None:
+      scores = scores.masked_fill(mask == 0, -1e4)
+      if self.block_length is not None:
+        assert t_s == t_t, "Local attention is only available for self-attention."
+        block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
+        scores = scores.masked_fill(block_mask == 0, -1e4)
+    p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
+    p_attn = self.drop(p_attn)
+    output = torch.matmul(p_attn, value)
+    if self.window_size is not None:
+      relative_weights = self._absolute_position_to_relative_position(p_attn)
+      value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
+      output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
+    output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
+    return output, p_attn
+
+  def _matmul_with_relative_values(self, x, y):
+    """
+    x: [b, h, l, m]
+    y: [h or 1, m, d]
+    ret: [b, h, l, d]
+    """
+    ret = torch.matmul(x, y.unsqueeze(0))
+    return ret
+
+  def _matmul_with_relative_keys(self, x, y):
+    """
+    x: [b, h, l, d]
+    y: [h or 1, m, d]
+    ret: [b, h, l, m]
+    """
+    ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
+    return ret
+
+  def _get_relative_embeddings(self, relative_embeddings, length):
+    max_relative_position = 2 * self.window_size + 1
+    # Pad first before slice to avoid using cond ops.
+    pad_length = max(length - (self.window_size + 1), 0)
+    slice_start_position = max((self.window_size + 1) - length, 0)
+    slice_end_position = slice_start_position + 2 * length - 1
+    if pad_length > 0:
+      padded_relative_embeddings = F.pad(
+          relative_embeddings,
+          commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
+    else:
+      padded_relative_embeddings = relative_embeddings
+    used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
+    return used_relative_embeddings
+
+  def _relative_position_to_absolute_position(self, x):
+    """
+    x: [b, h, l, 2*l-1]
+    ret: [b, h, l, l]
+    """
+    batch, heads, length, _ = x.size()
+    # Concat columns of pad to shift from relative to absolute indexing.
+    x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
+
+    # Concat extra elements so to add up to shape (len+1, 2*len-1).
+    x_flat = x.view([batch, heads, length * 2 * length])
+    x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
+
+    # Reshape and slice out the padded elements.
+    x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
+    return x_final
+
+  def _absolute_position_to_relative_position(self, x):
+    """
+    x: [b, h, l, l]
+    ret: [b, h, l, 2*l-1]
+    """
+    batch, heads, length, _ = x.size()
+    # padd along column
+    x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
+    x_flat = x.view([batch, heads, length**2 + length*(length -1)])
+    # add 0's in the beginning that will skew the elements after reshape
+    x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
+    x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
+    return x_final
+
+  def _attention_bias_proximal(self, length):
+    """Bias for self-attention to encourage attention to close positions.
+    Args:
+      length: an integer scalar.
+    Returns:
+      a Tensor with shape [1, 1, length, length]
+    """
+    r = torch.arange(length, dtype=torch.float32)
+    diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
+    return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
+
+
+class FFN(nn.Module):
+  def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
+    super().__init__()
+    self.in_channels = in_channels
+    self.out_channels = out_channels
+    self.filter_channels = filter_channels
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.activation = activation
+    self.causal = causal
+
+    if causal:
+      self.padding = self._causal_padding
+    else:
+      self.padding = self._same_padding
+
+    self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
+    self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
+    self.drop = nn.Dropout(p_dropout)
+
+  def forward(self, x, x_mask):
+    x = self.conv_1(self.padding(x * x_mask))
+    if self.activation == "gelu":
+      x = x * torch.sigmoid(1.702 * x)
+    else:
+      x = torch.relu(x)
+    x = self.drop(x)
+    x = self.conv_2(self.padding(x * x_mask))
+    return x * x_mask
+  
+  def _causal_padding(self, x):
+    if self.kernel_size == 1:
+      return x
+    pad_l = self.kernel_size - 1
+    pad_r = 0
+    padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+    x = F.pad(x, commons.convert_pad_shape(padding))
+    return x
+
+  def _same_padding(self, x):
+    if self.kernel_size == 1:
+      return x
+    pad_l = (self.kernel_size - 1) // 2
+    pad_r = self.kernel_size // 2
+    padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+    x = F.pad(x, commons.convert_pad_shape(padding))
+    return x

cmd_inference.py

@@ -0,0 +1,106 @@
+"""该模块用于生成VITS文件
+使用方法
+
+python cmd_inference.py -m 模型路径 -c 配置文件路径 -o 输出文件路径 -l 输入的语言 -t 输入文本 -s 合成目标说话人名称
+
+可选参数
+-ns 感情变化程度
+-nsw 音素发音长度
+-ls 整体语速
+-on 输出文件的名称
+
+"""
+
+from pathlib import Path
+import utils
+from models import SynthesizerTrn
+import torch
+from torch import no_grad, LongTensor
+import librosa
+from text import text_to_sequence, _clean_text
+import commons
+import scipy.io.wavfile as wavf
+import os
+
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+language_marks = {
+    "Japanese": "",
+    "日本語": "[JA]",
+    "简体中文": "[ZH]",
+    "English": "[EN]",
+    "Mix": "",
+}
+
+
+def get_text(text, hps, is_symbol):
+    text_norm = text_to_sequence(text, hps.symbols, [] if is_symbol else hps.data.text_cleaners)
+    if hps.data.add_blank:
+        text_norm = commons.intersperse(text_norm, 0)
+    text_norm = LongTensor(text_norm)
+    return text_norm
+
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description='vits inference')
+    #必须参数
+    parser.add_argument('-m', '--model_path', type=str, default="logs/44k/G_0.pth", help='模型路径')
+    parser.add_argument('-c', '--config_path', type=str, default="configs/config.json", help='配置文件路径')
+    parser.add_argument('-o', '--output_path', type=str, default="output/vits", help='输出文件路径')
+    parser.add_argument('-l', '--language', type=str, default="日本語", help='输入的语言')
+    parser.add_argument('-t', '--text', type=str, help='输入文本')
+    parser.add_argument('-s', '--spk', type=str, help='合成目标说话人名称')
+    #可选参数
+    parser.add_argument('-on', '--output_name', type=str, default="output", help='输出文件的名称')
+    parser.add_argument('-ns', '--noise_scale', type=float,default= .667,help='感情变化程度')
+    parser.add_argument('-nsw', '--noise_scale_w', type=float,default=0.6, help='音素发音长度')
+    parser.add_argument('-ls', '--length_scale', type=float,default=1, help='整体语速')
+    
+    args = parser.parse_args()
+    
+    model_path = args.model_path
+    config_path = args.config_path
+    output_dir = Path(args.output_path)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    language = args.language
+    text = args.text
+    spk = args.spk
+    noise_scale = args.noise_scale
+    noise_scale_w = args.noise_scale_w
+    length = args.length_scale
+    output_name = args.output_name
+    
+    hps = utils.get_hparams_from_file(config_path)
+    net_g = SynthesizerTrn(
+        len(hps.symbols),
+        hps.data.filter_length // 2 + 1,
+        hps.train.segment_size // hps.data.hop_length,
+        n_speakers=hps.data.n_speakers,
+        **hps.model).to(device)
+    _ = net_g.eval()
+    _ = utils.load_checkpoint(model_path, net_g, None)
+    
+    speaker_ids = hps.speakers
+
+
+    if language is not None:
+        text = language_marks[language] + text + language_marks[language]
+        speaker_id = speaker_ids[spk]
+        stn_tst = get_text(text, hps, False)
+        with no_grad():
+            x_tst = stn_tst.unsqueeze(0).to(device)
+            x_tst_lengths = LongTensor([stn_tst.size(0)]).to(device)
+            sid = LongTensor([speaker_id]).to(device)
+            audio = net_g.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=noise_scale, noise_scale_w=noise_scale_w,
+                                length_scale=1.0 / length)[0][0, 0].data.cpu().float().numpy()
+        del stn_tst, x_tst, x_tst_lengths, sid
+
+        wavf.write(str(output_dir)+"/"+output_name+".wav",hps.data.sampling_rate,audio)
+    
+
+    
+    

commons.py

@@ -0,0 +1,164 @@
+import math
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+def init_weights(m, mean=0.0, std=0.01):
+  classname = m.__class__.__name__
+  if classname.find("Conv") != -1:
+    m.weight.data.normal_(mean, std)
+
+
+def get_padding(kernel_size, dilation=1):
+  return int((kernel_size*dilation - dilation)/2)
+
+
+def convert_pad_shape(pad_shape):
+  l = pad_shape[::-1]
+  pad_shape = [item for sublist in l for item in sublist]
+  return pad_shape
+
+
+def intersperse(lst, item):
+  result = [item] * (len(lst) * 2 + 1)
+  result[1::2] = lst
+  return result
+
+
+def kl_divergence(m_p, logs_p, m_q, logs_q):
+  """KL(P||Q)"""
+  kl = (logs_q - logs_p) - 0.5
+  kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * logs_q)
+  return kl
+
+
+def rand_gumbel(shape):
+  """Sample from the Gumbel distribution, protect from overflows."""
+  uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
+  return -torch.log(-torch.log(uniform_samples))
+
+
+def rand_gumbel_like(x):
+  g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
+  return g
+
+
+def slice_segments(x, ids_str, segment_size=4):
+  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
+    try:
+      ret[i] = x[i, :, idx_str:idx_end]
+    except RuntimeError:
+      print("?")
+  return ret
+
+
+def rand_slice_segments(x, x_lengths=None, segment_size=4):
+  b, d, t = x.size()
+  if x_lengths is None:
+    x_lengths = t
+  ids_str_max = x_lengths - segment_size + 1
+  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
+  ret = slice_segments(x, ids_str, segment_size)
+  return ret, ids_str
+
+
+def get_timing_signal_1d(
+    length, channels, min_timescale=1.0, max_timescale=1.0e4):
+  position = torch.arange(length, dtype=torch.float)
+  num_timescales = channels // 2
+  log_timescale_increment = (
+      math.log(float(max_timescale) / float(min_timescale)) /
+      (num_timescales - 1))
+  inv_timescales = min_timescale * torch.exp(
+      torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
+  scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
+  signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
+  signal = F.pad(signal, [0, 0, 0, channels % 2])
+  signal = signal.view(1, channels, length)
+  return signal
+
+
+def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
+  b, channels, length = x.size()
+  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
+  return x + signal.to(dtype=x.dtype, device=x.device)
+
+
+def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
+  b, channels, length = x.size()
+  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
+  return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
+
+
+def subsequent_mask(length):
+  mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
+  return mask
+
+
+@torch.jit.script
+def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
+  n_channels_int = n_channels[0]
+  in_act = input_a + input_b
+  t_act = torch.tanh(in_act[:, :n_channels_int, :])
+  s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
+  acts = t_act * s_act
+  return acts
+
+
+def convert_pad_shape(pad_shape):
+  l = pad_shape[::-1]
+  pad_shape = [item for sublist in l for item in sublist]
+  return pad_shape
+
+
+def shift_1d(x):
+  x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
+  return x
+
+
+def sequence_mask(length, max_length=None):
+  if max_length is None:
+    max_length = length.max()
+  x = torch.arange(max_length, dtype=length.dtype, device=length.device)
+  return x.unsqueeze(0) < length.unsqueeze(1)
+
+
+def generate_path(duration, mask):
+  """
+  duration: [b, 1, t_x]
+  mask: [b, 1, t_y, t_x]
+  """
+  device = duration.device
+  
+  b, _, t_y, t_x = mask.shape
+  cum_duration = torch.cumsum(duration, -1)
+  
+  cum_duration_flat = cum_duration.view(b * t_x)
+  path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
+  path = path.view(b, t_x, t_y)
+  path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
+  path = path.unsqueeze(1).transpose(2,3) * mask
+  return path
+
+
+def clip_grad_value_(parameters, clip_value, norm_type=2):
+  if isinstance(parameters, torch.Tensor):
+    parameters = [parameters]
+  parameters = list(filter(lambda p: p.grad is not None, parameters))
+  norm_type = float(norm_type)
+  if clip_value is not None:
+    clip_value = float(clip_value)
+
+  total_norm = 0
+  for p in parameters:
+    param_norm = p.grad.data.norm(norm_type)
+    total_norm += param_norm.item() ** norm_type
+    if clip_value is not None:
+      p.grad.data.clamp_(min=-clip_value, max=clip_value)
+  total_norm = total_norm ** (1. / norm_type)
+  return total_norm

configs/amitaro_jp_base.json

@@ -0,0 +1,56 @@
+{
+  "train": {
+    "log_interval": 200,
+    "eval_interval": 1000,
+    "seed": 1234,
+    "epochs": 10000,
+    "learning_rate": 2e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "batch_size": 1,
+    "fp16_run": true,
+    "lr_decay": 0.999875,
+    "segment_size": 8192,
+    "init_lr_ratio": 1,
+    "warmup_epochs": 0,
+    "c_mel": 45,
+    "c_kl": 1.0
+  },
+  "data": {
+    "training_files":"./final_annotation_train.txt",
+    "validation_files":"./final_annotation_val.txt",
+    "text_cleaners":["japanese_cleaners"],
+    "max_wav_value": 32768.0,
+    "sampling_rate": 22050,
+    "filter_length": 1024,
+    "hop_length": 256,
+    "win_length": 1024,
+    "n_mel_channels": 80,
+    "mel_fmin": 0.0,
+    "mel_fmax": null,
+    "add_blank": true,
+    "n_speakers": 1,
+    "cleaned_text": true
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0.1,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [8,8,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [16,16,4,4],
+    "n_layers_q": 3,
+    "use_spectral_norm": false,
+    "gin_channels": 256
+  },
+  "speakers": {"amitaro":0
+  },
+  "symbols": ["_", ",", ".", "!", "?", "-", "A", "E", "I", "N", "O", "Q", "U", "a", "b", "d", "e", "f", "g", "h", "i", "j", "k", "m", "n", "o", "p", "r", "s", "t", "u", "v", "w", "y", "z", "\u0283", "\u02a7", "\u2193", "\u2191", " "]
+}

custom_character_voice/amitaro/amitaro_24.wav

@@ -0,0 +1,4 @@
+[ViewState]
+Mode=
+Vid=
+FolderType=Generic