updates and debugs

2026-10-27 12:30:27 +08:00 · 2018-02-13 01:45:52 -08:00
1 parent dadefb5dbc
commit 56697ac8cf
@@ -15,7 +15,7 @@
  "lr": 0.003,
  "lr_patience": 5,
  "lr_decay": 0.5,
-  "batch_size": 98,
+  "batch_size": 180,
  "r": 5,

  "griffin_lim_iters": 60,
@@ -23,7 +23,8 @@

  "num_loader_workers": 32,

-  "save_step": 200,
+  "checkpoint": false,
+  "save_step": 69,
  "data_path": "/data/shared/KeithIto/LJSpeech-1.0",
  "output_path": "result",
  "log_dir": "/home/erogol/projects/TTS/logs/"
@@ -72,9 +72,14 @@ class LJSpeechDataset(Dataset):
            timesteps = mel.shape[2]

            # PAD with zeros that can be divided by outputs per step
-            if timesteps % self.outputs_per_step != 0:
-                linear = pad_per_step(linear, self.outputs_per_step)
-                mel = pad_per_step(mel, self.outputs_per_step)
+            if (timesteps + 1) % self.outputs_per_step != 0:
+                pad_len = self.outputs_per_step - \
+                        ((timesteps + 1) % self.outputs_per_step)
+                pad_len += 1
+            else:
+                pad_len = 1
+            linear = pad_per_step(linear, pad_len)
+            mel = pad_per_step(mel, pad_len)

            # reshape jombo
            linear = linear.transpose(0, 2, 1)
@@ -192,6 +192,14 @@ class Encoder(nn.Module):
        self.cbhg = CBHG(128, K=16, projections=[128, 128])

    def forward(self, inputs):
+        r"""
+        Args:
+            inputs (FloatTensor): embedding features
+
+        Shapes:
+            - inputs: batch x time x embedding_size
+            - outputs: batch x time x 128
+        """
        inputs = self.prenet(inputs)
        return self.cbhg(inputs)

@@ -200,12 +208,9 @@ class Decoder(nn.Module):
    r"""Decoder module.

    Args:
-        memory_dim (int): memory vector sample size
-        r (int): number of outputs per time step
-
-    Shape:
-        - input: 
-        - output:
+        in_features (int): input vector (encoder output) sample size.
+        memory_dim (int): memory vector (prev. time-step output) sample size.
+        r (int): number of outputs per time step.
    """
    def __init__(self, in_features, memory_dim, r):
        super(Decoder, self).__init__()
@@ -263,9 +268,7 @@ class Decoder(nn.Module):

            # Grouping multiple frames if necessary
            if memory.size(-1) == self.memory_dim:
-                print(" > Blamento", memory.shape)
                memory = memory.view(B, memory.size(1) // self.r, -1)
-                print(" > Blamento", memory.shape)
            assert memory.size(-1) == self.memory_dim * self.r,\
                " !! Dimension mismatch {} vs {} * {}".format(memory.size(-1),
                                                         self.memory_dim, self.r)
@@ -20,7 +20,7 @@ class Tacotron(nn.Module):
        # Trying smaller std
        self.embedding.weight.data.normal_(0, 0.3)
        self.encoder = Encoder(embedding_dim)
-        self.decoder = Decoder(mel_dim, r)
+        self.decoder = Decoder(256, mel_dim, r)

        self.postnet = CBHG(mel_dim, K=8, projections=[256, mel_dim])
        self.last_linear = nn.Linear(mel_dim * 2, freq_dim)
@@ -60,12 +60,12 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
-    "ROOT_PATH = '../result/February-08-2018_05:35AM/'\n",
-    "MODEL_PATH = ROOT_PATH + '/checkpoint_40600.pth.tar'\n",
+    "ROOT_PATH = '../result/February-13-2018_01:04AM/'\n",
+    "MODEL_PATH = ROOT_PATH + '/best_model.pth.tar'\n",
    "CONFIG_PATH = ROOT_PATH + '/config.json'\n",
    "OUT_FOLDER = ROOT_PATH + '/test/'\n",
    "CONFIG = load_config(CONFIG_PATH)\n",
@@ -74,7 +74,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
@@ -83,18 +83,6 @@
     "text": [
      " | > Embedding dim : 149\n"
     ]
-    },
-    {
-     "ename": "TypeError",
-     "evalue": "__init__() missing 1 required positional argument: 'r'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-6-561a2605d2cd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# load the model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m model = Tacotron(CONFIG.embedding_size, CONFIG.hidden_size,\n\u001b[0;32m----> 3\u001b[0;31m         CONFIG.num_mels, CONFIG.num_freq, CONFIG.r)\n\u001b[0m\u001b[1;32m      4\u001b[0m ap = AudioProcessor(CONFIG.sample_rate, CONFIG.num_mels, CONFIG.min_level_db,\n\u001b[1;32m      5\u001b[0m                     \u001b[0mCONFIG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe_shift_ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCONFIG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe_length_ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCONFIG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpreemphasis\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/projects/TTS/models/tacotron.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, embedding_dim, linear_dim, mel_dim, freq_dim, r, padding_idx, use_memory_mask)\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0membedding\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormal_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencoder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEncoder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0membedding_dim\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecoder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDecoder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmel_dim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     24\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpostnet\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCBHG\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmel_dim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mK\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprojections\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m256\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmel_dim\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'r'"
-     ]
    }
   ],
   "source": [
@@ -120,7 +108,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
@@ -128,23 +116,23 @@
   "source": [
    "model.load_state_dict(cp['model'])\n",
    "# model.decoder.eval(); ##\n",
-    "model.encoder.eval();\n",
-    "model.postnet.eval();\n",
-    "# model.eval();"
+    "# model.encoder.eval();\n",
+    "# model.postnet.eval();\n",
+    "model.eval();"
   ]
  },
  {
   "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
-       "True"
+       "False"
      ]
     },
