Transfomer added, many other changes.

1 files changed, 310 insertions, 0 deletions

diff --git a/src/notebooks/Untitled.ipynb b/src/notebooks/Untitled.ipynb
new file mode 100644
index 0000000..76c4d28
--- /dev/null
+++ b/src/notebooks/Untitled.ipynb
@@ -0,0 +1,310 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import importlib\n",
+    "import cv2\n",
+    "import yaml\n",
+    "\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from importlib.util import find_spec\n",
+    "if find_spec(\"text_recognizer\") is None:\n",
+    "    import sys\n",
+    "    sys.path.append('..')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def convert_y_label_to_string(y, dataset=dataset):\n",
+    "    return ''.join([dataset.mapper(int(i)) for i in y])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from text_recognizer.models import VisionTransformerModel\n",
+    "from text_recognizer.datasets import IamLinesDataset\n",
+    "from text_recognizer.datasets.transforms import Compose, AddTokens"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "target_transform = Compose([torch.tensor, AddTokens(init_token=\"<sos>\", eos_token=\"<eos>\")])\n",
+    "dataset = IamLinesDataset(train=True, init_token=\"<sos>\", pad_token=\"_\", eos_token=\"<eos>\", target_transform=target_transform)\n",
+    "dataset.load_or_generate_data()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config_path = \"../training/experiments/VisionTransformerModel_IamLinesDataset_VisionTransformer/1021_083538/config.yml\"\n",
+    "with open(config_path, \"r\") as f:\n",
+    "    experiment_config = yaml.safe_load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset_args = experiment_config.get(\"dataset\", {})\n",
+    "datasets_module = importlib.import_module(\"text_recognizer.datasets\")\n",
+    "dataset_ = getattr(datasets_module, dataset_args[\"type\"])\n",
+    "\n",
+    "network_module = importlib.import_module(\"text_recognizer.networks\")\n",
+    "network_fn_ = getattr(network_module, experiment_config[\"network\"][\"type\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2020-10-21 23:27:40.719 | DEBUG    | text_recognizer.models.base:load_weights:454 - Loading network with pretrained weights.\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = VisionTransformerModel(network_fn=network_fn_, dataset=dataset_, dataset_args=dataset_args)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2020-10-21 23:29:55.892 | DEBUG    | text_recognizer.models.base:load_from_checkpoint:402 - Loading checkpoint...\n"
+     ]
+    }
+   ],
+   "source": [
+    "checkpoint_path = \"../training/experiments/VisionTransformerModel_IamLinesDataset_VisionTransformer/1021_083538/model/last.pt\"\n",
+    "model.load_from_checkpoint(checkpoint_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data, target = dataset[18]\n",
+    "sentence = convert_y_label_to_string(target, dataset) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "([], [])"
+      ]
+     },
+     "execution_count": 91,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x1440 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20, 20))\n",
+    "plt.title(sentence)\n",
+    "plt.imshow(data.squeeze(0).numpy(), cmap='gray')\n",
+    "plt.xticks([])\n",
+    "plt.yticks([])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 92,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('Since 1958, 13 Labour life Peers and<eos>', 0.9999997615814209)"
+      ]
+     },
+     "execution_count": 92,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.predict_on_image(data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[1, 28, 952], [92]]"
+      ]
+     },
+     "execution_count": 95,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "experiment_config[\"train_args\"][\"input_shape\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=========================================================================================================\n",
+      "Layer (type:depth-idx)                                  Output Shape              Param #\n",
+      "=========================================================================================================\n",
+      "├─Sequential: 1-1                                       [-1, 158, 1, 28, 6]       --\n",
+      "|    └─Unfold: 2-1                                      [-1, 168, 158]            --\n",
+      "|    └─Rearrange: 2-2                                   [-1, 158, 1, 28, 6]       --\n",
+      "├─Linear: 1-2                                           [-1, 158, 512]            86,528\n",
+      "├─PositionalEncoding: 1-3                               [-1, 158, 512]            --\n",
+      "|    └─Dropout: 2-3                                     [-1, 158, 512]            --\n",
+      "├─Embedding: 1-4                                        [-1, 92, 512]             41,984\n",
+      "├─PositionalEncoding: 1-5                               [-1, 92, 512]             --\n",
+      "|    └─Dropout: 2-4                                     [-1, 92, 512]             --\n",
+      "├─Transformer: 1-6                                      [-1, 92, 512]             --\n",
+      "|    └─Encoder: 2-5                                     [-1, 158, 512]            --\n",
+      "|    |    └─ModuleList: 3                               []                        --\n",
+      "|    |    |    └─EncoderLayer: 4-1                      [-1, 158, 512]            3,150,848\n",
+      "|    |    |    └─EncoderLayer: 4-2                      [-1, 158, 512]            3,150,848\n",
+      "|    |    |    └─EncoderLayer: 4-3                      [-1, 158, 512]            3,150,848\n",
+      "|    |    |    └─EncoderLayer: 4-4                      [-1, 158, 512]            3,150,848\n",
+      "|    |    └─LayerNorm: 3-1                              [-1, 158, 512]            1,024\n",
+      "|    └─Decoder: 2-6                                     [-1, 92, 512]             --\n",
+      "|    |    └─ModuleList: 3                               []                        --\n",
+      "|    |    |    └─DecoderLayer: 4-5                      [-1, 92, 512]             4,200,960\n",
+      "|    |    |    └─DecoderLayer: 4-6                      [-1, 92, 512]             4,200,960\n",
+      "|    |    |    └─DecoderLayer: 4-7                      [-1, 92, 512]             4,200,960\n",
+      "|    |    |    └─DecoderLayer: 4-8                      [-1, 92, 512]             4,200,960\n",
+      "|    |    └─LayerNorm: 3-2                              [-1, 92, 512]             1,024\n",
+      "├─Sequential: 1-7                                       [-1, 92, 82]              --\n",
+      "|    └─LayerNorm: 2-7                                   [-1, 92, 512]             1,024\n",
+      "|    └─Linear: 2-8                                      [-1, 92, 512]             262,656\n",
+      "|    └─GELU: 2-9                                        [-1, 92, 512]             --\n",
+      "|    └─Dropout: 2-10                                    [-1, 92, 512]             --\n",
+      "|    └─Linear: 2-11                                     [-1, 92, 82]              42,066\n",
+      "=========================================================================================================\n",
+      "Total params: 29,843,538\n",
+      "Trainable params: 29,843,538\n",
+      "Non-trainable params: 0\n",
+      "Total mult-adds (M): 118.22\n",
+      "=========================================================================================================\n",
+      "Input size (MB): 0.10\n",
+      "Forward/backward pass size (MB): 2.73\n",
+      "Params size (MB): 113.84\n",
+      "Estimated Total Size (MB): 116.68\n",
+      "=========================================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.summary(experiment_config[\"train_args\"][\"input_shape\"], 4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}