cpu_gpu_viterbi_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_40000\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_*\"))[-1]\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": "672b6d9829c4415eabb8761c06839f0b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.328456 / 0.689838 = 47.61%\n",
      "IO Time:  0.007548 / 0.689838 =  1.09%\n",
      "DL Time:  0.351875 / 0.689838 = 51.01%\n",
      "\n",
      "VT Time:  0.537944 / 0.718666 = 74.85%\n",
      "IO Time:  0.006255 / 0.718666 =  0.87%\n",
      "DL Time:  0.172813 / 0.718666 = 24.05%\n",
      "\n",
      "VT Time:  0.388770 / 0.570464 = 68.15%\n",
      "IO Time:  0.006215 / 0.570464 =  1.09%\n",
      "DL Time:  0.173757 / 0.570464 = 30.46%\n",
      "\n",
      "VT Time:  0.771784 / 0.955549 = 80.77%\n",
      "IO Time:  0.006236 / 0.955549 =  0.65%\n",
      "DL Time:  0.175656 / 0.955549 = 18.38%\n",
      "\n",
      "VT Time:  0.281851 / 0.483085 = 58.34%\n",
      "IO Time:  0.008502 / 0.483085 =  1.76%\n",
      "DL Time:  0.184141 / 0.483085 = 38.12%\n",
      "\n",
      "VT Time:  0.308661 / 0.473071 = 65.25%\n",
      "IO Time:  0.006027 / 0.473071 =  1.27%\n",
      "DL Time:  0.156760 / 0.473071 = 33.14%\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "038b5082db53465c80b428873d094e30",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.698476 / 0.908651 = 76.87%\n",
      "IO Time:  0.008725 / 0.908651 =  0.96%\n",
      "DL Time:  0.199437 / 0.908651 = 21.95%\n",
      "\n",
      "VT Time:  0.334133 / 0.487728 = 68.51%\n",
      "IO Time:  0.006090 / 0.487728 =  1.25%\n",
      "DL Time:  0.145989 / 0.487728 = 29.93%\n",
      "\n",
      "VT Time:  0.330283 / 0.523225 = 63.12%\n",
      "IO Time:  0.006205 / 0.523225 =  1.19%\n",
      "DL Time:  0.184709 / 0.523225 = 35.30%\n",
      "\n",
      "VT Time:  0.592178 / 0.780659 = 75.86%\n",
      "IO Time:  0.006253 / 0.780659 =  0.80%\n",
      "DL Time:  0.180463 / 0.780659 = 23.12%\n",
      "\n",
      "VT Time:  0.384609 / 0.545889 = 70.46%\n",
      "IO Time:  0.006090 / 0.545889 =  1.12%\n",
      "DL Time:  0.153518 / 0.545889 = 28.12%\n",
      "\n",
      "VT Time:  0.660129 / 0.862951 = 76.50%\n",
      "IO Time:  0.006022 / 0.862951 =  0.70%\n",
      "DL Time:  0.193690 / 0.862951 = 22.45%\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c13a7a7e7dd4db7a27669a48a3d407e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.340391 / 0.512507 = 66.42%\n",
      "IO Time:  0.005833 / 0.512507 =  1.14%\n",
      "DL Time:  0.164089 / 0.512507 = 32.02%\n",
      "\n",
      "VT Time:  0.401949 / 0.599483 = 67.05%\n",
      "IO Time:  0.006904 / 0.599483 =  1.15%\n",
      "DL Time:  0.187803 / 0.599483 = 31.33%\n",
      "\n",
      "VT Time:  0.539260 / 0.714146 = 75.51%\n",
      "IO Time:  0.006417 / 0.714146 =  0.90%\n",
      "DL Time:  0.165879 / 0.714146 = 23.23%\n",
      "\n",
      "VT Time:  0.358492 / 0.550398 = 65.13%\n",
      "IO Time:  0.005935 / 0.550398 =  1.08%\n",
      "DL Time:  0.184229 / 0.550398 = 33.47%\n",
      "\n",
      "VT Time:  0.661965 / 0.895034 = 73.96%\n",
      "IO Time:  0.006058 / 0.895034 =  0.68%\n",
      "DL Time:  0.215317 / 0.895034 = 24.06%\n",
      "\n",
      "VT Time:  0.517605 / 0.721623 = 71.73%\n",
      "IO Time:  0.006131 / 0.721623 =  0.85%\n",
      "DL Time:  0.195064 / 0.721623 = 27.03%\n",
      "\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 num, batch in tqdm(enumerate(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",
    "        print()\n",
    "        \n",
    "        if num >= 5:\n",
    "            break\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": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "640b1cd56a68467cb86cc8c6fddb8203",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.154995 / 0.370217 = 41.87%\n",
      "IO Time:  0.006096 / 0.370217 =  1.65%\n",
      "DL Time:  0.202699 / 0.370217 = 54.75%\n",
      "\n",
      "VT Time:  0.141098 / 0.375438 = 37.58%\n",
      "IO Time:  0.006999 / 0.375438 =  1.86%\n",
      "DL Time:  0.220038 / 0.375438 = 58.61%\n",
      "\n",
      "VT Time:  0.183458 / 0.367585 = 49.91%\n",
      "IO Time:  0.007175 / 0.367585 =  1.95%\n",
      "DL Time:  0.175275 / 0.367585 = 47.68%\n",
      "\n",
      "VT Time:  0.188948 / 0.451633 = 41.84%\n",
      "IO Time:  0.012213 / 0.451633 =  2.70%\n",
      "DL Time:  0.248239 / 0.451633 = 54.96%\n",
      "\n",
      "VT Time:  0.144518 / 0.341290 = 42.34%\n",
      "IO Time:  0.006642 / 0.341290 =  1.95%\n",
      "DL Time:  0.188535 / 0.341290 = 55.24%\n",
      "\n",
      "VT Time:  0.154774 / 0.377819 = 40.97%\n",
      "IO Time:  0.007465 / 0.377819 =  1.98%\n",
      "DL Time:  0.208595 / 0.377819 = 55.21%\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ea54a83813ca4950aa2c0f9ffaa02a35",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.116120 / 0.275899 = 42.09%\n",
      "IO Time:  0.007051 / 0.275899 =  2.56%\n",
      "DL Time:  0.151035 / 0.275899 = 54.74%\n",
      "\n",
      "VT Time:  0.115267 / 0.270026 = 42.69%\n",
      "IO Time:  0.007296 / 0.270026 =  2.70%\n",
      "DL Time:  0.145896 / 0.270026 = 54.03%\n",
      "\n",
      "VT Time:  0.157664 / 0.391994 = 40.22%\n",
      "IO Time:  0.007333 / 0.391994 =  1.87%\n",
      "DL Time:  0.222842 / 0.391994 = 56.85%\n",
      "\n",
      "VT Time:  0.164338 / 0.378136 = 43.46%\n",
      "IO Time:  0.007392 / 0.378136 =  1.95%\n",
      "DL Time:  0.204683 / 0.378136 = 54.13%\n",
      "\n",
      "VT Time:  0.145388 / 0.355010 = 40.95%\n",
      "IO Time:  0.010538 / 0.355010 =  2.97%\n",
      "DL Time:  0.194228 / 0.355010 = 54.71%\n",
      "\n",
      "VT Time:  0.170986 / 0.386790 = 44.21%\n",
      "IO Time:  0.007945 / 0.386790 =  2.05%\n",
      "DL Time:  0.205217 / 0.386790 = 53.06%\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4a5226849a2d46d6b21d8d8ad455702d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT Time:  0.176422 / 0.451842 = 39.05%\n",
      "IO Time:  0.008898 / 0.451842 =  1.97%\n",
      "DL Time:  0.260036 / 0.451842 = 57.55%\n",
      "\n",
      "VT Time:  0.158505 / 0.372225 = 42.58%\n",
      "IO Time:  0.009028 / 0.372225 =  2.43%\n",
      "DL Time:  0.202823 / 0.372225 = 54.49%\n",
      "\n",
      "VT Time:  0.231486 / 0.468632 = 49.40%\n",
      "IO Time:  0.008404 / 0.468632 =  1.79%\n",
      "DL Time:  0.226909 / 0.468632 = 48.42%\n",
      "\n",
      "VT Time:  0.151420 / 0.373891 = 40.50%\n",
      "IO Time:  0.008572 / 0.373891 =  2.29%\n",
      "DL Time:  0.205855 / 0.373891 = 55.06%\n",
      "\n",
      "VT Time:  0.152578 / 0.398423 = 38.30%\n",
      "IO Time:  0.006721 / 0.398423 =  1.69%\n",
      "DL Time:  0.231784 / 0.398423 = 58.18%\n",
      "\n",
      "VT Time:  0.175580 / 0.366029 = 47.97%\n",
      "IO Time:  0.006845 / 0.366029 =  1.87%\n",
      "DL Time:  0.181851 / 0.366029 = 49.68%\n",
      "\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 num, batch in tqdm(enumerate(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_cpu(log_prob_matrix, text_lengths.cpu(), mel_lengths.cpu()).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",
    "        print()\n",
    "        \n",
    "        if num >= 5:\n",
    "            break\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": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c2f2368fcb304947acdab2fe003ed776",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT_ Time:  0.748012\n",
      "VTF Time:  0.154824 / 0.351953 = 43.99%\n",
      "IO_ Time:  0.007186 / 0.351953 =  2.04%\n",
      "DL_ Time:  0.187973 / 0.351953 = 53.41%\n",
      "\n",
      "VT_ Time:  0.380354\n",
      "VTF Time:  0.138768 / 0.315039 = 44.05%\n",
      "IO_ Time:  0.006336 / 0.315039 =  2.01%\n",
      "DL_ Time:  0.168183 / 0.315039 = 53.38%\n",
      "\n",
      "VT_ Time:  0.743523\n",
      "VTF Time:  0.179107 / 0.370350 = 48.36%\n",
      "IO_ Time:  0.006254 / 0.370350 =  1.69%\n",
      "DL_ Time:  0.182077 / 0.370350 = 49.16%\n",
      "\n",
      "VT_ Time:  0.408704\n",
      "VTF Time:  0.140108 / 0.317411 = 44.14%\n",
      "IO_ Time:  0.006322 / 0.317411 =  1.99%\n",
      "DL_ Time:  0.169063 / 0.317411 = 53.26%\n",
      "\n",
      "VT_ Time:  0.762280\n",
      "VTF Time:  0.150737 / 0.336098 = 44.85%\n",
      "IO_ Time:  0.006118 / 0.336098 =  1.82%\n",
      "DL_ Time:  0.177326 / 0.336098 = 52.76%\n",
      "\n",
      "VT_ Time:  0.374688\n",
      "VTF Time:  0.124995 / 0.289050 = 43.24%\n",
      "IO_ Time:  0.006101 / 0.289050 =  2.11%\n",
      "DL_ Time:  0.156331 / 0.289050 = 54.08%\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "97fc167f9d8e42c88611f9db3eca61ce",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT_ Time:  0.731347\n",
      "VTF Time:  0.117543 / 0.334581 = 35.13%\n",
      "IO_ Time:  0.005515 / 0.334581 =  1.65%\n",
      "DL_ Time:  0.209092 / 0.334581 = 62.49%\n",
      "\n",
      "VT_ Time:  0.365710\n",
      "VTF Time:  0.141810 / 0.305110 = 46.48%\n",
      "IO_ Time:  0.006022 / 0.305110 =  1.97%\n",
      "DL_ Time:  0.154924 / 0.305110 = 50.78%\n",
      "\n",
      "VT_ Time:  0.550376\n",
      "VTF Time:  0.165681 / 0.413121 = 40.10%\n",
      "IO_ Time:  0.008668 / 0.413121 =  2.10%\n",
      "DL_ Time:  0.234786 / 0.413121 = 56.83%\n",
      "\n",
      "VT_ Time:  0.479786\n",
      "VTF Time:  0.218679 / 0.387866 = 56.38%\n",
      "IO_ Time:  0.006282 / 0.387866 =  1.62%\n",
      "DL_ Time:  0.161252 / 0.387866 = 41.57%\n",
      "\n",
      "VT_ Time:  0.367198\n",
      "VTF Time:  0.193584 / 0.417622 = 46.35%\n",
      "IO_ Time:  0.009180 / 0.417622 =  2.20%\n",
      "DL_ Time:  0.208714 / 0.417622 = 49.98%\n",
      "\n",
      "VT_ Time:  0.417315\n",
      "VTF Time:  0.216851 / 0.378024 = 57.36%\n",
      "IO_ Time:  0.006259 / 0.378024 =  1.66%\n",
      "DL_ Time:  0.153282 / 0.378024 = 40.55%\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "56f8464fa0f74809b0ed711e86f85497",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VT_ Time:  0.386003\n",
      "VTF Time:  0.177002 / 0.344754 = 51.34%\n",
      "IO_ Time:  0.009012 / 0.344754 =  2.61%\n",
      "DL_ Time:  0.156931 / 0.344754 = 45.52%\n",
      "\n",
      "VT_ Time:  0.430083\n",
      "VTF Time:  0.207760 / 0.370444 = 56.08%\n",
      "IO_ Time:  0.006171 / 0.370444 =  1.67%\n",
      "DL_ Time:  0.154863 / 0.370444 = 41.80%\n",
      "\n",
      "VT_ Time:  0.405816\n",
      "VTF Time:  0.175483 / 0.355281 = 49.39%\n",
      "IO_ Time:  0.008431 / 0.355281 =  2.37%\n",
      "DL_ Time:  0.169708 / 0.355281 = 47.77%\n",
      "\n",
      "VT_ Time:  0.480949\n",
      "VTF Time:  0.147155 / 0.332185 = 44.30%\n",
      "IO_ Time:  0.006287 / 0.332185 =  1.89%\n",
      "DL_ Time:  0.177005 / 0.332185 = 53.29%\n",
      "\n",
      "VT_ Time:  0.630736\n",
      "VTF Time:  0.150808 / 0.341883 = 44.11%\n",
      "IO_ Time:  0.006284 / 0.341883 =  1.84%\n",
      "DL_ Time:  0.182809 / 0.341883 = 53.47%\n",
      "\n",
      "VT_ Time:  0.360628\n",
      "VTF Time:  0.151731 / 0.339944 = 44.63%\n",
      "IO_ Time:  0.006294 / 0.339944 =  1.85%\n",
      "DL_ Time:  0.180163 / 0.339944 = 53.00%\n",
      "\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 num, batch in tqdm(enumerate(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.fast_viterbi(log_prob_matrix, text_lengths, mel_lengths).to(log_prob_matrix.device)\n",
    "#             alignments_ = list(torch.split(align_,1))\n",
    "            align_cpu = model.viterbi_cpu(log_prob_matrix, text_lengths.cpu(), mel_lengths.cpu())\n",
    "            alignments_cpu = list(torch.split(align_cpu,1))\n",
    "            \n",
    "            viterbi_end = time.perf_counter()\n",
    "            \n",
    "            viterbi_origin_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_origin_end = time.perf_counter()\n",
    "            \n",
    "#         print(alignments_ == alignments)\n",
    "        \n",
    "        print('VT_ Time: ', end=' ')\n",
    "        print(f'{viterbi_origin_end - viterbi_origin_start:.6f}')\n",
    "              \n",
    "        print('VTF 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",
    "    \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()\n",
    "        \n",
    "        \n",
    "        \n",
    "        if num >= 5:\n",
    "            break\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": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 161, 863])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alignments_cpu[0].shape\n",
    "alignments[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x864 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(3, 1, figsize=(14, 12), sharex = True)\n",
    "\n",
    "axes[0].imshow(alignments_cpu[0].cpu()[0, :, :])\n",
    "axes[0].set_title('Alignments from Viterbi CPU', fontsize=14)\n",
    "axes[1].imshow(alignments[0].cpu()[0, :, :])\n",
    "axes[1].set_title('Alignments from Viterbi', fontsize=14)\n",
    "im = axes[2].imshow(alignments_cpu[0].cpu()[0, :, :] - alignments[0].cpu()[0, :, :])\n",
    "axes[2].set_title('Alignments CPU - Alignments GPU', fontsize=14)\n",
    "fig.tight_layout()          \n",
    "plt.show(axes[0])"
   ]
  },
  {
   "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
}