-     "execution_count": 15,
+     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
@@ -155,7 +143,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
@@ -181,7 +169,7 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
@@ -200,16 +188,19 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
-     "name": "stdout",
+     "name": "stderr",
     "output_type": "stream",
     "text": [
-      "Warning! doesn't seems to be converged\n"
+      "/home/erogol/miniconda3/envs/pytorch/lib/python3.6/site-packages/librosa/util/utils.py:1725: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
+      "  if np.issubdtype(x.dtype, float) or np.issubdtype(x.dtype, complex):\n",
+      "/home/erogol/miniconda3/envs/pytorch/lib/python3.6/site-packages/librosa/display.py:656: FutureWarning: Conversion of the second argument of issubdtype from `complex` to `np.complexfloating` is deprecated. In future, it will be treated as `np.complex128 == np.dtype(complex).type`.\n",
+      "  if np.issubdtype(data.dtype, np.complex):\n"
     ]
    },
    {
@@ -217,7 +208,7 @@
      "text/html": [
       "\n",
       "                <audio controls=\"controls\" >\n",
-       "                    <source src=\"data:audio/wav;base64,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 truncated
+       "                    <source src=\"data:audio/wav;base64,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 truncated
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
@@ -233,14 +224,14 @@
     "name": "stdout",
     "output_type": "stream",
     "text": [
-      "For although the Chinese took impressions from wood blocks engraved in relief for centuries before the woodcutters of the Netherlands, by a similar process\n"
+      "And it is worth mention in passing that, as an example of fine typography,\n"
     ]
    },
    {
     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABBIAAAR4CAYAAAC7N/X6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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 truncated
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAR4CAYAAABQAE75AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzs3XmYZXdZJ/Dv2x2SQBayAcYkmABB\nxMA8MJFF5wGULSiCjsgEBCMgGUdwg1EQRoIsg8gogiJjjyBxRoXIKGQwyo64BQiLSBKQkEjSJCRs\nCUvWrnrnj7otRdtddTl1T1Xd6s/nec7T955zfvf9dRHSnfd+z+9X3R0AAACA1Wzb6AkAAAAA80ET\nAQAAAJiKJgIAAAAwFU0EAAAAYCqaCAAAAMBUNBEAAACAqWgiAAAAAFPRRAAAAACmookAAAAATOWA\njZ7AZnBgHdQH55CNngYAAMBcuzFfy819U230PGbt4d97SH/hiwuj1/ngR296a3efNnqhNdBESHJw\nDsl968EbPQ0AAIC59r5+50ZPYRRf+OJC3v/WO45eZ/uxnzxm9CJrpIkAAAAAK+gki1nc6GlsCtZE\nAAAAAKYiiQAAAAAr6iy0JEIiiQAAAABMSRIBAAAAVrC0JkJv9DQ2BUkEAAAAYCqaCAAAAMBUPM4A\nAAAAq7DF4xJJBAAAAGAqkggAAACwgk5noS2smEgiAAAAAFOSRAAAAIBV2OJxiSQCAAAAMBVJBAAA\nAFhBJ1mQREgiiQAAAABMSRIBAAAAVmFNhCWSCAAAAMBUJBEAAABgBZ1koSUREkkEAAAAYEqSCAAA\nALCKxY2ewCYhiQAAAABMRRIBAAAAVtDpLNidIYkkAgAAADAlSQQAAABYSScLgghJJBEAAACAKUki\nAAAAwAo6dmfYTRIBAAAAmIokAgAAAKyospDa6ElsCpIIAAAAwFQkEQAAAGAFnWTR7gxJJBEAAACA\nKUkiAAAAwCqsibBEEgEAAACYiiQCAAAArKAjibCbJAIAAAAwFUkEAAAAWMViSyIkkggAAADAlCQR\nAAAAYAXWRPg6SQQAAABgKpIIAAAAsIJOZcF38EkkEQAAAIApSSIAAADAKuzOsEQSAQAAAJiKJAIA\nAACswO4MXyeJAAAAAExFEgEAAABWVFlo38Enc5BEqKrXVtU1VfWxvVz7r1XVVXXM5H1V1Sur6pKq\n+mhV3Xv9ZwwAAABb06ZvIiR5XZLT9jxZVSckeWiSy5edfkSSkyfHmUlevQ7zAwAAYAvrJIvZNvox\nDzb9LLv7vUm+uJdLL0/yS1n633O3Ryf5w15yfpIjqurYdZgmAAAAbHlzuSZCVT0qyWe6+x+rvmGF\nzOOSXLHs/c7JuavWcXoAAABsMXZnWDJ3TYSquk2S5yZ52N4u7+Vc7+VcqurMLD3ykINzm5nNDwAA\nALaquWsiJLlzkpOS7E4hHJ/kQ1V1nywlD05Ydu/xSa7c24d0944kO5Lk8Dpqr40GAAAA6LY7w25z\n91Po7n/q7tt394ndfWKWGgf37u7PJjk3yY9Pdmm4X5LrutujDAAAADADmz6JUFV/kuRBSY6pqp1J\nzuru1+zj9vOSfH+SS5Jcn+RJ6zJJAAAAtrRFayIkmYMmQnc/bpXrJy573UmeNvacAAAAYH+06ZsI\nAAAAsJE6ycL8rQYwCj8FAAAAYCqSCAAAALAiuzPs5qcAAAAATEUSAQAAAFbQSRZ9B59EEgEAAACY\nkiQCAAAArGKha6OnsClIIgAAAABTkUQAAACAFXQqC76DTyKJAAAAAExJEgEAAABWsdi+g08kEQAA\nAIApSSIAAADACjqxJsKEnwIAAAAwFUkEAAAAWEGnstC10dPYFCQRAAAAgKloIgAAAABT8TgDAAAA\nrGLRd/BJJBEAAACAKUkiAAAAwAq6k4X2HXwiiQAAAABMSRIBAAAAVlRZjC0eE0kEAAAAYEqSCAAA\nALCCjjURdvNTAAAAAKYiiQAAAACrWPAdfBJJBAAAAGBKkggAAACwgk5lse3OkEgiAAAAAFOSRAAA\nAIBVWBNhiZ8CAAAAMBVJBAAAAFhBJ1ls38EnkggAAADAlCQRAAAAYEWVhdidIZFEAAAAAKYkiQAA\nAAArsCbC1/kpAAAAAFORRAAAAIBVWBNhiSQCAAAAMBVJBAAAAFhBd1kTYcJPAQAAAJiKJAIAAACs\nYkESIYkkAgAAADAlTQQAAABYQSdZTI1+rKaqTquqT1TVJVX17L1cv2NVvbuqPlxVH62q75/1z0IT\nAQAAADa5qtqe5FVJHpHk7kkeV1V33+O2/5bknO6+V5LTk/zurOdhTQQAAABYUW2GNRHuk+SS7r40\nSarq9UkeneSiZfd0ksMnr2+b5MpZT0ITAQAAADaHY6rqgmXvd3T3jsnr45JcsezaziT33WP885O8\nrap+JskhSR4y6wlqIgAAAMAKOslir75mwQx8vrtP3ce1vU2g93j/uCSv6+7fqKr7J/nfVXVKdy/O\naoIbnscAAAAAVrUzyQnL3h+ff/u4wlOSnJMk3f0PSQ5OcswsJ6GJAAAAAKtYyLbRj1V8IMnJVXVS\nVR2YpYUTz93jnsuTPDhJquo7stRE+Nwsfw6aCAAAALDJdfeuJE9P8tYkF2dpF4YLq+oFVfWoyW3P\nTPLUqvrHJH+S5Ce6e89HHtbEmggAAACwgk6t15oIK8+j+7wk5+1x7nnLXl+U5HvGnIMkAgAAADAV\nSQQAAABYxaLv4JNIIgAAAABTkkQAAACAFXQnC5tgTYTNQBIBAAAAmIokAgAAAKxiM+zOsBls+iRC\nVb22qq6pqo8tO/eyqvp4VX20qv68qo5Ydu2Xq+qSqvpEVT18Y2YNAAAAW8+mbyIkeV2S0/Y49/Yk\np3T3PZP8c5JfTpKqunuS05N852TM71bV9vWbKgAAAFtNp7LY20Y/5sGmn2V3vzfJF/c497bu3jV5\ne36S4yevH53k9d19U3dfluSSJPdZt8kCAADAFrYV1kR4cpI3TF4fl6Wmwm47J+f+jao6M8mZSXJw\nbjPm/AAAAJhzC7EmQjIHSYSVVNVzk+xK8ke7T+3ltt7b2O7e0d2ndvept8pBY00RAAAAtoy5TSJU\n1RlJHpnkwd29u1GwM8kJy247PsmV6z03AAAAto6O3Rl2m8skQlWdluRZSR7V3dcvu3RuktOr6qCq\nOinJyUnevxFzBAAAgK1m0ycRqupPkjwoyTFVtTPJWVnajeGgJG+vqiQ5v7t/qrsvrKpzklyUpccc\nntbdCxszcwAAALaGmpvdE8a26ZsI3f24vZx+zQr3vzjJi8ebEQAAAOyfNn0TAQAAADbaot0Zkszp\nmggAAADA+pNEAAAAgBV0Jwt2Z0giiQAAAABMSRIBAAAAVmF3hiV+CgAAAMBUJBEAAABgBZ3KojUR\nkkgiAAAAAFOSRAAAAIBVLEYSIZFEAAAAAKYkiQAAAAAr6MSaCBOSCAAAAMBUNBEAAACAqXicAQAA\nAFax2L6DTyQRAAAAgClJIgAAAMBKuiysOCGJAAAAAExFEgEAAABW0EkWI4mQSCIAAAAAU5JEAAAA\ngFVYE2GJJAIAAAAwFUkEAAAAWEFHEmE3SQQAAABgKpIIAAAAsApJhCWSCAAAAMBUJBEAAABgBZ2S\nRJiQRAAAAACmIokAAAAAq1iMJEIiiQAAAABMSRIBAAAAVtJ2Z9hNEgEAAACYiiQCAAAArKAjibCb\nJAIAAAAwFUkEAAAAWIUkwhJJBAAAAGAqkggAAACwgk5JIkxIIgAAAABTkUQAAACAVbQkQhJJBAAA\nAGBKkggAAACwisVIIiSSCAAAAMCUJBEAAABgBd2xO8OEJAIAAAAwFUkEAAAAWIXdGZZIIgAAAABT\nkUQAAACAFZU1ESYkEQAAAICpSCIAAADAKqyJsEQSAQAAAJiKJAIAAACsoBNrIkxIIgAAAABTkUQA\nAACAlXTSvdGT2BwkEQAAAICpSCIAAADAKhZjTYREEgEAAACYkiQCAAAArKCTtN0ZkkgiAAAAAFOS\nRAAAAIAVVRYlEZLMQRKhql5bVddU1ceWnTuqqt5eVZ+c/Hrk5HxV1Sur6pKq+mhV3XvjZg4AAABb\ny+hNhKq6S1U9vqp+cfLrXb7Jj3hdktP2OPfsJO/s7pOTvHPyPkkekeTkyXFmklcPnzkAAAAs6R7/\nmAejPc5QVQcn+d0kT0yyfdmlhao6O8nTuvum1T6nu99bVSfucfrRSR40eX12kvckedbk/B92dyc5\nv6qOqKpju/uqNfxWAAAAgIybRPgfSX4syVlJ7pLksMmvz89SY+Fla/jsO+xuDEx+vf3k/HFJrlh2\n387JuX+jqs6sqguq6oJbsmovAwAAgP1Yd41+zIMxF1Y8Pcmvdvd/X3bu0iQvrqok+YUkPzvjmnv7\nqe81FNLdO5LsSJLD66g5CY4AAADAxhmziXBQkvfv49r7khy4hs++evdjClV1bJJrJud3Jjlh2X3H\nJ7lyDXUAAADYzy2tWTAfSYGxjfk4wzuSPGwf1x6W5F1r+Oxzk5wxeX1GkjcvO//jk10a7pfkOush\nAAAAwGyMmUT4zST/u6oOSfKnSa5Ocockj03y/UmeUFV32n1zd1+6tw+pqj/J0iKKx1TVziytsfBr\nSc6pqqckuTzJj05uP2/y2ZckuT7Jk2b/2wIAAGB/syiJkGTcJsJfT379L0l+atn52uP6btuzF939\nuH18/oP3cm8nedo3MUcAAABgSmM2EaQAAAAA2BLacvxJRmwidPfZY302AAAAsP7GTCIAAADAlmB3\nhiWjNhGq6rQsLXp4QpKD97jc3f3AMesDAAAAszNaE6GqfilLuyh8Lku7Jdw8Vi0AALine truncated
      "text/plain": [
-       "<matplotlib.figure.Figure at 0x7f432103c128>"
+       "<matplotlib.figure.Figure at 0x7faad3bf6780>"
      ]
     },
     "metadata": {},
@@ -249,7 +240,7 @@
   ],
   "source": [
    "aling = tts(model, df.iloc[1, 1], CONFIG, use_cuda, ap)\n",
-    "print(df.iloc[1, 1])"
+    "print(df.iloc[4, 1])"
   ]
  },
  {
@@ -344,7 +335,7 @@
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.6.3"
  }
 },
 "nbformat": 4,
