prepare_stages_benchmark.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run this code twice after the stage0 and stage0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training_log/aligntts/stage0/checkpoint_1000\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]='0'\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import sys\n",
    "sys.path.append('waveglow/')\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import IPython.display as ipd\n",
    "import pickle as pkl\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import hparams\n",
    "from torch.utils.data import DataLoader\n",
    "from modules.model import Model\n",
    "from text import text_to_sequence, sequence_to_text\n",
    "from denoiser import Denoiser\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "import librosa\n",
    "from modules.loss import MDNLoss\n",
    "import math\n",
    "from multiprocessing import Pool\n",
    "import numpy as np\n",
    "\n",
    "data_type = 'char'\n",
    "checkpoint_path = f\"training_log/aligntts/stage0/checkpoint_40000\"\n",
    "\n",
    "from glob import glob\n",
    "\n",
    "checkpoint_path = sorted(glob(\"training_log/aligntts/stage0/checkpoint_*\"))[0]\n",
    "\n",
    "print(checkpoint_path)\n",
    "\n",
    "\n",
    "state_dict = {}\n",
    "for k, v in torch.load(checkpoint_path)['state_dict'].items():\n",
    "    state_dict[k[7:]]=v\n",
    "\n",
    "\n",
    "model = Model(hparams).cuda()\n",
    "model.load_state_dict(state_dict)\n",
    "_ = model.cuda().eval()\n",
    "criterion = MDNLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "17e3fa022cc04cc0916ed226d16297dd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=656.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.758989 / 1.367927 = 55.48%\n",
      "IO Time:  0.005540 / 1.367927 =  0.40%\n",
      "DL Time:  0.591276 / 1.367927 = 43.22%\n",
      "torch.Size([1, 170, 857])\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "239ca9b5506d4667a6e390b5b6507ae0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=86.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.590959 / 0.813022 = 72.69%\n",
      "IO Time:  0.005205 / 0.813022 =  0.64%\n",
      "DL Time:  0.213748 / 0.813022 = 26.29%\n",
      "torch.Size([1, 140, 725])\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fc2d69f9b7aa48a5971db851393858cc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=79.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.759542 / 1.017219 = 74.67%\n",
      "IO Time:  0.024682 / 1.017219 =  2.43%\n",
      "DL Time:  0.226169 / 1.017219 = 22.23%\n",
      "torch.Size([1, 137, 807])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "datasets = ['train', 'val', 'test']\n",
    "batch_size=64\n",
    "batch_size = 16\n",
    "\n",
    "start = time.perf_counter()\n",
    "\n",
    "for dataset in datasets:\n",
    "    \n",
    "    with open(f'filelists/ljs_audio_text_{dataset}_filelist.txt', 'r') as f:\n",
    "        lines_raw = [line.split('|') for line in f.read().splitlines()]\n",
    "        lines_list = [ lines_raw[batch_size*i:batch_size*(i+1)] \n",
    "                      for i in range(len(lines_raw)//batch_size+1)]\n",
    "        \n",
    "    for batch in tqdm(lines_list):\n",
    "        \n",
    "        single_loop_start = time.perf_counter()\n",
    "        \n",
    "        file_list, text_list, mel_list = [], [], []\n",
    "        text_lengths, mel_lengths=[], []\n",
    "        \n",
    "        for i in range(len(batch)):\n",
    "            file_name, _, text = batch[i]\n",
    "            file_list.append(file_name)\n",
    "            seq_path = os.path.join('../Dataset/LJSpeech-1.1/preprocessed',\n",
    "                               f'{data_type}_seq')\n",
    "            mel_path = os.path.join('../Dataset/LJSpeech-1.1/preprocessed',\n",
    "                               'melspectrogram')\n",
    "            try:\n",
    "                seq = torch.from_numpy(np.load(f'{seq_path}/{file_name}_sequence.npy'))\n",
    "            except FileNotFoundError:\n",
    "                with open(f'{seq_path}/{file_name}_sequence.pkl', 'rb') as f:\n",
    "                    seq = pkl.load(f)\n",
    "            \n",
    "            try:\n",
    "                mel = torch.from_numpy(np.load(f'{mel_path}/{file_name}_melspectrogram.npy'))\n",
    "            except FileNotFoundError:\n",
    "                with open(f'{mel_path}/{file_name}_melspectrogram.pkl', 'rb') as f:\n",
    "                    mel = pkl.load(f)\n",
    "            \n",
    "            text_list.append(seq)\n",
    "            mel_list.append(mel)\n",
    "            text_lengths.append(seq.size(0))\n",
    "            mel_lengths.append(mel.size(1))\n",
    "            \n",
    "        io_time = time.perf_counter()\n",
    "            \n",
    "        text_lengths = torch.LongTensor(text_lengths)\n",
    "        mel_lengths = torch.LongTensor(mel_lengths)\n",
    "        text_padded = torch.zeros(len(batch), text_lengths.max().item(), dtype=torch.long)\n",
    "        mel_padded = torch.zeros(len(batch), hparams.n_mel_channels, mel_lengths.max().item())\n",
    "        \n",
    "        for j in range(len(batch)):\n",
    "            text_padded[j, :text_list[j].size(0)] = text_list[j]\n",
    "            mel_padded[j, :, :mel_list[j].size(1)] = mel_list[j]\n",
    "        \n",
    "        text_padded = text_padded.cuda()\n",
    "        mel_padded = mel_padded.cuda()\n",
    "        text_lengths = text_lengths.cuda()\n",
    "        mel_lengths = mel_lengths.cuda()\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            \n",
    "            model_start = time.perf_counter()\n",
    "            \n",
    "            encoder_input = model.Prenet(text_padded)\n",
    "            hidden_states, _ = model.FFT_lower(encoder_input, text_lengths)\n",
    "            mu_sigma = model.get_mu_sigma(hidden_states)\n",
    "            _, log_prob_matrix = criterion(mu_sigma, mel_padded, text_lengths, mel_lengths)\n",
    "            \n",
    "            viterbi_start = time.perf_counter()\n",
    "\n",
    "            align = model.viterbi(log_prob_matrix, text_lengths, mel_lengths).to(torch.long)\n",
    "            alignments = list(torch.split(align,1))\n",
    "            \n",
    "            viterbi_end = time.perf_counter()\n",
    "        \n",
    "        print('VT Time: ', end=' ')\n",
    "        print(f'{viterbi_end - viterbi_start:.6f} / {viterbi_end - single_loop_start:.6f} = ' +\n",
    "             f'{(viterbi_end - viterbi_start) / (viterbi_end - single_loop_start) * 100:5.2f}%')\n",
    "        \n",
    "        print('IO Time: ', end=' ')\n",
    "        print(f'{io_time - single_loop_start:.6f} / {viterbi_end - single_loop_start:.6f} = ' +\n",
    "             f'{(io_time - single_loop_start) / (viterbi_end - single_loop_start) * 100:5.2f}%')\n",
    "        \n",
    "        print('DL Time: ', end=' ')\n",
    "        print(f'{viterbi_start - model_start:.6f} / {viterbi_end - single_loop_start:.6f} = ' +\n",
    "             f'{(viterbi_start - model_start) / (viterbi_end - single_loop_start) * 100:5.2f}%')\n",
    "        \n",
    "        print(alignments[0].shape)\n",
    "        \n",
    "        break\n",
    "        \n",
    "        \n",
    "        \n",
    "       \n",
    "#         for j, (l, t) in enumerate(zip(text_lengths, mel_lengths)):\n",
    "#             alignments[j] = alignments[j][0, :l.item(), :t.item()].sum(dim=-1)\n",
    "#             np.save(f'../Dataset/LJSpeech-1.1/preprocessed/alignments/{file_list[j]}_alignment.npy',\n",
    "#                     alignments[j].detach().cpu().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([16, 137, 807])\n"
     ]
    }
   ],
   "source": [
    "print(log_prob_matrix.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f33827a68b0>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(log_prob_matrix[0, :, :].cpu())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f3393d98460>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x1296 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(18, 18))\n",
    "plt.imshow(alignments[0][0, :, :].cpu())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}