train_script.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch \n",
    "import torch\n",
    "\n",
    "# utils\n",
    "import os\n",
    "import numpy as np\n",
    "import argparse\n",
    "\n",
    "# statistics & visualization\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# model & dataset\n",
    "from LALip.model.densenet_3d import DenseNet3D\n",
    "from dataset import dataset\n",
    "\n",
    "# evaluation\n",
    "from metric.WERandCERmetrics import CalculateErrorRate\n",
    "from LALip.misc import idx2text, ctc_decoder, plot_error_curves_comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(model, valid_loader, device, epoch):\n",
    "    model.eval()\n",
    "\n",
    "    with torch.no_grad():\n",
    "        # initialize\n",
    "        eval_loss = []\n",
    "        eval_WER = []\n",
    "        eval_CER = []\n",
    "        \n",
    "        criterion = torch.nn.CTCLoss()\n",
    "\n",
    "        for _, (video, label, video_length, label_length) in enumerate(valid_loader):\n",
    "            if video is None:\n",
    "                continue\n",
    "            video, label, video_length, label_length = video.to(device), label.to(device), video_length.to(device), label_length.to(device)\n",
    "            output = model(video)\n",
    "\n",
    "            # calculate loss\n",
    "            loss = criterion(output.log_softmax(-1).transpose(0,1), label, video_length.view(-1), label_length.view(-1))\n",
    "            eval_loss.append(loss.detach().cpu().numpy())\n",
    "\n",
    "            pred_text = ctc_decoder(output)\n",
    "            gt_text = []\n",
    "            for _ in range(len(label)):\n",
    "                gt_text.append(idx2text(label[_]))\n",
    "            \n",
    "            # calculate WER and CER\n",
    "            wer = CalculateErrorRate(gt_text[0], pred_text[0], method='WER')\n",
    "            cer = CalculateErrorRate(gt_text[0], pred_text[0], method='CER')\n",
    "            eval_WER.append(wer)\n",
    "            eval_CER.append(cer)\n",
    "\n",
    "            mean_WER = np.mean(np.array(eval_WER))\n",
    "            mean_CER = np.mean(np.array(eval_CER))\n",
    "        \n",
    "        # print statistics\n",
    "        print('Evaluation Loss: {:.3f}, eval WER: {:.3f}, eval CER: {:.3f}'.format(epoch+1, np.mean(np.array(eval_loss)), mean_WER, mean_CER))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(rnn):\n",
    "\n",
    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    print(\"device: \", device)\n",
    "\n",
    "    # load data\n",
    "    train_loader, valid_loader = dataset.get_dataloaders(root_path='/data/ziruiw3/lip_reading/frames/',\n",
    "                                                         batch_size=64,\n",
    "                                                         split=0.8,\n",
    "                                                         shuffle=True,\n",
    "                                                         num_workers=0,\n",
    "                                                         pin_memory=False)\n",
    "    print(\"data loaded\")\n",
    "\n",
    "    # ---- training 3D CNN + GRU -----\n",
    "    # load model\n",
    "    model = DenseNet3D(rnn)\n",
    "    model.to(device)\n",
    "    criterion = torch.nn.CTCLoss()                                  # loss function\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)    # optimizer\n",
    "    print(\"model loaded\")\n",
    "    model.train() \n",
    "\n",
    "    # training\n",
    "    WER = []\n",
    "    CER = []\n",
    "    losses = []\n",
    "    iteration = 0\n",
    "    print(\"start training...\")\n",
    "    for epoch in range(10):\n",
    "        model.train()\n",
    "        for _, (video, label, video_length, label_length) in enumerate(train_loader):\n",
    "\n",
    "            if video is None: # some videos have incorrect number of frames, skip them (see collate_fn in dataset.py)\n",
    "                continue\n",
    "\n",
    "            # reset gradients\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # load data to GPU\n",
    "            video, label,video_length, label_length = video.to(device), label.to(device), video_length.to(device), label_length.to(device)\n",
    "\n",
    "            # forward \n",
    "            output = model(video)   #(T, B, C, H, W) -> (B, T, Emb=28) (n, 75, 28)\n",
    "\n",
    "            # backward\n",
    "            loss = criterion(output.log_softmax(-1).transpose(0,1), label, video_length.view(-1), label_length.view(-1))\n",
    "            losses.append(loss.item())\n",
    "            loss.backward()\n",
    "\n",
    "            # decode text output\n",
    "            pred_text = ctc_decoder(output)\n",
    "\n",
    "            gt_text = []\n",
    "            for _ in range(len(label)):\n",
    "                gt_text.append(idx2text(label[_]))\n",
    "\n",
    "            # calculate WER and CER\n",
    "            for i in range(len(gt_text)):\n",
    "                wer = CalculateErrorRate(gt_text[i], pred_text[i], method='WER')\n",
    "                cer = CalculateErrorRate(gt_text[i], pred_text[i], method='CER')\n",
    "                WER.append(wer)\n",
    "                CER.append(cer)\n",
    "\n",
    "            # update parameters\n",
    "            optimizer.step()\n",
    "\n",
    "            # statistics\n",
    "            iteration += 1\n",
    "            if iteration % 50 == 0:\n",
    "                print('Epoch [{}/{}], Iteration: {}, Loss: {:.3f}, WER: {:.3f}, CER: {:.3f}'.format(epoch + 1, 10, iteration, loss.item(), np.mean(np.array(WER)), np.mean(np.array(CER))))\n",
    "        # validation after each epoch\n",
    "        evaluate(model, valid_loader, device, epoch)\n",
    "\n",
    "        # save model\n",
    "        if not os.path.exists(\"./checkpoints\"):\n",
    "            os.makedirs(\"./checkpoints\")\n",
    "        torch.save(model.state_dict(), os.path.join(\"./checkpoints\", 'densenet3d-{}-ep{}.pth'.format(rnn,epoch)))\n",
    "\n",
    "    \n",
    "    return losses, WER, CER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "device:  cuda\n",
      "data loaded\n",
      "model loaded\n",
      "start training...\n",
      "Epoch [1/10], Iteration: 50, Loss: 2.837, WER: 1.004, CER: 1.059\n",
      "Epoch [1/10], Iteration: 100, Loss: 2.665, WER: 1.001, CER: 1.009\n",
      "Epoch [1/10], Iteration: 150, Loss: 2.534, WER: 1.001, CER: 0.971\n",
      "Epoch [1/10], Iteration: 200, Loss: 2.423, WER: 1.000, CER: 0.945\n",
      "Epoch [1/10], Iteration: 250, Loss: 2.336, WER: 1.000, CER: 0.925\n",
      "Epoch [1/10], Iteration: 300, Loss: 2.226, WER: 1.000, CER: 0.910\n",
      "Epoch [1/10], Iteration: 350, Loss: 2.170, WER: 1.000, CER: 0.897\n",
      "Epoch [1/10], Iteration: 400, Loss: 2.094, WER: 0.999, CER: 0.886\n",
      "Evaluation Loss: 1.000, eval WER: 2.017, eval CER: 0.981\n",
      "Epoch [2/10], Iteration: 450, Loss: 1.964, WER: 0.999, CER: 0.874\n",
      "Epoch [2/10], Iteration: 500, Loss: 1.927, WER: 0.998, CER: 0.862\n",
      "Epoch [2/10], Iteration: 550, Loss: 1.829, WER: 0.998, CER: 0.851\n",
      "Epoch [2/10], Iteration: 600, Loss: 1.754, WER: 0.997, CER: 0.841\n",
      "Epoch [2/10], Iteration: 650, Loss: 1.729, WER: 0.997, CER: 0.832\n",
      "Epoch [2/10], Iteration: 700, Loss: 1.688, WER: 0.997, CER: 0.824\n",
      "Epoch [2/10], Iteration: 750, Loss: 1.650, WER: 0.996, CER: 0.817\n",
      "Epoch [2/10], Iteration: 800, Loss: 1.588, WER: 0.996, CER: 0.810\n",
      "Evaluation Loss: 2.000, eval WER: 1.486, eval CER: 0.944\n",
      "Epoch [3/10], Iteration: 850, Loss: 1.556, WER: 0.995, CER: 0.803\n",
      "Epoch [3/10], Iteration: 900, Loss: 1.505, WER: 0.994, CER: 0.796\n",
      "Epoch [3/10], Iteration: 950, Loss: 1.443, WER: 0.992, CER: 0.789\n",
      "Epoch [3/10], Iteration: 1000, Loss: 1.414, WER: 0.991, CER: 0.782\n",
      "Epoch [3/10], Iteration: 1050, Loss: 1.363, WER: 0.989, CER: 0.776\n",
      "Epoch [3/10], Iteration: 1100, Loss: 1.340, WER: 0.987, CER: 0.769\n",
      "Epoch [3/10], Iteration: 1150, Loss: 1.276, WER: 0.986, CER: 0.762\n",
      "Epoch [3/10], Iteration: 1200, Loss: 1.212, WER: 0.984, CER: 0.755\n",
      "Evaluation Loss: 3.000, eval WER: 1.206, eval CER: 0.859\n",
      "Epoch [4/10], Iteration: 1250, Loss: 1.208, WER: 0.982, CER: 0.748\n",
      "Epoch [4/10], Iteration: 1300, Loss: 1.193, WER: 0.980, CER: 0.741\n",
      "Epoch [4/10], Iteration: 1350, Loss: 1.164, WER: 0.979, CER: 0.735\n",
      "Epoch [4/10], Iteration: 1400, Loss: 1.218, WER: 0.976, CER: 0.728\n",
      "Epoch [4/10], Iteration: 1450, Loss: 1.110, WER: 0.974, CER: 0.722\n",
      "Epoch [4/10], Iteration: 1500, Loss: 1.167, WER: 0.972, CER: 0.716\n",
      "Epoch [4/10], Iteration: 1550, Loss: 1.071, WER: 0.969, CER: 0.710\n",
      "Epoch [4/10], Iteration: 1600, Loss: 1.017, WER: 0.965, CER: 0.704\n",
      "Epoch [4/10], Iteration: 1650, Loss: 0.967, WER: 0.962, CER: 0.697\n",
      "Evaluation Loss: 4.000, eval WER: 0.933, eval CER: 0.697\n",
      "Epoch [5/10], Iteration: 1700, Loss: 1.032, WER: 0.957, CER: 0.691\n",
      "Epoch [5/10], Iteration: 1750, Loss: 0.979, WER: 0.953, CER: 0.685\n",
      "Epoch [5/10], Iteration: 1800, Loss: 0.981, WER: 0.947, CER: 0.678\n",
      "Epoch [5/10], Iteration: 1850, Loss: 0.882, WER: 0.942, CER: 0.671\n",
      "Epoch [5/10], Iteration: 1900, Loss: 0.903, WER: 0.937, CER: 0.665\n",
      "Epoch [5/10], Iteration: 1950, Loss: 0.812, WER: 0.931, CER: 0.658\n",
      "Epoch [5/10], Iteration: 2000, Loss: 0.832, WER: 0.925, CER: 0.652\n",
      "Epoch [5/10], Iteration: 2050, Loss: 0.801, WER: 0.919, CER: 0.646\n",
      "Evaluation Loss: 5.000, eval WER: 0.747, eval CER: 0.596\n",
      "Epoch [6/10], Iteration: 2100, Loss: 0.838, WER: 0.913, CER: 0.639\n",
      "Epoch [6/10], Iteration: 2150, Loss: 0.820, WER: 0.906, CER: 0.633\n",
      "Epoch [6/10], Iteration: 2200, Loss: 0.810, WER: 0.900, CER: 0.627\n",
      "Epoch [6/10], Iteration: 2250, Loss: 0.743, WER: 0.894, CER: 0.621\n",
      "Epoch [6/10], Iteration: 2300, Loss: 0.708, WER: 0.888, CER: 0.615\n",
      "Epoch [6/10], Iteration: 2350, Loss: 0.694, WER: 0.881, CER: 0.609\n",
      "Epoch [6/10], Iteration: 2400, Loss: 0.707, WER: 0.875, CER: 0.603\n",
      "Epoch [6/10], Iteration: 2450, Loss: 0.687, WER: 0.869, CER: 0.598\n",
      "Evaluation Loss: 6.000, eval WER: 0.658, eval CER: 0.545\n",
      "Epoch [7/10], Iteration: 2500, Loss: 0.662, WER: 0.864, CER: 0.592\n",
      "Epoch [7/10], Iteration: 2550, Loss: 0.625, WER: 0.858, CER: 0.587\n",
      "Epoch [7/10], Iteration: 2600, Loss: 0.658, WER: 0.852, CER: 0.582\n",
      "Epoch [7/10], Iteration: 2650, Loss: 0.669, WER: 0.847, CER: 0.576\n",
      "Epoch [7/10], Iteration: 2700, Loss: 0.714, WER: 0.841, CER: 0.571\n",
      "Epoch [7/10], Iteration: 2750, Loss: 0.659, WER: 0.836, CER: 0.567\n",
      "Epoch [7/10], Iteration: 2800, Loss: 0.668, WER: 0.830, CER: 0.562\n",
      "Epoch [7/10], Iteration: 2850, Loss: 0.664, WER: 0.825, CER: 0.557\n",
      "Evaluation Loss: 7.000, eval WER: 0.583, eval CER: 0.505\n",
      "Epoch [8/10], Iteration: 2900, Loss: 0.620, WER: 0.820, CER: 0.552\n",
      "Epoch [8/10], Iteration: 2950, Loss: 0.570, WER: 0.814, CER: 0.548\n",
      "Epoch [8/10], Iteration: 3000, Loss: 0.553, WER: 0.809, CER: 0.543\n",
      "Epoch [8/10], Iteration: 3050, Loss: 0.649, WER: 0.804, CER: 0.539\n",
      "Epoch [8/10], Iteration: 3100, Loss: 0.562, WER: 0.799, CER: 0.534\n",
      "Epoch [8/10], Iteration: 3150, Loss: 0.575, WER: 0.794, CER: 0.530\n",
      "Epoch [8/10], Iteration: 3200, Loss: 0.541, WER: 0.789, CER: 0.526\n",
      "Epoch [8/10], Iteration: 3250, Loss: 0.607, WER: 0.784, CER: 0.522\n",
      "Epoch [8/10], Iteration: 3300, Loss: 0.590, WER: 0.779, CER: 0.518\n",
      "Evaluation Loss: 8.000, eval WER: 0.519, eval CER: 0.423\n",
      "Epoch [9/10], Iteration: 3350, Loss: 0.518, WER: 0.774, CER: 0.514\n",
      "Epoch [9/10], Iteration: 3400, Loss: 0.527, WER: 0.770, CER: 0.510\n",
      "Epoch [9/10], Iteration: 3450, Loss: 0.518, WER: 0.765, CER: 0.506\n",
      "Epoch [9/10], Iteration: 3500, Loss: 0.558, WER: 0.760, CER: 0.502\n",
      "Epoch [9/10], Iteration: 3550, Loss: 0.489, WER: 0.756, CER: 0.498\n",
      "Epoch [9/10], Iteration: 3600, Loss: 0.510, WER: 0.751, CER: 0.494\n",
      "Epoch [9/10], Iteration: 3650, Loss: 0.490, WER: 0.747, CER: 0.491\n",
      "Epoch [9/10], Iteration: 3700, Loss: 0.502, WER: 0.743, CER: 0.487\n",
      "Evaluation Loss: 9.000, eval WER: 0.451, eval CER: 0.402\n",
      "Epoch [10/10], Iteration: 3750, Loss: 0.525, WER: 0.739, CER: 0.483\n",
      "Epoch [10/10], Iteration: 3800, Loss: 0.478, WER: 0.734, CER: 0.480\n",
      "Epoch [10/10], Iteration: 3850, Loss: 0.488, WER: 0.730, CER: 0.476\n",
      "Epoch [10/10], Iteration: 3900, Loss: 0.483, WER: 0.726, CER: 0.473\n",
      "Epoch [10/10], Iteration: 3950, Loss: 0.422, WER: 0.722, CER: 0.470\n",
      "Epoch [10/10], Iteration: 4000, Loss: 0.431, WER: 0.718, CER: 0.466\n",
      "Epoch [10/10], Iteration: 4050, Loss: 0.479, WER: 0.714, CER: 0.463\n",
      "Epoch [10/10], Iteration: 4100, Loss: 0.438, WER: 0.710, CER: 0.460\n",
      "Evaluation Loss: 10.000, eval WER: 0.401, eval CER: 0.351\n"
     ]
    }
   ],
   "source": [
    "outputs = {}\n",
    "losses, gru_WER, gru_CER = train('gru')  \n",
    "outputs.update({'gru': {'train_wer': gru_WER, 'train_cer': gru_CER, 'train_loss': losses}})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_error_curves_comparison(outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "device:  cuda\n",
      "data loaded\n",
      "model loaded\n",
      "start training...\n",
      "Epoch [1/10], Iteration: 50, Loss: 2.896, WER: 1.000, CER: 1.073\n",
      "Epoch [1/10], Iteration: 100, Loss: 2.810, WER: 1.000, CER: 1.037\n",
      "Epoch [1/10], Iteration: 150, Loss: 2.704, WER: 1.000, CER: 1.024\n",
      "Epoch [1/10], Iteration: 200, Loss: 2.634, WER: 0.999, CER: 1.006\n",
      "Epoch [1/10], Iteration: 250, Loss: 2.531, WER: 0.999, CER: 0.990\n",
      "Epoch [1/10], Iteration: 300, Loss: 2.380, WER: 0.999, CER: 0.975\n",
      "Epoch [1/10], Iteration: 350, Loss: 2.291, WER: 0.999, CER: 0.963\n",
      "Epoch [1/10], Iteration: 400, Loss: 2.175, WER: 0.999, CER: 0.952\n",
      "Evaluation Loss: 1.000, eval WER: 2.136, eval CER: 1.000\n",
      "Epoch [2/10], Iteration: 450, Loss: 2.084, WER: 0.999, CER: 0.940\n",
      "Epoch [2/10], Iteration: 500, Loss: 1.992, WER: 0.998, CER: 0.929\n",
      "Epoch [2/10], Iteration: 550, Loss: 1.937, WER: 0.997, CER: 0.917\n",
      "Epoch [2/10], Iteration: 600, Loss: 1.846, WER: 0.996, CER: 0.905\n",
      "Epoch [2/10], Iteration: 650, Loss: 1.781, WER: 0.995, CER: 0.893\n",
      "Epoch [2/10], Iteration: 700, Loss: 1.688, WER: 0.995, CER: 0.882\n",
      "Epoch [2/10], Iteration: 750, Loss: 1.638, WER: 0.994, CER: 0.870\n",
      "Epoch [2/10], Iteration: 800, Loss: 1.537, WER: 0.992, CER: 0.858\n",
      "Evaluation Loss: 2.000, eval WER: 1.458, eval CER: 0.944\n",
      "Epoch [3/10], Iteration: 850, Loss: 1.523, WER: 0.991, CER: 0.846\n",
      "Epoch [3/10], Iteration: 900, Loss: 1.423, WER: 0.989, CER: 0.835\n",
      "Epoch [3/10], Iteration: 950, Loss: 1.389, WER: 0.987, CER: 0.823\n",
      "Epoch [3/10], Iteration: 1000, Loss: 1.307, WER: 0.985, CER: 0.812\n",
      "Epoch [3/10], Iteration: 1050, Loss: 1.285, WER: 0.982, CER: 0.800\n",
      "Epoch [3/10], Iteration: 1100, Loss: 1.229, WER: 0.979, CER: 0.789\n",
      "Epoch [3/10], Iteration: 1150, Loss: 1.171, WER: 0.975, CER: 0.777\n",
      "Epoch [3/10], Iteration: 1200, Loss: 1.110, WER: 0.970, CER: 0.765\n",
      "Evaluation Loss: 3.000, eval WER: 1.020, eval CER: 0.804\n",
      "Epoch [4/10], Iteration: 1250, Loss: 1.110, WER: 0.965, CER: 0.754\n",
      "Epoch [4/10], Iteration: 1300, Loss: 1.028, WER: 0.959, CER: 0.742\n",
      "Epoch [4/10], Iteration: 1350, Loss: 1.033, WER: 0.953, CER: 0.730\n",
      "Epoch [4/10], Iteration: 1400, Loss: 0.951, WER: 0.946, CER: 0.719\n",
      "Epoch [4/10], Iteration: 1450, Loss: 0.853, WER: 0.938, CER: 0.707\n",
      "Epoch [4/10], Iteration: 1500, Loss: 0.912, WER: 0.930, CER: 0.696\n",
      "Epoch [4/10], Iteration: 1550, Loss: 0.891, WER: 0.921, CER: 0.685\n",
      "Epoch [4/10], Iteration: 1600, Loss: 0.942, WER: 0.913, CER: 0.674\n",
      "Epoch [4/10], Iteration: 1650, Loss: 0.854, WER: 0.904, CER: 0.664\n",
      "Evaluation Loss: 4.000, eval WER: 0.751, eval CER: 0.546\n",
      "Epoch [5/10], Iteration: 1700, Loss: 0.764, WER: 0.895, CER: 0.654\n",
      "Epoch [5/10], Iteration: 1750, Loss: 0.724, WER: 0.886, CER: 0.644\n",
      "Epoch [5/10], Iteration: 1800, Loss: 0.719, WER: 0.877, CER: 0.634\n",
      "Epoch [5/10], Iteration: 1850, Loss: 0.736, WER: 0.868, CER: 0.624\n",
      "Epoch [5/10], Iteration: 1900, Loss: 0.693, WER: 0.859, CER: 0.615\n",
      "Epoch [5/10], Iteration: 1950, Loss: 0.631, WER: 0.851, CER: 0.606\n",
      "Epoch [5/10], Iteration: 2000, Loss: 0.669, WER: 0.842, CER: 0.597\n",
      "Epoch [5/10], Iteration: 2050, Loss: 0.633, WER: 0.834, CER: 0.589\n",
      "Evaluation Loss: 5.000, eval WER: 0.598, eval CER: 0.476\n",
      "Epoch [6/10], Iteration: 2100, Loss: 0.628, WER: 0.826, CER: 0.581\n",
      "Epoch [6/10], Iteration: 2150, Loss: 0.599, WER: 0.818, CER: 0.573\n",
      "Epoch [6/10], Iteration: 2200, Loss: 0.556, WER: 0.810, CER: 0.565\n",
      "Epoch [6/10], Iteration: 2250, Loss: 0.596, WER: 0.803, CER: 0.558\n",
      "Epoch [6/10], Iteration: 2300, Loss: 0.555, WER: 0.796, CER: 0.550\n",
      "Epoch [6/10], Iteration: 2350, Loss: 0.570, WER: 0.788, CER: 0.543\n",
      "Epoch [6/10], Iteration: 2400, Loss: 0.584, WER: 0.781, CER: 0.537\n",
      "Epoch [6/10], Iteration: 2450, Loss: 0.455, WER: 0.774, CER: 0.530\n",
      "Evaluation Loss: 6.000, eval WER: 0.452, eval CER: 0.402\n",
      "Epoch [7/10], Iteration: 2500, Loss: 0.490, WER: 0.768, CER: 0.523\n",
      "Epoch [7/10], Iteration: 2550, Loss: 0.445, WER: 0.761, CER: 0.517\n",
      "Epoch [7/10], Iteration: 2600, Loss: 0.469, WER: 0.754, CER: 0.511\n",
      "Epoch [7/10], Iteration: 2650, Loss: 0.462, WER: 0.748, CER: 0.505\n",
      "Epoch [7/10], Iteration: 2700, Loss: 0.448, WER: 0.741, CER: 0.499\n",
      "Epoch [7/10], Iteration: 2750, Loss: 0.460, WER: 0.735, CER: 0.493\n",
      "Epoch [7/10], Iteration: 2800, Loss: 0.463, WER: 0.729, CER: 0.487\n",
      "Epoch [7/10], Iteration: 2850, Loss: 0.420, WER: 0.723, CER: 0.482\n",
      "Evaluation Loss: 7.000, eval WER: 0.429, eval CER: 0.332\n",
      "Epoch [8/10], Iteration: 2900, Loss: 0.357, WER: 0.717, CER: 0.477\n",
      "Epoch [8/10], Iteration: 2950, Loss: 0.477, WER: 0.711, CER: 0.471\n",
      "Epoch [8/10], Iteration: 3000, Loss: 0.462, WER: 0.705, CER: 0.466\n",
      "Epoch [8/10], Iteration: 3050, Loss: 0.402, WER: 0.700, CER: 0.461\n",
      "Epoch [8/10], Iteration: 3100, Loss: 0.362, WER: 0.694, CER: 0.456\n",
      "Epoch [8/10], Iteration: 3150, Loss: 0.334, WER: 0.688, CER: 0.452\n",
      "Epoch [8/10], Iteration: 3200, Loss: 0.439, WER: 0.683, CER: 0.447\n",
      "Epoch [8/10], Iteration: 3250, Loss: 0.383, WER: 0.678, CER: 0.442\n",
      "Epoch [8/10], Iteration: 3300, Loss: 0.397, WER: 0.673, CER: 0.438\n",
      "Evaluation Loss: 8.000, eval WER: 0.375, eval CER: 0.295\n",
      "Epoch [9/10], Iteration: 3350, Loss: 0.297, WER: 0.668, CER: 0.434\n",
      "Epoch [9/10], Iteration: 3400, Loss: 0.331, WER: 0.663, CER: 0.429\n",
      "Epoch [9/10], Iteration: 3450, Loss: 0.333, WER: 0.658, CER: 0.425\n",
      "Epoch [9/10], Iteration: 3500, Loss: 0.343, WER: 0.653, CER: 0.421\n",
      "Epoch [9/10], Iteration: 3550, Loss: 0.374, WER: 0.649, CER: 0.417\n",
      "Epoch [9/10], Iteration: 3600, Loss: 0.298, WER: 0.644, CER: 0.414\n",
      "Epoch [9/10], Iteration: 3650, Loss: 0.337, WER: 0.640, CER: 0.410\n",
      "Epoch [9/10], Iteration: 3700, Loss: 0.398, WER: 0.635, CER: 0.406\n",
      "Evaluation Loss: 9.000, eval WER: 0.307, eval CER: 0.247\n",
      "Epoch [10/10], Iteration: 3750, Loss: 0.395, WER: 0.631, CER: 0.403\n",
      "Epoch [10/10], Iteration: 3800, Loss: 0.370, WER: 0.627, CER: 0.399\n",
      "Epoch [10/10], Iteration: 3850, Loss: 0.279, WER: 0.623, CER: 0.396\n",
      "Epoch [10/10], Iteration: 3900, Loss: 0.319, WER: 0.619, CER: 0.392\n",
      "Epoch [10/10], Iteration: 3950, Loss: 0.311, WER: 0.615, CER: 0.389\n",
      "Epoch [10/10], Iteration: 4000, Loss: 0.253, WER: 0.611, CER: 0.385\n",
      "Epoch [10/10], Iteration: 4050, Loss: 0.280, WER: 0.607, CER: 0.382\n",
      "Epoch [10/10], Iteration: 4100, Loss: 0.232, WER: 0.603, CER: 0.379\n",
      "Evaluation Loss: 10.000, eval WER: 0.276, eval CER: 0.263\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'Lstm_WER' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[11], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m losses, lstm_WER, lstm_CER \u001b[38;5;241m=\u001b[39m train(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlstm\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m outputs\u001b[38;5;241m.\u001b[39mupdate({\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlstm\u001b[39m\u001b[38;5;124m'\u001b[39m: {\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_wer\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[43mLstm_WER\u001b[49m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_cer\u001b[39m\u001b[38;5;124m'\u001b[39m: Lstm_CER, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain_loss\u001b[39m\u001b[38;5;124m'\u001b[39m: losses}})\n",
      "\u001b[0;31mNameError\u001b[0m: name 'Lstm_WER' is not defined"
     ]
    }
   ],
   "source": [
    "losses, lstm_WER, lstm_CER = train('lstm')\n",
    "outputs.update({'lstm': {'train_wer': Lstm_WER, 'train_cer': Lstm_CER, 'train_loss': losses}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs.update({'lstm': {'train_wer': lstm_WER, 'train_cer': lstm_CER, 'train_loss': losses}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "def plot_error_curves(output, mode='test'):\n",
    "    iters = len(output['gru']['train_wer'])\n",
    "    plt.figure(figsize=(18, 6)) #   (width, height)\n",
    "    # plot WER\n",
    "    plt.subplot(131)    # 1 row, 2 cols, subplot 1\n",
    "    for i, k in enumerate(output):\n",
    "        plt.plot(range(len(output[k]['train_wer'])), output[k]['train_wer'], label=k)\n",
    "    plt.title('{} Word Error Rate (WER)'.format(mode))\n",
    "    plt.xlabel('Iteration')\n",
    "    plt.ylabel('WER')\n",
    "    plt.legend()    \n",
    "\n",
    "    # plot CER\n",
    "    plt.subplot(132)    # 1 row, 2 cols, subplot 2\n",
    "    for i, k in enumerate(output):\n",
    "        plt.plot(range(len(output[k]['train_cer'])), output[k]['train_cer'], label=k)\n",
    "    plt.title('{} Character Error Rate (CER)'.format(mode))\n",
    "    plt.xlabel('Iteration')\n",
    "    plt.ylabel('CER')\n",
    "    plt.legend()\n",
    "\n",
    "    # plot training loss\n",
    "    plt.subplot(133)    # 1 row, 2 cols, subplot 3\n",
    "    for i, k in enumerate(output):\n",
    "        plt.plot(range(len(output[k]['train_loss'])), output[k]['train_loss'], label=k)\n",
    "    plt.title('{} Training Loss'.format(mode))\n",
    "    plt.xlabel('Iteration')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.legend()\n",
    "\n",
    "    \n",
    "plot_error_curves(outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}