@@ -41,6 +41,7 @@ class TestDataset(unittest.TestCase):
                break
            text_input = data[0]
            text_lengths = data[1]
+            linear_input = data[2]
            mel_input = data[3]
            item_idx = data[4]

@@ -48,7 +49,45 @@ class TestDataset(unittest.TestCase):
            check_count = len(neg_values)
            assert check_count == 0, \
                " !! Negative values in text_input: {}".format(check_count)
+            # TODO: more assertion here
+            assert linear_input.shape[0] == c.batch_size
+            assert mel_input.shape[0] == c.batch_size
+            assert mel_input.shape[2] == c.num_mels

+    def test_padding(self):
+        dataset = LJSpeechDataset(os.path.join(c.data_path, 'metadata.csv'),
+                                  os.path.join(c.data_path, 'wavs'),
+                                  1,
+                                  c.sample_rate,
+                                  c.text_cleaner,
+                                  c.num_mels,
+                                  c.min_level_db,
+                                  c.frame_shift_ms,
+                                  c.frame_length_ms,
+                                  c.preemphasis,
+                                  c.ref_level_db,
+                                  c.num_freq,
+                                  c.power
+                                )
+
+        dataloader = DataLoader(dataset, batch_size=1,
+                                shuffle=True, collate_fn=dataset.collate_fn,
+                                drop_last=True, num_workers=c.num_loader_workers)
+
+        for i, data in enumerate(dataloader):
+            if i == self.max_loader_iter:
+                break
+            text_input = data[0]
+            text_lengths = data[1]
+            linear_input = data[2]
+            mel_input = data[3]
+            item_idx = data[4]
+
+            # check the last time step to be zero padded
+            assert mel_input[0, -1].sum() == 0
+            assert mel_input[0, -2].sum() != 0
+            assert linear_input[0, -1].sum() == 0
+            assert linear_input[0, -2].sum() != 0



