TTS_overview.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_QIr9qW2RZoG"
   },
   "outputs": [],
   "source": [
    "# set.py 실행 \n",
    "import os\n",
    "os.chdir('./TensorFlowTTS')\n",
    "print(os.getcwd())\n",
    "! pip install TensorFlowTTS\n",
    "\n",
    "import sys\n",
    "sys.path.append(\"TensorFlowTTS/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 105
    },
    "executionInfo": {
     "elapsed": 18767,
     "status": "ok",
     "timestamp": 1603067233209,
     "user": {
      "displayName": "이소연",
      "photoUrl": "",
      "userId": "16388319312927188329"
     },
     "user_tz": -540
    },
    "id": "0sp8J6NfOoVN",
    "outputId": "06d72ba4-7e89-4a75-9d39-3dbbca01b1db"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package averaged_perceptron_tagger to\n",
      "[nltk_data]     /root/nltk_data...\n",
      "[nltk_data]   Unzipping taggers/averaged_perceptron_tagger.zip.\n",
      "[nltk_data] Downloading package cmudict to /root/nltk_data...\n",
      "[nltk_data]   Unzipping corpora/cmudict.zip.\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import yaml\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import IPython.display as ipd\n",
    "\n",
    "from tensorflow_tts.inference import AutoConfig\n",
    "from tensorflow_tts.inference import TFAutoModel\n",
    "from tensorflow_tts.inference import AutoProcessor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wFabwdMPPtxV"
   },
   "source": [
    "## HParams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "P15DTFttOoV4"
   },
   "outputs": [],
   "source": [
    "class Tacotron2Config(object):\n",
    "    \"\"\"Initialize Tacotron-2 Config.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        dataset='kss',\n",
    "        vocab_size=81,\n",
    "        n_mels=80, \n",
    "        embedding_hidden_size=512, \n",
    "        initializer_range=0.02,\n",
    "        layer_norm_eps=1e-6,\n",
    "        embedding_dropout_prob=0.1,\n",
    "        n_speakers=1,\n",
    "        n_conv_encoder=3,\n",
    "        encoder_conv_filters=512,\n",
    "        encoder_conv_kernel_sizes=5,\n",
    "        encoder_conv_activation=\"mish\",\n",
    "        encoder_conv_dropout_rate=0.5,\n",
    "        encoder_lstm_units=256,\n",
    "        reduction_factor=5,\n",
    "        n_prenet_layers=2,\n",
    "        prenet_units=256,\n",
    "        prenet_activation=\"mish\",\n",
    "        prenet_dropout_rate=0.5,\n",
    "        n_lstm_decoder=1,\n",
    "        decoder_lstm_units=1024,\n",
    "        attention_type=\"lsa\",\n",
    "        attention_dim=128,\n",
    "        attention_filters=32,\n",
    "        attention_kernel=31,\n",
    "        n_conv_postnet=5,\n",
    "        postnet_conv_filters=512,\n",
    "        postnet_conv_kernel_sizes=5,\n",
    "        postnet_dropout_rate=0.1,\n",
    "    ):\n",
    "\n",
    "        \"\"\"Init parameters for Tacotron-2 model.\"\"\"\n",
    "        self.vocab_size = 81 #len(kss_symbols)\n",
    "        self.embedding_hidden_size = embedding_hidden_size #text embedding 차수 \n",
    "        self.initializer_range = initializer_range\n",
    "        self.layer_norm_eps = layer_norm_eps\n",
    "        self.embedding_dropout_prob = embedding_dropout_prob\n",
    "        self.n_speakers = n_speakers\n",
    "        self.n_conv_encoder = n_conv_encoder\n",
    "        self.encoder_conv_filters = encoder_conv_filters\n",
    "        self.encoder_conv_kernel_sizes = encoder_conv_kernel_sizes\n",
    "        self.encoder_conv_activation = encoder_conv_activation\n",
    "        self.encoder_conv_dropout_rate = encoder_conv_dropout_rate\n",
    "        self.encoder_lstm_units = encoder_lstm_units\n",
    "\n",
    "        # decoder param\n",
    "        self.reduction_factor = reduction_factor\n",
    "        self.n_prenet_layers = n_prenet_layers\n",
    "        self.prenet_units = prenet_units\n",
    "        self.prenet_activation = prenet_activation\n",
    "        self.prenet_dropout_rate = prenet_dropout_rate\n",
    "        self.n_lstm_decoder = n_lstm_decoder\n",
    "        self.decoder_lstm_units = decoder_lstm_units\n",
    "        self.attention_type = attention_type\n",
    "        self.attention_dim = attention_dim\n",
    "        self.attention_filters = attention_filters\n",
    "        self.attention_kernel = attention_kernel\n",
    "        self.n_mels = n_mels #mel spectrogram 차수 \n",
    "\n",
    "        # postnet\n",
    "        self.n_conv_postnet = n_conv_postnet\n",
    "        self.postnet_conv_filters = postnet_conv_filters\n",
    "        self.postnet_conv_kernel_sizes = postnet_conv_kernel_sizes\n",
    "        self.postnet_dropout_rate = postnet_dropout_rate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mc9Cmx4FOoWA"
   },
   "source": [
    "## 데이터 전처리"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WIO--OpBOoWC"
   },
   "source": [
    "### 한국어 전처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Fv10VU2KOoWE"
   },
   "outputs": [],
   "source": [
    "# 한국어 전처리 코드 (korean.py)\n",
    "# Son data를 위한 딕셔너리 등은 코드 간략화를 위해 삭제 \n",
    "\n",
    "import ast\n",
    "import json\n",
    "import os\n",
    "import re\n",
    "\n",
    "from jamo import h2j, hangul_to_jamo, j2h, jamo_to_hcj\n",
    "\n",
    "num_to_kor = {\n",
    "    \"0\": \"영\",\n",
    "    \"1\": \"일\",\n",
    "    \"2\": \"이\",\n",
    "    \"3\": \"삼\",\n",
    "    \"4\": \"사\",\n",
    "    \"5\": \"오\",\n",
    "    \"6\": \"육\",\n",
    "    \"7\": \"칠\",\n",
    "    \"8\": \"팔\",\n",
    "    \"9\": \"구\",\n",
    "}\n",
    "\n",
    "unit_to_kor1 = {\"%\": \"퍼센트\", \"cm\": \"센치미터\", \"mm\": \"밀리미터\", \"km\": \"킬로미터\", \"kg\": \"킬로그람\"}\n",
    "unit_to_kor2 = {\"m\": \"미터\"}\n",
    "\n",
    "upper_to_kor = {\n",
    "    \"A\": \"에이\",\n",
    "    \"B\": \"비\",\n",
    "    \"C\": \"씨\",\n",
    "    \"D\": \"디\",\n",
    "    \"E\": \"이\",\n",
    "    \"F\": \"에프\",\n",
    "    \"G\": \"지\",\n",
    "    \"H\": \"에이치\",\n",
    "    \"I\": \"아이\",\n",
    "    \"J\": \"제이\",\n",
    "    \"K\": \"케이\",\n",
    "    \"L\": \"엘\",\n",
    "    \"M\": \"엠\",\n",
    "    \"N\": \"엔\",\n",
    "    \"O\": \"오\",\n",
    "    \"P\": \"피\",\n",
    "    \"Q\": \"큐\",\n",
    "    \"R\": \"알\",\n",
    "    \"S\": \"에스\",\n",
    "    \"T\": \"티\",\n",
    "    \"U\": \"유\",\n",
    "    \"V\": \"브이\",\n",
    "    \"W\": \"더블유\",\n",
    "    \"X\": \"엑스\",\n",
    "    \"Y\": \"와이\",\n",
    "    \"Z\": \"지\",\n",
    "}\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "초성과 종성은 같아보이지만, 다른 character이다.\n",
    "\n",
    "'_-!'(),-.:;? ᄀᄁᄂᄃᄄᄅᄆᄇᄈᄉᄊᄋᄌᄍᄎᄏᄐᄑ하ᅢᅣᅤᅥᅦᅧᅨᅩᅪᅫᅬᅭᅮᅯᅰᅱᅲᅳᅴᅵᆨᆩᆪᆫᆬᆭᆮᆯᆰᆱᆲᆳᆴᆵᆶᆷᆸᆹᆺᆻᆼᆽᆾᆿᇀᇁᇂ~'\n",
    "\n",
    "'_': 0, '-': 7, '!': 2, \"'\": 3, '(': 4, ')': 5, ',': 6, '.': 8, ':': 9, ';': 10,\n",
    "'?': 11, ' ': 12, 'ᄀ': 13, 'ᄁ': 14, 'ᄂ': 15, 'ᄃ': 16, 'ᄄ': 17, 'ᄅ': 18, 'ᄆ': 19, 'ᄇ': 20,\n",
    "'ᄈ': 21, 'ᄉ': 22, 'ᄊ': 23, 'ᄋ': 24, 'ᄌ': 25, 'ᄍ': 26, 'ᄎ': 27, 'ᄏ': 28, 'ᄐ': 29, 'ᄑ': 30,\n",
    "'ᄒ': 31, 'ᅡ': 32, 'ᅢ': 33, 'ᅣ': 34, 'ᅤ': 35, 'ᅥ': 36, 'ᅦ': 37, 'ᅧ': 38, 'ᅨ': 39, 'ᅩ': 40,\n",
    "'ᅪ': 41, 'ᅫ': 42, 'ᅬ': 43, 'ᅭ': 44, 'ᅮ': 45, 'ᅯ': 46, 'ᅰ': 47, 'ᅱ': 48, 'ᅲ': 49, 'ᅳ': 50,\n",
    "'ᅴ': 51, 'ᅵ': 52, 'ᆨ': 53, 'ᆩ': 54, 'ᆪ': 55, 'ᆫ': 56, 'ᆬ': 57, 'ᆭ': 58, 'ᆮ': 59, 'ᆯ': 60,\n",
    "'ᆰ': 61, 'ᆱ': 62, 'ᆲ': 63, 'ᆳ': 64, 'ᆴ': 65, 'ᆵ': 66, 'ᆶ': 67, 'ᆷ': 68, 'ᆸ': 69, 'ᆹ': 70,\n",
    "'ᆺ': 71, 'ᆻ': 72, 'ᆼ': 73, 'ᆽ': 74, 'ᆾ': 75, 'ᆿ': 76, 'ᇀ': 77, 'ᇁ': 78, 'ᇂ': 79, '~': 80\n",
    "\"\"\"\n",
    "\n",
    "_pad = \"pad\"\n",
    "_eos = \"eos\"\n",
    "_punctuation = \"!'(),-.:;? \"\n",
    "_special = \"-\"\n",
    "\n",
    "_jamo_leads = [chr(_) for _ in range(0x1100, 0x1113)]\n",
    "_jamo_vowels = [chr(_) for _ in range(0x1161, 0x1176)]\n",
    "_jamo_tails = [chr(_) for _ in range(0x11A8, 0x11C3)]\n",
    "\n",
    "_letters = _jamo_leads + _jamo_vowels + _jamo_tails\n",
    "\n",
    "symbols = [_pad] + list(_special) + list(_punctuation) + _letters + [_eos]\n",
    "\n",
    "_symbol_to_id = {c: i for i, c in enumerate(symbols)}\n",
    "_id_to_symbol = {i: c for i, c in enumerate(symbols)}\n",
    "\n",
    "quote_checker = \"\"\"([`\"'＂“‘])(.+?)([`\"'＂”’])\"\"\"\n",
    "\n",
    "\n",
    "def is_lead(char):\n",
    "    return char in _jamo_leads\n",
    "\n",
    "\n",
    "def is_vowel(char):\n",
    "    return char in _jamo_vowels\n",
    "\n",
    "\n",
    "def is_tail(char):\n",
    "    return char in _jamo_tails\n",
    "\n",
    "\n",
    "def get_mode(char):\n",
    "    if is_lead(char):\n",
    "        return 0\n",
    "    elif is_vowel(char):\n",
    "        return 1\n",
    "    elif is_tail(char):\n",
    "        return 2\n",
    "    else:\n",
    "        return -1\n",
    "\n",
    "\n",
    "def _get_text_from_candidates(candidates):\n",
    "    if len(candidates) == 0:\n",
    "        return \"\"\n",
    "    elif len(candidates) == 1:\n",
    "        return jamo_to_hcj(candidates[0])\n",
    "    else:\n",
    "        return j2h(**dict(zip([\"lead\", \"vowel\", \"tail\"], candidates)))\n",
    "\n",
    "\n",
    "def jamo_to_korean(text):\n",
    "    text = h2j(text)\n",
    "\n",
    "    idx = 0\n",
    "    new_text = \"\"\n",
    "    candidates = []\n",
    "\n",
    "    while True:\n",
    "        if idx >= len(text):\n",
    "            new_text += _get_text_from_candidates(candidates)\n",
    "            break\n",
    "\n",
    "        char = text[idx]\n",
    "        mode = get_mode(char)\n",
    "\n",
    "        if mode == 0:\n",
    "            new_text += _get_text_from_candidates(candidates)\n",
    "            candidates = [char]\n",
    "        elif mode == -1:\n",
    "            new_text += _get_text_from_candidates(candidates)\n",
    "            new_text += char\n",
    "            candidates = []\n",
    "        else:\n",
    "            candidates.append(char)\n",
    "\n",
    "        idx += 1\n",
    "    return new_text\n",
    "\n",
    "\n",
    "def compare_sentence_with_jamo(text1, text2):\n",
    "    return h2j(text1) != h2j(text2)\n",
    "\n",
    "\n",
    "def tokenize(text, as_id=False):\n",
    "    # jamo package에 있는 hangul_to_jamo를 이용하여 한글 string을 초성/중성/종성으로 나눈다.\n",
    "    text = normalize(text)\n",
    "    tokens = list(\n",
    "        hangul_to_jamo(text)\n",
    "    )  # '존경하는'  --> ['ᄌ', 'ᅩ', 'ᆫ', 'ᄀ', 'ᅧ', 'ᆼ', 'ᄒ', 'ᅡ', 'ᄂ', 'ᅳ', 'ᆫ', '~']\n",
    "\n",
    "    if as_id:\n",
    "        return [_symbol_to_id[token] for token in tokens]\n",
    "    else:\n",
    "        return [token for token in tokens]\n",
    "\n",
    "\n",
    "def tokenizer_fn(iterator):\n",
    "    return (token for x in iterator for token in tokenize(x, as_id=False))\n",
    "\n",
    "\n",
    "def normalize(text):\n",
    "    text = text.strip()\n",
    "\n",
    "    text = re.sub(\"\\(\\d+일\\)\", \"\", text)\n",
    "    text = normalize_with_dictionary(text, etc_dictionary)\n",
    "    text = normalize_english(text)\n",
    "    text = re.sub(\"[a-zA-Z]+\", normalize_upper, text)\n",
    "\n",
    "    text = normalize_quote(text)\n",
    "    text = normalize_number(text)\n",
    "\n",
    "    return text\n",
    "\n",
    "\n",
    "def normalize_with_dictionary(text, dic):\n",
    "    if any(key in text for key in dic.keys()):\n",
    "        pattern = re.compile(\"|\".join(re.escape(key) for key in dic.keys()))\n",
    "        return pattern.sub(lambda x: dic[x.group()], text)\n",
    "    else:\n",
    "        return text\n",
    "\n",
    "\n",
    "def normalize_english(text):\n",
    "    def fn(m):\n",
    "        word = m.group()\n",
    "        if word in english_dictionary:\n",
    "            return english_dictionary.get(word)\n",
    "        else:\n",
    "            return word\n",
    "\n",
    "    text = re.sub(\"([A-Za-z]+)\", fn, text)\n",
    "    return text\n",
    "\n",
    "\n",
    "def normalize_upper(text):\n",
    "    text = text.group(0)\n",
    "\n",
    "    if all([char.isupper() for char in text]):\n",
    "        return \"\".join(upper_to_kor[char] for char in text)\n",
    "    else:\n",
    "        return text\n",
    "\n",
    "\n",
    "def normalize_quote(text):\n",
    "    def fn(found_text):\n",
    "        from nltk import sent_tokenize  # NLTK doesn't along with multiprocessing\n",
    "\n",
    "        found_text = found_text.group()\n",
    "        unquoted_text = found_text[1:-1]\n",
    "\n",
    "        sentences = sent_tokenize(unquoted_text)\n",
    "        return \" \".join([\"'{}'\".format(sent) for sent in sentences])\n",
    "\n",
    "    return re.sub(quote_checker, fn, text)\n",
    "\n",
    "\n",
    "number_checker = \"([+-]?\\d[\\d,]*)[\\.]?\\d*\"\n",
    "count_checker = \"(시|명|가지|살|마리|포기|송이|수|톨|통|점|개|벌|척|채|다발|그루|자루|줄|켤레|그릇|잔|마디|상자|사람|곡|병|판)\"\n",
    "\n",
    "\n",
    "def normalize_number(text):\n",
    "    text = normalize_with_dictionary(text, unit_to_kor1)\n",
    "    text = normalize_with_dictionary(text, unit_to_kor2)\n",
    "    text = re.sub(\n",
    "        number_checker + count_checker, lambda x: number_to_korean(x, True), text\n",
    "    )\n",
    "    text = re.sub(number_checker, lambda x: number_to_korean(x, False), text)\n",
    "    return text\n",
    "\n",
    "\n",
    "num_to_kor1 = [\"\"] + list(\"일이삼사오육칠팔구\")\n",
    "num_to_kor2 = [\"\"] + list(\"만억조경해\")\n",
    "num_to_kor3 = [\"\"] + list(\"십백천\")\n",
    "\n",
    "# count_to_kor1 = [\"\"] + [\"하나\",\"둘\",\"셋\",\"넷\",\"다섯\",\"여섯\",\"일곱\",\"여덟\",\"아홉\"]\n",
    "count_to_kor1 = [\"\"] + [\"한\", \"두\", \"세\", \"네\", \"다섯\", \"여섯\", \"일곱\", \"여덟\", \"아홉\"]\n",
    "\n",
    "count_tenth_dict = {\n",
    "    \"십\": \"열\",\n",
    "    \"두십\": \"스물\",\n",
    "    \"세십\": \"서른\",\n",
    "    \"네십\": \"마흔\",\n",
    "    \"다섯십\": \"쉰\",\n",
    "    \"여섯십\": \"예순\",\n",
    "    \"일곱십\": \"일흔\",\n",
    "    \"여덟십\": \"여든\",\n",
    "    \"아홉십\": \"아흔\",\n",
    "}\n",
    "\n",
    "\n",
    "def number_to_korean(num_str, is_count=False):\n",
    "    if is_count:\n",
    "        num_str, unit_str = num_str.group(1), num_str.group(2)\n",
    "    else:\n",
    "        num_str, unit_str = num_str.group(), \"\"\n",
    "\n",
    "    num_str = num_str.replace(\",\", \"\")\n",
    "    num = ast.literal_eval(num_str)\n",
    "\n",
    "    if num == 0:\n",
    "        return \"영\"\n",
    "\n",
    "    check_float = num_str.split(\".\")\n",
    "    if len(check_float) == 2:\n",
    "        digit_str, float_str = check_float\n",
    "    elif len(check_float) >= 3:\n",
    "        raise Exception(\" [!] Wrong number format\")\n",
    "    else:\n",
    "        digit_str, float_str = check_float[0], None\n",
    "\n",
    "    if is_count and float_str is not None:\n",
    "        raise Exception(\" [!] `is_count` and float number does not fit each other\")\n",
    "\n",
    "    digit = int(digit_str)\n",
    "\n",
    "    if digit_str.startswith(\"-\"):\n",
    "        digit, digit_str = abs(digit), str(abs(digit))\n",
    "\n",
    "    kor = \"\"\n",
    "    size = len(str(digit))\n",
    "    tmp = []\n",
    "\n",
    "    for i, v in enumerate(digit_str, start=1):\n",
    "        v = int(v)\n",
    "\n",
    "        if v != 0:\n",
    "            if is_count:\n",
    "                tmp += count_to_kor1[v]\n",
    "            else:\n",
    "                tmp += num_to_kor1[v]\n",
    "\n",
    "            tmp += num_to_kor3[(size - i) % 4]\n",
    "\n",
    "        if (size - i) % 4 == 0 and len(tmp) != 0:\n",
    "            kor += \"\".join(tmp)\n",
    "            tmp = []\n",
    "            kor += num_to_kor2[int((size - i) / 4)]\n",
    "\n",
    "    if is_count:\n",
    "        if kor.startswith(\"한\") and len(kor) > 1:\n",
    "            kor = kor[1:]\n",
    "\n",
    "        if any(word in kor for word in count_tenth_dict):\n",
    "            kor = re.sub(\n",
    "                \"|\".join(count_tenth_dict.keys()),\n",
    "                lambda x: count_tenth_dict[x.group()],\n",
    "                kor,\n",
    "            )\n",
    "\n",
    "    if not is_count and kor.startswith(\"일\") and len(kor) > 1:\n",
    "        kor = kor[1:]\n",
    "\n",
    "    if float_str is not None:\n",
    "        kor += \"쩜 \"\n",
    "        kor += re.sub(\"\\d\", lambda x: num_to_kor[x.group()], float_str)\n",
    "\n",
    "    if num_str.startswith(\"+\"):\n",
    "        kor = \"플러스 \" + kor\n",
    "    elif num_str.startswith(\"-\"):\n",
    "        kor = \"마이너스 \" + kor\n",
    "\n",
    "    return kor + unit_str\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "executionInfo": {
     "elapsed": 950,
     "status": "ok",
     "timestamp": 1603067275546,
     "user": {
      "displayName": "이소연",
      "photoUrl": "",
      "userId": "16388319312927188329"
     },
     "user_tz": -540
    },
    "id": "HsaRAg5kOoWN",
    "outputId": "7911d4df-3bf9-4af9-b8b9-8820fef74c8b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 7,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(symbols) #한국어 character embedding할 개수 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "u5nW6xwVOoWV"
   },
   "outputs": [],
   "source": [
    "# KSS 데이터 processor\n",
    "import os\n",
    "import re\n",
    "\n",
    "import numpy as np\n",
    "import soundfile as sf\n",
    "from dataclasses import dataclass\n",
    "from tensorflow_tts.processor import BaseProcessor\n",
    "from tensorflow_tts.utils import cleaners\n",
    "from tensorflow_tts.utils.korean import symbols as KSS_SYMBOLS\n",
    "\n",
    "# Regular expression matching text enclosed in curly braces:\n",
    "_curly_re = re.compile(r\"(.*?)\\{(.+?)\\}(.*)\")\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class KSSProcessor(BaseProcessor):\n",
    "    \"\"\"KSS processor.\"\"\"\n",
    "\n",
    "    cleaner_names: str = \"korean_cleaners\"\n",
    "    positions = {\n",
    "        \"wave_file\": 0,\n",
    "        \"text_norm\": 2,\n",
    "    }\n",
    "    train_f_name: str = \"transcript.v.1.4.txt\"\n",
    "\n",
    "    def create_items(self):\n",
    "        if self.data_dir:\n",
    "            with open(\n",
    "                os.path.join(self.data_dir, self.train_f_name), encoding=\"utf-8\"\n",
    "            ) as f:\n",
    "                self.items = [self.split_line(self.data_dir, line, \"|\") for line in f]\n",
    "\n",
    "    def split_line(self, data_dir, line, split):\n",
    "        parts = line.strip().split(split)\n",
    "        wave_file = parts[self.positions[\"wave_file\"]]\n",
    "        text_norm = parts[self.positions[\"text_norm\"]]\n",
    "        wav_path = os.path.join(data_dir, \"kss\", wave_file)\n",
    "        speaker_name = \"kss\"\n",
    "        return text_norm, wav_path, speaker_name\n",
    "\n",
    "    def setup_eos_token(self):\n",
    "        return \"eos\"\n",
    "\n",
    "    def get_one_sample(self, item):\n",
    "        text, wav_path, speaker_name = item\n",
    "\n",
    "        # normalize audio signal to be [-1, 1], soundfile already norm.\n",
    "        audio, rate = sf.read(wav_path)\n",
    "        audio = audio.astype(np.float32)\n",
    "\n",
    "        # convert text to ids\n",
    "        text_ids = np.asarray(self.text_to_sequence(text), np.int32)\n",
    "\n",
    "        sample = {\n",
    "            \"raw_text\": text,\n",
    "            \"text_ids\": text_ids,\n",
    "            \"audio\": audio,\n",
    "            \"utt_id\": os.path.split(wav_path)[-1].split(\".\")[0],\n",
    "            \"speaker_name\": speaker_name,\n",
    "            \"rate\": rate,\n",
    "        }\n",
    "\n",
    "        return sample\n",
    "\n",
    "    def text_to_sequence(self, text):\n",
    "\n",
    "        sequence = []\n",
    "        # Check for curly braces and treat their contents as ARPAbet:\n",
    "        while len(text):\n",
    "            m = _curly_re.match(text)\n",
    "            if not m:\n",
    "                sequence += self._symbols_to_sequence(\n",
    "                    self._clean_text(text, [self.cleaner_names])\n",
    "                )\n",
    "                break\n",
    "            sequence += self._symbols_to_sequence(\n",
    "                self._clean_text(m.group(1), [self.cleaner_names])\n",
    "            )\n",
    "            sequence += self._arpabet_to_sequence(m.group(2))\n",
    "            text = m.group(3)\n",
    "\n",
    "        # add eos tokens\n",
    "        sequence += [self.eos_id]\n",
    "        return sequence\n",
    "\n",
    "    def _clean_text(self, text, cleaner_names):\n",
    "        for name in cleaner_names:\n",
    "            cleaner = getattr(cleaners, name)\n",
    "            if not cleaner:\n",
    "                raise Exception(\"Unknown cleaner: %s\" % name)\n",
    "            text = cleaner(text)\n",
    "        return text\n",
    "\n",
    "    def _symbols_to_sequence(self, symbols):\n",
    "        return [self.symbol_to_id[s] for s in symbols if self._should_keep_symbol(s)]\n",
    "\n",
    "    def _arpabet_to_sequence(self, text):\n",
    "        return self._symbols_to_sequence([\"@\" + s for s in text.split()])\n",
    "\n",
    "    def _should_keep_symbol(self, s):\n",
    "        return s in self.symbol_to_id and s != \"_\" and s != \"~\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-CcQjEslOoXA"
   },
   "source": [
    "### Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ebtUqFLMOoXU"
   },
   "outputs": [],
   "source": [
    "import argparse\n",
    "import glob\n",
    "import logging\n",
    "import os\n",
    "import yaml\n",
    "import easydict\n",
    "import librosa\n",
    "import numpy as np\n",
    "import pyworld as pw\n",
    "\n",
    "from functools import partial\n",
    "from multiprocessing import Pool\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from tqdm import tqdm\n",
    "from tensorflow_tts.processor import KSSProcessor\n",
    "from tensorflow_tts.processor.kss import KSS_SYMBOLS\n",
    "\n",
    "from tensorflow_tts.utils import remove_outlier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "STY-Un-YOoXa"
   },
   "outputs": [],
   "source": [
    "#  preprocess 전용 함수들 \n",
    "\n",
    "def parse_and_config():\n",
    "    args = easydict.EasyDict({ \"rootdir\": './kss', \n",
    "                              \"outdir\": './dump_test', \n",
    "                              \"dataset\": 'kss', \n",
    "                              \"config\": \"./preprocess/kss_preprocess.yaml\", \n",
    "                              \"n_cpus\": 4, \n",
    "                              \"test_size\": 0.05,\n",
    "                              \"verbose\":0})\n",
    "      # set logger\n",
    "    FORMAT = \"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s\"\n",
    "    log_level = {0: logging.DEBUG, 1: logging.WARNING, 2: logging.ERROR}\n",
    "    logging.basicConfig(level=log_level[args.verbose], format=FORMAT)\n",
    "\n",
    "    # load config\n",
    "    config = yaml.load(open(args.config), Loader=yaml.Loader)\n",
    "    config.update(vars(args))\n",
    "    # config checks\n",
    "    assert config[\"format\"] == \"npy\", \"'npy' is the only supported format.\"\n",
    "    return config\n",
    "\n",
    "\n",
    "def ph_based_trim(\n",
    "    config,\n",
    "    utt_id: str,\n",
    "    text_ids: np.array,\n",
    "    raw_text: str,\n",
    "    audio: np.array,\n",
    "    hop_size: int,\n",
    ") -> (bool, np.array, np.array):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        config: Parsed yaml config\n",
    "        utt_id: file name\n",
    "        text_ids: array with text ids\n",
    "        raw_text: raw text of file\n",
    "        audio: parsed wav file\n",
    "        hop_size: Hop size\n",
    "    Returns: (bool, np.array, np.array) => if trimmed return True, new text_ids, new audio_array\n",
    "    \"\"\"\n",
    "\n",
    "    os.makedirs(os.path.join(config[\"rootdir\"], \"trimmed-durations\"), exist_ok=True)\n",
    "    duration_path = config.get(\n",
    "        \"duration_path\", os.path.join(config[\"rootdir\"], \"durations\")\n",
    "    )\n",
    "    duration_fixed_path = config.get(\n",
    "        \"duration_fixed_path\", os.path.join(config[\"rootdir\"], \"trimmed-durations\")\n",
    "    )\n",
    "    sil_ph = [\"SIL\", \"END\"]  # TODO FIX hardcoded values\n",
    "    text = raw_text.split(\" \")\n",
    "\n",
    "    trim_start, trim_end = False, False\n",
    "\n",
    "    if text[0] in sil_ph:\n",
    "        trim_start = True\n",
    "\n",
    "    if text[-1] in sil_ph:\n",
    "        trim_end = True\n",
    "\n",
    "    if not trim_start and not trim_end:\n",
    "        return False, text_ids, audio\n",
    "\n",
    "    idx_start, idx_end = (\n",
    "        0 if not trim_start else 1,\n",
    "        text_ids.__len__() if not trim_end else -1,\n",
    "    )\n",
    "    text_ids = text_ids[idx_start:idx_end]\n",
    "    durations = np.load(os.path.join(duration_path, f\"{utt_id}-durations.npy\"))\n",
    "    if trim_start:\n",
    "        s_trim = int(durations[0] * hop_size)\n",
    "        audio = audio[s_trim:]\n",
    "    if trim_end:\n",
    "        e_trim = int(durations[-1] * hop_size)\n",
    "        audio = audio[:-e_trim]\n",
    "\n",
    "    durations = durations[idx_start:idx_end]\n",
    "    np.save(os.path.join(duration_fixed_path, f\"{utt_id}-durations.npy\"), durations)\n",
    "    return True, text_ids, audio\n",
    "\n",
    "\n",
    "def gen_audio_features(item, config):\n",
    "    \"\"\"Generate audio features and transformations\n",
    "    Args:\n",
    "        item (Dict): dictionary containing the attributes to encode.\n",
    "        config (Dict): configuration dictionary.\n",
    "    Returns:\n",
    "        (bool): keep this sample or not.\n",
    "        mel (ndarray): mel matrix in np.float32.\n",
    "        energy (ndarray): energy audio profile.\n",
    "        f0 (ndarray): fundamental frequency.\n",
    "        item (Dict): dictionary containing the updated attributes.\n",
    "        \n",
    "        \n",
    "# sample_rate: 오디오(신호) 데이터의 표본 비율(속도)\n",
    "# mel spectrogram의 차수\n",
    "# win_length: short time analysis를 하기위한 window의 길이\n",
    "# hop_length: 얼만큼씩 이동시킬 것인가 => 즉, 1024 length의 윈도우를 256만큼 조금씩 이동시켜가면서 분석을 진행\n",
    "# f_min, f_max: fundamental freq(사람 음성)의 바운더리 설정 => 계산용이를 위해 / 각자 제공하는 코드에 맞게 스케일을 맞출것\n",
    "# n_fft: fft size => FT(Fourier Transform, 푸리에 변환)는 시간에 대한 함수(신호)를 주파수 성분으로 분해하는 작업        \n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    # get info from sample.\n",
    "    audio = item[\"audio\"]\n",
    "    utt_id = item[\"utt_id\"]\n",
    "    rate = item[\"rate\"]\n",
    "\n",
    "    # check audio properties\n",
    "    assert len(audio.shape) == 1, f\"{utt_id} seems to be multi-channel signal.\"\n",
    "    assert np.abs(audio).max() <= 1.0, f\"{utt_id} is different from 16 bit PCM.\"\n",
    "    \n",
    "    # check sample rate\n",
    "    if rate != config[\"sampling_rate\"]:\n",
    "        audio = librosa.resample(audio, rate, config[\"sampling_rate\"])\n",
    "        logging.info(f\"{utt_id} sampling rate is {rate}, not {config['sampling_rate']}, we resample it.\")\n",
    "\n",
    "    # trim silence\n",
    "    if config[\"trim_silence\"]:\n",
    "        if \"trim_mfa\" in config and config[\"trim_mfa\"]:\n",
    "            _, item[\"text_ids\"], audio = ph_based_trim(\n",
    "                config,\n",
    "                utt_id,\n",
    "                item[\"text_ids\"],\n",
    "                item[\"raw_text\"],\n",
    "                audio,\n",
    "                config[\"hop_size\"],\n",
    "            )\n",
    "            if (\n",
    "                audio.__len__() < 1\n",
    "            ):  # very short files can get trimmed fully if mfa didnt extract any tokens LibriTTS maybe take only longer files?\n",
    "                logging.warning(\n",
    "                    f\"File have only silence or MFA didnt extract any token {utt_id}\"\n",
    "                )\n",
    "                return False, None, None, None, item\n",
    "        else:\n",
    "            audio, _ = librosa.effects.trim(\n",
    "                audio,\n",
    "                top_db=config[\"trim_threshold_in_db\"],\n",
    "                frame_length=config[\"trim_frame_size\"],\n",
    "                hop_length=config[\"trim_hop_size\"],\n",
    "            )\n",
    "\n",
    "    # resample audio if necessary\n",
    "    if \"sampling_rate_for_feats\" in config:\n",
    "        audio = librosa.resample(audio, rate, config[\"sampling_rate_for_feats\"])\n",
    "        sampling_rate = config[\"sampling_rate_for_feats\"]\n",
    "        assert (\n",
    "            config[\"hop_size\"] * config[\"sampling_rate_for_feats\"] % rate == 0\n",
    "        ), \"'hop_size' must be 'int' value. Please check if 'sampling_rate_for_feats' is correct.\"\n",
    "        hop_size = config[\"hop_size\"] * config[\"sampling_rate_for_feats\"] // rate\n",
    "    else:\n",
    "        sampling_rate = config[\"sampling_rate\"]\n",
    "        hop_size = config[\"hop_size\"]\n",
    "\n",
    "    # get spectrogram\n",
    "    D = librosa.stft(\n",
    "        audio,\n",
    "        n_fft=config[\"fft_size\"],\n",
    "        hop_length=hop_size,\n",
    "        win_length=config[\"win_length\"],\n",
    "        window=config[\"window\"],\n",
    "        pad_mode=\"reflect\",\n",
    "    )\n",
    "    S, _ = librosa.magphase(D)  # (#bins, #frames)\n",
    "\n",
    "    # get mel basis\n",
    "    fmin = 0 if config[\"fmin\"] is None else config[\"fmin\"]\n",
    "    fmax = sampling_rate // 2 if config[\"fmax\"] is None else config[\"fmax\"]\n",
    "    mel_basis = librosa.filters.mel(\n",
    "        sr=sampling_rate,\n",
    "        n_fft=config[\"fft_size\"],\n",
    "        n_mels=config[\"num_mels\"],\n",
    "        fmin=fmin,\n",
    "        fmax=fmax,\n",
    "    )\n",
    "    mel = np.log10(np.maximum(np.dot(mel_basis, S), 1e-10)).T  # (#frames, #bins)\n",
    "\n",
    "    # check audio and feature length\n",
    "    audio = np.pad(audio, (0, config[\"fft_size\"]), mode=\"edge\")\n",
    "    audio = audio[: len(mel) * hop_size]\n",
    "    assert len(mel) * hop_size == len(audio)\n",
    "\n",
    "    # extract raw pitch\n",
    "    _f0, t = pw.dio(\n",
    "        audio.astype(np.double),\n",
    "        fs=sampling_rate,\n",
    "        f0_ceil=fmax,\n",
    "        frame_period=1000 * hop_size / sampling_rate,\n",
    "    )\n",
    "    f0 = pw.stonemask(audio.astype(np.double), _f0, t, sampling_rate)\n",
    "    if len(f0) >= len(mel):\n",
    "        f0 = f0[: len(mel)]\n",
    "    else:\n",
    "        f0 = np.pad(f0, (0, len(mel) - len(f0)))\n",
    "\n",
    "    # extract energy\n",
    "    energy = np.sqrt(np.sum(S ** 2, axis=0))\n",
    "    assert len(mel) == len(f0) == len(energy)\n",
    "\n",
    "    # remove outlier f0/energy\n",
    "    f0 = remove_outlier(f0)\n",
    "    energy = remove_outlier(energy)\n",
    "\n",
    "    # apply global gain\n",
    "    if config[\"global_gain_scale\"] > 0.0:\n",
    "        audio *= config[\"global_gain_scale\"]\n",
    "    if np.abs(audio).max() >= 1.0:\n",
    "        logging.warn(\n",
    "            f\"{utt_id} causes clipping. It is better to reconsider global gain scale value.\"\n",
    "        )\n",
    "    item[\"audio\"] = audio\n",
    "    item[\"mel\"] = mel\n",
    "    item[\"f0\"] = f0\n",
    "    item[\"energy\"] = energy\n",
    "    return True, mel, energy, f0, item\n",
    "\n",
    "\n",
    "def save_statistics_to_file(scaler_list, config):\n",
    "    \"\"\"Save computed statistics to disk.\n",
    "    Args:\n",
    "        scaler_list (List): List of scalers containing statistics to save.\n",
    "        config (Dict): configuration dictionary.\n",
    "    \"\"\"\n",
    "    for scaler, name in scaler_list:\n",
    "        stats = np.stack((scaler.mean_, scaler.scale_))\n",
    "        np.save(\n",
    "            os.path.join(config[\"outdir\"], f\"stats{name}.npy\"),\n",
    "            stats.astype(np.float32),\n",
    "            allow_pickle=False,\n",
    "        )\n",
    "\n",
    "\n",
    "def save_features_to_file(features, subdir, config):\n",
    "    \"\"\"Save transformed dataset features in disk.\n",
    "    Args:\n",
    "        features (Dict): dictionary containing the attributes to save.\n",
    "        subdir (str): data split folder where features will be saved.\n",
    "        config (Dict): configuration dictionary.\n",
    "    \"\"\"\n",
    "    utt_id = features[\"utt_id\"]\n",
    "\n",
    "    if config[\"format\"] == \"npy\":\n",
    "        save_list = [\n",
    "            (features[\"audio\"], \"wavs\", \"wave\", np.float32),\n",
    "            (features[\"mel\"], \"raw-feats\", \"raw-feats\", np.float32),\n",
    "            (features[\"text_ids\"], \"ids\", \"ids\", np.int32),\n",
    "            (features[\"f0\"], \"raw-f0\", \"raw-f0\", np.float32),\n",
    "            (features[\"energy\"], \"raw-energies\", \"raw-energy\", np.float32),\n",
    "        ]\n",
    "        for item, name_dir, name_file, fmt in save_list:\n",
    "            np.save(\n",
    "                os.path.join(\n",
    "                    config[\"outdir\"], subdir, name_dir, f\"{utt_id}-{name_file}.npy\"\n",
    "                ),\n",
    "                item.astype(fmt),\n",
    "                allow_pickle=False,\n",
    "            )\n",
    "    else:\n",
    "        raise ValueError(\"'npy' is the only supported format.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HtKtWgv1OoXf"
   },
   "outputs": [],
   "source": [
    "# Hyperparameters 파싱\n",
    "\n",
    "def parse_and_config():\n",
    "    args = easydict.EasyDict({ \"rootdir\": './kss', \n",
    "                              \"outdir\": './dump_test', \n",
    "                              \"dataset\": 'kss', \n",
    "                              \"config\": \"./preprocess/kss_preprocess.yaml\", \n",
    "                              \"n_cpus\": 4, \n",
    "                              \"test_size\": 0.05,\n",
    "                              \"verbose\":0})\n",
    "      # set logger\n",
    "    FORMAT = \"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s\"\n",
    "    log_level = {0: logging.DEBUG, 1: logging.WARNING, 2: logging.ERROR}\n",
    "    logging.basicConfig(level=log_level[args.verbose], format=FORMAT)\n",
    "\n",
    "    # load config\n",
    "    config = yaml.load(open(args.config), Loader=yaml.Loader)\n",
    "    config.update(vars(args))\n",
    "    # config checks\n",
    "    assert config[\"format\"] == \"npy\", \"'npy' is the only supported format.\"\n",
    "    return config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GH477GayOoXk"
   },
   "outputs": [],
   "source": [
    "def preprocess():\n",
    "    \"\"\"Run preprocessing process and compute statistics for normalizing.\"\"\"\n",
    "    config = parse_and_config()\n",
    "\n",
    "    dataset_processor = {\n",
    "        \"kss\": KSSProcessor,\n",
    "    }\n",
    "\n",
    "    dataset_symbol = {\n",
    "        \"kss\": KSS_SYMBOLS,\n",
    "    }\n",
    "\n",
    "    dataset_cleaner = {\n",
    "        \"kss\": \"korean_cleaners\",\n",
    "    }\n",
    "\n",
    "    logging.info(f\"Selected '{config['dataset']}' processor.\")\n",
    "    processor = dataset_processor[config[\"dataset\"]](\n",
    "        config[\"rootdir\"],\n",
    "        symbols=dataset_symbol[config[\"dataset\"]],\n",
    "        cleaner_names=dataset_cleaner[config[\"dataset\"]],\n",
    "    )\n",
    "\n",
    "    # check output directories\n",
    "    build_dir = lambda x: [\n",
    "        os.makedirs(os.path.join(config[\"outdir\"], x, y), exist_ok=True)\n",
    "        for y in [\"raw-feats\", \"wavs\", \"ids\", \"raw-f0\", \"raw-energies\"]\n",
    "    ]\n",
    "    build_dir(\"train\")\n",
    "    build_dir(\"valid\")\n",
    "\n",
    "    # save pretrained-processor to feature dir\n",
    "    processor._save_mapper(\n",
    "        os.path.join(config[\"outdir\"], f\"{config['dataset']}_mapper.json\"),\n",
    "        extra_attrs_to_save={\"pinyin_dict\": processor.pinyin_dict}\n",
    "        if config[\"dataset\"] == \"baker\"\n",
    "        else {},\n",
    "    )\n",
    "\n",
    "    # build train test split\n",
    "    if config[\"dataset\"] == \"libritts\":\n",
    "        train_split, valid_split, _, _ = train_test_split(\n",
    "            processor.items,\n",
    "            [i[-1] for i in processor.items],\n",
    "            test_size=config[\"test_size\"],\n",
    "            random_state=42,\n",
    "            shuffle=True,\n",
    "        )\n",
    "    else:\n",
    "        train_split, valid_split = train_test_split(\n",
    "            processor.items,\n",
    "            test_size=config[\"test_size\"],\n",
    "            random_state=42,\n",
    "            shuffle=True,\n",
    "        )\n",
    "    logging.info(f\"Training items: {len(train_split)}\")\n",
    "    logging.info(f\"Validation items: {len(valid_split)}\")\n",
    "\n",
    "    get_utt_id = lambda x: os.path.split(x[1])[-1].split(\".\")[0]\n",
    "    train_utt_ids = [get_utt_id(x) for x in train_split]\n",
    "    valid_utt_ids = [get_utt_id(x) for x in valid_split]\n",
    "\n",
    "    # save train and valid utt_ids to track later\n",
    "    np.save(os.path.join(config[\"outdir\"], \"train_utt_ids.npy\"), train_utt_ids)\n",
    "    np.save(os.path.join(config[\"outdir\"], \"valid_utt_ids.npy\"), valid_utt_ids)\n",
    "\n",
    "    # define map iterator\n",
    "    def iterator_data(items_list):\n",
    "        for item in items_list:\n",
    "            yield processor.get_one_sample(item)\n",
    "\n",
    "    train_iterator_data = iterator_data(train_split)\n",
    "    valid_iterator_data = iterator_data(valid_split)\n",
    "\n",
    "    p = Pool(config[\"n_cpus\"])\n",
    "\n",
    "    # preprocess train files and get statistics for normalizing\n",
    "    partial_fn = partial(gen_audio_features, config=config)\n",
    "    train_map = p.imap_unordered(\n",
    "        partial_fn,\n",
    "        tqdm(train_iterator_data, total=len(train_split), desc=\"[Preprocessing train]\"),\n",
    "        chunksize=10,\n",
    "    )\n",
    "    # init scaler for multiple features\n",
    "    scaler_mel = StandardScaler(copy=False)\n",
    "    scaler_energy = StandardScaler(copy=False)\n",
    "    scaler_f0 = StandardScaler(copy=False)\n",
    "\n",
    "    id_to_remove = []\n",
    "    for result, mel, energy, f0, features in train_map:\n",
    "        if not result:\n",
    "            id_to_remove.append(features[\"utt_id\"])\n",
    "            continue\n",
    "        save_features_to_file(features, \"train\", config)\n",
    "        # partial fitting of scalers\n",
    "        if len(energy[energy != 0]) == 0 or len(f0[f0 != 0]) == 0:\n",
    "            id_to_remove.append(features[\"utt_id\"])\n",
    "            continue\n",
    "        # partial fitting of scalers\n",
    "        if len(energy[energy != 0]) == 0 or len(f0[f0 != 0]) == 0:\n",
    "            id_to_remove.append(features[\"utt_id\"])\n",
    "            continue\n",
    "        scaler_mel.partial_fit(mel)\n",
    "        scaler_energy.partial_fit(energy[energy != 0].reshape(-1, 1))\n",
    "        scaler_f0.partial_fit(f0[f0 != 0].reshape(-1, 1))\n",
    "\n",
    "    if len(id_to_remove) > 0:\n",
    "        np.save(\n",
    "            os.path.join(config[\"outdir\"], \"train_utt_ids.npy\"),\n",
    "            [i for i in train_utt_ids if i not in id_to_remove],\n",
    "        )\n",
    "        logging.info(\n",
    "            f\"removed {len(id_to_remove)} cause of too many outliers or bad mfa extraction\"\n",
    "        )\n",
    "\n",
    "    # save statistics to file\n",
    "    logging.info(\"Saving computed statistics.\")\n",
    "    scaler_list = [(scaler_mel, \"\"), (scaler_energy, \"_energy\"), (scaler_f0, \"_f0\")]\n",
    "    save_statistics_to_file(scaler_list, config)\n",
    "\n",
    "    # preprocess valid files\n",
    "    partial_fn = partial(gen_audio_features, config=config)\n",
    "    valid_map = p.imap_unordered(\n",
    "        partial_fn,\n",
    "        tqdm(valid_iterator_data, total=len(valid_split), desc=\"[Preprocessing valid]\"),\n",
    "        chunksize=10,\n",
    "    )\n",
    "    for *_, features in valid_map:\n",
    "        save_features_to_file(features, \"valid\", config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "executionInfo": {
     "elapsed": 313547,
     "status": "error",
     "timestamp": 1603068051951,
     "user": {
      "displayName": "이소연",
      "photoUrl": "",
      "userId": "16388319312927188329"
     },
     "user_tz": -540
    },
    "id": "agPj7AwkOoXm",
    "outputId": "58a1a6e3-527e-4a08-8091-1cecca1788f7",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "preprocess()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bCzCiUVWXq7I"
   },
   "source": [
    "### Normalizing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sdeyhlJ-OoXt"
   },
   "outputs": [],
   "source": [
    "# Normalizing \n",
    "def parse_and_config():\n",
    "    args = easydict.EasyDict({ \"rootdir\": './dump_test', \n",
    "                              \"outdir\": './dump_test', \n",
    "                              \"dataset\": 'kss', \n",
    "                              \"config\": \"./preprocess/kss_preprocess.yaml\", \n",
    "                              \"n_cpus\": 4, \n",
    "                              \"test_size\": 0.05,\n",
    "                              \"verbose\":0})\n",
    "      # set logger\n",
    "    FORMAT = \"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s\"\n",
    "    log_level = {0: logging.DEBUG, 1: logging.WARNING, 2: logging.ERROR}\n",
    "    logging.basicConfig(level=log_level[args.verbose], format=FORMAT)\n",
    "\n",
    "    # load config\n",
    "    config = yaml.load(open(args.config), Loader=yaml.Loader)\n",
    "    config.update(vars(args))\n",
    "    # config checks\n",
    "    assert config[\"format\"] == \"npy\", \"'npy' is the only supported format.\"\n",
    "    return config\n",
    "\n",
    "def normalize():\n",
    "    \"\"\"Normalize mel spectrogram with pre-computed statistics.\"\"\"\n",
    "    config = parse_and_config()\n",
    "    if config[\"format\"] == \"npy\":\n",
    "        # init scaler with saved values\n",
    "        scaler = StandardScaler()\n",
    "        scaler.mean_, scaler.scale_ = np.load(\n",
    "            os.path.join(config[\"outdir\"], \"stats.npy\")\n",
    "        )\n",
    "        scaler.n_features_in_ = config[\"num_mels\"]\n",
    "    else:\n",
    "        raise ValueError(\"'npy' is the only supported format.\")\n",
    "\n",
    "    # find all \"raw-feats\" files in both train and valid folders\n",
    "    glob_path = os.path.join(config[\"rootdir\"], \"**\", \"raw-feats\", \"*.npy\")\n",
    "    mel_raw_feats = glob.glob(glob_path, recursive=True)\n",
    "    logging.info(f\"Files to normalize: {len(mel_raw_feats)}\")\n",
    "\n",
    "    # check for output directories\n",
    "    os.makedirs(os.path.join(config[\"outdir\"], \"train\", \"norm-feats\"), exist_ok=True)\n",
    "    os.makedirs(os.path.join(config[\"outdir\"], \"valid\", \"norm-feats\"), exist_ok=True)\n",
    "\n",
    "    p = Pool(config[\"n_cpus\"])\n",
    "    partial_fn = partial(gen_normal_mel, scaler=scaler, config=config)\n",
    "    list(p.map(partial_fn, tqdm(mel_raw_feats, desc=\"[Normalizing]\")))\n",
    "\n",
    "\n",
    "def compute_statistics():\n",
    "    \"\"\"Compute mean / std statistics of some features for later normalization.\"\"\"\n",
    "    config = parse_and_config()\n",
    "\n",
    "    # find features files for the train split\n",
    "    glob_fn = lambda x: glob.glob(os.path.join(config[\"rootdir\"], \"train\", x, \"*.npy\"))\n",
    "    glob_mel = glob_fn(\"raw-feats\")\n",
    "    glob_f0 = glob_fn(\"raw-f0\")\n",
    "    glob_energy = glob_fn(\"raw-energies\")\n",
    "    assert (\n",
    "        len(glob_mel) == len(glob_f0) == len(glob_energy)\n",
    "    ), \"Features, f0 and energies have different files in training split.\"\n",
    "\n",
    "    logging.info(f\"Computing statistics for {len(glob_mel)} files.\")\n",
    "    # init scaler for multiple features\n",
    "    scaler_mel = StandardScaler(copy=False)\n",
    "    scaler_energy = StandardScaler(copy=False)\n",
    "    scaler_f0 = StandardScaler(copy=False)\n",
    "\n",
    "    for mel, f0, energy in tqdm(\n",
    "        zip(glob_mel, glob_f0, glob_energy), total=len(glob_mel)\n",
    "    ):\n",
    "        # remove outliers\n",
    "        energy = remove_outlier(np.load(energy))\n",
    "        f0 = remove_outlier(np.load(f0))\n",
    "        # partial fitting of scalers\n",
    "        scaler_mel.partial_fit(np.load(mel))\n",
    "        scaler_energy.partial_fit(energy[energy != 0].reshape(-1, 1))\n",
    "        scaler_f0.partial_fit(f0[f0 != 0].reshape(-1, 1))\n",
    "\n",
    "    # save statistics to file\n",
    "    logging.info(\"Saving computed statistics.\")\n",
    "    scaler_list = [(scaler_mel, \"\"), (scaler_energy, \"_energy\"), (scaler_f0, \"_f0\")]\n",
    "    save_statistics_to_file(scaler_list, config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "executionInfo": {
     "elapsed": 1476,
     "status": "ok",
     "timestamp": 1603035477193,
     "user": {
      "displayName": "이소연",
      "photoUrl": "",
      "userId": "16388319312927188329"
     },
     "user_tz": -540
    },
    "id": "zx1iiSkvOoYT",
    "outputId": "2e1d7974-0dd9-4e9d-aded-a662639934fe"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-10-18 15:37:56,077 (<ipython-input-54-191f8d40068d>:37) INFO: Files to normalize: 120\n",
      "[Normalizing]: 100%|██████████| 120/120 [00:00<00:00, 15018.54it/s]\n"
     ]
    }
   ],
   "source": [
    "normalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cEq1YinjOoax"
   },
   "source": [
    "## 모델 구현"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1GS9DAfdOoa2"
   },
   "source": [
    "### 1. Basic Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yITj-ogCOoa5"
   },
   "outputs": [],
   "source": [
    "\"\"\"Tacotron-2 Modules.\"\"\"\n",
    "\n",
    "import collections\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow_addons.seq2seq import BahdanauAttention, Decoder, Sampler\n",
    "from tensorflow_tts.utils import dynamic_decode\n",
    "\n",
    "\n",
    "def get_initializer(initializer_range=0.02):\n",
    "    \"\"\"Creates a `tf.initializers.truncated_normal` with the given range.\n",
    "    Args:\n",
    "        initializer_range: float, initializer range for stddev.\n",
    "    Returns:\n",
    "        TruncatedNormal initializer with stddev = `initializer_range`.\n",
    "    \"\"\"\n",
    "    return tf.keras.initializers.TruncatedNormal(stddev=initializer_range)\n",
    "\n",
    "\n",
    "def gelu(x):\n",
    "    \"\"\"Gaussian Error Linear unit.\"\"\"\n",
    "    cdf = 0.5 * (1.0 + tf.math.erf(x / tf.math.sqrt(2.0)))\n",
    "    return x * cdf\n",
    "\n",
    "\n",
    "def gelu_new(x):\n",
    "    \"\"\"Smoother gaussian Error Linear Unit.\"\"\"\n",
    "    cdf = 0.5 * (1.0 + tf.tanh((np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))\n",
    "    return x * cdf\n",
    "\n",
    "\n",
    "def swish(x):\n",
    "    \"\"\"Swish activation function.\"\"\"\n",
    "    return x * tf.sigmoid(x)\n",
    "\n",
    "\n",
    "def mish(x):\n",
    "    return x * tf.math.tanh(tf.math.softplus(x))\n",
    "\n",
    "\n",
    "ACT2FN = {\n",
    "    \"identity\": tf.keras.layers.Activation(\"linear\"),\n",
    "    \"tanh\": tf.keras.layers.Activation(\"tanh\"),\n",
    "    \"gelu\": tf.keras.layers.Activation(gelu),\n",
    "    \"relu\": tf.keras.activations.relu,\n",
    "    \"swish\": tf.keras.layers.Activation(swish),\n",
    "    \"gelu_new\": tf.keras.layers.Activation(gelu_new),\n",
    "    \"mish\": tf.keras.layers.Activation(mish),\n",
    "}\n",
    "\n",
    "\n",
    "\n",
    "###############################################\n",
    "############### Embedding 관련 ################\n",
    "###############################################\n",
    "\n",
    "class TFEmbedding(tf.keras.layers.Embedding):\n",
    "    \"\"\"Faster version of embedding.\"\"\"\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        inputs = tf.cast(tf.expand_dims(inputs, -1), tf.int32)\n",
    "        outputs = tf.gather_nd(self.embeddings, inputs)\n",
    "        return outputs\n",
    "    \n",
    "class TFTacotronConvBatchNorm(tf.keras.layers.Layer):\n",
    "    \"\"\"Tacotron-2 Convolutional Batchnorm module.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, filters, kernel_size, dropout_rate, activation=None, name_idx=None\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.conv1d = tf.keras.layers.Conv1D(\n",
    "            filters,\n",
    "            kernel_size,\n",
    "            kernel_initializer=get_initializer(0.02),\n",
    "            padding=\"same\",\n",
    "            name=\"conv_._{}\".format(name_idx),\n",
    "        )\n",
    "        self.norm = tf.keras.layers.experimental.SyncBatchNormalization(\n",
    "            axis=-1, name=\"batch_norm_._{}\".format(name_idx)\n",
    "        )\n",
    "        self.dropout = tf.keras.layers.Dropout(\n",
    "            rate=dropout_rate, name=\"dropout_._{}\".format(name_idx)\n",
    "        )\n",
    "        self.act = ACT2FN[activation]\n",
    "\n",
    "    def call(self, inputs, training=False):\n",
    "        outputs = self.conv1d(inputs)\n",
    "        outputs = self.norm(outputs, training=training)\n",
    "        outputs = self.act(outputs)\n",
    "        outputs = self.dropout(outputs, training=training)\n",
    "        return outputs\n",
    "\n",
    "class TFTacotronEmbeddings(tf.keras.layers.Layer):\n",
    "    \"\"\"Construct character/phoneme/positional/speaker embeddings.\"\"\"\n",
    "\n",
    "    def __init__(self, config, **kwargs):\n",
    "        \"\"\"Init variables.\"\"\"\n",
    "        super().__init__(**kwargs)\n",
    "        self.vocab_size = config.vocab_size\n",
    "        self.embedding_hidden_size = config.embedding_hidden_size\n",
    "        self.initializer_range = config.initializer_range\n",
    "        self.config = config\n",
    "\n",
    "        if config.n_speakers > 1:\n",
    "            self.speaker_embeddings = TFEmbedding(\n",
    "                config.n_speakers,\n",
    "                config.embedding_hidden_size,\n",
    "                embeddings_initializer=get_initializer(self.initializer_range),\n",
    "                name=\"speaker_embeddings\",\n",
    "            )\n",
    "            self.speaker_fc = tf.keras.layers.Dense(\n",
    "                units=config.embedding_hidden_size, name=\"speaker_fc\"\n",
    "            )\n",
    "\n",
    "        self.LayerNorm = tf.keras.layers.LayerNormalization(\n",
    "            epsilon=config.layer_norm_eps, name=\"LayerNorm\"\n",
    "        )\n",
    "        self.dropout = tf.keras.layers.Dropout(config.embedding_dropout_prob)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        \"\"\"Build shared character/phoneme embedding layers.\"\"\"\n",
    "        with tf.name_scope(\"character_embeddings\"):\n",
    "            self.character_embeddings = self.add_weight(\n",
    "                \"weight\",\n",
    "                shape=[self.vocab_size, self.embedding_hidden_size],\n",
    "                initializer=get_initializer(self.initializer_range),\n",
    "            )\n",
    "        super().build(input_shape)\n",
    "\n",
    "    def call(self, inputs, training=False):\n",
    "        \"\"\"Get character embeddings of inputs.\n",
    "        Args:\n",
    "            1. character, Tensor (int32) shape [batch_size, length].\n",
    "            2. speaker_id, Tensor (int32) shape [batch_size]\n",
    "        Returns:\n",
    "            Tensor (float32) shape [batch_size, length, embedding_size].\n",
    "        \"\"\"\n",
    "        return self._embedding(inputs, training=training)\n",
    "\n",
    "    def _embedding(self, inputs, training=False):\n",
    "        \"\"\"Applies embedding based on inputs tensor.\"\"\"\n",
    "        input_ids, speaker_ids = inputs\n",
    "\n",
    "        # create embeddings\n",
    "        inputs_embeds = tf.gather(self.character_embeddings, input_ids)\n",
    "        embeddings = inputs_embeds\n",
    "\n",
    "        if self.config.n_speakers > 1:\n",
    "            speaker_embeddings = self.speaker_embeddings(speaker_ids)\n",
    "            speaker_features = tf.math.softplus(self.speaker_fc(speaker_embeddings))\n",
    "            # extended speaker embeddings\n",
    "            extended_speaker_features = speaker_features[:, tf.newaxis, :]\n",
    "            # sum all embedding\n",
    "            embeddings += extended_speaker_features\n",
    "\n",
    "        # apply layer-norm and dropout for embeddings.\n",
    "        embeddings = self.LayerNorm(embeddings)\n",
    "        embeddings = self.dropout(embeddings, training=training)\n",
    "\n",
    "        return embeddings\n",
    "    \n",
    "##################################################\n",
    "##################################################\n",
    "\n",
    "class TrainingSampler(Sampler):\n",
    "    \"\"\"Training sampler for Seq2Seq training.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, config,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.config = config\n",
    "        # create schedule factor.\n",
    "        # the input of a next decoder cell is calculated by formular:\n",
    "        # next_inputs = ratio * prev_groundtruth_outputs + (1.0 - ratio) * prev_predicted_outputs.\n",
    "        self._ratio = tf.constant(1.0, dtype=tf.float32)\n",
    "        self._reduction_factor = self.config.reduction_factor\n",
    "\n",
    "    def setup_target(self, targets, mel_lengths):\n",
    "        \"\"\"Setup ground-truth mel outputs for decoder.\"\"\"\n",
    "        self.mel_lengths = mel_lengths\n",
    "        self.set_batch_size(tf.shape(targets)[0])\n",
    "        self.targets = targets[\n",
    "            :, self._reduction_factor - 1 :: self._reduction_factor, :\n",
    "        ]\n",
    "        self.max_lengths = tf.tile([tf.shape(self.targets)[1]], [self._batch_size])\n",
    "\n",
    "    @property\n",
    "    def batch_size(self):\n",
    "        return self._batch_size\n",
    "\n",
    "    @property\n",
    "    def sample_ids_shape(self):\n",
    "        return tf.TensorShape([])\n",
    "\n",
    "    @property\n",
    "    def sample_ids_dtype(self):\n",
    "        return tf.int32\n",
    "\n",
    "    @property\n",
    "    def reduction_factor(self):\n",
    "        return self._reduction_factor\n",
    "\n",
    "    def initialize(self):\n",
    "        \"\"\"Return (Finished, next_inputs).\"\"\"\n",
    "        return (\n",
    "            tf.tile([False], [self._batch_size]),\n",
    "            tf.tile([[0.0]], [self._batch_size, self.config.n_mels]),\n",
    "        )\n",
    "\n",
    "    def sample(self, time, outputs, state):\n",
    "        return tf.tile([0], [self._batch_size])\n",
    "\n",
    "    def next_inputs(self, time, outputs, state, sample_ids, **kwargs):\n",
    "        finished = time + 1 >= self.max_lengths\n",
    "        next_inputs = (\n",
    "            self._ratio * self.targets[:, time, :]\n",
    "            + (1.0 - self._ratio) * outputs[:, -self.config.n_mels :]\n",
    "        )\n",
    "        next_state = state\n",
    "        return (finished, next_inputs, next_state)\n",
    "\n",
    "    def set_batch_size(self, batch_size):\n",
    "        self._batch_size = batch_size\n",
    "\n",
    "\n",
    "class TestingSampler(TrainingSampler):\n",
    "    \"\"\"Testing sampler for Seq2Seq training.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, config,\n",
    "    ):\n",
    "        super().__init__(config)\n",
    "\n",
    "    def next_inputs(self, time, outputs, state, sample_ids, **kwargs):\n",
    "        stop_token_prediction = kwargs.get(\"stop_token_prediction\")\n",
    "        stop_token_prediction = tf.nn.sigmoid(stop_token_prediction)\n",
    "        finished = tf.cast(tf.round(stop_token_prediction), tf.bool)\n",
    "        finished = tf.reduce_all(finished)\n",
    "        next_inputs = outputs[:, -self.config.n_mels :]\n",
    "        next_state = state\n",
    "        return (finished, next_inputs, next_state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ch94cuOwOobO"
   },
   "source": [
    "### Encoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oABc7qulOobc"
   },
   "source": [
    "\n",
    "![image.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "23j5PgNeOobm"
   },
   "outputs": [],
   "source": [
    "class TFTacotronEncoderConvs(tf.keras.layers.Layer):\n",
    "    \"\"\"Tacotron-2 Encoder Convolutional Batchnorm module.\"\"\"\n",
    "\n",
    "    def __init__(self, config, **kwargs):\n",
    "        \"\"\"Init variables.\"\"\"\n",
    "        super().__init__(**kwargs)\n",
    "        self.conv_batch_norm = []\n",
    "        for i in range(config.n_conv_encoder):\n",
    "            conv = TFTacotronConvBatchNorm(\n",
    "                filters=config.encoder_conv_filters,\n",
    "                kernel_size=config.encoder_conv_kernel_sizes,\n",
    "                activation=config.encoder_conv_activation,\n",
    "                dropout_rate=config.encoder_conv_dropout_rate,\n",
    "                name_idx=i,\n",
    "            )\n",
    "            self.conv_batch_norm.append(conv)\n",
    "\n",
    "    def call(self, inputs, training=False):\n",
    "        \"\"\"Call logic.\"\"\"\n",
    "        outputs = inputs\n",
    "        for conv in self.conv_batch_norm:\n",
    "            outputs = conv(outputs, training=training)\n",
    "        return outputs\n",
    "\n",
    "\n",
    "class TFTacotronEncoder(tf.keras.layers.Layer):\n",
    "    \"\"\"Tacotron-2 Encoder.\"\"\"\n",
    "\n",
    "    def __init__(self, config, **kwargs):\n",
    "        \"\"\"Init variables.\"\"\"\n",
    "        super().__init__(**kwargs)\n",
    "        self.embeddings = TFTacotronEmbeddings(config, name=\"embeddings\")\n",
    "        self.convbn = TFTacotronEncoderConvs(config, name=\"conv_batch_norm\")\n",
    "        self.bilstm = tf.keras.layers.Bidirectional(\n",
    "            tf.keras.layers.LSTM(\n",
    "                units=config.encoder_lstm_units, return_sequences=True\n",
    "            ),\n",
    "            name=\"bilstm\",\n",
    "        )\n",
    "\n",
    "        ## Speaker Embedding 부분 ## \n",
    "        if config.n_speakers > 1:\n",
    "            self.encoder_speaker_embeddings = TFEmbedding(\n",
    "                config.n_speakers,\n",
    "                config.embedding_hidden_size,\n",
    "                embeddings_initializer=get_initializer(config.initializer_range),\n",
    "                name=\"encoder_speaker_embeddings\",\n",
    "            )\n",
    "            self.encoder_speaker_fc = tf.keras.layers.Dense(\n",
    "                units=config.encoder_lstm_units * 2, name=\"encoder_speaker_fc\"\n",
    "            )\n",
    "\n",
    "        self.config = config\n",
    "\n",
    "    def call(self, inputs, training=False):\n",
    "        \n",
    "        \"\"\"Call logic\n",
    "        \n",
    "            Encoder: Embedding Table => Encoder Conv => Encoder RNN 구조  \n",
    "            Encoder Conv: (1d Conv -> 배치 Normalization -> activation -> dropout)\n",
    "            이 Conv 레이어를 여러개 쌓음\n",
    "        \"\"\"\n",
    "        input_ids, speaker_ids, input_mask = inputs\n",
    "\n",
    "        # create embedding and mask them since we sum\n",
    "        # speaker embedding to all character embedding.\n",
    "        input_embeddings = self.embeddings([input_ids, speaker_ids], training=training)\n",
    "\n",
    "        # pass embeddings to convolution batch norm\n",
    "        conv_outputs = self.convbn(input_embeddings, training=training)\n",
    "\n",
    "        # bi-lstm. 인코더는 Bi-Directional LSTM 사용\n",
    "        outputs = self.bilstm(conv_outputs, mask=input_mask)\n",
    "\n",
    "        if self.config.n_speakers > 1:\n",
    "            encoder_speaker_embeddings = self.encoder_speaker_embeddings(speaker_ids)\n",
    "            encoder_speaker_features = tf.math.softplus(\n",
    "                self.encoder_speaker_fc(encoder_speaker_embeddings)\n",
    "            )\n",
    "            # extended encoderspeaker embeddings\n",
    "            extended_encoder_speaker_features = encoder_speaker_features[\n",
    "                :, tf.newaxis, :\n",
    "            ]\n",
    "            # sum to encoder outputs\n",
    "            outputs += extended_encoder_speaker_features\n",
    "\n",
    "        return outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4SoQzN1VOobv"
   },
   "source": [
    "### 3. Attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-Ovge6RYOob5"
   },
   "source": [
    "PARAMS\n",
    "----------------\n",
    "- memory(X): 인코더 output\n",
    "- mask: binary mask for padded data\n",
    "- query(h): 디코더 output (batch, n_mel_channels * n_frames_per_step)\n",
    "- energy 디코더와 인코더를 가지고 위치 정보 계산하는 것( e에 softmax를 취하면 attention weight이 나옴) \n",
    "\n",
    "\n",
    "Return\n",
    "----------------\n",
    "- alignment(y:location): (batch, max_time) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ew3GMe0XOob7"
   },
   "source": [
    "![image.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rtA7WmjuOob8"
   },
   "source": [
    "![image.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "E3G3wUevOob-"
   },
   "outputs": [],
   "source": [
    "class TFTacotronLocationSensitiveAttention(BahdanauAttention):\n",
    "    \"\"\"Tacotron-2 Location Sensitive Attention module.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        config,\n",
    "        memory,\n",
    "        mask_encoder=True,\n",
    "        memory_sequence_length=None,\n",
    "        is_cumulate=True,\n",
    "    ):\n",
    "        \"\"\"Init variables.\"\"\"\n",
    "        memory_length = memory_sequence_length if (mask_encoder is True) else None\n",
    "        super().__init__(\n",
    "            units=config.attention_dim,\n",
    "            memory=memory,\n",
    "            memory_sequence_length=memory_length,\n",
    "            probability_fn=\"softmax\",\n",
    "            name=\"LocationSensitiveAttention\",\n",
    "        )\n",
    "        self.location_convolution = tf.keras.layers.Conv1D(\n",
    "            filters=config.attention_filters,\n",
    "            kernel_size=config.attention_kernel,\n",
    "            padding=\"same\",\n",
    "            use_bias=False,\n",
    "            name=\"location_conv\",\n",
    "        )\n",
    "        self.location_layer = tf.keras.layers.Dense(\n",
    "            units=config.attention_dim, use_bias=False, name=\"location_layer\"\n",
    "        )\n",
    "\n",
    "        self.v = tf.keras.layers.Dense(1, use_bias=True, name=\"scores_attention\")\n",
    "        self.config = config\n",
    "        self.is_cumulate = is_cumulate\n",
    "        self.use_window = False\n",
    "\n",
    "    def setup_window(self, win_front=2, win_back=4):\n",
    "        self.win_front = tf.constant(win_front, tf.int32)\n",
    "        self.win_back = tf.constant(win_back, tf.int32)\n",
    "\n",
    "        self._indices = tf.expand_dims(tf.range(tf.shape(self.keys)[1]), 0)\n",
    "        self._indices = tf.tile(\n",
    "            self._indices, [tf.shape(self.keys)[0], 1]\n",
    "        )  # [batch_size, max_time]\n",
    "\n",
    "        self.use_window = True\n",
    "\n",
    "    def _compute_window_mask(self, max_alignments):\n",
    "        \"\"\"Compute window mask for inference.\n",
    "        Args:\n",
    "            max_alignments (int): [batch_size]\n",
    "        \"\"\"\n",
    "        expanded_max_alignments = tf.expand_dims(max_alignments, 1)  # [batch_size, 1]\n",
    "        low = expanded_max_alignments - self.win_front\n",
    "        high = expanded_max_alignments + self.win_back\n",
    "        mlow = tf.cast((self._indices < low), tf.float32)\n",
    "        mhigh = tf.cast((self._indices > high), tf.float32)\n",
    "        mask = mlow + mhigh\n",
    "        return mask  # [batch_size, max_length]\n",
    "\n",
    "    def __call__(self, inputs, training=False):\n",
    "        query, state, prev_max_alignments = inputs\n",
    "\n",
    "        processed_query = self.query_layer(query) if self.query_layer else query\n",
    "        processed_query = tf.expand_dims(processed_query, 1)\n",
    "\n",
    "        expanded_alignments = tf.expand_dims(state, axis=2)\n",
    "        f = self.location_convolution(expanded_alignments)\n",
    "        processed_location_features = self.location_layer(f)\n",
    "\n",
    "        energy = self._location_sensitive_score(\n",
    "            processed_query, processed_location_features, self.keys\n",
    "        )\n",
    "\n",
    "        # mask energy on inference steps.\n",
    "        if self.use_window is True:\n",
    "            window_mask = self._compute_window_mask(prev_max_alignments)\n",
    "            energy = energy + window_mask * -1e20\n",
    "\n",
    "        alignments = self.probability_fn(energy, state)\n",
    "\n",
    "        if self.is_cumulate:\n",
    "            state = alignments + state\n",
    "        else:\n",
    "            state = alignments\n",
    "\n",
    "        expanded_alignments = tf.expand_dims(alignments, 2)\n",
    "        context = tf.reduce_sum(expanded_alignments * self.values, 1)\n",
    "\n",
    "        return context, alignments, state\n",
    "\n",
    "    def _location_sensitive_score(self, W_query, W_fil, W_keys):\n",
    "        \"\"\"Calculate location sensitive energy.\"\"\"\n",
    "        return tf.squeeze(self.v(tf.nn.tanh(W_keys + W_query + W_fil)), -1)\n",
    "\n",
    "    def get_initial_state(self, batch_size, size):\n",
    "        \"\"\"Get initial alignments.\"\"\"\n",
    "        return tf.zeros(shape=[batch_size, size], dtype=tf.float32)\n",
    "\n",
    "    def get_initial_context(self, batch_size):\n",
    "        \"\"\"Get initial attention.\"\"\"\n",
    "        return tf.zeros(\n",
    "            shape=[batch_size, self.config.encoder_lstm_units * 2], dtype=tf.float32\n",
    "        )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PAnY2EVLOocL"
   },
   "source": [
    "### 4. Decoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8D36x8PAOocN"
   },
   "source": [
    "![image.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xZzO6Bj6OocO"
   },
   "outputs": [],
   "source": [
    "class TFTacotronPrenet(tf.keras.layers.Layer):\n",
    "    \"\"\"Tacotron-2 prenet.\n",
    "    \n",
    "    Prenet은 Linear들을 여러개 쌓는 형태 \n",
    "    각각의 Linear는 dropout을 거침 \n",
    "    \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, config, **kwargs):\n",
    "        \"\"\"Init variables.\"\"\"\n",
    "        super().__init__(**kwargs)\n",
    "        self.prenet_dense = [\n",
    "            tf.keras.layers.Dense(\n",
    "                units=config.prenet_units,\n",
    "                activation=ACT2FN[config.prenet_activation],\n",
    "                name=\"dense_._{}\".format(i),\n",
    "            )\n",
    "            for i in range(config.n_prenet_layers)\n",
    "        ]\n",
    "        self.dropout = tf.keras.layers.Dropout(\n",
    "            rate=config.prenet_dropout_rate, name=\"dropout\"\n",
    "        )\n",
    "\n",
    "    def call(self, inputs, training=False):\n",
    "        \"\"\"Call logic.\"\"\"\n",
    "        outputs = inputs\n",
    "        for layer in self.prenet_dense:\n",
    "            outputs = layer(outputs)\n",
    "            outputs = self.dropout(outputs, training=True)\n",
    "        return outputs\n",
    "\n",
    "\n",
    "class TFTacotronPostnet(tf.keras.layers.Layer):\n",
    "    \"\"\"Tacotron-2 postnet.\n",
    "    \n",
    "    1d Conv를 쭉 쌓은 형태 \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, config, **kwargs):\n",
    "        \"\"\"Init variables.\"\"\"\n",
    "        super().__init__(**kwargs)\n",
    "        self.conv_batch_norm = []\n",
    "        for i in range(config.n_conv_postnet):\n",
    "            conv = TFTacotronConvBatchNorm(\n",
    "                filters=config.postnet_conv_filters,\n",
    "                kernel_size=config.postnet_conv_kernel_sizes,\n",
    "                dropout_rate=config.postnet_dropout_rate,\n",
    "                activation=\"identity\" if i + 1 == config.n_conv_postnet else \"tanh\",\n",
    "                name_idx=i,\n",
    "            )\n",
    "            self.conv_batch_norm.append(conv)            \n",
    "# 마지막 Conv 전까지는 activation f이 Tanh \n",
    "# 마지막 layer -> linear (mel을 regression할 수 있어야 하므로!)\n",
    "\n",
    "    def call(self, inputs, training=False):\n",
    "        \"\"\"Call logic.\"\"\"\n",
    "        outputs = inputs\n",
    "        for _, conv in enumerate(self.conv_batch_norm):\n",
    "            outputs = conv(outputs, training=training)\n",
    "        return outputs\n",
    "\n",
    "\n",
    "TFTacotronDecoderCellState = collections.namedtuple(\n",
    "    \"TFTacotronDecoderCellState\",\n",
    "    [\n",
    "        \"attention_lstm_state\",\n",
    "        \"decoder_lstms_state\",\n",
    "        \"context\",\n",
    "        \"time\",\n",
    "        \"state\",\n",
    "        \"alignment_history\",\n",
    "        \"max_alignments\",\n",
    "    ],\n",
    ")\n",
    "\n",
    "TFDecoderOutput = collections.namedtuple(\n",
    "    \"TFDecoderOutput\", (\"mel_output\", \"token_output\", \"sample_id\")\n",
    ")\n",
    "\n",
    "\n",
    "class TFTacotronDecoderCell(tf.keras.layers.AbstractRNNCell):\n",
    "    \"\"\"Tacotron-2 custom decoder cell.\"\"\"\n",
    "\n",
    "    def __init__(self, config, training, enable_tflite_convertible=False, **kwargs):\n",
    "        \"\"\"Init variables.\"\"\"\n",
    "        super().__init__(**kwargs)\n",
    "        self.training = training\n",
    "        self.enable_tflite_convertible = enable_tflite_convertible\n",
    "        self.prenet = TFTacotronPrenet(config, name=\"prenet\")\n",
    "\n",
    "        # define lstm cell on decoder.\n",
    "        # TODO(@dathudeptrai) switch to zone-out lstm.\n",
    "        self.attention_lstm = tf.keras.layers.LSTMCell(\n",
    "            units=config.decoder_lstm_units, name=\"attention_lstm_cell\"\n",
    "        )\n",
    "        lstm_cells = []\n",
    "        for i in range(config.n_lstm_decoder):\n",
    "            lstm_cell = tf.keras.layers.LSTMCell(\n",
    "                units=config.decoder_lstm_units, name=\"lstm_cell_._{}\".format(i)\n",
    "            )\n",
    "            lstm_cells.append(lstm_cell)\n",
    "        self.decoder_lstms = tf.keras.layers.StackedRNNCells(\n",
    "            lstm_cells, name=\"decoder_lstms\"\n",
    "        )\n",
    "\n",
    "        # define attention layer.\n",
    "        if config.attention_type == \"lsa\":\n",
    "            # create location-sensitive attention.\n",
    "            self.attention_layer = TFTacotronLocationSensitiveAttention(\n",
    "                config,\n",
    "                memory=None,\n",
    "                mask_encoder=True,\n",
    "                memory_sequence_length=None,\n",
    "                is_cumulate=True,\n",
    "            )\n",
    "        else:\n",
    "            raise ValueError(\"Only lsa (location-sensitive attention) is supported\")\n",
    "\n",
    "        # frame, stop projection layer.\n",
    "        self.frame_projection = tf.keras.layers.Dense(\n",
    "            units=config.n_mels * config.reduction_factor, name=\"frame_projection\"\n",
    "        )\n",
    "        self.stop_projection = tf.keras.layers.Dense(\n",
    "            units=config.reduction_factor, name=\"stop_projection\"\n",
    "        )\n",
    "\n",
    "        self.config = config\n",
    "\n",
    "    def set_alignment_size(self, alignment_size):\n",
    "        self.alignment_size = alignment_size\n",
    "\n",
    "    @property\n",
    "    def output_size(self):\n",
    "        \"\"\"Return output (mel) size.\"\"\"\n",
    "        return self.frame_projection.units\n",
    "\n",
    "    @property\n",
    "    def state_size(self):\n",
    "        \"\"\"Return hidden state size.\"\"\"\n",
    "        return TFTacotronDecoderCellState(\n",
    "            attention_lstm_state=self.attention_lstm.state_size,\n",
    "            decoder_lstms_state=self.decoder_lstms.state_size,\n",
    "            time=tf.TensorShape([]),\n",
    "            attention=self.config.attention_dim,\n",
    "            state=self.alignment_size,\n",
    "            alignment_history=(),\n",
    "            max_alignments=tf.TensorShape([1]),\n",
    "        )\n",
    "\n",
    "    def get_initial_state(self, batch_size):\n",
    "        \"\"\"Get initial states.\"\"\"\n",
    "        initial_attention_lstm_cell_states = self.attention_lstm.get_initial_state(\n",
    "            None, batch_size, dtype=tf.float32\n",
    "        )\n",
    "        initial_decoder_lstms_cell_states = self.decoder_lstms.get_initial_state(\n",
    "            None, batch_size, dtype=tf.float32\n",
    "        )\n",
    "        initial_context = tf.zeros(\n",
    "            shape=[batch_size, self.config.encoder_lstm_units * 2], dtype=tf.float32\n",
    "        )\n",
    "        initial_state = self.attention_layer.get_initial_state(\n",
    "            batch_size, size=self.alignment_size\n",
    "        )\n",
    "        if self.enable_tflite_convertible:\n",
    "            initial_alignment_history = ()\n",
    "        else:\n",
    "            initial_alignment_history = tf.TensorArray(\n",
    "                dtype=tf.float32, size=0, dynamic_size=True\n",
    "            )\n",
    "        return TFTacotronDecoderCellState(\n",
    "            attention_lstm_state=initial_attention_lstm_cell_states,\n",
    "            decoder_lstms_state=initial_decoder_lstms_cell_states,\n",
    "            time=tf.zeros([], dtype=tf.int32),\n",
    "            context=initial_context,\n",
    "            state=initial_state,\n",
    "            alignment_history=initial_alignment_history,\n",
    "            max_alignments=tf.zeros([batch_size], dtype=tf.int32),\n",
    "        )\n",
    "\n",
    "    def call(self, inputs, states):\n",
    "        \"\"\"Call logic.\"\"\"\n",
    "        decoder_input = inputs\n",
    "\n",
    "        # 1. apply prenet for decoder_input.\n",
    "        prenet_out = self.prenet(\n",
    "            decoder_input, training=self.training\n",
    "        )  # [batch_size, dim]\n",
    "\n",
    "        # 2. concat prenet_out and prev context vector\n",
    "        # then use it as input of attention lstm layer.\n",
    "        # 전 타임스텝의 decoder_output이 decoder_input으로 들어가고, attention_context 벡터의 결과를 concat해서 사용 \n",
    "        attention_lstm_input = tf.concat([prenet_out, states.context], axis=-1)\n",
    "        attention_lstm_output, next_attention_lstm_state = self.attention_lstm(\n",
    "            attention_lstm_input, states.attention_lstm_state\n",
    "        )\n",
    "\n",
    "        # 3. compute context, alignment and cumulative alignment.\n",
    "        # Cumulative alignment: 타코트론에서는 attention weight들이 나올때마다 지속적으로 더해줘서 최대한 attention이 우상승(monotonic)하게 만들어주는 방식\n",
    "        prev_state = states.state\n",
    "        if not self.enable_tflite_convertible:\n",
    "            prev_alignment_history = states.alignment_history\n",
    "        prev_max_alignments = states.max_alignments\n",
    "        context, alignments, state = self.attention_layer(\n",
    "            [attention_lstm_output, prev_state, prev_max_alignments],\n",
    "            training=self.training,\n",
    "        )\n",
    "\n",
    "        # 4. run decoder lstm(s)\n",
    "        decoder_lstms_input = tf.concat([attention_lstm_output, context], axis=-1)\n",
    "        decoder_lstms_output, next_decoder_lstms_state = self.decoder_lstms(\n",
    "            decoder_lstms_input, states.decoder_lstms_state\n",
    "        )\n",
    "\n",
    "        # 5. compute frame feature and stop token.\n",
    "        #mel을 뽑는 linear projection과 stop token projection을 할 때 모두 decoder lstm 값에 decoder hidden과 attention context벡터의 concat을 넣어줌\n",
    "        projection_inputs = tf.concat([decoder_lstms_output, context], axis=-1)\n",
    "        decoder_outputs = self.frame_projection(projection_inputs)\n",
    "\n",
    "        stop_inputs = tf.concat([decoder_lstms_output, decoder_outputs], axis=-1)\n",
    "        stop_tokens = self.stop_projection(stop_inputs)\n",
    "\n",
    "        \n",
    "        # 6. save alignment history to visualize.\n",
    "        if self.enable_tflite_convertible:\n",
    "            alignment_history = ()\n",
    "        else:\n",
    "            alignment_history = prev_alignment_history.write(states.time, alignments)\n",
    "\n",
    "        # 7. return new states.\n",
    "        new_states = TFTacotronDecoderCellState(\n",
    "            attention_lstm_state=next_attention_lstm_state,\n",
    "            decoder_lstms_state=next_decoder_lstms_state,\n",
    "            time=states.time + 1,\n",
    "            context=context,\n",
    "            state=state,\n",
    "            alignment_history=alignment_history,\n",
    "            max_alignments=tf.argmax(alignments, -1, output_type=tf.int32),\n",
    "        )\n",
    "\n",
    "        return (decoder_outputs, stop_tokens), new_states\n",
    "        # 최종: mel, stop token 결과, attention_weight(align 관련 정보) return\n",
    "\n",
    "class TFTacotronDecoder(Decoder):\n",
    "    \"\"\"Tacotron-2 Decoder.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        decoder_cell,\n",
    "        decoder_sampler,\n",
    "        output_layer=None,\n",
    "        enable_tflite_convertible=False,\n",
    "    ):\n",
    "        \"\"\"Initial variables.\"\"\"\n",
    "        self.cell = decoder_cell\n",
    "        self.sampler = decoder_sampler\n",
    "        self.output_layer = output_layer\n",
    "        self.enable_tflite_convertible = enable_tflite_convertible\n",
    "\n",
    "    def setup_decoder_init_state(self, decoder_init_state):\n",
    "        self.initial_state = decoder_init_state\n",
    "\n",
    "    def initialize(self, **kwargs):\n",
    "        return self.sampler.initialize() + (self.initial_state,)\n",
    "\n",
    "    @property\n",
    "    def output_size(self):\n",
    "        return TFDecoderOutput(\n",
    "            mel_output=tf.nest.map_structure(\n",
    "                lambda shape: tf.TensorShape(shape), self.cell.output_size\n",
    "            ),\n",
    "            token_output=tf.TensorShape(self.sampler.reduction_factor),\n",
    "            sample_id=tf.TensorShape([1])\n",
    "            if self.enable_tflite_convertible\n",
    "            else self.sampler.sample_ids_shape,  # tf.TensorShape([])\n",
    "        )\n",
    "\n",
    "    @property\n",
    "    def output_dtype(self):\n",
    "        return TFDecoderOutput(tf.float32, tf.float32, self.sampler.sample_ids_dtype)\n",
    "\n",
    "    @property\n",
    "    def batch_size(self):\n",
    "        return self.sampler._batch_size\n",
    "\n",
    "    def step(self, time, inputs, state, training=False):\n",
    "        (mel_outputs, stop_tokens), cell_state = self.cell(\n",
    "            inputs, state, training=training\n",
    "        )\n",
    "        if self.output_layer is not None:\n",
    "            mel_outputs = self.output_layer(mel_outputs)\n",
    "        sample_ids = self.sampler.sample(\n",
    "            time=time, outputs=mel_outputs, state=cell_state\n",
    "        )\n",
    "        (finished, next_inputs, next_state) = self.sampler.next_inputs(\n",
    "            time=time,\n",
    "            outputs=mel_outputs,\n",
    "            state=cell_state,\n",
    "            sample_ids=sample_ids,\n",
    "            stop_token_prediction=stop_tokens,\n",
    "        )\n",
    "\n",
    "        outputs = TFDecoderOutput(mel_outputs, stop_tokens, sample_ids)\n",
    "        return (outputs, next_state, next_inputs, finished)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gy62wOeAOocc"
   },
   "source": [
    "### 5. Tacotron2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "q65OJG9KOocd"
   },
   "outputs": [],
   "source": [
    "class TFTacotron2(tf.keras.Model):\n",
    "    \"\"\"Tensorflow tacotron-2 model.\"\"\"\n",
    "\n",
    "    def __init__(self, config, **kwargs):\n",
    "        \"\"\"Initalize tacotron-2 layers.\"\"\"\n",
    "        training = kwargs.pop(\"training\", False)\n",
    "        enable_tflite_convertible = kwargs.pop(\"enable_tflite_convertible\", False)\n",
    "        super().__init__(self, **kwargs)\n",
    "        self.encoder = TFTacotronEncoder(config, name=\"encoder\")\n",
    "        self.decoder_cell = TFTacotronDecoderCell(\n",
    "            config,\n",
    "            training=training,\n",
    "            name=\"decoder_cell\",\n",
    "            enable_tflite_convertible=enable_tflite_convertible,\n",
    "        )\n",
    "        self.decoder = TFTacotronDecoder(\n",
    "            self.decoder_cell,\n",
    "            TrainingSampler(config) if training is True else TestingSampler(config),\n",
    "            enable_tflite_convertible=enable_tflite_convertible,\n",
    "        )\n",
    "        self.postnet = TFTacotronPostnet(config, name=\"post_net\")\n",
    "        self.post_projection = tf.keras.layers.Dense(\n",
    "            units=config.n_mels, name=\"residual_projection\"\n",
    "        )\n",
    "\n",
    "        self.config = config\n",
    "        self.use_window_mask = False\n",
    "        self.maximum_iterations = 4000\n",
    "        self.enable_tflite_convertible = enable_tflite_convertible\n",
    "\n",
    "    def setup_window(self, win_front, win_back):\n",
    "        \"\"\"Call only for inference.\"\"\"\n",
    "        self.use_window_mask = True\n",
    "        self.win_front = win_front\n",
    "        self.win_back = win_back\n",
    "\n",
    "    def setup_maximum_iterations(self, maximum_iterations):\n",
    "        \"\"\"Call only for inference.\"\"\"\n",
    "        self.maximum_iterations = maximum_iterations\n",
    "\n",
    "    def _build(self):\n",
    "        input_ids = np.array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])\n",
    "        input_lengths = np.array([9])\n",
    "        speaker_ids = np.array([0])\n",
    "        mel_outputs = np.random.normal(size=(1, 50, 80)).astype(np.float32)\n",
    "        mel_lengths = np.array([50])\n",
    "        self(\n",
    "            input_ids,\n",
    "            input_lengths,\n",
    "            speaker_ids,\n",
    "            mel_outputs,\n",
    "            mel_lengths,\n",
    "            10,\n",
    "            training=True,\n",
    "        )\n",
    "\n",
    "    def call(\n",
    "        self,\n",
    "        input_ids,\n",
    "        input_lengths,\n",
    "        speaker_ids,\n",
    "        mel_gts,\n",
    "        mel_lengths,\n",
    "        maximum_iterations=2000,\n",
    "        use_window_mask=False,\n",
    "        win_front=2,\n",
    "        win_back=3,\n",
    "        training=False,\n",
    "        **kwargs,\n",
    "    ):\n",
    "        \"\"\"Call logic.\"\"\"\n",
    "        # create input-mask based on input_lengths\n",
    "        input_mask = tf.sequence_mask(\n",
    "            input_lengths,\n",
    "            maxlen=tf.reduce_max(input_lengths),\n",
    "            name=\"input_sequence_masks\",\n",
    "        )\n",
    "\n",
    "        # Encoder Step.\n",
    "        encoder_hidden_states = self.encoder(\n",
    "            [input_ids, speaker_ids, input_mask], training=training\n",
    "        )\n",
    "\n",
    "        batch_size = tf.shape(encoder_hidden_states)[0]\n",
    "        alignment_size = tf.shape(encoder_hidden_states)[1]\n",
    "\n",
    "        # Setup some initial placeholders for decoder step. Include:\n",
    "        # 1. mel_gts, mel_lengths for teacher forcing mode.\n",
    "        # 2. alignment_size for attention size.\n",
    "        # 3. initial state for decoder cell.\n",
    "        # 4. memory (encoder hidden state) for attention mechanism.\n",
    "        self.decoder.sampler.setup_target(targets=mel_gts, mel_lengths=mel_lengths)\n",
    "        self.decoder.cell.set_alignment_size(alignment_size)\n",
    "        self.decoder.setup_decoder_init_state(\n",
    "            self.decoder.cell.get_initial_state(batch_size)\n",
    "        )\n",
    "        self.decoder.cell.attention_layer.setup_memory(\n",
    "            memory=encoder_hidden_states,\n",
    "            memory_sequence_length=input_lengths,  # use for mask attention.\n",
    "        )\n",
    "        if use_window_mask:\n",
    "            self.decoder.cell.attention_layer.setup_window(\n",
    "                win_front=win_front, win_back=win_back\n",
    "            )\n",
    "\n",
    "        # run decode step.\n",
    "        (\n",
    "            (frames_prediction, stop_token_prediction, _),\n",
    "            final_decoder_state,\n",
    "            _,\n",
    "        ) = dynamic_decode(\n",
    "            self.decoder,\n",
    "            maximum_iterations=maximum_iterations,\n",
    "            enable_tflite_convertible=self.enable_tflite_convertible,\n",
    "        )\n",
    "\n",
    "        decoder_outputs = tf.reshape(\n",
    "            frames_prediction, [batch_size, -1, self.config.n_mels]\n",
    "        )\n",
    "        stop_token_prediction = tf.reshape(stop_token_prediction, [batch_size, -1])\n",
    "\n",
    "        residual = self.postnet(decoder_outputs, training=training)\n",
    "        residual_projection = self.post_projection(residual)\n",
    "\n",
    "        mel_outputs = decoder_outputs + residual_projection\n",
    "\n",
    "        if self.enable_tflite_convertible:\n",
    "            mask = tf.math.not_equal(\n",
    "                tf.cast(\n",
    "                    tf.reduce_sum(tf.abs(decoder_outputs), axis=-1), dtype=tf.int32\n",
    "                ),\n",
    "                0,\n",
    "            )\n",
    "            decoder_outputs = tf.expand_dims(\n",
    "                tf.boolean_mask(decoder_outputs, mask), axis=0\n",
    "            )\n",
    "            mel_outputs = tf.expand_dims(tf.boolean_mask(mel_outputs, mask), axis=0)\n",
    "            alignment_history = ()\n",
    "        else:\n",
    "            alignment_history = tf.transpose(\n",
    "                final_decoder_state.alignment_history.stack(), [1, 2, 0]\n",
    "            )\n",
    "\n",
    "        return decoder_outputs, mel_outputs, stop_token_prediction, alignment_history\n",
    "\n",
    "    @tf.function(\n",
    "        experimental_relax_shapes=True,\n",
    "        input_signature=[\n",
    "            tf.TensorSpec([None, None], dtype=tf.int32, name=\"input_ids\"),\n",
    "            tf.TensorSpec([None,], dtype=tf.int32, name=\"input_lengths\"),\n",
    "            tf.TensorSpec([None,], dtype=tf.int32, name=\"speaker_ids\"),\n",
    "        ],\n",
    "    )\n",
    "    def inference(self, input_ids, input_lengths, speaker_ids, **kwargs):\n",
    "        \"\"\"Call logic.\"\"\"\n",
    "        # create input-mask based on input_lengths\n",
    "        input_mask = tf.sequence_mask(\n",
    "            input_lengths,\n",
    "            maxlen=tf.reduce_max(input_lengths),\n",
    "            name=\"input_sequence_masks\",\n",
    "        )\n",
    "\n",
    "        # Encoder Step.\n",
    "        encoder_hidden_states = self.encoder(\n",
    "            [input_ids, speaker_ids, input_mask], training=False\n",
    "        )\n",
    "\n",
    "        batch_size = tf.shape(encoder_hidden_states)[0]\n",
    "        alignment_size = tf.shape(encoder_hidden_states)[1]\n",
    "\n",
    "        # Setup some initial placeholders for decoder step. Include:\n",
    "        # 1. batch_size for inference.\n",
    "        # 2. alignment_size for attention size.\n",
    "        # 3. initial state for decoder cell.\n",
    "        # 4. memory (encoder hidden state) for attention mechanism.\n",
    "        # 5. window front/back to solve long sentence synthesize problems. (call after setup memory.)\n",
    "        self.decoder.sampler.set_batch_size(batch_size)\n",
    "        self.decoder.cell.set_alignment_size(alignment_size)\n",
    "        self.decoder.setup_decoder_init_state(\n",
    "            self.decoder.cell.get_initial_state(batch_size)\n",
    "        )\n",
    "        self.decoder.cell.attention_layer.setup_memory(\n",
    "            memory=encoder_hidden_states,\n",
    "            memory_sequence_length=input_lengths,  # use for mask attention.\n",
    "        )\n",
    "        if self.use_window_mask:\n",
    "            self.decoder.cell.attention_layer.setup_window(\n",
    "                win_front=self.win_front, win_back=self.win_back\n",
    "            )\n",
    "\n",
    "        # run decode step.\n",
    "        (\n",
    "            (frames_prediction, stop_token_prediction, _),\n",
    "            final_decoder_state,\n",
    "            _,\n",
    "        ) = dynamic_decode(self.decoder, maximum_iterations=self.maximum_iterations)\n",
    "\n",
    "        decoder_outputs = tf.reshape(\n",
    "            frames_prediction, [batch_size, -1, self.config.n_mels]\n",
    "        )\n",
    "        stop_token_predictions = tf.reshape(stop_token_prediction, [batch_size, -1])\n",
    "\n",
    "        residual = self.postnet(decoder_outputs, training=False)\n",
    "        residual_projection = self.post_projection(residual)\n",
    "\n",
    "        mel_outputs = decoder_outputs + residual_projection\n",
    "\n",
    "        alignment_historys = tf.transpose(\n",
    "            final_decoder_state.alignment_history.stack(), [1, 2, 0]\n",
    "        )\n",
    "\n",
    "        return decoder_outputs, mel_outputs, stop_token_predictions, alignment_historys\n",
    "\n",
    "    @tf.function(\n",
    "        experimental_relax_shapes=True,\n",
    "        input_signature=[\n",
    "            tf.TensorSpec([1, None], dtype=tf.int32, name=\"input_ids\"),\n",
    "            tf.TensorSpec([1,], dtype=tf.int32, name=\"input_lengths\"),\n",
    "            tf.TensorSpec([1,], dtype=tf.int32, name=\"speaker_ids\"),\n",
    "        ],\n",
    "    )\n",
    "    def inference_tflite(self, input_ids, input_lengths, speaker_ids, **kwargs):\n",
    "        \"\"\"Call logic.\"\"\"\n",
    "        # create input-mask based on input_lengths\n",
    "        input_mask = tf.sequence_mask(\n",
    "            input_lengths,\n",
    "            maxlen=tf.reduce_max(input_lengths),\n",
    "            name=\"input_sequence_masks\",\n",
    "        )\n",
    "\n",
    "        # Encoder Step.\n",
    "        encoder_hidden_states = self.encoder(\n",
    "            [input_ids, speaker_ids, input_mask], training=False\n",
    "        )\n",
    "\n",
    "        batch_size = tf.shape(encoder_hidden_states)[0]\n",
    "        alignment_size = tf.shape(encoder_hidden_states)[1]\n",
    "\n",
    "        # Setup some initial placeholders for decoder step. Include:\n",
    "        # 1. batch_size for inference.\n",
    "        # 2. alignment_size for attention size.\n",
    "        # 3. initial state for decoder cell.\n",
    "        # 4. memory (encoder hidden state) for attention mechanism.\n",
    "        # 5. window front/back to solve long sentence synthesize problems. (call after setup memory.)\n",
    "        self.decoder.sampler.set_batch_size(batch_size)\n",
    "        self.decoder.cell.set_alignment_size(alignment_size)\n",
    "        self.decoder.setup_decoder_init_state(\n",
    "            self.decoder.cell.get_initial_state(batch_size)\n",
    "        )\n",
    "        self.decoder.cell.attention_layer.setup_memory(\n",
    "            memory=encoder_hidden_states,\n",
    "            memory_sequence_length=input_lengths,  # use for mask attention.\n",
    "        )\n",
    "        if self.use_window_mask:\n",
    "            self.decoder.cell.attention_layer.setup_window(\n",
    "                win_front=self.win_front, win_back=self.win_back\n",
    "            )\n",
    "\n",
    "        # run decode step.\n",
    "        (\n",
    "            (frames_prediction, stop_token_prediction, _),\n",
    "            final_decoder_state,\n",
    "            _,\n",
    "        ) = dynamic_decode(\n",
    "            self.decoder,\n",
    "            maximum_iterations=self.maximum_iterations,\n",
    "            enable_tflite_convertible=self.enable_tflite_convertible,\n",
    "        )\n",
    "\n",
    "        decoder_outputs = tf.reshape(\n",
    "            frames_prediction, [batch_size, -1, self.config.n_mels]\n",
    "        )\n",
    "        stop_token_predictions = tf.reshape(stop_token_prediction, [batch_size, -1])\n",
    "\n",
    "        residual = self.postnet(decoder_outputs, training=False)\n",
    "        residual_projection = self.post_projection(residual)\n",
    "\n",
    "        mel_outputs = decoder_outputs + residual_projection\n",
    "\n",
    "        if self.enable_tflite_convertible:\n",
    "            mask = tf.math.not_equal(\n",
    "                tf.cast(\n",
    "                    tf.reduce_sum(tf.abs(decoder_outputs), axis=-1), dtype=tf.int32\n",
    "                ),\n",
    "                0,\n",
    "            )\n",
    "            decoder_outputs = tf.expand_dims(\n",
    "                tf.boolean_mask(decoder_outputs, mask), axis=0\n",
    "            )\n",
    "            mel_outputs = tf.expand_dims(tf.boolean_mask(mel_outputs, mask), axis=0)\n",
    "            alignment_historys = ()\n",
    "        else:\n",
    "            alignment_historys = tf.transpose(\n",
    "                final_decoder_state.alignment_history.stack(), [1, 2, 0]\n",
    "            )\n",
    "\n",
    "        return decoder_outputs, mel_outputs, stop_token_predictions, alignment_historys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jDE5n9aDOoci"
   },
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wPYtRVGCOoef"
   },
   "outputs": [],
   "source": [
    "# 데이터 config 파일 \n",
    "\n",
    "# # This is the hyperparameter configuration file for Tacotron2 v1.\n",
    "# # Please make sure this is adjusted for the KSS dataset. If you want to\n",
    "# # apply to the other dataset, you might need to carefully change some parameters.\n",
    "# # This configuration performs 200k iters but 65k iters is enough to get a good models.\n",
    "\n",
    "# ###########################################################\n",
    "# #                FEATURE EXTRACTION SETTING               #\n",
    "# ###########################################################\n",
    "# hop_size: 256            # Hop size.\n",
    "# format: \"npy\"\n",
    "\n",
    "\n",
    "# ###########################################################\n",
    "# #              NETWORK ARCHITECTURE SETTING               #\n",
    "# ###########################################################\n",
    "# model_type: \"tacotron2\"\n",
    "\n",
    "# tacotron2_params:\n",
    "#     dataset: \"kss\"\n",
    "#     embedding_hidden_size: 512\n",
    "#     initializer_range: 0.02\n",
    "#     embedding_dropout_prob: 0.1\n",
    "#     n_speakers: 1\n",
    "#     n_conv_encoder: 5\n",
    "#     encoder_conv_filters: 512\n",
    "#     encoder_conv_kernel_sizes: 5\n",
    "#     encoder_conv_activation: 'relu'\n",
    "#     encoder_conv_dropout_rate: 0.5\n",
    "#     encoder_lstm_units: 256\n",
    "#     n_prenet_layers: 2\n",
    "#     prenet_units: 256\n",
    "#     prenet_activation: 'relu'\n",
    "#     prenet_dropout_rate: 0.5\n",
    "#     n_lstm_decoder: 1\n",
    "#     reduction_factor: 1\n",
    "#     decoder_lstm_units: 1024\n",
    "#     attention_dim: 128\n",
    "#     attention_filters: 32\n",
    "#     attention_kernel: 31\n",
    "#     n_mels: 80\n",
    "#     n_conv_postnet: 5\n",
    "#     postnet_conv_filters: 512\n",
    "#     postnet_conv_kernel_sizes: 5\n",
    "#     postnet_dropout_rate: 0.1\n",
    "#     attention_type: \"lsa\"\n",
    "\n",
    "# ###########################################################\n",
    "# #                  DATA LOADER SETTING                    #\n",
    "# ###########################################################\n",
    "# batch_size: 32             # Batch size.\n",
    "# remove_short_samples: true # Whether to remove samples the length of which are less than batch_max_steps.\n",
    "# allow_cache: true          # Whether to allow cache in dataset. If true, it requires cpu memory.\n",
    "# mel_length_threshold: 32   # remove all targets has mel_length <= 32 \n",
    "# is_shuffle: true           # shuffle dataset after each epoch.\n",
    "# use_fixed_shapes: false    # use_fixed_shapes for training (2x speed-up)\n",
    "#                            # refer (https://github.com/dathudeptrai/TensorflowTTS/issues/34#issuecomment-642309118)\n",
    "\n",
    "# ###########################################################\n",
    "# #             OPTIMIZER & SCHEDULER SETTING               #\n",
    "# ###########################################################\n",
    "# optimizer_params:\n",
    "#     initial_learning_rate: 0.001\n",
    "#     end_learning_rate: 0.00001\n",
    "#     decay_steps: 150000          # < train_max_steps is recommend.\n",
    "#     warmup_proportion: 0.02\n",
    "#     weight_decay: 0.001\n",
    "    \n",
    "    \n",
    "# ###########################################################\n",
    "# #                    INTERVAL SETTING                     #\n",
    "# ###########################################################\n",
    "# train_max_steps: 200000                 # Number of training steps.\n",
    "# save_interval_steps: 2000               # Interval steps to save checkpoint.\n",
    "# eval_interval_steps: 500                # Interval steps to evaluate the network.\n",
    "# log_interval_steps: 200                 # Interval steps to record the training log.\n",
    "# start_schedule_teacher_forcing: 200001  # don't need to apply schedule teacher forcing.\n",
    "# start_ratio_value: 0.5                  # start ratio of scheduled teacher forcing.\n",
    "# schedule_decay_steps: 50000             # decay step scheduled teacher forcing.\n",
    "# end_ratio_value: 0.0                    # end ratio of scheduled teacher forcing.\n",
    "# ###########################################################\n",
    "# #                     OTHER SETTING                       #\n",
    "# ###########################################################\n",
    "# num_save_intermediate_results: 1  # Number of results to be saved as intermediate results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0glWcZUlOofC"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "physical_devices = tf.config.list_physical_devices(\"GPU\")\n",
    "for i in range(len(physical_devices)):\n",
    "    tf.config.experimental.set_memory_growth(physical_devices[i], True)\n",
    "\n",
    "import easydict\n",
    "import argparse\n",
    "import logging\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import yaml\n",
    "from tqdm import tqdm\n",
    "\n",
    "import tensorflow_tts\n",
    "from ttsexamples.tacotron2.tacotron_dataset import CharactorMelDataset\n",
    "from tensorflow_tts.configs.tacotron2 import Tacotron2Config\n",
    "from tensorflow_tts.models import TFTacotron2\n",
    "from tensorflow_tts.optimizers import AdamWeightDecay, WarmUp\n",
    "from tensorflow_tts.trainers import Seq2SeqBasedTrainer\n",
    "from tensorflow_tts.utils import (calculate_2d_loss, calculate_3d_loss,\n",
    "                                  return_strategy)\n",
    "\n",
    "\n",
    "class Tacotron2Trainer(Seq2SeqBasedTrainer):\n",
    "    \"\"\"Tacotron2 Trainer class based on Seq2SeqBasedTrainer.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, config, strategy, steps=0, epochs=0, is_mixed_precision=False,\n",
    "    ):\n",
    "        \"\"\"Initialize trainer.\n",
    "\n",
    "        Args:\n",
    "            steps (int): Initial global steps.\n",
    "            epochs (int): Initial global epochs.\n",
    "            config (dict): Config dict loaded from yaml format configuration file.\n",
    "            is_mixed_precision (bool): Use mixed precision or not.\n",
    "\n",
    "        \"\"\"\n",
    "        super(Tacotron2Trainer, self).__init__(\n",
    "            steps=steps,\n",
    "            epochs=epochs,\n",
    "            config=config,\n",
    "            strategy=strategy,\n",
    "            is_mixed_precision=is_mixed_precision,\n",
    "        )\n",
    "        # define metrics to aggregates data and use tf.summary logs them\n",
    "        self.list_metrics_name = [\n",
    "            \"stop_token_loss\",\n",
    "            \"mel_loss_before\",\n",
    "            \"mel_loss_after\",\n",
    "            \"guided_attention_loss\",\n",
    "        ]\n",
    "        self.init_train_eval_metrics(self.list_metrics_name)\n",
    "        self.reset_states_train()\n",
    "        self.reset_states_eval()\n",
    "\n",
    "        self.config = config\n",
    "\n",
    "    def compile(self, model, optimizer):\n",
    "        super().compile(model, optimizer)\n",
    "        self.binary_crossentropy = tf.keras.losses.BinaryCrossentropy(\n",
    "            from_logits=True, reduction=tf.keras.losses.Reduction.NONE\n",
    "        )\n",
    "        self.mse = tf.keras.losses.MeanSquaredError(\n",
    "            reduction=tf.keras.losses.Reduction.NONE\n",
    "        )\n",
    "        self.mae = tf.keras.losses.MeanAbsoluteError(\n",
    "            reduction=tf.keras.losses.Reduction.NONE\n",
    "        )\n",
    "\n",
    "    def _train_step(self, batch):\n",
    "        \"\"\"Here we re-define _train_step because apply input_signature make\n",
    "        the training progress slower on my experiment. Note that input_signature\n",
    "        is apply on based_trainer by default.\n",
    "        \"\"\"\n",
    "        if self._already_apply_input_signature is False:\n",
    "            self.one_step_forward = tf.function(\n",
    "                self._one_step_forward, experimental_relax_shapes=True\n",
    "            )\n",
    "            self.one_step_evaluate = tf.function(\n",
    "                self._one_step_evaluate, experimental_relax_shapes=True\n",
    "            )\n",
    "            self.one_step_predict = tf.function(\n",
    "                self._one_step_predict, experimental_relax_shapes=True\n",
    "            )\n",
    "            self._already_apply_input_signature = True\n",
    "\n",
    "        # run one_step_forward\n",
    "        self.one_step_forward(batch)\n",
    "\n",
    "        # update counts\n",
    "        self.steps += 1\n",
    "        self.tqdm.update(1)\n",
    "        self._check_train_finish()\n",
    "\n",
    "    def compute_per_example_losses(self, batch, outputs):\n",
    "        \"\"\"Compute per example losses and return dict_metrics_losses\n",
    "        Note that all element of the loss MUST has a shape [batch_size] and \n",
    "        the keys of dict_metrics_losses MUST be in self.list_metrics_name.\n",
    "\n",
    "        Args:\n",
    "            batch: dictionary batch input return from dataloader\n",
    "            outputs: outputs of the model\n",
    "        \n",
    "        Returns:\n",
    "            per_example_losses: per example losses for each GPU, shape [B]\n",
    "            dict_metrics_losses: dictionary loss.\n",
    "        \"\"\"\n",
    "        (\n",
    "            decoder_output,\n",
    "            post_mel_outputs,\n",
    "            stop_token_predictions,\n",
    "            alignment_historys,\n",
    "        ) = outputs\n",
    "\n",
    "        mel_loss_before = calculate_3d_loss(\n",
    "            batch[\"mel_gts\"], decoder_output, loss_fn=self.mae\n",
    "        )\n",
    "        mel_loss_after = calculate_3d_loss(\n",
    "            batch[\"mel_gts\"], post_mel_outputs, loss_fn=self.mae\n",
    "        )\n",
    "\n",
    "        # calculate stop_loss\n",
    "        max_mel_length = (\n",
    "            tf.reduce_max(batch[\"mel_lengths\"])\n",
    "            if self.config[\"use_fixed_shapes\"] is False\n",
    "            else [self.config[\"max_mel_length\"]]\n",
    "        )\n",
    "        stop_gts = tf.expand_dims(\n",
    "            tf.range(tf.reduce_max(max_mel_length), dtype=tf.int32), 0\n",
    "        )  # [1, max_len]\n",
    "        stop_gts = tf.tile(\n",
    "            stop_gts, [tf.shape(batch[\"mel_lengths\"])[0], 1]\n",
    "        )  # [B, max_len]\n",
    "        stop_gts = tf.cast(\n",
    "            tf.math.greater_equal(stop_gts, tf.expand_dims(batch[\"mel_lengths\"], 1)),\n",
    "            tf.float32,\n",
    "        )\n",
    "\n",
    "        stop_token_loss = calculate_2d_loss(\n",
    "            stop_gts, stop_token_predictions, loss_fn=self.binary_crossentropy\n",
    "        )\n",
    "\n",
    "        # calculate guided attention loss.\n",
    "        attention_masks = tf.cast(\n",
    "            tf.math.not_equal(batch[\"g_attentions\"], -1.0), tf.float32\n",
    "        )\n",
    "        loss_att = tf.reduce_sum(\n",
    "            tf.abs(alignment_historys * batch[\"g_attentions\"]) * attention_masks,\n",
    "            axis=[1, 2],\n",
    "        )\n",
    "        loss_att /= tf.reduce_sum(attention_masks, axis=[1, 2])\n",
    "\n",
    "        per_example_losses = (\n",
    "            stop_token_loss + mel_loss_before + mel_loss_after + loss_att\n",
    "        )\n",
    "\n",
    "        dict_metrics_losses = {\n",
    "            \"stop_token_loss\": stop_token_loss,\n",
    "            \"mel_loss_before\": mel_loss_before,\n",
    "            \"mel_loss_after\": mel_loss_after,\n",
    "            \"guided_attention_loss\": loss_att,\n",
    "        }\n",
    "\n",
    "        return per_example_losses, dict_metrics_losses\n",
    "\n",
    "    def generate_and_save_intermediate_result(self, batch):\n",
    "        \"\"\"Generate and save intermediate result.\"\"\"\n",
    "        import matplotlib.pyplot as plt\n",
    "\n",
    "        # predict with tf.function for faster.\n",
    "        outputs = self.one_step_predict(batch)\n",
    "        (\n",
    "            decoder_output,\n",
    "            mel_outputs,\n",
    "            stop_token_predictions,\n",
    "            alignment_historys,\n",
    "        ) = outputs\n",
    "        mel_gts = batch[\"mel_gts\"]\n",
    "\n",
    "        # convert to tensor.\n",
    "        # here we just take a sample at first replica.\n",
    "        try:\n",
    "            mels_before = decoder_output.values[0].numpy()\n",
    "            mels_after = mel_outputs.values[0].numpy()\n",
    "            mel_gts = mel_gts.values[0].numpy()\n",
    "            alignment_historys = alignment_historys.values[0].numpy()\n",
    "        except Exception:\n",
    "            mels_before = decoder_output.numpy()\n",
    "            mels_after = mel_outputs.numpy()\n",
    "            mel_gts = mel_gts.numpy()\n",
    "            alignment_historys = alignment_historys.numpy()\n",
    "\n",
    "        # check directory\n",
    "        utt_ids = batch[\"utt_ids\"].numpy()\n",
    "        dirname = os.path.join(self.config[\"outdir\"], f\"predictions/{self.steps}steps\")\n",
    "        if not os.path.exists(dirname):\n",
    "            os.makedirs(dirname)\n",
    "\n",
    "        for idx, (mel_gt, mel_before, mel_after, alignment_history) in enumerate(\n",
    "            zip(mel_gts, mels_before, mels_after, alignment_historys), 0\n",
    "        ):\n",
    "            mel_gt = tf.reshape(mel_gt, (-1, 80)).numpy()  # [length, 80]\n",
    "            mel_before = tf.reshape(mel_before, (-1, 80)).numpy()  # [length, 80]\n",
    "            mel_after = tf.reshape(mel_after, (-1, 80)).numpy()  # [length, 80]\n",
    "\n",
    "            # plot figure and save it\n",
    "            utt_id = utt_ids[idx]\n",
    "            figname = os.path.join(dirname, f\"{utt_id}.png\")\n",
    "            fig = plt.figure(figsize=(10, 8))\n",
    "            ax1 = fig.add_subplot(311)\n",
    "            ax2 = fig.add_subplot(312)\n",
    "            ax3 = fig.add_subplot(313)\n",
    "            im = ax1.imshow(np.rot90(mel_gt), aspect=\"auto\", interpolation=\"none\")\n",
    "            ax1.set_title(\"Target Mel-Spectrogram\")\n",
    "            fig.colorbar(mappable=im, shrink=0.65, orientation=\"horizontal\", ax=ax1)\n",
    "            ax2.set_title(f\"Predicted Mel-before-Spectrogram @ {self.steps} steps\")\n",
    "            im = ax2.imshow(np.rot90(mel_before), aspect=\"auto\", interpolation=\"none\")\n",
    "            fig.colorbar(mappable=im, shrink=0.65, orientation=\"horizontal\", ax=ax2)\n",
    "            ax3.set_title(f\"Predicted Mel-after-Spectrogram @ {self.steps} steps\")\n",
    "            im = ax3.imshow(np.rot90(mel_after), aspect=\"auto\", interpolation=\"none\")\n",
    "            fig.colorbar(mappable=im, shrink=0.65, orientation=\"horizontal\", ax=ax3)\n",
    "            plt.tight_layout()\n",
    "            plt.savefig(figname)\n",
    "            plt.close()\n",
    "\n",
    "            # plot alignment\n",
    "            figname = os.path.join(dirname, f\"{idx}_alignment.png\")\n",
    "            fig = plt.figure(figsize=(8, 6))\n",
    "            ax = fig.add_subplot(111)\n",
    "            ax.set_title(f\"Alignment @ {self.steps} steps\")\n",
    "            im = ax.imshow(\n",
    "                alignment_history, aspect=\"auto\", origin=\"lower\", interpolation=\"none\"\n",
    "            )\n",
    "            fig.colorbar(im, ax=ax)\n",
    "            xlabel = \"Decoder timestep\"\n",
    "            plt.xlabel(xlabel)\n",
    "            plt.ylabel(\"Encoder timestep\")\n",
    "            plt.tight_layout()\n",
    "            plt.savefig(figname)\n",
    "            plt.close()\n",
    "\n",
    "def main():\n",
    "    \"\"\"Run training process.\"\"\"\n",
    "    args = easydict.EasyDict({ \"train_dir\": './dump_test/train', \n",
    "                              \"dev_dir\": './dump_test/valid/', \n",
    "                              \"use_norm\": 1, \n",
    "                              \"outdir\": \"./ttsexamples/tacotron2/exp/train.multiband_melgan.v3/\", \n",
    "                              \"config\": './ttsexamples/tacotron2/conf/tacotron2.v1.yaml', \n",
    "                              \"resume\": '',\n",
    "                              \"verbose\":0,\n",
    "                             'mixed_precision':0,\n",
    "                             'pretrained':''})\n",
    "    # return strategy\n",
    "    STRATEGY = return_strategy()\n",
    "\n",
    "    # set mixed precision config\n",
    "    if args.mixed_precision == 1:\n",
    "        tf.config.optimizer.set_experimental_options({\"auto_mixed_precision\": True})\n",
    "\n",
    "    args.mixed_precision = bool(args.mixed_precision)\n",
    "    args.use_norm = bool(args.use_norm)\n",
    "\n",
    "    # set logger\n",
    "    if args.verbose > 1:\n",
    "        logging.basicConfig(\n",
    "            level=logging.DEBUG,\n",
    "            stream=sys.stdout,\n",
    "            format=\"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s\",\n",
    "        )\n",
    "    elif args.verbose > 0:\n",
    "        logging.basicConfig(\n",
    "            level=logging.INFO,\n",
    "            stream=sys.stdout,\n",
    "            format=\"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s\",\n",
    "        )\n",
    "    else:\n",
    "        logging.basicConfig(\n",
    "            level=logging.WARN,\n",
    "            stream=sys.stdout,\n",
    "            format=\"%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s\",\n",
    "        )\n",
    "        logging.warning(\"Skip DEBUG/INFO messages\")\n",
    "\n",
    "    # check directory existence\n",
    "    if not os.path.exists(args.outdir):\n",
    "        os.makedirs(args.outdir)\n",
    "\n",
    "    # check arguments\n",
    "    if args.train_dir is None:\n",
    "        raise ValueError(\"Please specify --train-dir\")\n",
    "    if args.dev_dir is None:\n",
    "        raise ValueError(\"Please specify --valid-dir\")\n",
    "\n",
    "    # load and save config\n",
    "    with open(args.config) as f:\n",
    "        config = yaml.load(f, Loader=yaml.Loader)\n",
    "    config.update(vars(args))\n",
    "    config[\"version\"] = tensorflow_tts.__version__\n",
    "\n",
    "    # get dataset\n",
    "    if config[\"remove_short_samples\"]:\n",
    "        mel_length_threshold = config[\"mel_length_threshold\"]\n",
    "    else:\n",
    "        mel_length_threshold = 0\n",
    "\n",
    "    if config[\"format\"] == \"npy\":\n",
    "        charactor_query = \"*-ids.npy\"\n",
    "        mel_query = \"*-raw-feats.npy\" if args.use_norm is False else \"*-norm-feats.npy\"\n",
    "        charactor_load_fn = np.load\n",
    "        mel_load_fn = np.load\n",
    "    else:\n",
    "        raise ValueError(\"Only npy are supported.\")\n",
    "\n",
    "    train_dataset = CharactorMelDataset(\n",
    "        dataset=config[\"tacotron2_params\"][\"dataset\"],\n",
    "        root_dir=args.train_dir,\n",
    "        charactor_query=charactor_query,\n",
    "        mel_query=mel_query,\n",
    "        charactor_load_fn=charactor_load_fn,\n",
    "        mel_load_fn=mel_load_fn,\n",
    "        mel_length_threshold=mel_length_threshold,\n",
    "        reduction_factor=config[\"tacotron2_params\"][\"reduction_factor\"],\n",
    "        use_fixed_shapes=config[\"use_fixed_shapes\"],\n",
    "    )\n",
    "\n",
    "    # update max_mel_length and max_char_length to config\n",
    "    config.update({\"max_mel_length\": int(train_dataset.max_mel_length)})\n",
    "    config.update({\"max_char_length\": int(train_dataset.max_char_length)})\n",
    "\n",
    "    with open(os.path.join(args.outdir, \"config.yml\"), \"w\") as f:\n",
    "        yaml.dump(config, f, Dumper=yaml.Dumper)\n",
    "    for key, value in config.items():\n",
    "        logging.info(f\"{key} = {value}\")\n",
    "\n",
    "    train_dataset = train_dataset.create(\n",
    "        is_shuffle=config[\"is_shuffle\"],\n",
    "        allow_cache=config[\"allow_cache\"],\n",
    "        batch_size=config[\"batch_size\"] * STRATEGY.num_replicas_in_sync,\n",
    "    )\n",
    "\n",
    "    valid_dataset = CharactorMelDataset(\n",
    "        dataset=config[\"tacotron2_params\"][\"dataset\"],\n",
    "        root_dir=args.dev_dir,\n",
    "        charactor_query=charactor_query,\n",
    "        mel_query=mel_query,\n",
    "        charactor_load_fn=charactor_load_fn,\n",
    "        mel_load_fn=mel_load_fn,\n",
    "        mel_length_threshold=mel_length_threshold,\n",
    "        reduction_factor=config[\"tacotron2_params\"][\"reduction_factor\"],\n",
    "        use_fixed_shapes=False,  # don't need apply fixed shape for evaluation.\n",
    "    ).create(\n",
    "        is_shuffle=config[\"is_shuffle\"],\n",
    "        allow_cache=config[\"allow_cache\"],\n",
    "        batch_size=config[\"batch_size\"] * STRATEGY.num_replicas_in_sync,\n",
    "    )\n",
    "\n",
    "    # define trainer\n",
    "    trainer = Tacotron2Trainer(\n",
    "        config=config,\n",
    "        strategy=STRATEGY,\n",
    "        steps=0,\n",
    "        epochs=0,\n",
    "        is_mixed_precision=args.mixed_precision,\n",
    "    )\n",
    "\n",
    "    with STRATEGY.scope():\n",
    "        # define model.\n",
    "        tacotron_config = Tacotron2Config(**config[\"tacotron2_params\"])\n",
    "        tacotron2 = TFTacotron2(config=tacotron_config, training=True, name=\"tacotron2\")\n",
    "        tacotron2._build()\n",
    "        tacotron2.summary()\n",
    "        \n",
    "        if len(args.pretrained) > 1:\n",
    "            tacotron2.load_weights(args.pretrained, by_name=True, skip_mismatch=True)\n",
    "            logging.info(f\"Successfully loaded pretrained weight from {args.pretrained}.\")\n",
    "\n",
    "        # AdamW for tacotron2\n",
    "        learning_rate_fn = tf.keras.optimizers.schedules.PolynomialDecay(\n",
    "            initial_learning_rate=config[\"optimizer_params\"][\"initial_learning_rate\"],\n",
    "            decay_steps=config[\"optimizer_params\"][\"decay_steps\"],\n",
    "            end_learning_rate=config[\"optimizer_params\"][\"end_learning_rate\"],\n",
    "        )\n",
    "\n",
    "        learning_rate_fn = WarmUp(\n",
    "            initial_learning_rate=config[\"optimizer_params\"][\"initial_learning_rate\"],\n",
    "            decay_schedule_fn=learning_rate_fn,\n",
    "            warmup_steps=int(\n",
    "                config[\"train_max_steps\"]\n",
    "                * config[\"optimizer_params\"][\"warmup_proportion\"]\n",
    "            ),\n",
    "        )\n",
    "\n",
    "        optimizer = AdamWeightDecay(\n",
    "            learning_rate=learning_rate_fn,\n",
    "            weight_decay_rate=config[\"optimizer_params\"][\"weight_decay\"],\n",
    "            beta_1=0.9,\n",
    "            beta_2=0.98,\n",
    "            epsilon=1e-6,\n",
    "            exclude_from_weight_decay=[\"LayerNorm\", \"layer_norm\", \"bias\"],\n",
    "        )\n",
    "\n",
    "        _ = optimizer.iterations\n",
    "\n",
    "    # compile trainer\n",
    "    trainer.compile(model=tacotron2, optimizer=optimizer)\n",
    "\n",
    "    # start training\n",
    "    try:\n",
    "        trainer.fit(\n",
    "            train_dataset,\n",
    "            valid_dataset,\n",
    "            saved_path=os.path.join(config[\"outdir\"], \"checkpoints/\"),\n",
    "            resume=args.resume,\n",
    "        )\n",
    "    except KeyboardInterrupt:\n",
    "        trainer.save_checkpoint()\n",
    "        logging.info(f\"Successfully saved checkpoint @ {trainer.steps}steps.\")\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IO5ehbLDOofk"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4HFdNZiiOofn"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kyun5yl_Oof7"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "-CcQjEslOoXA",
    "4SoQzN1VOobv"
   ],
   "name": "Tacotron_정리.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}