Tacotron2_synthesis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.8.5"
    },
    "colab": {
      "name": "Tacotron2_synthesis.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "puvcpwPvO8Jb"
      },
      "source": [
        "# Tacotron 2 Synthesis notebook for your model\n",
        "\n",
        "## ***Notebook organized by Justin John***\n",
        "\n",
        "### Check if your session has a GPU in it (Runtime -> Change runtime type)\n",
        "\n",
        "#  \n",
        "\n",
        "5/15/2021 - Fixed model not loading error.\n",
        "\n",
        "5/10/2021 - Cleaned up.\n",
        "\n",
        "5/3/2021 - Made a bit more compact.\n",
        "\n",
        "4/25/2021 - Fixed imports and synthesize, finalized using local file option.\n",
        "\n",
        "4/24/2021 - Added a local checkpoint option\n",
        "\n",
        "4/23/2021 - Fixed pre-trained waveglow file by uploading it into mega.nz\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M58tjujYBN1E",
        "cellView": "form"
      },
      "source": [
        "# @markdown # Setting up dependencies, run this cell once. \n",
        "%tensorflow_version 1.x\n",
        "%cd /content/\n",
        "!apt-get install pv\n",
        "!apt-get install jq\n",
        "!wget https://raw.githubusercontent.com/tonikelope/megadown/master/megadown -O megadown.sh\n",
        "!chmod 755 megadown.sh\n",
        "\n",
        "import os\n",
        "from os.path import exists, join, basename, splitext\n",
        "!pip install gdown\n",
        "git_repo_url = 'https://github.com/NVIDIA/tacotron2.git'\n",
        "project_name = splitext(basename(git_repo_url))[0]\n",
        "if not exists(project_name):\n",
        "  # clone and install\n",
        "  !git clone -q --recursive {git_repo_url}\n",
        "  !cd {project_name}/waveglow && git checkout 2fd4e63\n",
        "  !pip install -q librosa unidecode\n",
        "  \n",
        "import sys\n",
        "sys.path.append(join(project_name, 'waveglow/'))\n",
        "sys.path.append(project_name)\n",
        "import time\n",
        "import matplotlib\n",
        "import matplotlib.pylab as plt\n",
        "import gdown\n",
        "d = 'https://drive.google.com/uc?id='"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "DrXqDkJEXMb5"
      },
      "source": [
        "#@title Initialize Tacotron and Waveglow, also run this cell once.\n",
        "%matplotlib inline\n",
        "import IPython.display as ipd\n",
        "import numpy as np\n",
        "import torch\n",
        "\n",
        "from hparams import create_hparams\n",
        "from model import Tacotron2\n",
        "from layers import TacotronSTFT\n",
        "from audio_processing import griffin_lim\n",
        "from text import text_to_sequence\n",
        "from denoiser import Denoiser\n",
        "\n",
        "waveglow_pretrained_model = '/content/waveglow.pt'\n",
        "\n",
        "if not exists(waveglow_pretrained_model):\n",
        "  print(\"Installing waveglow pretrained model, may take a bit! (This will only run once)\")\n",
        "  #os.system(\"/content/megadown.sh https://mega.nz/#!zO5H1KrS!kNwIsmb8EklYHCzVW9-cau-YM_UySthWv88khK4Pydw --o waveglow.pt\")\n",
        "  !/content/megadown.sh https://mega.nz/#!zO5H1KrS!kNwIsmb8EklYHCzVW9-cau-YM_UySthWv88khK4Pydw --o waveglow.pt\n",
        "  print(\"Finished!\")\n",
        "\n",
        "graph_width = 900\n",
        "graph_height = 360\n",
        "def plot_data(data, figsize=(int(graph_width/100), int(graph_height/100))):\n",
        "    %matplotlib inline\n",
        "    fig, axes = plt.subplots(1, len(data), figsize=figsize)\n",
        "    for i in range(len(data)):\n",
        "        axes[i].imshow(data[i], aspect='auto', origin='bottom', \n",
        "                       interpolation='none', cmap='inferno')\n",
        "    fig.canvas.draw()\n",
        "    plt.show()\n",
        "\n",
        "!gdown --id '1IUxCkgRNsoDCLtMZxYXmIePAKgh0m-aZ'\n",
        "thisdict = {}\n",
        "for line in reversed((open('merged.dict.txt', \"r\").read()).splitlines()):\n",
        "    thisdict[(line.split(\" \",1))[0]] = (line.split(\" \",1))[1].strip()\n",
        "def ARPA(text):\n",
        "    out = ''\n",
        "    for word_ in text.split(\" \"):\n",
        "        word=word_; end_chars = ''\n",
        "        while any(elem in word for elem in r\"!?,.;\") and len(word) > 1:\n",
        "            if word[-1] == '!': end_chars = '!' + end_chars; word = word[:-1]\n",
        "            if word[-1] == '?': end_chars = '?' + end_chars; word = word[:-1]\n",
        "            if word[-1] == ',': end_chars = ',' + end_chars; word = word[:-1]\n",
        "            if word[-1] == '.': end_chars = '.' + end_chars; word = word[:-1]\n",
        "            if word[-1] == ';': end_chars = ';' + end_chars; word = word[:-1]\n",
        "            else: break\n",
        "        try: word_arpa = thisdict[word.upper()]\n",
        "        except: word_arpa = ''\n",
        "        if len(word_arpa)!=0: word = \"{\" + str(word_arpa) + \"}\"\n",
        "        out = (out + \" \" + word + end_chars).strip()\n",
        "    if out[-1] != \";\": out = out + \";\"\n",
        "    return out\n",
        "\n",
        "#torch.set_grad_enabled(False)\n",
        "\n",
        "# initialize Tacotron2 with the pretrained model\n",
        "hparams = create_hparams()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9aKHsAgYBTtE",
        "cellView": "form"
      },
      "source": [
        "%cd /content/\n",
        "import os\n",
        "force_download_TT2 = True\n",
        "\n",
        "#@markdown ![tutorial.png](data:image/png;base64,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)\n",
        "\n",
        "#@markdown # Enter your model's google drive ID here:\n",
        "\n",
        "#@markdown Make sure to change restricted to \"Anyone with the link\" or else it won't be able to download.\n",
        "\n",
        "model_ID = \"1IP4tiIfFdy6ePagEmEgrnbRYfHKebpbi\" #@param {type: \"string\"}\n",
        "\n",
        "#@markdown ---\n",
        "\n",
        "#@markdown ### If you are using an uploaded checkpoint instead, check the box and copy the path after uploading it into the files.\n",
        "\n",
        "using_local_file = False #@param {type:\"boolean\"}\n",
        "#@markdown #### Enter the path here:\n",
        "tacotron2_pretrained_model = \"\" #@param {type:\"string\"}\n",
        "\n",
        "#@markdown ---\n",
        "\n",
        "if using_local_file == False: \n",
        "  tacotron2_pretrained_model = \"/content/MLPTTS\"\n",
        "\n",
        "if not exists(tacotron2_pretrained_model) or force_download_TT2 and using_local_file == False:\n",
        "  gdown.download(d+model_ID, tacotron2_pretrained_model, quiet=False); print(\"Tacotron2 Model Downloaded\")\n",
        "elif using_local_file == True:\n",
        "  print(\"Using local file\")\n",
        "\n",
        "checkpoint_path = tacotron2_pretrained_model\n",
        "waveglow_path = \"/content/waveglow.pt\"\n",
        "\n",
        "# Load Tacotron2 (run this cell every time you change the model)\n",
        "hparams.sampling_rate = 22050 # Don't change this\n",
        "hparams.max_decoder_steps = 1000 # How long the audio will be before it cuts off (1000 is about 11 seconds)\n",
        "hparams.gate_threshold = 0.1 # Model must be 90% sure the clip is over before ending generation (the higher this number is, the more likely that the AI will keep generating until it reaches the Max Decoder Steps)\n",
        "model = Tacotron2(hparams)\n",
        "model.load_state_dict(torch.load(tacotron2_pretrained_model)['state_dict'])\n",
        "_ = model.cuda().eval().half()\n",
        "\n",
        "# Load WaveGlow\n",
        "waveglow = torch.load(waveglow_pretrained_model)['model']\n",
        "waveglow.cuda().eval().half()\n",
        "for k in waveglow.convinv:\n",
        "    k.float()\n",
        "denoiser = Denoiser(waveglow)# Load WaveGlow\n",
        "waveglow = torch.load(waveglow_pretrained_model)['model']\n",
        "waveglow.cuda().eval().half()\n",
        "for k in waveglow.convinv:\n",
        "    k.float()\n",
        "denoiser = Denoiser(waveglow)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lsi-G8SzBN1I",
        "cellView": "form"
      },
      "source": [
        "#@markdown # **Synthesis**\n",
        "\n",
        "#@markdown # Enter your desired text here, the graph and audio will show up.\n",
        "\n",
        "text = \"And so he ran across the street to measure the absence of being.\" #@param {type:\"string\"}\n",
        "sigma = 0.8\n",
        "denoise_strength = 0.324\n",
        "\n",
        "#@markdown #### Optional if you want automatic ARPA convertion. \n",
        "\n",
        "raw_input = True #@param {type:\"boolean\"}\n",
        "\n",
        "for i in text.split(\"\\n\"):\n",
        "    if len(i) < 1: continue;\n",
        "    print(i)\n",
        "    if raw_input:\n",
        "        if i[-1] != \";\": i=i+\";\" \n",
        "    else: i = ARPA(i)\n",
        "    print(i)\n",
        "    with torch.no_grad(): # save VRAM by not including gradients\n",
        "        sequence = np.array(text_to_sequence(i, ['english_cleaners']))[None, :]\n",
        "        sequence = torch.autograd.Variable(torch.from_numpy(sequence)).cuda().long()\n",
        "        mel_outputs, mel_outputs_postnet, _, alignments = model.inference(sequence)\n",
        "        plot_data((mel_outputs_postnet.float().data.cpu().numpy()[0],\n",
        "                alignments.float().data.cpu().numpy()[0].T))\n",
        "        audio = waveglow.infer(mel_outputs_postnet, sigma=sigma); print(\"\"); ipd.display(ipd.Audio(audio[0].data.cpu().numpy(), rate=hparams.sampling_rate))"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}