@@ -15,7 +15,7 @@
  "lr": 0.003,
  "lr_patience": 5,
  "lr_decay": 0.5,
-  "batch_size": 8,
+  "batch_size": 2,
  "r": 5,

  "griffin_lim_iters": 60,
@@ -20,7 +20,7 @@ from tensorboardX import SummaryWriter

 from utils.generic_utils import (Progbar, remove_experiment_folder,
                                 create_experiment_folder, save_checkpoint,
-                                 load_config, lr_decay)
+                                 save_best_model, load_config, lr_decay)
 from utils.model import get_param_size
 from utils.visual import plot_alignment, plot_spectrogram
 from datasets.LJSpeech import LJSpeechDataset
@@ -101,7 +101,7 @@ def main(args):
        optimizer.load_state_dict(checkpoint['optimizer'])
        print("\n > Model restored from step %d\n" % args.restore_step)
        start_epoch = checkpoint['step'] // len(dataloader)
-
+        best_loss = checkpoint['linear_loss']
    else:
        start_epoch = 0
        print("\n > Starting a new training")
@@ -144,6 +144,7 @@ def main(args):

            optimizer.zero_grad()

+            # Add a single frame of zeros to Mel Specs for better end detection
            #try:
            #    mel_input = np.concatenate((np.zeros(
            #        [c.batch_size, 1, c.num_mels], dtype=np.float32),
