Upload folder using huggingface_hub

.gitattributes

@@ -35,3 +35,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 AuxiliaryASR/Data/train_list.csv filter=lfs diff=lfs merge=lfs -text
 AuxiliaryASR/Data/train_list_plus.csv filter=lfs diff=lfs merge=lfs -text
+stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/train.log filter=lfs diff=lfs merge=lfs -text
+stts_48khz/StyleTTS2_48khz/Utils/JDC/bst_rmvpe_48k.t7 filter=lfs diff=lfs merge=lfs -text
+stts_48khz/StyleTTS2_48khz/infer.ipynb filter=lfs diff=lfs merge=lfs -text

stts_48khz/StyleTTS2_48khz/.gitignore

@@ -0,0 +1 @@
+__pycache__

stts_48khz/StyleTTS2_48khz/Colab/StyleTTS2_Demo_LJSpeech.ipynb

@@ -0,0 +1,486 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "colab_type": "text",
+        "id": "view-in-github"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/yl4579/StyleTTS2/blob/main/Colab/StyleTTS2_Demo_LJSpeech.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nm653VK4CG9F"
+      },
+      "source": [
+        "### Install packages and download models"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "gciBKMqCCLvT"
+      },
+      "outputs": [],
+      "source": [
+        "%%shell\n",
+        "git clone https://github.com/yl4579/StyleTTS2.git\n",
+        "cd StyleTTS2\n",
+        "pip install SoundFile torchaudio munch torch pydub pyyaml librosa nltk matplotlib accelerate transformers phonemizer einops einops-exts tqdm typing-extensions git+https://github.com/resemble-ai/monotonic_align.git\n",
+        "sudo apt-get install espeak-ng\n",
+        "git-lfs clone https://huggingface.co/yl4579/StyleTTS2-LJSpeech\n",
+        "mv StyleTTS2-LJSpeech/Models ."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OAA8lx-XCQnM"
+      },
+      "source": [
+        "### Load models"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "m0XRpbxSCSix"
+      },
+      "outputs": [],
+      "source": [
+        "%cd StyleTTS2\n",
+        "\n",
+        "import torch\n",
+        "torch.manual_seed(0)\n",
+        "torch.backends.cudnn.benchmark = False\n",
+        "torch.backends.cudnn.deterministic = True\n",
+        "\n",
+        "import random\n",
+        "random.seed(0)\n",
+        "\n",
+        "import numpy as np\n",
+        "np.random.seed(0)\n",
+        "\n",
+        "import nltk\n",
+        "nltk.download('punkt')\n",
+        "\n",
+        "# load packages\n",
+        "import time\n",
+        "import random\n",
+        "import yaml\n",
+        "from munch import Munch\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "from torch import nn\n",
+        "import torch.nn.functional as F\n",
+        "import torchaudio\n",
+        "import librosa\n",
+        "from nltk.tokenize import word_tokenize\n",
+        "\n",
+        "from models import *\n",
+        "from utils import *\n",
+        "from text_utils import TextCleaner\n",
+        "textclenaer = TextCleaner()\n",
+        "\n",
+        "%matplotlib inline\n",
+        "\n",
+        "device = 'cpu' if torch.cuda.is_available() else 'cpu'\n",
+        "\n",
+        "to_mel = torchaudio.transforms.MelSpectrogram(\n",
+        "    n_mels=80, n_fft=2048, win_length=1200, hop_length=300)\n",
+        "mean, std = -4, 4\n",
+        "\n",
+        "def length_to_mask(lengths):\n",
+        "    mask = torch.arange(lengths.max()).unsqueeze(0).expand(lengths.shape[0], -1).type_as(lengths)\n",
+        "    mask = torch.gt(mask+1, lengths.unsqueeze(1))\n",
+        "    return mask\n",
+        "\n",
+        "def preprocess(wave):\n",
+        "    wave_tensor = torch.from_numpy(wave).float()\n",
+        "    mel_tensor = to_mel(wave_tensor)\n",
+        "    mel_tensor = (torch.log(1e-5 + mel_tensor.unsqueeze(0)) - mean) / std\n",
+        "    return mel_tensor\n",
+        "\n",
+        "def compute_style(ref_dicts):\n",
+        "    reference_embeddings = {}\n",
+        "    for key, path in ref_dicts.items():\n",
+        "        wave, sr = librosa.load(path, sr=24000)\n",
+        "        audio, index = librosa.effects.trim(wave, top_db=30)\n",
+        "        if sr != 24000:\n",
+        "            audio = librosa.resample(audio, sr, 24000)\n",
+        "        mel_tensor = preprocess(audio).to(device)\n",
+        "\n",
+        "        with torch.no_grad():\n",
+        "            ref = model.style_encoder(mel_tensor.unsqueeze(1))\n",
+        "        reference_embeddings[key] = (ref.squeeze(1), audio)\n",
+        "\n",
+        "    return reference_embeddings\n",
+        "\n",
+        "# load phonemizer\n",
+        "import phonemizer\n",
+        "global_phonemizer = phonemizer.backend.EspeakBackend(language='en-us', preserve_punctuation=True, with_stress=True, words_mismatch='ignore')\n",
+        "\n",
+        "config = yaml.safe_load(open(\"Models/Kaede-san/config.yml\"))\n",
+        "\n",
+        "# load pretrained ASR model\n",
+        "ASR_config = config.get('ASR_config', False)\n",
+        "ASR_path = config.get('ASR_path', False)\n",
+        "text_aligner = load_ASR_models(ASR_path, ASR_config)\n",
+        "\n",
+        "# load pretrained F0 model\n",
+        "F0_path = config.get('F0_path', False)\n",
+        "pitch_extractor = load_F0_models(F0_path)\n",
+        "\n",
+        "# load BERT model\n",
+        "from Utils.PLBERT.util import load_plbert\n",
+        "BERT_path = config.get('PLBERT_dir', False)\n",
+        "plbert = load_plbert(BERT_path)\n",
+        "\n",
+        "model = build_model(recursive_munch(config['model_params']), text_aligner, pitch_extractor, plbert)\n",
+        "_ = [model[key].eval() for key in model]\n",
+        "_ = [model[key].to(device) for key in model]\n",
+        "\n",
+        "params_whole = torch.load(\"Models/LJSpeech/epoch_2nd_00100.pth\", map_location='cpu')\n",
+        "params = params_whole['net']\n",
+        "\n",
+        "for key in model:\n",
+        "    if key in params:\n",
+        "        print('%s loaded' % key)\n",
+        "        try:\n",
+        "            model[key].load_state_dict(params[key])\n",
+        "        except:\n",
+        "            from collections import OrderedDict\n",
+        "            state_dict = params[key]\n",
+        "            new_state_dict = OrderedDict()\n",
+        "            for k, v in state_dict.items():\n",
+        "                name = k[7:] # remove `module.`\n",
+        "                new_state_dict[name] = v\n",
+        "            # load params\n",
+        "            model[key].load_state_dict(new_state_dict, strict=False)\n",
+        "#             except:\n",
+        "#                 _load(params[key], model[key])\n",
+        "_ = [model[key].eval() for key in model]\n",
+        "\n",
+        "from Modules.diffusion.sampler import DiffusionSampler, ADPM2Sampler, KarrasSchedule\n",
+        "\n",
+        "sampler = DiffusionSampler(\n",
+        "    model.diffusion.diffusion,\n",
+        "    sampler=ADPM2Sampler(),\n",
+        "    sigma_schedule=KarrasSchedule(sigma_min=0.0001, sigma_max=3.0, rho=9.0), # empirical parameters\n",
+        "    clamp=False\n",
+        ")\n",
+        "\n",
+        "def inference(text, noise, diffusion_steps=5, embedding_scale=1):\n",
+        "    text = text.strip()\n",
+        "    text = text.replace('\"', '')\n",
+        "    ps = global_phonemizer.phonemize([text])\n",
+        "    ps = word_tokenize(ps[0])\n",
+        "    ps = ' '.join(ps)\n",
+        "\n",
+        "    tokens = textclenaer(ps)\n",
+        "    tokens.insert(0, 0)\n",
+        "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(tokens.device)\n",
+        "        text_mask = length_to_mask(input_lengths).to(tokens.device)\n",
+        "\n",
+        "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+        "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+        "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2)\n",
+        "\n",
+        "        s_pred = sampler(noise,\n",
+        "              embedding=bert_dur[0].unsqueeze(0), num_steps=diffusion_steps,\n",
+        "              embedding_scale=embedding_scale).squeeze(0)\n",
+        "\n",
+        "        s = s_pred[:, 128:]\n",
+        "        ref = s_pred[:, :128]\n",
+        "\n",
+        "        d = model.predictor.text_encoder(d_en, s, input_lengths, text_mask)\n",
+        "\n",
+        "        x, _ = model.predictor.lstm(d)\n",
+        "        duration = model.predictor.duration_proj(x)\n",
+        "        duration = torch.sigmoid(duration).sum(axis=-1)\n",
+        "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+        "\n",
+        "        pred_dur[-1] += 5\n",
+        "\n",
+        "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+        "        c_frame = 0\n",
+        "        for i in range(pred_aln_trg.size(0)):\n",
+        "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+        "            c_frame += int(pred_dur[i].data)\n",
+        "\n",
+        "        # encode prosody\n",
+        "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+        "        out = model.decoder((t_en @ pred_aln_trg.unsqueeze(0).to(device)),\n",
+        "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+        "\n",
+        "    return out.squeeze().cpu().numpy()\n",
+        "\n",
+        "def LFinference(text, s_prev, noise, alpha=0.7, diffusion_steps=5, embedding_scale=1):\n",
+        "  text = text.strip()\n",
+        "  text = text.replace('\"', '')\n",
+        "  ps = global_phonemizer.phonemize([text])\n",
+        "  ps = word_tokenize(ps[0])\n",
+        "  ps = ' '.join(ps)\n",
+        "\n",
+        "  tokens = textclenaer(\"so↑nna to↓kini, jo↓kaʔta jo↑otoka, ge↓ŋkiga mo↑ɾaeɾʔʔte i↑ʔte mo↑ɾaeɾɯto, so↑ɾedakede ta↑içeɴ↓sanante ɸɯ↑kito↓ndʑa i↑ma↓sɯ. a↑idoɾɯo ja↓ʔte i↑tejo↓kaʔtaʔte o↑moe↓ɾɯ n↓desɯjo. ko↑no ka↑itoo, sɯ↑ko↓ɕi zɯ↑ɾɯ↓ikamo ɕi↑ɾemase↓ŋkedo, wa↑taɕino ço↑ntoono ki↑motɕide↓sɯ.\")\n",
+        "  tokens.insert(0, 0)\n",
+        "  tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+        "\n",
+        "  with torch.no_grad():\n",
+        "      input_lengths = torch.LongTensor([tokens.shape[-1]]).to(tokens.device)\n",
+        "      text_mask = length_to_mask(input_lengths).to(tokens.device)\n",
+        "\n",
+        "      t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+        "      bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+        "      d_en = model.bert_encoder(bert_dur).transpose(-1, -2)\n",
+        "\n",
+        "      s_pred = sampler(noise,\n",
+        "            embedding=bert_dur[0].unsqueeze(0), num_steps=diffusion_steps,\n",
+        "            embedding_scale=embedding_scale).squeeze(0)\n",
+        "\n",
+        "      if s_prev is not None:\n",
+        "          # convex combination of previous and current style\n",
+        "          s_pred = alpha * s_prev + (1 - alpha) * s_pred\n",
+        "\n",
+        "      s = s_pred[:, 128:]\n",
+        "      ref = s_pred[:, :128]\n",
+        "\n",
+        "      d = model.predictor.text_encoder(d_en, s, input_lengths, text_mask)\n",
+        "\n",
+        "      x, _ = model.predictor.lstm(d)\n",
+        "      duration = model.predictor.duration_proj(x)\n",
+        "      duration = torch.sigmoid(duration).sum(axis=-1)\n",
+        "      pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+        "\n",
+        "      pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+        "      c_frame = 0\n",
+        "      for i in range(pred_aln_trg.size(0)):\n",
+        "          pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+        "          c_frame += int(pred_dur[i].data)\n",
+        "\n",
+        "      # encode prosody\n",
+        "      en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "      F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+        "      out = model.decoder((t_en @ pred_aln_trg.unsqueeze(0).to(device)),\n",
+        "                              F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+        "\n",
+        "  return out.squeeze().cpu().numpy(), s_pred"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "vuCbS0gdArgJ"
+      },
+      "source": [
+        "### Synthesize speech"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "7Ud1Y-kbBPTw"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Input Text { display-mode: \"form\" }\n",
+        "# synthesize a text\n",
+        "text = \"StyleTTS 2 is a text-to-speech model that leverages style diffusion and adversarial training with large speech language models to achieve human-level text-to-speech synthesis.\" # @param {type:\"string\"}\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "TM2NjuM7B6sz"
+      },
+      "source": [
+        "#### Basic synthesis (5 diffusion steps)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KILqC-V-Ay5e"
+      },
+      "outputs": [],
+      "source": [
+        "start = time.time()\n",
+        "noise = torch.randn(1,1,256).to(device)\n",
+        "wav = inference(text, noise, diffusion_steps=5, embedding_scale=1)\n",
+        "rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "print(f\"RTF = {rtf:5f}\")\n",
+        "import IPython.display as ipd\n",
+        "display(ipd.Audio(wav, rate=24000))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "oZk9o-EzCBVx"
+      },
+      "source": [
+        "#### With higher diffusion steps (more diverse)\n",
+        "Since the sampler is ancestral, the higher the stpes, the more diverse the samples are, with the cost of slower synthesis speed."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9_OHtzMbB9gL"
+      },
+      "outputs": [],
+      "source": [
+        "start = time.time()\n",
+        "noise = torch.randn(1,1,256).to(device)\n",
+        "wav = inference(text, noise, diffusion_steps=10, embedding_scale=1)\n",
+        "rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "print(f\"RTF = {rtf:5f}\")\n",
+        "import IPython.display as ipd\n",
+        "display(ipd.Audio(wav, rate=24000))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "NyDACd-0CaqL"
+      },
+      "source": [
+        "### Speech expressiveness\n",
+        "The following section recreates the samples shown in [Section 6](https://styletts2.github.io/#emo) of the demo page."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "cRkS5VWxCck4"
+      },
+      "source": [
+        "#### With embedding_scale=1\n",
+        "This is the classifier-free guidance scale. The higher the scale, the more conditional the style is to the input text and hence more emotional."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "H5g5RO-mCbZB"
+      },
+      "outputs": [],
+      "source": [
+        "texts = {}\n",
+        "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+        "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+        "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+        "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+        "\n",
+        "for k,v in texts.items():\n",
+        "    noise = torch.randn(1,1,256).to(device)\n",
+        "    wav = inference(v, noise, diffusion_steps=10, embedding_scale=1)\n",
+        "    print(k + \": \")\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "f4S8TXSpCgpA"
+      },
+      "source": [
+        "#### With embedding_scale=2"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xHHIdeNrCezC"
+      },
+      "outputs": [],
+      "source": [
+        "texts = {}\n",
+        "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+        "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+        "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+        "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+        "\n",
+        "for k,v in texts.items():\n",
+        "    noise = torch.randn(1,1,256).to(device)\n",
+        "    wav = inference(v, noise, diffusion_steps=10, embedding_scale=2) # embedding_scale=2 for more pronounced emotion\n",
+        "    print(k + \": \")\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nAh7Tov4CkuH"
+      },
+      "source": [
+        "### Long-form generation\n",
+        "This section includes basic implementation of Algorithm 1 in the paper for consistent longform audio generation. The example passage is taken from [Section 5](https://styletts2.github.io/#long) of the demo page."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "cellView": "form",
+        "id": "IJwUbgvACoDu"
+      },
+      "outputs": [],
+      "source": [
+        "passage = '''If the supply of fruit is greater than the family needs, it may be made a source of income by sending the fresh fruit to the market if there is one near enough, or by preserving, canning, and making jelly for sale. To make such an enterprise a success the fruit and work must be first class. There is magic in the word \"Homemade,\" when the product appeals to the eye and the palate; but many careless and incompetent people have found to their sorrow that this word has not magic enough to float inferior goods on the market. As a rule large canning and preserving establishments are clean and have the best appliances, and they employ chemists and skilled labor. The home product must be very good to compete with the attractive goods that are sent out from such establishments. Yet for first-class homemade products there is a market in all large cities. All first-class grocers have customers who purchase such goods.''' # @param {type:\"string\"}"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "nP-7i2QAC0JT"
+      },
+      "outputs": [],
+      "source": [
+        "sentences = passage.split('.') # simple split by comma\n",
+        "wavs = []\n",
+        "s_prev = None\n",
+        "for text in sentences:\n",
+        "    if text.strip() == \"\": continue\n",
+        "    text += '.' # add it back\n",
+        "    noise = torch.randn(1,1,256).to(device)\n",
+        "    wav, s_prev = LFinference(text, s_prev, noise, alpha=0.7, diffusion_steps=10, embedding_scale=1.5)\n",
+        "    wavs.append(wav)\n",
+        "display(ipd.Audio(np.concatenate(wavs), rate=24000, normalize=False))"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "authorship_tag": "ABX9TyM1x2mx2VnkYNFVlD+DFzmy",
+      "gpuType": "T4",
+      "include_colab_link": true,
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

stts_48khz/StyleTTS2_48khz/Colab/StyleTTS2_Demo_LibriTTS.ipynb

@@ -0,0 +1,1218 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/yl4579/StyleTTS2/blob/main/Colab/StyleTTS2_Demo_LibriTTS.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aAGQPfgYIR23"
+      },
+      "source": [
+        "### Install packages and download models"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "zDPW5uSpISd2",
+        "outputId": "6463ff79-18d5-4071-c6ad-01947beeb368"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+
+          ]
+        }
+      ],
+      "source": [
+        "%%shell\n",
+        "git clone https://github.com/yl4579/StyleTTS2.git\n",
+        "cd StyleTTS2\n",
+        "pip install SoundFile torchaudio munch torch pydub pyyaml librosa nltk matplotlib accelerate transformers phonemizer einops einops-exts tqdm typing-extensions git+https://github.com/resemble-ai/monotonic_align.git\n",
+        "sudo apt-get install espeak-ng\n",
+        "git-lfs clone https://huggingface.co/yl4579/StyleTTS2-LibriTTS\n",
+        "mv StyleTTS2-LibriTTS/Models .\n",
+        "mv StyleTTS2-LibriTTS/reference_audio.zip .\n",
+        "unzip reference_audio.zip\n",
+        "mv reference_audio Demo/reference_audio"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "eJdB_nCOIVIN"
+      },
+      "source": [
+        "### Load models"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "cha8Tr2uJwN0"
+      },
+      "outputs": [],
+      "source": [
+        "import nltk\n",
+        "nltk.download('punkt')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Qoow8Wd8ITtm"
+      },
+      "outputs": [],
+      "source": [
+        "%cd StyleTTS2\n",
+        "\n",
+        "import torch\n",
+        "torch.manual_seed(0)\n",
+        "torch.backends.cudnn.benchmark = False\n",
+        "torch.backends.cudnn.deterministic = True\n",
+        "\n",
+        "import random\n",
+        "random.seed(0)\n",
+        "\n",
+        "import numpy as np\n",
+        "np.random.seed(0)\n",
+        "\n",
+        "# load packages\n",
+        "import time\n",
+        "import random\n",
+        "import yaml\n",
+        "from munch import Munch\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "from torch import nn\n",
+        "import torch.nn.functional as F\n",
+        "import torchaudio\n",
+        "import librosa\n",
+        "from nltk.tokenize import word_tokenize\n",
+        "\n",
+        "from models import *\n",
+        "from utils import *\n",
+        "from text_utils import TextCleaner\n",
+        "textclenaer = TextCleaner()\n",
+        "\n",
+        "%matplotlib inline\n",
+        "\n",
+        "to_mel = torchaudio.transforms.MelSpectrogram(\n",
+        "    n_mels=80, n_fft=2048, win_length=1200, hop_length=300)\n",
+        "mean, std = -4, 4\n",
+        "\n",
+        "def length_to_mask(lengths):\n",
+        "    mask = torch.arange(lengths.max()).unsqueeze(0).expand(lengths.shape[0], -1).type_as(lengths)\n",
+        "    mask = torch.gt(mask+1, lengths.unsqueeze(1))\n",
+        "    return mask\n",
+        "\n",
+        "def preprocess(wave):\n",
+        "    wave_tensor = torch.from_numpy(wave).float()\n",
+        "    mel_tensor = to_mel(wave_tensor)\n",
+        "    mel_tensor = (torch.log(1e-5 + mel_tensor.unsqueeze(0)) - mean) / std\n",
+        "    return mel_tensor\n",
+        "\n",
+        "def compute_style(path):\n",
+        "    wave, sr = librosa.load(path, sr=24000)\n",
+        "    audio, index = librosa.effects.trim(wave, top_db=30)\n",
+        "    if sr != 24000:\n",
+        "        audio = librosa.resample(audio, sr, 24000)\n",
+        "    mel_tensor = preprocess(audio).to(device)\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        ref_s = model.style_encoder(mel_tensor.unsqueeze(1))\n",
+        "        ref_p = model.predictor_encoder(mel_tensor.unsqueeze(1))\n",
+        "\n",
+        "    return torch.cat([ref_s, ref_p], dim=1)\n",
+        "\n",
+        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+        "\n",
+        "# load phonemizer\n",
+        "import phonemizer\n",
+        "global_phonemizer = phonemizer.backend.EspeakBackend(language='en-us', preserve_punctuation=True,  with_stress=True)\n",
+        "\n",
+        "config = yaml.safe_load(open(\"Models/LibriTTS/config.yml\"))\n",
+        "\n",
+        "# load pretrained ASR model\n",
+        "ASR_config = config.get('ASR_config', False)\n",
+        "ASR_path = config.get('ASR_path', False)\n",
+        "text_aligner = load_ASR_models(ASR_path, ASR_config)\n",
+        "\n",
+        "# load pretrained F0 model\n",
+        "F0_path = config.get('F0_path', False)\n",
+        "pitch_extractor = load_F0_models(F0_path)\n",
+        "\n",
+        "# load BERT model\n",
+        "from Utils.PLBERT.util import load_plbert\n",
+        "BERT_path = config.get('PLBERT_dir', False)\n",
+        "plbert = load_plbert(BERT_path)\n",
+        "\n",
+        "model_params = recursive_munch(config['model_params'])\n",
+        "model = build_model(model_params, text_aligner, pitch_extractor, plbert)\n",
+        "_ = [model[key].eval() for key in model]\n",
+        "_ = [model[key].to(device) for key in model]\n",
+        "\n",
+        "params_whole = torch.load(\"Models/LibriTTS/epochs_2nd_00020.pth\", map_location='cpu')\n",
+        "params = params_whole['net']\n",
+        "\n",
+        "for key in model:\n",
+        "    if key in params:\n",
+        "        print('%s loaded' % key)\n",
+        "        try:\n",
+        "            model[key].load_state_dict(params[key])\n",
+        "        except:\n",
+        "            from collections import OrderedDict\n",
+        "            state_dict = params[key]\n",
+        "            new_state_dict = OrderedDict()\n",
+        "            for k, v in state_dict.items():\n",
+        "                name = k[7:] # remove `module.`\n",
+        "                new_state_dict[name] = v\n",
+        "            # load params\n",
+        "            model[key].load_state_dict(new_state_dict, strict=False)\n",
+        "#             except:\n",
+        "#                 _load(params[key], model[key])\n",
+        "_ = [model[key].eval() for key in model]\n",
+        "\n",
+        "from Modules.diffusion.sampler import DiffusionSampler, ADPM2Sampler, KarrasSchedule\n",
+        "\n",
+        "sampler = DiffusionSampler(\n",
+        "    model.diffusion.diffusion,\n",
+        "    sampler=ADPM2Sampler(),\n",
+        "    sigma_schedule=KarrasSchedule(sigma_min=0.0001, sigma_max=3.0, rho=9.0), # empirical parameters\n",
+        "    clamp=False\n",
+        ")\n",
+        "\n",
+        "def inference(text, ref_s, alpha = 0.3, beta = 0.7, diffusion_steps=5, embedding_scale=1):\n",
+        "    text = text.strip()\n",
+        "    ps = global_phonemizer.phonemize([text])\n",
+        "    ps = word_tokenize(ps[0])\n",
+        "    ps = ' '.join(ps)\n",
+        "    tokens = textclenaer(ps)\n",
+        "    tokens.insert(0, 0)\n",
+        "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)\n",
+        "        text_mask = length_to_mask(input_lengths).to(device)\n",
+        "\n",
+        "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+        "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+        "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2)\n",
+        "\n",
+        "        s_pred = sampler(noise = torch.randn((1, 256)).unsqueeze(1).to(device),\n",
+        "                                          embedding=bert_dur,\n",
+        "                                          embedding_scale=embedding_scale,\n",
+        "                                            features=ref_s, # reference from the same speaker as the embedding\n",
+        "                                             num_steps=diffusion_steps).squeeze(1)\n",
+        "\n",
+        "\n",
+        "        s = s_pred[:, 128:]\n",
+        "        ref = s_pred[:, :128]\n",
+        "\n",
+        "        ref = alpha * ref + (1 - alpha)  * ref_s[:, :128]\n",
+        "        s = beta * s + (1 - beta)  * ref_s[:, 128:]\n",
+        "\n",
+        "        d = model.predictor.text_encoder(d_en,\n",
+        "                                         s, input_lengths, text_mask)\n",
+        "\n",
+        "        x, _ = model.predictor.lstm(d)\n",
+        "        duration = model.predictor.duration_proj(x)\n",
+        "\n",
+        "        duration = torch.sigmoid(duration).sum(axis=-1)\n",
+        "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+        "\n",
+        "\n",
+        "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+        "        c_frame = 0\n",
+        "        for i in range(pred_aln_trg.size(0)):\n",
+        "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+        "            c_frame += int(pred_dur[i].data)\n",
+        "\n",
+        "        # encode prosody\n",
+        "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "        if model_params.decoder.type == \"hifigan\":\n",
+        "            asr_new = torch.zeros_like(en)\n",
+        "            asr_new[:, :, 0] = en[:, :, 0]\n",
+        "            asr_new[:, :, 1:] = en[:, :, 0:-1]\n",
+        "            en = asr_new\n",
+        "\n",
+        "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+        "\n",
+        "        asr = (t_en @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "        if model_params.decoder.type == \"hifigan\":\n",
+        "            asr_new = torch.zeros_like(asr)\n",
+        "            asr_new[:, :, 0] = asr[:, :, 0]\n",
+        "            asr_new[:, :, 1:] = asr[:, :, 0:-1]\n",
+        "            asr = asr_new\n",
+        "\n",
+        "        out = model.decoder(asr,\n",
+        "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+        "\n",
+        "\n",
+        "    return out.squeeze().cpu().numpy()[..., :-50] # weird pulse at the end of the model, need to be fixed later\n",
+        "\n",
+        "def LFinference(text, s_prev, ref_s, alpha = 0.3, beta = 0.7, t = 0.7, diffusion_steps=5, embedding_scale=1):\n",
+        "  text = text.strip()\n",
+        "  ps = global_phonemizer.phonemize([text])\n",
+        "  ps = word_tokenize(ps[0])\n",
+        "  ps = ' '.join(ps)\n",
+        "  ps = ps.replace('``', '\"')\n",
+        "  ps = ps.replace(\"''\", '\"')\n",
+        "\n",
+        "  tokens = textclenaer(ps)\n",
+        "  tokens.insert(0, 0)\n",
+        "  tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+        "\n",
+        "  with torch.no_grad():\n",
+        "      input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)\n",
+        "      text_mask = length_to_mask(input_lengths).to(device)\n",
+        "\n",
+        "      t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+        "      bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+        "      d_en = model.bert_encoder(bert_dur).transpose(-1, -2)\n",
+        "\n",
+        "      s_pred = sampler(noise = torch.randn((1, 256)).unsqueeze(1).to(device),\n",
+        "                                        embedding=bert_dur,\n",
+        "                                        embedding_scale=embedding_scale,\n",
+        "                                          features=ref_s, # reference from the same speaker as the embedding\n",
+        "                                            num_steps=diffusion_steps).squeeze(1)\n",
+        "\n",
+        "      if s_prev is not None:\n",
+        "          # convex combination of previous and current style\n",
+        "          s_pred = t * s_prev + (1 - t) * s_pred\n",
+        "\n",
+        "      s = s_pred[:, 128:]\n",
+        "      ref = s_pred[:, :128]\n",
+        "\n",
+        "      ref = alpha * ref + (1 - alpha)  * ref_s[:, :128]\n",
+        "      s = beta * s + (1 - beta)  * ref_s[:, 128:]\n",
+        "\n",
+        "      s_pred = torch.cat([ref, s], dim=-1)\n",
+        "\n",
+        "      d = model.predictor.text_encoder(d_en,\n",
+        "                                        s, input_lengths, text_mask)\n",
+        "\n",
+        "      x, _ = model.predictor.lstm(d)\n",
+        "      duration = model.predictor.duration_proj(x)\n",
+        "\n",
+        "      duration = torch.sigmoid(duration).sum(axis=-1)\n",
+        "      pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+        "\n",
+        "\n",
+        "      pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+        "      c_frame = 0\n",
+        "      for i in range(pred_aln_trg.size(0)):\n",
+        "          pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+        "          c_frame += int(pred_dur[i].data)\n",
+        "\n",
+        "      # encode prosody\n",
+        "      en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "      if model_params.decoder.type == \"hifigan\":\n",
+        "          asr_new = torch.zeros_like(en)\n",
+        "          asr_new[:, :, 0] = en[:, :, 0]\n",
+        "          asr_new[:, :, 1:] = en[:, :, 0:-1]\n",
+        "          en = asr_new\n",
+        "\n",
+        "      F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+        "\n",
+        "      asr = (t_en @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "      if model_params.decoder.type == \"hifigan\":\n",
+        "          asr_new = torch.zeros_like(asr)\n",
+        "          asr_new[:, :, 0] = asr[:, :, 0]\n",
+        "          asr_new[:, :, 1:] = asr[:, :, 0:-1]\n",
+        "          asr = asr_new\n",
+        "\n",
+        "      out = model.decoder(asr,\n",
+        "                              F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+        "\n",
+        "\n",
+        "  return out.squeeze().cpu().numpy()[..., :-100], s_pred # weird pulse at the end of the model, need to be fixed later\n",
+        "\n",
+        "def STinference(text, ref_s, ref_text, alpha = 0.3, beta = 0.7, diffusion_steps=5, embedding_scale=1):\n",
+        "    text = text.strip()\n",
+        "    ps = global_phonemizer.phonemize([text])\n",
+        "    ps = word_tokenize(ps[0])\n",
+        "    ps = ' '.join(ps)\n",
+        "\n",
+        "    tokens = textclenaer(ps)\n",
+        "    tokens.insert(0, 0)\n",
+        "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+        "\n",
+        "    ref_text = ref_text.strip()\n",
+        "    ps = global_phonemizer.phonemize([ref_text])\n",
+        "    ps = word_tokenize(ps[0])\n",
+        "    ps = ' '.join(ps)\n",
+        "\n",
+        "    ref_tokens = textclenaer(ps)\n",
+        "    ref_tokens.insert(0, 0)\n",
+        "    ref_tokens = torch.LongTensor(ref_tokens).to(device).unsqueeze(0)\n",
+        "\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)\n",
+        "        text_mask = length_to_mask(input_lengths).to(device)\n",
+        "\n",
+        "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+        "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+        "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2)\n",
+        "\n",
+        "        ref_input_lengths = torch.LongTensor([ref_tokens.shape[-1]]).to(device)\n",
+        "        ref_text_mask = length_to_mask(ref_input_lengths).to(device)\n",
+        "        ref_bert_dur = model.bert(ref_tokens, attention_mask=(~ref_text_mask).int())\n",
+        "        s_pred = sampler(noise = torch.randn((1, 256)).unsqueeze(1).to(device),\n",
+        "                                          embedding=bert_dur,\n",
+        "                                          embedding_scale=embedding_scale,\n",
+        "                                            features=ref_s, # reference from the same speaker as the embedding\n",
+        "                                             num_steps=diffusion_steps).squeeze(1)\n",
+        "\n",
+        "\n",
+        "        s = s_pred[:, 128:]\n",
+        "        ref = s_pred[:, :128]\n",
+        "\n",
+        "        ref = alpha * ref + (1 - alpha)  * ref_s[:, :128]\n",
+        "        s = beta * s + (1 - beta)  * ref_s[:, 128:]\n",
+        "\n",
+        "        d = model.predictor.text_encoder(d_en,\n",
+        "                                         s, input_lengths, text_mask)\n",
+        "\n",
+        "        x, _ = model.predictor.lstm(d)\n",
+        "        duration = model.predictor.duration_proj(x)\n",
+        "\n",
+        "        duration = torch.sigmoid(duration).sum(axis=-1)\n",
+        "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+        "\n",
+        "\n",
+        "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+        "        c_frame = 0\n",
+        "        for i in range(pred_aln_trg.size(0)):\n",
+        "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+        "            c_frame += int(pred_dur[i].data)\n",
+        "\n",
+        "        # encode prosody\n",
+        "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "        if model_params.decoder.type == \"hifigan\":\n",
+        "            asr_new = torch.zeros_like(en)\n",
+        "            asr_new[:, :, 0] = en[:, :, 0]\n",
+        "            asr_new[:, :, 1:] = en[:, :, 0:-1]\n",
+        "            en = asr_new\n",
+        "\n",
+        "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+        "\n",
+        "        asr = (t_en @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "        if model_params.decoder.type == \"hifigan\":\n",
+        "            asr_new = torch.zeros_like(asr)\n",
+        "            asr_new[:, :, 0] = asr[:, :, 0]\n",
+        "            asr_new[:, :, 1:] = asr[:, :, 0:-1]\n",
+        "            asr = asr_new\n",
+        "\n",
+        "        out = model.decoder(asr,\n",
+        "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+        "\n",
+        "\n",
+        "    return out.squeeze().cpu().numpy()[..., :-50] # weird pulse at the end of the model, need to be fixed later\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "32S6U0LyJbCA"
+      },
+      "source": [
+        "### Synthesize speech"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ehK_0daMJdk_"
+      },
+      "source": [
+        "#### Basic synthesis (5 diffusion steps, seen speakers)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "SJs2x41MJhM-"
+      },
+      "outputs": [],
+      "source": [
+        "text = ''' StyleTTS 2 is a text to speech model that leverages style diffusion and adversarial training with large speech language models to achieve human level text to speech synthesis. ''' # @param {type:\"string\"}\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xuqIJe-IJb7A"
+      },
+      "outputs": [],
+      "source": [
+        "reference_dicts = {}\n",
+        "reference_dicts['696_92939'] = \"Demo/reference_audio/696_92939_000016_000006.wav\"\n",
+        "reference_dicts['1789_142896'] = \"Demo/reference_audio/1789_142896_000022_000005.wav\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "H3ra3IxJJmF0"
+      },
+      "outputs": [],
+      "source": [
+        "noise = torch.randn(1,1,256).to(device)\n",
+        "for k, path in reference_dicts.items():\n",
+        "    ref_s = compute_style(path)\n",
+        "    start = time.time()\n",
+        "    wav = inference(text, ref_s, alpha=0.3, beta=0.7, diffusion_steps=5, embedding_scale=1)\n",
+        "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "    print(f\"RTF = {rtf:5f}\")\n",
+        "    import IPython.display as ipd\n",
+        "    print(k + ' Synthesized:')\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+        "    print('Reference:')\n",
+        "    display(ipd.Audio(path, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aB3wUz6yJ-P_"
+      },
+      "source": [
+        "#### With higher diffusion steps (more diverse)\n",
+        "\n",
+        "Since the sampler is ancestral, the higher the stpes, the more diverse the samples are, with the cost of slower synthesis speed."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "lF27XUo4JrKk"
+      },
+      "outputs": [],
+      "source": [
+        "noise = torch.randn(1,1,256).to(device)\n",
+        "for k, path in reference_dicts.items():\n",
+        "    ref_s = compute_style(path)\n",
+        "    start = time.time()\n",
+        "    wav = inference(text, ref_s, alpha=0.3, beta=0.7, diffusion_steps=10, embedding_scale=1)\n",
+        "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "    print(f\"RTF = {rtf:5f}\")\n",
+        "    import IPython.display as ipd\n",
+        "    print(k + ' Synthesized:')\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+        "    print(k + ' Reference:')\n",
+        "    display(ipd.Audio(path, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pFT_vmJcKDs1"
+      },
+      "source": [
+        "#### Basic synthesis (5 diffusion steps, unseen speakers)\n",
+        "The following samples are to reproduce samples in [Section 4](https://styletts2.github.io/#libri) of the demo page. All spsakers are unseen during training. You can compare the generated samples to popular zero-shot TTS models like Vall-E and NaturalSpeech 2."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "HvNAeGPEKAWN"
+      },
+      "outputs": [],
+      "source": [
+        "reference_dicts = {}\n",
+        "# format: (path, text)\n",
+        "reference_dicts['1221-135767'] = (\"Demo/reference_audio/1221-135767-0014.wav\", \"Yea, his honourable worship is within, but he hath a godly minister or two with him, and likewise a leech.\")\n",
+        "reference_dicts['5639-40744'] = (\"Demo/reference_audio/5639-40744-0020.wav\", \"Thus did this humane and right minded father comfort his unhappy daughter, and her mother embracing her again, did all she could to soothe her feelings.\")\n",
+        "reference_dicts['908-157963'] = (\"Demo/reference_audio/908-157963-0027.wav\", \"And lay me down in my cold bed and leave my shining lot.\")\n",
+        "reference_dicts['4077-13754'] = (\"Demo/reference_audio/4077-13754-0000.wav\", \"The army found the people in poverty and left them in comparative wealth.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "mFnyvYp5KAYN"
+      },
+      "outputs": [],
+      "source": [
+        "noise = torch.randn(1,1,256).to(device)\n",
+        "for k, v in reference_dicts.items():\n",
+        "    path, text = v\n",
+        "    ref_s = compute_style(path)\n",
+        "    start = time.time()\n",
+        "    wav = inference(text, ref_s, alpha=0.3, beta=0.7, diffusion_steps=5, embedding_scale=1)\n",
+        "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "    print(f\"RTF = {rtf:5f}\")\n",
+        "    import IPython.display as ipd\n",
+        "    print(k + ' Synthesized: ' + text)\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+        "    print(k + ' Reference:')\n",
+        "    display(ipd.Audio(path, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "QBZ53BQtKNQ6"
+      },
+      "source": [
+        "### Speech expressiveness\n",
+        "\n",
+        "The following section recreates the samples shown in [Section 6](https://styletts2.github.io/#emo) of the demo page. The speaker reference used is `1221-135767-0014.wav`, which is unseen during training.\n",
+        "\n",
+        "#### With `embedding_scale=1`\n",
+        "This is the classifier-free guidance scale. The higher the scale, the more conditional the style is to the input text and hence more emotional."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "5FwE9CefKQk6"
+      },
+      "outputs": [],
+      "source": [
+        "ref_s = compute_style(\"Demo/reference_audio/1221-135767-0014.wav\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "0CKMI0ZsKUDh"
+      },
+      "outputs": [],
+      "source": [
+        "texts = {}\n",
+        "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+        "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+        "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+        "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+        "\n",
+        "for k,v in texts.items():\n",
+        "    wav = inference(v, ref_s, diffusion_steps=10, alpha=0.3, beta=0.7, embedding_scale=1)\n",
+        "    print(k + \": \")\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "reemQKVEKWAZ"
+      },
+      "source": [
+        "#### With `embedding_scale=2`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "npIAiAUvKYGv"
+      },
+      "outputs": [],
+      "source": [
+        "texts = {}\n",
+        "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+        "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+        "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+        "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+        "\n",
+        "for k,v in texts.items():\n",
+        "    noise = torch.randn(1,1,256).to(device)\n",
+        "    wav = inference(v, ref_s, diffusion_steps=10, alpha=0.3, beta=0.7, embedding_scale=2)\n",
+        "    print(k + \": \")\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lqKZaXeYKbrH"
+      },
+      "source": [
+        "#### With `embedding_scale=2, alpha = 0.5, beta = 0.9`\n",
+        "`alpha` and `beta` is the factor to determine much we use the style sampled based on the text instead of the reference. The higher the value of `alpha` and `beta`, the more suitable the style it is to the text but less similar to the reference. Using higher beta makes the synthesized speech more emotional, at the cost of lower similarity to the reference. `alpha` determines the timbre of the speaker while `beta` determines the prosody."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "VjXuRCCWKcdN"
+      },
+      "outputs": [],
+      "source": [
+        "texts = {}\n",
+        "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+        "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+        "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+        "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+        "\n",
+        "for k,v in texts.items():\n",
+        "    noise = torch.randn(1,1,256).to(device)\n",
+        "    wav = inference(v, ref_s, diffusion_steps=10, alpha=0.5, beta=0.9, embedding_scale=2)\n",
+        "    print(k + \": \")\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xrwYXGh0KiIW"
+      },
+      "source": [
+        "### Zero-shot speaker adaptation\n",
+        "This section recreates the \"Acoustic Environment Maintenance\" and \"Speaker’s Emotion Maintenance\" demo in [Section 4](https://styletts2.github.io/#libri) of the demo page. You can compare the generated samples to popular zero-shot TTS models like Vall-E. Note that the model was trained only on LibriTTS, which is about 250 times fewer data compared to those used to trian Vall-E with similar or better effect for these maintainance."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ETUywHHmKimE"
+      },
+      "source": [
+        "#### Acoustic Environment Maintenance\n",
+        "\n",
+        "Since we want to maintain the acoustic environment in the speaker (timbre), we set  `alpha = 0` to make the speaker as close to the reference as possible while only changing the prosody according to the text.  "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "yvjBK3syKnZL"
+      },
+      "outputs": [],
+      "source": [
+        "reference_dicts = {}\n",
+        "# format: (path, text)\n",
+        "reference_dicts['3'] = (\"Demo/reference_audio/3.wav\", \"As friends thing I definitely I've got more male friends.\")\n",
+        "reference_dicts['4'] = (\"Demo/reference_audio/4.wav\", \"Everything is run by computer but you got to know how to think before you can do a computer.\")\n",
+        "reference_dicts['5'] = (\"Demo/reference_audio/5.wav\", \"Then out in LA you guys got a whole another ball game within California to worry about.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "jclowWp4KomJ"
+      },
+      "outputs": [],
+      "source": [
+        "noise = torch.randn(1,1,256).to(device)\n",
+        "for k, v in reference_dicts.items():\n",
+        "    path, text = v\n",
+        "    ref_s = compute_style(path)\n",
+        "    start = time.time()\n",
+        "    wav = inference(text, ref_s, alpha=0.0, beta=0.5, diffusion_steps=5, embedding_scale=1)\n",
+        "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "    print(f\"RTF = {rtf:5f}\")\n",
+        "    import IPython.display as ipd\n",
+        "    print('Synthesized: ' + text)\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+        "    print('Reference:')\n",
+        "    display(ipd.Audio(path, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LgIm7M93KqVZ"
+      },
+      "source": [
+        "#### Speaker’s Emotion Maintenance\n",
+        "\n",
+        "Since we want to maintain the emotion in the speaker (prosody), we set  `beta = 0.1` to make the speaker as closer to the reference as possible while having some diversity thruogh the slight timbre change."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "yzsNoP6oKulL"
+      },
+      "outputs": [],
+      "source": [
+        "reference_dicts = {}\n",
+        "# format: (path, text)\n",
+        "reference_dicts['Anger'] = (\"Demo/reference_audio/anger.wav\", \"We have to reduce the number of plastic bags.\")\n",
+        "reference_dicts['Sleepy'] = (\"Demo/reference_audio/sleepy.wav\", \"We have to reduce the number of plastic bags.\")\n",
+        "reference_dicts['Amused'] = (\"Demo/reference_audio/amused.wav\", \"We have to reduce the number of plastic bags.\")\n",
+        "reference_dicts['Disgusted'] = (\"Demo/reference_audio/disgusted.wav\", \"We have to reduce the number of plastic bags.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "7h2-9cpfKwr4"
+      },
+      "outputs": [],
+      "source": [
+        "noise = torch.randn(1,1,256).to(device)\n",
+        "for k, v in reference_dicts.items():\n",
+        "    path, text = v\n",
+        "    ref_s = compute_style(path)\n",
+        "    start = time.time()\n",
+        "    wav = inference(text, ref_s, alpha=0.3, beta=0.1, diffusion_steps=10, embedding_scale=1)\n",
+        "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "    print(f\"RTF = {rtf:5f}\")\n",
+        "    import IPython.display as ipd\n",
+        "    print(k + ' Synthesized: ' + text)\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+        "    print(k + ' Reference:')\n",
+        "    display(ipd.Audio(path, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aNS82PGwKzgg"
+      },
+      "source": [
+        "### Longform Narration\n",
+        "\n",
+        "This section includes basic implementation of Algorithm 1 in the paper for consistent longform audio generation. The example passage is taken from [Section 5](https://styletts2.github.io/#long) of the demo page."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "id": "qs97nL5HK5DH"
+      },
+      "outputs": [],
+      "source": [
+        "passage = passage = '''If the supply of fruit is greater than the family needs, it may be made a source of income by sending the fresh fruit to the market if there is one near enough, or by preserving, canning, and making jelly for sale. To make such an enterprise a success the fruit and work must be first class. There is magic in the word \"Homemade,\" when the product appeals to the eye and the palate; but many careless and incompetent people have found to their sorrow that this word has not magic enough to float inferior goods on the market. As a rule large canning and preserving establishments are clean and have the best appliances, and they employ chemists and skilled labor. The home product must be very good to compete with the attractive goods that are sent out from such establishments. Yet for first class home made products there is a market in all large cities. All first-class grocers have customers who purchase such goods.''' # @param {type:\"string\"}"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "background_save": true
+        },
+        "id": "8Mu9whHYK_1b"
+      },
+      "outputs": [],
+      "source": [
+        "# seen speaker\n",
+        "path = \"Demo/reference_audio/696_92939_000016_000006.wav\"\n",
+        "s_ref = compute_style(path)\n",
+        "sentences = passage.split('.') # simple split by comma\n",
+        "wavs = []\n",
+        "s_prev = None\n",
+        "for text in sentences:\n",
+        "    if text.strip() == \"\": continue\n",
+        "    text += '.' # add it back\n",
+        "\n",
+        "    wav, s_prev = LFinference(text,\n",
+        "                              s_prev,\n",
+        "                              s_ref,\n",
+        "                              alpha = 0.3,\n",
+        "                              beta = 0.9,  # make it more suitable for the text\n",
+        "                              t = 0.7,\n",
+        "                              diffusion_steps=10, embedding_scale=1.5)\n",
+        "    wavs.append(wav)\n",
+        "print('Synthesized: ')\n",
+        "display(ipd.Audio(np.concatenate(wavs), rate=24000, normalize=False))\n",
+        "print('Reference: ')\n",
+        "display(ipd.Audio(path, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "81Rh-lgWLB2i"
+      },
+      "source": [
+        "### Style Transfer\n",
+        "\n",
+        "The following section demostrates the style transfer capacity for unseen speakers in [Section 6](https://styletts2.github.io/#emo) of the demo page. For this, we set `alpha=0.5, beta = 0.9` for the most pronounced effects (mostly using the sampled style)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "CtIgr5kOLE9a"
+      },
+      "outputs": [],
+      "source": [
+        "# reference texts to sample styles\n",
+        "\n",
+        "ref_texts = {}\n",
+        "ref_texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+        "ref_texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+        "ref_texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+        "ref_texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "MlA1CbhzLIoI"
+      },
+      "outputs": [],
+      "source": [
+        "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+        "s_ref = compute_style(path)\n",
+        "\n",
+        "text = \"Yea, his honourable worship is within, but he hath a godly minister or two with him, and likewise a leech.\"\n",
+        "for k,v in ref_texts.items():\n",
+        "    wav = STinference(text, s_ref, v, diffusion_steps=10, alpha=0.5, beta=0.9, embedding_scale=1.5)\n",
+        "    print(k + \": \")\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2M0iaXlkLJUQ"
+      },
+      "source": [
+        "### Speech diversity\n",
+        "\n",
+        "This section reproduces samples in [Section 7](https://styletts2.github.io/#var) of the demo page.\n",
+        "\n",
+        "`alpha` and `beta` determine the diversity of the synthesized speech. There are two extreme cases:\n",
+        "- If `alpha = 1` and `beta = 1`, the synthesized speech sounds the most dissimilar to the reference speaker, but it is also the most diverse (each time you synthesize a speech it will be totally different).\n",
+        "- If `alpha = 0` and `beta = 0`, the synthesized speech sounds the most siimlar to the reference speaker, but it is deterministic (i.e., the sampled style is not used for speech synthesis).\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tSxZDvF2LNu4"
+      },
+      "source": [
+        "#### Default setting (`alpha = 0.3, beta=0.7`)\n",
+        "This setting uses 70% of the reference timbre and 30% of the reference prosody and use the diffusion model to sample them based on the text."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "AAomGCDZLIt5"
+      },
+      "outputs": [],
+      "source": [
+        "# unseen speaker\n",
+        "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+        "ref_s = compute_style(path)\n",
+        "\n",
+        "text = \"How much variation is there?\"\n",
+        "for _ in range(5):\n",
+        "    wav = inference(text, ref_s, diffusion_steps=10, alpha=0.3, beta=0.7, embedding_scale=1)\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BKrSMdgcLQRP"
+      },
+      "source": [
+        "#### Less diverse setting (`alpha = 0.1, beta=0.3`)\n",
+        "This setting uses 90% of the reference timbre and 70% of the reference prosody. This makes it more similar to the reference speaker at cost of less diverse samples."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Uo7gVmFoLRfm"
+      },
+      "outputs": [],
+      "source": [
+        "# unseen speaker\n",
+        "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+        "ref_s = compute_style(path)\n",
+        "\n",
+        "text = \"How much variation is there?\"\n",
+        "for _ in range(5):\n",
+        "    wav = inference(text, ref_s, diffusion_steps=10, alpha=0.1, beta=0.3, embedding_scale=1)\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nfQ0Xrg9LStd"
+      },
+      "source": [
+        "#### More diverse setting (`alpha = 0.5, beta=0.95`)\n",
+        "This setting uses 50% of the reference timbre and 5% of the reference prosody (so it uses 100% of the sampled prosody, which makes it more diverse), but this makes it more dissimilar to the reference speaker.  "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "cPHz4BzVLT_u"
+      },
+      "outputs": [],
+      "source": [
+        "# unseen speaker\n",
+        "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+        "ref_s = compute_style(path)\n",
+        "\n",
+        "text = \"How much variation is there?\"\n",
+        "for _ in range(5):\n",
+        "    wav = inference(text, ref_s, diffusion_steps=10, alpha=0.5, beta=0.95, embedding_scale=1)\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Extreme setting (`alpha = 1, beta=1`)\n",
+        "This setting uses 0% of the reference timbre and prosody and use the diffusion model to sample the entire style. This makes the speaker very dissimilar to the reference speaker."
+      ],
+      "metadata": {
+        "id": "hPKg9eYpL00f"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# unseen speaker\n",
+        "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+        "ref_s = compute_style(path)\n",
+        "\n",
+        "text = \"How much variation is there?\"\n",
+        "for _ in range(5):\n",
+        "    wav = inference(text, ref_s, diffusion_steps=10, alpha=1, beta=1, embedding_scale=1)\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ],
+      "metadata": {
+        "id": "Ei-7JOccL0bF"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### No variation (`alpha = 0, beta=0`)\n",
+        "This setting uses 100% of the reference timbre and prosody and do not use the diffusion model at all. This makes the speaker very similar to the reference speaker, but there is no variation."
+      ],
+      "metadata": {
+        "id": "FVMPc3bhL3eL"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# unseen speaker\n",
+        "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+        "ref_s = compute_style(path)\n",
+        "\n",
+        "text = \"How much variation is there?\"\n",
+        "for _ in range(5):\n",
+        "    wav = inference(text, ref_s, diffusion_steps=10, alpha=0, beta=0, embedding_scale=1)\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ],
+      "metadata": {
+        "id": "yh1QZ7uhL4wM"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Extra fun!\n",
+        "\n",
+        "You can record your own voice and clone it using pre-trained StyleTTS 2 model here."
+      ],
+      "metadata": {
+        "id": "T0EvkWrAMBDB"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Run the following cell to record your voice for 5 seconds. Please keep speaking to have the best effect."
+      ],
+      "metadata": {
+        "id": "R985j5QONY8I"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# all imports\n",
+        "from IPython.display import Javascript\n",
+        "from google.colab import output\n",
+        "from base64 import b64decode\n",
+        "\n",
+        "RECORD = \"\"\"\n",
+        "const sleep  = time => new Promise(resolve => setTimeout(resolve, time))\n",
+        "const b2text = blob => new Promise(resolve => {\n",
+        "  const reader = new FileReader()\n",
+        "  reader.onloadend = e => resolve(e.srcElement.result)\n",
+        "  reader.readAsDataURL(blob)\n",
+        "})\n",
+        "var record = time => new Promise(async resolve => {\n",
+        "  stream = await navigator.mediaDevices.getUserMedia({ audio: true })\n",
+        "  recorder = new MediaRecorder(stream)\n",
+        "  chunks = []\n",
+        "  recorder.ondataavailable = e => chunks.push(e.data)\n",
+        "  recorder.start()\n",
+        "  await sleep(time)\n",
+        "  recorder.onstop = async ()=>{\n",
+        "    blob = new Blob(chunks)\n",
+        "    text = await b2text(blob)\n",
+        "    resolve(text)\n",
+        "  }\n",
+        "  recorder.stop()\n",
+        "})\n",
+        "\"\"\"\n",
+        "\n",
+        "def record(sec=3):\n",
+        "  display(Javascript(RECORD))\n",
+        "  s = output.eval_js('record(%d)' % (sec*1000))\n",
+        "  b = b64decode(s.split(',')[1])\n",
+        "  with open('audio.wav','wb') as f:\n",
+        "    f.write(b)\n",
+        "  return 'audio.wav'  # or webm ?"
+      ],
+      "metadata": {
+        "id": "MWrFs0KWMBpz"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Please run this cell and speak:"
+      ],
+      "metadata": {
+        "id": "z35qXwM0Nhx1"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print('Speak now for 5 seconds.')\n",
+        "audio = record(sec=5)\n",
+        "import IPython.display as ipd\n",
+        "display(ipd.Audio(audio, rate=24000, normalize=False))"
+      ],
+      "metadata": {
+        "id": "KUEoFyQBMR-8"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "#### Synthesize in your own voice"
+      ],
+      "metadata": {
+        "id": "OQS_7IBpNmM1"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "text = ''' StyleTTS 2 is a text to speech model that leverages style diffusion and adversarial training with large speech language models to achieve human level text to speech synthesis. ''' # @param {type:\"string\"}\n"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "c0I3LY7vM8Ta"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "reference_dicts = {}\n",
+        "reference_dicts['You'] = audio"
+      ],
+      "metadata": {
+        "id": "80eW-pwxNCxu"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "start = time.time()\n",
+        "noise = torch.randn(1,1,256).to(device)\n",
+        "for k, path in reference_dicts.items():\n",
+        "    ref_s = compute_style(path)\n",
+        "\n",
+        "    wav = inference(text, ref_s, alpha=0.1, beta=0.5, diffusion_steps=5, embedding_scale=1)\n",
+        "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "    print('Speaker: ' + k)\n",
+        "    import IPython.display as ipd\n",
+        "    print('Synthesized:')\n",
+        "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+        "    print('Reference:')\n",
+        "    display(ipd.Audio(path, rate=24000, normalize=False))"
+      ],
+      "metadata": {
+        "id": "yIga6MTuNJaN"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": [],
+      "collapsed_sections": [
+        "aAGQPfgYIR23",
+        "eJdB_nCOIVIN",
+        "R985j5QONY8I"
+      ],
+      "authorship_tag": "ABX9TyPQdFTqqVEknEG/ma/HMfU+",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

stts_48khz/StyleTTS2_48khz/Colab/StyleTTS2_Finetune_Demo.ipynb

@@ -0,0 +1,480 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4",
+      "authorship_tag": "ABX9TyNiDU9ykIeYxO86Lmuid+ph",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/yl4579/StyleTTS2/blob/main/Colab/StyleTTS2_Finetune_Demo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Install packages and download models"
+      ],
+      "metadata": {
+        "id": "yLqBa4uYPrqE"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "%%shell\n",
+        "git clone https://github.com/yl4579/StyleTTS2.git\n",
+        "cd StyleTTS2\n",
+        "pip install SoundFile torchaudio munch torch pydub pyyaml librosa nltk matplotlib accelerate transformers phonemizer einops einops-exts tqdm typing-extensions git+https://github.com/resemble-ai/monotonic_align.git\n",
+        "sudo apt-get install espeak-ng\n",
+        "git-lfs clone https://huggingface.co/yl4579/StyleTTS2-LibriTTS\n",
+        "mv StyleTTS2-LibriTTS/Models ."
+      ],
+      "metadata": {
+        "id": "H72WF06ZPrTF"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Download dataset (LJSpeech, 200 samples, ~15 minutes of data)\n",
+        "\n",
+        "You can definitely do it with fewer samples. This is just a proof of concept with 200 smaples."
+      ],
+      "metadata": {
+        "id": "G398sL8wPzTB"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "%cd StyleTTS2\n",
+        "!rm -rf Data"
+      ],
+      "metadata": {
+        "id": "kJuQUBrEPy5C"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!gdown --id 1vqz26D3yn7OXS2vbfYxfSnpLS6m6tOFP\n",
+        "!unzip Data.zip"
+      ],
+      "metadata": {
+        "id": "mDXW8ZZePuSb"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Change the finetuning config\n",
+        "\n",
+        "Depending on the GPU you got, you may want to change the bacth size, max audio length, epiochs and so on."
+      ],
+      "metadata": {
+        "id": "_AlBQREWU8ud"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "config_path = \"Configs/config_ft.yml\"\n",
+        "\n",
+        "import yaml\n",
+        "config = yaml.safe_load(open(config_path))"
+      ],
+      "metadata": {
+        "id": "7uEITi0hU4I2"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "config['data_params']['root_path'] = \"Data/wavs\"\n",
+        "\n",
+        "config['batch_size'] = 2 # not enough RAM\n",
+        "config['max_len'] = 100 # not enough RAM\n",
+        "config['loss_params']['joint_epoch'] = 110 # we do not do SLM adversarial training due to not enough RAM\n",
+        "\n",
+        "with open(config_path, 'w') as outfile:\n",
+        "  yaml.dump(config, outfile, default_flow_style=True)"
+      ],
+      "metadata": {
+        "id": "TPTRgOKSVT4K"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Start finetuning\n"
+      ],
+      "metadata": {
+        "id": "uUuB_19NWj2Y"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!python train_finetune.py --config_path ./Configs/config_ft.yml"
+      ],
+      "metadata": {
+        "id": "HZVAD5GKWm-O"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Test the model quality\n",
+        "\n",
+        "Note that this mainly serves as a proof of concept due to RAM limitation of free Colab instances. A lot of settings are suboptimal. In the future when DDP works for train_second.py, we will also add mixed precision finetuning to save time and RAM. You can also add SLM adversarial training run if you have paid Colab services (such as A100 with 40G of RAM)."
+      ],
+      "metadata": {
+        "id": "I0_7wsGkXGfc"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import nltk\n",
+        "nltk.download('punkt')"
+      ],
+      "metadata": {
+        "id": "OPLphjbncE7p"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "torch.manual_seed(0)\n",
+        "torch.backends.cudnn.benchmark = False\n",
+        "torch.backends.cudnn.deterministic = True\n",
+        "\n",
+        "import random\n",
+        "random.seed(0)\n",
+        "\n",
+        "import numpy as np\n",
+        "np.random.seed(0)\n",
+        "\n",
+        "# load packages\n",
+        "import time\n",
+        "import random\n",
+        "import yaml\n",
+        "from munch import Munch\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "from torch import nn\n",
+        "import torch.nn.functional as F\n",
+        "import torchaudio\n",
+        "import librosa\n",
+        "from nltk.tokenize import word_tokenize\n",
+        "\n",
+        "from models import *\n",
+        "from utils import *\n",
+        "from text_utils import TextCleaner\n",
+        "textclenaer = TextCleaner()\n",
+        "\n",
+        "%matplotlib inline\n",
+        "\n",
+        "to_mel = torchaudio.transforms.MelSpectrogram(\n",
+        "    n_mels=80, n_fft=2048, win_length=1200, hop_length=300)\n",
+        "mean, std = -4, 4\n",
+        "\n",
+        "def length_to_mask(lengths):\n",
+        "    mask = torch.arange(lengths.max()).unsqueeze(0).expand(lengths.shape[0], -1).type_as(lengths)\n",
+        "    mask = torch.gt(mask+1, lengths.unsqueeze(1))\n",
+        "    return mask\n",
+        "\n",
+        "def preprocess(wave):\n",
+        "    wave_tensor = torch.from_numpy(wave).float()\n",
+        "    mel_tensor = to_mel(wave_tensor)\n",
+        "    mel_tensor = (torch.log(1e-5 + mel_tensor.unsqueeze(0)) - mean) / std\n",
+        "    return mel_tensor\n",
+        "\n",
+        "def compute_style(path):\n",
+        "    wave, sr = librosa.load(path, sr=24000)\n",
+        "    audio, index = librosa.effects.trim(wave, top_db=30)\n",
+        "    if sr != 24000:\n",
+        "        audio = librosa.resample(audio, sr, 24000)\n",
+        "    mel_tensor = preprocess(audio).to(device)\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        ref_s = model.style_encoder(mel_tensor.unsqueeze(1))\n",
+        "        ref_p = model.predictor_encoder(mel_tensor.unsqueeze(1))\n",
+        "\n",
+        "    return torch.cat([ref_s, ref_p], dim=1)\n",
+        "\n",
+        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+        "\n",
+        "# load phonemizer\n",
+        "import phonemizer\n",
+        "global_phonemizer = phonemizer.backend.EspeakBackend(language='en-us', preserve_punctuation=True,  with_stress=True)\n",
+        "\n",
+        "config = yaml.safe_load(open(\"Models/LJSpeech/config_ft.yml\"))\n",
+        "\n",
+        "# load pretrained ASR model\n",
+        "ASR_config = config.get('ASR_config', False)\n",
+        "ASR_path = config.get('ASR_path', False)\n",
+        "text_aligner = load_ASR_models(ASR_path, ASR_config)\n",
+        "\n",
+        "# load pretrained F0 model\n",
+        "F0_path = config.get('F0_path', False)\n",
+        "pitch_extractor = load_F0_models(F0_path)\n",
+        "\n",
+        "# load BERT model\n",
+        "from Utils.PLBERT.util import load_plbert\n",
+        "BERT_path = config.get('PLBERT_dir', False)\n",
+        "plbert = load_plbert(BERT_path)\n",
+        "\n",
+        "model_params = recursive_munch(config['model_params'])\n",
+        "model = build_model(model_params, text_aligner, pitch_extractor, plbert)\n",
+        "_ = [model[key].eval() for key in model]\n",
+        "_ = [model[key].to(device) for key in model]"
+      ],
+      "metadata": {
+        "id": "jIIAoDACXJL0"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "files = [f for f in os.listdir(\"Models/LJSpeech/\") if f.endswith('.pth')]\n",
+        "sorted_files = sorted(files, key=lambda x: int(x.split('_')[-1].split('.')[0]))"
+      ],
+      "metadata": {
+        "id": "eKXRAyyzcMpQ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "params_whole = torch.load(\"Models/LJSpeech/\" + sorted_files[-1], map_location='cpu')\n",
+        "params = params_whole['net']"
+      ],
+      "metadata": {
+        "id": "ULuU9-VDb9Pk"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "for key in model:\n",
+        "    if key in params:\n",
+        "        print('%s loaded' % key)\n",
+        "        try:\n",
+        "            model[key].load_state_dict(params[key])\n",
+        "        except:\n",
+        "            from collections import OrderedDict\n",
+        "            state_dict = params[key]\n",
+        "            new_state_dict = OrderedDict()\n",
+        "            for k, v in state_dict.items():\n",
+        "                name = k[7:] # remove `module.`\n",
+        "                new_state_dict[name] = v\n",
+        "            # load params\n",
+        "            model[key].load_state_dict(new_state_dict, strict=False)\n",
+        "#             except:\n",
+        "#                 _load(params[key], model[key])\n",
+        "_ = [model[key].eval() for key in model]"
+      ],
+      "metadata": {
+        "id": "J-U29yIYc2ea"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from Modules.diffusion.sampler import DiffusionSampler, ADPM2Sampler, KarrasSchedule"
+      ],
+      "metadata": {
+        "id": "jrPQ_Yrwc3n6"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sampler = DiffusionSampler(\n",
+        "    model.diffusion.diffusion,\n",
+        "    sampler=ADPM2Sampler(),\n",
+        "    sigma_schedule=KarrasSchedule(sigma_min=0.0001, sigma_max=3.0, rho=9.0), # empirical parameters\n",
+        "    clamp=False\n",
+        ")"
+      ],
+      "metadata": {
+        "id": "n2CWYNoqc455"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def inference(text, ref_s, alpha = 0.3, beta = 0.7, diffusion_steps=5, embedding_scale=1):\n",
+        "    text = text.strip()\n",
+        "    ps = global_phonemizer.phonemize([text])\n",
+        "    ps = word_tokenize(ps[0])\n",
+        "    ps = ' '.join(ps)\n",
+        "    tokens = textclenaer(ps)\n",
+        "    tokens.insert(0, 0)\n",
+        "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)\n",
+        "        text_mask = length_to_mask(input_lengths).to(device)\n",
+        "\n",
+        "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+        "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+        "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2)\n",
+        "\n",
+        "        s_pred = sampler(noise = torch.randn((1, 256)).unsqueeze(1).to(device),\n",
+        "                                          embedding=bert_dur,\n",
+        "                                          embedding_scale=embedding_scale,\n",
+        "                                            features=ref_s, # reference from the same speaker as the embedding\n",
+        "                                             num_steps=diffusion_steps).squeeze(1)\n",
+        "\n",
+        "\n",
+        "        s = s_pred[:, 128:]\n",
+        "        ref = s_pred[:, :128]\n",
+        "\n",
+        "        ref = alpha * ref + (1 - alpha)  * ref_s[:, :128]\n",
+        "        s = beta * s + (1 - beta)  * ref_s[:, 128:]\n",
+        "\n",
+        "        d = model.predictor.text_encoder(d_en,\n",
+        "                                         s, input_lengths, text_mask)\n",
+        "\n",
+        "        x, _ = model.predictor.lstm(d)\n",
+        "        duration = model.predictor.duration_proj(x)\n",
+        "\n",
+        "        duration = torch.sigmoid(duration).sum(axis=-1)\n",
+        "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+        "\n",
+        "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+        "        c_frame = 0\n",
+        "        for i in range(pred_aln_trg.size(0)):\n",
+        "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+        "            c_frame += int(pred_dur[i].data)\n",
+        "\n",
+        "        # encode prosody\n",
+        "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "        if model_params.decoder.type == \"hifigan\":\n",
+        "            asr_new = torch.zeros_like(en)\n",
+        "            asr_new[:, :, 0] = en[:, :, 0]\n",
+        "            asr_new[:, :, 1:] = en[:, :, 0:-1]\n",
+        "            en = asr_new\n",
+        "\n",
+        "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+        "\n",
+        "        asr = (t_en @ pred_aln_trg.unsqueeze(0).to(device))\n",
+        "        if model_params.decoder.type == \"hifigan\":\n",
+        "            asr_new = torch.zeros_like(asr)\n",
+        "            asr_new[:, :, 0] = asr[:, :, 0]\n",
+        "            asr_new[:, :, 1:] = asr[:, :, 0:-1]\n",
+        "            asr = asr_new\n",
+        "\n",
+        "        out = model.decoder(asr,\n",
+        "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+        "\n",
+        "\n",
+        "    return out.squeeze().cpu().numpy()[..., :-50] # weird pulse at the end of the model, need to be fixed later"
+      ],
+      "metadata": {
+        "id": "2x5kVb3nc_eY"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### Synthesize speech"
+      ],
+      "metadata": {
+        "id": "O159JnwCc6CC"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "text = '''Maltby and Company would issue warrants on them deliverable to the importer, and the goods were then passed to be stored in neighboring warehouses.\n",
+        "'''"
+      ],
+      "metadata": {
+        "id": "ThciXQ6rc9Eq"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# get a random reference in the training set, note that it doesn't matter which one you use\n",
+        "path = \"Data/wavs/LJ001-0110.wav\"\n",
+        "# this style vector ref_s can be saved as a parameter together with the model weights\n",
+        "ref_s = compute_style(path)"
+      ],
+      "metadata": {
+        "id": "jldPkJyCc83a"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "start = time.time()\n",
+        "wav = inference(text, ref_s, alpha=0.9, beta=0.9, diffusion_steps=10, embedding_scale=1)\n",
+        "rtf = (time.time() - start) / (len(wav) / 24000)\n",
+        "print(f\"RTF = {rtf:5f}\")\n",
+        "import IPython.display as ipd\n",
+        "display(ipd.Audio(wav, rate=24000, normalize=False))"
+      ],
+      "metadata": {
+        "id": "_mIU0jqDdQ-c"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

stts_48khz/StyleTTS2_48khz/Configs/config.yml

@@ -0,0 +1,116 @@
+log_dir: "Models/LJSpeech"
+first_stage_path: "first_stage.pth"
+save_freq: 2
+log_interval: 10
+device: "cuda"
+epochs_1st: 200 # number of epochs for first stage training (pre-training)
+epochs_2nd: 100 # number of peochs for second stage training (joint training)
+batch_size: 16
+max_len: 325 # maximum number of frames
+pretrained_model: ""
+second_stage_load_pretrained: true # set to true if the pre-trained model is for 2nd stage
+load_only_params: false # set to true if do not want to load epoch numbers and optimizer parameters
+
+F0_path: "Utils/JDC/bst.t7"
+ASR_config: "Utils/ASR/config.yml"
+ASR_path: "Utils/ASR/epoch_00080.pth"
+PLBERT_dir: 'Utils/PLBERT/'
+
+data_params:
+  train_data: "Data/train_list.txt"
+  val_data: "Data/val_list.txt"
+  root_path: "/local/LJSpeech-1.1/wavs"
+  OOD_data: "Data/OOD_texts.txt"
+  min_length: 50 # sample until texts with this size are obtained for OOD texts
+
+preprocess_params:
+  sr: 24000
+  spect_params:
+    n_fft: 2048
+    win_length: 1200
+    hop_length: 300
+
+model_params:
+  multispeaker: false
+
+  dim_in: 64 
+  hidden_dim: 512
+  max_conv_dim: 512
+  n_layer: 3
+  n_mels: 80
+
+  n_token: 178 # number of phoneme tokens
+  max_dur: 50 # maximum duration of a single phoneme
+  style_dim: 128 # style vector size
+  
+  dropout: 0.2
+
+  # config for decoder
+  decoder: 
+      type: 'istftnet' # either hifigan or istftnet
+      resblock_kernel_sizes: [3,7,11]
+      upsample_rates :  [10, 6]
+      upsample_initial_channel: 512
+      resblock_dilation_sizes: [[1,3,5], [1,3,5], [1,3,5]]
+      upsample_kernel_sizes: [20, 12]
+      gen_istft_n_fft: 20
+      gen_istft_hop_size: 5
+      
+  # speech language model config
+  slm:
+      model: 'microsoft/wavlm-base-plus'
+      sr: 16000 # sampling rate of SLM
+      hidden: 768 # hidden size of SLM
+      nlayers: 13 # number of layers of SLM
+      initial_channel: 64 # initial channels of SLM discriminator head
+  
+  # style diffusion model config
+  diffusion:
+    embedding_mask_proba: 0.1
+    # transformer config
+    transformer:
+      num_layers: 3
+      num_heads: 8
+      head_features: 64
+      multiplier: 2
+
+    # diffusion distribution config
+    dist:
+      sigma_data: 0.2 # placeholder for estimate_sigma_data set to false
+      estimate_sigma_data: true # estimate sigma_data from the current batch if set to true
+      mean: -3.0
+      std: 1.0
+  
+loss_params:
+    lambda_mel: 5. # mel reconstruction loss
+    lambda_gen: 1. # generator loss
+    lambda_slm: 1. # slm feature matching loss
+    
+    lambda_mono: 1. # monotonic alignment loss (1st stage, TMA)
+    lambda_s2s: 1. # sequence-to-sequence loss (1st stage, TMA)
+    TMA_epoch: 50 # TMA starting epoch (1st stage)
+
+    lambda_F0: 1. # F0 reconstruction loss (2nd stage)
+    lambda_norm: 1. # norm reconstruction loss (2nd stage)
+    lambda_dur: 1. # duration loss (2nd stage)
+    lambda_ce: 20. # duration predictor probability output CE loss (2nd stage)
+    lambda_sty: 1. # style reconstruction loss (2nd stage)
+    lambda_diff: 1. # score matching loss (2nd stage)
+    
+    diff_epoch: 20 # style diffusion starting epoch (2nd stage)
+    joint_epoch: 50 # joint training starting epoch (2nd stage)
+
+optimizer_params:
+  lr: 0.0001 # general learning rate
+  bert_lr: 0.00001 # learning rate for PLBERT
+  ft_lr: 0.00001 # learning rate for acoustic modules
+  
+slmadv_params:
+  min_len: 400 # minimum length of samples
+  max_len: 500 # maximum length of samples
+  batch_percentage: 0.5 # to prevent out of memory, only use half of the original batch size
+  iter: 10 # update the discriminator every this iterations of generator update
+  thresh: 5 # gradient norm above which the gradient is scaled
+  scale: 0.01 # gradient scaling factor for predictors from SLM discriminators
+  sig: 1.5 # sigma for differentiable duration modeling
+  

stts_48khz/StyleTTS2_48khz/Configs/config_ft.yml

@@ -0,0 +1,118 @@
+log_dir: "Models/Style_Kanade_48khz_fn"
+save_freq: 1
+log_interval: 10
+device: "cuda"
+epochs: 2
+batch_size: 14
+max_len: 2250 # maximum number of frames
+pretrained_model: "/home/austin/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz_fn/finetune_phase_13999.pth"
+second_stage_load_pretrained: true # set to true if the pre-trained model is for 2nd stage
+load_only_params: true # set to true if do not want to load epoch numbers and optimizer parameters
+
+
+F0_path: "/home/austin/disk1/stts-zs_cleaning/F0_extractor/PitchExtractor/Checkpoint_200k/PE_48khz_epoch_00060.pth"
+ASR_config: "/home/austin/disk2/llmvcs/tt/stylekan/Utils/ASR/config.yml"
+ASR_path: "/home/austin/disk2/llmvcs/tt/AuxiliaryASR/Checkpoint_new_plus/epoch_00070.pth"
+
+PLBERT_dir: '/home/austin/disk2/llmvcs/tt/stylekan/Utils/PLBERT'
+
+data_params:
+  train_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/metadata_cleanest/train_48_pure.csv"
+  val_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/metadata_cleanest/val_48_pure.csv"
+  root_path: ""
+  OOD_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/OOD_LargeScale_.csv"
+  min_length: 50 # sample until texts with this size are obtained for OOD texts
+
+#CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6 accelerate launch accelerate_train_finetune.py -config_path ./Configs/config_ft.yml
+#CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6 python train_second.py --config_path ./Configs/config_kanade.yml
+preprocess_params:
+  sr: 48000
+  spect_params:
+    n_fft: 2048
+    win_length: 2048
+    hop_length: 512
+
+model_params:
+  multispeaker: true
+
+  dim_in: 64 
+  hidden_dim: 512
+  max_conv_dim: 512
+  n_layer: 3
+  n_mels: 80
+
+  n_token: 178 # number of phoneme tokens
+  max_dur: 50 # maximum duration of a single phoneme
+  style_dim: 128 # style vector size
+  
+  dropout: 0.2
+  
+  # config for decoder
+  decoder: 
+      type: 'istftnet' # either hifigan or istftnet
+      resblock_kernel_sizes: [3,7,11]
+      upsample_rates :  [16, 8]
+      upsample_initial_channel: 512
+      resblock_dilation_sizes: [[1,3,5], [1,3,5], [1,3,5]]
+      upsample_kernel_sizes: [32, 16]
+      gen_istft_n_fft: 32
+      gen_istft_hop_size: 4
+      
+      
+  # speech language model config
+  slm:
+      model: 'Respair/Whisper_Large_v2_Encoder_Block' # The model itself is hardcoded, change it through -> losses.py
+      sr: 16000 # sampling rate of SLM
+      hidden: 1280 # hidden size of SLM
+      nlayers: 33 # number of layers of SLM
+      initial_channel: 64 # initial channels of SLM discriminator head
+  
+  # style diffusion model config
+  diffusion:
+    embedding_mask_proba: 0.1
+    # transformer config
+    transformer:
+      num_layers: 3
+      num_heads: 8
+      head_features: 64
+      multiplier: 2
+
+    # diffusion distribution config
+    dist:
+      sigma_data: 0.2 # placeholder for estimate_sigma_data set to false
+      estimate_sigma_data: true # estimate sigma_data from the current batch if set to true
+      mean: -3.0
+      std: 1.0
+  
+loss_params:
+    lambda_mel: 5. # mel reconstruction loss
+    lambda_gen: 1. # generator loss
+    lambda_slm: 1. # slm feature matching loss
+    
+    lambda_mono: 1. # monotonic alignment loss (TMA)
+    lambda_s2s: 1. # sequence-to-sequence loss (TMA)
+
+    lambda_F0: 1. # F0 reconstruction loss
+    lambda_norm: 1. # norm reconstruction loss
+    lambda_dur: 1. # duration loss
+    lambda_ce: 20. # duration predictor probability output CE loss
+    lambda_sty: 1. # style reconstruction loss
+    lambda_diff: 1. # score matching loss
+    
+    diff_epoch: 0 # style diffusion starting epoch
+    joint_epoch: 30 # joint training starting epoch
+
+optimizer_params:
+  lr: 0.0001 # general learning rate
+  bert_lr: 0.00001 # learning rate for PLBERT
+  ft_lr: 0.0001 # learning rate for acoustic modules
+  
+slmadv_params:
+  min_len: 400 # minimum length of samples
+  max_len: 500 # maximum length of samples
+  batch_percentage: 0.5 # to prevent out of memory, only use half of the original batch size
+  iter: 10 # update the discriminator every this iterations of generator update
+  thresh: 5 # gradient norm above which the gradient is scaled
+  scale: 0.01 # gradient scaling factor for predictors from SLM discriminators
+  sig: 1.5 # sigma for differentiable duration modeling
+  

stts_48khz/StyleTTS2_48khz/Configs/config_kanade_48khz.yml

@@ -0,0 +1,125 @@
+log_dir: "Models/Style_Kanade_48khz"
+first_stage_path: ""
+save_freq: 1
+log_interval: 10
+device: "cuda"
+epochs_1st: 25 # number of epochs for first stage training (pre-training)
+epochs_2nd: 15 # number of peochs for second stage training (joint training)
+batch_size: 35
+
+max_len: 560 # approximately 15 seconds -> (512 / 48000) × (**2812** // 2) = 14.997 sec
+
+pretrained_model: "/home/austin/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/Top_ckpt.pth"
+second_stage_load_pretrained: true # set to true if the pre-trained model is for 2nd stage
+load_only_params: false # set to true if do not want to load epoch numbers and optimizer parameters
+
+# F0_path: "/home/ubuntu/STTS_48khz/StyleTTS2-48khz/Utils/JDC/bst_rmvpe_48k.t7"
+# ASR_config: "Utils/ASR/config.yml"
+# ASR_path: "/home/ubuntu/STTS_48khz/StyleTTS2-48khz/Utils/ASR/epoch_00050_48K.pth"
+
+F0_path: "/home/austin/disk1/stts-zs_cleaning/F0_extractor/PitchExtractor/Checkpoint_200k/PE_48khz_epoch_00060.pth"
+ASR_config: "/home/austin/disk2/llmvcs/tt/stylekan/Utils/ASR/config.yml"
+ASR_path: "/home/austin/disk2/llmvcs/tt/AuxiliaryASR/Checkpoint_new_plus/epoch_00070.pth"
+
+PLBERT_dir: '/home/austin/disk2/llmvcs/tt/stylekan/Utils/PLBERT'
+
+data_params:
+  train_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/metadata_cleanest/train_48_pure.csv"
+  val_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/metadata_cleanest/val_48_pure.csv"
+  root_path: ""
+  OOD_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/OOD_LargeScale_.csv"
+  min_length: 50 # sample until texts with this size are obtained for OOD texts
+
+#CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6 accelerate launch accelerate_train_second.py --config_path ./Configs/config_kanade_48khz.yml
+#CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6 python train_second.py --config_path ./Configs/config_kanade.yml
+#CUDA_VISIBLE_DEVICES=7 accelerate launch accelerate_train_second.py --config_path ./Configs/config_ft.yml
+preprocess_params:
+  sr: 48000
+  spect_params:
+    n_fft: 2048
+    win_length: 2048
+    hop_length: 512
+
+model_params:
+  multispeaker: true
+
+  dim_in: 64 
+  hidden_dim: 512
+  max_conv_dim: 512
+  n_layer: 3
+  n_mels: 80
+
+  n_token: 178 # number of phoneme tokens
+  max_dur: 50 # maximum duration of a single phoneme
+  style_dim: 128 # style vector size
+  
+  dropout: 0.2
+
+  decoder: 
+      type: 'istftnet' # either hifigan or istftnet
+      resblock_kernel_sizes: [3,7,11]
+      upsample_rates :  [16, 8]
+      upsample_initial_channel: 512
+      resblock_dilation_sizes: [[1,3,5], [1,3,5], [1,3,5]]
+      upsample_kernel_sizes: [32, 16]
+      gen_istft_n_fft: 32
+      gen_istft_hop_size: 4
+      
+      
+  # speech language model config
+  slm:
+      model: 'Respair/Whisper_Large_v2_Encoder_Block' # The model itself is hardcoded, change it through -> losses.py
+      sr: 16000 # sampling rate of SLM
+      hidden: 1280 # hidden size of SLM
+      nlayers: 33 # number of layers of SLM
+      initial_channel: 64 # initial channels of SLM discriminator head
+  
+  # style diffusion model config
+  diffusion:
+    embedding_mask_proba: 0.1
+    # transformer config
+    transformer:
+      num_layers: 3
+      num_heads: 8
+      head_features: 64
+      multiplier: 2
+
+    # diffusion distribution config
+    dist:
+      sigma_data: 0.2 # placeholder for estimate_sigma_data set to false
+      estimate_sigma_data: true # estimate sigma_data from the current batch if set to true
+      mean: -3.0
+      std: 1.0
+  
+loss_params:
+    lambda_mel: 10. # mel reconstruction loss
+    lambda_gen: 1. # generator loss
+    lambda_slm: 1. # slm feature matching loss
+    
+    lambda_mono: 1. # monotonic alignment loss (1st stage, TMA)
+    lambda_s2s: 1. # sequence-to-sequence loss (1st stage, TMA)
+    TMA_epoch: 3 # TMA starting epoch (1st stage)
+
+    lambda_F0: 1. # F0 reconstruction loss (2nd stage)
+    lambda_norm: 1. # norm reconstruction loss (2nd stage)
+    lambda_dur: 1. # duration loss (2nd stage)
+    lambda_ce: 20. # duration predictor probability output CE loss (2nd stage)
+    lambda_sty: 1. # style reconstruction loss (2nd stage)
+    lambda_diff: 1. # score matching loss (2nd stage)
+    
+    diff_epoch: 4 # style diffusion starting epoch (2nd stage)
+    joint_epoch: 999 # joint training starting epoch (2nd stage)
+
+optimizer_params:
+  lr: 0.0001 # general learning rate
+  bert_lr: 0.00001 # learning rate for PLBERT
+  ft_lr: 0.00001 # learning rate for acoustic modules
+  
+slmadv_params:
+  min_len: 400 # minimum length of samples
+  max_len: 500 # maximum length of samples
+  batch_percentage: .5 # to prevent out of memory, only use 1/2 of the original batch size
+  iter: 20 # update the discriminator every this iterations of generator update
+  thresh: 5 # gradient norm above which the gradient is scaled
+  scale: 0.01 # gradient scaling factor for predictors from SLM discriminators
+  sig: 1.5 # sigma for differentiable duration modeling

stts_48khz/StyleTTS2_48khz/Configs/config_kanade_48khz_copy.yml

@@ -0,0 +1,124 @@
+log_dir: "Models/Style_Kanade_48khz_test"
+first_stage_path: "/home/austin/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/epoch_1st_00020.pth"
+save_freq: 1
+log_interval: 10
+device: "cuda"
+epochs_1st: 25 # number of epochs for first stage training (pre-training)
+epochs_2nd: 15 # number of peochs for second stage training (joint training)
+batch_size: 2
+
+max_len: 2812 # approximately 15 seconds -> 0.01066666666666666666666666666667 × (2812 // 2) = 14.999
+
+pretrained_model: "/home/austin/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/epoch_2nd_00004.pth"
+second_stage_load_pretrained: true # set to true if the pre-trained model is for 2nd stage
+load_only_params: false # set to true if do not want to load epoch numbers and optimizer parameters
+
+# F0_path: "/home/ubuntu/STTS_48khz/StyleTTS2-48khz/Utils/JDC/bst_rmvpe_48k.t7"
+# ASR_config: "Utils/ASR/config.yml"
+# ASR_path: "/home/ubuntu/STTS_48khz/StyleTTS2-48khz/Utils/ASR/epoch_00050_48K.pth"
+
+F0_path: "/home/austin/disk1/stts-zs_cleaning/F0_extractor/PitchExtractor/Checkpoint_200k/PE_48khz_epoch_00060.pth"
+ASR_config: "/home/austin/disk2/llmvcs/tt/stylekan/Utils/ASR/config.yml"
+ASR_path: "/home/austin/disk2/llmvcs/tt/AuxiliaryASR/Checkpoint_new_plus/epoch_00070.pth"
+
+PLBERT_dir: '/home/austin/disk2/llmvcs/tt/stylekan/Utils/PLBERT'
+
+data_params:
+  train_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/metadata_cleanest/val_48_pure.txt"
+  val_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/metadata_cleanest/val_48_pure.csv"
+  root_path: ""
+  OOD_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/OOD_LargeScale_.csv"
+  min_length: 50 # sample until texts with this size are obtained for OOD texts
+
+#CUDA_VISIBLE_DEVICES=5,6,7 accelerate launch accelerate_train_second.py --config_path ./Configs/config_kanade_48khz_copy.yml
+#CUDA_VISIBLE_DEVICES=6,7 python train_second.py --config_path ./Configs/config_kanade_48khz_copy.yml
+preprocess_params:
+  sr: 48000
+  spect_params:
+    n_fft: 2048
+    win_length: 2048
+    hop_length: 512
+
+model_params:
+  multispeaker: true
+
+  dim_in: 64 
+  hidden_dim: 512
+  max_conv_dim: 512
+  n_layer: 3
+  n_mels: 80
+
+  n_token: 178 # number of phoneme tokens
+  max_dur: 50 # maximum duration of a single phoneme
+  style_dim: 128 # style vector size
+  
+  dropout: 0.2
+
+  decoder: 
+      type: 'istftnet' # either hifigan or istftnet
+      resblock_kernel_sizes: [3,7,11]
+      upsample_rates :  [16, 8]
+      upsample_initial_channel: 512
+      resblock_dilation_sizes: [[1,3,5], [1,3,5], [1,3,5]]
+      upsample_kernel_sizes: [32, 16]
+      gen_istft_n_fft: 32
+      gen_istft_hop_size: 4
+      
+      
+  # speech language model config
+  slm:
+      model: 'Respair/Whisper_Large_v2_Encoder_Block' # The model itself is hardcoded, change it through -> losses.py
+      sr: 16000 # sampling rate of SLM
+      hidden: 1280 # hidden size of SLM
+      nlayers: 33 # number of layers of SLM
+      initial_channel: 64 # initial channels of SLM discriminator head
+  
+  # style diffusion model config
+  diffusion:
+    embedding_mask_proba: 0.1
+    # transformer config
+    transformer:
+      num_layers: 3
+      num_heads: 8
+      head_features: 64
+      multiplier: 2
+
+    # diffusion distribution config
+    dist:
+      sigma_data: 0.2 # placeholder for estimate_sigma_data set to false
+      estimate_sigma_data: true # estimate sigma_data from the current batch if set to true
+      mean: -3.0
+      std: 1.0
+  
+loss_params:
+    lambda_mel: 10. # mel reconstruction loss
+    lambda_gen: 1. # generator loss
+    lambda_slm: 1. # slm feature matching loss
+    
+    lambda_mono: 1. # monotonic alignment loss (1st stage, TMA)
+    lambda_s2s: 1. # sequence-to-sequence loss (1st stage, TMA)
+    TMA_epoch: 3 # TMA starting epoch (1st stage)
+
+    lambda_F0: 1. # F0 reconstruction loss (2nd stage)
+    lambda_norm: 1. # norm reconstruction loss (2nd stage)
+    lambda_dur: 1. # duration loss (2nd stage)
+    lambda_ce: 20. # duration predictor probability output CE loss (2nd stage)
+    lambda_sty: 1. # style reconstruction loss (2nd stage)
+    lambda_diff: 1. # score matching loss (2nd stage)
+    
+    diff_epoch: 4 # style diffusion starting epoch (2nd stage)
+    joint_epoch: 12 # joint training starting epoch (2nd stage)
+
+optimizer_params:
+  lr: 0.0001 # general learning rate
+  bert_lr: 0.00001 # learning rate for PLBERT
+  ft_lr: 0.00001 # learning rate for acoustic modules
+  
+slmadv_params:
+  min_len: 400 # minimum length of samples
+  max_len: 500 # maximum length of samples
+  batch_percentage: 1 # to prevent out of memory, only use half of the original batch size
+  iter: 20 # update the discriminator every this iterations of generator update
+  thresh: 5 # gradient norm above which the gradient is scaled
+  scale: 0.01 # gradient scaling factor for predictors from SLM discriminators
+  sig: 1.5 # sigma for differentiable duration modeling

stts_48khz/StyleTTS2_48khz/Demo/Inference_LJSpeech.ipynb

@@ -0,0 +1,554 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9adb7bd1",
+   "metadata": {},
+   "source": [
+    "# StyleTTS 2 Demo (LJSpeech)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6108384d",
+   "metadata": {},
+   "source": [
+    "### Utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "96e173bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "torch.manual_seed(0)\n",
+    "torch.backends.cudnn.benchmark = False\n",
+    "torch.backends.cudnn.deterministic = True\n",
+    "\n",
+    "import random\n",
+    "random.seed(0)\n",
+    "\n",
+    "import numpy as np\n",
+    "np.random.seed(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da84c60f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%cd .."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a3ddcc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load packages\n",
+    "import time\n",
+    "import random\n",
+    "import yaml\n",
+    "from munch import Munch\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "import torch.nn.functional as F\n",
+    "import torchaudio\n",
+    "import librosa\n",
+    "from nltk.tokenize import word_tokenize\n",
+    "\n",
+    "from models import *\n",
+    "from utils import *\n",
+    "from text_utils import TextCleaner\n",
+    "textclenaer = TextCleaner()\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bbdc04c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00ee05e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "to_mel = torchaudio.transforms.MelSpectrogram(\n",
+    "    n_mels=80, n_fft=2048, win_length=1200, hop_length=300)\n",
+    "mean, std = -4, 4\n",
+    "\n",
+    "def length_to_mask(lengths):\n",
+    "    mask = torch.arange(lengths.max()).unsqueeze(0).expand(lengths.shape[0], -1).type_as(lengths)\n",
+    "    mask = torch.gt(mask+1, lengths.unsqueeze(1))\n",
+    "    return mask\n",
+    "\n",
+    "def preprocess(wave):\n",
+    "    wave_tensor = torch.from_numpy(wave).float()\n",
+    "    mel_tensor = to_mel(wave_tensor)\n",
+    "    mel_tensor = (torch.log(1e-5 + mel_tensor.unsqueeze(0)) - mean) / std\n",
+    "    return mel_tensor\n",
+    "\n",
+    "def compute_style(ref_dicts):\n",
+    "    reference_embeddings = {}\n",
+    "    for key, path in ref_dicts.items():\n",
+    "        wave, sr = librosa.load(path, sr=24000)\n",
+    "        audio, index = librosa.effects.trim(wave, top_db=30)\n",
+    "        if sr != 24000:\n",
+    "            audio = librosa.resample(audio, sr, 24000)\n",
+    "        mel_tensor = preprocess(audio).to(device)\n",
+    "\n",
+    "        with torch.no_grad():\n",
+    "            ref = model.style_encoder(mel_tensor.unsqueeze(1))\n",
+    "        reference_embeddings[key] = (ref.squeeze(1), audio)\n",
+    "    \n",
+    "    return reference_embeddings"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b9cecbe",
+   "metadata": {},
+   "source": [
+    "### Load models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "64fc4c0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load phonemizer\n",
+    "import phonemizer\n",
+    "global_phonemizer = phonemizer.backend.EspeakBackend(language='en-us', preserve_punctuation=True,  with_stress=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48e7b644",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = yaml.safe_load(open(\"Models/LJSpeech/config.yml\"))\n",
+    "\n",
+    "# load pretrained ASR model\n",
+    "ASR_config = config.get('ASR_config', False)\n",
+    "ASR_path = config.get('ASR_path', False)\n",
+    "text_aligner = load_ASR_models(ASR_path, ASR_config)\n",
+    "\n",
+    "# load pretrained F0 model\n",
+    "F0_path = config.get('F0_path', False)\n",
+    "pitch_extractor = load_F0_models(F0_path)\n",
+    "\n",
+    "# load BERT model\n",
+    "from Utils.PLBERT.util import load_plbert\n",
+    "BERT_path = config.get('PLBERT_dir', False)\n",
+    "plbert = load_plbert(BERT_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffc18cf7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = build_model(recursive_munch(config['model_params']), text_aligner, pitch_extractor, plbert)\n",
+    "_ = [model[key].eval() for key in model]\n",
+    "_ = [model[key].to(device) for key in model]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "64529d5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params_whole = torch.load(\"Models/LJSpeech/epoch_2nd_00100.pth\", map_location='cpu')\n",
+    "params = params_whole['net']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "895d9706",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for key in model:\n",
+    "    if key in params:\n",
+    "        print('%s loaded' % key)\n",
+    "        try:\n",
+    "            model[key].load_state_dict(params[key])\n",
+    "        except:\n",
+    "            from collections import OrderedDict\n",
+    "            state_dict = params[key]\n",
+    "            new_state_dict = OrderedDict()\n",
+    "            for k, v in state_dict.items():\n",
+    "                name = k[7:] # remove `module.`\n",
+    "                new_state_dict[name] = v\n",
+    "            # load params\n",
+    "            model[key].load_state_dict(new_state_dict, strict=False)\n",
+    "#             except:\n",
+    "#                 _load(params[key], model[key])\n",
+    "_ = [model[key].eval() for key in model]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1a59db2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from Modules.diffusion.sampler import DiffusionSampler, ADPM2Sampler, KarrasSchedule"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e30985ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sampler = DiffusionSampler(\n",
+    "    model.diffusion.diffusion,\n",
+    "    sampler=ADPM2Sampler(),\n",
+    "    sigma_schedule=KarrasSchedule(sigma_min=0.0001, sigma_max=3.0, rho=9.0), # empirical parameters\n",
+    "    clamp=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b803110e",
+   "metadata": {},
+   "source": [
+    "### Synthesize speech"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24655f46",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# synthesize a text\n",
+    "text = ''' StyleTTS 2 is a text-to-speech model that leverages style diffusion and adversarial training with large speech language models to achieve human-level text-to-speech synthesis. '''"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ca57469c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def inference(text, noise, diffusion_steps=5, embedding_scale=1):\n",
+    "    text = text.strip()\n",
+    "    text = text.replace('\"', '')\n",
+    "    ps = global_phonemizer.phonemize([text])\n",
+    "    ps = word_tokenize(ps[0])\n",
+    "    ps = ' '.join(ps)\n",
+    "\n",
+    "    tokens = textclenaer(ps)\n",
+    "    tokens.insert(0, 0)\n",
+    "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(tokens.device)\n",
+    "        text_mask = length_to_mask(input_lengths).to(tokens.device)\n",
+    "\n",
+    "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+    "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+    "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2) \n",
+    "\n",
+    "        s_pred = sampler(noise, \n",
+    "              embedding=bert_dur[0].unsqueeze(0), num_steps=diffusion_steps,\n",
+    "              embedding_scale=embedding_scale).squeeze(0)\n",
+    "\n",
+    "        s = s_pred[:, 128:]\n",
+    "        ref = s_pred[:, :128]\n",
+    "\n",
+    "        d = model.predictor.text_encoder(d_en, s, input_lengths, text_mask)\n",
+    "\n",
+    "        x, _ = model.predictor.lstm(d)\n",
+    "        duration = model.predictor.duration_proj(x)\n",
+    "        duration = torch.sigmoid(duration).sum(axis=-1)\n",
+    "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+    "\n",
+    "        pred_dur[-1] += 5\n",
+    "\n",
+    "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+    "        c_frame = 0\n",
+    "        for i in range(pred_aln_trg.size(0)):\n",
+    "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+    "            c_frame += int(pred_dur[i].data)\n",
+    "\n",
+    "        # encode prosody\n",
+    "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+    "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+    "        out = model.decoder((t_en @ pred_aln_trg.unsqueeze(0).to(device)), \n",
+    "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+    "        \n",
+    "    return out.squeeze().cpu().numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d438ef4f",
+   "metadata": {},
+   "source": [
+    "#### Basic synthesis (5 diffusion steps)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3d7f7d5",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "start = time.time()\n",
+    "noise = torch.randn(1,1,256).to(device)\n",
+    "wav = inference(text, noise, diffusion_steps=5, embedding_scale=1)\n",
+    "rtf = (time.time() - start) / (len(wav) / 24000)\n",
+    "print(f\"RTF = {rtf:5f}\")\n",
+    "import IPython.display as ipd\n",
+    "display(ipd.Audio(wav, rate=24000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d5d9df0",
+   "metadata": {},
+   "source": [
+    "#### With higher diffusion steps (more diverse)\n",
+    "Since the sampler is ancestral, the higher the stpes, the more diverse the samples are, with the cost of slower synthesis speed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a10129fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start = time.time()\n",
+    "noise = torch.randn(1,1,256).to(device)\n",
+    "wav = inference(text, noise, diffusion_steps=10, embedding_scale=1)\n",
+    "rtf = (time.time() - start) / (len(wav) / 24000)\n",
+    "print(f\"RTF = {rtf:5f}\")\n",
+    "import IPython.display as ipd\n",
+    "display(ipd.Audio(wav, rate=24000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1877ea15",
+   "metadata": {},
+   "source": [
+    "### Speech expressiveness\n",
+    "The following section recreates the samples shown in [Section 6](https://styletts2.github.io/#emo) of the demo page."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c4777b7",
+   "metadata": {},
+   "source": [
+    "#### With embedding_scale=1\n",
+    "This is the classifier-free guidance scale. The higher the scale, the more conditional the style is to the input text and hence more emotional. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c29ea2f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texts = {}\n",
+    "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+    "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+    "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+    "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+    "\n",
+    "for k,v in texts.items():\n",
+    "    noise = torch.randn(1,1,256).to(device)\n",
+    "    wav = inference(v, noise, diffusion_steps=10, embedding_scale=1)\n",
+    "    print(k + \": \")\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c89499f",
+   "metadata": {},
+   "source": [
+    "#### With embedding_scale=2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f73be3aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texts = {}\n",
+    "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+    "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+    "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+    "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+    "\n",
+    "for k,v in texts.items():\n",
+    "    noise = torch.randn(1,1,256).to(device)\n",
+    "    wav = inference(v, noise, diffusion_steps=10, embedding_scale=2) # embedding_scale=2 for more pronounced emotion\n",
+    "    print(k + \": \")\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9320da63",
+   "metadata": {},
+   "source": [
+    "### Long-form generation\n",
+    "This section includes basic implementation of Algorithm 1 in the paper for consistent longform audio generation. The example passage is taken from [Section 5](https://styletts2.github.io/#long) of the demo page. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cdd4db51",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "passage = '''If the supply of fruit is greater than the family needs, it may be made a source of income by sending the fresh fruit to the market if there is one near enough, or by preserving, canning, and making jelly for sale. To make such an enterprise a success the fruit and work must be first class. There is magic in the word \"Homemade,\" when the product appeals to the eye and the palate; but many careless and incompetent people have found to their sorrow that this word has not magic enough to float inferior goods on the market. As a rule large canning and preserving establishments are clean and have the best appliances, and they employ chemists and skilled labor. The home product must be very good to compete with the attractive goods that are sent out from such establishments. Yet for first-class homemade products there is a market in all large cities. All first-class grocers have customers who purchase such goods.'''"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ebb941c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def LFinference(text, s_prev, noise, alpha=0.7, diffusion_steps=5, embedding_scale=1):\n",
+    "    text = text.strip()\n",
+    "    text = text.replace('\"', '')\n",
+    "    ps = global_phonemizer.phonemize([text])\n",
+    "    ps = word_tokenize(ps[0])\n",
+    "    ps = ' '.join(ps)\n",
+    "\n",
+    "    tokens = textclenaer(ps)\n",
+    "    tokens.insert(0, 0)\n",
+    "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(tokens.device)\n",
+    "        text_mask = length_to_mask(input_lengths).to(tokens.device)\n",
+    "\n",
+    "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+    "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+    "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2) \n",
+    "\n",
+    "        s_pred = sampler(noise, \n",
+    "              embedding=bert_dur[0].unsqueeze(0), num_steps=diffusion_steps,\n",
+    "              embedding_scale=embedding_scale).squeeze(0)\n",
+    "        \n",
+    "        if s_prev is not None:\n",
+    "            # convex combination of previous and current style\n",
+    "            s_pred = alpha * s_prev + (1 - alpha) * s_pred\n",
+    "        \n",
+    "        s = s_pred[:, 128:]\n",
+    "        ref = s_pred[:, :128]\n",
+    "\n",
+    "        d = model.predictor.text_encoder(d_en, s, input_lengths, text_mask)\n",
+    "\n",
+    "        x, _ = model.predictor.lstm(d)\n",
+    "        duration = model.predictor.duration_proj(x)\n",
+    "        duration = torch.sigmoid(duration).sum(axis=-1)\n",
+    "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+    "\n",
+    "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+    "        c_frame = 0\n",
+    "        for i in range(pred_aln_trg.size(0)):\n",
+    "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+    "            c_frame += int(pred_dur[i].data)\n",
+    "\n",
+    "        # encode prosody\n",
+    "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+    "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+    "        out = model.decoder((t_en @ pred_aln_trg.unsqueeze(0).to(device)), \n",
+    "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+    "        \n",
+    "    return out.squeeze().cpu().numpy(), s_pred"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ca0ef2e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sentences = passage.split('.') # simple split by comma\n",
+    "wavs = []\n",
+    "s_prev = None\n",
+    "for text in sentences:\n",
+    "    if text.strip() == \"\": continue\n",
+    "    text += '.' # add it back\n",
+    "    noise = torch.randn(1,1,256).to(device)\n",
+    "    wav, s_prev = LFinference(text, s_prev, noise, alpha=0.7, diffusion_steps=10, embedding_scale=1.5)\n",
+    "    wavs.append(wav)\n",
+    "display(ipd.Audio(np.concatenate(wavs), rate=24000, normalize=False))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "NLP",
+   "language": "python",
+   "name": "nlp"
+  },
+  "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.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

stts_48khz/StyleTTS2_48khz/Demo/Inference_LibriTTS.ipynb

@@ -0,0 +1,1242 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9adb7bd1",
+   "metadata": {},
+   "source": [
+    "# StyleTTS 2 Demo (LibriTTS) 48khz\n",
+    "\n",
+    "Before you run the following cells, please make sure you have downloaded [reference_audio.zip](https://huggingface.co/yl4579/StyleTTS2-LibriTTS/resolve/main/reference_audio.zip) and unzipped it under the `demo` folder."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6108384d",
+   "metadata": {},
+   "source": [
+    "### Utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "96e173bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"6\"\n",
+    "import torch\n",
+    "print(torch.cuda.device_count())  # should print: 1\n",
+    "\n",
+    "import torch\n",
+    "torch.manual_seed(0)\n",
+    "torch.backends.cudnn.benchmark = False\n",
+    "torch.backends.cudnn.deterministic = True\n",
+    "\n",
+    "import random\n",
+    "random.seed(0)\n",
+    "\n",
+    "import numpy as np\n",
+    "np.random.seed(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "da84c60f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/austin/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd /home/austin/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "5a3ddcc8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "177\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load packages\n",
+    "import time\n",
+    "import random\n",
+    "import yaml\n",
+    "from munch import Munch\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "import torch.nn.functional as F\n",
+    "import torchaudio\n",
+    "import librosa\n",
+    "from nltk.tokenize import word_tokenize\n",
+    "\n",
+    "from models import *\n",
+    "from utils import *\n",
+    "from text_utils import TextCleaner\n",
+    "textclenaer = TextCleaner()\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "00ee05e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "to_mel = torchaudio.transforms.MelSpectrogram(\n",
+    "    n_mels=80, n_fft=2048, win_length=2048, hop_length=512)\n",
+    "mean, std = -4, 4\n",
+    "\n",
+    "def length_to_mask(lengths):\n",
+    "    mask = torch.arange(lengths.max()).unsqueeze(0).expand(lengths.shape[0], -1).type_as(lengths)\n",
+    "    mask = torch.gt(mask+1, lengths.unsqueeze(1))\n",
+    "    return mask\n",
+    "\n",
+    "def preprocess(wave):\n",
+    "    wave_tensor = torch.from_numpy(wave).float()\n",
+    "    mel_tensor = to_mel(wave_tensor)\n",
+    "    mel_tensor = (torch.log(1e-5 + mel_tensor.unsqueeze(0)) - mean) / std\n",
+    "    return mel_tensor\n",
+    "\n",
+    "def compute_style(path):\n",
+    "    wave, sr = librosa.load(path, sr=48000)\n",
+    "    audio, index = librosa.effects.trim(wave, top_db=30)\n",
+    "    if sr != 48000:\n",
+    "        audio = librosa.resample(audio, sr, 48000)\n",
+    "    mel_tensor = preprocess(audio).to(device)\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        ref_s = model.style_encoder(mel_tensor.unsqueeze(1))\n",
+    "        ref_p = model.predictor_encoder(mel_tensor.unsqueeze(1))\n",
+    "\n",
+    "    return torch.cat([ref_s, ref_p], dim=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "bbdc04c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b9cecbe",
+   "metadata": {},
+   "source": [
+    "### Load models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "64fc4c0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load phonemizer\n",
+    "import phonemizer\n",
+    "global_phonemizer = phonemizer.backend.EspeakBackend(language='en-us', preserve_punctuation=True,  with_stress=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "48e7b644",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = yaml.safe_load(open(\"/home/austin/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/config_kanade_48khz.yml\"))\n",
+    "\n",
+    "# load pretrained ASR model\n",
+    "ASR_config = config.get('ASR_config', False)\n",
+    "ASR_path = config.get('ASR_path', False)\n",
+    "text_aligner = load_ASR_models(ASR_path, ASR_config)\n",
+    "\n",
+    "# load pretrained F0 model\n",
+    "F0_path = config.get('F0_path', False)\n",
+    "pitch_extractor = load_F0_models(F0_path)\n",
+    "\n",
+    "# load BERT model\n",
+    "from Utils.PLBERT.util import load_plbert\n",
+    "BERT_path = config.get('PLBERT_dir', False)\n",
+    "plbert = load_plbert(BERT_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "ffc18cf7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_params = recursive_munch(config['model_params'])\n",
+    "model = build_model(model_params, text_aligner, pitch_extractor, plbert)\n",
+    "_ = [model[key].eval() for key in model]\n",
+    "_ = [model[key].to(device) for key in model]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "64529d5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params_whole = torch.load(\"/home/austin/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/epoch_2nd_00006.pth\", map_location='cpu')\n",
+    "params = params_whole['net']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "895d9706",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "bert loaded\n",
+      "bert_encoder loaded\n",
+      "predictor loaded\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "decoder loaded\n",
+      "text_encoder loaded\n",
+      "predictor_encoder loaded\n",
+      "style_encoder loaded\n",
+      "diffusion loaded\n",
+      "text_aligner loaded\n",
+      "pitch_extractor loaded\n",
+      "mpd loaded\n",
+      "msd loaded\n",
+      "wd loaded\n"
+     ]
+    }
+   ],
+   "source": [
+    "for key in model:\n",
+    "    if key in params:\n",
+    "        print('%s loaded' % key)\n",
+    "        try:\n",
+    "            model[key].load_state_dict(params[key])\n",
+    "        except:\n",
+    "            from collections import OrderedDict\n",
+    "            state_dict = params[key]\n",
+    "            new_state_dict = OrderedDict()\n",
+    "            for k, v in state_dict.items():\n",
+    "                name = k[7:] # remove `module.`\n",
+    "                new_state_dict[name] = v\n",
+    "            # load params\n",
+    "            model[key].load_state_dict(new_state_dict, strict=False)\n",
+    "#             except:\n",
+    "#                 _load(params[key], model[key])\n",
+    "_ = [model[key].eval() for key in model]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "e30985ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from Modules.diffusion.sampler import DiffusionSampler, ADPM2Sampler, KarrasSchedule\n",
+    "sampler = DiffusionSampler(\n",
+    "    model.diffusion.diffusion,\n",
+    "    sampler=ADPM2Sampler(),\n",
+    "    sigma_schedule=KarrasSchedule(sigma_min=0.0001, sigma_max=3.0, rho=9.0), # empirical parameters\n",
+    "    clamp=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b803110e",
+   "metadata": {},
+   "source": [
+    "### Synthesize speech"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ca57469c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def inference(text, ref_s, alpha = 0.3, beta = 0.7, diffusion_steps=5, embedding_scale=1):\n",
+    "    # text = text.strip()\n",
+    "    # ps = global_phonemizer.phonemize([text])\n",
+    "    # ps = word_tokenize(ps[0])\n",
+    "    # ps = ' '.join(ps)\n",
+    "    tokens = textclenaer(text)\n",
+    "    tokens.insert(0, 0)\n",
+    "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)\n",
+    "        text_mask = length_to_mask(input_lengths).to(device)\n",
+    "\n",
+    "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+    "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+    "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2) \n",
+    "        \n",
+    "\n",
+    "\n",
+    "        s_pred = sampler(noise = torch.randn((1, 256)).unsqueeze(1).to(device), \n",
+    "                                          embedding=bert_dur,\n",
+    "                                          embedding_scale=embedding_scale,\n",
+    "                                            features=ref_s, # reference from the same speaker as the embedding\n",
+    "                                             num_steps=diffusion_steps).squeeze(1)\n",
+    "\n",
+    "\n",
+    "        s = s_pred[:, 128:]\n",
+    "        ref = s_pred[:, :128]\n",
+    "\n",
+    "        ref = alpha * ref + (1 - alpha)  * ref_s[:, :128]\n",
+    "        s = beta * s + (1 - beta)  * ref_s[:, 128:]\n",
+    "\n",
+    "        d = model.predictor.text_encoder(d_en, \n",
+    "                                         s, input_lengths, text_mask)\n",
+    "\n",
+    "        x = model.predictor.lstm(d)\n",
+    "        x_mod =  model.predictor.prepare_projection(x) # 640 -> 512\n",
+    "        duration = model.predictor.duration_proj(x_mod)\n",
+    "\n",
+    "\n",
+    "        duration = torch.sigmoid(duration).sum(axis=-1) \n",
+    "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+    "\n",
+    "\n",
+    "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+    "        c_frame = 0\n",
+    "        for i in range(pred_aln_trg.size(0)):\n",
+    "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+    "            c_frame += int(pred_dur[i].data)\n",
+    "\n",
+    "        # encode prosody\n",
+    "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+    "        if model_params.decoder.type == \"hifigan\":\n",
+    "            asr_new = torch.zeros_like(en)\n",
+    "            asr_new[:, :, 0] = en[:, :, 0]\n",
+    "            asr_new[:, :, 1:] = en[:, :, 0:-1]\n",
+    "            en = asr_new\n",
+    "\n",
+    "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+    "\n",
+    "        asr = (t_en @ pred_aln_trg.unsqueeze(0).to(device))\n",
+    "        if model_params.decoder.type == \"hifigan\":\n",
+    "            asr_new = torch.zeros_like(asr)\n",
+    "            asr_new[:, :, 0] = asr[:, :, 0]\n",
+    "            asr_new[:, :, 1:] = asr[:, :, 0:-1]\n",
+    "            asr = asr_new\n",
+    "\n",
+    "        out = model.decoder(asr, \n",
+    "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+    "    \n",
+    "        \n",
+    "    return out.squeeze().cpu().numpy()[..., :-50] # weird pulse at the end of the model, need to be fixed later"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d438ef4f",
+   "metadata": {},
+   "source": [
+    "#### Basic synthesis (5 diffusion steps, seen speakers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "cace9787",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = '''soɯ iɯ imi de wa, sendʑoɯgawaɽa çitagi wa, kawaʔta no de mo, koɯsei ɕita no de mo, modoʔta no de mo toɽikaeɕita no de mo nakɯ, maɕite, deɽeta no de mo doɽota no de mo nakɯ.'''\n",
+    "reference_dicts = {}\n",
+    "# reference_dicts['696_92939'] = \"/home/austin/disk1/stts-zs_cleaning/data/moe_soshy/Japanese/imas_split/Syuuko/Syuuko_Events_and_Card/Event/saite_jewel/saite_jewel_chunk90.wav\"\n",
+    "# reference_dicts['1789_142896'] = \"/home/austin/disk1/stts-zs_cleaning/data/moe_soshy/Japanese/imas_split/Kanade/Kanade_Events_and_Card/Kanade_Events/KanLipps/Kanade_lipps_02/Kanade_lipps_02_chunk9.wav\"\n",
+    "# reference_dicts['1789_14289w'] = \"/home/austin/disk1/stts-zs_cleaning/data/moe_soshy/Japanese/sakura_moyu/01/01102220.wav\"\n",
+    "reference_dicts['1789_14289w'] = \"/home/austin/disk1/stts-zs_cleaning/data/moe_soshy/Japanese/monogatari/monogatari_voices/monogatari_split/sakamoto_maya/Sakamoto_Maya_01/Sakamoto_Maya_01_chunk1709.wav\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "16e8ac60",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'time' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[5], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m start \u001b[38;5;241m=\u001b[39m \u001b[43mtime\u001b[49m\u001b[38;5;241m.\u001b[39mtime()\n\u001b[1;32m      2\u001b[0m noise \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mrandn(\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m256\u001b[39m)\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, path \u001b[38;5;129;01min\u001b[39;00m reference_dicts\u001b[38;5;241m.\u001b[39mitems():\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'time' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "start = time.time()\n",
+    "noise = torch.randn(1,1,256).to(device)\n",
+    "for k, path in reference_dicts.items():\n",
+    "    ref_s = compute_style(path)\n",
+    "    \n",
+    "    wav = inference(text, ref_s, alpha=0., beta=0.5, diffusion_steps=10, embedding_scale=2)\n",
+    "    rtf = (time.time() - start) / (len(wav) / 48000)\n",
+    "    print(f\"RTF = {rtf:5f}\")\n",
+    "    import IPython.display as ipd\n",
+    "    print(k + ' Synthesized:')\n",
+    "    display(ipd.Audio(wav, rate=48000, normalize=False))\n",
+    "    print('Reference:')\n",
+    "    display(ipd.Audio(path, rate=48000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "14838708",
+   "metadata": {},
+   "source": [
+    "#### With higher diffusion steps (more diverse)\n",
+    "\n",
+    "Since the sampler is ancestral, the higher the stpes, the more diverse the samples are, with the cost of slower synthesis speed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6fbff03b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "noise = torch.randn(1,1,256).to(device)\n",
+    "for k, path in reference_dicts.items():\n",
+    "    ref_s = compute_style(path)\n",
+    "    start = time.time()\n",
+    "    wav = inference(text, ref_s, alpha=0.3, beta=0.7, diffusion_steps=10, embedding_scale=1)\n",
+    "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+    "    print(f\"RTF = {rtf:5f}\")\n",
+    "    import IPython.display as ipd\n",
+    "    print(k + ' Synthesized:')\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+    "    print(k + ' Reference:')\n",
+    "    display(ipd.Audio(path, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e6867fd",
+   "metadata": {},
+   "source": [
+    "#### Basic synthesis (5 diffusion steps, umseen speakers)\n",
+    "The following samples are to reproduce samples in [Section 4](https://styletts2.github.io/#libri) of the demo page. All spsakers are unseen during training. You can compare the generated samples to popular zero-shot TTS models like Vall-E and NaturalSpeech 2."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4e8faa0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reference_dicts = {}\n",
+    "# format: (path, text)\n",
+    "reference_dicts['1221-135767'] = (\"Demo/reference_audio/1221-135767-0014.wav\", \"Yea, his honourable worship is within, but he hath a godly minister or two with him, and likewise a leech.\")\n",
+    "reference_dicts['5639-40744'] = (\"Demo/reference_audio/5639-40744-0020.wav\", \"Thus did this humane and right minded father comfort his unhappy daughter, and her mother embracing her again, did all she could to soothe her feelings.\")\n",
+    "reference_dicts['908-157963'] = (\"Demo/reference_audio/908-157963-0027.wav\", \"And lay me down in my cold bed and leave my shining lot.\")\n",
+    "reference_dicts['4077-13754'] = (\"Demo/reference_audio/4077-13754-0000.wav\", \"The army found the people in poverty and left them in comparative wealth.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "653f1406",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "noise = torch.randn(1,1,256).to(device)\n",
+    "for k, v in reference_dicts.items():\n",
+    "    path, text = v\n",
+    "    ref_s = compute_style(path)\n",
+    "    start = time.time()\n",
+    "    wav = inference(text, ref_s, alpha=0.3, beta=0.7, diffusion_steps=5, embedding_scale=1)\n",
+    "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+    "    print(f\"RTF = {rtf:5f}\")\n",
+    "    import IPython.display as ipd\n",
+    "    print(k + ' Synthesized: ' + text)\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+    "    print(k + ' Reference:')\n",
+    "    display(ipd.Audio(path, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "141e91b3",
+   "metadata": {},
+   "source": [
+    "### Speech expressiveness\n",
+    "\n",
+    "The following section recreates the samples shown in [Section 6](https://styletts2.github.io/#emo) of the demo page. The speaker reference used is `1221-135767-0014.wav`, which is unseen during training. \n",
+    "\n",
+    "#### With `embedding_scale=1`\n",
+    "This is the classifier-free guidance scale. The higher the scale, the more conditional the style is to the input text and hence more emotional.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81addda4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ref_s = compute_style(\"Demo/reference_audio/1221-135767-0014.wav\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "be1b2a11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texts = {}\n",
+    "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+    "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+    "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+    "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+    "\n",
+    "for k,v in texts.items():\n",
+    "    wav = inference(v, ref_s, diffusion_steps=10, alpha=0.3, beta=0.7, embedding_scale=1)\n",
+    "    print(k + \": \")\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "96d262b8",
+   "metadata": {},
+   "source": [
+    "#### With `embedding_scale=2`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e7d40b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texts = {}\n",
+    "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+    "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+    "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+    "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+    "\n",
+    "for k,v in texts.items():\n",
+    "    noise = torch.randn(1,1,256).to(device)\n",
+    "    wav = inference(v, ref_s, diffusion_steps=10, alpha=0.3, beta=0.7, embedding_scale=2)\n",
+    "    print(k + \": \")\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "402b2bd6",
+   "metadata": {},
+   "source": [
+    "#### With `embedding_scale=2, alpha = 0.5, beta = 0.9`\n",
+    "`alpha` and `beta` is the factor to determine much we use the style sampled based on the text instead of the reference. The higher the value of `alpha` and `beta`, the more suitable the style it is to the text but less similar to the reference. Using higher beta makes the synthesized speech more emotional, at the cost of lower similarity to the reference. `alpha` determines the timbre of the speaker while `beta` determines the prosody. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "599de5d5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texts = {}\n",
+    "texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+    "texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+    "texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+    "texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\"\n",
+    "\n",
+    "for k,v in texts.items():\n",
+    "    noise = torch.randn(1,1,256).to(device)\n",
+    "    wav = inference(v, ref_s, diffusion_steps=10, alpha=0.5, beta=0.9, embedding_scale=2)\n",
+    "    print(k + \": \")\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48548866",
+   "metadata": {},
+   "source": [
+    "### Zero-shot speaker adaptation\n",
+    "This section recreates the \"Acoustic Environment Maintenance\" and \"Speaker’s Emotion Maintenance\" demo in [Section 4](https://styletts2.github.io/#libri) of the demo page. You can compare the generated samples to popular zero-shot TTS models like Vall-E. Note that the model was trained only on LibriTTS, which is about 250 times fewer data compared to those used to trian Vall-E with similar or better effect for these maintainance. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23e81572",
+   "metadata": {},
+   "source": [
+    "#### Acoustic Environment Maintenance\n",
+    "\n",
+    "Since we want to maintain the acoustic environment in the speaker (timbre), we set  `alpha = 0` to make the speaker as closer to the reference as possible while only changing the prosody according to the text.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8087bccb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reference_dicts = {}\n",
+    "# format: (path, text)\n",
+    "reference_dicts['3'] = (\"Demo/reference_audio/3.wav\", \"As friends thing I definitely I've got more male friends.\")\n",
+    "reference_dicts['4'] = (\"Demo/reference_audio/4.wav\", \"Everything is run by computer but you got to know how to think before you can do a computer.\")\n",
+    "reference_dicts['5'] = (\"Demo/reference_audio/5.wav\", \"Then out in LA you guys got a whole another ball game within California to worry about.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e99c200",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "noise = torch.randn(1,1,256).to(device)\n",
+    "for k, v in reference_dicts.items():\n",
+    "    path, text = v\n",
+    "    ref_s = compute_style(path)\n",
+    "    start = time.time()\n",
+    "    wav = inference(text, ref_s, alpha=0.0, beta=0.5, diffusion_steps=5, embedding_scale=1)\n",
+    "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+    "    print(f\"RTF = {rtf:5f}\")\n",
+    "    import IPython.display as ipd\n",
+    "    print('Synthesized: ' + text)\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+    "    print('Reference:')\n",
+    "    display(ipd.Audio(path, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d56505d",
+   "metadata": {},
+   "source": [
+    "#### Speaker’s Emotion Maintenance\n",
+    "\n",
+    "Since we want to maintain the emotion in the speaker (prosody), we set  `beta = 0.1` to make the speaker as closer to the reference as possible while having some diversity thruogh the slight timbre change."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f90179e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reference_dicts = {}\n",
+    "# format: (path, text)\n",
+    "reference_dicts['Anger'] = (\"Demo/reference_audio/anger.wav\", \"We have to reduce the number of plastic bags.\")\n",
+    "reference_dicts['Sleepy'] = (\"Demo/reference_audio/sleepy.wav\", \"We have to reduce the number of plastic bags.\")\n",
+    "reference_dicts['Amused'] = (\"Demo/reference_audio/amused.wav\", \"We have to reduce the number of plastic bags.\")\n",
+    "reference_dicts['Disgusted'] = (\"Demo/reference_audio/disgusted.wav\", \"We have to reduce the number of plastic bags.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e6bdfed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "noise = torch.randn(1,1,256).to(device)\n",
+    "for k, v in reference_dicts.items():\n",
+    "    path, text = v\n",
+    "    ref_s = compute_style(path)\n",
+    "    start = time.time()\n",
+    "    wav = inference(text, ref_s, alpha=0.3, beta=0.1, diffusion_steps=10, embedding_scale=1)\n",
+    "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+    "    print(f\"RTF = {rtf:5f}\")\n",
+    "    import IPython.display as ipd\n",
+    "    print(k + ' Synthesized: ' + text)\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+    "    print(k + ' Reference:')\n",
+    "    display(ipd.Audio(path, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37ae3963",
+   "metadata": {},
+   "source": [
+    "### Longform Narration\n",
+    "\n",
+    "This section includes basic implementation of Algorithm 1 in the paper for consistent longform audio generation. The example passage is taken from [Section 5](https://styletts2.github.io/#long) of the demo page."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f12a716b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "a1a38079",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def LFinference(text, s_prev, ref_s, alpha = 0.3, beta = 0.7, t = 0.7, diffusion_steps=5, embedding_scale=1):\n",
+    "    # text = text.strip()\n",
+    "    # ps = global_phonemizer.phonemize([text])\n",
+    "    # ps = word_tokenize(ps[0])\n",
+    "    # ps = ' '.join(ps)\n",
+    "    # ps = ps.replace('``', '\"')\n",
+    "    # ps = ps.replace(\"''\", '\"')\n",
+    "\n",
+    "    tokens = textclenaer(text)\n",
+    "    tokens.insert(0, 0)\n",
+    "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)\n",
+    "        text_mask = length_to_mask(input_lengths).to(device)\n",
+    "\n",
+    "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+    "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+    "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2) \n",
+    "\n",
+    "        s_pred = sampler(noise = torch.randn((1, 256)).unsqueeze(1).to(device), \n",
+    "                                          embedding=bert_dur,\n",
+    "                                          embedding_scale=embedding_scale,\n",
+    "                                            features=ref_s, # reference from the same speaker as the embedding\n",
+    "                                             num_steps=diffusion_steps).squeeze(1)\n",
+    "        \n",
+    "        if s_prev is not None:\n",
+    "            # convex combination of previous and current style\n",
+    "            s_pred = t * s_prev + (1 - t) * s_pred\n",
+    "        \n",
+    "        s = s_pred[:, 128:]\n",
+    "        ref = s_pred[:, :128]\n",
+    "        \n",
+    "        ref = alpha * ref + (1 - alpha)  * ref_s[:, :128]\n",
+    "        s = beta * s + (1 - beta)  * ref_s[:, 128:]\n",
+    "\n",
+    "        s_pred = torch.cat([ref, s], dim=-1)\n",
+    "\n",
+    "        d = model.predictor.text_encoder(d_en, \n",
+    "                                         s, input_lengths, text_mask)\n",
+    "\n",
+    "        x = model.predictor.lstm(d)\n",
+    "        x_mod =  model.predictor.prepare_projection(x) # 640 -> 512\n",
+    "        duration = model.predictor.duration_proj(x_mod)\n",
+    "\n",
+    "        duration = torch.sigmoid(duration).sum(axis=-1)\n",
+    "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+    "\n",
+    "\n",
+    "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+    "        c_frame = 0\n",
+    "        for i in range(pred_aln_trg.size(0)):\n",
+    "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+    "            c_frame += int(pred_dur[i].data)\n",
+    "\n",
+    "        # encode prosody\n",
+    "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+    "        if model_params.decoder.type == \"hifigan\":\n",
+    "            asr_new = torch.zeros_like(en)\n",
+    "            asr_new[:, :, 0] = en[:, :, 0]\n",
+    "            asr_new[:, :, 1:] = en[:, :, 0:-1]\n",
+    "            en = asr_new\n",
+    "\n",
+    "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+    "\n",
+    "        asr = (t_en @ pred_aln_trg.unsqueeze(0).to(device))\n",
+    "        if model_params.decoder.type == \"hifigan\":\n",
+    "            asr_new = torch.zeros_like(asr)\n",
+    "            asr_new[:, :, 0] = asr[:, :, 0]\n",
+    "            asr_new[:, :, 1:] = asr[:, :, 0:-1]\n",
+    "            asr = asr_new\n",
+    "\n",
+    "        out = model.decoder(asr, \n",
+    "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+    "    \n",
+    "        \n",
+    "    return out.squeeze().cpu().numpy()[..., :-100], s_pred # weird pulse at the end of the model, need to be fixed later"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "id": "e9088f7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "RuntimeError",
+     "evalue": "The size of tensor a (512) must match the size of tensor b (531) at non-singleton dimension 3",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[75], line 15\u001b[0m\n\u001b[1;32m     12\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m text\u001b[38;5;241m.\u001b[39mstrip() \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m     13\u001b[0m     text \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;66;03m# add it back\u001b[39;00m\n\u001b[0;32m---> 15\u001b[0m     wav, s_prev \u001b[38;5;241m=\u001b[39m \u001b[43mLFinference\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m     16\u001b[0m \u001b[43m                              \u001b[49m\u001b[43ms_prev\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m     17\u001b[0m \u001b[43m                              \u001b[49m\u001b[43ms_ref\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m     18\u001b[0m \u001b[43m                              \u001b[49m\u001b[43malpha\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m     19\u001b[0m \u001b[43m                              \u001b[49m\u001b[43mbeta\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# make it more suitable for the text\u001b[39;49;00m\n\u001b[1;32m     20\u001b[0m \u001b[43m                              \u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.7\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m     21\u001b[0m \u001b[43m                              \u001b[49m\u001b[43mdiffusion_steps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43membedding_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1.5\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     22\u001b[0m     wavs\u001b[38;5;241m.\u001b[39mappend(wav)\n\u001b[1;32m     23\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSynthesized: \u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
+      "Cell \u001b[0;32mIn[19], line 64\u001b[0m, in \u001b[0;36mLFinference\u001b[0;34m(text, s_prev, ref_s, alpha, beta, t, diffusion_steps, embedding_scale)\u001b[0m\n\u001b[1;32m     61\u001b[0m     asr_new[:, :, \u001b[38;5;241m1\u001b[39m:] \u001b[38;5;241m=\u001b[39m en[:, :, \u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m     62\u001b[0m     en \u001b[38;5;241m=\u001b[39m asr_new\n\u001b[0;32m---> 64\u001b[0m F0_pred, N_pred \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpredictor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mF0Ntrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43men\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43ms\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     66\u001b[0m asr \u001b[38;5;241m=\u001b[39m (t_en \u001b[38;5;241m@\u001b[39m pred_aln_trg\u001b[38;5;241m.\u001b[39munsqueeze(\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m.\u001b[39mto(device))\n\u001b[1;32m     67\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m model_params\u001b[38;5;241m.\u001b[39mdecoder\u001b[38;5;241m.\u001b[39mtype \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhifigan\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n",
+      "File \u001b[0;32m~/disk2/llmvcs/tt/stts_48khz/StyleTTS2_48khz/models.py:1651\u001b[0m, in \u001b[0;36mProsodyPredictor.F0Ntrain\u001b[0;34m(self, x, s)\u001b[0m\n\u001b[1;32m   1647\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mF0Ntrain\u001b[39m(\u001b[38;5;28mself\u001b[39m, x, s):\n\u001b[0;32m-> 1651\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshared\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtranspose\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1652\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprepare_projection(x)\n\u001b[1;32m   1655\u001b[0m     F0 \u001b[38;5;241m=\u001b[39m x\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m)\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/torch/nn/modules/module.py:1532\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1530\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1531\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1532\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/torch/nn/modules/module.py:1541\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1536\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1537\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1538\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1539\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1540\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1541\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1543\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1544\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/xlstm/xlstm_block_stack.py:120\u001b[0m, in \u001b[0;36mxLSTMBlockStack.forward\u001b[0;34m(self, x, **kwargs)\u001b[0m\n\u001b[1;32m    117\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x: torch\u001b[38;5;241m.\u001b[39mTensor, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m torch\u001b[38;5;241m.\u001b[39mTensor:\n\u001b[1;32m    119\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m block \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mblocks:\n\u001b[0;32m--> 120\u001b[0m         x \u001b[38;5;241m=\u001b[39m \u001b[43mblock\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    122\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpost_blocks_norm(x)\n\u001b[1;32m    124\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m x\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/torch/nn/modules/module.py:1532\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1530\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1531\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1532\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/torch/nn/modules/module.py:1541\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1536\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1537\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1538\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1539\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1540\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1541\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1543\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1544\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/xlstm/blocks/xlstm_block.py:77\u001b[0m, in \u001b[0;36mxLSTMBlock.forward\u001b[0;34m(self, x, **kwargs)\u001b[0m\n\u001b[1;32m     76\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x: torch\u001b[38;5;241m.\u001b[39mTensor, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m torch\u001b[38;5;241m.\u001b[39mTensor:\n\u001b[0;32m---> 77\u001b[0m     x \u001b[38;5;241m=\u001b[39m x \u001b[38;5;241m+\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mxlstm\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mxlstm_norm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     78\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mffn \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     79\u001b[0m         x \u001b[38;5;241m=\u001b[39m x \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mffn(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mffn_norm(x), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/torch/nn/modules/module.py:1532\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1530\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1531\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1532\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/torch/nn/modules/module.py:1541\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1536\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1537\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1538\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1539\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1540\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1541\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1543\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1544\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/xlstm/blocks/mlstm/layer.py:116\u001b[0m, in \u001b[0;36mmLSTMLayer.forward\u001b[0;34m(self, x, **kwargs)\u001b[0m\n\u001b[1;32m    113\u001b[0m k \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mk_proj(x_mlstm_conv_act)\n\u001b[1;32m    114\u001b[0m v \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mv_proj(x_mlstm)\n\u001b[0;32m--> 116\u001b[0m h_tilde_state \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmlstm_cell\u001b[49m\u001b[43m(\u001b[49m\u001b[43mq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mq\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    118\u001b[0m h_tilde_state_skip \u001b[38;5;241m=\u001b[39m h_tilde_state \u001b[38;5;241m+\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlearnable_skip \u001b[38;5;241m*\u001b[39m x_mlstm_conv_act)\n\u001b[1;32m    120\u001b[0m \u001b[38;5;66;03m# output / z branch\u001b[39;00m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/torch/nn/modules/module.py:1532\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1530\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1531\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1532\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/torch/nn/modules/module.py:1541\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1536\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1537\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1538\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1539\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1540\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1541\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1543\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1544\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/xlstm/blocks/mlstm/cell.py:61\u001b[0m, in \u001b[0;36mmLSTMCell.forward\u001b[0;34m(self, q, k, v, **kwargs)\u001b[0m\n\u001b[1;32m     58\u001b[0m fgate_preact \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfgate(if_gate_input)  \u001b[38;5;66;03m# (B, S, NH)\u001b[39;00m\n\u001b[1;32m     59\u001b[0m fgate_preact \u001b[38;5;241m=\u001b[39m fgate_preact\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m)\u001b[38;5;241m.\u001b[39munsqueeze(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)  \u001b[38;5;66;03m# (B, NH, S, 1)#\u001b[39;00m\n\u001b[0;32m---> 61\u001b[0m h_state \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackend_fn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     62\u001b[0m \u001b[43m    \u001b[49m\u001b[43mqueries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     63\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkeys\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     64\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalues\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mv\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     65\u001b[0m \u001b[43m    \u001b[49m\u001b[43migate_preact\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43migate_preact\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     66\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfgate_preact\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfgate_preact\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     67\u001b[0m \u001b[43m    \u001b[49m\u001b[43mlower_triangular_matrix\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcausal_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     68\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# (B, NH, S, DH)\u001b[39;00m\n\u001b[1;32m     70\u001b[0m h_state_norm \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutnorm(h_state)  \u001b[38;5;66;03m# (B, NH, S, DH)\u001b[39;00m\n\u001b[1;32m     71\u001b[0m h_state_norm \u001b[38;5;241m=\u001b[39m h_state_norm\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\u001b[38;5;241m.\u001b[39mreshape(B, S, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)  \u001b[38;5;66;03m# (B, NH, S, DH) -> (B, S, NH, DH) -> (B, S, H)\u001b[39;00m\n",
+      "File \u001b[0;32m~/disk2/micromamba/envs/sttszs/lib/python3.11/site-packages/xlstm/blocks/mlstm/backends.py:64\u001b[0m, in \u001b[0;36mparallel_stabilized_simple\u001b[0;34m(queries, keys, values, igate_preact, fgate_preact, lower_triangular_matrix, stabilize_rowwise, eps, **kwargs)\u001b[0m\n\u001b[1;32m     61\u001b[0m _log_fg_matrix \u001b[38;5;241m=\u001b[39m rep_log_fgates_cumsum \u001b[38;5;241m-\u001b[39m rep_log_fgates_cumsum\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)  \u001b[38;5;66;03m# (B, NH, S+1, S+1)\u001b[39;00m\n\u001b[1;32m     62\u001b[0m \u001b[38;5;66;03m# Causal masking & selection of the correct submatrix, such that forgetgate at timestep t is not applied\u001b[39;00m\n\u001b[1;32m     63\u001b[0m \u001b[38;5;66;03m# to the input at timestep t\u001b[39;00m\n\u001b[0;32m---> 64\u001b[0m log_fg_matrix \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwhere\u001b[49m\u001b[43m(\u001b[49m\u001b[43mltr\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_log_fg_matrix\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;28;43mfloat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43minf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# (B, NH, S, S)\u001b[39;00m\n\u001b[1;32m     66\u001b[0m \u001b[38;5;66;03m# gate decay matrix D (combination of forget gate and input gate)\u001b[39;00m\n\u001b[1;32m     67\u001b[0m log_D_matrix \u001b[38;5;241m=\u001b[39m log_fg_matrix \u001b[38;5;241m+\u001b[39m igate_preact\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)  \u001b[38;5;66;03m# (B, NH, S, S)\u001b[39;00m\n",
+      "\u001b[0;31mRuntimeError\u001b[0m: The size of tensor a (512) must match the size of tensor b (531) at non-singleton dimension 3"
+     ]
+    }
+   ],
+   "source": [
+    "# unseen speaker\n",
+    "passage = '''ohoɕisama, doko kaɽa kita no? kiʔto, oːkina ɯtɕɯɯ no jɯme o miterɯɴ da ne. sono jɯme wa, wataɕitatɕi no kokoɽo ni mo todokɯ joɯ na, totemo fɯkai jɯme naɴ daɽoɯ ne. ohoɕisama ga çikarɯ jorɯ wa, wataɕi mo sono jɯme o mite, aɕita no boɯkeɴ o soɯzoɯ sɯrɯɴ da. dakaɽa, ohoɕisama, zɯʔto iʔɕo ni ite ne.'''\n",
+    "# reference_dicts = {}\n",
+    "# reference_dicts['696_92939'] = \"/home/austin/disk1/stts-zs_cleaning/data/moe_soshy/Japanese/imas_split/Syuuko/Syuuko_Events_and_Card/Event/saite_jewel/saite_jewel_chunk90.wav\"\n",
+    "# reference_dicts['1789_142896'] = \"/home/austin/disk1/stts-zs_cleaning/data/moe_soshy/Japanese/imas_split/Kanade/Kanade_Events_and_Card/Kanade_Events/KanLipps/Kanade_lipps_02/Kanade_lipps_02_chunk9.wav\"\n",
+    "path = \"/home/austin/disk1/stts-zs_cleaning/data/moe_soshy/Japanese/sakura_moyu/01/01001290.wav\"\n",
+    "s_ref = compute_style(path)\n",
+    "sentences = passage.split('.') # simple split by comma\n",
+    "wavs = []\n",
+    "s_prev = None\n",
+    "for text in sentences:\n",
+    "    if text.strip() == \"\": continue\n",
+    "    text += ',' # add it back\n",
+    "    \n",
+    "    wav, s_prev = LFinference(text, \n",
+    "                              s_prev, \n",
+    "                              s_ref, \n",
+    "                              alpha = 0.1, \n",
+    "                              beta = 0.3,  # make it more suitable for the text\n",
+    "                              t = 0.7, \n",
+    "                              diffusion_steps=10, embedding_scale=1.5)\n",
+    "    wavs.append(wav)\n",
+    "print('Synthesized: ')\n",
+    "display(ipd.Audio(np.concatenate(wavs), rate=48000, normalize=False))\n",
+    "print('Reference: ')\n",
+    "display(ipd.Audio(path, rate=48000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7517b657",
+   "metadata": {},
+   "source": [
+    "### Style Transfer\n",
+    "\n",
+    "The following section demostrates the style transfer capacity for unseen speakers in [Section 6](https://styletts2.github.io/#emo) of the demo page. For this, we set `alpha=0.5, beta = 0.9` for the most pronounced effects (mostly using the sampled style). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed95d0f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def STinference(text, ref_s, ref_text, alpha = 0.3, beta = 0.7, diffusion_steps=5, embedding_scale=1):\n",
+    "    text = text.strip()\n",
+    "    ps = global_phonemizer.phonemize([text])\n",
+    "    ps = word_tokenize(ps[0])\n",
+    "    ps = ' '.join(ps)\n",
+    "\n",
+    "    tokens = textclenaer(ps)\n",
+    "    tokens.insert(0, 0)\n",
+    "    tokens = torch.LongTensor(tokens).to(device).unsqueeze(0)\n",
+    "    \n",
+    "    ref_text = ref_text.strip()\n",
+    "    ps = global_phonemizer.phonemize([ref_text])\n",
+    "    ps = word_tokenize(ps[0])\n",
+    "    ps = ' '.join(ps)\n",
+    "\n",
+    "    ref_tokens = textclenaer(ps)\n",
+    "    ref_tokens.insert(0, 0)\n",
+    "    ref_tokens = torch.LongTensor(ref_tokens).to(device).unsqueeze(0)\n",
+    "    \n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)\n",
+    "        text_mask = length_to_mask(input_lengths).to(device)\n",
+    "\n",
+    "        t_en = model.text_encoder(tokens, input_lengths, text_mask)\n",
+    "        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())\n",
+    "        d_en = model.bert_encoder(bert_dur).transpose(-1, -2) \n",
+    "        \n",
+    "        ref_input_lengths = torch.LongTensor([ref_tokens.shape[-1]]).to(device)\n",
+    "        ref_text_mask = length_to_mask(ref_input_lengths).to(device)\n",
+    "        ref_bert_dur = model.bert(ref_tokens, attention_mask=(~ref_text_mask).int())\n",
+    "        s_pred = sampler(noise = torch.randn((1, 256)).unsqueeze(1).to(device), \n",
+    "                                          embedding=bert_dur,\n",
+    "                                          embedding_scale=embedding_scale,\n",
+    "                                            features=ref_s, # reference from the same speaker as the embedding\n",
+    "                                             num_steps=diffusion_steps).squeeze(1)\n",
+    "\n",
+    "\n",
+    "        s = s_pred[:, 128:]\n",
+    "        ref = s_pred[:, :128]\n",
+    "\n",
+    "        ref = alpha * ref + (1 - alpha)  * ref_s[:, :128]\n",
+    "        s = beta * s + (1 - beta)  * ref_s[:, 128:]\n",
+    "\n",
+    "        d = model.predictor.text_encoder(d_en, \n",
+    "                                         s, input_lengths, text_mask)\n",
+    "\n",
+    "        x, _ = model.predictor.lstm(d)\n",
+    "        duration = model.predictor.duration_proj(x)\n",
+    "\n",
+    "        duration = torch.sigmoid(duration).sum(axis=-1)\n",
+    "        pred_dur = torch.round(duration.squeeze()).clamp(min=1)\n",
+    "\n",
+    "\n",
+    "        pred_aln_trg = torch.zeros(input_lengths, int(pred_dur.sum().data))\n",
+    "        c_frame = 0\n",
+    "        for i in range(pred_aln_trg.size(0)):\n",
+    "            pred_aln_trg[i, c_frame:c_frame + int(pred_dur[i].data)] = 1\n",
+    "            c_frame += int(pred_dur[i].data)\n",
+    "\n",
+    "        # encode prosody\n",
+    "        en = (d.transpose(-1, -2) @ pred_aln_trg.unsqueeze(0).to(device))\n",
+    "        if model_params.decoder.type == \"hifigan\":\n",
+    "            asr_new = torch.zeros_like(en)\n",
+    "            asr_new[:, :, 0] = en[:, :, 0]\n",
+    "            asr_new[:, :, 1:] = en[:, :, 0:-1]\n",
+    "            en = asr_new\n",
+    "\n",
+    "        F0_pred, N_pred = model.predictor.F0Ntrain(en, s)\n",
+    "\n",
+    "        asr = (t_en @ pred_aln_trg.unsqueeze(0).to(device))\n",
+    "        if model_params.decoder.type == \"hifigan\":\n",
+    "            asr_new = torch.zeros_like(asr)\n",
+    "            asr_new[:, :, 0] = asr[:, :, 0]\n",
+    "            asr_new[:, :, 1:] = asr[:, :, 0:-1]\n",
+    "            asr = asr_new\n",
+    "\n",
+    "        out = model.decoder(asr, \n",
+    "                                F0_pred, N_pred, ref.squeeze().unsqueeze(0))\n",
+    "    \n",
+    "        \n",
+    "    return out.squeeze().cpu().numpy()[..., :-50] # weird pulse at the end of the model, need to be fixed later"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ec3f0da4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# reference texts to sample styles\n",
+    "\n",
+    "ref_texts = {}\n",
+    "ref_texts['Happy'] = \"We are happy to invite you to join us on a journey to the past, where we will visit the most amazing monuments ever built by human hands.\"\n",
+    "ref_texts['Sad'] = \"I am sorry to say that we have suffered a severe setback in our efforts to restore prosperity and confidence.\"\n",
+    "ref_texts['Angry'] = \"The field of astronomy is a joke! Its theories are based on flawed observations and biased interpretations!\"\n",
+    "ref_texts['Surprised'] = \"I can't believe it! You mean to tell me that you have discovered a new species of bacteria in this pond?\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d0a3825",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+    "s_ref = compute_style(path)\n",
+    "\n",
+    "text = \"Yea, his honourable worship is within, but he hath a godly minister or two with him, and likewise a leech.\"\n",
+    "for k,v in ref_texts.items():\n",
+    "    wav = STinference(text, s_ref, v, diffusion_steps=10, alpha=0.5, beta=0.9, embedding_scale=1.5)\n",
+    "    print(k + \": \")\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6750aed9",
+   "metadata": {},
+   "source": [
+    "### Speech diversity\n",
+    "\n",
+    "This section reproduces samples in [Section 7](https://styletts2.github.io/#var) of the demo page. \n",
+    "\n",
+    "`alpha` and `beta` determine the diversity of the synthesized speech. There are two extreme cases:\n",
+    "- If `alpha = 1` and `beta = 1`, the synthesized speech sounds the most dissimilar to the reference speaker, but it is also the most diverse (each time you synthesize a speech it will be totally different). \n",
+    "- If `alpha = 0` and `beta = 0`, the synthesized speech sounds the most siimlar to the reference speaker, but it is deterministic (i.e., the sampled style is not used for speech synthesis). \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6ae0aa5",
+   "metadata": {},
+   "source": [
+    "#### Default setting (`alpha = 0.3, beta=0.7`)\n",
+    "This setting uses 70% of the reference timbre and 30% of the reference prosody and use the diffusion model to sample them based on the text. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36dc0148",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# unseen speaker\n",
+    "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+    "ref_s = compute_style(path)\n",
+    "\n",
+    "text = \"How much variation is there?\"\n",
+    "for _ in range(5):\n",
+    "    wav = inference(text, ref_s, diffusion_steps=10, alpha=0.3, beta=0.7, embedding_scale=1)\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf9ef421",
+   "metadata": {},
+   "source": [
+    "#### Less diverse setting (`alpha = 0.1, beta=0.3`)\n",
+    "This setting uses 90% of the reference timbre and 70% of the reference prosody. This makes it more similar to the reference speaker at cost of less diverse samples. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ba406bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# unseen speaker\n",
+    "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+    "ref_s = compute_style(path)\n",
+    "\n",
+    "text = \"How much variation is there?\"\n",
+    "for _ in range(5):\n",
+    "    wav = inference(text, ref_s, diffusion_steps=10, alpha=0.1, beta=0.3, embedding_scale=1)\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a38fe464",
+   "metadata": {},
+   "source": [
+    "#### More diverse setting (`alpha = 0.5, beta=0.95`)\n",
+    "This setting uses 50% of the reference timbre and 5% of the reference prosody (so it uses 100% of the sampled prosody, which makes it more diverse), but this makes it more dissimilar to the reference speaker.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f25bf94",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# unseen speaker\n",
+    "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+    "ref_s = compute_style(path)\n",
+    "\n",
+    "text = \"How much variation is there?\"\n",
+    "for _ in range(5):\n",
+    "    wav = inference(text, ref_s, diffusion_steps=10, alpha=0.5, beta=0.95, embedding_scale=1)\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21c3a071",
+   "metadata": {},
+   "source": [
+    "#### Extreme setting (`alpha = 1, beta=1`)\n",
+    "This setting uses 0% of the reference timbre and prosody and use the diffusion model to sample the entire style. This makes the speaker very dissimilar to the reference speaker. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fff8bab1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# unseen speaker\n",
+    "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+    "ref_s = compute_style(path)\n",
+    "\n",
+    "text = \"How much variation is there?\"\n",
+    "for _ in range(5):\n",
+    "    wav = inference(text, ref_s, diffusion_steps=10, alpha=1, beta=1, embedding_scale=1)\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8741e5a",
+   "metadata": {},
+   "source": [
+    "#### No variation (`alpha = 0, beta=0`)\n",
+    "This setting uses 0% of the reference timbre and prosody and use the diffusion model to sample the entire style. This makes the speaker very similar to the reference speaker, but there is no variation. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e55dd281",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# unseen speaker\n",
+    "path = \"Demo/reference_audio/1221-135767-0014.wav\"\n",
+    "ref_s = compute_style(path)\n",
+    "\n",
+    "text = \"How much variation is there?\"\n",
+    "for _ in range(5):\n",
+    "    wav = inference(text, ref_s, diffusion_steps=10, alpha=0, beta=0, embedding_scale=1)\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5e86423",
+   "metadata": {},
+   "source": [
+    "### Extra fun!\n",
+    "\n",
+    "Here we clone some of the authors' voice of the StyleTTS 2 papers with a few seconds of the recording in the wild. None of the voices is in the dataset and all authors agreed to have their voices cloned here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6f558314",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = ''' StyleTTS 2 is a text to speech model that leverages style diffusion and adversarial training with large speech language models to achieve human level text to speech synthesis. '''"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "caa5747c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reference_dicts = {}\n",
+    "reference_dicts['Yinghao'] = \"Demo/reference_audio/Yinghao.wav\"\n",
+    "reference_dicts['Gavin'] = \"Demo/reference_audio/Gavin.wav\"\n",
+    "reference_dicts['Vinay'] = \"Demo/reference_audio/Vinay.wav\"\n",
+    "reference_dicts['Nima'] = \"Demo/reference_audio/Nima.wav\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44a4cea1",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "start = time.time()\n",
+    "noise = torch.randn(1,1,256).to(device)\n",
+    "for k, path in reference_dicts.items():\n",
+    "    ref_s = compute_style(path)\n",
+    "    \n",
+    "    wav = inference(text, ref_s, alpha=0.1, beta=0.5, diffusion_steps=5, embedding_scale=1)\n",
+    "    rtf = (time.time() - start) / (len(wav) / 24000)\n",
+    "    print('Speaker: ' + k)\n",
+    "    import IPython.display as ipd\n",
+    "    print('Synthesized:')\n",
+    "    display(ipd.Audio(wav, rate=24000, normalize=False))\n",
+    "    print('Reference:')\n",
+    "    display(ipd.Audio(path, rate=24000, normalize=False))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.11.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

stts_48khz/StyleTTS2_48khz/LICENSE

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade/config_kanade.yml

@@ -0,0 +1,124 @@
+log_dir: "Models/Style_Kanade"
+first_stage_path: "/home/austin/disk2/llmvcs/tt/stylekan/Models/Style_Kanade/epoch_1st_00013.pth"
+save_freq: 1
+log_interval: 10
+device: "cuda"
+epochs_1st: 25 # number of epochs for first stage training (pre-training)
+epochs_2nd: 15 # number of peochs for second stage training (joint training)
+batch_size: 24
+max_len: 560 # maximum number of frames
+pretrained_model: "/home/austin/disk2/llmvcs/tt/stylekan/Models/Style_Kanade/succ_epoch_2nd_00002.pth"
+second_stage_load_pretrained: true # set to true if the pre-trained model is for 2nd stage
+load_only_params: false # set to true if do not want to load epoch numbers and optimizer parameters
+
+# F0_path: "/home/ubuntu/STTS_48khz/StyleTTS2-48khz/Utils/JDC/bst_rmvpe_48k.t7"
+# ASR_config: "Utils/ASR/config.yml"
+# ASR_path: "/home/ubuntu/STTS_48khz/StyleTTS2-48khz/Utils/ASR/epoch_00050_48K.pth"
+
+
+
+F0_path: "/home/austin/disk2/llmvcs/tt/stylekan/Utils/JDC/bst.t7"
+ASR_config: "/home/austin/disk2/llmvcs/tt/stylekan/Utils/ASR/config.yml"
+ASR_path: "/home/austin/disk2/llmvcs/tt/stylekan/Utils/ASR/bst_00080.pth"
+
+PLBERT_dir: 'Utils/PLBERT/'
+
+data_params:
+  train_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/filtered_train_list.csv"
+  val_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/mg_valid.txt"
+  root_path: ""
+  OOD_data: "/home/austin/disk2/llmvcs/tt/stylekan/Data/OOD_LargeScale_.csv"
+  min_length: 50 # sample until texts with this size are obtained for OOD texts
+
+
+preprocess_params:
+  sr: 24000
+  spect_params:
+    n_fft: 2048
+    win_length: 1200
+    hop_length: 300
+
+model_params:
+  multispeaker: true
+
+  dim_in: 64 
+  hidden_dim: 512
+  max_conv_dim: 512
+  n_layer: 3
+  n_mels: 80
+
+  n_token: 178 # number of phoneme tokens
+  max_dur: 50 # maximum duration of a single phoneme
+  style_dim: 128 # style vector size
+  
+  dropout: 0.2
+
+  decoder: 
+    type: 'istftnet' # either hifigan or istftnet
+    resblock_kernel_sizes: [3,7,11]
+    upsample_rates :  [10, 6]
+    upsample_initial_channel: 512
+    resblock_dilation_sizes: [[1,3,5], [1,3,5], [1,3,5]]
+    upsample_kernel_sizes: [20, 12]
+    gen_istft_n_fft: 20
+    gen_istft_hop_size: 5
+
+
+      
+  # speech language model config
+  slm:
+      model: 'Respair/Whisper_Large_v2_Encoder_Block' # The model itself is hardcoded, change it through -> losses.py
+      sr: 16000 # sampling rate of SLM
+      hidden: 1280 # hidden size of SLM
+      nlayers: 33 # number of layers of SLM
+      initial_channel: 64 # initial channels of SLM discriminator head
+  
+  # style diffusion model config
+  diffusion:
+    embedding_mask_proba: 0.1
+    # transformer config
+    transformer:
+      num_layers: 3
+      num_heads: 8
+      head_features: 64
+      multiplier: 2
+
+    # diffusion distribution config
+    dist:
+      sigma_data: 0.2 # placeholder for estimate_sigma_data set to false
+      estimate_sigma_data: true # estimate sigma_data from the current batch if set to true
+      mean: -3.0
+      std: 1.0
+  
+loss_params:
+    lambda_mel: 10. # mel reconstruction loss
+    lambda_gen: 1. # generator loss
+    lambda_slm: 1. # slm feature matching loss
+    
+    lambda_mono: 1. # monotonic alignment loss (1st stage, TMA)
+    lambda_s2s: 1. # sequence-to-sequence loss (1st stage, TMA)
+    TMA_epoch: 9 # TMA starting epoch (1st stage)
+
+    lambda_F0: 1. # F0 reconstruction loss (2nd stage)
+    lambda_norm: 1. # norm reconstruction loss (2nd stage)
+    lambda_dur: 1. # duration loss (2nd stage)
+    lambda_ce: 20. # duration predictor probability output CE loss (2nd stage)
+    lambda_sty: 1. # style reconstruction loss (2nd stage)
+    lambda_diff: 1. # score matching loss (2nd stage)
+    
+    diff_epoch: 2 # style diffusion starting epoch (2nd stage)
+    joint_epoch: 6 # joint training starting epoch (2nd stage)
+
+optimizer_params:
+  lr: 0.0001 # general learning rate
+  bert_lr: 0.00001 # learning rate for PLBERT
+  ft_lr: 0.00001 # learning rate for acoustic modules
+  
+slmadv_params:
+  min_len: 400 # minimum length of samples
+  max_len: 500 # maximum length of samples
+  batch_percentage: 0.5 # to prevent out of memory, only use half of the original batch size
+  iter: 20 # update the discriminator every this iterations of generator update
+  thresh: 5 # gradient norm above which the gradient is scaled
+  scale: 0.01 # gradient scaling factor for predictors from SLM discriminators
+  sig: 1.5 # sigma for differentiable duration modeling

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade/tensorboard/events.out.tfevents.1728511195.node-1.1421403.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/2nd_phase_165885.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d88946c2ad6951102438d4377a0de03e8e932cdb921a96491c8302d2ccee062
+size 2634096094

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/2nd_phase_65527.pth

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/2nd_phase_last.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:837323ec6d6a23319c3e80c169595a13010a4ed783015c4b727e7e26bae2928e
+size 2056545874

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/DP_epoch_2nd_00004.pth

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/NO_SLM_epoch_2nd_00009.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:845b43f224edc0ad3a57d3a5bfaa2c293a28cbf3caa8c80a7bb9fa1bb08d0470
+size 2056549032

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/NO_SLM_epoch_2nd_00010.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79aa6cd825f51004625f7ba8806da65c6fcc95484dacfb7f862982b81b4a0308
+size 2056549032

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728462180.node-1.1003680.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728462294.node-1.1004682.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728462472.node-1.1005638.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:851ea96b4c47b93d43be6f80acff6230535e6bfbe99c36667589b124441c38cb
+size 2560

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728462951.node-1.1007312.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f59ad7609f349f7396199de23168c05c873f722309d0b0f17830b46c430bb07
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728463094.node-1.1008219.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5df01fc68dfb3b019689711260ed2a9321af4c95fdddbb2a96229d5978396625
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728463336.node-1.1010823.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83d76a0888871f133e42fc11450319a6561a6495a789b7ae87d47ecd65b4f97a
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728463388.node-1.1011249.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2545722cbdece2a028da4a0a5b270adc17334aab1fbae91501816d21a7464ba3
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728463515.node-1.1013548.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728463957.node-1.1016238.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:487baec629ff2b35ef5a5dee52804320ff18926173581103b1e8707b68bd0065
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728464009.node-1.1016738.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31294dbd8a51f7d1bcc38516e988fb01106b7e3a95b221746b2ef8265e6f2041
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728464233.node-1.1019060.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90c1c0bf4b9a6b7df5234a63b7a053f3566cdc36ff8f767eb38f0385df5adc12
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728464354.node-1.1019744.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728464586.node-1.1020751.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728464707.node-1.1021516.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728464831.node-1.1022361.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728464900.node-1.1022907.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728465001.node-1.1025007.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728465067.node-1.1026980.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5def090452ecadea26774681015c59eb6156b32b32c18043ee1c9f5a463649a0
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728465130.node-1.1028957.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36986ddd50b5ac71411f0d8c23dd32b29f955e1eb687b626db75c7db9d454b58
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728465526.node-1.1031919.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728465719.node-1.1034258.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18a3b4ae4ac7f2b657745d442f650035264c9bd73bcc6946c55c3ad68736b31a
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728465773.node-1.1034708.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728465956.node-1.1037028.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:142f9797269c386eae3311cb4c463edbe4db04085b3211ab6cd2e25774125efd
+size 4414

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728466151.node-1.1039623.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a6ec80c55b1ac401c4154cec4959b4a6b580413479e9c39ad6527889bbea685
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728466402.node-1.1042081.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2212f2ad84e8300d7c193b214dae7021fba8336b9e5a8bed28a95d63e67de435
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728466494.node-1.1044247.0

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

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728466592.node-1.1046287.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28504f4d924fd17bd6c5ad2a5622bf78a16dc81a71ad9cb9832a9c8b6ec72e3b
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728466648.node-1.1048190.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29375abbff4881e86b811dccec6d07e7bb4c45395e9be31210d760248689cb95
+size 88

stts_48khz/StyleTTS2_48khz/Models/Style_Kanade_48khz/StyleTTS2-Second-Stage/events.out.tfevents.1728466722.node-1.1050256.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73a0a5169b6144f9da5dad9b9cde28cdb7f582da193f133b540c778d9959793c
+size 88