@@ -214,9 +215,11 @@ def main(args):

            if current_step % c.save_step == 0:

-                # save model
-                best_loss = save_checkpoint(model, loss.data[0],
-                                            best_loss, out_path=OUT_PATH)
+                if c.checkpoint:
+                    # save model
+                    save_checkpoint(model, optimizer, linear_loss.data[0],
+                                    best_loss, OUT_PATH,
+                                    current_step, epoch)

                # Diagnostic visualizations
                const_spec = linear_output[0].data.cpu().numpy()
@@ -243,6 +246,14 @@ def main(args):
                    print(audio_signal.max())
                    print(audio_signal.min())

+
+        # average loss after the epoch
+        avg_epoch_loss = np.mean(
+            progbar.sum_values['linear_loss'][0] / max(1, progbar.sum_values['linear_loss'][1]))
+        best_loss = save_best_model(model, optimizer, avg_epoch_loss,
+                                    best_loss, OUT_PATH,
+                                    current_step, epoch)
+
        #lr_scheduler.step(loss.data[0])
        tb.add_scalar('Time/EpochTime', epoch_time, epoch)
        epoch_time = 0
@@ -14,9 +14,8 @@ def prepare_data(inputs):
    return np.stack([pad_data(x, max_len) for x in inputs])


-def pad_per_step(inputs, outputs_per_step):
-    """zero pad inputs if it is not divisible with outputs_per_step (r)"""
+def pad_per_step(inputs, pad_len):
    timesteps = inputs.shape[-1]
    return np.pad(inputs, [[0, 0], [0, 0],
-                           [0, outputs_per_step - (timesteps % outputs_per_step)]],
+                           [0, pad_len]],
                  mode='constant', constant_values=0.0)
@@ -48,7 +48,8 @@ def copy_config_file(config_file, path):
    shutil.copyfile(config_file, out_path)


-def save_checkpoint(model, model_loss, best_loss, out_path):
+def save_checkpoint(model, optimizer, model_loss, best_loss, out_path,
+                    current_step, epoch):
    checkpoint_path = 'checkpoint_{}.pth.tar'.format(current_step)
    checkpoint_path = os.path.join(out_path, checkpoint_path)
    print("\n | > Checkpoint saving : {}".format(checkpoint_path))
@@ -56,16 +57,24 @@ def save_checkpoint(model, model_loss, best_loss, out_path):
             'optimizer': optimizer.state_dict(),
             'step': current_step,
             'epoch': epoch,
-             'total_loss': loss.data[0],
-             'linear_loss': linear_loss.data[0],
-             'mel_loss': mel_loss.data[0],
+             'linear_loss': model_loss,
             'date': datetime.date.today().strftime("%B %d, %Y")}
    torch.save(state, checkpoint_path)
+
+
+def save_best_model(model, optimizer, model_loss, best_loss, out_path,
+                    current_step, epoch):
    if model_loss < best_loss:
+        state = {'model': model.state_dict(),
+                 'optimizer': optimizer.state_dict(),
+                 'step': current_step,
+                 'epoch': epoch,
+                 'linear_loss': model_loss,
+                 'date': datetime.date.today().strftime("%B %d, %Y")}
        best_loss = model_loss
-        bestmodel_path = 'best_model.pth.tar'.format(current_step)
+        bestmodel_path = 'best_model.pth.tar'
        bestmodel_path = os.path.join(out_path, bestmodel_path)
-        print("\n | > Best model saving with loss {} : {}".format(model_loss, bestmodel_path))
+        print("\n | > Best model saving with loss {0:.2f} : {1:}".format(model_loss, bestmodel_path))
        torch.save(state, bestmodel_path)
    return best_loss