diff options
83 files changed, 5541 insertions, 1312 deletions
@@ -141,5 +141,7 @@ src/training/experiments/* !src/training/experiments/iam_line_ctc_experiment.yml !src/training/experiments/line_ctc_experiment.yml !src/training/experiments/default_config_emnist.yml - -wandb/* +!src/training/experiments/embedding_experiment.yml +src/text_recognizer/weights/*Transformer*.pt +src/wandb/* +!src/wandb/settings @@ -51,10 +51,13 @@ TBC - [x] IAM dataset - [x] IAM Lines dataset - [x] IAM paragraphs dataset -- [ ] CNN + Transformer +- [ ] CNN + Transformer (!!) +- [ ] CNN + GPT - [ ] fix nosec problem - [x] common Dataset class - [x] Fix CTC blank stuff and varying length +- [x] Metric Learning for backbone training + ## Run Sweeps Run the following commands to execute hyperparameter search with W&B: diff --git a/poetry.lock b/poetry.lock index 7176cdb..6d07542 100644 --- a/poetry.lock +++ b/poetry.lock @@ -334,6 +334,17 @@ version = "0.3" [[package]] category = "main" +description = "A library for efficient similarity search and clustering of dense vectors." +name = "faiss-gpu" +optional = false +python-versions = "*" +version = "1.6.3" + +[package.dependencies] +numpy = "*" + +[[package]] +category = "main" description = "the modular source code checker: pep8 pyflakes and co" name = "flake8" optional = false @@ -1030,6 +1041,18 @@ version = "7.352.0" [[package]] category = "main" +description = "A flexible configuration library" +name = "omegaconf" +optional = false +python-versions = ">=3.6" +version = "2.0.2" + +[package.dependencies] +PyYAML = ">=5.1" +typing-extensions = "*" + +[[package]] +category = "main" description = "Wrapper package for OpenCV python bindings." name = "opencv-python" optional = false @@ -1342,6 +1365,34 @@ version = "0.12.0" setuptools = "*" [[package]] +category = "main" +description = "PyTorch extension for fast block sparse matrices computation, drop in replacement for torch.nn.Linear." +name = "pytorch-block-sparse" +optional = false +python-versions = "*" +version = "0.1.2" + +[[package]] +category = "main" +description = "The easiest way to use deep metric learning in your application. Modular, flexible, and extensible. Written in PyTorch." +name = "pytorch-metric-learning" +optional = false +python-versions = ">=3.0" +version = "0.9.92" + +[package.dependencies] +numpy = "*" +scikit-learn = "*" +torch = ">=1.6.0" +torchvision = "*" +tqdm = "*" + +[package.extras] +dev = ["pytest (>3.8)", "pytest-cov (>=2.8,<3.0)"] +with-hooks = ["record-keeper (>=0.9.29)", "faiss-gpu (>=1.6.3)", "tensorboard"] +with-hooks-cpu = ["record-keeper (>=0.9.29)", "faiss-cpu (>=1.6.3)", "tensorboard"] + +[[package]] category = "dev" description = "Python type inferencer" marker = "python_version == \"3.7\"" @@ -1494,6 +1545,34 @@ requests = "*" setuptools = "*" [[package]] +category = "main" +description = "A set of python modules for machine learning and data mining" +name = "scikit-learn" +optional = false +python-versions = ">=3.6" +version = "0.23.2" + +[package.dependencies] +joblib = ">=0.11" +numpy = ">=1.13.3" +scipy = ">=0.19.1" +threadpoolctl = ">=2.0.0" + +[package.extras] +alldeps = ["numpy (>=1.13.3)", "scipy (>=0.19.1)"] + +[[package]] +category = "main" +description = "SciPy: Scientific Library for Python" +name = "scipy" +optional = false +python-versions = ">=3.6" +version = "1.5.2" + +[package.dependencies] +numpy = ">=1.14.5" + +[[package]] category = "dev" description = "Send file to trash natively under Mac OS X, Windows and Linux." name = "send2trash" @@ -1738,6 +1817,14 @@ test = ["pathlib2"] [[package]] category = "main" +description = "threadpoolctl" +name = "threadpoolctl" +optional = false +python-versions = ">=3.5" +version = "2.1.0" + +[[package]] +category = "main" description = "Python Library for Tom's Obvious, Minimal Language" name = "toml" optional = false @@ -1981,7 +2068,7 @@ docs = ["sphinx", "jaraco.packaging (>=3.2)", "rst.linker (>=1.9)"] testing = ["jaraco.itertools", "func-timeout"] [metadata] -content-hash = "d2554d5ea2a2de69322438b76e2dc21566d82b0aeb0c5e8a0ebcd69c0a057dba" +content-hash = "c8511d6e4ae5708277c07f553830c11d3dc5cd77ca7f99bb47cd94dbb21d4b13" lock-version = "1.0" python-versions = "^3.7" @@ -2183,6 +2270,13 @@ entrypoints = [ {file = "entrypoints-0.3-py2.py3-none-any.whl", hash = "sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19"}, {file = "entrypoints-0.3.tar.gz", hash = "sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451"}, ] +faiss-gpu = [ + {file = "faiss-gpu-1.6.3.tar.gz", hash = "sha256:46092bcf20789353d9ffc45b0b10df6fdc1d2078983be2d97e78203b71827986"}, + {file = "faiss_gpu-1.6.3-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:e17178990518bd55e91c8364ef57dc4e3b4d20691c15e4eba6c88fd31e2e0c3a"}, + {file = "faiss_gpu-1.6.3-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:45f702846168d9b3a9435745c21fb6786684cbfa849a2e01cd79c2224eff4698"}, + {file = "faiss_gpu-1.6.3-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:cfdfe6681e24b69f429dcdec33d3a25ee2465a5e691d851218482ba8ad6892ee"}, + {file = "faiss_gpu-1.6.3-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:70b3ebe0fdd8438e8d385684de00e7605b562a7680abba72fad4ef5c7f955fbf"}, +] flake8 = [ {file = "flake8-3.8.3-py2.py3-none-any.whl", hash = "sha256:15e351d19611c887e482fb960eae4d44845013cc142d42896e9862f775d8cf5c"}, {file = "flake8-3.8.3.tar.gz", hash = "sha256:f04b9fcbac03b0a3e58c0ab3a0ecc462e023a9faf046d57794184028123aa208"}, @@ -2504,6 +2598,10 @@ numpy = [ nvidia-ml-py3 = [ {file = "nvidia-ml-py3-7.352.0.tar.gz", hash = "sha256:390f02919ee9d73fe63a98c73101061a6b37fa694a793abf56673320f1f51277"}, ] +omegaconf = [ + {file = "omegaconf-2.0.2-py3-none-any.whl", hash = "sha256:3892d6a6848e1f54869d6ea3720f7208e4bb4276774f97dbb899fb540ac84506"}, + {file = "omegaconf-2.0.2.tar.gz", hash = "sha256:dede7746b3dc18c5670dcec4ce283593d229a055a1c9cf089e2663545396fba0"}, +] opencv-python = [ {file = "opencv-python-4.4.0.42.tar.gz", hash = "sha256:0039506845d7076e6871c0075227881a84de69799d70ed37c8704d203b740911"}, {file = "opencv_python-4.4.0.42-cp35-cp35m-macosx_10_13_x86_64.whl", hash = "sha256:608dae0444065669fc26fa6bf1653072e40735b33dfa514c74a6165563a99e97"}, @@ -2667,6 +2765,13 @@ python-dateutil = [ python-levenshtein = [ {file = "python-Levenshtein-0.12.0.tar.gz", hash = "sha256:033a11de5e3d19ea25c9302d11224e1a1898fe5abd23c61c7c360c25195e3eb1"}, ] +pytorch-block-sparse = [ + {file = "pytorch_block_sparse-0.1.2.tar.gz", hash = "sha256:ca4a5c1dde96ac01c007f209067b2bbaee311a8699eba1eef712faef7f97df1f"}, +] +pytorch-metric-learning = [ + {file = "pytorch-metric-learning-0.9.92.tar.gz", hash = "sha256:d46eb3edfcae3f5dc2cf1b4478c108665a7205ba59e36c131b76d6909670737d"}, + {file = "pytorch_metric_learning-0.9.92-py3-none-any.whl", hash = "sha256:a2583da7d442da26ca2af4932591c5812994874ff0320fe0ade20a4c56126f6d"}, +] pytype = [ {file = "pytype-2020.8.10-cp35-cp35m-macosx_10_14_x86_64.whl", hash = "sha256:da1977a1aa74fbd237e889c1d29421d490e0be9a91a22efd96fbca2570ef9165"}, {file = "pytype-2020.8.10-cp35-cp35m-manylinux2014_x86_64.whl", hash = "sha256:e0909b99aff8eff0ece91fd64e00b935f0e4fecb51359d83d742b27db160dd00"}, @@ -2795,6 +2900,42 @@ safety = [ {file = "safety-1.9.0-py2.py3-none-any.whl", hash = "sha256:86c1c4a031fe35bd624fce143fbe642a0234d29f7cbf7a9aa269f244a955b087"}, {file = "safety-1.9.0.tar.gz", hash = "sha256:23bf20690d4400edc795836b0c983c2b4cbbb922233108ff925b7dd7750f00c9"}, ] +scikit-learn = [ + {file = "scikit-learn-0.23.2.tar.gz", hash = "sha256:20766f515e6cd6f954554387dfae705d93c7b544ec0e6c6a5d8e006f6f7ef480"}, + {file = "scikit_learn-0.23.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:98508723f44c61896a4e15894b2016762a55555fbf09365a0bb1870ecbd442de"}, + {file = "scikit_learn-0.23.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:a64817b050efd50f9abcfd311870073e500ae11b299683a519fbb52d85e08d25"}, + {file = "scikit_learn-0.23.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:daf276c465c38ef736a79bd79fc80a249f746bcbcae50c40945428f7ece074f8"}, + {file = "scikit_learn-0.23.2-cp36-cp36m-win32.whl", hash = "sha256:cb3e76380312e1f86abd20340ab1d5b3cc46a26f6593d3c33c9ea3e4c7134028"}, + {file = "scikit_learn-0.23.2-cp36-cp36m-win_amd64.whl", hash = "sha256:0a127cc70990d4c15b1019680bfedc7fec6c23d14d3719fdf9b64b22d37cdeca"}, + {file = "scikit_learn-0.23.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:2aa95c2f17d2f80534156215c87bee72b6aa314a7f8b8fe92a2d71f47280570d"}, + {file = "scikit_learn-0.23.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:6c28a1d00aae7c3c9568f61aafeaad813f0f01c729bee4fd9479e2132b215c1d"}, + {file = "scikit_learn-0.23.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:da8e7c302003dd765d92a5616678e591f347460ac7b53e53d667be7dfe6d1b10"}, + {file = "scikit_learn-0.23.2-cp37-cp37m-win32.whl", hash = "sha256:d9a1ce5f099f29c7c33181cc4386660e0ba891b21a60dc036bf369e3a3ee3aec"}, + {file = "scikit_learn-0.23.2-cp37-cp37m-win_amd64.whl", hash = "sha256:914ac2b45a058d3f1338d7736200f7f3b094857758895f8667be8a81ff443b5b"}, + {file = "scikit_learn-0.23.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7671bbeddd7f4f9a6968f3b5442dac5f22bf1ba06709ef888cc9132ad354a9ab"}, + {file = "scikit_learn-0.23.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:d0dcaa54263307075cb93d0bee3ceb02821093b1b3d25f66021987d305d01dce"}, + {file = "scikit_learn-0.23.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:5ce7a8021c9defc2b75620571b350acc4a7d9763c25b7593621ef50f3bd019a2"}, + {file = "scikit_learn-0.23.2-cp38-cp38-win32.whl", hash = "sha256:0d39748e7c9669ba648acf40fb3ce96b8a07b240db6888563a7cb76e05e0d9cc"}, + {file = "scikit_learn-0.23.2-cp38-cp38-win_amd64.whl", hash = "sha256:1b8a391de95f6285a2f9adffb7db0892718950954b7149a70c783dc848f104ea"}, +] +scipy = [ + {file = "scipy-1.5.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:cca9fce15109a36a0a9f9cfc64f870f1c140cb235ddf27fe0328e6afb44dfed0"}, + {file = "scipy-1.5.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:1c7564a4810c1cd77fcdee7fa726d7d39d4e2695ad252d7c86c3ea9d85b7fb8f"}, + {file = "scipy-1.5.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:07e52b316b40a4f001667d1ad4eb5f2318738de34597bd91537851365b6c61f1"}, + {file = "scipy-1.5.2-cp36-cp36m-win32.whl", hash = "sha256:d56b10d8ed72ec1be76bf10508446df60954f08a41c2d40778bc29a3a9ad9bce"}, + {file = "scipy-1.5.2-cp36-cp36m-win_amd64.whl", hash = "sha256:8e28e74b97fc8d6aa0454989db3b5d36fc27e69cef39a7ee5eaf8174ca1123cb"}, + {file = "scipy-1.5.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:6e86c873fe1335d88b7a4bfa09d021f27a9e753758fd75f3f92d714aa4093768"}, + {file = "scipy-1.5.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:a0afbb967fd2c98efad5f4c24439a640d39463282040a88e8e928db647d8ac3d"}, + {file = "scipy-1.5.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:eecf40fa87eeda53e8e11d265ff2254729d04000cd40bae648e76ff268885d66"}, + {file = "scipy-1.5.2-cp37-cp37m-win32.whl", hash = "sha256:315aa2165aca31375f4e26c230188db192ed901761390be908c9b21d8b07df62"}, + {file = "scipy-1.5.2-cp37-cp37m-win_amd64.whl", hash = "sha256:ec5fe57e46828d034775b00cd625c4a7b5c7d2e354c3b258d820c6c72212a6ec"}, + {file = "scipy-1.5.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:fc98f3eac993b9bfdd392e675dfe19850cc8c7246a8fd2b42443e506344be7d9"}, + {file = "scipy-1.5.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:a785409c0fa51764766840185a34f96a0a93527a0ff0230484d33a8ed085c8f8"}, + {file = "scipy-1.5.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:0a0e9a4e58a4734c2eba917f834b25b7e3b6dc333901ce7784fd31aefbd37b2f"}, + {file = "scipy-1.5.2-cp38-cp38-win32.whl", hash = "sha256:dac09281a0eacd59974e24525a3bc90fa39b4e95177e638a31b14db60d3fa806"}, + {file = "scipy-1.5.2-cp38-cp38-win_amd64.whl", hash = "sha256:92eb04041d371fea828858e4fff182453c25ae3eaa8782d9b6c32b25857d23bc"}, + {file = "scipy-1.5.2.tar.gz", hash = "sha256:066c513d90eb3fd7567a9e150828d39111ebd88d3e924cdfc9f8ce19ab6f90c9"}, +] send2trash = [ {file = "Send2Trash-1.5.0-py3-none-any.whl", hash = "sha256:f1691922577b6fa12821234aeb57599d887c4900b9ca537948d2dac34aea888b"}, {file = "Send2Trash-1.5.0.tar.gz", hash = "sha256:60001cc07d707fe247c94f74ca6ac0d3255aabcb930529690897ca2a39db28b2"}, @@ -2871,6 +3012,10 @@ testpath = [ {file = "testpath-0.4.4-py2.py3-none-any.whl", hash = "sha256:bfcf9411ef4bf3db7579063e0546938b1edda3d69f4e1fb8756991f5951f85d4"}, {file = "testpath-0.4.4.tar.gz", hash = "sha256:60e0a3261c149755f4399a1fff7d37523179a70fdc3abdf78de9fc2604aeec7e"}, ] +threadpoolctl = [ + {file = "threadpoolctl-2.1.0-py3-none-any.whl", hash = "sha256:38b74ca20ff3bb42caca8b00055111d74159ee95c4370882bbff2b93d24da725"}, + {file = "threadpoolctl-2.1.0.tar.gz", hash = "sha256:ddc57c96a38beb63db45d6c159b5ab07b6bced12c45a1f07b2b92f272aebfa6b"}, +] toml = [ {file = "toml-0.10.1-py2.py3-none-any.whl", hash = "sha256:bda89d5935c2eac546d648028b9901107a595863cb36bae0c73ac804a9b4ce88"}, {file = "toml-0.10.1.tar.gz", hash = "sha256:926b612be1e5ce0634a2ca03470f95169cf16f939018233a670519cb4ac58b0f"}, diff --git a/pyproject.toml b/pyproject.toml index 43943e7..95e32a6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,6 +35,10 @@ wandb = "^0.9.6" torch-summary = "^1.4.2" python-Levenshtein = "^0.12.0" defusedxml = "^0.6.0" +pytorch-block-sparse = "^0.1.2" +pytorch-metric-learning = "^0.9.92" +faiss-gpu = "^1.6.3" +omegaconf = "^2.0.2" [tool.poetry.dev-dependencies] pytest = "^5.4.2" @@ -62,12 +66,14 @@ wandb = "^0.9.4" fail_under = 50 [tool.poetry.scripts] -download-emnist = "text_recognizer.datasets.emnist_dataset:download_emnist" +download-emnist = "text_recognizer.datasets.util:download_emnist" +download-iam = "text_recognizer.datasets.iam_dataset:main" create-emnist-support-files = "text_recognizer.tests.support.create_emnist_support_files:create_emnist_support_files" -run-experiment = "training.run_experiment:main" -run-experiments = "training.prepare_experiments:main" -# mlp = "text_recognizer.networks.mlp:test" -# lenet = "text_recognizer.networks.lenet:test" +create-emnist-lines-datasets = "text_recognizer.datasets.emnist_lines_dataset:create_datasets" +create-iam-paragraphs = "text_recognizer.datasets.iam_paragraphs_dataset:main" +prepare-experiments = "training.prepare_experiments:run_cli" + + [build-system] requires = ["poetry>=0.12"] diff --git a/src/notebooks/00-testing-stuff-out.ipynb b/src/notebooks/00-testing-stuff-out.ipynb index 0294394..62e549c 100644 --- a/src/notebooks/00-testing-stuff-out.ipynb +++ b/src/notebooks/00-testing-stuff-out.ipynb @@ -2,9 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "metadata": {}, - "outputs": [], + "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", @@ -14,6 +23,7 @@ "import numpy as np\n", "from PIL import Image\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", @@ -22,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -31,575 +41,946 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from text_recognizer.networks import WideResidualNetwork" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "wr = WideResidualNetwork(\n", + " in_channels= 1,\n", + " num_classes= 80,\n", + " in_planes=32,\n", + " depth=10,\n", + " num_layers=4,\n", + " width_factor=1,\n", + " dropout_rate= 0.2,\n", + " activation= \"SELU\",\n", + " use_decoder= True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from torchsummary import summary" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + " backbone = nn.Sequential(\n", + " *list(wr.children())[:][:-1]\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "IdentityBlock(\n", - " (blocks): Identity()\n", - " (activation_fn): ReLU(inplace=True)\n", - " (shortcut): Identity()\n", + "Sequential(\n", + " (0): SELU(inplace=True)\n", + " (1): Sequential(\n", + " (0): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): Sequential(\n", + " (0): WideBlock(\n", + " (activation): SELU(inplace=True)\n", + " (blocks): Sequential(\n", + " (0): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): SELU(inplace=True)\n", + " (2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (3): Dropout(p=0.2, inplace=False)\n", + " (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): SELU(inplace=True)\n", + " (6): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " )\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): WideBlock(\n", + " (activation): SELU(inplace=True)\n", + " (blocks): Sequential(\n", + " (0): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): SELU(inplace=True)\n", + " (2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (3): Dropout(p=0.2, inplace=False)\n", + " (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): SELU(inplace=True)\n", + " (6): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " )\n", + " (shortcut): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " )\n", + " )\n", + " )\n", + " (3): Sequential(\n", + " (0): WideBlock(\n", + " (activation): SELU(inplace=True)\n", + " (blocks): Sequential(\n", + " (0): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): SELU(inplace=True)\n", + " (2): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (3): Dropout(p=0.2, inplace=False)\n", + " (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): SELU(inplace=True)\n", + " (6): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " )\n", + " (shortcut): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " )\n", + " )\n", + " )\n", + " (4): Sequential(\n", + " (0): WideBlock(\n", + " (activation): SELU(inplace=True)\n", + " (blocks): Sequential(\n", + " (0): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): SELU(inplace=True)\n", + " (2): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (3): Dropout(p=0.2, inplace=False)\n", + " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): SELU(inplace=True)\n", + " (6): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " )\n", + " (shortcut): Sequential(\n", + " (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", ")" ] }, - "execution_count": 5, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "IdentityBlock(32, 64)" + "backbone" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { + "name": "stdout", + "output_type": "stream", + "text": [ + "==========================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "==========================================================================================\n", + "├─Sequential: 1-1 [-1, 256, 4, 119] --\n", + "| └─Conv2d: 2-1 [-1, 32, 28, 952] 288\n", + "| └─Sequential: 2-2 [-1, 32, 28, 952] --\n", + "| | └─WideBlock: 3-1 [-1, 32, 28, 952] 18,560\n", + "| └─Sequential: 2-3 [-1, 64, 14, 476] --\n", + "| | └─WideBlock: 3-2 [-1, 64, 14, 476] 57,536\n", + "| └─Sequential: 2-4 [-1, 128, 7, 238] --\n", + "| | └─WideBlock: 3-3 [-1, 128, 7, 238] 229,760\n", + "| └─Sequential: 2-5 [-1, 256, 4, 119] --\n", + "| | └─WideBlock: 3-4 [-1, 256, 4, 119] 918,272\n", + "├─Sequential: 1-2 [-1, 80] --\n", + "| └─BatchNorm2d: 2-6 [-1, 256, 4, 119] 512\n", + "├─SELU: 1-3 [-1, 256, 4, 119] --\n", + "├─Sequential: 1 [] --\n", + "| └─SELU: 2-7 [-1, 256, 4, 119] --\n", + "| └─Reduce: 2-8 [-1, 256] --\n", + "| └─Linear: 2-9 [-1, 80] 20,560\n", + "==========================================================================================\n", + "Total params: 1,245,488\n", + "Trainable params: 1,245,488\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 12.61\n", + "==========================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 7.44\n", + "Params size (MB): 4.75\n", + "Estimated Total Size (MB): 12.29\n", + "==========================================================================================\n" + ] + }, + { "data": { "text/plain": [ - "ResidualBlock(\n", - " (blocks): Identity()\n", - " (activation_fn): ReLU(inplace=True)\n", - " (shortcut): Sequential(\n", - " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - ")" + "==========================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "==========================================================================================\n", + "├─Sequential: 1-1 [-1, 256, 4, 119] --\n", + "| └─Conv2d: 2-1 [-1, 32, 28, 952] 288\n", + "| └─Sequential: 2-2 [-1, 32, 28, 952] --\n", + "| | └─WideBlock: 3-1 [-1, 32, 28, 952] 18,560\n", + "| └─Sequential: 2-3 [-1, 64, 14, 476] --\n", + "| | └─WideBlock: 3-2 [-1, 64, 14, 476] 57,536\n", + "| └─Sequential: 2-4 [-1, 128, 7, 238] --\n", + "| | └─WideBlock: 3-3 [-1, 128, 7, 238] 229,760\n", + "| └─Sequential: 2-5 [-1, 256, 4, 119] --\n", + "| | └─WideBlock: 3-4 [-1, 256, 4, 119] 918,272\n", + "├─Sequential: 1-2 [-1, 80] --\n", + "| └─BatchNorm2d: 2-6 [-1, 256, 4, 119] 512\n", + "├─SELU: 1-3 [-1, 256, 4, 119] --\n", + "├─Sequential: 1 [] --\n", + "| └─SELU: 2-7 [-1, 256, 4, 119] --\n", + "| └─Reduce: 2-8 [-1, 256] --\n", + "| └─Linear: 2-9 [-1, 80] 20,560\n", + "==========================================================================================\n", + "Total params: 1,245,488\n", + "Trainable params: 1,245,488\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 12.61\n", + "==========================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 7.44\n", + "Params size (MB): 4.75\n", + "Estimated Total Size (MB): 12.29\n", + "==========================================================================================" ] }, - "execution_count": 6, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ResidualBlock(32, 64)" + "summary(wr, (1, 28, 952), device=\"cpu\", depth=3)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "from torch import nn" + ] + }, + { + "cell_type": "code", + "execution_count": 70, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "BasicBlock(\n", - " (blocks): Sequential(\n", - " (0): Sequential(\n", - " (0): Conv2dAuto(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (1): ReLU(inplace=True)\n", - " (2): Sequential(\n", - " (0): Conv2dAuto(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (activation_fn): ReLU(inplace=True)\n", - " (shortcut): Sequential(\n", - " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - ")\n" - ] + "data": { + "text/plain": [ + "96" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "dummy = torch.ones((1, 32, 224, 224))\n", - "\n", - "block = BasicBlock(32, 64)\n", - "block(dummy).shape\n", - "print(block)" + "32 + 64" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 106, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "BottleNeckBlock(\n", - " (blocks): Sequential(\n", - " (0): Sequential(\n", - " (0): Conv2dAuto(32, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (1): ReLU(inplace=True)\n", - " (2): Sequential(\n", - " (0): Conv2dAuto(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (3): ReLU(inplace=True)\n", - " (4): Sequential(\n", - " (0): Conv2dAuto(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (activation_fn): ReLU(inplace=True)\n", - " (shortcut): Sequential(\n", - " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - ")\n" - ] + "data": { + "text/plain": [ + "336" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "dummy = torch.ones((1, 32, 10, 10))\n", - "\n", - "block = BottleNeckBlock(32, 64)\n", - "block(dummy).shape\n", - "print(block)" + "3 * 112" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ - "dummy = torch.ones((1, 64, 48, 48))\n", - "\n", - "layer = ResidualLayer(64, 128, block=BasicBlock, num_blocks=3)\n", - "layer(dummy).shape" + "col_embed = nn.Parameter(torch.rand(1000, 256 // 2))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ - "blocks_sizes=[64, 128, 256, 512]\n", - "list(zip(blocks_sizes, blocks_sizes[1:]))" + "W, H = 196, 4" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([4, 196, 128])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "col_embed[:W].unsqueeze(0).repeat(H, 1, 1).shape" ] }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([4, 196, 128])" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "col_embed[:H].unsqueeze(1).repeat(1, W, 1).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 4, 196, 256])" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + " torch.cat(\n", + " [\n", + " col_embed[:W].unsqueeze(0).repeat(H, 1, 1),\n", + " col_embed[:H].unsqueeze(1).repeat(1, W, 1),\n", + " ],\n", + " dim=-1,\n", + " ).unsqueeze(0).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "4 * 196" + ] + }, + { + "cell_type": "code", + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ - "e = Encoder(depths=[2, 1], block_sizes= [96, 128])" + "target = torch.tensor([1,1,12,1,1,1,1,1,9,9,9,9,9,9])" ] }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Encoder(\n", - " (gate): Sequential(\n", - " (0): Conv2d(1, 96, kernel_size=(3, 3), stride=(2, 2), padding=(3, 3), bias=False)\n", - " (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (2): ReLU(inplace=True)\n", - " (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", - " )\n", - " (blocks): Sequential(\n", - " (0): ResidualLayer(\n", - " (blocks): Sequential(\n", - " (0): BasicBlock(\n", - " (blocks): Sequential(\n", - " (0): Sequential(\n", - " (0): Conv2dAuto(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (1): ReLU(inplace=True)\n", - " (2): Sequential(\n", - " (0): Conv2dAuto(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (activation_fn): ReLU(inplace=True)\n", - " (shortcut): None\n", - " )\n", - " (1): BasicBlock(\n", - " (blocks): Sequential(\n", - " (0): Sequential(\n", - " (0): Conv2dAuto(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (1): ReLU(inplace=True)\n", - " (2): Sequential(\n", - " (0): Conv2dAuto(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (activation_fn): ReLU(inplace=True)\n", - " (shortcut): None\n", - " )\n", - " )\n", - " )\n", - " (1): ResidualLayer(\n", - " (blocks): Sequential(\n", - " (0): BasicBlock(\n", - " (blocks): Sequential(\n", - " (0): Sequential(\n", - " (0): Conv2dAuto(96, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (1): ReLU(inplace=True)\n", - " (2): Sequential(\n", - " (0): Conv2dAuto(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (activation_fn): ReLU(inplace=True)\n", - " (shortcut): Sequential(\n", - " (0): Conv2d(96, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " )\n", - " )\n", - " )\n", - ")" + "8" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.nonzero(target == 9, as_tuple=False)[0].item()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 1, 1, 12, 1, 1, 1, 1, 1, 9])" ] }, - "execution_count": 75, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "Encoder(**{\"depths\": [2, 1], \"block_sizes\": [96, 128]})" + "target[:9]" ] }, { "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", "execution_count": 9, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "inf" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.inf" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [], "source": [ - "from text_recognizer.networks import WideResidualNetwork" + "from text_recognizer.networks.transformer.positional_encoding import PositionalEncoding" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1080x360 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 5))\n", + "pe = PositionalEncoding(20, 0)\n", + "y = pe.forward(torch.zeros(1, 100, 20))\n", + "plt.plot(np.arange(100), y[0, :, 4:8].data.numpy())\n", + "plt.legend([\"dim %d\"%p for p in [4,5,6,7]])\n", + "None" + ] + }, + { + "cell_type": "code", + "execution_count": 74, "metadata": {}, "outputs": [], "source": [ - "wr = WideResidualNetwork(\n", - " in_channels= 1,\n", - " num_classes= 80,\n", - " depth= 16,\n", - " num_layers= 4,\n", - " width_factor= 2,\n", - " dropout_rate= 0.2,\n", - " activation= \"SELU\",\n", - " use_decoder= False,\n", - ")" + "from text_recognizer.networks.densenet import DenseNet,_DenseLayer,_DenseBlock" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 113, "metadata": {}, "outputs": [], "source": [ - "from torchsummary import summary" + "dnet = DenseNet(12, (6, 8, 10, 6), 1, 24, 80, 4, 0, False)" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 114, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "===============================================================================================\n", - "Layer (type:depth-idx) Output Shape Param #\n", - "===============================================================================================\n", - "├─Sequential: 1-1 [-1, 256, 4, 2] --\n", - "| └─Conv2d: 2-1 [-1, 16, 28, 14] 144\n", - "| └─Sequential: 2-2 [-1, 32, 28, 14] --\n", - "| | └─WideBlock: 3-1 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4-1 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-1 [-1, 32, 28, 14] 512\n", - "| | | └─Sequential: 4-2 [-1, 32, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-2 [-1, 16, 28, 14] 32\n", - "| | | └─SELU: 4-3 [-1, 16, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-3 [-1, 16, 28, 14] --\n", - "| | | | └─Conv2d: 5-4 [-1, 32, 28, 14] 4,608\n", - "| | | | └─Dropout: 5-5 [-1, 32, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-6 [-1, 32, 28, 14] 64\n", - "| | | └─SELU: 4-4 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-7 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-8 [-1, 32, 28, 14] 9,216\n", - "| | └─WideBlock: 3-2 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4-5 [-1, 32, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-9 [-1, 32, 28, 14] 64\n", - "| | | └─SELU: 4-6 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-10 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-11 [-1, 32, 28, 14] 9,216\n", - "| | | | └─Dropout: 5-12 [-1, 32, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-13 [-1, 32, 28, 14] 64\n", - "| | | └─SELU: 4-7 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-14 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-15 [-1, 32, 28, 14] 9,216\n", - "| └─Sequential: 2-3 [-1, 64, 14, 7] --\n", - "| | └─WideBlock: 3-3 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4-8 [-1, 64, 14, 7] --\n", - "| | | | └─Conv2d: 5-16 [-1, 64, 14, 7] 2,048\n", - "| | | └─Sequential: 4-9 [-1, 64, 14, 7] --\n", - "| | | | └─BatchNorm2d: 5-17 [-1, 32, 28, 14] 64\n", - "| | | └─SELU: 4-10 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-18 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-19 [-1, 64, 28, 14] 18,432\n", - "| | | | └─Dropout: 5-20 [-1, 64, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-21 [-1, 64, 28, 14] 128\n", - "| | | └─SELU: 4-11 [-1, 64, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-22 [-1, 64, 28, 14] --\n", - "| | | | └─Conv2d: 5-23 [-1, 64, 14, 7] 36,864\n", - "| | └─WideBlock: 3-4 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4-12 [-1, 64, 14, 7] --\n", - "| | | | └─BatchNorm2d: 5-24 [-1, 64, 14, 7] 128\n", - "| | | └─SELU: 4-13 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-25 [-1, 64, 14, 7] --\n", - "| | | | └─Conv2d: 5-26 [-1, 64, 14, 7] 36,864\n", - "| | | | └─Dropout: 5-27 [-1, 64, 14, 7] --\n", - "| | | | └─BatchNorm2d: 5-28 [-1, 64, 14, 7] 128\n", - "| | | └─SELU: 4-14 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-29 [-1, 64, 14, 7] --\n", - "| | | | └─Conv2d: 5-30 [-1, 64, 14, 7] 36,864\n", - "| └─Sequential: 2-4 [-1, 128, 7, 4] --\n", - "| | └─WideBlock: 3-5 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4-15 [-1, 128, 7, 4] --\n", - "| | | | └─Conv2d: 5-31 [-1, 128, 7, 4] 8,192\n", - "| | | └─Sequential: 4-16 [-1, 128, 7, 4] --\n", - "| | | | └─BatchNorm2d: 5-32 [-1, 64, 14, 7] 128\n", - "| | | └─SELU: 4-17 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-33 [-1, 64, 14, 7] --\n", - "| | | | └─Conv2d: 5-34 [-1, 128, 14, 7] 73,728\n", - "| | | | └─Dropout: 5-35 [-1, 128, 14, 7] --\n", - "| | | | └─BatchNorm2d: 5-36 [-1, 128, 14, 7] 256\n", - "| | | └─SELU: 4-18 [-1, 128, 14, 7] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-37 [-1, 128, 14, 7] --\n", - "| | | | └─Conv2d: 5-38 [-1, 128, 7, 4] 147,456\n", - "| | └─WideBlock: 3-6 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4-19 [-1, 128, 7, 4] --\n", - "| | | | └─BatchNorm2d: 5-39 [-1, 128, 7, 4] 256\n", - "| | | └─SELU: 4-20 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-40 [-1, 128, 7, 4] --\n", - "| | | | └─Conv2d: 5-41 [-1, 128, 7, 4] 147,456\n", - "| | | | └─Dropout: 5-42 [-1, 128, 7, 4] --\n", - "| | | | └─BatchNorm2d: 5-43 [-1, 128, 7, 4] 256\n", - "| | | └─SELU: 4-21 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-44 [-1, 128, 7, 4] --\n", - "| | | | └─Conv2d: 5-45 [-1, 128, 7, 4] 147,456\n", - "| └─Sequential: 2-5 [-1, 256, 4, 2] --\n", - "| | └─WideBlock: 3-7 [-1, 256, 4, 2] --\n", - "| | | └─Sequential: 4-22 [-1, 256, 4, 2] --\n", - "| | | | └─Conv2d: 5-46 [-1, 256, 4, 2] 32,768\n", - "| | | └─Sequential: 4-23 [-1, 256, 4, 2] --\n", - "| | | | └─BatchNorm2d: 5-47 [-1, 128, 7, 4] 256\n", - "| | | └─SELU: 4-24 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-48 [-1, 128, 7, 4] --\n", - "| | | | └─Conv2d: 5-49 [-1, 256, 7, 4] 294,912\n", - "| | | | └─Dropout: 5-50 [-1, 256, 7, 4] --\n", - "| | | | └─BatchNorm2d: 5-51 [-1, 256, 7, 4] 512\n", - "| | | └─SELU: 4-25 [-1, 256, 7, 4] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-52 [-1, 256, 7, 4] --\n", - "| | | | └─Conv2d: 5-53 [-1, 256, 4, 2] 589,824\n", - "| | └─WideBlock: 3-8 [-1, 256, 4, 2] --\n", - "| | | └─Sequential: 4-26 [-1, 256, 4, 2] --\n", - "| | | | └─BatchNorm2d: 5-54 [-1, 256, 4, 2] 512\n", - "| | | └─SELU: 4-27 [-1, 256, 4, 2] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-55 [-1, 256, 4, 2] --\n", - "| | | | └─Conv2d: 5-56 [-1, 256, 4, 2] 589,824\n", - "| | | | └─Dropout: 5-57 [-1, 256, 4, 2] --\n", - "| | | | └─BatchNorm2d: 5-58 [-1, 256, 4, 2] 512\n", - "| | | └─SELU: 4-28 [-1, 256, 4, 2] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-59 [-1, 256, 4, 2] --\n", - "| | | | └─Conv2d: 5-60 [-1, 256, 4, 2] 589,824\n", - "===============================================================================================\n", - "Total params: 2,788,784\n", - "Trainable params: 2,788,784\n", + "==========================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "==========================================================================================\n", + "├─Sequential: 1-1 [-1, 168, 3, 119] --\n", + "| └─Conv2d: 2-1 [-1, 24, 28, 952] 216\n", + "| └─BatchNorm2d: 2-2 [-1, 24, 28, 952] 48\n", + "| └─ReLU: 2-3 [-1, 24, 28, 952] --\n", + "| └─_DenseBlock: 2-4 [-1, 96, 28, 952] --\n", + "| └─_Transition: 2-5 [-1, 48, 14, 476] --\n", + "| | └─Sequential: 3-1 [-1, 48, 14, 476] 4,800\n", + "| └─_DenseBlock: 2-6 [-1, 144, 14, 476] --\n", + "| └─_Transition: 2-7 [-1, 72, 7, 238] --\n", + "| | └─Sequential: 3-2 [-1, 72, 7, 238] 10,656\n", + "| └─_DenseBlock: 2-8 [-1, 192, 7, 238] --\n", + "| └─_Transition: 2-9 [-1, 96, 3, 119] --\n", + "| | └─Sequential: 3-3 [-1, 96, 3, 119] 18,816\n", + "| └─_DenseBlock: 2-10 [-1, 168, 3, 119] --\n", + "| └─ReLU: 2-11 [-1, 168, 3, 119] --\n", + "==========================================================================================\n", + "Total params: 34,536\n", + "Trainable params: 34,536\n", "Non-trainable params: 0\n", - "Total mult-adds (M): 84.83\n", - "===============================================================================================\n", - "Input size (MB): 0.00\n", - "Forward/backward pass size (MB): 2.26\n", - "Params size (MB): 10.64\n", - "Estimated Total Size (MB): 12.90\n", - "===============================================================================================\n" + "Total mult-adds (M): 229.41\n", + "==========================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 53.69\n", + "Params size (MB): 0.13\n", + "Estimated Total Size (MB): 53.92\n", + "==========================================================================================\n" ] }, { "data": { "text/plain": [ - "===============================================================================================\n", - "Layer (type:depth-idx) Output Shape Param #\n", - "===============================================================================================\n", - "├─Sequential: 1-1 [-1, 256, 4, 2] --\n", - "| └─Conv2d: 2-1 [-1, 16, 28, 14] 144\n", - "| └─Sequential: 2-2 [-1, 32, 28, 14] --\n", - "| | └─WideBlock: 3-1 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4-1 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-1 [-1, 32, 28, 14] 512\n", - "| | | └─Sequential: 4-2 [-1, 32, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-2 [-1, 16, 28, 14] 32\n", - "| | | └─SELU: 4-3 [-1, 16, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-3 [-1, 16, 28, 14] --\n", - "| | | | └─Conv2d: 5-4 [-1, 32, 28, 14] 4,608\n", - "| | | | └─Dropout: 5-5 [-1, 32, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-6 [-1, 32, 28, 14] 64\n", - "| | | └─SELU: 4-4 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-7 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-8 [-1, 32, 28, 14] 9,216\n", - "| | └─WideBlock: 3-2 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4-5 [-1, 32, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-9 [-1, 32, 28, 14] 64\n", - "| | | └─SELU: 4-6 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-10 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-11 [-1, 32, 28, 14] 9,216\n", - "| | | | └─Dropout: 5-12 [-1, 32, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-13 [-1, 32, 28, 14] 64\n", - "| | | └─SELU: 4-7 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-14 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-15 [-1, 32, 28, 14] 9,216\n", - "| └─Sequential: 2-3 [-1, 64, 14, 7] --\n", - "| | └─WideBlock: 3-3 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4-8 [-1, 64, 14, 7] --\n", - "| | | | └─Conv2d: 5-16 [-1, 64, 14, 7] 2,048\n", - "| | | └─Sequential: 4-9 [-1, 64, 14, 7] --\n", - "| | | | └─BatchNorm2d: 5-17 [-1, 32, 28, 14] 64\n", - "| | | └─SELU: 4-10 [-1, 32, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-18 [-1, 32, 28, 14] --\n", - "| | | | └─Conv2d: 5-19 [-1, 64, 28, 14] 18,432\n", - "| | | | └─Dropout: 5-20 [-1, 64, 28, 14] --\n", - "| | | | └─BatchNorm2d: 5-21 [-1, 64, 28, 14] 128\n", - "| | | └─SELU: 4-11 [-1, 64, 28, 14] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-22 [-1, 64, 28, 14] --\n", - "| | | | └─Conv2d: 5-23 [-1, 64, 14, 7] 36,864\n", - "| | └─WideBlock: 3-4 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4-12 [-1, 64, 14, 7] --\n", - "| | | | └─BatchNorm2d: 5-24 [-1, 64, 14, 7] 128\n", - "| | | └─SELU: 4-13 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-25 [-1, 64, 14, 7] --\n", - "| | | | └─Conv2d: 5-26 [-1, 64, 14, 7] 36,864\n", - "| | | | └─Dropout: 5-27 [-1, 64, 14, 7] --\n", - "| | | | └─BatchNorm2d: 5-28 [-1, 64, 14, 7] 128\n", - "| | | └─SELU: 4-14 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-29 [-1, 64, 14, 7] --\n", - "| | | | └─Conv2d: 5-30 [-1, 64, 14, 7] 36,864\n", - "| └─Sequential: 2-4 [-1, 128, 7, 4] --\n", - "| | └─WideBlock: 3-5 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4-15 [-1, 128, 7, 4] --\n", - "| | | | └─Conv2d: 5-31 [-1, 128, 7, 4] 8,192\n", - "| | | └─Sequential: 4-16 [-1, 128, 7, 4] --\n", - "| | | | └─BatchNorm2d: 5-32 [-1, 64, 14, 7] 128\n", - "| | | └─SELU: 4-17 [-1, 64, 14, 7] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-33 [-1, 64, 14, 7] --\n", - "| | | | └─Conv2d: 5-34 [-1, 128, 14, 7] 73,728\n", - "| | | | └─Dropout: 5-35 [-1, 128, 14, 7] --\n", - "| | | | └─BatchNorm2d: 5-36 [-1, 128, 14, 7] 256\n", - "| | | └─SELU: 4-18 [-1, 128, 14, 7] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-37 [-1, 128, 14, 7] --\n", - "| | | | └─Conv2d: 5-38 [-1, 128, 7, 4] 147,456\n", - "| | └─WideBlock: 3-6 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4-19 [-1, 128, 7, 4] --\n", - "| | | | └─BatchNorm2d: 5-39 [-1, 128, 7, 4] 256\n", - "| | | └─SELU: 4-20 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-40 [-1, 128, 7, 4] --\n", - "| | | | └─Conv2d: 5-41 [-1, 128, 7, 4] 147,456\n", - "| | | | └─Dropout: 5-42 [-1, 128, 7, 4] --\n", - "| | | | └─BatchNorm2d: 5-43 [-1, 128, 7, 4] 256\n", - "| | | └─SELU: 4-21 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-44 [-1, 128, 7, 4] --\n", - "| | | | └─Conv2d: 5-45 [-1, 128, 7, 4] 147,456\n", - "| └─Sequential: 2-5 [-1, 256, 4, 2] --\n", - "| | └─WideBlock: 3-7 [-1, 256, 4, 2] --\n", - "| | | └─Sequential: 4-22 [-1, 256, 4, 2] --\n", - "| | | | └─Conv2d: 5-46 [-1, 256, 4, 2] 32,768\n", - "| | | └─Sequential: 4-23 [-1, 256, 4, 2] --\n", - "| | | | └─BatchNorm2d: 5-47 [-1, 128, 7, 4] 256\n", - "| | | └─SELU: 4-24 [-1, 128, 7, 4] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-48 [-1, 128, 7, 4] --\n", - "| | | | └─Conv2d: 5-49 [-1, 256, 7, 4] 294,912\n", - "| | | | └─Dropout: 5-50 [-1, 256, 7, 4] --\n", - "| | | | └─BatchNorm2d: 5-51 [-1, 256, 7, 4] 512\n", - "| | | └─SELU: 4-25 [-1, 256, 7, 4] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-52 [-1, 256, 7, 4] --\n", - "| | | | └─Conv2d: 5-53 [-1, 256, 4, 2] 589,824\n", - "| | └─WideBlock: 3-8 [-1, 256, 4, 2] --\n", - "| | | └─Sequential: 4-26 [-1, 256, 4, 2] --\n", - "| | | | └─BatchNorm2d: 5-54 [-1, 256, 4, 2] 512\n", - "| | | └─SELU: 4-27 [-1, 256, 4, 2] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-55 [-1, 256, 4, 2] --\n", - "| | | | └─Conv2d: 5-56 [-1, 256, 4, 2] 589,824\n", - "| | | | └─Dropout: 5-57 [-1, 256, 4, 2] --\n", - "| | | | └─BatchNorm2d: 5-58 [-1, 256, 4, 2] 512\n", - "| | | └─SELU: 4-28 [-1, 256, 4, 2] --\n", - "| | | └─Sequential: 4 [] --\n", - "| | | | └─SELU: 5-59 [-1, 256, 4, 2] --\n", - "| | | | └─Conv2d: 5-60 [-1, 256, 4, 2] 589,824\n", - "===============================================================================================\n", - "Total params: 2,788,784\n", - "Trainable params: 2,788,784\n", + "==========================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "==========================================================================================\n", + "├─Sequential: 1-1 [-1, 168, 3, 119] --\n", + "| └─Conv2d: 2-1 [-1, 24, 28, 952] 216\n", + "| └─BatchNorm2d: 2-2 [-1, 24, 28, 952] 48\n", + "| └─ReLU: 2-3 [-1, 24, 28, 952] --\n", + "| └─_DenseBlock: 2-4 [-1, 96, 28, 952] --\n", + "| └─_Transition: 2-5 [-1, 48, 14, 476] --\n", + "| | └─Sequential: 3-1 [-1, 48, 14, 476] 4,800\n", + "| └─_DenseBlock: 2-6 [-1, 144, 14, 476] --\n", + "| └─_Transition: 2-7 [-1, 72, 7, 238] --\n", + "| | └─Sequential: 3-2 [-1, 72, 7, 238] 10,656\n", + "| └─_DenseBlock: 2-8 [-1, 192, 7, 238] --\n", + "| └─_Transition: 2-9 [-1, 96, 3, 119] --\n", + "| | └─Sequential: 3-3 [-1, 96, 3, 119] 18,816\n", + "| └─_DenseBlock: 2-10 [-1, 168, 3, 119] --\n", + "| └─ReLU: 2-11 [-1, 168, 3, 119] --\n", + "==========================================================================================\n", + "Total params: 34,536\n", + "Trainable params: 34,536\n", "Non-trainable params: 0\n", - "Total mult-adds (M): 84.83\n", - "===============================================================================================\n", - "Input size (MB): 0.00\n", - "Forward/backward pass size (MB): 2.26\n", - "Params size (MB): 10.64\n", - "Estimated Total Size (MB): 12.90\n", - "===============================================================================================" + "Total mult-adds (M): 229.41\n", + "==========================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 53.69\n", + "Params size (MB): 0.13\n", + "Estimated Total Size (MB): 53.92\n", + "==========================================================================================" ] }, - "execution_count": 14, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "summary(dnet, (1, 28, 952), device=\"cpu\", depth=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from text_recognizer.networks import WideResidualNetwork" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "w = WideResidualNetwork(\n", + " in_channels = 1,\n", + " in_planes = 32,\n", + " num_classes = 80,\n", + " depth = 10,\n", + " width_factor = 1,\n", + " dropout_rate = 0.0,\n", + " num_layers = 5,\n", + " activation = \"relu\",\n", + " use_decoder = False,)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==========================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "==========================================================================================\n", + "├─Sequential: 1-1 [-1, 512, 2, 60] --\n", + "| └─Conv2d: 2-1 [-1, 32, 28, 952] 288\n", + "| └─Sequential: 2-2 [-1, 32, 28, 952] 18,560\n", + "| └─Sequential: 2-3 [-1, 64, 14, 476] 57,536\n", + "| └─Sequential: 2-4 [-1, 128, 7, 238] 229,760\n", + "| └─Sequential: 2-5 [-1, 256, 4, 119] 918,272\n", + "| └─Sequential: 2-6 [-1, 512, 2, 60] 3,671,552\n", + "==========================================================================================\n", + "Total params: 4,895,968\n", + "Trainable params: 4,895,968\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 22.36\n", + "==========================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 6.51\n", + "Params size (MB): 18.68\n", + "Estimated Total Size (MB): 25.29\n", + "==========================================================================================\n" + ] + }, + { + "data": { + "text/plain": [ + "==========================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "==========================================================================================\n", + "├─Sequential: 1-1 [-1, 512, 2, 60] --\n", + "| └─Conv2d: 2-1 [-1, 32, 28, 952] 288\n", + "| └─Sequential: 2-2 [-1, 32, 28, 952] 18,560\n", + "| └─Sequential: 2-3 [-1, 64, 14, 476] 57,536\n", + "| └─Sequential: 2-4 [-1, 128, 7, 238] 229,760\n", + "| └─Sequential: 2-5 [-1, 256, 4, 119] 918,272\n", + "| └─Sequential: 2-6 [-1, 512, 2, 60] 3,671,552\n", + "==========================================================================================\n", + "Total params: 4,895,968\n", + "Trainable params: 4,895,968\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 22.36\n", + "==========================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 6.51\n", + "Params size (MB): 18.68\n", + "Estimated Total Size (MB): 25.29\n", + "==========================================================================================" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "summary(w, (1, 28, 952), device=\"cpu\", depth=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "sz= 5" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "mask = torch.triu(torch.ones(sz, sz), 1)\n", + "mask = mask.masked_fill(mask==1, float('-inf'))" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "h = torch.rand(1, 256, 10, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([100, 1, 256])" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.flatten(2).permute(2, 0, 1).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([100, 1, 256])" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.flatten(2).permute(2, 0, 1).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[0., -inf, -inf, -inf, -inf],\n", + " [0., 0., -inf, -inf, -inf],\n", + " [0., 0., 0., -inf, -inf],\n", + " [0., 0., 0., 0., -inf],\n", + " [0., 0., 0., 0., 0.]])" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mask\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "120 / 8" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "120" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 * 60" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import yaml" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "path = \"../training/experiments/cnn_transformer.yml\"" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "with open(path, \"r\") as f:\n", + " f = yaml.safe_load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'experiment_group': 'Transformer Experiments',\n", + " 'experiments': [{'train_args': {'transformer_model': True,\n", + " 'batch_size': 16,\n", + " 'max_epochs': 128,\n", + " 'input_shape': [[1, 28, 952], [92]]},\n", + " 'dataset': {'type': 'EmnistLinesDataset',\n", + " 'args': {'subsample_fraction': None,\n", + " 'transform': [{'type': 'ToPILImage', 'args': None},\n", + " {'type': 'Resize', 'args': {'size': [28, 952]}},\n", + " {'type': 'ToTensor', 'args': None}],\n", + " 'max_length': 97,\n", + " 'min_overlap': 0.0,\n", + " 'max_overlap': 0.33,\n", + " 'num_samples': 1,\n", + " 'seed': 4711,\n", + " 'init_token': '<sos>',\n", + " 'pad_token': '_',\n", + " 'eos_token': '<eos>',\n", + " 'target_transform': [{'type': 'AddTokens',\n", + " 'args': {'init_token': '<sos>',\n", + " 'eos_token': '<eos>',\n", + " 'pad_token': '_'}}]},\n", + " 'train_args': {'num_workers': 8,\n", + " 'train_fraction': 0.85,\n", + " 'batch_size': 16}},\n", + " 'model': 'VisionTransformerModel',\n", + " 'metrics': ['accuracy'],\n", + " 'network': {'type': 'CNNTransformer',\n", + " 'args': {'backbone': 'DenseNet',\n", + " 'backbone_args': {'growth_rate': 8,\n", + " 'block_config': [4, 6, 8, 6],\n", + " 'in_channels': 1,\n", + " 'base_channels': 24,\n", + " 'num_classes': 256,\n", + " 'bn_size': 4,\n", + " 'dropout_rate': 0.1,\n", + " 'classifier': False,\n", + " 'activation': 'elu'},\n", + " 'num_encoder_layers': 3,\n", + " 'num_decoder_layers': 3,\n", + " 'hidden_dim': 256,\n", + " 'vocab_size': 82,\n", + " 'num_heads': 8,\n", + " 'max_len': 99,\n", + " 'expansion_dim': 512,\n", + " 'mlp_dim': 256,\n", + " 'spatial_dim': 357,\n", + " 'dropout_rate': 0.1,\n", + " 'trg_pad_index': 79,\n", + " 'activation': 'gelu'}},\n", + " 'criterion': {'type': 'CrossEntropyLoss', 'args': {'ignore_index': 79}},\n", + " 'optimizer': {'type': 'AdamW',\n", + " 'args': {'lr': 0.0003,\n", + " 'betas': [0.9, 0.999],\n", + " 'eps': 1e-08,\n", + " 'weight_decay': 3e-06,\n", + " 'amsgrad': False}},\n", + " 'lr_scheduler': {'type': 'OneCycleLR',\n", + " 'args': {'max_lr': 0.0007,\n", + " 'epochs': 128,\n", + " 'anneal_strategy': 'cos',\n", + " 'pct_start': 0.475,\n", + " 'cycle_momentum': True,\n", + " 'base_momentum': 0.85,\n", + " 'max_momentum': 0.9,\n", + " 'div_factor': 10,\n", + " 'final_div_factor': 10000,\n", + " 'interval': 'step'}},\n", + " 'callbacks': ['Checkpoint',\n", + " 'ProgressBar',\n", + " 'WandbCallback',\n", + " 'WandbImageLogger'],\n", + " 'callback_args': {'Checkpoint': {'monitor': 'val_loss', 'mode': 'min'},\n", + " 'ProgressBar': {'epochs': 128},\n", + " 'WandbCallback': {'log_batch_frequency': 10},\n", + " 'WandbImageLogger': {'num_examples': 6}},\n", + " 'test_metric': 'test_accuracy'}]}" + ] + }, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "summary(wr, (1, 28, 14), device=\"cpu\", depth=10)" + "f" ] }, { @@ -626,7 +1007,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/src/notebooks/01-look-at-emnist.ipynb b/src/notebooks/01-look-at-emnist.ipynb index 564d14e..0ef77b6 100644 --- a/src/notebooks/01-look-at-emnist.ipynb +++ b/src/notebooks/01-look-at-emnist.ipynb @@ -2,18 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 18, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", @@ -31,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -40,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -49,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -58,169 +49,6 @@ }, { "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [], - "source": [ - "from torch.utils.data import random_split, DataLoader" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [], - "source": [ - "d1, d2 = random_split(dataset, [len(dataset)-10, 10])" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "55898" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(d1)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "dl = DataLoader(d1, batch_size=16)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3494" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(dl)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 4, 4, 4, 4, 4, 2, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 2, 4, 9, 32, 37, 37, 37, 32, 20, 1, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 3, 65, 109, 140, 204, 215, 217, 217, 201, 154, 22, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,\n", - " 12, 122, 190, 222, 245, 249, 250, 250, 242, 206, 46, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 8, 79,\n", - " 127, 222, 247, 253, 235, 228, 249, 254, 254, 245, 114, 4, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 35, 91, 219,\n", - " 244, 252, 247, 207, 100, 84, 223, 251, 254, 250, 127, 4, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 91, 163, 246,\n", - " 252, 244, 220, 127, 39, 48, 218, 250, 255, 250, 127, 4, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 5, 20, 95, 219, 246, 246,\n", - " 221, 127, 79, 10, 5, 37, 217, 250, 254, 249, 125, 4, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 20, 67, 175, 246, 252, 219,\n", - " 164, 47, 22, 1, 5, 39, 218, 250, 254, 245, 114, 4, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 1, 9, 95, 175, 250, 246, 219, 91,\n", - " 35, 1, 0, 0, 22, 84, 234, 252, 250, 220, 50, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 9, 35, 164, 221, 252, 219, 163, 35,\n", - " 9, 0, 0, 0, 46, 127, 246, 254, 245, 204, 34, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 7, 91, 163, 246, 252, 219, 91, 35, 1,\n", - " 0, 0, 0, 10, 128, 209, 254, 254, 220, 139, 9, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 3, 22, 159, 219, 252, 247, 164, 35, 9, 0,\n", - " 0, 0, 1, 36, 175, 233, 254, 254, 204, 115, 4, 0, 0, 0],\n", - " [ 0, 0, 0, 1, 36, 95, 232, 251, 232, 195, 47, 1, 0, 0,\n", - " 0, 9, 35, 163, 246, 253, 249, 232, 122, 45, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 7, 91, 164, 247, 251, 187, 127, 20, 0, 0, 0,\n", - " 1, 35, 91, 219, 253, 254, 234, 187, 67, 20, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 46, 207, 244, 247, 220, 80, 24, 1, 3, 8, 34,\n", - " 52, 164, 219, 253, 249, 234, 155, 79, 4, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 2, 81, 232, 251, 235, 179, 39, 12, 5, 22, 46, 115,\n", - " 139, 221, 246, 254, 234, 188, 79, 32, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 3, 112, 244, 254, 236, 193, 130, 127, 129, 173, 209, 245,\n", - " 250, 254, 253, 232, 154, 79, 4, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 46, 206, 242, 249, 248, 249, 250, 250, 250, 250, 250,\n", - " 250, 243, 219, 95, 22, 7, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 22, 154, 201, 217, 222, 245, 249, 249, 233, 222, 217,\n", - " 217, 202, 158, 36, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 1, 20, 32, 39, 51, 114, 125, 125, 82, 51, 37,\n", - " 37, 32, 20, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 2, 4, 5, 9, 32, 37, 37, 21, 9, 4,\n", - " 4, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", - " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],\n", - " dtype=torch.uint8)" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d1.dataset.data[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Tensor" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "type(dataset.data)" - ] - }, - { - "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ @@ -297,27 +125,6 @@ "source": [ "display_images(dataset, 9)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -336,7 +143,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/src/notebooks/02b-emnist-lines-dataset.ipynb b/src/notebooks/02b-emnist-lines-dataset.ipynb index 84d853b..fb856c5 100644 --- a/src/notebooks/02b-emnist-lines-dataset.ipynb +++ b/src/notebooks/02b-emnist-lines-dataset.ipynb @@ -2,9 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, - "outputs": [], + "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", @@ -22,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -31,23 +40,27 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "emnist_lines = EmnistLinesDataset(train=False)" + "emnist_lines = EmnistLinesDataset(train=False,\n", + " max_length = 97,\n", + " min_overlap = 0.0,\n", + " max_overlap = 0.33,\n", + " num_samples = 10_000,)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "2020-09-10 20:11:30.358 | DEBUG | text_recognizer.datasets.emnist_lines_dataset:_load_data:134 - EmnistLinesDataset loading data from HDF5...\n" + "2020-10-25 18:35:53.133 | DEBUG | text_recognizer.datasets.emnist_lines_dataset:_load_data:147 - EmnistLinesDataset loading data from HDF5...\n" ] } ], @@ -57,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -67,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": { "scrolled": false }, @@ -76,123 +89,105 @@ "name": "stdout", "output_type": "stream", "text": [ - "office in Arkansas after the______\n", - "in________________________________\n", - "by a oneshot technique____________\n", - "office Incumbent__________________\n", - "of the revolutionary______________\n", - "they______________________________\n", - "the scene but_____________________\n", - "Knox Ky___________________________\n", - "workers wife refused to have______\n" + "One of the reporters called to him_______________________________________________________________\n", + "and reproduce what_______________________________________________________________________________\n", + "plasma arylesterase against inactivation by urea_________________________________________________\n", + "bar while the sleekheaded bartender absently polished a glass Looking the setup over_____________\n", + "many areas of need in this amazing_______________________________________________________________\n", + "mulch over the seedlings now we must use a heavy one_____________________________________________\n", + "it later turned out that masked__________________________________________________________________\n", + "the Homeric poems appear oral compositions Yet they are written at some stage in_________________\n", + "through our growth studies we have_______________________________________________________________\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -207,12 +202,14 @@ " sentence = convert_y_label_to_string(target.numpy()) \n", " print(sentence)\n", " plt.title(sentence)\n", - " plt.imshow(data.squeeze(0), cmap='gray')\n" + " plt.imshow(data.squeeze(0), cmap='gray')\n", + " plt.xticks([])\n", + " plt.yticks([])" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -221,12 +218,12 @@ "text": [ "EMNIST Lines Dataset\n", "Max length: 34\n", - "Min overlap: 0\n", + "Min overlap: 0.0\n", "Max overlap: 0.33\n", "Num classes: 80\n", "Input shape: (28, 952)\n", - "Data: (10000, 28, 952)\n", - "Tagets: (10000, 34)\n", + "Data: (1000, 28, 952)\n", + "Tagets: (1000, 34)\n", "\n" ] } @@ -237,115 +234,6 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([58, 50, 53, 46, 40, 53, 54, 62, 58, 44, 41, 40, 62, 53, 40, 41, 56, 54,\n", - " 40, 39, 62, 55, 50, 62, 43, 36, 57, 40, 79, 79, 79, 79, 79, 79],\n", - " dtype=torch.uint8)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "target" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "from text_recognizer.networks import LineRecurrentNetwork" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "crnn = LineRecurrentNetwork(encoder=\"ResidualNetworkEncoder\",\n", - " \n", - " encoder_args={\n", - " \"in_channels\": 1,\n", - " \"num_classes\": 80,\n", - " \"depths\": [2, 2],\n", - " \"block_sizes\": [64, 128],\n", - " \"activation\": \"leaky_relu\",\n", - " \"stn\": False,})" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "output = crnn(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "targets = target.unsqueeze(0).type(torch.long)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "input_lengths = torch.full(\n", - " size=(output.shape[1],), fill_value=output.shape[0], dtype=torch.long,\n", - ")\n", - "target_lengths = torch.full(\n", - " size=(output.shape[1],), fill_value=targets.shape[1], dtype=torch.long,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "ctc = torch.nn.CTCLoss(blank=79)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(6.9917, grad_fn=<MeanBackward0>)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ctc(output, targets, input_lengths, target_lengths)" - ] - }, - { - "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], @@ -368,7 +256,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/src/notebooks/02c-image-patches.ipynb b/src/notebooks/02c-image-patches.ipynb index 947611d..9e8d4b2 100644 --- a/src/notebooks/02c-image-patches.ipynb +++ b/src/notebooks/02c-image-patches.ipynb @@ -438,7 +438,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/src/notebooks/03a-line-prediction.ipynb b/src/notebooks/03a-line-prediction.ipynb index 336614f..539fb6e 100644 --- a/src/notebooks/03a-line-prediction.ipynb +++ b/src/notebooks/03a-line-prediction.ipynb @@ -398,7 +398,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/src/notebooks/04a-look-at-iam-lines.ipynb b/src/notebooks/04a-look-at-iam-lines.ipynb index d64b391..8132f44 100644 --- a/src/notebooks/04a-look-at-iam-lines.ipynb +++ b/src/notebooks/04a-look-at-iam-lines.ipynb @@ -15,6 +15,7 @@ "from PIL import Image\n", "import torch\n", "from torch import nn\n", + "\n", "from importlib.util import find_spec\n", "if find_spec(\"text_recognizer\") is None:\n", " import sys\n", @@ -27,7 +28,7 @@ "metadata": {}, "outputs": [], "source": [ - "from text_recognizer.datasets import IamLinesDataset" + "from text_recognizer.datasets import IamLinesDataset, AddTokens" ] }, { @@ -42,14 +43,14 @@ "IAM Lines Dataset\n", "Number classes: 80\n", "Mapping: {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: 'A', 11: 'B', 12: 'C', 13: 'D', 14: 'E', 15: 'F', 16: 'G', 17: 'H', 18: 'I', 19: 'J', 20: 'K', 21: 'L', 22: 'M', 23: 'N', 24: 'O', 25: 'P', 26: 'Q', 27: 'R', 28: 'S', 29: 'T', 30: 'U', 31: 'V', 32: 'W', 33: 'X', 34: 'Y', 35: 'Z', 36: 'a', 37: 'b', 38: 'c', 39: 'd', 40: 'e', 41: 'f', 42: 'g', 43: 'h', 44: 'i', 45: 'j', 46: 'k', 47: 'l', 48: 'm', 49: 'n', 50: 'o', 51: 'p', 52: 'q', 53: 'r', 54: 's', 55: 't', 56: 'u', 57: 'v', 58: 'w', 59: 'x', 60: 'y', 61: 'z', 62: ' ', 63: '!', 64: '\"', 65: '#', 66: '&', 67: \"'\", 68: '(', 69: ')', 70: '*', 71: '+', 72: ',', 73: '-', 74: '.', 75: '/', 76: ':', 77: ';', 78: '?', 79: '_'}\n", - "Data: (7101, 28, 952)\n", - "Targets: (7101, 97)\n", + "Data: (1861, 28, 952)\n", + "Targets: (1861, 97)\n", "\n" ] } ], "source": [ - "dataset = IamLinesDataset(train=True)\n", + "dataset = IamLinesDataset(train=False, pad_token=\"_\")\n", "dataset.load_or_generate_data()\n", "print(dataset)" ] @@ -62,7 +63,7 @@ { "data": { "text/plain": [ - "(97, 80)" + "(28, 952)" ] }, "execution_count": 4, @@ -71,7 +72,7 @@ } ], "source": [ - "dataset.output_shape" + "dataset.input_shape" ] }, { @@ -82,7 +83,7 @@ { "data": { "text/plain": [ - "'A MOVE to stop Mr. Gaitskell from'" + "(97, 80)" ] }, "execution_count": 5, @@ -91,159 +92,161 @@ } ], "source": [ + "dataset.output_shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'He rose from his breakfast-nook bench____________________________________________________________'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ "def convert_y_label_to_string(y, dataset=dataset):\n", - " return ''.join([dataset.mapper(int(i)) for i in y]).rstrip(\"_\")\n", + " return ''.join([dataset.mapper(int(i)) for i in y])\n", "\n", "convert_y_label_to_string(dataset.targets[0])" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Griffiths resolution. Mr. Foot's line will\n", - "be that as Labour M Ps opposed the\n", - "Government Bill which brought life peers\n", - "into existence, they should not now put\n", - "forward nominees. He believes that the\n", - "House of Lords should be abolished and\n", - "that Labour should not take any steps\n", - "which would appear to \"prop up\" an out-\n", - "Since 1958, 13 Labour life Peers and\n", - "Peeresses have been created. Most Labour\n" + "drawing-in great breaths that____________________________________________________________________\n", + "became great sighs of ecstacy.___________________________________________________________________\n", + "\"They have come!\" he said reverently, gripping his_______________________________________________\n", + "hands together between his knees and leaning_____________________________________________________\n", + "forward. \"Isn't it a glorious thing! Long awaited________________________________________________\n", + "transcendent event, the exalted desire of all____________________________________________________\n", + "mankind through all ages! The Kingdom of the_____________________________________________________\n", + "Mind is at hand!\" He turned beaming eyes_________________________________________________________\n", + "upward and shook his head slowly from____________________________________________________________\n", + "A superfluous precaution for there was no other car______________________________________________\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAABCCAYAAADt2ys3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA4l0lEQVR4nO29eXicV3n3/zkzI41G+y5Zq+VFtiU7XmLHcWziOAnJ6/wCaUiTNIUQSuEtv5bywq99C2/hKqX0pXShb9rSXylLCaRAICG7IUuzLzZJLFte5V2LZe3bSJoZzXbeP2bOk0ePZmQpMbFI7s91+crM85znnPssz+Q6X933fZTWGkEQBEEQBEEQBEEQBGFh4brYBgiCIAiCIAiCIAiCIAgzEdFGEARBEARBEARBEARhASKijSAIgiAIgiAIgiAIwgJERBtBEARBEARBEARBEIQFiIg2giAIgiAIgiAIgiAICxARbQRBEARBEARBEARBEBYgItoIgnDRUEpppdSyd0s771aUUn+plPrPi2zDL5VSd6W5tzg5x5532q53GqXU80qpT1yktieUUksuQD0fVko9dSFsSlF3u1Lq2jT33qeUOvbraFcQBEEQBOHXhYg2giBcEJKbpcVKqXuUUh9TSv15cpM3oZQKKaVitu+HL7a971WcApZz3i6iabOitd6ptf7BxbbjnWQhiGV2tNa5WuvTF6CeH2mtr7sQNs2z3Ze01ive6XYFQRAEQRDeDiLaCILwa0Fr/bXkJi8X+BSw23zXWjdfbPuE9ybvpDfOu8Xz593SD0EQBEEQhN9ERLQRBOFic61S6oRSalQp9a9KKWVuKKU+rpQ6qpQaUUo9qZSqT17/V6XUN+yVKKUeVUp9br7tKKWWKqWeVUoNKaUGlVI/UkoVJu99Xin1gKOdf1JK/XPyc4FS6ntKqR6lVLdS6q+VUu5UjSul3Envo1NKqXGl1F6lVG3y3hVKqdeVUmPJ/15he+75ZL2vJr2UHlNKlSTt9CfLL7aVX6mUelopNayUOqaUum1Os3B+MpVSP0zaflgptdHWZpVS6udKqQGl1Bml1GfSVaKUukEpdSRZT7dS6k+T14uUUo8n6xhJfq5xjMMnbGP5D8n5Og38P7MZnvQm+rxS6gAwqZTyKKUuT47pqFKqVSl1VbLs7UqpNxzPf04p9WjyszfZdqdSqk8p9S2llC957yql1NlkW73A95VSLqXUF5LzPqSU+plSqjhZ3oR13ZWsb1Ap9cXkvf8G/Dlwe3LeWx02ZSbneI3tWrlSKqCUKpttPJJlS5Jryayhv1ZKvWy7r5VSf6SUOgGcsF1blvx8T7LvTyfn8gWVfD9tZT+jlDqd7NffK6VcyXsfS9HWp1Tq99OtlPpGso4zSqlPq/OHwq1TSh1Qiffpp0qpLPv82Nr9fHINjifflWvON26CIAiCIAjvNCLaCIJwQdBaL9Zat2utP6a1vmcej94IbAIuAW4DrgdQSt1EYtP6IaAMeAn4SfKZHwB32DaBpcC1wI/n2w6ggL8BqoBVQC3wl8l79wE3KKXyku24k8+adu4BosAyYD1wHZAu38j/B9wB3ADkAx8HAskN/C7gn4ES4B+BXUqpEtuzvwPcCVQDS4HdwPeBYuAo8OWkfTnA00n7ypPP/f9KqaZ0gzKPeftgcjwKgUeBbybbdAGPAa1J+64BPquUuj51NXwP+AOtdR6wGng2ed2V7FM9UAcETRsp+CSJ+VwPbAR+exa7DXeQEHcKgQoSY/7XJMbwT4GfJ8WOx4AVSqnltmd/lzfn/OtAI7COxLxXA39hK1uZrLMe+O/AHwO/BWwnscZGgH912LYNWEFi7P5CKbVKa/0E8DXgp0nvtLX2B7TWYRLz8RFHH5/RWg/MYTz+FZhM2ntX8p+T3wI2A+nWz4eBrwKlwH7gR477N5OYnw3ATSTWfDrSvZ+fBHaSGO8NSZvOx23AfwMakvV9zFlAKbUC+DSwKbkWrwfa51C3IAiCIAjCO4qINoIgXGy+rrUe1Vp3As+R2JxBIqTqb7TWR7XWURIb2HVKqXqt9WvAGIlNLiTEiee11n3zbUdrfVJr/bTWeiq52f1HEhtstNYdQAuJzSfA1UBAa71HKVVBQoD5rNZ6UmvdD/yfpC2p+ATwJa31MZ2gVWs9REJIOKG1vldrHdVa/wRoAz5ge/b7WutTWusx4JfAKa31fyXH5X4S4gUkNr7tWuvvJ+vaB/wcuHWWcZkrL2utf6G1jgH3AkZE2ASUaa3/SmsdTuY8+c4s4xABmpRS+VrrEa11C4DWekhr/XOtdUBrPQ78b5LzkILbgLu11l1a62ESotv5+Odk+SAJoeMXyf7EtdZPA28AN2itA8AjJAQQkuLNSuDRpPfHfwc+p7UeTtr5NUdf48CXk+spSGIdf1FrfVZrPUVCEPxth6fIV7TWQa11Kwnxa5pAMwtGvDTeaXeSmJtZSYqPtyTtDGitjyTrcvI3yX4G01S1S2v9YrJfXwS2qKT3WJK/TT7fCdxNckzTkO534Dbgn5LjN0JCNDsf/6y1PpdcG4/Z6rITA7wk1mJGUrg8NYe6BUEQBEEQ3lFEtBEE4WLTa/scAHKTn+uBf0qGS4wCwyS8YqqT93/Am14GH+H8m9WU7SilKpRS9yXDJPzAf5LwHDD8mDc3m3aPi3ogA+ix2fjvJDxcUlELpNoUVgEdjmsdvNlPALsYFUzx3T5mm409SZs+TMKb4u3iHL+spPBQD1Q52vxzEt4sqbiFhNjVkQyp2QKglMpWSv27UqojOQ8vAoUqdbhZFdBl++4cv1TYy9cDtzps3gYsSt53zvnDSTGnDMgG9tqeeyJ53TCgtQ452nrIVv4oCcHAPj7p3oFZ0Vr/Kln+KqXUShKeP4/O4dEywMP0MelKUS7VtZT3tdYTJN7RqjTPdzjuOUk3Bs65Pp9Ns9VlobU+CXyWhIjWn/wNmM0+QRAEQRCEi4KINoIgLFS6SITRFNr++bTWrybv/ydwk1JqLYmwpoffYjtfAzSwRmudT0IAUrb795PYFNeQ8Lgxok0XMAWU2uzLnyXJcheJ0CYn50hs7O3UAd1voS9dwAuOMcvVWv+/poDWWiU3rBeKLuCMo808rfUNqQprrV/XWt9EQtx6GPhZ8tafkAgR2pychyuT19WMSqCHhAhmqJuDndph870Om3O01saL42mgTCm1joR4Y+Z8kIRI1mx7rkAnkm2nase0tdPRVpbWei7z66wrFUa8vBN4wCEYpWOARFhfje1abYpy52vfekYplUsiLOxcmjrrHPfmSg/nt/MtobX+sdZ6G4n3TwN/e6HqFgRBEARBuFCIaCMIwkLlW8D/Uko1g5X01wrz0VqfBV4n4WHz81lCOM5HHjABjCmlqoH/ab+ZDJl6nkS+lTNa66PJ6z3AU8A3lFL5KpFwdqlSKl1Iz3eBryqllqsElyTz1vwCaFRK/a5KJMi9nUQOkcffQl8eT9Z1p1IqI/lvk1Jq1Vuoa668Bownk7r6koljVyulNjkLqkTy3A8rpQq01hHATyKcCBLzEARGk3l+vjxLmz8DPqOUqlFKFQFfmKfN/wl8QCl1fdLerGSS2hqApG33A39PQoh4Onk9TiL06/8opcqTfaqeJX8PJNbx/1ZvJtEuS+Zrmgt9wGKTu2mWvtxMQrj5of1GMmHvVc4HkiFuDwJ/mfRwWgl8dI422blBKbVNKZVJIrfNHq213RPmf6pEgula4H8AP30LbfwM+B/JcS4EPv8W6piBUmqFUupqpZQXCJFYe/HzPCYIgiAIgvCOI6KNIAgLEq31QyT+8n1fMlzmEImEpHZ+AKxhDnk8ZuErJBKcjpFITvtgijI/JnWi448CmcAREglmH+DNEBsn/0hiA/oUCbHie4AvmdfmRhKeJkPAnwE3aq0H59uRZI6V60jkWDlHIkzkb0nk7gBAJU4iWjLfumdpM0bC/nXAGRLeKN8FCtI8cifQnpzTT5EI34JEzhNf8vk9JMKO0vEd4EkS+V9aSD1ns9ncRSIx7p+T8DrpIiHW2f+faOb8/mTuIMPngZPAnmQf/ouEh1A6/olEyNJTSqlxEn3bPEdT70/+d0gp1TJLX1pIeIq8ZK4nhZJx4GCauj9NYo56Sbw/PyHhOTYffkxCXBsGLmV6UmRI5AbaSyJJ8S4Sa36+fIfEO3MA2EdC5IySCDF7O3hJ5McZJDEG5cD/ept1CoIgCIIgXHCU1nPxvhYEQVh4KKWuJOFpUK/lx0x4j6KU+g/gnNb6S7ZrHyERxjUnIUIp9bdApdY61SlSqcrfA5y1t+m4r4HlFzgUD6XUTuBbWmtnSKEgCIIgCMK7Es/5iwiCICw8lFIZJEIuviuCjfBeRSm1GPgQb54gBoDW+j/P89xKEl5iB0mcAPb7pD+u/qKhlPIBO0h421SQ8Ox56KIaJQiCIAiC8A4ioo0gCL9xJHO0vEEiPOb3LrI5gnBRUEp9FfgciaO5z8zz8TwSIVFVJHLnfINEONNCQ5EIYfwpibwzu4C/+LU1ptQvgfeluJUDTMp1uS7X5foFuP41rfXXUlwXBEFIiYRHCYIgCIIgCIIgCIIgLEAkEbEgCIIgCIIgCIIgCMICZF7hUcnjQ39dtgiCsMAx77/WGp/PB0A0GiUSiVxMs942Sim01lb/4nE5+VcQBEEQBEEQhHeUQa11mfPifEUbMjIyLpxJgiBcUIz4cKGeMSKGUsoqF4/HycjI4Morr6Snp4fOzk4CgQCpBF1Tr10U0Vpbn+0ikP2zEU1MGbuNSini8fgMocXZl3RtxeNxXC7XjHsul4t4PI7WmnA4LMKNIAiCIAiCIAjvJB2pLkoiYkF4F/FWclTN9oxTTNFa43K5KC4upquri6GhIUKh0HlFH3hTLLFfNwKMXUBxtmkXX5z3TL12Ycde3t6W+W6vay5jIAiCIAiCIAiCcLEQ0UYQhFlJJX5MTU3R09NDKBQiGo0CTPNeMeVTPWsXbJziiR274OOsx/58urqdHjXOPjk9g0S4EQRBEARBEARhoSGijSC8B3grYVPp0FozOjo6Q5RJJ9I47XDWZbx30tk3H7vt9aVqy3j6GFtmE5gEQRAEQRAEQRAuNiLaCMJ7gPkIH6kEl3QeNHZisVhK4cN+zZ43xin4ONu057VJ1Z9U3jL2Z+1CkD03TjqBxh5aJQiCIAiCIAiCsBCQI7+FdxXvdS+JC9H/uYQs2UOTUnncGGHGWW80GrXEG/t1I/ikyl1jyjjtMPdNXeYZ893kunG5XDM8b5zt271wUnnpCIIgCIIgCIIgXAx+ozxtXC4XhYWFVFZWcvz4cSuXxnuNZcuWUVxcTEdHB319fdPulZeXU1JSQjAYpL29/eIYeBERL4nppPMcmY9HiTMRsfOaweVyEYvFpt1PVZcpYy+XKj/NbOFSzgTH9jrMc3Zhxo7xwnHmx7HXJetIEARBEARBEISFwG+UaGOOHG9sbOTMmTPvWdEmMzOTiooKsrOzZ4g2ubm51NfXAzAxMUFxcTFnzpwhEolcDFOFd5jzeai81TrnW87uhWM8b5xl5mqn/dQn53W7x835yptrqRImA7jd7mkeP4IgCIIgCIIgCBebeYVHXeywgXg8TigUoqKiIu1f0d8LxONxMjIyKC8vn7Fpdbvd5OTkUFdXR3Z2Nh/+8IcpKChIO2/5+fnk5eXh9XrfKfOFOeDxeN7yu5bqSOtUZd4OqfLJGGEGZve0OV+9c00IbPfSSVW/M9wq1XHg9nLmXbrYv3OCIAiCIAiCIAiGeSkfXq+XRYsWkZubi8dzcZx0pqamKC4ufk+LNsbDqLCwcMa9UChEJBKhtLSUaDTK8uXLycvLw+12p6zL5/NRXV1NWVnZr9NkYR54vV5qamrIzc1NW8btdpORkUFGRsY7aNncsee6mU8YlvOfue68nwqv10tBQQFut9sSXmYrP5voJAiCIAiCIAiCsBCYl/Lh8/lYv349DQ0N5Ofn/7psSovWmng8TlFRUVoR4r1AOBwGoKCgwLpmNqd+v5+RkRFycnIYHx/n8OHDKKVSem4opYhGozQ0NFghVcLFJzs7m0svvZTS0tKU991uN2VlZdTX17No0aI51ZlKwHi73iTpjvNOVW+qtZeqjFNssScSTicAGS+ZvLw8KisrcbvdM7xm7Lly0gk5JteOhEYJgiAIgiAIgrBQmHd41IoVK7jyyitZtmzZrJu+t7ohnEv4RGFhIT6fb17CzWx/rf9NCoUw+UEikUhKb6NgMMj4+Li18dy1axfDw8NEIpGU+U6Gh4fJzs5O6bWz0DGb83cbU1NTNDY2pp2TwsJCbr31Vr7whS9wxx13zDmMyPn97YgTzvfHrMV0iYTteWacpzjZnzGnTsXj8ZSeL6nq11qTmZlJVlYWbrd72nVnYmLz/qT6PTDX341rShAEQRAEQRCE30zmJdp4PB6eeOIJRkdHrQ0SJBLj2jc6xcXFLF26lNLS0nnntkiVqDTV8b5er3faX9TTkS5R6WxJU1OFZSwkPB4PLpeLQCBARkaGFQ5iNqwdHR3cd999xONx2tramJycnJbPw47WmqysLLKzsxdcPzMzM2e9/8lPfpLa2tp3nddVNBplyZIlFBYWzhDmlFJcccUVBAIB6wQ1t9s9bQzSrfkLIdbY6wOorKxk8+bNXHPNNdOuz3ZkuF1MSReS5MzT5PF4rPfdiC9m3Zu1X1paSmNj44z+2uspLS0lIyMjpX1ut3uaoCMIgiAIgiAIgnCxmVdiGr/fTzweZ2RkhJKSEm688UZ27NjB6tWr2bdvH93d3XR3d+PxeCgoKGBwcJAHHnggZV2zbRxThTLYBZSpqSny8/NZv349zc3NRCIRfvKTn9DZ2TmntpzeJnYxY7YwjlSbXvtf73/dYRWmfSOSDQ8PT7tuxikQCHD69GnrxChzIo4pY7fT7XZbSYhTiToXC7fbzaZNmxgbG+PkyZOEQqEZZZqbm3njjTcYGBggGAxeBCt/PcRiMaLRqCVG2IWNkpISMjMzaWpqYmRkhEceecQSP9LlkDHf7Z4kF2KelVIMDQ1RXl5OY2MjlZWV9Pb2TrtvbzfVe+h2u4lGo7OKuOb+bKdBxWIxPB4PhYWFKcXWgoICVqxYwTXXXMN3vvMdBgcH5ZQoQRAEQRAEQRAWPPMSbaamplBKEQqFrPCFsbExotEoPT099Pf3o5QiEong9/upq6uzNlTpcG7G7N+deSyM18H4+DhNTU0UFBTQ2dlJMBhk586dfPvb355RhzOfRSqPA601GRkZKY/7TffZ7Xazdu1a1q1bR0lJCX19fezfv5+DBw+ilKKkpIRwOMzk5OQFO5pca215HZh5cHoUmA2+EZFMn9J5WdjrNJ4L6UJT3kni8ThHjhyhqKhoVq8N42nxbsK5Bu3zu3nzZlauXInL5aKnp4eOjg7rmXRcSA8bO2atnD17lkgkYnn7pDqlKV3bLpeLiooKhoaG0q4554lSZs0ajGgaj8dxuVxkZWVNE/G01gSDQbq6ujhx4gSlpaUMDw8Ti8XOK8oKgiAIgiAIgiBcTOYl2sTjcWKxGPF4nImJCSKRCMPDw9TV1aG15ujRo9YGq7CwkMbGxmnCi1P0yMvLs0SNdH9FN9g3V5FIhDVr1tDS0sKpU6fIz89n3bp1VnhQU1MTlZWVjI6OcurUKfx+Pz6fj2AwaAkodg+exsZGNmzYwODgIIcPH6a7u3tau07bvF4vTU1NVFRU0Nvby9jYGAUFBSxZsoRjx47R3NxMTU0NXq+X1tZWenp6rE3t5OTkece5uLiYZcuWUVhYyPDwMPv27bM2tFprKzxqdHR0zrlDZsPlcpGdnU1DQwObNm1iaGiIp59+eprYppQiJyeH5cuXEwqFOHv2LJOTk3MWd8wGf65orRkZGSEej6cVvd7q5trlclFdXU0sFmNkZORte+lkZWURDoen9c/tdrN+/XqOHj1KMBicd98jkciMZ5RSbN68mdraWg4cOMC+ffusOXg73jNKKbKysojH40xNTc2pvLETEiLq1NTUtBPl0tniXKsej4cNGzbQ2tpKf3//tL6kC+ez3zdCIyQSdIdCIYqLi+np6Zm2fs1JW4cOHWJ0dDTl2Jr/imgjCIIgCIIgCMJCYV6ijV0gCIfDxGIxYrEYXV1dLFq0iLNnzxIIBHC5XNTX15Obm0ttbS25ubn09/czOjrK1NSUdaRxWVkZQ0NDdHV1pdw4pzrpxWzU8vPz6erqorOzk2XLllk5bvLz82lubmbRokWMjo4CcODAAerr6wkEAnR3d6OUori4mIKCArq6utiyZQtLliyx8sT09/enTNwLic1fSUkJa9eupa2tjSNHjhCLxWhubqa0tJT8/Hw2bdpEKBSivLwcSIg8AwMDlJWVcfjwYRYvXszQ0BDRaJS8vDwKCwsJBAJ0dXXh8/lYunQpK1asoL6+nmg0ypEjRyyvGkiIBABDQ0OzegWlymvixJQpKipi9erVrF27lszMTF555RUmJiYsr4bc3Fzq6+tZsmQJxcXFvPzyy3R0dBAIBNKuFyMG1dbW4vP56O3tZWhoaJowcD7vhrGxsRl1mvIulyvlqVjno7KyklWrVuFyuejs7KSzs5OJiQmUUhQWFlohNhMTEwwMDMwIhysoKCAvL89a9zU1NZw9e5bh4WFCoZCVO2XTpk309/fT29uLz+ejoKCAeDxOf3+/dQJYKkpLSyksLKSiooKysjL8fj+Tk5N4vV42bNjA2bNnOXDgAMePH7c8qswYlJeXEwqFmJiYmCb0pQo5NP1atGiRlfR4ZGSEnp6eGTa5XC5ycnKorKyku7ubqakpq/5YLDZn4cvpBed2uykuLiY3N5fBwcFpYYbpBBtnP8y/UCjE+Pg4NTU1+P1+SkpKGBoaIhAIkJeXR01NDYcPH2Z8fNwShzIyMvB4PMRiMcLhsOSzEQRBEARBEARhQfGW40qMB0QkEmFwcJCCggIrFCoSiaCUory8nA984AP84R/+IVdddRWVlZV4vV7Ky8u56aab2LhxI7fccgulpaVWklGzUTObKefGzOTLOXz4MKOjo5aXTmZmJh6Ph40bN6KU4qWXXmJwcJANGzaQkZHB2rVrufnmmykpKaGyspIdO3bw0Y9+lPLycpqamvj3f/93wuEwRUVF+Hw+q5/OMKvCwkLWrFmDUoq9e/cSCASIRqMcPHiQ3bt3s2jRIgoKCnjooYf4+c9/Tm1tLZdeeilVVVVce+215OTkcOedd7JhwwaamprYsWMHH//4x7n11lvx+XwsW7aMpqYmurq6OHnyJMuXLycrK2vaGGRkZBCPx+np6Zm2AXd6NKULT3HmwIlEIpSXl7N48WLuuecevF4vRUVFZGRkoJQiNzeX5cuXs337dnp7e1m7di1LliwhPz9/1k1udnY2K1eu5Pd+7/f4oz/6I66//nrKysqseczJySE/P5+ioiK8Xu+sYU6ZmZnk5+dTUlJCaWkp2dnZVh3nS1js5H3vex+1tbUsX76cbdu2UVNTAyTynqxdu5abbrqJ22+/ne3bt+Pz+ab1MTs7m9WrV3PjjTfi8/nYuXMnn/jEJ7jqqqsskS4rK4uNGzcSj8cpLCwkJyfHeua6666jpqZmWp1GfDLvwMaNG1m/fj3btm1j8+bN1NXV4fF4aGhoYOnSpTz22GMcOHDAEr/s78327dtZuXLljDFxCnrmu9frZfv27WzdupX3v//9XHvttdPWvyEnJ4dVq1Zx1113UV1dbdnq8Xgszy9TZ3Z2Nrm5uWRlZVn3zJoqLi4mPz/fuhcOh9m9ezd9fX0zvF9mCxMznlvRaNQKAQwGg4yNjbF8+XKWLl3K7bffzurVqyksLCQvL4+qqiorCXFWVpZ1raGhgUWLFpGTk2OJgSLeCIIgCIIgCIKwEJiXpw3MTOIbj8cJhUIUFRVZmx3zF/TMzEyqqqr4u7/7O/74j/+YyclJXC4XixcvRmvN9773Pe6++27KysoYGBiwks26XC4uu+wyenp66O3ttbwSTL11dXU88MADVl4KSISjFBQUcOWVV/L973+foaEhiouLrZCNJ554gm9961u0tLRQVlZGVlYWv/rVr1i3bh3d3d0UFBRQUVGB2+227LBvhs1f9isqKrj00ku57777rOsmUWpeXh6LFi3iwIED+Hw+/H4/ra2tltfF6tWrufLKK6mpqeHTn/400WiU1157jV/84hfcfPPNXHfddaxZs4Ynn3ySNWvW0NjYyGuvvWZ5TZjxHRgYYHJykrGxsVnDUFIlnXXmDDLzZHL6dHZ2smfPHsrLyxkaGsLj8bBixQquuuoqhoaG+OIXv8hTTz3Fvn376OvrS9u+2+1myZIl3HLLLfzLv/wLo6Oj3HLLLWRmZuL1emloaGDnzp0UFBSQn5/PE088QUtLCwMDAzPsVEqxZcsWtm3bRkNDA1lZWTzyyCP4/X7KysooLCxkZGQkZaJbMxb2/jY3N/Pwww9z8OBBK0TH6/Xy+7//+xw6dIgHH3yQJUuWWG3u3r2bUChENBqlqqqKnJwczp07xyWXXALAwYMHLY+pc+fOkZ2dzcaNG7n77ruZnJxk3bp1VFdX09fXR1dXF3/1V3/Fpz71KSs3VHFxMaWlpcRiMdrb28nNzaWvr4+jR4/S1tZmeWndfffd7Nu3jxMnTjA2NjYtX5Hp66WXXorH4+H48eMp17FzbLZs2UI4HObJJ5+kvr6eyy+/nNtuu40f/OAH08qvXLmS7du3c+LECbZt20Z3dzfRaJRFixaRm5vL6Ogovb29ZGdnc9NNN1FfX8+ZM2fYv38/586dY8uWLdx5551kZWVx+vRpnn/+ed544w3Gxsbo7u6ekW/KOX8ej2eaV5E9F5O5FggEGB0dpba2lq1bt/Lss8+ydetWlFL4/X6KioqIxWK43W6uuuoqtm3bRk5OjuV1c+rUKb797W9f9HxOgiAIgiAIgiAIhnmLNgaTBNZsnMxmyGy0TMjECy+8wOjoKC0tLRQVFbFt2zaysrI4dOgQf/Inf0JRUZGVD8R4Wng8Hq6++mqeffZZRkZGCIfDlkBkTtYZGRmx8n5MTk7S29tLXV0dmZmZRKNRVq9ezebNm1m0aBGXXXYZv/rVr7jnnnt4//vfT1VVFXv37uW5555jx44d+Hw+vvjFL/LII4+wd+9eYrHYjBwspr+ZmZlWKAcw43QfpRT19fW88MILxGIxuru7LU+KU6dO8bnPfY7PfOYzfOlLX6Kvr4/Dhw9z8OBB4vE4v/M7v4PH4+HGG28kFovR0tLCrl27rA2q2Xh3dHRYYktxcTF9fX3A/PLYQMJbKiMjg4KCAsLhMCdPniQejzMwMGDZvG3bNnbu3MnixYt5+umn+YM/+ANGRkYIBAKz5v7weDxkZmaitaa3t5dYLMaPfvQjMjIy2LFjB+vXr+fRRx+ls7OTwsJCvvCFL3DFFVfw3HPP8fLLLwOwbt06Wlpa2Lx5M2vXrqWzs5N/+7d/w+PxsHPnTurq6ojFYpw5c4b29vaU4TQGn8/HDTfcQGtrK2fOnGF0dHSa4HfrrbfS1tbGnj17WLp0KZdccgler5c33niDNWvWsHz5cnbt2kVtbS3Z2dn09PTw4Q9/mFdeeYUrrriCb37zmxw/fnxaziETbnPZZZfR19dHb28vN910Ex0dHWzfvp1QKMTixYupq6ujvr6e6upq7rrrLp566ik2b97M8ePH6erqwuVy0dDQwCOPPEJjY6MlMvh8Pnw+H5FIxArvysnJweVyzTiRySmCmXdt+/bt/OhHP2J4eJjm5mYaGhpoaGjg/vvvt0LyysrKWLp0KTk5OTz00EOWN53L5aKwsJCGhgbC4TADAwO43W42bNjAnj17aGho4Oqrr7ZyYH3lK19hYmKC5uZmtm7dysaNG7n//vvZsmULP/vZz6zTzoqLi6mqqiIzM5P9+/dz++23s3PnTh566CGef/55a30qpaYlEza/QWvWrOHRRx/l9ddfZ/HixXi9XkuYU0rxoQ99iHXr1vHII49w6tQpy2PJ3BcvG0EQBEEQBEEQFgrzFm1Shdvk5ubS1dVlbVLNBnFiYsI6lvrUqVOsWLGCVatWsXjxYsbHxzl06BBf/epX6ezsJC8vjyVLlrBq1Sq6u7u55ppr+OlPfzrtqGeToPU//uM/6OvrsxLUmoTIQ0NDNDU18clPfpKzZ8+yd+9e2tvbLU+dlpYWbr/9doqLi3G5XIRCIQYHB/mzP/szvv71r/Paa69ZYozH46GiooLOzs5p4UfRaJRwOExjYyOtra3T8ob4/X5Onz7Nxz/+cQ4dOmSFXrW3t1t1X3755QwPD/PSSy8RjUYZHR217J+cnKS5uZmWlhZaWlro7Oy0BCR7smZzvLFJfmxEm3RzNds1k68mHo9b9Sil8Hq9lvfI0aNH+da3vkV/fz9+v39Op2FFIhG6u7s5ePAg3/jGN/iHf/gHenp6WL9+Pfn5+bz++uucPHmSSCRCNBplfHycSy+9lGAwSGtrK8FgkGuvvZbjx49z2WWXMTg4yL59+yxx4pe//CVaay6//HKKi4vPaw8kQqxuueUWOjo6rDVhPLRWrlzJrl27qK6uZt26dfT39/Poo48yOTnJ2bNnueOOO3jppZcoKyujqKjIOu0oJyeHb37zm5w5c8YSDfLy8ti8eTMul8vKgVRdXU13dzd9fX08/vjjNDY28rnPfY5z587xwgsv8OKLL3LDDTdw6aWX8sILL1gipUkO3NbWxsTEBDfeeCPl5eWMjIxQUFDA5s2bue2229izZw9PPfUUtbW1HDlyxAotTJWk2Kxlt9tNZWUl4XCYqqoqSktLGR8fZ3x8nMbGRktMLC4uxufzMT4+TjgctvI9AYyOjhIIBKw5CAaD+P1+Ojo62Lt3L/X19Vx33XVs3bqV+++/n+HhYfbv38/Y2BhNTU3ceuutFBcX86tf/YrOzk5Wr17N6tWraWhoIDc3l8zMTMLhMLt27aK+vp4tW7bwzDPPWF5Kpj8mPMuE87366qtMTEzg9/stUcblcpGbm0tRURFut5vs7GwyMjKsEEeTp0tEG0EQBEEQBEEQFgpvy9MGEt4akUiEffv2WRsppRTj4+McOHCAoaEhACspcF9fH6dOnaK6uppz585x7tw5pqam0FozOTnJ+Pg4kBAmJiYmZhwXHo1G2bt3L36/39qkTU1NMTAwwMTEBD/5yU8YGxuzQqtMu7FYjLGxMVpbW2lqaiIejxMOhzlx4gRtbW2sXr2avr4+ampqKCkpoaysjEOHDtHV1TWtv/39/bS0tPBbv/VbVuJZk0h4aGiIgYEBHnroIVasWEEkEqGlpYUzZ87Q19fH1NQU9957L5OTkzz//PNAItGu8Rp45ZVXWLRoERUVFVRVVeF2u8nKyqK4uJjHH3/cEku01oTDYUZHRzlx4sR5Q0tmm0MjMpg5Mt4LkMhN4na7GR0d5cyZM0QikZTHoqciHo8zMjLC7t27AfjoRz/Ks88+y9q1axkbG7M8HJRSNDc309/fT0lJCZFIhNzcXCKRCJWVlZaHRDQaJRAIWOtrbGyMvr4+CgoKKCgowOPxTBMTnEQiEVpbW/nIRz7Cvffea42lEVUikQjBYJCJiQn6+voIBAKMjY0Rj8fx+/0UFhZyySWX4PP5iMViFBUVMTExwe7du+nu7iYQCFgC29jYGE8++aQlKng8HoaGhti/f7+V3Dg/P5+lS5eyZ88eDh48SDgcpqOjg6qqKlwuF+3t7fj9fksEDYfDnDt3jocffpjGxkbC4TC9vb20trYSjUbJyMhgamrKSg5uf29mE+8yMzPJzs6mubmZzMxM9u3bRywWY8uWLRw5cgRIeCllZWVNC380fRsZGWFoaIjs7GxLPJmamrKExnA4bNm+ZcsWOjs78Xq9VFVVUVRUZJ0YtXTpUpRSrFq1inA4TGtrK1u3bmXlypUcP34cr9fLpk2bqKmpIR6P88QTT8xY70a4MWKN1prBwUErWbaZn927d+NyudixYwdXX301vb297N+/n3379r3rjo8XBEEQBEEQBOE3m7ec08Yu2gwNDVkeI5DYEI6Pj9PS0mLl3jCn5vT09NDZ2Ul1dTVDQ0NW6FM4HKa/vx+Xy0V+fr513LMzh45SyvKGMZvIQCDAiRMnCIVCPPfccwBMTk5O28QaW1999VX6+/utE6L6+vp46KGHaGxsZMWKFYRCISs5r9/vn9H/0dFRDh48yMqVK1m3bh3j4+OMjY0RDAYt4em5555jzZo1TExM0N7ebvVlcHCQl156iUgkQnt7u+UB4fF4LJHLJGutrq6mqKiIYDBIMBicIcLEYjECgYAVpjQXkSbdPJp8NmacjHBmxICCggKqq6stj6Dx8fE5tRMKhSwPrJqaGq666iry8vKIRqPk5uZSXFxMfX09S5cu5ciRI0xOTuL3+60wFSPq9Pb2kpmZSWlpKWfPngUSITTBYJBwOIzP5yM/P98SCFMRi8Xo6OiwcurYT6GampoiHA5z5ZVXEggE8Pv9DA4OWuF3oVCI48ePs3TpUnp7e+nu7sbj8VBcXExRURF+v59QKGQJWn6/3xJttNacPn3a8lyamJjA7XYzODhIa2srBw4coLe3l9zcXEs0isfj7N+/f1rOIK01oVCIZ599liVLlhAIBJiYmGBwcJDu7m4qKioIh8NMTk5atszmMWKEt/b2djZs2GDl4zECydatW8nIyACw5qGgoMAKBzR9C4VCDAwMWDlnXC4XkUiEJUuWUFJSgsfj4cyZM3R3d7N582YOHz5MVlYWBQUFVo6furo6S4wpLi7mxIkTnDx50soxVV1dTV5eHqOjo1RUVHD55Zfz/PPPW++cM7H28PCwFR5m+hkMBunt7SUajXL69Gl8Ph/r1q2jtLSU4uJitmzZQk1NDU888cS0900QBEEQBEEQBOFiMi/Rxmxk7BteI8Y4E6KGQiFOnDgBYAkCp06dsjwYuru7ZwgqY2NjhMNhKzwlXTJdpw3j4+O0tbXhcrkYHR21TrEyG0t7Lo/W1lba2toALM+RXbt20dnZyapVqyw7Dx48yNjY2IxkxFNTU3R3d/Ozn/2M6667Dq/Xy6lTp+jt7bVOzRoaGuKFF16YZq/x7DEJc+31xmIx+vr6cLvdPPzww6xdu5aGhgaUUvT09Fh5dpx9SeXxkmqsUmG8EkzeHbsI19/fT25uLmNjYwQCASorK1m/fj0jIyMcOnTIEnVmw8ybye3y6quvctddd9HZ2Ynb7Wbt2rXk5eVxySWXMDg4SEtLC2fPniUrK4toNEo8Hufo0aPEYjEOHTrEpk2bWLVqFefOnSMWi9HU1MTIyAinTp3C6/VSV1fH8PDwrImZQ6EQe/futUKDICFIGK+sLVu20N7ezoEDB6zE2CYk74knnuCyyy6ju7ubY8eOUVpaisvlYuPGjUxOTlonmQGEw2GOHTtmjfHu3bvZsGEDq1atwuv1cu7cOcbHx/nBD37AqVOnLOHS7/dbfT5w4ICVw8nep7Nnz9LR0WH1ycxhe3s7VVVVTE5OEgwGpyUpNqeNOeuKx+M8++yzXH311Rw7doy2tja6urrIz8/H5/NRVFTE8PAwIyMjDA8PU1ZWZs2tIRaLWR5n5vdgcnKSlStXMj4+zunTp9m7dy8TExNcf/31rF27llAoxMmTJzl27Jh1RHpNTY2V0Hh0dJTh4WHeeOMNiouLufzyy8nIyODll1+moaGB9evXU15eTldXl9UnI1K53W76+/utULWcnByysrLo6+vj9OnTVtLtQ4cOcezYMfLy8li1ahUf/OAH+e3f/m2OHDnC6dOnRbQRBEEQBEEQBGFBoObqmQHgcrm0z+ez/tpuwiGMx4vZCJvNZGZm5rRwCbs3iH3DaT8VpqioiA9+8IPk5ubywx/+kPHx8WmJfs1mbFonkuKAXVQy9ZvNqr2MSeprDxGBN5MKm2OEjQhjt8++mXO73dM2wmYs7KKM3VvI7hVgTrUy9tvvmYTOziON7WOXdkJt4ou93lTijsm5UlhYCIDf77cSzLrdbsLhMFlZWSxevJgVK1bQ29vLnj17ZoSsOTEhTZmZmeTk5LBjxw62bt3Kgw8+SFtbG7W1tWzcuJFoNMozzzxDZ2en5aVlt90Ic5mZmdx0002sXr2awcFB+vv7qaur47vf/S51dXVs3bqVYDDI9773vVnz7bhcLlasWEFGRgYdHR2WJ5Xb7Z4RFmNfo/Y+2ddCRkYGWVlZ004xs4eqmfVhjqM3a8OEcZkj1Y1t5ghsMwb2f8Y+4wVmt9P0oampiTvvvJMXX3yRJ5980srlUl9fTygUYnh42Krf1GX6bn+Ps7Oz+djHPsaJEyd45ZVXCAaD1hHePT09lqhmb9/ehx07dtDc3ExrayuHDx8mHo+TmZnJl7/8Ze6//35OnjzJ+Pg4sVgMr9dLdXU1S5cu5ejRo0SjUfx+P36/3zoZasWKFQQCAYaHh2lqamLLli10dHRw3333EYlErD4UFRWxfPlympubuffee3G73dx8882cOXOGU6dOUVRUxKpVq2hra7O8xbKzs6muruayyy7jd3/3d/n7v/97du3aZXniCYIgCIIgCIIgvEPs1VpvdF6cd3iUcxNp9xaxCxWAJTjYsW+EnUKE2QgvXryYXbt2zdiAm7pMbgq7QAFvhvqYTaVduHGeBmXfpBuhwp4PxJS1eyw4RRj7Bt6UNW2ZsqnEHrNxN9edngupPIzs42gXgeynVzmFGec4O583otDQ0NC0eTHjbo4/b2tr48iRI3M+Cnn79u2sXLkSr9drhcD86Z/+qRVm09/fz759+6y1ZE+ybMcuhDzyyCO8/vrrrFy5kkgkwmOPPUYwGGR8fJzCwkJycnLOa1c8Hre8rOztOXPA2MfJPg8mbMZ8D4VClvDj9IIy9dqFN3M9Go1aophZK852jb1mLZgcMXZh1N4vpRQlJSXTQuYMlZWV1NXV8cILL8xIWm0XNu3j8dhjj/HZz36WlpYW/H6/lXjZvgZSrbd4PM6JEydYtWoV8GZolcvlYs+ePfh8PutdNGNoRBUzXk6R9tixY9aYt7W1kZ2dzR133MEDDzwwzVNvamqK3t5eBgYGrJDLZ555hnA4bIVKjo6Octddd1FRUWGJMibE80tf+hKvvPLKNGFLEARBEARBEAThYvKWTo9yhg6YDZX9mGH7d7NhtW9CjReCed6IMJmZmSxZsoTOzk7i8fg0rxPjIeMUh+z2OP86bq/bbG6NHfCmV445+cp+z9k/+xjMNjZ20cVuqxFZ7CKV3aPEWZfTq8aZTwjSizmz4RQs0j1nF4Pm45H10ksvWcleTR0mBMgpSJmTsOybdft8GTuCwSAdHR309vZam30jNrz44otWXecjVT9SrWl7v50eS/br6eo3Xmj2emDmHKXzWLF7G9lFPvs7Y54zQs6yZctob2+3jlg3dR45coSlS5dOW2d2Ycn+HRJzZRIG5+bmMjw8bHntzDaOxla/308gELDCD83a7+npsUTVcDhsHTlvF+eMLeadNP0wnkB+v5/e3l68Xi/Lly+nra3N+p2ZmJhgcnJyWt4dczy4y+VicnKS1157jUOHDuH1eq2wMSNShkIhpqamZk1oLQiCIAiCIAiC8E7ylk6PSuUd4hRUnCFBds8XpyBhyvh8PkpKSsjMzLROCrJ7vdiFELvYYBc+7Bs/Z96XVKFCZsPnFHTmumlz2mD37HGKN8YGpweM3UvJfj0dThFgrs/NVpfTE+it1GffbBvxzClspBIwnN4VzvGzj5NJPmsXO+Y7Z6lsTiWOzVYmlZfJbGKeE3sOFueY2MUnu9CZ6t0xZGRkUFtby6uvvmolZDbPGLFibGwspU1ZWVkz3rVoNEpLSwsNDQ2WUHK+8bWH5PX19U1LWB2LxRgfH2dwcBC/32+VjUaj1rvr/I0ArPEx92KxGIODg7zxxhts2LCBkydPWvftIp9zPdvF2MnJScvLydmu04tPEARBEARBEAThYjJv0cYujqTyeHGG0NhFG/s1Z51moxQMBnn++een5c2w5/0wmzPnRtrumeAMW3J6d6Syw3nP+X0+OG1zemqkI5Vtzs1nKhFkNhvmyoXwLDifqJEqr1GqNWPuO+fPfE41v/DW58wpNM7Wt1Tilr2eVM+YtZlqLp2eO3bBwS5qpfLasa/rrKwsAoGAleTYblssFuPs2bMzvGUMGRkZVFRUkJmZaYVglZWV4XK5KC8vx+fzzWlszf2pqSmOHDli5a0xdHV1MTExYXld2ftn71uqduy/BYFAgDNnznDFFVfw4IMPWvXBm94+pj772Nk9uOyJve2CjlmngiAIgiAIgiAIC4G3fOS3UzCBmYKO+ey8lsqTwXgYDA8P88wzz0zbSDk3u/bNqrnmTF7rbDuVmDSXPs6VdN4v9nupxiKVPc7PcxVqFiIX0n6nB1A6weft2nc+7GLD+YSe8wmBqbyO7N43zj6nssO8C62trfT19TE1NTWjfDAYTGtnLBYjIyOD7OxsAHw+H/X19QSDQSs0ai7CmLFnamqKjo6OGfb19/dPmzOncJWuvvz8fCuMLjs7m0WLFpGdnT3NS8fejvN5p0BkPGqcYyzeNYIgCIIgCIIgLDTmfeR3Og8W8z3VM06cngdGVIlGo0xMTMw4McqUcebfcG7QtNaWp0C6zVgqr5tUG+m5eMbYyzvtsNdjtyHVX/TPN26zeQfZr6US1NKRqm9vx7totnYMc7HLXtZeh93TIp2o9XZst9c71817Og+qdJ47s11zetmYe/Z6jdeIff2adycQCPBf//Vf1nPzIRAIcOzYMTIyMqyjvkOhENFolI6ODiYmJqa9s+mEMqcA4/RacYok9lPd7PmrTBnzbFVVFVprCgoKqKmpoba2lry8PB5//HErnMnehhkr+wlt5howzRvPjhnb3yRRVBAEQRAEQRCEdzfzOvLb7XZrk//Cvtl0JhU2my6TYBZmbpTM5tSeC8e+YXWGTDg3jM6Noz0Hit0eU4czFMMagGR5ezjW+Ui1Sbe3k06EOZ/XRSqxIF0Zu3dSqucX0sZzruFh53ve/t1wIfqZTvQ5X7vnE4vmKv44w8acYYH2+p1hUs73xn5vNtvS2WveB5Pc2B5KZN6/83mp2cMdnXalElw9Hs+M99X0VWtNaWkpVVVVFBUVEQwG6e/vZ2xsjHA4bOVPsv8mOU+JM9fNsetG2LWLu+b3ySQlDgQCsx4fLwiCIAiCIAiCcIFJeeT3vEQbpdQA0HEhrRIEQRAEQRAEQRAEQXiPU6+1LnNenJdoIwiCIAiCIAiCIAiCILwzyDEpgiAIgiAIgiAIgiAICxARbQRBEARBEARBEARBEBYgItoIgiAIgiAIgiAIgiAsQES0EQRBEARBEARBEARBWICIaCMIgiAIgiAIgiAIgrAAEdFGEARBEARBEARBEARhASKijSAIgiAIgiAIgiAIwgJERBtBEARBEARBEARBEIQFiIg2giAIgiAIgiAIgiAIC5D/C76tBn5G10ghAAAAAElFTkSuQmCC\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABH4AAABQCAYAAABvXLJMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAACBaklEQVR4nO39d3Sd13ngjf726Q046L13EgQJgr2LEk01Ws1ykW6W7cR27Mk3mW+SfDNxcrPuZOabjGdy58skmSSTZJLYsX0dObEtF8myZElUYRU7ARK9996BA+AA7/3jnL314vAABDtF7d9aWADOect+97vLs5/9FGEYBhqNRqPRaDQajUaj0Wg0mgcPy70ugEaj0Wg0Go1Go9FoNBqN5s6gFT8ajUaj0Wg0Go1Go9FoNA8oWvGj0Wg0Go1Go9FoNBqNRvOAohU/Go1Go9FoNBqNRqPRaDQPKFrxo9FoNBqNRqPRaDQajUbzgKIVPxqNRqPRaDQajUaj0Wg0Dyha8aPRaDQajeYahBBtQohD97gMXxRCHLuXZfioIYQwhBBF97ocdxLdLjQajUajuTG04kej0Wg0miiEFR+zQogpIUS/EOJbQgjfvS6X5sHlbis0wkqiASGEzfSZPfyZcYvXzgtf37bKMX8ohPjurdxHo9FoNBrN9dGKH41Go9FoVuaThmH4gCpgK/AHt/Piqy2KNR89PqLvcxR43PT/4+HPPvZ8RN+nRqPRaDTXoBU/Go1Go9FcB8MwuoHXgA0AQoidQogTQogxIcQlIcRD8lghhF8I8fdCiF4hRLcQ4j8LIazh774ohDguhPgfQohh4A+FEE4hxH8XQnSELYv+WgjhDh+fJIR4JXyfESHE+0IIS/i73w1ff1IIUS+EeCT8uUUI8XUhRLMQYlgI8c9CiITwdy4hxHfDn48JIc4IIVJXefRKIcRlIcS4EOL7QghX+Drx4XINCiFGw39nhb/7rBDirPkiQojfEkL8NPz3is+7AkII8RfhMtTJ57xeXYe//zUhRG24jK8LIXJN3xlCiK8JIRrDdfGXQgixQgGsQojfD9fppBDinBAi23Sd/0MI0Qg0hj87IoS4GL7uCSHERtO1vm66zlUhxLPhz9cBfw3sEiErs7G11JcQ4t+Fn79HCPFrq9TjSnwH+Lzp/88D3454/gwhxE/DbbBJCPEV03fbhRBnhRAT4fL9Sfir98K/x8LPs+tGCrVSPS0/ZMV2sVp5vyWE+M+m/x8SQnSZ/m8Tob51GZgWWvmj0Wg0mgcArfjRaDQajeY6hBf5TwAXhBCZwKvAfwYSgP8L+KEQIjl8+LeAIFAEbAYOA182XW4H0AKkAn8E/FegBKgMn5MJ/H/Cx/4O0AUkh4//fcAQQpQC/xrYZhhGDPAo0BY+5zeBZ4ADQAYh642/DH/3BcAPZAOJwNeA2VUe/TPAY0A+sBH4YvhzC/BNIBfICV/jL8Lf/QwoFUIUm67zIvC98N+rPW80dgDNQBLwH4AfSUUWq9S1EOJpQvX1HKH6ex/4p4hrHwG2hZ/tM4TqMRq/DbxAqA3EAr8GzJi+fyZczvVCiM3APwBfJVTHfwP8VAjhDB/bDOwj9B7+I/BdIUS6YRi1hN7HScMwfIZhxIWPX7G+hBCPEWp/nwCKgZuJyfRjYL8QIk4IER8u208ijnmJUDvMAJ4H/osQ4uHwd38G/JlhGLFAIfDP4c/3h3/HhZ/n5A2WK2o9mb5frV2sVt618ALwZLjswRsst0aj0Wg09x1a8aPRaDQazcr8OGx5cQx4F/gvwK8APzcM4+eGYSwZhvFL4CzwhAhZzzwB/FvDMKYNwxgA/gfwOdM1ewzD+J/hBWUA+HXgtwzDGDEMYzJ8D3n8ApAO5BqGsWAYxvuGYRjAIuAkpGiwG4bRZhhGc/icrwH/b8MwugzDmAP+EHg+bLmwQEgZUWQYxqJhGOcMw5hY5fn/3DCMHsMwRggpdCoBDMMYNgzjh4ZhzITL/EeEFE0YhjFDSHHwAkBYAVRGSPkhrvO80RgA/jT8/N8H6oEn11DXXwO+YRhGbbiu/wshC6Zc07X/q2EYY4ZhdABH5fNF4cvAHxiGUW+EuGQYxrDp+2+En2c2/Hx/YxjG6XAd/yMwB+wM18+/hOt0Kfw8jcD2aDddQ319BvimYRg1hmFME3rXN0qA0Lv9bPjnp+HPZBmygT3A7xqGETAM4yLwd3xoJbQAFAkhkgzDmDIM49RNlOEa1lBPK7WL65V3Lfy5YRid4fep0Wg0Gs1HHq340Wg0Go1mZZ4xDCPOMIxcwzB+I7wQzAU+HXbjGQsrhvYSVtAAdqDX9N3fACmma3aa/k4GPMA50/G/CH8O8P8FmoA3hBAtQoivAxiG0QT8W0IL/QEhxEtCiIzwObnAy6br1RJSFKUScut5HXgp7Br0x0II+yrP32f6ewbwAQghPEKIvxFCtAshJgi59cSJD92svkdY8UPI2ufHYYXQ9Z43Gt1hZZeknZAlx/XqOhf4M9N3I4AgZDGz6vNFIZuQdclKmN9pLvA7Ee0jO1xmhBCfN7mBjRFyH0xa4brXq6+MiHu3r1LG1fg2IcXINW5e4XtIpZP5PrIev0TIIqlOhFwHj9xkGZaxhnpaqV1cr7xrofP6h2g0Go1G89FBK340Go1Go7kxOoHvhBVC8sdrGMZ/DX83BySZvos1DKPcdL55sTpEyE2q3HS8PxxQGsMwJg3D+B3DMAqAp4DflrFMDMP4nmEYewkpGgzgv5nK93hE+VyGYXSHrSP+o2EY64HdhFydbsQSQvI7QCmwI+ziI916ZIycXwLJQohKQgog6ea16vOuQGbY8kWSA/Rw/bruBL4aUQ9uwzBO3MTzdhJyY1oJ8zvtBP4o4r4ewzD+KWxt9L8JueklGiF3rho+rLfITFrXq69eQkolSc5NPBuE3ODSCSkHI7OK9QAJQoiYiPt0AxiG0WgYxguEFG7/DfiBEMIb5VnWzBrqCVZuF6uWF5gmpEyTpEUpwi1lNNNoNBqN5n5DK340Go1Go7kxvgt8UgjxqAgF/XWFA8RmGYbRC7wB/D9CiFgRCrRcKIQ4EO1ChmEsEVrg/g8hRAqAECJTCPFo+O8jQoii8AJ3nJDlzpIQolQI8XA4bkyAkHJgKXzZvwb+SLo0CSGSw/FuEEIcFEJUhC1zJgi56Sxx48SE7zkWjqvyHyKeawH4F0IWSwmEFEHXfd4VSAH+jQilGf80sI6Qq9316vqvgd8TQpSH7+MPn38z/B3wfwshikWIjUKIxBWO/d/A14QQO8LHeoUQT4YVEVIhMhgu068SDhgeph/IEkI4YE319c/AF4UQ64UQHiLew1oJW858EngqwooGwzA6gRPAN8JtfSMhK5/vhsvzK0KI5HBZx8KnLYWfcQkouM7tLeHryh8n168nWLldrFpe4CIht8wEIUQaIcs5jUaj0WgeaLTiR6PRaDSaGyC8sJSBgwcJWXj8Oz6cUz8POICrhAIr/4CQNcVK/C4hd65TYbepNwlZ00AoYO+bwBRwEvgrwzCOEorv818JWYT0EVoE/174nD8jFKflDSHEJHCKUCBcCFk3/ICQ0qeWUNyi79xENfwp4A7f/xQh96NIvkco2PC/GMsD5K72vNE4TagehgjFEnreFF9nxbo2DONlQhYoL4XvU8PytOU3wp8QUrK8Qaju/p7Q81+DYRhnga8QCnY9Gn7WL4a/uwr8P4TeZT9QARw3nf42cAXoE0IMhT9bsb4Mw3iN0Lt4O3zM2+ayiFAmstfW8oCGYVwxDOPKCl+/AOQRsqZ5GfgPhmG8Gf7uMeCKEGKKUNv7nGEYs2HXvj8CjofdtXaucu1Z00/zGuoJVm8Xq5X3O8AlQsHQ3wC+v0q1aDQajUbzQCAiNnY0Go1Go9FoNBqNRqPRaDQPCNriR6PRaDQajUaj0Wg0Go3mAUUrfjQajUaj0Wg0Go1Go9FoHlBuSfEjhHhMCFEvhGgS4RSzGo1Go9FoNBqNRqPRaDSa+4ObjvETzgjSAHwC6ALOAC+EA/JpNBqNRqPRaDQajUaj0WjuMbdi8bMdaDIMo8UwjHngJUJZTjQajUaj0Wg0Go1Go9FoNPcBtls4N5NQCltJFx+mi42KEOKmU4gJIdTf0ayU5Pc6S5lGo9FoNBrNxw8hBDabDbvdzuLiIsFgkMXFxXtdLI3mnnO9dZJ5nbVW9JpLo7kvGTIMIznaF7ei+FkTQohfB35d3dB2526plT8ajUaj0Wg0Hz9sNht5eXl86UtfIiUlhY6ODt59912OHTvG4uLiAyUbWiwWrFYrEJJ5g8HgPS7RrSGEwG63Y7VaWVpaYn5+/pbflxDigXrna+VG1kKRx650bjSlkBCChYWFj2UdazT3Oe0rfXErWphuINv0f1b4s2UYhvG3wN/C2i1+5AAjhEAIweLiovrb/H34+lgsFgzDwDAMNdDLnxshcuC7XchyreXzyM/M/692HVg+ya123Wh/R352vetd75qrlWEt9bGW663luVZiLWU0f7+WMkQ7ZrVnvl57W60Ma2kL5vtH/h3t+LWU8Ubb40rn3Mh7W609rrUM0bheO7zd7THaOau1nZu53mrXvNH2diPXu5G2sNo5N9Mnbkd7XOn4m+0TkQuOtbTh29UnIo+7kfnsRueJj3qfMBP5zm6mjGsddyLPudX2eKMyQ7QyrbWe1/JM17t25HdrqbeVzpPnCCFwu93s3LmT8vJyfD4fLpeLxsZGHA4Hs7Ozq5btbrbH6z3X9bDb7eTn51NQUIDf72dgYIB3332XpaWlm76m+XhZ7tstt6yE1WolOzubsrIyvF4v7e3t1NTUEAgE1lReOeaa77ca0fq6+VrRjrdYLCwtLa3p+uZy3MiYeDu4Xls0l99838h5y/z+I8t3I3Wt0WjuL25F8XMGKBZC5BNS+HwOePFGLrDSYCL/tlqtWCwWHA4HNpsNi8WC3W7H5XLhcDjUrgBAMBhUP/Pz8ywuLi4bpCN/y3usNAiudMzNsNKgvtL9Vvp/Lde50WPMQtONXO9mzol2r1u53s2eczNlXEsZVnufa3nX1/v+Rt/zWs65ke9vZxlu5L2t9v2N9K21HvOg9IkbacM3U8Y73R5vx/VutQx3Y4y+3X1itbJejwd9nog8xmq1EhcXR3x8PDabjc7OTqanp2+6jDcz7tzqu7ZYLEpOiVxErvX930obu973Nzt3ruV+5vMsFgsej4eSkhJiYmLweDxK+WO1WlUdrVS2u9keV2Kt9ZyamsqWLVuoqqoiJiaG5uZmTp06RSAQWPUZb7QMt3uMXul4l8vFrl27KCsrw+FwYLFYaGpqWpPiZ7Xr36jsHvnsTqcTn89HUlISiYmJ9PX10dPTw9zcnOpvN1OuW20n0a63knJntfvLYyPLI/9fWlpa9v/11ksajeb+56YVP4ZhBIUQ/xp4HbAC/2AYxpW1nh85YQvxoZmn1WrF4XDg9XrxeDx4PB41ebvdbvx+P16vl4WFBWZmZjAMg/n5eebm5ggEAkxMTDA5OUkgEGBubo75+XkWFhai+nqvNkjqgU2j0Wg0N8r9thMaTXD/uGOxWPD5fGzevJn8/HwcDgevvvoqc3Nz973bjJSXYmNj8fl8BINBBgYGPtZuFxaLBbfbTWpqKlarFbvdrhatFsvqeUyECMUFcrlcLCwssLCwcN/GBbLZbJSVlbFlyxY2btyIzWbDarXi8/lUuT9KbUAIgdfrZdeuXcTHxxMMBklISMDpdN7QdW7kmdeiGPF4PKSnp1NSUkJJSQnZ2dnU1dXxy1/+kr6+Pubm5takZLnT3Mg6ZSUrJ+k1Ia9n/l9+Fs3y7V4/u0ajuXFuKeCOYRg/B35+k+cCocna6XTicDiIi4sjNjYWv99PcnIyhYWF5OXlkZCQgMViwWaz4XQ61U8gEFg2OS8uLhIIBBgbG6OtrY3BwUE6OzsZGhpiZGSE0dFRZmZmWFxcXGYRtJJQvNZB7aMwAK7mBnG3FFy6DCvzcasDXYb7vwx3i/u5Dh6EMph3bOX15Ofm/+9kGW6Eu1UGu91Oeno6L7zwAmlpaczPz3P16lVGRkaYmJi44/dfjevVgdVqJSUlhQMHDlBeXs7g4CAvvfQSg4ODt01p9VFrC1L5kZCQoNq8tBq/3gaf1WolNTWV4uJient76enpUW3gfqoHwzBwOp1s3LiRnJwcvF4vTqdTWaRMTEzcVYXV7agDIQQOh4OYmBgVlNvlcinF3b2QrW02G4WFhRw8eJADBw6QlJSEzWZj8+bNjIyMcOLECQYHB9Ua4l72icj6Mbv7rVR3kR4QkS6CkcrDSJdK+dn1FKoajeb+444Hd14JqVX2eDyUl5dz8OBBCgsLSU5OVpOZ2+3GarUuy8xgGIaazO12e1TTw4SEBNLT01WQuLm5OUZHR2ltbeXixYtUV1czMDDA/Px81EHSHDNoLURqwu9H1mKmrMtw7/i41YEuw/1fhnt9//uhDh6EMqw0l5njN1wvDseDUA8rIa2Il5aWyMjIoKGhIari536qg4SEBCorKzly5AherxeLxUJNTQ1nz55ldHT0rpThbrDWMkiLHZ/Ph9vtVrKh/JFxIqP1A5vNRnp6Ov/6X/9r8vLyuHTpEq+++iqXL19Wri43UrY7gXnR7fF4iI+Px+fzYbfbsdvteL1evF7vXStPZLlu5Tz57uTmrqxzqVS4m7K1LFdSUhKPPvoo+/fvV4pEwzBwu93s2LGDzs5ORkZG1PrhTrSFlZ77VjcB4Nr4P+b/o9V/ZGyjG10jaTSa+4e7qviRA4vFYiEmJobi4mKeeOIJduzYgcPhwOFwKEXPxMQEDQ0N9PX1MTIyQl1dnRLGPB4PCQkJeDwepqamlLmztBay2+0kJiaSlJSEx+MhJiaGhIQEcnNz2bVrF8PDw/zzP/8z1dXVDA8PEwgEWFpauuHgbWZW202K3FmVO0xCXD8ifuQgf7sH2vt19+5BLkM0Pm51oMtw/5RB7rhmZ2eTkpLC5cuXmZqauiv3hvujDj6uZYhm5fpxqYfFxUVmZmYYHx9XruQbNmygqamJ/v7+ayxn7oc6gA83zaSVRGxsLF6vl23bttHR0cHExMRNyzFrKcO9nitXKoP8X8Z/lJt+gUCAYDAYNfCxVKSsX7+eiooK/H4/09PTJCYmYrPZVAzJtZRBynTys4WFhdvxqNfcy2q1kpiYSGJiIjExMcvuabPZlEX73ViU32xbMMvCNpuNtLQ03G43FouFiYkJBgcHGR4eVkqHW7nXjeJ2uzl06BAbN27E6/UyMDBAbW0tu3btAiAnJ4eUlBScTucddQm9E+/PrOxf7X5mZalZAST/lu9EW/xoNB897qriRw46TqeTLVu28Pjjj7N+/Xp8Ph8tLS00NzczPj7OyMgIPT09DAwMKH97OXnDh2ksHQ4H8/PzWK1W5QbmcrmIjY1l79697Nmzh/n5eaamprBYLKSmpqpA0Z/73Oc4ePAg9fX1XLx4kStXrjA7O4vVal3RdHMtA7F5UI00x4y8XjRBRD7f0tKSsmySx0aaZ2o+mtwPgrNGA6ExKjY2lqqqKh577DGsVitzc3PU19ffVeWP5sFCiFAMmoSEBNavX48QgubmZgYGBpiZmbnXxQNCip+pqSkuXbrEjh07ACgtLSUnJ4fq6up7GudHyjhysWW325V7uvxZWFjA5XIRFxeHx+OhrKyMpKQk2tvbmZubu2dlvxtEU/rIz6TSwzAMpqammJ6eXtXix2q14vf7lXuRx+NRm5BrKYPdbic5OZmcnBylPF9aWqKxsZELFy4wNjZ2WxRx8p52u52YmBhVRqvVyvz8PGNjY0rBZVas3C558XbLLfKdWSwWkpOTCQaD2Gw2xsbGGBsbu2cxlnw+H1VVVSQmJjI2NkZ1dTU///nPiY2NpbS0lNjYWFJSUoiLi7vhsSxyE/heEq0MZkWOdOUyrzvkO5HvbaU1jEajuX+56xY/UohJTEwkKysLu91Od3c3P/zhD+nr62N2dpbp6Wmmp6dV4GbgGpNKea3FxUUlIFmtVrxeLykpKeTk5OB0Omlra+Py5cuMjIxQUFBAcXExqampZGRkkJycTEZGBjk5OSQlJfHuu+8yNzfH4uKiGgDN5owrTaLShxxQ/skulwubzaZ2n5xOJ3Nzc0xOTjI1NUUwGLxGwWTWxsfFxakdKCEEo6OjXL16lfHx8dsmRJjr825wP5lM329luNf3/ziUIdI8+XpliDRHj8atmjvfD+/CbreTlpZGUVERAOvXr6e/v5/p6em7IqDeD3Wgy3D7ymCxWIiPj6e0tJQ9e/aQn5+PxWKhra2No0ePcunSpVWz9aylDHLOd7lcWCwWlc3zRpU1s7OzXLlyhenpaVwuF6mpqUoe6OzsjOpKfj3M48eNLoxkUouMjAwyMjJITEzE5XLhdrtZWFhgbGyMpqYmJicnlYJDujZlZ2eTlJSkZI1b5X5ojzdCMBhkcnKSyclJEhMTcTgcBIPBqJY3kbKcDAwt5bXryXxS3vT7/VRUVLB582YyMjJISkpSwbZLSkqIjY3l3Xffva4i43oKAbO1/OLiIgsLC6qcCwsLdHV1qXuYy347FT+3W26R8q60+HG5XAghGBkZYXh4eJnL0d109UpJSSE1NRWXy8Xg4CAdHR309vbS1tZGYWGhsrhKSEigt7d3WR1f7z3eT5t+5vYRrUzmNZD578hraDSajxb3JMbP0tKSsuKZn59nfHycixcvMjU1peLuRC6oIgdWs1tWpPY5ISGBrKwsbDYbU1NTNDU1UV9fT3NzM52dnVRUVFBUVERcXBxZWVn4/X48Hg+Dg4PU1NSonR9p/SPNhVeauGW2sYSEBFJTU0lOTiYuLk4FoTYMA5vNxuzsLIODg3R1ddHW1sbIyMiy68iB2G63s2fPHg4dOkRcXBwAQ0NDpKen88477zA6OromU97rmXM+SJiVik6nE7vdzvz8PLOzs8t2ADXLkYJXYmIiACMjIw9MZhjZnzweD0IIld1vLf3G4XAoYdRms13Tl8bGxhgfH1/Wvla73v1cn3Lx4HA4ACgrK6O2tpbBwcEH3nLgQedmrFZv9X5JSUls2LCBffv2sXPnTrxeL3a7ndzcXMbGxujv76e9vf2GyyLnxsTERDIyMnC5XMTHx+NwOJidnaW3t5eOjg5GR0fXdG3Z7tvb2xkcHCQzMxOfz0deXh4FBQX09vau2V1HjhkxMTHExcXhcrkIBoOMjY0xMTGh0myvVC6peCgvLyc7O5uCggKysrKIj4/H6XQqy46xsTGuXr1KY2MjLpeLqakpXC4XEIpLEh8fj8vlYnJyUj3jxwHDMAgGg0xNTTEyMkJxcfGyZCBmFyiJnB9kbCB53MzMjErXHYk8R2YP27RpEzt27KCkpASbLSROSzc8v99PMBikpaWF+fl5AoEAdrtdWarPzs7e1PuRsrNUjAQCAerq6qKmcr/fkR4AWVlZynVqeHiYsbGxG7qGedPUvEaA5YGK5XErKTAsFoua961WK1NTU/T39zM3N0dXVxfBYFC9W7kpK5Vxa2Wt7+hOyQ2ruUmu1Oaj/X0/KbE0Gs3aueuuXktLS8zPz9Pb20tLSws+nw+Xy4Xf72dqakophSJ3Y+T5a/lcWuxIhQuEFmrDw8M0NjbS3NzMwYMHWb9+PUlJScrVQS7mZLp4l8uFYRiMjY0xMDDA2NiYKqO8r7TOyc3NZcOGDaxbt47c3FyVjlJORMFgkGAwyOjoKPX19Rw9epRTp04tm8DlLpLD4eCZZ55h69ateL1etWjdvHkzMzMznDhxYtmOXyRmgUa6tgkhVGr7e5Xu807FDJCCmN/vV7GdYmJiGBsbo7e3l5GREaamptSi/14vxFdyI7xbk2hkvICkpCR27dqFYRicOnXqtmaGWUsZ1vL5jWK1WlUQzNzcXCwWC11dXQwMDDA9PX1NRj95jsPhwOfzkZyczJ49e0hMTFQLAnns/Py8UiZ3dnYyOjp6zZi1Vu51HA3DMAgEAnR1dalFZH5+PpmZmbS0tNwVxc+9roMHoQxyzLdYLEoBLl2gJdI9SFq1Rmuvt1oPMuPQoUOHqKqqIhgMMjg4SEpKCvHx8ZSXl9PW1kZnZ+eaF0tyLvN4PCQnJ7N161a2bduG3+8nJSUFl8vFxMQEdXV1HD16lNOnT6uYfTLT50p9c3FxkeHhYVpaWsjOzsZut5Ofn8+GDRs4f/78MsXPajvjMTExpKenU1hYSHFxMYmJiWrTqampid7eXiYmJqIqFKTlUnFxMZ/97GdZt26dSs09MzOjElukpaWRmZlJXl4e9fX1dHd3MzY2ht1uJxgM4vP51Nw3MjJyy2P4/dAnViKyDNINZW5ujrGxMdxuN4uLiyQmJpKSkoLX612Wol1aMchNu/T0dOx2OxaLhampKWZnZ1eMCeR2u8nOzmbXrl0cOXIEv9/PyMgI7e3tjI2NYbVayc3NJSkpiby8PNavX8/U1BSBQIDExETi4+MZGxujubmZmZmZG7LglvKxdF2TCq329vZrFB93Q8a5lbYg5V2v10t2draKqTQ8PMz4+Li6/lo27eRY53a78Xg8WCwWvF4vi4uLSm6X8Zoi5T+zhZ7MlictCgOBgNpo7e/vV7K6tMKT64xom9V3mxt5F5HPv5JlY6S8bK6ryGM1Gs1Hg7tu8SN32RobG/F4PMpXNj8/n+7ubiWsyMEmWtYt+Z2c/OR3clIcGhpSZtZSgWOxWJQp+MWLF2loaGDXrl1KQPV4POzatYuEhASys7Pxer0qw8DU1BQDAwMcO3aM48ePq4xgQghiYmJ47LHHePLJJ4mNjV0Wk2dubg6LxcLs7KwqQ3x8PNu2bSMrK4uRkREaGhqU2btZkTU0NMTbb7/Npk2byMrKUsLG17/+df7Tf/pPnDlzhsnJyWWTjRRm5ASYmJhIdnY2+fn5uFwuLl68qHZEzcLwzShC7rXyxFwOj8dDaWkpjz32GJWVlSr1ZjAYZGBggFdffZXTp0/T0dHB3Nxc1LLfTWH2fposfT4fBw8e5KmnniIYDDIzM8PZs2cZHh6+Y/e83Sbo0a4fGxvL1q1befHFF9mxYwezs7O8++67vPbaa5w+fVrtiEssFgt+v5/i4mL27t1LZWUleXl5yyzJpJA9Pz+PYRi0tbXx6quv8vbbbzMwMLCqeff9zNzcHO3t7bS2tlJRUUFsbCzp6ekkJCRcY5V4LzArNYQQ1+zgftyR1iZOpxOfz0d8fDxZWVkkJCQQFxenFiczMzN0d3dz9epVBgYGrlFWmhVHq20ORC4MzGRmZrJnzx42b97M5OQkr776Kh0dHXzlK19RljrFxcW89957K8bHMI/FcpGVmZlJZWUlhw4dorS0FLvdrpQ7coNny5YtFBUVKbnA5/MxMDCwomuZbFfz8/NUV1eza9cuLBYLCQkJFBcXk5CQoObY1YiJieHw4cM89NBDlJWV4Xa7mZmZUYkqOjs7OX/+PO+//z5Xr169JmCwVLZ++ctfZsuWLSwuLtLc3MzFixepr68nEAiwbt069u3bR2pqKm63m4qKCrKzs+nr61Pv0eFwsG7dOq5evUpfXx9LS0vXVa7dL/P47ULKZE6nk5mZGdLS0igpKSE/P5+amhoVJ8ls4eH1epWFuLSsguUpr+XxNpuN/Px8Dh48yBNPPEFMTAy1tbV873vfo729nampKTweDxUVFXzxi1/EMAzKysqYm5sjOTmZHTt2qLTr3/ve9zhz5gzj4+MrBp+Wz2Quh1RYyR+Px0NlZSUnT55U8vX9PkZGKn3i4+MBGB4eZnh4mKmpqWva7kqWKtJiKzU1leLiYjZu3Ijf7ycnJ4fZ2Vneeecdzp49S2trq9poledGYrVaycvLW5ZRWG5+zM3NqQ0gmU1NegXIYyPLeyP1Icsj2+dq8sRqCr7VLJoix3v5Ey2Uhvl48+fy+vLZNRrNR4u7HuNH/oyPj6t0mZWVlXzwwQdq90NObrA82Fg0LbMctKQAKAM2yl17Gb/C5XKxsLCgFm/BYJBTp06p3c+HH36YnJwctVMnB3GbzaYyiMndm5/97GdcuXIFj8fD/v37efHFF3G5XNTX11NbW0tHRwfj4+PKvDcQCJCSkkJ5eTmbNm0iOzubuLg4fu3Xfo0//uM/pr+/f5k7UiAQ4Bvf+AYWi4WKigqefvppDh8+jNfrJS0tjd/7vd/jG9/4BhcuXFAxf2R54+LiOHDgANu2bVM7j3a7ncnJSR5++GG6u7t58803OX78uDKnvRHTU/njdruX7Ryv5RorKTyimZJe73pScHA6nXz+85/n8ccfx+/3K/93CAnUOTk5fPWrX2X37t28+eabvPnmm/c8VW807ub9I3e4vF4vTqeT+Ph4CgsLaW5uZmRk5LZO6rLdSFN3afkX2X5upB5Wait2u53CwkJ+4zd+g927dxMMBomNjeVTn/oUxcXF/OhHP+IHP/gBU1NTSojy+/3s2bOHF154gby8PIaGhvjpT3+q6iExMZGioiLcbjeGYZCTk0NOTg4HDx5kYWGBH//4xzcV6HAtfeJOI7MoNjU1sXHjRpxOJ3l5eWRlZdHc3HzL7cAcA03eL9ouYiRSoREfH09mZib5+fmkp6fT2tqqrCjMFpi3wv3wHm60DLI/5efns3v3bsrLy8nMzFzmaiTnOwgtKGZnZ+nv7+f73/8+x44dU0pMq9VKTEwMu3btQgjBu+++uyzGnnnMiI2NxW63EwgElgUAt1gsbN68maysLObm5mhsbOQXv/gFgUCADz74gF27duF0OlUWqpUUP+bnTUxM5PHHH2fv3r0UFhYCcPLkSc6ePcvk5CQul4uCggLKy8vJy8sjJSWFf/fv/p3asZfH1dbWRlX2y9/nzp1jamoKt9tNbGwsOTk5rFu3bpll0koLxUOHDvHcc89RVFREIBCgvr6e6elp1q9fj9frpbS0lOzsbMrLy/nWt77F2bNn1QaXzWajsLCQZ555hoqKChYWFvj+97/PW2+9RU9Pj1ISnTlzhrfeeosXX3yR7du3k5CQQHx8PB6Ph+npaZKTkwkEAlRVVdHd3U1DQwMdHR3XVfys1rfvhz6xEtHKYLPZ8Pv9pKamMjc3h8fjwW63s2XLFubm5uju7mZ0dFRt/thsNnJzczlw4AB79+5VykQpT8ofcx9IT0/nkUce4eGHH8Zut3P69Gn+9//+33R3dysFgQwYfuHCBSorK4mPj2fr1q1kZWUppaXFYuE3f/M3OXbsGMeOHaO+vp6RkZGoWcQirdwrKiooKCggOTlZxZN8+umnWVxc5PXXX6e1tVXJsFI2vJ1xIa/3Hm6ExMREDh8+TGpqKsFgkKtXr9LT06M2TeWGrfleZjk0OTmZvXv3snPnTkpKSkhKSsJutyNEKGOu1WqlpKSEsrIyXn31VS5duqTcs83XMv+dnJysFDzz8/NMTEwghFDu8HL9EKn8sFqtqv2sJBNHU+JFs2pazX3sZvql+X7yfzPm9i6vs7i4iN1uV89pbkNmSyeNRvPR4p7E+JGD3Pj4OKdPn+by5csqkGg0RY+ciM2DtPxcDk7m3eBAIIDX6yUmJobFxUV8Ph82mw3DMJYN2C6XC4/Hg8fjwev1EggEePvtt/nggw8AlHl5SUmJyj5WXl5OR0cH8/PzuN1uPvnJT+L1enn33Xd55ZVX6OrqWhb3Qw6MHR0dNDQ00NjYyJEjRygoKCA/P59169YRCARU5gdpsSP9vy9evMjIyAjNzc185StfITY2lqysLH7zN3+Tb33rWxw7doyJiQll5fPVr36V7du34/P5mJ+fZ3R0VMUIkMqrgwcPYrFYeOONN27IlUO6Be3evZs9e/ZQV1fH6dOnlZtI5K6VeWKLnCDkosXlcuF0OpUFlVyMr2VScblcPPvss3zmM59hbm6Of/mXf+Hs2bMEAgGysrJ44YUXKCwsxGKxUFZWBoT841977bVV07TeC+6VS8nS0pLaDQ8Ggyo45e3aCbbZbMTExJCTk8OGDRvYsGGDyobR19fHlStXuHr1qrL2M+8+rYQ0pV+/fj3Z2dmcOHGC6urqZSlGZcwtebwcWzZt2oTP52NiYoJXX31VCYdbtmzh4MGDpKenU1tby//8n/+T9vZ2NV7IeBEWi4XExER+9Vd/lfLycnJzc6moqODtt9++KSup+8GdQu4St7e343K58Hq95OfnK9cX2Tfljrgcd1dbVFqtVpXRqbi4GLfbvSyGw/T0NPX19XR1damsO5G7kT6fjyNHjrB//35ycnKUQA8wOjrKBx98wLFjx7hy5co1Flw3Uwf3w3tYaxlkYNlnnnmGgwcPqs0Ji8XCwsICk5OTyhpEWgJJ14S4uDgee+wxFcdpcXGRrKwsjhw5wiOPPKIswJqbm9XYIPvA5s2bVfa3M2fO8Oabb6qxNC4ujk2bNpGSksLQ0BCXL19mYmJi2cJIjvlut/u69eB2u/nMZz7D/v37SU5OZmhoiKNHj/LKK68wMTFBMBjEYrFw9uxZSktL+exnP0tmZiZpaWlqEZOTk0NBQQH19fVR26vcLOrv76e+vp6EhARcLhcJCQmUlZUpBdhK78HtdrN9+3ZSU1NZWFigtraWv/iLv2BmZobNmzdz6NAhcnJycLlcZGVlcfjwYS5cuKCUn7GxsWpDaWlpiZMnT/Lqq68yNDSkNlYgNDZ3dnby7W9/m8XFRXbu3ElaWpqSbWw2Gy6Xi4yMDA4cOMDMzAzf+c536Onpuelx/H7oE2vFYrHg8/koKCggJiZGZXK1WCykpKQoq8/XXnuNnp4eEhMTKS8vZ+vWrWzevHlZ25DxfuS8Ib9zuVwcOnSIrVu3EhsbS09PD//wD/9AR0eHcr+C0Jw6PDzM8ePHGR8fZ2BggJ07dxIfH6+sRqxWK9nZ2Xzyk5+krKyMEydO8O6779LW1rbMKgWWx5+Riom4uDi1YSNEyOr5S1/6Eo888ghXrlyhoaGBpqYmGhoaGBwcvCahyO3iZtuCxWJRlnyybmZmZmhra2N8fFyVU8oE5rWBEEJtTnz5y1+mvLwch8PB8PAwx44do7W1FZ/Px/79+0lJScHhcLBjxw4SEhLIzMzk1VdfVeOanHdk3Vqt1mVyrJTHDcNQ46vT6VTzn8/nIyMjg5SUFPx+P0NDQ3R2dtLX16eUb3LdIkMvyDkWYGZmRoVtkEoj8/NGWm2Z5bIbtVo3X0P+yDHZ7XaTlZVFWlqaCpIeCAQYHh5mcnKShYWFazZw5Pir0Wg+Wtx1xY95wSkX99JCwzwwRS7+zIOdeaCOPE+awRpGKCiz1WolNjZWLfaWlpaw2+3Exsby0EMPsWfPHsrLy5mdneW9997j5Zdfpq+vTw2iNpuN6upq2traeOaZZ5RAmpKSQmJiIsnJySwuLvLBBx8oS5+VMivIjBynTp0iNzeXpaUlJbjJsstnlxPAwsICPT09vPvuuwgh+PznP09SUhIFBQVs3bqV/v5+Ll++jMVi4ZFHHmH79u24XC7Onj3LpUuXGBwcVIFqt23bRnJyssrgc+rUKYaGhtYkCFgsFjIyMtixYwfPPPMMKSkpFBQUUFZWxqlTp6iurqazs1PtEptd3szvXird/H4/69atY8OGDWRnZ6v20NraytWrV+no6GBsbEwF+45sQzabjbi4OHbu3InNZlO7wA0NDSwuLjI4OMjo6Cjbtm1TO6SyDs6ePUt3d/eNNdwbZK2WS5HH3w3MZZM+8HKHXLpGrrU8UiiKtqPo9/vZvn07lZWVFBcXK2sE6QZZWlpKRUUFdXV1nDlzhs7OTtLT02loaGBoaEhZI0SSkJDAvn37OHz4MB6PB6fTSV1dnTp+aWlJKZZKSkpUxhMZyD0rK4vPf/7z1NTU0NraquJr5Ofnq2Cc7e3tatEq60JaNywsLDA8PEwwGFRplm9WmL5fdtWXlpbo6uoCUH1LBosVQpCZmalS3M7Pz9PZ2Ul1dTVNTU3L3HOdTidJSUmUlZWxZ88eioqKVHBfuYs5NzdHMBhUyp+6ujoaGxvp6OhQCu+SkhI+8YlPsG3bNpKSktTOqwyaL2MwZWRkcO7cOV555RUVF+JmMAvn0q1P7vTeLdbaFtxuNzk5ORw+fJg9e/bg8/loaGhgYGCA/v5++vr6mJycZHZ2Vln9eL1ekpKSyM7Oxu/309LSsszCVs6JSUlJBAIBldXK7IYcExPD008/rTYr2tvbVaBagJSUFNLT0/F6vXR1damYGD6fj/T0dJxOJxMTE/T19a0avFVaeh06dIjdu3cTFxdHXV0d77//PqdOnWJ4eFjNC3KOlNk7Z2dnsdvtxMfHq2xXkRtG0ZidneXy5ctUVFQQHx9PXFwcVVVVJCQkrBojSMaHiY2NVWPgxMQEo6OjyqX00UcfZcOGDdjtdvx+v4rJY7FYKCoqYtOmTSQlJbG4uMjJkycZGxtblrUJUP1mYGCAd955B5fLxYEDB1Tyh5mZGdxuN0II1TYA/vqv/1rJPTfK/TI2rQUhQi5ehYWFeDweFU4gKytLuQEdPnyY4uJiRkZG8Hq9+P1+rFYr/f39tLa2smvXLpaWllSMR6vVqmRTaVm3adMm0tPTmZiY4OLFi/T19al3ZXaXmZub4+rVqwwODpKXl6fa4dDQEBcuXMDtdlNZWYnf76ekpIS4uDjKy8s5ffo0P/vZz5TSIJrF3ZUrV+js7FQKIKlEla7KqampbNmyhZGREXp7e2lqalIK8omJiduavOFG24JZmRETE6OUJtLqtKenh9nZWeBDlyezpYp0zcvNzeVTn/oUFRUVTE1N8corr9DY2MjAwAATExNKJvjCF75AXl4e8fHxlJSUsLS0RG1tLXV1dddsKMsEMV1dXWzatAlAjV1jY2PExsYql66xsTH8fr9STEsF3OLiInV1dbz33nu88847SmEirb4KCgpITExU7Wt0dJSLFy9y4cIFBgYGVHuTsafM2Qqv14dv5F1IhZbf72fXrl3s3r2b4uJiYmNj1dppdnaWtrY26uvraWtro7e3VymCZDZleV/t8qXRfHS4JzF+on0mf+QgErn7a/7f/L0MXmk2QZTa+KWlJaxWKz6fj8TERGZmZkhPTyc7O5vk5GS2b99OYWEhMTExjI+Pc/z4cdra2pYJXUIIZmdnmZmZUdeUGXCkWalhGCoDjlmhJcsjryOzfLS3t7OwsIAQQgVvNNdBZF0EAgF6enp47733SEpK4tlnn1WWSNKKyG63s3//fpKSkqipqeHMmTNcvHiRyclJtcvr9/uJiYlRi4DExERGRkauaw4uzy8tLWX79u3KFDYnJ4e4uDi1k3Lq1CkuXLiwLCCmeTKSC4zs7GyqqqrYvHkzhYWFShheWlqioKBAuRvV1dVRW1t7TZwFuTCIi4tTSiM56cvFjFwoTk5OYrVa2bx5MwkJCUphdys7oddDChEyw5h8l9KyAe4fv/vFxUVlLSGFZ4/Hs8xFJBoWi0XFxRocHKSlpUW9J7kD+YlPfIJ9+/aRl5enMu80NzczNTVFTk4OsbGxqk0mJyczOjpKYmIiV69e5c0336Srq+sa5Y80uS4sLKSoqIilpSW2bNlCenq6yrqxuLhIX18fP/3pT+np6aGzs5Px8XH27t2rlBcyZkZ/f78KGhsXF8fc3BzT09PLdl3N95dWb9Lse3R0VCmBPsoCkNylHhkZUYryvLw89u7dS1paGjk5ORQVFRETE8Pc3Bz9/f1kZWXx6quv0tzczNLSEh6Ph7KyMiorKykrKyMnJ4fR0VEmJiZUf3C73dfEocnNzSUvL48LFy5w7tw5LBYL+/fvZ/fu3TgcDurr69WiRSoX1q9fj9/vVzFVhoaGePPNN28ou4oZi8WiUnmnpaWxuLjIG2+8cd9ZBsrsWAcPHmTv3r243W6OHz+uFg4jIyPLFAdmK1I5D/r9fgYHB1UAW+nSMD4+rhSZOTk5NDQ0qLHBZrORl5fHxo0bSUhIoKen55oMSfK32bLH4XCwfv160tPTMQyDlpYW6uvr1eIuGhaLhdjYWPbv309GRgb9/f1cvHiRDz74QN3XPE/KefXChQsMDQ2puIHmHfbVdqblNaRiV1rHyoW+DMwrxxY5xsn+Lq1mZZKKxMRExsfHlfJ5fn5exZyTiSdkf0hNTSUzM1NZvUq3b3PZJFJh3tzcTEtLCxUVFUrZA6GxXCY5kGNjc3MzR48eVXFkPqrj0/WQyuqioiIAxsfHee+998jPz6ekpERlW/V4PCrJRU9PD7W1tbS2tmK329m2bZuK8ZSYmKiOhVCbzM/PJykpCafTSW9vL42NjUopGC1ujBz3du3ahcfjYWpqio6ODt577z0VRHrnzp1qvE1JSSEmJoaenh7Onj27LAmBeeOzr6+PxsZGcnNz8fl8yyzDZGiCuLg4MjIyKCgooKioiOzsbGpqanjnnXdobW1d5sZ5NzG7HPn9ftLS0nA4HAQCAdra2hgbG1NzaWSflZuGaWlp7Nixg82bN+NyuXjrrbc4fvw4PT09KvuuxWJRc7kQoThhMotvcXGx2rCIjCFqGAbNzc3Mzs7i8XiUi3d3d7fKFDc5Ocng4CDz8/MkJiaqzeSkpCRcLhexsbEsLi7S09NDY2MjycnJHDhwgM2bN6vQC9ISenZ2loSEBBYWFrh48SLDw8PY7XbWr19Pbm4u09PT1NTULFMwmseeSMztL5qVkETW/4YNG3j66afZsGEDfr9fWbpBaLwpLi5m/fr19Pf309vby5kzZ5RC+3Zbj2k0mrvDPVP8SE17pNniSoqhaMofuNZHF0JZdyYnJ0lMTEQIQUpKChs2bCAzM5OysjJKSkrw+XwkJCQorfrMzIyyGjDf0+l0KgsZIUKxiaQvtsfjUdYtcrFsVvSYBQKpoJLBYaUSSZp0RwoPZsFWCnxdXV288sorbN26lfz8fDIyMsjJySEmJga3201JSQlWq5W2tjZaWloYHBxU509PT9PU1ER5eblKXy9dYVZDCqhS6M/NzVXpNrdu3aoWwampqXi9XsbGxmhpaVlm4iqRaTv37t3L7t27ycjIwGq1MjMzg8PhIDY2VpmcFhUVkZmZqSyupEJH1o/dbicuLo6YmBiWlpaU7758dzLAYWtrK5cvXyYrK4u4uDi1k3K7F+nyWaUZr9frJS4ujvT0dFWmmpoa9b7vF2TwcvjQvUZaaKxUTtkvNmzYwGc/+1nq6+t5+eWXlbum3W5n3bp1PPXUU2qHta6uTlklzMzMsG3bNtatW0dqaqr6cTgcWK1WCgsLGR4eJhAI0Nvbe43ix+l04na7cblcLC0tUVJSQnl5uXJbWVpaYnBwkNdee42LFy8yPj7OwsICgUAAj8ejUkx/4hOf4J133lGCG3woEMnnN48zNptNZUDLzMxkdnaWlpYWmpqa7qt3ejMYhsH09DQdHR1kZ2fjdrspKirC4/GQm5urTNNlPSUkJJCcnMzU1JRyJcjKymL37t3s2rULr9dLbW0tp06dWhZzy+/3K6vD1NRU5VKTnJyMw+GgoaGB2NhYdu/eTWpqKjU1Nbz77rucPHmSQCCg4q9MTU2xceNGUlNTycvL46GHHuLkyZNrCsYbDavVyrp169i5cycFBQVMT09z7tw5Zf1pRo4/MTExOBwOJicnl41Pd5L4+HgqKiqUG8OpU6d47bXXllnwRM4jZou1/v5+tbNtnnNnZmaUMtzhcFBSUsIHH3xAf3+/6tNFRUUkJSWpuDKTk5NqkQYhqxNZhri4OJUS/cCBA8THxzM8PExNTQ11dXXXdROUrjjSeqihoYGenh61WDPLD9LCr7m5mdHRUR5++GHl/iRdMdxu96qWDnIel9mBpFLm0KFDGIahlGpTU1PLFtoul0vF85OL9x07dqjxKT09nfT0dFwuF8PDw8vGM1k+n8+3bPc8csFrlgeWlpaYnJxkYGCAvr4+ZfEzOjrKyMgIubm5pKWl4ff7KS0t5TOf+QyBQIDz588vs5R6kJCWqnJTLxgM0t3dzYkTJ7h69Srt7e2sX79eBTqXi/LLly9TXV1Nd3c3mZmZSqaT87ZU4Mm5PT09XckOgUCAoaGhqOnhzRs/GRkZlJaW4nK5GBgY4MqVKypbnAwAXlZWplys161bxyOPPMLQ0BBtbW3L+rR8/7Ozs9TU1LBu3TrS0tKUMkDGt5Su/zExMWqjLzMzkw0bNjA4OMjAwMBNp5K/VeR4JK2+k5KSVDlaWlqUQjia0kfKVzk5OWzfvp3ExERGR0c5efIknZ2dy5TJ8r1IS1P5PmS4AymPm8cEWb8dHR1MT08rBWBpaSldXV2UlZVhtVrp6Oigq6uLkZER3G43ra2tJCYmsmvXLgoLC0lNTWXTpk10dnYyODhIVVUVn/jEJ4iNjVWuYIZhkJ2dTUpKCuvWrWNgYIDx8XEVpuKRRx6hpKREKZ0nJyeXzW3m2EDwYdtzOBw4HA6l3DQHMpfHyfpITExkx44dKvZaQ0ODckV0u92qH6SmpmIYBqOjoxiGsUwev9mNFo1Gc++46+ncgWUCmyTSTNGszFlJsywHO6/Xu8wUVAhBT08Pubm5CCEoLS0lIyND7ULOz8/T19fH4OCg2m0xp301Wy1kZWWxb98+tm/fTiAQoLq6mubmZiDk47qwsIDb7WbdunW0tbWpCVVOxOZnlIuFpKQkrFYrvb299Pf3Rw1eZ1b8AMqKpb29nYsXL6oUpfHx8cTHxy+LY2S2VJCCst1uV7uPcuJdS1R+u91OQkICW7Zsoby8HIDq6mref/99kpOTyc3Nxe12k5ubS0xMDBAyL5+amlomAHk8HtLT03nsscd46KGHsNvt9PT00NrayvDwMBkZGZSVleHz+XA4HGRkZBATE0N2djbf+c53uHr16rLFlQxGKjOvSX93+UzmCW92dpbp6WlmZmZUqtbbIfTI68sFgyyvTIedm5vL5s2blbXLN7/5Td5//316enpu+d63gnkxaI7xI9unfAcrIRdmX/jCF3jooYfIz8/nwoULalfK7/fzqU99ivLycubm5jh+/DhvvPGGcsMTQlBbW8vDDz/M3r17KSoqwu/3ExcXx+LiIjabjcOHDzM8PHyNoswwDJWe1Wq1KmXegQMHuHjxonIjmp+fV9YPcqF+8uRJkpOTKSwsJDc3l+3bt5OXl0dTUxNjY2NMT08TExPDhg0byMjIoL29XfUXp9NJYmIiu3fv5tlnnyUYDCoT+rNnz67olnYj72Itn98JzBaJjY2N7NixA7/frwTTmZkZ2tvbGRkZIT4+nuTkZGJiYkhJSeHZZ5/lwoULNDU1UVVVpbLqNTc3861vfUsFhzbv9DqdTjIyMigvL+fw4cPK+is9PZ24uDjWrVtHeno6CwsLygpoaGgIQMWu6e7uJhAIsG/fPmJiYtQY39jYeFPCqN1up7y8nC1btpCcnMzk5CRlZWUMDAxccz25CNy2bRvx8fGcP3+eq1evrmrFciPvYaXPhRAUFBSwadMm0tLSGBoa4qWXXqKhoUEJ+dE2RyI/i2adMDs7q+LT+Xw+ZQkrlUQ2m02lXJbKDnNcOoBAIKCsFNLS0ti7dy/JyckcOnSI0dFRLl26RHV1NQMDAysqH+TclJSUpCxqh4aGrnENi1zwGIahYuvJoP8Wi4WkpCSqqqr45S9/ucy6NhqBQEDNDU6nE5fLxXPPPcfWrVtpbGyktrZWLeamp6dZWFggLS1NufFYrVbS09P50pe+RH19vUqt7nK5mJqaor29ndOnTy+ziJWLJ6moSktLo7W19RqZwFw/0jqvs7OT7OxsDMPg7NmzvPXWW+zZs4eHH35YbW7t3buXpKQk/vZv/5Zz587R39+vrJeuF/D3bo5BN1oG8+dyc6+goIDY2FiCwSDV1dW0t7dz+fJlzpw5Q1JSEmlpacTHx7OwsEBdXR39/f3Mzc0pS8TBwUGVQTU/P5/8/HxlRSoV/y6XS2VzMisVzAtyi8WCw+EgPT2dw4cPK0WydGOfm5tjYWGBS5cuMTk5ybZt29i2bRulpaU4HA7279/P6Ogor732Gh0dHSrGlNmy69y5cxQXF6u4LDKYe1tbG8eOHUMIoaw1YmNjlZwsyy/79b1A1pVUskmk4jkya5lZzo+JiSEvL0/Fbuzt7WVwcBBAWd/Dh23C7/crK33DMFT8LrMyKNKCcGRkhOnpaWXpnp+fz4EDB8jIyGB0dJQTJ07Q0NDA8PAwDQ0N6t5jY2N8/vOfJyMjg+zsbA4ePMjVq1d59tlnSUlJobW1lffff58LFy6wtLTE5s2beeaZZ/D7/ZSXlzMwMMDw8DAxMTHs3btXuY9J1z4pU0vkO5Rjj8PhIDU1lezsbDo7O+nv71+2qSd/ZL0mJiayZcsWLBYLwWCQf/qnf6KxsRGA5ORkysvLef7550lLS1Ox/YLBoPr5KFs4azQfZ+5JjB9zusxIs2bzghRQ8W/kcXLAln9v2bKFnTt3Kqsdt9tNfHw85eXlauBMS0sjISGBwcFBlVb18uXLbN++nb1791JcXEwwGCQ+Pp6uri6EECQkJFBVVcX+/fspKipiaGiI1157jXPnzjE2Nobb7ebq1ascOHAAIQT79+/nypUrTE1NqcHWLBQIIZSCZM+ePQC8+uqr18QRMe/GmrX6UvAwDIPLly+ze/du3G63ykIi6ysYDFJWVkZ1dTWtra1KEJYuMvIa8/PzanKT9zCbeMpJwu12qyxh8fHxNDY28pOf/IT+/n7++I//mC984Qts2bJFLdyfeuopLl26xPHjx5UFiUyRvXv3brXzef78eU6cOEFdXR2BQEClq9+zZ49yJ5PX/P3f/33+9E//lHPnzi2LISQXq263m6qqKpqbmxkcHFR1BSG/9/3795Ofn6/cAVpaWtTOn6z3tU5gkS4NUiGQnJzMwYMHWb9+PS6XS2XLkjty8fHxfOpTn2J4eJjBwUEleN+LydMsPEh/9ZmZGeLi4tTPasFX7XY7KSkp7Ny5k9nZWbXTWldXx/j4OCkpKZSVlSGE4MyZM7z99tvU1dWpBc/S0hI9PT388Ic/pL29nSeeeIJHH310WbDAiooKTp8+rZQ5ZiYnJ5mYmGB+fh6v14vH4+GJJ57gl7/8JbOzsyrOlryXfM7u7m7ee+89EhIS+NrXvobT6WTXrl20trbS1dVFX18f8fHxZGdn84UvfIH/9b/+F+Pj42on9uDBg2zZsgUhhEoN397efkuKxJUWVndzwWVWxI+Njan+ZbfbGR4e5vvf/z4/+9nPCAQCSnl74MABcnNzVerioaEhNm3aRE5ODnNzc7S0tCxzy4EPx/fFxUUVM2BhYYHnnnuOrKwsZYW4fft2bDYbg4ODtLe3Mzg4uGyREgwGlTuE3Gl1Op2kpqbS3Ny8phTWZqSCvLm5mZKSEtLS0nC73Tz66KPLXC7kuT6fj6997Wt86lOfwul08q1vfUvFK7qVvny9tmCxWNRCT8YQaWlpiar0WQvmRdL8/DxDQ0OMjo6qzYmkpCTcbjezs7M4nU4KCgqUVZ50Y42JiVEBpOPi4lQ8iqSkJJKTk9mwYQNTU1McO3aM1157jba2NhUTaiVkJk65QJWbM5G79FKRKF2zcnJyeOKJJygrK1PHSkXul7/8Zf7kT/5k2dhrrq9gMMjp06cpLy/H4/FQWFiorCby8vJIS0tTGQJlW5idnVVzsJxjPR4PSUlJZGRkEAgEmJmZ4dKlSxw9elQp/c3z18TEBGNjYyp2yYsvvsjw8DD19fVMTExc4xosz5VlXlhYoL+/n5deeom2tjbq6upoa2vjc5/7HJWVlTidTsrLy/n617/O+fPnOXPmDJcuXaK9vZ3+/v5lirDIufBGx6BoKa1vlbWMjzL+YFFRkZJtZNKLhYUF5ubmGBkZUf3TrCyUfb+3t5fXX3+dL37xi0rBWlFRQU1NDYFAAIvFQnt7O4FAAKvVSkZGBvv371cZMGXGWBlPKycnh+eff55t27YxNzfH+++/r0IJWCwW5VocExOjkndIhavD4eCpp55ifn6eN998k6amJhW2QMrMXV1dvPzyy8zMzPDFL35R9cuSkhJOnDjB22+/zfe+9z1SUlLYs2cP8fHxnDhxgsuXLzM8PHxPLTXku4uNjSU5OVlZGc7PzytXKZlYRboCz8/Ps3v3bkZHR/H7/arPlZaW8txzz3HmzBnlfiXbdGpqqrIKlrJWMBhULnhmWU62B6vVyvT0NFeuXCEzM5P09HTy8vIoKioiGAzywQcfUFtbq2R8s+vniRMn2LZtm5LJCwsL+eQnP0lqaip2u51Lly5x6dIluru7MQyDoaEhpSD3+Xzk5ORQWFhIIBBQAcaDwSDZ2dmkpaUpS6FoMUSlIuff//t/T2pqKm+++Sa//OUvaWxsjBorSVobxsfHqz7Q3d2t4ro1NTVx8eJFuru7efTRRxFCcPz4cRWD7H5QCms0mpvjrqdzhw/T+ZqVGfChj200c2dzdih5jNPp5IUXXmDHjh14PB4AtRsj01zKIJQyW0ZLS4uycOjo6GB4eFhlnamsrKS5uZmcnBw+8YlPsG7dOpW95Ec/+hHd3d1q0F1cXKS9vZ0LFy6wd+9eMjIyeOqpp9QAL32LhQjFTSkvL2f79u1KKD1+/DiXL19WqUXNCoBIhZFZIFtaWqKtrY2BgQG1OzEzM8Ps7Cxzc3NK0VJeXk5nZycdHR1qV6usrAyHw8Ho6ChdXV1qIpHKJvMukIyNdOTIEZ588kkcDgeXL1/m6NGjDAwMANDe3s43v/lNenp62LVrl3IJ+cpXvkJOTg5lZWVkZWURHx+P3W5nYmJCLQA6OjpUtgA58TQ0NNDc3Extba1aZMvsFb/927/Nn//5n1NdXa0EYhkA2ul0sm7dOoqLixkaGmJ6ehqv10t2djaPPvooBQUFKg7QyZMnl+24rrZYMrsTyHqSk3pxcTFFRUUUFBSQk5OD1+tlcnKSy5cvKysmaW32b/7Nv1GuEtnZ2col7nr3v1OYJ225Uz41NYXf7ycQCJCdnU1ubq5aGEikKXFOTg4PP/wwiYmJzM7Oqp1uacm2fft2srOzEUJw+fJlhoaGlpmry8X/zMwMFy9eVELP1q1bVVuVu6tut/saQUO6p01PT6vdq9zcXKqqqmhtbVV9zxx0WC4Impubeffdd9m7d6+yMrFarZw+fVqlDk9JSeHgwYPYbDY6OjpU3CmXy0Vvby/f//73OXPmjMosdCvv8H6w+DEzPDys3CQnJiaora3l5z//uQoCPzc3x89//nMAvvCFL2C1WpX1od/vx+fzqQw78KFrGHyoLHU4HHg8HuLj46mqqsLr9TI4OEhra6sKNC4trWTwbrNFlXyf0vJHvgNpobIaaWlpSnkSExNDS0sLdXV1KnZKW1sbGzZsUK6MmZmZasEHKFeDxx57TFmobdy4kcbGRpXd8Ga5XluQrkOJiYkq2K95TrxZ5HwzNzfH+Pg4NptNLVxaW1vp7OxUceHkGLFt2zays7Pp7e1lcXFRBcpNS0sjLi4Oh8OhYm1I94O4uDji4+PVdzImXqTlr8ViUWO8xWLhoYceIjExkYKCAhobG1X8Nul2lpaWRllZGZs3byYuLo729naamprIzc0lJSUFt9vNI488gt/v54c//CFXr15lZGRkmUJZKr/eeOMNYmNjiYuLU4svmYVJLkYBFedP1r+MCeZwOIiJiVHtVSrW5QaPw+FQVj5yDmtpaWHr1q34fD5KSkr4+te/zvvvv8+ZM2eU+4uUZ6RCbevWrWzatInJyUleeuklmpqalNL75ZdfpqmpiV/7tV9TbpcyzkhlZSVDQ0MMDAzwJ3/yJ1y8eHHFuHPmDSdpASXdqqNxJ5QJaxkfpVVySkoKgAoSLGOiSMtrKUtFPq90n3rvvfd47rnnVHychx9+GIvFwne/+13GxsZUHEHp/nLo0CGSk5Opra2lvr5ezY0lJSXk5uYSHx9PR0cHr7/+OmfPnmVmZoasrCwqKyv53Oc+p+IFCREK+tzc3Mw777zDoUOHlDx69epVOjs7EUKo9irj77W3t3P8+HFycnJ45plngJAVTVVVFY2NjTQ2NjI6OkpdXR2GYVwTp+peIMMh2O12HA6H6l8Wi4UXX3yR5557DkDNEXFxccqibmlpiZdffpm2tjYVc87lcnHkyBEeeuihZfF9pGVpQkLCsk3RgYEB3nrrLWw227JMVbI+pPLuypUrbN++nfz8fNX/u7u7efXVV5WCSfZhKR/29fVx8uRJUlNTlRX+hg0b1Jwkn1kGDZcKwbKyMhU2wuVyMTMzo8pvt9vVmka+d/PaQD6bVMyXlpaytLSkrJ2cTuey+UHOweawFIuLi8zOziqlmYw/urS0xOuvv86bb76p5Cez4vtetyWNRnNz3BNXL/PfcgAzKznMA/FKFhly96OpqYni4mLl2yx3J10uF0VFRUrh0NHRQWNjoxI2hRAqZaEQIVeQvXv30tHRwSOPPEJGRgaTk5NUV1fzxhtvqPgCchBfXFxkeHiYd955h8rKSpKTk6msrFSBHC9evIjT6WT9+vXs2rWL/Px8FhcX6ezs5Pz585w/f14FzjQPzFIBY7ZGkYO13W7H5/Nx8OBBvF4vU1NTjI6Oqvg2V69eZffu3TidTrZt28bs7Cy/+MUvGBwcxO12k5ycDEBdXR3nzp1TO1mRu2c2m43ExEQOHz7M008/zdTUlAog2traqrIBJCQkqPgJcgchGAxSWlpKamoqNpuN6elpWlpaOHfuHFevXqWtrY2pqallwa/lBCxNSC9evMjCwgILCws8/PDDOJ1OcnJyePHFF/nmN79JdXW1WpieOHGCZ599lsTERJ588knKy8uZmZmhsLBQBd6Tga4bGxvp6+u7Ruloblvm9iYFE7kDnpmZSV5eHjk5OaSkpOB0OgkEAvT19dHS0sKFCxfo7e1ViwCZGaivr4+MjAz1fuV97tWEaX7fUuk2MDCg4h9lZWWRk5PDxYsXlWAgd7QzMzPZt2+fynAXGxvL/Pw8paWlXLlyhWAwqII5S2EzMkON2ax6bm6OxsZG3nrrLYqKilT8nuHhYRVLI9LyTQY77+7upqqqioWFBZxOp3LviPQ9N99Xxg06c+aMyohksVgYHx/n0qVLxMXF8fTTT+NwONi9ezcHDhxQ7bi2tla5HZrT437UMS+irFarsqKYnJxUFk3m9mq2xjTHW5FCYUxMDCUlJeTk5ACQmJiogqr7/X78fr9apMXFxdHX18f58+c5ffo0Q0ND9PX1UVVVRUpKClu3bmVsbIyLFy8uC7gtlYPm+64W30cIQXl5OS+++KLK1gSheHDvvvsuf/VXf8Xo6CgdHR309/dTVFREYmIilZWV9PX1MTc3h9PppLCwkN/4jd8gKSlJjVkyg1lNTQ2XL1++Yy4UMpbN3NycUlpeT9G11uvKmCOnTp1i48aNOBwOysvLaWtrY25ujm3btpGVlYVhGGoxkZmZSWpq6rI5cXZ2loGBARUjQi5gnnzySaqqqujt7VXZGmWMoLa2NqUokYoii8XC9PQ0ycnJJCQkqJhgMsmCnOdlu5TjyPvvv099fT02m40dO3bw8MMPs3nzZnw+H9u2baOgoICOjg5lSTY7O8vIyAh+vx8hhIo7V19fz5YtW5iammJoaIgf/vCHzMzMqIDVgUBAKXTm5+fVBk5qaioHDhxgx44dKn7PgQMHKCsro66ujuPHj6vMZNJy7fjx47hcLj71qU+pmERHjhxh+/btDA0NKQsAn8+nAlXLrFKnT5/m3LlzKoPb0tIS4+PjXLx4kW984xuUl5fz1FNPUVJSgtvtZn5+nqmpKXp6elbNrAYfWrcdOHCAQ4cOUVRURF1dHX/wB39w066ttxshhIqn5/F4CAQCKt7V4uLisjFajlWRsqdUBrW3t/PDH/6Qz33uc8THx5Oens4TTzxBfn4+J06coKuri8uXL+Pz+ZRb+tatW9m4caOSaeT8Mz4+zptvvslbb71Fd3c3S0tL7N69m+eee47y8nKVZfaNN96gvb2dzs5Ouru7iYmJYdu2bSo+j9PpVM8qLbLNi+/W1lZ+8pOfkJqayr59+7BYLOTl5VFcXMyVK1fo6OhQslRk9tx7gZQDZB+WQZRtNhvr169fZs0HKGuturo6ampqOHfuHCMjIzQ2NvL000+rjTSpUJFysuwDOTk5ZGVlqfeSmprK5z73OU6fPk1tba1qJ1KBkZmZSXFxMZWVlUrB7nA4CAaD+Hw+srOz6enpUXOk2d1KCEF7ezvDw8OqjmVmwcXFRSoqKlQcH+nuOjAwQF1dHdPT0wwODqp4eUNDQyqLWGJiIomJiUrxKtu0tAKT1uV5eXnqmPz8fKX0lgpDs5LK7DkhLdcj5UKpEJVtTb47c//RaDQfPe66xY8cbKItuKWW2WzOLBUgkaaNcvJ46623aGtrUwvCYDCIw+EgJSWFf/Wv/hXx8fFKAJBaenn9oaEhOjo66OvrU0EYP/WpT6l0t9XV1Vy+fHlZHB740Ppobm5O+e0fPnwYt9vNxo0biYuLY+PGjcr8PCEhgampKWpqajh//jzNzc0MDQ1dE2zSrOiRiykpOMfExJCWlsbOnTtVCvOrV6/S0NCgLA+OHj1KWVkZCQkJJCUlsW3bNqxWK2+//TaGYdDe3k5jYyPNzc20trZeEyRTKm+ys7PZsWMH+/fvJxgM8t5771FdXc3Y2Bh5eXnKokNmvpBB+szBMYeGhpQrghRshoeHmZ6eJicnh/LychwOB2NjY3R2dip3I/meWltblen4U089hdVqpaioiPLycqanpxkfHyc2NlbtPsp0qxkZGcr9a3Jykp///OecO3dO3UO+R6nIkG1RKoI8Hg+xsbGkpKSQlpamLFlkDCEZ5HZgYIDe3l7lIjQ4OKiUFVIQcDqdSnAQQqhUmJGWKJF9xLyTcycxW9B0dnaqepF+4jKriXyvSUlJbNmyRe0id3V1kZuby+LiooonIM3r5e6UjNU0PDy8bHdfCh5LS0uMjIzQ0NBAW1ubSqMqrfbMyhxZ5qWlJVpbW7l06RL79u1TKUjz8vKUmXjkTpR5gTw3N6cCc8odvoWFBbq6unj//fdxOBwcOXJEWZvJcxYWFpidnV1TOtyVFNYrHbfWz+8EUrEsFZxSoeJ2u0lLS6O8vJzR0VFldZKdnU1mZqYan0pKSnj88ceVu5bL5aKwsJCvfOUrylpA/kgLoImJCRoaGhgaGqKlpYXW1laV0ai2tpZDhw7hdDqprKxU776hoUHthpaWlrJnzx4qKytZXFykqamJtra2Va0OZMpsaSUosynt2rWLb3/72/T399PZ2Ul9fT0lJSXYbDa2bt3KxYsXSU1NpbCwkG3btrF9+3aVIltaeJSXl/P444/T3t6+okXEWt7Dap9LBe3o6CgZGRnqp6WlZVlmyBu5n/l46UIire5ycnLYvHkzsbGx7N27F7vdTk1NzTWZzqQiorOzk9bWVmU9WFhYSElJCQUFBSrWTUpKirKekmUeHx9ftpiQCw45b0tLw8TEROLj41WMPrmAam9vp6Wlhe7ubtrb2xkbG8Nmsyl35snJSbZs2aJi9vn9fnJycpiZmVFKG4vFouLwXLlyhebmZubn5wkEApw7d45jx44xOzurxsJgMKjkDelqZ7GEUt739fVRX1/P7t27VeYlmeY+PT2drVu3cvnyZerr6+no6KCnp4e3336bmZkZZWUg5+Hk5GQCgYBSNMsshbLPyIyFZvc1malRBiDu6ekhNTVVBbgeHx9ncHCQ/v7+684zcXFxbN26lUcffVTN80lJSddYg94p1jI+er1e3G43FotFvTOzpY9E1o38WyKPmZiY4M033yQ9PZ2NGzeSnJyM1+ulqKiIyclJ0tLSOHv2LKOjo3R2dlJaWorP51Pu/dKSqr+/n56eHrq6uujt7VXZn3Jycli3bp1yr3E6nSwsLKjzZHBpKZtIK26ztax5wS4tX5uamvjZz36mAlg7nU5KS0vZvHkz/f39qi/dLwt2qaxvamrijTfeYGJiQo0PQ0NDKhbj2NiY2tgcGBhgcHCQsbExAoEAo6OjTE5OkpCQQGxsrFJcSAsZGfsnKSmJRx55hHXr1inlYFVVFdnZ2WoMMWfrzczMJDY2dlkWNrlhAXDw4EFmZmaora1lbGzsmnqdmZlZZsXe1NREZmamGgMOHDhAXl4edXV11NfXEwwGqaurU9bk2dnZSi6Rlk55eXns3LmTQCCgXI+lsgpCVqipqalUVFSotpycnExRURHt7e20tbUtiwVk9iKQdWbOWmyWQaX1j3mzTrZDKTPfy01MjUZz49yTGD+RriZyIIlmEWQO0hvNUkGa2JuPlSnDZaBKKRTJyVP+npiYoLGxkaysLKVRLy8vX5aKVbo4mIPByftL8/gLFy6wfft2kpKSVKaa0tJSteiRCiSp9JFm7GYlVqRiSwZETkhIID09naysLNLT06moqMDhcFBbW8sHH3ygrJhkQMNz586xY8cOYmJiVAyOpaUluru76e7upqenh4GBARUoTqa8lYHh8vPzKSsro6KiArvdrkzOg8EgBQUFVFVVsXPnTmVKak4jan5Xly5d4p133qGjo4PR0VE1wXo8HrZv305VVRUej0cFax0aGlLxb0ZHR5W7h7Sgke4HW7duxe/3MzU1pXyU5a6HzBpk3qmQGXdkDAVpam+324mNjVVZuGQWFpmONzk5Wbk2WK1WRkdHlaJHTrzyPck6lcK/dFOKj4+nrKxM7Sa3tbUpV5rVuNuTqBRQAoGAqgOp8JqamsJms5Gbm0tFRYWK9SSDZ37605/GbrerLDwTExMqGKXNZmPjxo309fUBKCFU1pPL5VJtPC0tTZ0j0xIXFhaybt06pqenlcJF9kOZoWhyclIF9CwtLSU/P5/u7m6V0U5iVqJ6vV58Ph9LS6Fsd9JkeXJyktbWVt566y3i4uKorKxUmVxklp99+/bhcrloaWlRu/3RFhgfFeRuX0JCAps3b1ZxQQzDUK4njz32GNPT00BoBzMpKYmcnBwlSErrmNTUVDweDw6HA5vNxsGDB9XCfnh4mNHRUcbHx5WSoL6+noGBAYaGhtTC1mq10tzcTEdHh0rDXFVVhc1mIyMjg4mJCXw+H+Xl5axbt069i5MnT6qd1pUE0aGhIU6dOkVTU5PKBCbv4Xa7MYxQ3AUZ503GkJDvXJrSG4bB0aNHycnJobKyUlnJ7dq1i6NHj/LBBx/cEcXt4uKiUjDLwMUHDhxQMUrM2aZg5XYo+4JcXLjdbuVS19nZSXt7O3l5ecTHx7NhwwbS09MpLCxkfHycX/7yl4yPj6sFhLzH1NQUnZ2dqhxer5e6ujoaGxupqKggNzdXjc1y0St/S0si2c9lX3z//feJiYlRSnRpWTo+Pk5zczOTk5NKWdfd3a36MoRcsTo6OggEAkxMTDAwMEB2drZSaEurpfn5eZXKvr+/n5qaGtra2oCQcn9hYYHa2loVuD5SQSWtc6U8MDMzw8TEhFp4FhcXk5KSQnJyMqmpqRQUFJCXl0dmZqZSRNbX19PU1MTk5CRDQ0MUFxerNNcy6URPTw+Tk5NqDurv71cbGVJ+kG1O/h0MBpmdnWV0dBSHw6GC387PzysLkLWMVXKele7TycnJSnF+r8c6eX9ZT8FgUMXkinSBjFZWs5wpNxRef/11Ojo6yMzMxOv1qpgngUCA1tZWmpub6enpUXF55Jw3NDTEyMgIw8PDKu6PvL60XOnt7cXtdiur9NLSUpxOJ3l5eczNzZGRkYHX62VxcZGWlhZGRkbU/BKp2DWMUPbS0dFRzpw5wzvvvMOePXtUDKHi4mJOnTq1zFU6ck68F+9Pts/e3l6OHTumLJ2kpe/09DRTU1OMj48rqyDzpq1hhNzTx8bGlAukjAcm3bJGRkYAlDXR9PQ0JSUlKq5SXFwcOTk56ppLS0vKam9gYIDGxka6u7uVBdX27dux2+2UlpYyMjKCw+GgtbVVZfqT3gCJiYlKwSpjWY6MjCj34YKCAjIzM5VVtWyzMt28lNflxrKMIblhwwb17DU1NWqclJnjtm3bpjIPG4ah4pS1t7fT29u7TGlttnKTyu/R0VFlmS3leLMSyPzu5G/zOk6j0Xx0uOuKH/POvXniMQ8kZiEmUlEkj5XXMruDmDXV5oCXchdITqBy0b60tERzc7OyzMnLy1OZD+QOrxzAR0ZGlFZeCs4Oh0NlBJPuENJqJDk5mWAwyNTUFI2NjZw/f57Ozk61uxgthpEMmCkDWqanp1NcXExxcTE5OTm43W66u7s5c+YMx44do6mpScUOWFoKBWZ96623SEpKoqSkhNjYWHJzczly5IhyL5NBOOUEI2MvJCYmsn79epUiVPof/+QnP2FiYoKNGzeyY8cO9uzZQ2JionK1iOYnPTs7y/nz51UQPLMprcfjYdOmTWRnZ+Pz+dSuxvz8PMPDw8pCCFAZhKSpu91up7KyknXr1qlJaXp6WsUFkYE2zZm+tm7disViUUKy3OH1er1kZWUp6x4Zl0LeR7o+SFctaWo8PT2tFrX79u3D6XQqAUUGOZXxBvLz81Xq8IGBAS5duqRiYpjbsZm7IYhF9qdgMEhLSwv9/f1kZGSoQLkVFRVAKAjjgQMHqKqqwul0qswhLS0tbNiwgfXr12Oz2SgtLcVqtVJXVweE/PQrKytVHJgrV64wNDSkFvjx8fEkJSWRm5ur4kHNz8+rYK1VVVWqz/b29jI0NKQW5DJguxwnFhcXyc/PZ/v27QwODqp4JbKvSkVqcnKyckOSliJScFtcDKXDraur46WXXlIBi3Nzc1V6ahkj5tixY3R2djIyMsLExIRq59FilkRiVmTfyyCbEFLkZGZmUlVVxZNPPkleXp6yVJMLErObolywACrGjBRaZZ8BlDuoDBrc0dFBdXU1TU1NDA4OLhOYZZuXY4p0q5PZvnJzc0lPT6eyslLt8iYlJamAyufOneP8+fPXWDCa27kQgo6ODoaGhvD5fAwPD1NUVERZWdmyWC/S9UeOOenp6Tz99NNqQTEzM8PJkyd56aWXKC8vJy0tjdzcXGJjYykqKuLhhx+mpqbmptK7ryRIm+dFmcZ7fn4ev9/PkSNHCAaDKmPT1NTUMmVk5IaC7A8yfkZSUhIpKSnExMQwOTnJiRMnOHPmDNnZ2SqeUWpqKmNjY9TX1/OLX/xCBU83L67NO9AAY2Nj9Pb2cvXqVc6fP09FRQXZ2dmqLFLpHxMTo9qJTGkMofh79fX1qu/K2GoyOYB0QZRKDHNdSwtBGbB0cHCQmpoaSktL2bhxo2rPUiFkttqUFgWLi4s0NDSoPmreMIqUW8z1IDekpqen6e7uVpsIxcXFat6TsbCkNaRcyHZ1dTE8PMzp06dJTU1VmxTSQnFmZkZZFJjvZ16oRSLnVhkz60aZmpqiubmZhoYGioqKWFhYWFMsrTuNua9MTU2p9zg7O0tHR8c1brjXm1fNCppTp04ply6fz0cgEGBkZES9C9kPq6urVf2a+4P8WwYYl7LZ+fPn8fl8fOITn6C4uBifz0dVVRUbN25kbm5OLc4XFhZoa2vj1KlTKoZZtHdsVljIAN8pKSnK/VK643d0dKyqEL+ZOl/ts9WQzyGVpG1tbXR2dirFjXT3l89pztIqxxez4kIqL8zWLObNyMXFRY4fP87AwICK1yezoMGHlsCLi4tMT0/T0dFBbW0tTU1NDA0NYbVaKSwsxO12U1paitvtZtu2bfj9fmWl3N7ezsTEBA6Hg9LSUuLi4hgZGeHKlSucOXOGpqYmFYBcJs6QcaDm5uaUBeTi4qKST5ubm5menlaubCkpKcoF0G63Mzo6yuLiIrGxsZSWlrJ9+3b8fr9KPGO1WsnJyaGiokKVUSoi5Rwprf+ksjKaElnWv6zXSM+Mu2GZrtFobi/3jeLHvFtlRgpxq+1USMHMPPCbF3yAmpzNaVJlbI/q6mqWlpY4cuQIGzZswGq1UllZycaNGxkbG6OpqUmlbLbb7SpYojQLlbvg5uvLicpms7Fr1y58Ph+XLl1SpvBygoPQjpqcpGU6UanskQqaiYkJWltb+fa3v6182M2TqBzQr1y5wk9/+lMeffRRqqqqiI2NJSEhgV27dlFZWUlXVxcDAwMqo5d0cZMBmGdmZujt7eXy5cu8/PLLSuHlcrnw+XxqUpETtVysyd3EyclJzp07R01NDVNTU8q6RZZxZmaG6upqldJZ7vRICxkZTE9eVwq/kf7tcpdCBpuenZ0lPz+f8vJyCgsLVXDqLVu2sHHjRtXepFAud0AXFhZUsL2xsTFlRdbR0aHSaI6NjSnFjnQzOXToENu3b2dqaornn39e7fxmZGRQWVlJeXk5WVlZWK1W+vv7efnll1WsKLOpttmN6W4RqURdXFxkaGiIDz74gCeffBKv10t+fj4vvvgiHR0dStkxOTnJ8ePHeeutt1TAyH/8x3/kt3/7t0lLSyMxMZGYmBiKi4vVTpzFYmHHjh1UVlYyMTHB8PCwssBKSEjA6/Vit9uVANvZ2aniJ2VmZqr4Hk1NTbzzzjtMTEwoaxypiJILSLfbzeHDh5Xv/YULFwgGgyowbWlpKRs2bKCsrIyUlBT6+/t57bXXlFBvdqmRVifFxcU88cQT7Nmzh9TUVLxeL48//jg7duygq6uL+vp6ampqlFJrbm5OLbLMizIpUEnXMjkujYyMrKgAvBu7aSkpKTz00EO8+OKLeDwetZCRVnGy75uFadmHBgYG6OnpYWpqSrmjJCQkqMDnMltfSkqKErSlsC77pznGmMyII+P/SJdBGesiKytLBQVeXFxUbgAyk5y0cDDH7pJzgtVqJSsri9TUVDIyMigpKaGwsJBgMMilS5cYGxtjYWGBiYkJ2tvbqaurY+/evUrJODQ0RE1NDSdOnOD06dOMjo7S2tpKdnY2TzzxhFL+PP/88/z4xz+mtbVVuWncKmbr2L6+PhobG2lvb1djzFe+8hWqqqq4cOEC9fX19Pf3K4sDOf5KFwiHw4HL5SIzM5OysjI2bdpEXFwcHR0d/PSnPyUQCPDee++xZ88e0tPT1SL37bff5tVXX2VkZGSZW5G57ZpjcZkXC7W1tSpNsNx1NmeAkudFBguVn5nrINLlM1KxFWmFsrCwQDAYpLOzk56eHo4dO6bij5kt9cwu5bKNmhMvmGUOs4whyynLJs+X/Wh6epquri6uXLnCG2+8QVxcnAq62tvby/DwsNq9l+dLa8aVlE2Rzxj5HsyYz11pA20lDCNkFf2zn/2MwcFBjhw5wvT09D3PChXJ2NgYNTU1ym1UuoyvVi8rIdv23Nyccm+VmK0hZHDeaMF2ZZuS8oJ0mamvr6evr48rV67wta99jY0bNy4Lsjs9PU1bWxtdXV38+Mc/pr6+Xm0oRNsMNSMzUb3//vvs2bMHwzDo6elR1uCR7/9m6uZ2zkfmNmlW6pj/NoeFMNe9PF/ORRIpT0lkoGLprnn58mXcbjcJCQnKtQw+VLjIDHtStpb1NTY2xsDAAC+88AIbNmwgJiaGyspK1q9fz+TkJBcvXqSlpQWfz0dFRQVCCKqrq3n99deVhVhHRwdlZWVkZGSQlpZGRkYGFotFbYBMTEwwNDTE0NAQk5OTdHV1kZqayrPPPktFRYWKdbZlyxby8/OZm5tjZmYGh8Oh3Bz7+vp466232L17N5mZmcTHx7NlyxZsNhvf//73ldWi2TNCCKGSrERa+ERukke+P5niXaPRfLQQ1xv8hRDZwLeBVMAA/tYwjD8TQvwh8BVgMHzo7xuG8fPVrmWxWAxzbJVowtwK50WdqMxxcMwTm91uZ926dfzN3/wNiYmJnDhxgpdffpmjR4+qhZncwZVIAf+3fuu3WL9+PV6vVy0gpEWPFFrlBCMXb0tLSyr9YU9Pj1pMyTSOcgA1m1jLhYbcGfd4PCp6v/Td7u/vp6uri5qaGi5duqSCjErNfeSPHIxtNhtZWVns3r2bT37yk2RkZCxzTZKTo1mgHR0d5e233+b48ePU1dUpgUMSHx/PwYMHeeaZZygsLMTr9S6bZKempmhoaOBHP/oRR48eZWJiYpkgJBVTS0tLeDweSkpKeOihh9ixYwdZWVnqfZh/zJZRw8PDVFdXc+XKFZqamujp6VG7FfIdyHe4YcMGduzYQU5OjnLhk+/aMELm0SMjI/T19amg3w0NDSqAd2TAP3merL+srCz+8A//kF27dik3Odl25Tlzc3P09fXxzjvv8L3vfY+2tjbl5mReNEUKL7I9Ryo77zR2u53169fz9a9/XcVfkguxkZERampqePnll7l69apSkEmlwKZNm1TQ3Pj4eCWURdsdlxmjpPVEU1MTtbW11NbWqgC+u3bt4ld+5VfIzc1V7VW+D7krJa292tvbqa2t5Utf+pKqt5mZGZXJz+l0kpaWRkFBgQp8OD4+zpUrV/jud79LbW2tiiMiy2jGZrMRFxdHcXExu3fvZs+ePZSWli4TSgOBAMPDw4yPj1NXV0dtbS0LCwtqp91isSg3upSUFAoKCsjNzWV0dJQ//MM/ZHh4+K69ZzNCCAoLC3nkkUd49tlnlTWgjEslA2babDa1K9nZ2cm5c+c4deoUly5dYnJycpkyXQbVf/zxx3niiSdISUlRCuXJyUkmJiaURY1ULpkFSI/Ho8Zel8ulMolYrVbi4uKUsC6Vv4FAQF2ro6ODmZkZZfUnlfTyejJOl3yu+fl52tra+Ku/+iuOHj3K5OSkckctLS3l6aefJhgMKlec7u5utdNqGAZ2u52CggI+//nPc/jwYVJSUlhaWuLv/u7v+PM//3PGx8dvu2AshFApyqXCB1gmoEtXo76+Pnp7e5VlXUJCAn6/XynxBwcHee211zh58iQtLS1qAeD1ennyyScpLi5meHiYs2fPqrTW5r680uIxsi/J9yv7rXlxIXflzeNdpKWW+X7Rrr/WejOXxyx7RNtUirz2avdcyQrCbH0WqTySVqnmH/PnkfdcyaLnbswR8lnk80h55m7OT9dDyg9yzroZ6xbzuzJzveuYNxyjtZtIazur1aoyg7rdboLBoHLzGx8fV7HkIhVJ0dqg+d1ASJFfWVm5zB1SWrCtxN16j+bym+dPiXmcMJ8TGZBbfm5+X1JpId+FecPFnLAgMhizWblq3iwwy9TShcztdlNQUMBjjz1GeXk5cXFxqkw2m43JyUmmp6dpaGjg9OnTnD59epniWq4bZD+Sm6XS4tTc7qS1mAyyv3fvXrZs2YLD4WBubg6r1crc3JxKctHV1aUywGVmZvL888+zceNG4uPjCQQCVFdX8w//8A8q211ycjI7duzgmWeewev1cu7cOb75zW8yPj6u1imRMbzM5TP/bU7WotFo7hvOGYaxNdoXa1H8pAPphmGcF0LEAOeAZ4DPAFOGYfz3tZbCYrEYckBbbUd7pZ0ps6LBLDyaJwYhQoEgH3roIf7oj/6I2NhYXnnlFV566SWqq6uVYCDPM7uISd/oTZs2KbennJwcFctHBoyUE/T09DQ9PT3U1NTQ2dmpYvdIV7HKykoeeughsrOzMT+3VFIEAgG18JG76J2dnRw/fpz6+np6e3tVqna5C2+2jIrUzssJVU5UMohlZWUlW7ZsUVH/5QQrLSw++OADzp8/r5QpUsA316lcAOfl5Sn3F5/Px+TkJG1tbSrQZH9/v9oJkwtqqTyTk650afP7/WRkZLBhwwaVHthut+P3+7Hb7czPz9PV1cWxY8eoqamhtbVV+SRHuu3Jcsp00dKKKDMzU6XgXVxcVDvg4+Pj9PX1qdgx5pgH5p0oc1uT783tdvOVr3yFT37yk8uUAA0NDRw/fpz+/n56e3tpbW2lvb2d6enpZfE3IoWY6/WHO4lZcPR4PDzyyCM8/vjjrF+/nmAwyOnTp/nBD36g2kZkHBEZEDw5OVnFoYqJicHhcNDd3c369euVJZD86ejo4L333lMxp6QiQAoaHo+HdevWsXPnTqqqqsjPz1dxkgYHBzl//jwXL16kqalJxQR44okn+PVf/3VSU1MRIhToXcalkRl4rl69ypUrV6irq1PnStN9M+a+ZRbSfD4fCQkJbN26lV27dpGTk4Pf71fKBamUkJkCze1T3kO6US0sLFBdXc3v//7vK9fGe0FcXBxlZWU89dRTlJWVkZaWphZRUiiV7h5SKdzT06OCeJvjm8j2a7fbSUpKoqqqiueff16Zq5sFbykES6WRVAwtLi6q/tPQ0EBvby+Tk5MIEcqYVFpaSnZ2NkVFRco9U74rl8ullKtyzJKKHrvdTjAYZHR0lO7ubhobG1XcNWm1JJ9Fnuv1etVYIHePzSbuQoQCYB84cIBPf/rTPPHEEywuhlJ0f/WrX6WhoUEpzNbCSmNA5OdS4ZqTk8O+ffvYt28fBQUFqo6ltYl0mzQvDAOBAB0dHTQ1NSmXlqGhoWXzixBCxcEJBoPLssJEs/S5HpGL8EiFxr1QIETOnWs5Hm58kWyem8yWntHmgJXuJ8+921Y2ke3uZuvgdpZhNe5VWzLfH65VzMjPzG1AyinmPmDO1nQj/cysxJCK+mjXuRN1czNyy2oKLPm5ub6k/Bi5JjDPz2ZljlTCRVO6yXtFK3ekkjmyzqTs7PV6SUtLIzk5mdjYWOLi4hgbG6Ovr4/x8XGlADIH1TaXwyxfmhVVZnlbfi4VVjKJitwglpsiw8PDyrJeWqs5HA6ys7N59NFH2b59Oz6fj4WFBVpbW3nvvfdobm4mJyeHHTt2sG7dOgD+/u//nuPHjzM7O6vqIFLBG00JabFYVEwtjUZzX3Hzip9rThDiJ8BfAHu4QcWPEMIwB0c2Y1bqmAf+lYSNSGWP/O1wOEhISOB3f/d3efTRR+nv7+ef//mf+dnPfqayWETbfZQWIRaLRS1Qk5KSSExMVAGirVarCio3PT2tzEjlrrc5Y5SMF5ORkaEULomJiSQlJeF0OlUAOxkjRgY2lrEGJiYmrsnoIMsXbVcEWOYDbVaASFcXqYCSfuSjo6OMjIwwPj7O1NSUsiYymxbLiVW6dzmdTnw+n1KmyJ13GYRP+lubFSeR70/WtXQ78Hg8xMfHK3ezlJSUZQF8e3p61LUj358R3nk3T1JS+JEKMKl0M09i8t2ZBXDzJG1ug2bkhJybm0txcTFZWVnq/nV1dfT29jI9Pa18tc2xPu62Fc9qRD6XrKukpCQV7Bygvb1d1b/ZxUOeAx8GCJauJNI9zzAM5col26PD4VAZUGRqarNPv7ye1+slISFBBQ3Oy8vDMAwVEHhsbEy1WQjtdO7YsYNt27ap2DCy/JcvX6aurk5ZbMhYGZFBmVerJ9kHbDYb8fHxKk6WdNHMyMigsLCQmJgYUlNTcTqdqt3Nzc3h8/m4cuUKLpeLtrY2GhoaaGho4PLly0rYuhdIBYcMPpuVlbUs5ktbWxsjIyOMjY0xMjLC9PS0UtKZ+06kYkIqcFNTU1XAdK/Xi8fjUeOrtL6U15a7jVJwlv1I9ks5psqxND4+Hp/Pp5Q75rgNUviXfVwqAwcGBhgeHmZsbExZIJnHPIl57pFEW6zb7XYyMzM5dOgQn/3sZ/F4PFy+fJm//Mu/VAFh7wSyjmXby83NVcpHv9+P3+9X/UQuBGXcq/7+fmUtGRkzZqXnj1ycPAjcaUVG5KJfcjP3u9dKDc3tQS7ml5aWlrmkSszzkVkOWSvRLGmi/X8viex3kRu40WTbSDekleQz8yaduS4iFT/yd+TmW2T5Iud/QMkBDodDzfNmK5nIDHvynZoD4putacyfyzKYYx6ZFUBy3Jebt3Ij27whLDfx8vLyqKqqYt++fWRnZzM9Pc3Q0BBjY2NK5rbZbNTV1fHXf/3XDA4OXuM6J8tqritzOeW8cj+1L41GA9wuxY8QIg94D9gA/DbwRWACOAv8jmEYo9c5f0XFj1kbbibaLpn52Gg7oZmZmfzBH/wBfr+f48eP8+6773L16lWlSJHWJ+ZrmScYqSyQiwmZAUQO5NL9wOwOZN6Ri7QUkBYsbrcbn8+Hw+FQ5rw2m43Z2Vm10JEWLZHBCeV1ZRnNCqCVdjnMFk0yK5b8XLo0yYVzpFY/sq6j7Z5Es4gxZ6wy+2TLe5gnYPNOtHTNsFgs+Hw+Zco6OzurXDkid8HMvvWy/uV30l0scrFi3m2JVj6ziXC0sssfaQEid9mXlkJpyaVFTOQkeTNC3J0k8tnM7UQupIUQytrMXG+R9Q/L3SdkW5CpPuVn8j1JASlyV818Lflb7m4lJCQghGB4eHiZ4kGW3WKxKKWVjB1ktVoZHByku7ubvr4+lfUn2j3XWlfmfiXHCBl4Njk5WS28ZYwqIUJxpRwOB52dnVitVoaHh1Va7uuZ4d9pzO/F7XarwLMul0ulzZVjktnaxdz3o7UHKShbLBYVEFpm+5LKXjnOyT4u+45UxEgid4ABlRlHum2Zlb3m88yBf2WwfbOy0Sww30zdyXrLy8tTGRfb29upqalRLpF3CrNCPjY2VrU5malQKtBkf5LK7kAgsKxerjcu3Qmlw4OiyIj2HOb540F4Rs213KzS0Oz+F41Ixc/N3MN8/Tut3LwZoslV0VjtO/Mx8prmdYGUC8z3NNeF2VJIfm8eByPntch1RrRniVRKwbWxS82bovJvOW+tprQyK97NlrPmeTFyo1Zm4du0aRObNm0iISFBxVaTiRj6+vqUW5qcfyPrcaV4WfJ/8waqRqO5b7h1xY8Qwge8C/yRYRg/EkKkAkOE4v7834TcwX4tynm/Dvx6+N8tkYqf1QZ28+AdaWJouv6ywc/hcJCcnMynP/1pJicnOXnypIr9IJUjkVnAIgU1c8pDsxJHxjWRZZODotTGR2YdkIO1vIZ5AROplDArNVbyFTcrNyJ3R+S9zFH4I8+PLId8DvNkY17cmxdakZjfi3lSleVbqV1FKtrMzybLE02JYF50Ri405Tnm7+ViUNZn5KRsfldmIuvF/Flk+SMFGPP1V2Oti4KbEYqi9au13CtSQSP/j1RoRtZxtN0suDbQork8kUq3SMVYtDYn+4zsw5FCmVmYk+9eCKGUTOZ2uVZlz0oLush6ks8hBTLzmGE+Ryo0zH3dLNBF1pO5bqL9He34mz1H1qX8MT97NLeDaHUYbUySn0eeF21313w/8zHm55D1JZVq5nqU94xWhsi2u9Iz3AiyfHIX1uFwAChrsmiCcrRFWeT3q/1tJnKOiezzq8UGWenZVxtXVivvaudGI9q7WytrqZsbvV5km492r2hcb5xY6X63Wua1ciPzxGrnrqXOb/S5bkcZVmqDax0f11Ke1eSp1SxGo41B0WSGaOfcLJFljZRt7xdWakuryY2R30X2WfN8a5YJV6qPaNc0yyDm8SnaO1zp/crzzONyZDuJlF/Mm7SRc56cP6XsIGUcYNn/Uv43X0taxxYVFalkMRCao0ZHR+nq6qKxsXFZpkZ5z0irpWjPK691P7UtjUYD3KriRwhhB14BXjcM40+ifJ8HvGIYxobrXGeZxc9Kg6/8Psr5UY8zD0Ry0IuNjV2WeUEeE+lza1ZgRJpcRi7g5P3MA7NZ2SIXu+Y4FhLztc2aeXnvSLeT1Rbw0SakyEWz+Xw5CUZas5gXZOY6Mg/y0l3FXE+Ri3pzmc0TXrSJwryok9cT4sNAd9GEOPPkGU3xY/4+8hxzfZnrLdqiKPJaqy1OzZOrOYBfpCASTTCMthC7U6z1XpGTeaSQvZLwa25L5jo233Mtgt1ay76SIjLa95EKlhspQ7R3Ge3cSKEwmiBpPu6j4C6zWru/HawkDF9vMRUpkEZ+Z/47svx3euFzN/v0zWBupzoew7Xcbwtjzf3NWhQ/0c6B6HNItM9vJ/dz+15tXL/eOZGyhvzbrByJPGYl2VVeN5rsE7khYr5HtDIAy+TgSDczKe9LuVd+J783J54xz2VSTjdvbpm/NydGiYy/53a7cTgcKv6m2S3NHF/KPE+sZDEvN7sBHeNHo7k/WVHxc9107iI0Cvw9UGtW+ggh0g3D6A3/+yxQs5aSRBtE1jLxRS46DSMU2yVSYSIHrsnJyaiL0sgFoFSKwIdKIZnmUF7PrKwwx4sxKxrktcwuWmZLIKkgMgdzi1SQmJ81ctd7pR0Dc91ELrojFVuRE160hXnk9cyKHvl5NOXW9RRSKy28zZ9H7l6YJyE5kZmfyaxIM9d5pFLJ/Czm60VzdTCXLXInPbLtRirqoi36V1MGmOtgLZ/dDNGuEU2JY35vKwkyZiFC1vlKpuuRbWulZ4n8PlrZrndcZB+M9uzR7h9NOblSOa/3uXm8WKm9rHR+tOdd6fM7QeS9zOPa7Walulnp/UWOG2vZYV+pzd8Ma62H29VX71RbWKsi7260x5td6N7JPnG/LYrvx3HhXnA762G1OXW171Yrw1rvu9rxt9L27ofxaTWiPXs0GfxGr2f+bZ57o8kkkbJwZHmknG6WESMt+yOfPVIujFTsRMoB0c6XVqvmDWNz2cxzormezOsIuWYxu4sZhrHMXVp+Pj4+rsJWRMq+MstlNPk32tpBfn6vxweNRnPjrCWr117gfaAakFL37wMvAJWAAbQBXzU+VAStdK1BYJqQi5hGo7l/SUL3U43mfkf3U43mo4HuqxrN/Y/up5oHgVzDMJKjfXHDWb1uFSHEWWMF8yONRnN/oPupRnP/o/upRvPRQPdVjeb+R/dTzYPO6gEzNBqNRqPRaDQajUaj0Wg0H1m04kej0Wg0Go1Go9FoNBqN5gHlXih+/vYe3FOj0dwYup9qNPc/up9qNB8NdF/VaO5/dD/VPNDc9Rg/Go1Go9FoNBqNRqPRaDSau4N29dJoNBqNRqPRaDQajUajeUC5a4ofIcRjQoh6IUSTEOLrd+u+Go1mOUKIbCHEUSHEVSHEFSHE/xn+PEEI8UshRGP4d3z4cyGE+PNw370shKi6t0+g0Xy8EEJYhRAXhBCvhP/PF0KcDvfJ7wshHOHPneH/m8Lf593Tgms0HxOEEHFCiB8IIeqEELVCiF16TtVo7j+EEL8Vln1rhBD/JIRw6TlV83Hhrih+hBBW4C+Bx4H1wAtCiPV3494ajeYagsDvGIaxHtgJ/B/h/vh14C3DMIqBt8L/Q6jfFod/fh34X3e/yBrNx5r/E6g1/f/fgP9hGEYRMAp8Kfz5l4DR8Of/I3ycRqO58/wZ8AvDMMqATYT6q55TNZr7CCFEJvBvgK2GYWwArMDn0HOq5mPC3bL42Q40GYbRYhjGPPAS8PRdurdGozFhGEavYRjnw39PEhJQMwn1yX8MH/aPwDPhv58Gvm2EOAXECSHS726pNZqPJ0KILOBJ4O/C/wvgYeAH4UMi+6rswz8AHgkfr9Fo7hBCCD+wH/h7AMMw5g3DGEPPqRrN/YgNcAshbIAH6EXPqZqPCXdL8ZMJdJr+7wp/ptFo7iFhs9XNwGkg1TCM3vBXfUBq+G/dfzWae8efAv8eWAr/nwiMGYYRDP9v7o+qr4a/Hw8fr9Fo7hz5wCDwzbBL5t8JIbzoOVWjua8wDKMb+O9AByGFzzhwDj2naj4m6ODOGs3HFCGED/gh8G8Nw5gwf2eE0v3plH8azT1ECHEEGDAM49y9LotGo1kRG1AF/C/DMDYD03zo1gXoOVWjuR8Ix9l6mpCyNgPwAo/d00JpNHeRu6X46QayTf9nhT/TaDT3ACGEnZDS5/9nGMaPwh/3S3Pz8O+B8Oe6/2o094Y9wFNCiDZCLtIPE4olEhc2U4fl/VH11fD3fmD4bhZYo/kY0gV0GYZxOvz/DwgpgvScqtHcXxwCWg3DGDQMYwH4EaF5Vs+pmo8Fd0vxcwYoDkdNdxAKpPXTu3RvjUZjIuyf/PdArWEYf2L66qfAF8J/fwH4ienzz4czkewExk3m6xqN5g5hGMbvGYaRZRhGHqF5823DMP5fwFHg+fBhkX1V9uHnw8drKwON5g5iGEYf0CmEKA1/9AhwFT2najT3Gx3ATiGEJywLy76q51TNxwJxt9qvEOIJQrEKrMA/GIbxR3flxhqNZhlCiL3A+0A1H8YN+X1CcX7+GcgB2oHPGIYxEp4c/4KQOewM8KuGYZy96wXXaD7GCCEeAv4vwzCOCCEKCFkAJQAXgF8xDGNOCOECvkMobtcI8DnDMFruUZE1mo8NQohKQgHYHUAL8KuENlf1nKrR3EcIIf4j8FlCGW4vAF8mFMtHz6maB567pvjRaDQajUaj0Wg0Go1Go9HcXXRwZ41Go9FoNBqNRqPRaDSaBxSt+NFoNBqNRqPRaDQajUajeUDRih+NRqPRaDQajUaj0Wg0mgcUrfjRaDQajUaj0Wg0Go1Go3lA0YofjUaj0Wg0Go1Go9FoNJoHFK340Wg0Go1Go9FoNBqNRqN5QNGKH41Go9FoNBqNRqPRaDSaBxSt+NFoNBqNRqPRaDQajUajeUD5/wN/MDxLriQzGQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "<Figure size 1440x1440 with 1 Axes>" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ "for i in range(10, 20):\n", " plt.figure(figsize=(20, 20))\n", + " plt.xticks([])\n", + " plt.yticks([])\n", " data, target = dataset[i]\n", - " sentence = convert_y_label_to_string(target) \n", + " sentence = convert_y_label_to_string(target, dataset) \n", " print(sentence)\n", " plt.title(sentence)\n", " plt.imshow(data.squeeze(0).numpy(), cmap='gray')" @@ -251,26 +254,46 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "data, target = dataset[0]\n", + "data, target = dataset[12]\n", "sentence = convert_y_label_to_string(target) " ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([97])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "target.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "h, w, s = 28, 18, 4" + "h, w, s = 28, 8, 2" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -280,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -289,21 +312,21 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "A MOVE to stop Mr. Gaitskell from\n" + "\"They have come!\" he said reverently, gripping his_______________________________________________\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "<Figure size 1440x1440 with 60 Axes>" + "<Figure size 2880x2880 with 50 Axes>" ] }, "metadata": {}, @@ -312,9 +335,9 @@ ], "source": [ "# remove batch size\n", - "n = 60\n", + "n = 50\n", "patches = patches.squeeze(0)\n", - "fig = plt.figure(figsize=(20, 20))\n", + "fig = plt.figure(figsize=(40, 40))\n", "print(sentence)\n", "for i in range(n):\n", " ax = fig.add_subplot(1, n, i + 1)\n", @@ -325,16 +348,16 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "torch.Size([234, 1, 28, 18])" + "torch.Size([473, 1, 28, 8])" ] }, - "execution_count": 44, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -345,22 +368,1196 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x7f95e295e5d0>" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABH4AAABDCAYAAADqHsJ5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABsUElEQVR4nO29aXBcV3Ym+L3cM7EllkRiI3YSxEaAAAESXERqLS0luRZ32eWa6uqyXZ7oHvfY1T0x3dO/ZjzR7ZiOjvZ4Ytx2ONoeu1wVtktlqaySKEsUSYngThAECGLfQRBrJpDITCBX4M0P8FydvHhJ1SqJqvtFMIh8y13Pve+c7557rqbrOhQUFBQUFBQUFBQUFBQUFBQUPnswfdIFUFBQUFBQUFBQUFBQUFBQUFD4xUARPwoKCgoKCgoKCgoKCgoKCgqfUSjiR0FBQUFBQUFBQUFBQUFBQeEzCkX8KCgoKCgoKCgoKCgoKCgoKHxGoYgfBQUFBQUFBQUFBQUFBQUFhc8oFPGjoKCgoKCgoKCgoKCgoKCg8BnFz0T8aJr2vKZpo5qmTWia9u9/XoVSUFBQUFBQUFBQUFBQUFBQUPjZoem6/tO9qGlmAGMAngUwD+AWgK/quj708yuegoKCgoKCgoKCgoKCgoKCgsJPi5/F46cTwISu61O6rscB/B2AX/n5FEtBQUFBQUFBQUFBQUFBQUFB4WeF5Wd4txTAffZ7HsDRR72gaZquadrPkKWCws8Hshz+tJ5vPL2fJA3K/2fN9ycpT7prVA5+n7ePfO+nKQul89OWn37L5fpp0vp5lvPThp9WDo3AZcHob6P308mcUT5G19OlLedrVMdHyYimaeL+o8ojp/eT4lFt87Omka5f0/WJ0ViW85HH/0fl86j7Py/I/SjXQ87fZDLBbDZD0zQkEokfqy5G+f2kzxjl8ai2Tyd36fJ51PPp+taoTOnK96iypBtvmqZhZ2fnkXVQUFBQUFBQ+ETh03XdY3TjZyF+fixomvY7AH6Hflut1rRK2Y9jlHIFnu7z57hib5SexWLB9vZ2ivJC75tMJkOlhtIymUxpFcR01ynNRxnhjzKmjBQ8+b6RsZPOaJKvU9nSKb/U3nJ+RmXh9ZXLn65eRmnwa48yxuT2M5lM4rrZbMb29vYj66RpmuhTem5nZ0fco3oYySEZGrxvt7e397SX3DY8L26IpoNRevx5s9mc8mwymRTXeN/KdeLPUNl43alsdI2nZwTKh/eBxWJJkcWdnZ2UPuFlk9Pi6fD2MpvNe65tb2/vaSuehzxujQxJk8mU0kbyuKLfVC65vOkMKZlw4Nfl8hhdp/LIdfsoY1/ud6O5kv9P9adrvK+p3bksyPXn89yjxhyNG5IDeYwBqbIpyy5dozxlOaH7VB9Kn8sjz3NnZ0ekIbcNry/v90fNLXw88XrzNI3kno8R/hzPV/7mUV24fMvyStd4//L5mbcfLwuNKX7vo0gLo/pSHRKJRNpvGPBhn/N+5GVL931zOp1obGxEW1sbEokE/vEf/xFra2uG7UBpGs05NHfKbcjnNHkelOdzs9ksxoHJZEIymUz77bVYPlS9uNzKz5OMks4ij2VZhvmYMKqPyWSCxWJBPB4X12hcyOXkY4fPE1tbW1BQUFBQUFD41GI23Y2fhfh5AGAf+1328FoKdF3/cwB/DgAmk0lPp5iSQccNDlkBMkh7z2+urBkZQUaGyUcRJ49S1LmCbASj/GQjTK4jr4eRgswNXZ6PrKB+VP7pyiKX/1HP/bgEDj1rpHATuCJtJAPp8jXqX1J6jerBjXiu3PK00pXVyHgiQ0k2GOT8ZVKRG5ayIc/rLBuk8vNcFrkhILetUf3kMSEbF5QupWFk/Mjl5W3J/+ZGu2y8ULnlcsnpyv3O+1IuD+9bI9LEaIylkz9eDhny2DW6TnMcEQbpnjOqowyTyQSr1YpkMpl29T1dmkTg0N98zjUigQgymcvT52nyNHh/EkiW5Hlabj9ucMt1eNTYl9uNp/uTkhnp+tWoDwky0S/LHSfQ0s1xRmWTZV0un9we/L4s6/K3Uc6b52Ekj0bzCh+/Ru0iE7ZyekZkFN3npBCvj81mQ2FhIfbv34+DBw9icXFxzzxM6VE6Rt8xWRch+X/UWOTPGLWdnKaRHMlEqtF8zPstHUHD+5ePZ/kbJc9tdC2dDmM0NoyIbwUFBQUFBYXHAz8L8XMLwH5N06qwS/j8OoDf+KiX0hnFRjAyhvm9R103MgZkyKudctnkNGQFi+eXzmiX65HO0H8UASCXJ901I0XUKE2jsnKjwG63IycnB9vb2/D5fI80Lo3aSm7HH8d4/ig8ql/S1ctI8abf6ZR62VCT85GNNjldOQ+j/jKqW7p0jGDkEWHU5rxf6ZlHKe5GZTUy+uR2lfOiZ40MDf6+bMByr6OfpI34Kv5HyZpc3h+3LahO/J5c13RtJl83Gp/pxr2RoWqUj1G5jQxD+k1/ywa+TA4YGaBGbWLkDSZ7/xkZtnKa6TxQ0rUVlYvLtUxyymnydpCN/HRyJPcpvWvkbSaXR86Xk118jMh9TekQmSE/Y+S1alRm8gJxOBzIzs7Gzs4O/H5/CqErtzldIxLZyOuM55Xu+yXPsx81H/J0NM3Ymw/YnQOrq6vR1NSE6upqJJNJzM7OIh6Pp8xz/D2LxYJkMrlnvjLypklXPlmmjL659LfsxcRlSyYHuacOb38ZRvOBURl52jJpa7QwYPTt4GnJc7+CgoKCgoLC44efmvjRdT2padrvAngHgBnAX+q6PvhjvgsgVQE3UmJlZURWfGXlmV83MoSNFEKuiPH8fxLSRL6ezlhLB7mccrpGSpmRkWV0nxsPHLLySy7gmZmZKCoqQlVVFWKxGK5cuYJIJJKyPSId6fFRiqGs1HPjjf5/FIEmp5GuTSj9j9rGls5AN+qPdOWTnzEqIzeA5foYba8yWpHn7xqtnqdrA6OVe26QGJVbbgeeRrqVeTkdI+NZvic/Y5Reuvfk8tJ13ufpttbR39ygNboul4Eb0kbGEX833Zz0qDks3XwhG9y6rqd4+xgZcOm8CYzajjyRjOY9o3Lxe48iQo3a0cgji8sjvSOTmrKcyHXn/S1v7dO0XU8b2nrDDX65bY3qns74N7ou1zPdtyhdexp9n+RxyMmqdOlwmdI0TXjH1NbWYmtrCxsbG0gmk4ZbwNJ904zkM51ccXmXxwJvQ56PTEAZEXbUtvn5+ejs7ERdXR12dnZw79493L59G4lEQrxDdTObzcjKykJpaSn8fj/8fr94jiMd2cn/luVFHrvyXEBjhOYEee7mz8rfcEqbzyfca4n6TP5e8D41moflMSN/f+StkPx9Fd9HQUFBQUHh8cXPFONH1/WzAM7+uM+TEsaVlHRu7/S3bDxQOqSUGCmS9FtWeGSlRlbQDOqXNn5IOsNYfj+dMZWuzLKxI+ebziOC11Nuv3RGMzdQbDYbcnJycOjQIRw5cgRVVVXY3NzEwMAAYrHYHkOPG2fp2lv+WzYAjJRm/r+R0srbQa43f54UaVrhlfsnneG2s7OTEjfHyHBJZ8TR3zKZw8tuZFTRby7X/D7Fg5CJLN4f9I8MGpvNlnI/HSFB+aUrk9H4o3eN4u0AEAYlz4OX2agMXB55GxgZNLRdJh2ZxtOTtxvx/PmckE4Gjbay0d9yWgS+HZP3rVFf87QsFktKvbic83bZ2dlJket0BrlcD7pmtHWG9zPfjiXPN7wfeDwaozlULp+8PVBuF8pbngf5s7x9aIzTs9QmsjzL8svLmY68lK/zMm9vb+8ZF7LBL8eToXobzV3U77zucl68nXk/pKsjH08mkwl5eXloaGjA8ePHMT4+jrt37yIWixlur6Q2NiJeqDxmsxlmsxkWiwVWqxWxWCwlpow8r8h1p3IZzfWyzPJ5gBYnjh49iqamJmxsbOD27du4ceMGNjc398yHZrMZ2dnZOHr0KH7jN34D3d3dOHv2LJaWllLIUyPSRS6XPPfLOghdo3TSbbVKN8fRc/Kcw+c7I92Df4stFksKASpvJ5bnRSKSaE5IJBIpfWM0/ygoKCgoKCg8nviFB3fmkA05WXnlJIwcD4T/baRUyat1lIds8FFsDHqOEzuy4ZLOSJfrQ/XgShgvK3+ep5uOfCAYrVxT3bnXAU/DSNGjtOTyUBtarVY4nU688MILOHXqFEpKShAKhTA0NIRwOLwnGDZvV9mok+sn11tW7mUj3MhA5u/KdebGp1E7yW0qG+j0HPWh1WoV9/kJMVwhJwPIqG9ko8HIgDCCXGb+HvdM4HnL7UAGGRmMPG0yCrhRL48PDmoPInH49jLK3yhmCoEIND4mqM3587LBSXnye1Rn4NFBc7mhy8vHjfF0bS2TUUTeGJHLRoSLPM450Zaujfg1o/Lx/jMimahPZaKI11cen3KMME7EbG9vpxDzsnFOafD3KX9OzMjvy8HGdf3DgLKyt4KmabBarULOuIzTezyAufztkAkLXj+jft7e3k4Jdit7wBgFcacDCmhbEaXFZZXepWe3t7f3kHXcy4MTFrIcUX2pzunIBbnPqO2zs7Nx+PBhdHR0wGq1CtKHCAUuWwSaB6m/dX3Xy8xisYjxUVxcjJaWFtTX1+Ps2bMYGRkRbZwu0D2vL9WZ2kgeK0Z1czgcOHnyJE6fPo25uTlcunQJExMTiEQi4jmSS03TYLfbUVFRgd/7vd9DZWUlJicnRX7y3MLHnxG5wp+h6zabLeWbL/edPAelI7e2t7cN41/J/Ql8GMuN58Pbln/TCDw+EJ8XrFYrqqqqUFFRgWAwiJ6eHnHfKJag3J8KCgoKCgoKjw8+VuKHICuZRtdJ8SJDhCsi9CxgvNIJIMWA5Pdk5UpWTo0CsBopO7JSJZMjfNXOiLAwIkDoPVLmjAwV+j8dASKXjStv3HDgimVZWRm+9a1vob6+HouLi7h+/TpKS0sxMjIiDCKjk6J43eTyy+VI11YyqWK0oiiTL7Jiy401mVDi7SYbzvzUFZPJBKfTCY/Hg7q6OlRWVuLixYuYm5sTJ9JommYYNJrSk4NvymSbTFbICrt8TTbMZTmie/LqrCzXsqFIxiyVw2azIR6Pp5BHNFZkY0OWTQLPixtCskFLZZXjFPFxZ0TqEPj4pfToGq8XH8O8bDKhRn/LcpXO048TvFz2qU7y+JD7O918ZTTXcHJXJmCM5gYjYzBd2vw3J4u4RwefZ+i6PG8aeUtRf9I9GjNcVhOJhCAGZSOf2p/SoL7kssMJHk5YGc1L5AXHPXBkeZFPx+MeEHL7cRKN9zfvX5oLiDilvDl5wsmtdGNYJhA4Wc3Lyd+h/iKi7Pjx42htbcX29jbOnz+PkZGRlDbWNA0OhwN5eXmIRqNYX19PaT8qO88rIyMDhw4dwuc//3m43W7cv38fU1NTKTF2jAgTaiu5D9ORsFzeXC4XamtrcerUKVy/fh23b9/G6uoqotHonv7hMpFMJhEIBBAOhzE4OIhIJJLSTlwe5HbUNE3MjTJBRWnzZ3nZ+ZzJ601jSfYy4u3LZVj2HuNyYTabEY/HU7wF5TlEXozipLDb7ca3vvUt7N+/H/39/VheXsb8/PweGXzUN11BQUFBQUHh8cDHTvzIxqDs4cCVbFJOjYxV/gz9Ld+XFSuu8JDR4XA4kJGRAYfDgeXlZaGoy4SGkYEF7CqZj9pOxJVbXkajU8xkY1c24Hm6vD250Sanw5+XvWJsNhuKi4vx7W9/G01NTbh48SICgQC8Xi+SySTGx8dTys3bKyMjA3NzcyJd2UiX+4bKyo17ebXbyFDn6coeULwN5PbVNG2PMiwrsSaTSRhoWVlZqK+vxzPPPAOfz4fW1lYsLi4iHA5jdXU1JR3ZwJWJAJlo4Z42MvnAn+X9ZGS4U5m5McS9lfhx1UZGEPcI4uDGp9wPfCykc/Pn44z/5mNWToO8OuR3ZaJEHrvyqUjcoKF6cpmjcjzKAJL7k8rD+4TXS05DbnO577isy0albNgblV3ub9mbh8rE0093jZdFLg+1r1xuI/KY189onpQNd7k9ZRKMl1H2SqPnuaFuZNzyccblSr7G25gTSrw8RuPZqK052SvLBG9rInzk8UfPcHJKLiNPx2hOlecR4EOPnQMHDqCxsRGapmF0dBQDAwN7tpQ5nU4cO3YMv//7v4/p6Wn8p//0nxAIBBCPx1PKQPJhNptx5MgRHD58GIlEAt3d3ejr60uJryP3H0+HIHsn8jHCSUhN05CVlYXq6mqcOHECGxsbuHPnDnw+HyKRSFoPGEpL13UEg0H09vbi1q1bCIVCe/pXljNefupPTthQe8jfJXlO4PWSiTReRlk34HMM14Vo/HHiiI8v+g5o2odbH+Wxxr+P5GkUCATg8/mwtbUFXf/Qs46/S+NPQUFBQUFB4fHEJ+LxIyup9Les4HLF8VHeDHJ6ZHByEoDfp3w8Hg/q6+tx4MAB2O12XL58GXfv3k3JXy6zEQkjK49G9wl85VPOwwjy/XT5yASaXE5+jVzUCwsL8Wu/9ms4ceIEJiYmMD09jZycHGRnZ2Nubg4rKysppInNZkNJSQm6urowOzuLxcVFQ68qo7+NCDQjI0auM3/OyJCQDR+en9z//DoAYcSQl8+hQ4cQDofhcrkQCASwvr4uVpNlw47KIJNJRvXghpaszH9UWpx4kesg/5PbjrehEaFC/2SXfiO5l6/xNGXZo7+5JwnFA8nIyIDL5YLb7UY0GkU4HEYkEknZqpFODozkieojyxNdczgcKd5MsjzJ7UfXuZzwfuHvyOkZeb/w8sjEWbo06R6N02QyucdLLh0JalQHo/lPNkDpWSJQeDpGRLg8/8pGrlE/8XJRe/FyGJWZ9ws3so36R35eHh82mw1ZWVnIzc2F2+2G2WzGnTt3RPsaze1Gc4tscBvVjxvocltyspHGH29nmXjgefHfvN2N6p+RkYHOzk7k5eVhfHwcIyMjCIVCe+oHAPF4HJFIBM8++yzef/99XLhwIcUjktK3WCyoqKhAQ0MDbDYb+vr6cPXqVSwsLKSQclxeZNKK8pbJHble9B13Op2orq5GQ0MDotEoBgcHsbS0JIgm+V0+NpLJJJaXl/H9738fmqZhdXVVeHGl+85wcBmV+5mX1Sgto/T4HCy3E7UfEUry4o9MGsoLGvI8L9+Tr29vbyMajWJpaQmrq6sYHBwU8sE9NvncYKRXKCgoKCgoKDwe+MSIHyNF1eg5wHhrWDoj2uFwwOv1YnNzE2tra3tWukjhysvLQ0tLC9rb21FbW4tEIoHh4WEAxvFqONIpdEZGAFeYZIPlo0gfOT8jA042AIzeldvKYrHA4/Ggq6sLzzzzDPLz8/Hee+8hHo8jKysLADA4OChW/0iZLigoQHNzM44cOYLx8fEUpVc2uH7Sej2qLX4SZZPKQsGq6fQaUmK5YUCkD5F/mZmZmJ2dRW5uLnp6enD//n1EIhFD0oVDNr7S1ZOe5Qa+bODKBq2Rwi4bxkbGPYEbk/IqMj3PDTTZwJHzMbouG+xyG9lsNuTn56OoqAhFRUVwuVxwOp2IRCLY2tpCMBiEz+fD+vo6gsGgKJdsIKfzgjIqk9VqRXZ2Nurq6jA/P4/FxcU9hqIR8WNkEBrlaeSBYeQRZkROGKVHMkHPm81mZGZmYv/+/QiFQpifn8fm5maK4cg9DWXI/WzUTrJHJB/rVqsVmZmZyM7ORjgchs/n23Ps9aNImnRj2mgu431sNL64jMmekkZyKL9rMplgt9tRXV2NmpoalJaWIjs7G8FgEOPj49jY2Eg7Do1kmpM03BiW6yz/NvpbngPlMW9EmjwKRBBYLBZR32AwiMnJSTx48CBl2x3VY3t7G/fv38e7776LpqYmlJaW7vGwpbZ3u91oa2uD1+vFysoKent7MTMzsycemlH/yWOJ0jYKpk9bq8xmM0pLS1FTU4OcnBzcu3cPQ0NDiEQie7wficzgedI2rytXrsBisSAWi+3pX94eRjKYzgNTXqTi92XZ4SBSi+dHZaY6GMmHkRzInoZGJLicPvciTCaTGB4eRiQSwfT0NGKxmCiDEaEvfx8UFBQUFBQUHh98Ilu9uKt0OmXQyOiVFTOuxNBpHyUlJWhvb8f4+Dju3LkjFD3+fGZmJlpbW3HmzBns27cPOzs7wjiUtx/wvKmM/H9edll5N1KceFl42umIE9mwNjJs+P/pDGL6Z7FYkJOTg+bmZnzxi1+E2+3GysoK5ufn4Xa74XK5sLS0hLt376b0gcPhQF1dHY4dOwYAGB0dFYYnf04mu+RyfBRBZeTJwNvnUQo65cGPLh4aGkIgEBABUnl5XS4XmpubcfDgQVitVoyPj8Nms2FlZQWXLl1CMBjcs0VLJiN428onoqSTXSBVYedbbDgBIHsA0DXe37LxbmSEp/udrp1lwzPdlgVOFvG6kjFJJ/54PB40Njbi0KFD8Hg8wrsgmUzC6XQiHo9jeXkZi4uLGB0dxerqKuLxOJLJZAq5YbRlgf9P5bNYLMjNzUV9fT2ef/55XL16FYFAAIlEIiU+C28XI8ON/280/uQ+5h4MVB55LuB58j7k8kDHT9fU1ODll1/G+Pg4wuGwiLfFx8qj+vhRnjRGQZx5/JnMzEw0NzejsbERk5OTePfdd/e0jVEfyDIkl4nKKRvG6QghXkciI2QjXCaE5HFitVpRWlqKZ599Fi0tLcjPz0c4HEZvb684/Y6Xh9KViTxKj8ePkWWPl01eQJCJCZIJqhfFPeLv8ODS8hZHo61yFFA6Ozsbx44dg8ViQV9fHyYmJhAOh/d4zlLMmfn5efzoRz9CQ0MDlpaWBPnAPV7sdjsOHDiA9vZ2hMNhjI+PY3p6eg8pxucuHmuLk2V071HfWLPZjLy8PDQ2NsLj8WB1dRXDw8PY2NgQ7cu3bnNZkr8TnPSl7VAAxMleVqtVEEVG20GNZNgIfP6W5wr+N+8/6gsjUoXPH5yAMorDJssLeWzx+YW8L7e3t0XMot7eXsTjcbHQYyTX6caygoKCgoKCwuODT8Tj51EuykbEihxHhV8HdmMUFBcX49ChQzh+/DhKSkoQi8Vw7949EaeAFCKr1Ypjx47h61//OjIyMrCzs4O5uTm89957GB8fT7utQY4bwBV3XiYyosgITEeAGNVfhvycDFIg+W/+LFfu6ZrFYsHhw4fx+c9/Hg0NDeju7sbMzAwGBgbQ2tqKeDyOqakprK2tifTNZjPq6urQ3t6O7OxsvPHGG0JJpHalfuWKuLytjdrHqB5076PIFa6Qy7FpNO1Db6bTp08jIyMDU1NTe4gLIodaWlpw+vRphEIhjI+PY3V1FQ6HA9euXcPW1taecsjxZWS5lY1Hoy0h8qosGSm8/9ORW3L6Rm3C21M2po28FDhJw/uP+pM/w/tSNopk2aO8vF4vTp8+jQMHDiCRSODmzZvw+/3C88Dj8aCoqAgVFRU4cuQIurq68M4772BsbAwbGxt7yDIuX0Bq7BTKNz8/H01NTXjuuedQWFiIwsJC2Gy2lPbl/WI0Bikf2eij45K57PH68/HA+4Dy3dn5MOYSxdGgdMggdbvdqK+vx1e/+lVkZWVheHg4hWTl6VIacp9wIzGdPPGyUxrUnm63Gy0tLfjCF76A6elpfPDBByltYrS1S56/KV8ysnlbkLHN5YzIAKvVuieoMrUtxR1J13/8HYvFAqfTiX379uGrX/0qjh8/ju3tbWxsbGBychJXrlyB3+83nKf53Ef5cfnjhjRdl+dCeX6idHjMLS4XnECVY9BwcoDe421E85PZbIbT6UR9fT2am5vR19eH4eFh+P1+w28Il5319XX8wR/8AeLxeAqhAAAOhwNFRUV44YUXAABXr14Vp4NR3pws4uOJ6mZEVBF5wetHYzk7OxvPPvssiouLMTk5iVu3bmFzczPlyHJqP0qfnzJnBE3bPekrPz8fNpsNa2triMVi8Hg82NnZwebmpjianuYoOrlL7guaN2kMUz9QPeh9WY6p/JxU48HE+fzOQeQbjQEqA28H3va8bLJs0jvJZBJra2siDx4ni8gweSuigoKCgoKCwuOJj534IcVCNkq5YiUrSvKKF1eYS0pK8NJLL6GpqQklJSXIyMjA0NAQPvjgA2xtbYl8dX3Xa+X48eP4l//yXwpFdW5uDleuXEFPT0+KEiwbKTwdrphxw4buk7Ikr+ilu8chtwtf/ZTzN3pHdpsnBXB7exs2mw2dnZ348pe/jMOHD6Ovrw//7b/9N6ysrOD48eMoKirC+Pg4bty4IRR6TdOQm5uLF154AUVFRbhx4wauXLmSslotExjceCFjhAwCfqoXN+h4PWQQ4SKf2sRlh46kr6mpweHDh1FUVIRz585hdXU1pd3JMKqursY3vvENxGIxJBIJWK1WTE1NYXV1NcUIkQlA3tdGirm8Ei97fcgGAj3DSTzuuUL15co6P41HXlnnciCXnVazZQ8dq9W6x0jl9eGxPmS543LN24SMwdLSUjgcDvT19eHGjRvY3NzE5z73Obz44ou4ePEirl69igsXLiAnJweHDh3CF7/4Rfz2b/827t27h4sXL2JwcFCcWkPGKJ8rrFariNHicDhQVVWFp556CidOnIDJZML09DTee+89BAKBlLaWSRS53GRU8fmGt50RgUfPyMYsN3xljxDehxaLBU1NTTh69Cja2tqQk5ODmzdv4sKFCwiHw3uMRd4GJHckQ1xOjSCPJxpDVOZwOIxAIICNjQ0sLS2ltJ1Rm3HPL05ayAQ4nws5iULPUhl4Wai8ZBTzcvCTwWgesVgssNlsqKiowDPPPIOnn34ai4uLWFlZAQD09vbi/fffx/DwMHZ2dmC32xGLxVKCDMtkLL9uBE4G6LouSC15vNCz8nzJ50GSE7rG5Yd/NzhxR2VzOp0oLy/HSy+9BJ/Ph/Pnz2N5eVnMvfz7IxPG8XgcsVhMlJ3PA263G1/+8pehaRp++MMfYmJiAsFgMGWuk+VJ13XY7faUuY3f4zLM62U2m+FyufD1r38dBQUFuHbtGsbHxxGPx5GbmwuXy4XMzExkZWUhJycHWVlZcDqdiEajeP/997GwsLCnn6juDocDR48eRUdHB7KysjA/Pw+bzYbq6mqYTCbMzc1hdHQUU1NTWFlZEbHHZE8gi8WCRCJhGIicy61MRHGZ4gQmpWG1WvfIGc0NJF8kI5yIkuclmv85AcW/L9QevP+JrKTr/IQ/I71IQUFBQUFB4fHCx078kMs1wWi1VgatQpPyQ1s5nn76aeHhk5mZCYfDgbW1Nbz66qvC0CPFxu12o7m5Gb/5m78Jl8uFnZ0dXLp0Cd3d3RgbG0vZRsHLxRVumcCh9An8nrw6+OMQPZQfJ4Zk4iAdOcbLLYOU/oaGBnzlK1+B1+vFuXPn8N3vfhdLS0soKyvD4cOHsbCwgOHhYfh8PpFWZmYmvvzlL6OkpASDg4N4//33EYlEhOFodJQ2rUiS0s+NNN4mvOx0j5RUrgzLx+KSgci9P3JyctDe3o7GxkbY7XbcvHkTExMTKcYLGZTZ2dn4+te/jtzcXOzs7IhtNNFoVNRHJlK4UUvGGDfQuAwY/f0oTxAqn0zIUDn4M5SW7N0jG4E8Ddno5oYJ9RdvT15nThjRNX7qDPfsko1Xs9mMkZERcczzzs4Oamtr0dnZKbZVUvqrq6u4fPkyotEonnvuOVRXVyMUCiEWi2F4eDiFPOCkFvfK8Hg8OHbsGOrr62G1WuH3+/Hmm29idXVVlI+PS7rG/+ZjRiYo6DqRJJyI4cYRN7JlgoK8BHj/Ut+3tbXhueeeQ11dHXRdx9DQEF577TWEQiFx+o5MPMvbLfl8Qf3L+47PJbxe/Ohri8UijOtkMomxsTFBrnEY9TuXD9mbibcxH8s0T1AdySOC8jCa69LNH5qmwePxoKOjA11dXWhoaEAsFsPExAQqKipw6dIl9Pf3Y2lpScz59E3inpF8Dufjx4gETEeyykQ4N6b5eOVjNl05OFHC8+IebxaLBVVVVXj22Wfh9Xrx13/911hdXRVzqkz4yN83ThpQeS0WC0pLS/HCCy9g//79ePPNNzE9PY2tra0UUt/tdovtm3xLJfWnUXwoqh+lQ/Nzfn4+vvzlL+P48eOYnp5GTU0NGhsbUVhYCJNp9wS0zMxMaJom4viRrNJWUS6jlFd2djZefvllNDQ0IBwOY2VlBW63G5WVlZiZmUF+fj5qa2tRV1eHWCwmYpBtbGxgY2MD0WhUlJHGZ19fX8pY4PO6UYBvHsxaJoH5d4XaXyZS+XeW0uFjmZPWBJpvrFYrbDYbNE1DMBgU/W2xWGC32+FwOIS3XSwWQzgcFv1G/3OiT0FBQUFBQeHxwsdO/MjGr0z4pFsZM5vN4vjxpqYmNDU1oa6uDjs7u1u18vLysLOzgzt37ojAw2RsOZ1O1NXV4ZVXXkFxcTEWFxdx+fJlXL16FdPT0ynHu3IYrU7yMtLfRitvnKiR68uNH6N0eP3lPLm3k0xSyW1J7Wa329Hc3Iyvfe1rqK2txejoKG7cuIGVlRVomobDhw/DYrFgdHQUMzMzwiCy2+0oLy9HU1MTAoEAJicnU7YMkDKZm5uLsrIyeL1eRKNR9PT0CI8h3gbUjtxYJ5CxZ7PZxFYDue5y25GSW1xcjCeffBIHDhxAKBRCT08PBgcHhaLOPQHy8vLw7LPPorKyEhaLBXNzc+jr68PAwIA4wcuo33j5ubHHjWdO3nBiggxBXn6utMtkIO9fbiDIRiL3/OHl4zIkG4rccCbIz8teLrw8ZMw9ioCk9JLJpPBUsVqt8Hq9aGtrQzgcxrlz57C4uIi1tTWRXiQSwZ07dxCNRvHMM8+grKxMyCs3OIw8H1wuF5555hm0tbXB7XZjfn4e58+fx9jYWMopPkbjkbcB73+ZpOAkCTe4ZJkx8gqRY0VxrxKTyYSjR4/i+eefR2VlJba3tzE2NoY33nhDBKWWCTvqDyLs5LmLb4nicwWNP15no3ltZ2cH0WgUgUBAeIzI8yCXNVmmeDsYeT7SbxojvC1JxuQy8jmVk1h8/mtoaMCTTz6JqqoqbG9v4/z58zCZTFhcXMTAwABGR0fh8/kEESmTo1ymZK8LWYZkEoW3tRGJy8lAmdA1IpEBiJg9+/btQ15eHubn57G6uopoNApd10WaOzs7yMvLQ0NDA1paWuD3+7GwsIDS0lK4XK6UrUTr6+tYWFhIKR8vL80rFCutqakJjY2N8Pv98Pv9KC0thcfjgdlsRjQaFYHbA4EAenp6sLCwkOJty73QuBzH4/E94yA/Px9dXV04ceIEcnJyUFpaCpvNJgjCtbU1jI6OYnNzE9vb21hfX0dBQQEaGxthtVpFoG6+gEBbF5966ins378fU1NTGBkZga7rOHToELa2tnDu3DnYbDbs27cPRUVFKC4uRnl5ufA0i0ajKVu6Njc3MTU1tYc45gSvLPf8vtG8z+d7PtfzY9dl0ofeo/7lnrBEBhYXF4uYZ4WFhfD5fHj99ddhs9lw+PBhFBQUIDMzUwTdTyaT2NrawtTUFAYGBuD3+1O+AwoKCgoKCgqPJz6R4M4y+cPBFSngw6PHKyoqUFlZiQMHDqC2thYulwvT09OYmZnBvn37YLfb4fP5cPv2bXEkqd1uR1FREfbv34+Ojg7U1tZiYmICH3zwAe7cuYO5uTmhQD6qvFQu2cjlyjKtlsViMcTj8UeSWfR+utVsOT+j9+VnZFB6FosFXq8Xv/Irv4L6+npsbm5icHAQIyMj2NnZQUFBgSBMlpaWEA6HRZp2ux3Hjh1DVlYWenp6MDk5KWImUf0rKyvR1NSE2tpaeDweALvHCPv9fmxubiIQCAiPGjoxhE5roWO9PR4PMjMzsbGxgaysLBHod21tLaVduOxYLBZkZWWhtrYWra2taGpqQjgcFkp9IBAQBBMp2/n5+WhubkZXVxe2t7dx9+5dDAwM4N69e1heXhZ1A/aeNEPgq68kn/QvPz8fZWVlAIDl5WVhXPH2kmWb9yfvu3TEDy8DXeOGhWyApkuf14m/K29d4ASPkUxyI1fuK27g5uTkoKqqCm63G729vRgdHUUkEhHeAdygmp6exubmJrxeL3JyclK2Lciyr2m78Zra29vR3t6OvLw8LC4uoqenB/39/XsC2speGHIbGJE39A6PdSGvfHPSIp1xJPc9J7NPnjyJ2tpamEwmTExM4Pbt25icnBQEqtyfXHa4ochlQs6b5EY2Onndqa7BYBD9/f0IBAIYGxtLkT2jehnFPOLv8DYhA1gmrOR50aiv5H6itqRtfqdPn0ZZWRlWVlYwPj6O8fFxWCwWxONxrK2tYWNjY09sHNmDkPqG36Pn+bxAW32ItKK25X1t9K2TCSsuT9RuZrMZ2dnZOHDgACoqKlBSUgK73Y7x8XEMDAxgcnIypQ1sNhvq6urQ0tICr9eLeDyOM2fOwG63p2wFNJlMCAaDePfdd7GysrLnGHvqmyNHjsDr9aKkpARVVVUoKCjAzs4Ojh8/Lrwm6Thwt9st5vyBgYGU+hJhY7PZkJeXJ7Zq0bHs0WhUzM9ZWVnYv38/Tp48CbfbjdnZWYyMjKR4Z4VCISwsLCAYDIotWvT9v3fvHgKBQAqZRIc5HD58GAcOHMDs7Czu3r0Lv9+P4uJiZGVlYW5uDnNzc9B1HSsrK8jOzhZkltVqFf1P8cisViuWlpawvLyc0mb0Nyf/eFtwmebegvz7wINh8zYkmeBjTJYvKgdte87Ly8O+ffvg9XpRWVmJxsZGuN1ujI+P48KFC2htbUVbW5voR5IR2kKXk5ODeDyO4eFhrKys7CEsFRQUFBQUFB4vfCLBnWUjUQYpN7Slq6ioCEeOHMHBgwfh8XgQi8UwPj6Oy5cvIxaLobKyUhiM09PTMJlMyMzMxL59+1BfX4+2tjZUVFRgfX0d58+fx/nz58Ux37IRlI7o4de4caBpGpxOJyorK+FyubC4uIilpSWxIisbiUZGumwAGBnsXBnk5eBpyOnb7XYUFBSgvb0dJ0+eRCQSwcDAAAYHB7G8vAyr1YqSkhLk5eVhdHRUbCmhsuTl5aGjowMbGxuYmJjA0tKSyNdsNsPr9aKjowOHDh1CYWEhHA6H+H95eVl4C/h8PoRCIQSDQWxtbSEajYo2279/P4qLixGPx3Hv3j1kZWUhHo+nbDej8lCbu1wu5OXloaamBl1dXWhsbEQgEMD4+DiGhobg9/sBQBhttJpZU1ODY8eOobi4GD09Pbh69SrGxsYQDAYFWcdXZXkaNpsNsVhMHKnNV2PJeG9ubsb+/fuhaRr6+/vh9/vFscOyNxClzdOXjXKr1Sq2OHK3/Gg0usfzihvu9D+PWUIGtdE45CQClyeZ7DEas9yI57LJDRwaixUVFVhdXUVvby/C4XCK3FI5c3Jy4PV6YbfbEQqFsLGxkWKIy4SG2WxGUVERnnzySXHEdH9/P3p6erC+vp5i2PJ6ciNdbhdqa76Ni55LR7TyNk1HrPDAqdS/eXl56OrqQlNTE6xWK+bm5gQZSUQp7xeeJk9b9pDhRNFHQU5f0zRsbm5iaGgIY2NjIs4J1c9o3uF1p78fRVgDqbFs5DbkBrRcVk4amUy7Hp1VVVXo6upCeXk5ZmZm0NfXh8nJSRGHhhNKnGDSNC3FyOXBraPRKFwuF1wul3iPb/GLxWLY2toSJyKRvPI25XWl/OVg10ZtyUkQj8cjZOfAgQMIBoOYm5sT2/wors+RI0dQX18Pm80Gt9uNI0eOIBQKiS1LZrNZeHcMDAxgfX3dcPHBZrPh6NGjqKurg8fjgcPhQDweR3Z2NpqamhCNRrG5uYlIJIKMjAwUFhZC13Xcv38fm5ubYqsjtaPH40FGRgZKSkpEHL7V1VWxkEAE6L59+9Da2oqamhrMzMygu7sbd+7cEQGY+XaxZDKJ/fv3o7OzE2VlZZienkZfXx82NzcBfOhdREGp29rakEwm0dPTg8XFReTl5aGiogJ5eXm4ePGi6PvNzU0RI4i+7fS9aW5uhsPhwPb2Nm7fvo3FxUUx1uT+ozhJnMCRt1bK8448v8rzlJEewslsInvy8vLgdrvh9XpRVlYGXddRX1+Puro6bG9vY3x8HA6HA01NTSgtLcXg4CDm5ubE9vjc3Fzk5OSguroalZWVWF1dTfH6UVBQUFBQUHg88Yls9eJGJf9NCpTFYkFGRgY8Hg+OHDmC1tZW4bo/Pj6OK1euYGhoCJFIBJ///Ofh9XoxPDyMgYEB7OzswOv1oqmpSbj8OxwO3L9/H++++y4uXLggYhFwsoUbZ+Q+n0gkUrxAjIywzMxM1NXV4eWXX4bdbsfly5dx8+ZNLC0tCXdzYO8qPFfwuGHOjW2+4s2flw1L7nEBfOjiXVhYiI6ODvyzf/bPYLVaMTk5iXPnzmFkZEQEwy0tLUU0GsX4+LgwkmjrDB2//dZbb2F5eTklPoHL5cKTTz6Jo0ePIhaLYWpqCmazGYWFhaiurkZ2djai0SiampqQSCQQCoWwubmJ2dlZTE1NoaCgACdOnEBdXR3W19fx7rvv4vr169jc3EyJEUEgciQnJwc1NTVoa2vDkSNHUFhYiFgshvPnz+PWrVtYWFgQ9bdarcjJyUFdXR0KCwtRV1eHxsZGLC0t4e/+7u+wurqashJObUzv67qOrKwsFBYWoqCgADMzM2JlmN5xOBzwer344he/iK6uLlHeWCwmjsnlxIWsxJtMJhQVFcHr9SKRSCCRSAhyp6CgAC6XCxkZGbDZbLDb7cjKysLS0hLee+89hMPhFHk02h7DySxOOsgEpFFwZ24w83u8HvLzJH+Un8vlQlVVFfbv3w+n04kLFy6IE+M46URxJg4ePIhTp04hNzcXV69eRU9PT0o8FQ4yLLu6utDS0oLl5WVcuXIFvb29IiAxGdrcC0kmE+VVbCOCgt/jBJ48N8jp8H6WyQyn04nGxka8+OKLcLvdmJmZwaVLl9DT0yOCjPMtTdQX/NQdXv50RB4nSdJ5PHEDld5NJpPC44h7olD68vY2TvZQ+fj2FN4O8jYfuV58zpNlmP7W9d1gveXl5fjc5z6H4uJidHd349atWyL2i9x/vA+JRG5tbcWBAwcEQeJyuXDw4EFEo1FkZWWJ0x9pC5TZbBYeKMFgEIFAAEtLSxgfH8ft27fTEoQ0jnjMGy5D3EOGSJ+amhq8/fbbIh7NgQMHkJ2dDafTiVAoBE3TUFZWhldeeQVHjx5FTk4O1tfXsb6+jhs3bmBmZgYrKytIJBKCvOjq6kqJq2M0FjMzM5GZmSnquLa2Bp/Ph4WFBczPz4sj38vLy/Hyyy9je3sbV65cQTgcFvGhPB4PWlpa0NDQgHg8DqfTiaysLCSTSRGwneqemZmJlpYWtLW1IRQK4dVXX8Xt27dF/CW+FdBqtcLj8eCLX/wiWltbMTg4iLNnz4q5meSMiOSamhoUFxfjnXfewdzcHMzm3VMq6+rqEIlEMDIyIhaBKA++1Xh7exudnZ3Yv38/dF3H6OgohoeHRT6P+n7Q/EMk/tbWltgGJ88zPB4SJ5NIbmTCnf7Z7Xa4XC6UlJSgpaUFlZWVyMrKQiKRwNDQENbX11FeXo5wOIwHDx6gu7sbkUgEDx48gKZp6O7uxvT0NCKRiCh/VlYWnn76aeTn5yMrK0ucEPZRQeMVFBQUFBQUPr34RLZ6EbhhQoqR3W4XwYbPnDmD8vJyBINBfPDBB+jp6cHMzIxY1Wtvb8cLL7yA4eFhDA0NQdM0vPTSSzh+/DjKysrg8/kQi8UwMzODGzdu4OLFi8Jjg5QrUnptNpvwCikrK4PNZsPU1BT6+/uFkcKNdrPZjLy8PDzxxBN4+eWXoWkaRkdHsbS0hFAoJBRPAuUlx8qgtIBUZZPHEaH3+btym3IjU9M0lJaW4vjx43juuefg9XoRi8XQ09OD+fl5sfrr9XrR1dWF5eVlzM3NiSPM7XY7SkpK8Morr+DBgwe4cuUKFhYWkEwmhVJ4+vRpnDlzBjMzM7hw4QJmZ2dRUVGBpqYmTExM4I033kAymURZWRlKS0tRWFiI5uZmPPfcc4IQm5qawltvvYUrV67g/v37KeSD7AlCHkjPP/882tvbUVRUJO5NTU3h2rVrWFxcFMagx+PByZMnUVdXJ7ZfmUwmbG1t4ebNmylxS3jMGlLa6+rqxDbBsrIyRCIR/M3f/E0K6WGxWEQ7Pfnkk7h8+TIyMjIQj8eFJxEZyvyYXu69lJubi29+85vwer2iLOT943Q6xTWK2WKz2bCwsIArV64IRZ0ThdRHVD5u9MoEK6UNpJKJsnxxgoSMHH6MOI+nwdvTarWirq4OnZ2dAID+/n7cv39fGHOUD23JPHLkCJ577jnEYjG8/fbb6OvrSzHgZZLY7Xbj5MmT+Na3voWxsTH8/d//PQYHB7GxsZFC5nAvFLl+nNyicccJBj52jU794zE7eEBf3sYkV3SfCIfa2lp86UtfQmFhIZaWlvDuu++it7dXEJL0/s7OjtgqYzKZ4Pf7UwxiKiMnfqm9OHnF+4+T3Zyw4f3HjVkiOSldqh/f1spJJtnDQSY9eZvzOZCnxT3WgA+DE9MWzqysLDQ0NOD06dMoLCzEW2+9hZs3b6YY8bI3C5WHYk6dOXMGJ0+exOLiIpLJJNxuNwoLC5GTkwOr1YpAIICtrS2Ew2ERH2d1dVXEC8vPz0d+fj7Ky8uxb98+zM/PC08QInl0XUcsFoPdbhdyJxN0wIdBpr1eLxobG1FbW4v5+Xm8//77gih58OCBiDkD7BIm3/zmN9Ha2gqTyYSenh688cYbmJmZER4cNCcEg0HY7XY0NTVhY2Mj5SQzal+r1YqioiJUV1cjEAjg4sWL6OvrQygUSomN5HA4cOjQIXR0dCA7OxuvvfYa/H6/8F4rLy+Hy+VCIpHAgwcPcO/ePRQVFaGlpQWxWAzXrl0TxLXdbkdXVxfa29thsVhw/fp13LlzR8S1kU9bM5vN+Hf/7t/h0KFDuHr1Kt577z1MTU0J4pz612q1orKyEk888QSsVisGBweh6zpKS0tRXV0Ns9mMq1evCu9S6gs+toHd+amjowMFBQXo7e0VOgEF1d7e3kZWVhays7PFKWNEElqtVpSXl6O2thbZ2dm4fPkyvv/97+8Zn0S4kFzwQxNo7uBEIc3BDocDlZWVIqi9yWSCz+fD0NAQJicnMT4+js997nM4cuSI+PZdunQJoVAIr732GqxWKyKRSErQ8Z2dHSHvLpcLdrs9xdtKQUFBQUFB4fHEJxrcmX7bbDZ4vV6cPHkSnZ2dKC8vh8PhQCgUwve//310d3eLGCyk9BcXF+Nf/+t/DbfbjampKTz55JMoLi6Gx+PBxsYGzp07h+XlZXR0dGB1dRULCwvCm4KUNqvVCrfbjfLycrS2tqKlpQVZWVkAdpXgmzdvYnV1FTMzM3sMw6KiInR0dODll1+Gw+HAnTt38E//9E8YHx8XK7GcqOFKG62akYHFPYPoWSMjyYg0I0ONp1teXo7Tp0+jtLQUt27dwvr6OlZWVvD666+L4JdOpxM5OTkoKCgQ8SKsViscDgcqKirwyiuvoKCgQCj0ZLTm5uaio6MDv/qrv4ru7m4RKwIA/H4/BgcHcfnyZdy7dw/b29sYGRkRpwRVV1fjm9/8Jqqrq7GxsYHu7m68/fbb2NjYEG3DDVlShktKStDY2IgzZ84gkUjgxo0bWFtbw7Fjx1BaWorJyUm0tLSIQJXl5eXIz8+HxWLB6uoqzp49C5fLhYqKCtFXRiSAy+VCc3Mzjh8/jqysLLHa7/P5cOHCBbGiTG78Xq8X7e3tOHLkCN5++21sbW1B13VBUBJIZoFdgyQrK0uszra3tyMzMxP9/f3C4KeYHHTMNAVQraioQEFBAS5duoRgMJgiA7LHiRyrh4wFOT4QyRI/Op4b/eQZJ3sncGJE9uigcdLc3IyOjg4EAgEMDw9jdHRUGKHkcUZeCKdOnYLL5cKFCxdw+fJl+P1+4VVBRBjlQ1tbjh07hueffx5jY2P4z//5P4vTfPipUgDEuJfnHk400mk3nBQuLCzE008/DZPJhLGxMfT29iIWi6XMBbz9+THYdrsdOTk5yMzMRCwWS/FEy87ORnNzs/BIXFlZwV/8xV9gcHBQENO8XYuKinD69Gk0NDQgmUzi5s2beP/991PiIxEBRcamw+FAXV0dkskk1tbWsLy8LGSGH9NMfSunwz2NOBFktVpht9sFqRgKhVKOteZzE8mYTHJw4omTrpxQ5PMh9R2PzUPxxzo7O5GZmYkf/vCHuHXrliBY5bkykUiII+Lz8vLQ2tqKZ599Fpqm4c0338T169eRkZGB48eP4/jx43jw4AGys7PxJ3/yJ+LbQyebkdxQrJvOzk5UV1djbW1NkL1EotAcS/OSx+OBruv40Y9+hNnZ2ZSjtvliAHk48gWHRCKB0dFR8YzT6UR7eztqa2uhaRp6enrw3nvvoa+vT7QDtXNxcTE6Oztx8uRJLC8vC+Jb9g7LycnBN77xDTidTly6dEmQ8rwcRK5T/B8i+L/0pS8hJycHGxsbmJubw40bN3D37l1MTEygpKQEp06dQlZWFoaGhnDv3j0xp1RXV+PIkSNwuVy4c+cOfvjDH2Jzc1PIB/U7jdOsrCwcOHAAH3zwAV5//XWMjIykBHCneSsjIwP5+fkoKSnB+vo6IpEIvF4vXnrpJVGOmzdvppzoyRdnSCZdLheys7ORm5uLkpISNDU1ob6+XszH+fn5yMjIELHrNE3D3NwcIpEI7HY7cnNzUVFRgbKyMlRWVuL1118X86A83xJBy+dXPmfzLa8FBQU4c+YMTpw4gfv376O3txdDQ0NYXFwUJ29WV1fjd3/3d2EymfC9730Pb7/9tojjR/lwkpTmAPLAWllZEdsX5QUBBQUFBQUFhccLn4jHDxkd5JnR1dWFzs5O4cUxNzeHoaEh3L59G7Ozs9ja2hLGqd1uR35+Pl588UWUl5cjkUjg2LFjiMfjuH//Pn74wx/izp07WF9fR1tbGwAI13JSHIuKilBXV4fm5mYUFRUhKysLLpcLwWAQg4ODqKurw8LCAmZmZrCxsSGMHFrhKy4uxokTJ/Dss8+KFcp/+qd/wsLCQsrJUECqsiSvdPP73CiV/5a9eSh9UtL4SmFeXh5eeukl5OXlIRqNChLh1VdfFZ5Suq7DZrPB4/HA6XQKQy8zMxNNTU3o6urC/v378aMf/Qi3bt0S75FhcOLECWForK+vw2TaDfLc0dEBh8OB/v5+oVRS21NcpqGhIVRWVsLn88Hv96fEMaGVTiIbnE4niouL8fLLL8Pj8aCvrw9TU1PQdR0HDx5EXV0dVldX0djYKFzkk8kkNjY2cO3aNSwtLWFtbQ3r6+tob2+H1+tFJBKBz+cT5AAZb1VVVejs7ERNTQ1u3bqF8fFxHD16FKFQCH19fcJQof6y2WyoqalBe3s7srKyUFFRgaGhIdy4cUNsg+Ar1OXl5SgrK0NZWZnYOrZv3z44HA7cvn0b3d3dKdsDyXi0WCzipJvs7Gz4fD6MjY0Jo5DaKTMzEw6HA06nU8RY8vv9CAaDoo1l7weSBU4E0d+ypxm9x40rbrRw8slut6OmpgYnTpyAz+cTMSTI2DGZTKiursYTTzwhgsZOTEygr68Ps7OzCIVCKacuEWFis9lQWlqKjo4OHDx4EEVFRfD5fPibv/kbBAKBlMConGygrSsej0cEIO/t7U2pE+8vh8OBtrY2/NZv/RZaW1thNpvxwQcfYH19HRMTE0IOuBcfzU9msxmNjY1obW1FWVkZ7HY7VldX8Zd/+ZcirlFjYyNOnTqF+vp6+P1+/NVf/RUGBwcFccg9jXJzc/GlL30J9fX12N7eFiv53KuK+ozIzaeffhq5ubmi7pFIBKOjo3jrrbfEPEhELhnH+fn5GBkZEQY371uHw4Hc3FxUVVWhoqICXq8XTqcT6+vrOHfunBiTJENUdjmGGp/XZJmhf/QO92Di7U39WllZidraWtjtdgwNDWFoaGiP1xp/n58A2NHRgfr6euE5NzExIbx6rly5gpmZGRQUFOCVV15BZmYmpqenxQmBnEyJxWKoqanBwYMHYTKZMDk5CYvFgv379+PAgQOoqqqC1+tFYWEhvF6viDdmMpmER04gENizSEDbYqkesscZjYecnBy0tbVhZ2cHg4ODuHTpEgYGBoQsx2IxAEBFRQVefPFFHDt2DJFIRJDUfHuepmnIyMjAsWPHxLZqOkGMe/QR8QDskm9utxtOpxOtra24desWZmdnMTc3h5WVFYRCIbFV8NSpU6isrMSDBw8wOTmZIhtFRUWwWCyYnJzEnTt3hCcQgW+bIrLxz/7szzA5OYm5uTlRT5prqazb29vihEin04m2tjY88cQTyMzMxKVLl3Dt2jVBtMrfZE6qB4NBrK+vo7S0FG1tbTh48KDw6JmZmUE4HBbb31ZWVpBMJnH//n1sbW3B4XAgIyMDTzzxBH7t135NfHO4Bw/Pk3s3Ubnob07mUz/4/X50d3cL70hqb2qDzs5O5OTk4Dvf+Q6uX78uvtckSyRzeXl5cDgcSCQSyMzMxHPPPQer1Ypbt26JWEz8pEAFBQUFBQWFxw8fO/FDxgwp7vv27UN1dTUyMjIwOjqKiYkJzM7OYmFhAT6fTwQWtVgsOHjwIBoaGlBbW4uOjg64XC48ePAAg4ODmJqawtTUFCYnJ7G8vIxkMilOdioqKkJra6sILun1epGRkQGHw4FwOIzR0VGsrKxgfn4e+fn5OHDgAObm5nD//n2h8DudTpSWlqK+vl4cJ5+Xl4dLly7h/PnzgvSRPXVkoofuceVLNoy4ss8Vc2BvsGP+bkZGBj73uc+hpaUFFotFuOdfuHABy8vLKR4C8XhcGMs1NTU4evQo8vPzUVtbi9zcXAwMDODKlSsIhUIpCqLL5UJRURGSySSCwaA4TaelpQX79u1DX1+fMHCpXPS+xWJBVVUVIpGIIPV4G/BtI3RMfFVVFXw+H0ZGRjA3N4eNjQ3U1taivLwckUgE/f39KC8vx9TUFAKBADY3N7GxsSFOKKPtUBSfgLxMAMDtdqO+vh6VlZXweDwwmUy4fPkyBgYG0NzcDLvdjoWFBYyPjyMSiQhvBGqH4uJi7Nu3DzabTZyWtrGxAafTCY/Hg/z8fOTl5cFut6O4uBihUAjhcBgWiwVFRUVwu91YXV3F1atXMT8/n3KiGvWrxWJBc3MzKioq4Ha7EQgE0NzcjIyMDLjdbrGlwWazibhOtD2yv78f3d3d6Onp2UPWcMOKDAk5/hAngui3kWzTVgRd12G327Fv3z4cOXIEmvbh9kcK4kpeVS0tLbDb7ZiamsKDBw+wurqKpaUlbG1tpcTfIo8P8jQrKyvDwYMHsW/fPsRiMXR3d2NqakqQW1Q+8ugrKCiAx+PB/v37UVNTI44znp6eFh5CNI5o+057ezu+9rWvibFgs9lw8OBBtLe3Y25uLsU44/GPsrKycPLkSRw4cABOpxMbGxsIBoPCcKb+aWlpQU1NDcLhMC5evIjx8fE9BhsRsS+//DIOHTqEcDiM4eFh9Pf3Cw87vkqfmZmJ2tpaHD9+HCUlJZibm8PCwoLw7CPZj0ajok0tFgvKysrEUdh0mhoR5OThsG/fPhQXFyMjI0Nsp6FYJfn5+ZiZmdkTrFaWYz6vGckS1Yee4wGcZZm12WzYv38/SkpKBKFM7ce3sHGYTLvxXtrb21FXV4dYLIarV6+KsU0nG5Gs5uTkiDmLl42McxpzBw8eRGlpKba2tlBZWYmamhoxVgGI70tvby8ikQja29tRX1+/53hwblATOe3z+cQWZFr84ORkRUWF8J68fPmyOOacPDjouRMnTqC2thbLy8t4//33MT4+nuJpRW1aVFSEkydPwmw2Y2xsDMvLy2L+lPthc3MTd+/eFbI3Pz+PkZERQVpFo1HxvaH4ZBRnqKamBkVFReI49KWlJfT29sLv92N8fFwsnshzELURbRUjGaQy8a3S9DsYDGJ1dRWlpaV45plnEI1GceXKFRHcmh+7Tt84/l0lAu2dd97B2toacnJyEIlEEAqFEAgEMDc3h0Qigc3NTVHvnZ0dbG1tCU9Dq9Uq+snpdKaMXSov96ojbx95bBD5Q+RWKBTCwMAALBaL8MqV57NkMolbt27hxo0bIvi20RilkzHNZrM4gfG1117D1NSUIIM56aegoKCgoKDw+OET2epVWFiIQ4cOoaWlBQ6HA+vr67h79y6Gh4cxNzcnVq6AVKKDVtyam5vh9XoxMDCA27dv4+7du5idnRVEESlOi4uL8Pv9ImZQNBpFdnY27HY7xsbGMDY2hsXFRSwuLmJ1dRXr6+s4c+YMgF2FnYJ7ut1uVFZWoq6uDuXl5eIkqkAggKGhIUxPTwtXc66wydsNZG8J2Tjhz3LjW36f/6a/zWYzGhoacOzYMZSUlGBzcxPLy8si4CjfoqJpGqLRKJaXlzE/P4+ysjKcOnVKGPBjY2O4evUq7t+/v0fpTyaTCIVC8Hq9IqZAZWUl3G43lpeX0d/fv4cw0DRNEDlutxtjY2Po7+8XHi7cvZ6DvHeIFIjH48JTqbS0FOFwGKFQCIODg+jr60MgEBAGB3djp2DJiUQCRUVF6OzsxObmJgoKCsQxyaFQCBMTE7h27Rqi0agIGr24uCiOsiXioqioCGVlZairqxMGYjgcRnZ2togPQieJEXkUCASwsLAglGibzYZ4PI7e3l6MjY0hHA6nrKxzj5XS0lKUlJTA7XajuLhYBE+12+3Y2dlBJBIRxIfdbkdFRQVyc3PhdDoxMzMjAs7y/iAYefvwZ4zkjssneVJQnTweD+rr65GVlYWRkRFhbGiahuzsbNTV1aWQQuPj4+IUPIrPQfnYbDZkZ2ejuLgYpaWlqK2tRSKRENuZaAtZJBIRMkbbN71er/DwIeKIgrw6nc6UrV1kJBUWFqKhoQEdHR2w2+24evUqzGYzamtrkZGRgVOnTuHKlSvidDsAgiTxeDw4cOAAmpubEQqFcP/+fczPzyMQCIggzBUVFWhra0NjYyNsNhuGhoZw/fr1lK2O1KYUlPzpp5/GxsYG+vv7cffuXeFJIMPj8aCurg4VFRWYmZkR21Rp3O3s7KQQqxRXqbq6Gvn5+ZienhZERF5eHsrLy1FaWipOgbJardja2hIxlzIyMlBUVISCgoIUbyXZ84e3sdEcyIkgfl/eksiNcordUlRUhNnZWVEmLteUH98yQ0da2+12Ef8kFAqlxBciYtfj8SAcDgsylnvlUL+TrNE4r6urE0b3gwcP4PP5hBfI2toaotEoHjx4gLGxMczOziIWiwmPw2QyCb/fL7ye1tfX4fP54PF4hKxSvchTq7KyEhaLBXfu3BFHlFMZabxTP62trWF4eBg3b94UdeKeVC6XS/T52toabt++DZ/Pt8eLjt7Z2trCxMQE/H4/HA6H2ObGAxHzslB8naysLOEVQ+nOz8+LU8LW19f3vCt/DxOJBJaXl1MWVXidSaaSyaQglSKRCMLhMAYGBsTx5PJ8I5Nb/Js3MDCAzc1NOJ1OxONxbG5uIhgMYmNjI2Wro0ya01a1yclJvP/++/B6vXtIH15+8m4y0gE4Oajru3Gj6Eh5Pj6ozZLJJO7duwefz4fh4WFxkqlMjNL2MofDIQje+fl5DAwMpMRLk3UaBQUFBQUFhccLn8gRDZmZmSIA4vj4OHp6ejA8PIxQKCQUQiDVaCAliuLF+P1+/OAHP8Dly5cRDofF1hCCyWTCgwcPMDw8DKfTKQz8paUlBAIBnDt3DvPz8yJPAGJvu8m0Gzi2qqoKmqahsrISbW1tyMnJwcrKioi7QivfXJHiBruRpw+QGneFykrXydOHfstEkqwM0vtWqxVtbW1iO9Pc3Bx6enrQ3d1tGCA3FovB5/Ph1q1bwlCemprCvXv3MDg4KNzxuSK5s7ODQCCAgYEBeDwePPHEE9jZ2UEikcDU1BRu3ryJubm5PXUkhdRut2N6eho3b97E1NQUQqGQKJccdJZikwSDQXGdvMXy8/PhdrsRDAbh8Xhw7tw5zM3N7Qk0y08U8vv9WFpaQmVlJbq6uoSivbS0hMHBQYyMjGBmZgaxWAxerxcFBQVi+4fJZEJ2djaysrJQXFyMxsZG4QVBsTRcLheeeeYZFBQUwGKxYHNzEz6fD6urq+Lo31gsJrYZOp1OzM3N4fz581hbW0tZreZ9L69m5+XlwWazCeIuGAzC7/cL7zaSjyeffFLEnKCxQ+0iE5PU3rJBwI1n+Rq9S4YKxemqq6tDbW0tJicncevWLUEIZGVloaqqCidPnoTT6cT58+cxODiIcDicEuuKvFGcTify8/NRWVmJ+vp6ZGdnw+/34969e4IYiUQi2NjYgMvlgsPhQE5OjiAtiOQhInN6ehpFRUXIzs7G+vp6iocQsHt8dl1dHY4fP47MzEy8+uqr6OnpEW35wgsvoLOzE/X19eLEMACi3q2trWhubkYgEMClS5dSCBo6cefIkSN44oknUFRUhPv372NsbAwPHjxIMVjtdjvy8vJQW1uLU6dOoaamBn/7t3+LK1euYHFxUcg4n2c0TYPH40FJSQkSiQRu376Ne/fuCRmfnZ2Frutim5fL5RLEZW5uLpaWltDT04OtrS1YLBYcOHAAHR0dyM3NRSAQgM/nQzAYTAk+vH//fjQ1NSErKws/+MEPhAcLB98myE+1I6KatiRxuSVvFXnu5Glqmga32w232421tTVkZGSIe3ybDp+TAeDgwYMoLi4WJwvyLUXU9jk5OaioqEB5eTlmZ2exuLi459Q3HtDb7/djbW0NTqcTmqZhdnYWY2NjGB8fF0Q098S4ePEirl69Kk6WzM7ORkVFBex2O65fvy6+AXREPB8X1C5EtgLA5OQkLly4IIJT87pT+87Pz8Pv92NkZAR+v9/QeHc4HCgsLEQ0GhXxrCg4NLUh9/ggb5pwOJxCnPFvF3mn6LqOy5cvo7e3F06nE8lkEj6fT3i9rq2tibzI24u2QtE1SpPyftTCCT2bTCaxsLCAS5cuYWZmBqurq5ifnxdEBweNJy57/PtLpBH9Jo80iiUmk+bU/iTno6Oj8Pl8KCsrS/H04vLJ8+S/5fEul5EfVMHbf2dnR5yKKI8nrg8kEglBbB04cABWqxV9fX1CpvjzivhRUFBQUFB4fPGJePxQDADaLsRJG77qRr8pIDNt5aqursbw8DA++OCDlLg1PE4Cue5/8MEH4vjwaDQqjoGneDDcxRqAWHF84oknxGkgABCNRnH27Fn09PTgyJEjeOqpp1BZWYnnn38eU1NTWF9fTwkAyhVXboBwg4QUUO7hQWXnSi8pd+R1wk9r4mnS0cJ0pPHs7KzYqsaVcMo7GAzinXfeEbEYJicnRVBdvmLJyab19XVcvHgRAFBYWCiIopWVFeHmzskKKv/W1hbGxsbw3e9+V5AgfFWXB7rk5EI8HhfeH8DuEdh2u11srbFarSJQKf0jxZwbDHNzc+I4YY/Hg/n5eVy/fl2cwsYDfEajUZjNZhQUFKChoQEOhwMOhwMNDQ0iDtX09DT6+/vhdrtRW1srvNcCgQCuXbuGW7duYWpqCvF4HIlEQhjd2dnZMJvNGB4exq1btzA9Pb2H9OFxHXRdFwGyCwoKsLa2hsHBQWGQkwHJZd/hcKCzsxORSETIOk+T8pANcC6r/Dngw4DJfHySoURxt9rb29Hc3Iy1tTXcuHFDkHYWiwX79u3DsWPHUF5eju985zu4e/euMICoDNx7qKqqCs3NzSgpKUE0GsU777wjYskUFhaiuroaeXl5OHLkCPLz83Hw4EHU1tbC7XZje3tbtFNvby/u3buHrKwsHD58GFtbW+JkQJI1i8WCmpoaQZyePXtWBE/WdR3vvvsubDYb/sW/+Bc4dOgQuru7xbgoLi5Ge3s7Dh8+jFu3bqG7uxuhUEjUJzc3F42NjXjqqaeQk5MDk8mESCQi4oZQP9hsNmRkZKC6uhptbW3o7OxEaWkpotGoiFnGxyL1FY83s7W1BbfbLbbYyJ4zlE9nZyc+//nPY3l5Gb29vRgYGEAoFBJxlE6cOIHy8nKxfcflcqGhoQE1NTUiWC0RHW63G9XV1VhZWdlDOnBShcsbgeY6Pu9zo5rHXeJGudVqxdzcHGpqalBeXo6TJ09idXVVkPHceN7Z2REkX3Z2ttj+kkgkhCcNEaQlJSU4dOgQGhsbAQBnz55NIWVpTiK5jcfjYusUsBubzu/3Y2trK4V05kb39vY2IpHInlg5Z86cwezsLMLhMKxWKwoLC5GZmQmfz7dn62wymcTy8jLeeustuFwurK+vCwKak8WatruN6vXXXxftyb91VB5d1xGJRLCwsIB79+7h0qVLwus2HfnC5wmK3UUEFf9+83hDtG2b14We5YQ/nxdIxvmWSiKMuBzxbYRc9sjLigeo5oHeqfwUn4v3GdclKIYc1YtIUE7Ccc8cHmuItn5tbW1hfn4eAMQWQplI4R5OXN5oTBjpEDJxyseZ/DzVjQhS+t/v94uFIL5tk+sZMrGroKCgoKCg8HjhYyV+SPnw+Xx7vBu4QUDPcmWFYhUcOnQIo6Oj+NM//VMEAoGUd7nyY7VaEY/Hsba2Jk6y4qt88rYaUoiuXLkCh8OBw4cPIzMzE4uLi7hx4wamp6eFEbC+vo5kMolf//Vfx7Fjx1BbW4t79+4J9/eBgQGMjIykEC6yMkcGCI/HwA1zKptR3BVebroei8Xw+uuvGyrt3GDn8QuSySTC4TDee++9lPx4YGYyjCnvaDSKqakp3L9/f0+ZKC9Kh5RW3uaTk5N7yC0iafiRsfJqLhkzwWAQDx48wPT0NGKxGP7hH/5BnKIGpMZH4kbv1tYW+vv7MTg4CLPZjFgsJuSG+oDkIxQKYWlpCYWFhejq6kJHRwfW1tawuLiI73//+5icnBReVA6HQxzjG4vFsL6+LgIqc0OVgvBOTk4KsocblNwIonqQN9WdO3fQ39+fQoZxGeFkjKZpIo7E4uKi2ApAAUVlOeSkD5czWR6on3j56L2cnBx85StfQVtbG3w+H/7+7/9erOiTrFPw7Hg8jtnZWWGg81OkqDwUcDgYDGJychIjIyMi1ojJZMLU1BRWV1dRX1+PV155RRjSCwsL6O7uxsDAAKanp0WcjXg8LuJXjI6O4tq1aynjAwD279+PgwcPIpFIiK2bwK63jsfjQXZ2NoLBICYmJoSBS9t7GhoasLa2hosXL4r4JHl5eSJQel1dHQYGBvC9730PBw8exNNPP42ioiI0NjZiaGhIxBU7evQoCgoKoOu6iFlDwdHJMKV+oDFP/b6ysoKFhQURgJkIbi5fLpcLx44dwx/+4R8iFovhj//4j1OC6VIw+EQiIeJrdXV1YWdnR2xRGhgYEFuSampq8G/+zb/BgQMHxHZCfiKRkWcFyRXJndEY4PIlky3A7hHyly9fRllZGU6fPo2vfOUreO655+D3+xGNRrG6ugqz2QybzYa1tTX82Z/9GTY3NzEyMoKamhocPnwYlZWVGBgYQDKZREFBAXJzc1FYWIhEIoHx8XG88847Qk7lsvOxNjMzg+np6ZRrNF8RSLa5Jwu1y8bGBoaGhnD48GH8wR/8gehri8UCn8+Hs2fPpmyL4oR2OBzG1taWuMbnPB53i4h13p7yaWqhUAhXrlzBzZs3xdjgXiacZOSkL58b5Pg0VCbqO3k7FAef9/k8yPUC7rlCJ/3xBSLuOehwOFL6gZOHsswRqSEvPPC+JDng8ih79vL24t9BHpQb+FD3oPJwApp7vvKxw/PncgVAEFk0priOQSQwlz2ZzKK0OMlGZLz8beHfCgUFBQUFBYXHCx9J/Giatg/AdwB4AegA/lzX9T/WNO1/B/AtAKsPH/0Puq6ffVRafHVPJjj4/0DqSpbZbIbX60V5eTnW1tbw+uuvY2lpSSgqRtsf+HG2PH/uucANDco7HA7j3Xffxfnz50U5KKApsKuIBgIB4V7/G7/xGzCZdo97Hh0dxfr6espKvtVqTSE5ZMOaTt0iBZHKzLcsELhHkNHK3/b2Nu7fv78nL76aSumQok5KqazQUbtzQ44rlWSgyGXk+cjBIGUiir9LSqvNZkshwujZRCIBk8kkglVfvnwZuq6nBJ/mXip02hl5YPF85S1hvL5U/h/84Afo7u5GdnY2tre3sbi4iPX19T2xaGKxGEKhEBYWFkQfGq3MkqFAxADlJ2/d4H3FjTmjMUP9w/tU13XcvXsXb775piAsjZ6nd2RClBtasixyI4ruZWZm4ktf+hIOHz6M6elpvP3222L7Ejd0NjY2sLa2JgJih8NhYZRwo568TgYGBsRpcJykNZlMmJubw9mzZzE5OYnMzExsbGxgZGRExIwisoT6iU5GSyaTmJ+fx9TUVIoRSR4kMzMzqKurwxe+8AWMjY2huLgYRUVFyM/Px/b2Nt544w10d3cL0pbi5xQWFiIYDKK0tFRsmzx16hRycnIwPz+P733ve7h9+zZCoRCCwaCIOXbixAnU19cjJycHADA1NYWzZ89iamoKLpcLv/3bv42ysjJ8/etfx/j4OObn50W+7733nggyDOzOWxsbG8jJycHx48fx3nvvpch+fn4+Tp48iW9/+9tYWFjAn//5n+POnTsIBoOibWkLIQWrz8zMRDAYxMrKCoaHh0WbJhIJOBwO2O12xONxFBQUwGq1irhsXL6A9EFz+bzCnyM5JZmjZzgJ8eDBA/zDP/wD5ubmcPz4cXG6FHn2JRIJLC4uYnJyUvT13bt3UVdXJ+Ix1dbWIhgMYnt7W8T3Ghoawvj4uPDeJNJb9uDk3zI+NvmcJ89x5PXH66NpGjY2NvC9730PkUgEFRUV2NzcxP379zE6OoqRkRHhpUKGOMWUkRc9+DzIvxH85EciXEmG+feY5kZ5vHPwuZ3SpzFM/cq9fvgcYrQdieY58gzkXjuccOFzErWlTCBxr7BYLLZHrnjdOKmj67r4DvN3qH1pPibyld/jBBvw4beHfws4Mafr+h7SiurPPd3kBR65PCRD8lZeAi3cUP/KZBxdp626/Jssg8+VCgoKCgoKCo8vNCPlLuUBTSsGUKzreq+maVkAbgP4AoCvAAjruv5fftzMTCaTToa9QT4p/9PfpIzl5OSgpqYGOzs7mJqaSol/wJ83Uuq40kmGrpFiy1dU5S0SXCmk7VYUu2NnZzf2DRmztJWAk0vyqiBfUZPbgK/c8esyccVd4UmZ58o2/5sr3zxdah9+khKVl28N4IaXXBdZWSSShiuSVAYypDj4dU5E8XJyg5EbHEYKK683rxOXD0648D4gDy06jYXKRf0q9xmVjxRwvs2GrlP7ygSPbJgYKeDcK0k2FPh1LiMUHycUCiEUCgkSlNLn73PDgLcJ/UvXH1S2F198EV/+8pcxNDSEa9eu4d69eyLgKcmjybQbmP3EiRP42te+hsnJSfT29oo4EqFQKOUkH6MxzMtntVrhcDhgs9mE4RWNRgXBKhu/ZrMZeXl58Hg8CIVCmJ+fF/1ExlxFRQWOHj0qCJutrS1xWtvo6Cju3buHiYkJ3L9/P6Wdu7q6cPLkSZSVlSEYDCIvLw+bm5uYmZnByMgIJiYmsLKyImIZ2e12VFVViSPFacve/Py8CFBPx0C3trais7MTmqZha2sLd+/eFUQeBfcNhUKw2+3weDxoaGhAc3Mzzp07h7/6q7/C1taWqGNLSwu+/e1vIycnB3/0R38kPH34qj7Vi048JHKGTi3iMmu321FdXY1/9a/+Fe7cuYPvfve7KSdA0VhK16fcC0LelklzNJ+/+TigMU1xnXJzc+FwOIQ3Jn1jEomE2FYXj8dhtVpRXFyM2tpaVFRUiADkW1tboo/C4XCKtxUnxLlxT/IoG9xG8yH/LX9XOPFQUFCAjIwMsU2ZgrbzBQHKm5dDJt+5/Mtl4N8K+fQ8eT7g/cUJCKM0AaQQZbzPeZ/y93gby2SY7P3J5YqeNSLE+fxtRNQZtRUnn+TvndVqTfE25O1N13g7yzqDrM+QjPAxwOvOdQaeJs3hVqs1bR3494b3P7UD/37wcsjl5u/I9zRNE2SxgoKCgoKCwqcSt3VdP2J04yM9fnRdXwSw+PDvkKZpwwBKf5bSyMTDw7TF//w+KSmbm5sYGxuDru/GIzBSenkasuJkRHBxxYeTO7JCaWSE0japiYkJ8bz8Hhk28nYa3g5GpMWj3Kllo4GXj+dDZTVS1OW2obaQFWy5D/hKITfEeNr0t/weJxSM8qd0qQ+4AcIJLW588TLxMshyISvKVF9+TzYMiOiRjR4jOZLbWs6Ll102HIzSlI2GdGlzkoOTRhR0lbdXOrng942MPrmOvPw2mw3t7e2YmprC9evXxXHOnKihdNbW1tDf3499+/bh4MGDaG1tRUZGBh48eIDJyUmMjo4Kooa8WmRwg2lzczPldCKZUORtrus61tbWROwd+dhjAPD7/cLLqKysDHa7Hevr61haWsLMzAwWFxexsbGR0j7JZBIzMzPIzc1FZmYmMjMzEQqFcPfuXQwMDGB2djYl/grFd6ETnSYmJoTHGJWPZC4ej6Ovrw9ra2ui75aWlrC+vo7MzEw89dRTOHPmjNie5XA4xOlDPT09KVtDNE1DKBRCb28vNjY2cOfOHbFN1mgshsNhcRIbN9j5WKcTk1599VX4fD5RRw7uucNlm+7xMWw0j8jzOZ8Xd3Z2hPfd+vq6IDLi8XhKsGF6loighYUFhMNhzMzMwOFwYGVlRQRSNiIaZOOdykhjjXtQyO2ZjpyVCXQiL1dWVlIIAN42j2oXeVwaGe9c1jkpIKdhRM7Qb05yyHMIkQ7yN53PBem+wbIXCi+70TyVbl6XvUT5czxN+Rskywt/huRanj95H8pztZyvfI+el8cAbb9Kp4PI40T+htB3ltfBqN353EhEmQz5eyX3g4KCgoKCgsLjh58oxo+maZUADgO4AeAEgN/VNO2fA+gB8G91XV83eOd3APwO/eaKDFeMZMKEr6gBu6QGBXI2MuJlL6J0igsvB1foKB3+dzpSQVZQ0xECch15/Y2epXSI6DBSRHn5ZIVSJkd4/bl3kJEyx13Y+ao65f0oV3C5nJz4kRVX+fdHpW9UF6P25vcpTV5+ekYmOmQiRTYu5TLw9PjfRqfEyH1u1J/yPaMxYFRX2dA02iJgVJ5HGUZGxqWR9xtdN5lMCAQC6O3txeDgINbX11PanhtE0WgUc3NzIpg4eTbQliEuK/LWiHQkFIE8qvjWByNCgwcU5+UEIII++3w+5Ofnw+FwwOfzwe/3IxaLGcaf2tnZPRXu7t270DQNGRkZgkCi0/9oPPE5KhwOY3p6GrOzs6IcRgGE/X6/OIKZyyXFL8nOzobH40E0GkUoFBJHRo+MjKRskaFyvvnmm4hGo2J7kywfcnvxuU6eb2j73pUrVwBgz0lFvH3luRiA8MiQ5V0GN7DlMUWGK8k+pSePW26cE1EUCAT2EDw8P7kt5LErexPK359045bXi/LisVhkmZfllfKWvzvyuPyofqDrvEy8neT52ahvePq8LYy+cenaQk5b/pbJ+ciBv+V71MdG5ZXrTfoFH5ty21ObymWnd+Vx+1Hztiw7Rt9tnofR91KWETkfLgtyOxqVy4jsN9Kp0ukuCgoKCgoKCo8HPnKrl3hQ0zIBfADgP+q6/pqmaV4APuzG/fk/sbsd7DcflYbJZNL5iRoP0xWGj5Sf+FteSeT3+GlVXFEzcmPmaXNDRFaMyHuAG9P8VA1ZaeVkjRGBIRsipKRSrBm5fpz4kYkKep/aUd5uQO/KwTtJkePu/ZQuh9EKIeUjt50cz4L6ilYu6To3wOQ+MOpTOX9eVspTjk1kZJxS21LdeV/KJ0nxFXzZCEinyMur1fIzRu/y7V68veWtXkaxO+Q0OVHFDV++NUbuKyMPDKP+pb/JKJVlido6Pz9fHI/O24TLH+8Pm80Gu92eYsDxQNfcCOFtQeOF4mOQzNMKeTgchs1mE/fTxVqSCRzuWWREKnAZ46dM8W1klBadPmhEBsuxQLjRJ5MgfAzQ3CjLTV5eHp588kkUFBRgaWkJCwsLePDgAVZXd0Ou0XZLXgcu63IsFy5X8rYf8vCTjVO+9SVdwHGZAKR05fhfMqjc8nwmn1bEn6c0ZXmmPqe+5mXjMOoz+s3lmW/TTfdtkuc6eoZkgLYp0vMUm8rIo4V/2yhtOS6XEZHCvTlk2SayVCbTuBcS72M+N8mEC/cEInnh92SZobLJafDfctkoTYp1RF6B/HvL+0Kur0zq8/6T7/Ny07gx8oSiNjTyVqM85Guy3PN5VS5vuvrTczL4XMnbmPcdlxPqN5IT7vlDdeN5UdvyU+YUFBQUFBQUPnVIu9XrxyJ+NE2zAngTwDu6rv9Xg/uVAN7Udb3pUemYTCbdbrcD2GvwcoXKiAQwckfmSqpsqJHBwNMgJZYrcZwgMJvNYqWcK2L0f7qyktIpkz5cWZdPEqH7shHOFXNZ6SZljba2yIYK/eaGj0wA8Lxk41omH7hRypVJftoXV5xlwoQHf5YNDiPPEyqXTBow+UkhNbgRL4O3ldF13mc83ovs4ULPEmnGDR+qG9WJ2oq78lM9ZKOO9zcPxMqNEGp/eSVdNsjld2S55EG65XpxYoHXTSagjIgnSocTGtyIoe03Mni/8PyIWDEybmjM2mw2ABDxlqh+MkEjb9OT5xReTjpxjf/j/SXHdSIZ5LLCZVI+XYeIUJIhPrb5WObzCs9LPnmH7lssFjgcjpRg5fzkHpI7PgZoTMrBb/l4oHqlI094+ek+ERdGhiz1Ey+/ru9uo6H06FnZyORjPJ1HF801fBzzuY3PhUZeRpwQ43LJAyDLhBD3OJEXHOga/01jnOSc6k2/5XFF9aK2lb8rfJ7n8xmXV/6MPD55P8mkmhxjjvch1VOWUxny3M7nKFlu5DnOSOa5fPB68/fMZrOQazlf3jZyO8t6BO9L/p00+q7z7yX1AW8bui6TObzdeZvy9qYykWwDH55mRu0HQJxQyb/jAFKIG3ku5Hlz+aD5lGSffzsoT0X8KCgoKCgofKrx08f40Xa1i78AMMxJH03TivXd+D8A8EUA9z4qLV3XfdFodBO7nkK/UMgnzCgoKPxEKMDHME4VFBR+JqhxqqDweECNVQWFTz/UOFX4LKAi3Y0f51SvkwC6AQwAoKWu/wDgqwBasbvVawbA/8iIoEel15OOhVJQUPh0QI1TBYVPP9Q4VVB4PKDGqoLCpx9qnCp81vHjnOp1GYBRZMezP//iKCgoKCgoKCgoKCgoKCgoKCj8vJD+3HAFBQUFBQUFBQUFBQUFBQUFhccanwTx8+efQJ4KCgo/GdQ4VVD49EONUwWFxwNqrCoofPqhxqnCZxo/9nHuCgoKCgoKCgoKCgoKCgoKCgqPF9RWLwUFBQUFBQUFBQUFBQUFBYXPKD424kfTtOc1TRvVNG1C07R//3Hlq6CgkApN0/ZpmnZR07QhTdMGNU37vYfX8zRNO6dp2vjD/3MfXtc0Tft/Ho7du5qmtX2yNVBQ+OWCpmlmTdPuaJr25sPfVZqm3Xg4Jv9e0zTbw+v2h78nHt6v/EQLrqDwSwJN09yapv1A07QRTdOGNU3rUt9UBYVPHzRN+/ZD3feepml/q2maQ31TFX5Z8LEQP5qmmQH8CYAXADQA+KqmaQ0fR94KCgp7kATwb3VdbwBwDMD/9HA8/nsA53Vd3w/g/MPfwO643f/w3+8A+NOPv8gKCr/U+D0Aw+z3/wXgj3RdrwWwDuC3Hl7/LQDrD6//0cPnFBQUfvH4YwD/pOv6QQAt2B2v6puqoPApgqZppQD+ZwBHdF1vAmAG8OtQ31SFXxJ8XB4/nQAmdF2f0nU9DuDvAPzKx5S3goICg67ri7qu9z78O4RdBbUUu2Pyrx8+9tcAvvDw718B8B19F9cBuDVNK/54S62g8MsJTdPKALwE4L8//K0BeArADx4+Io9VGsM/APD0w+cVFBR+QdA0LQfAEwD+AgB0XY/ruh6A+qYqKHwaYQHg1DTNAsAFYBHqm6rwS4KPi/gpBXCf/Z5/eE1BQeETxEO31cMAbgDw6rq++PDWEgDvw7/V+FVQ+OTwfwP4XwHsPPydDyCg63ry4W8+HsVYfXh/4+HzCgoKvzhUAVgF8P893JL53zVNy4D6pioofKqg6/oDAP8FwBx2CZ8NALehvqkKvyRQwZ0VFH5JoWlaJoB/APD7uq4H+T1997g/deSfgsInCE3TPg9gRdf12590WRQUFNLCAqANwJ/qun4YwCY+3NYFQH1TFRQ+DXgYZ+tXsEvWlgDIAPD8J1ooBYWPER8X8fMAwD72u+zhNQUFhU8AmqZZsUv6fE/X9dceXl4md/OH/688vK7Gr4LCJ4MTAF7RNG0Gu1ukn8JuLBH3Qzd1IHU8irH68H4OAP/HWWAFhV9CzAOY13X9xsPfP8AuEaS+qQoKny48A2Ba1/VVXdcTAF7D7ndWfVMVfinwcRE/twDsfxg13YbdQFpvfEx5KygoMDzcn/wXAIZ1Xf+v7NYbAL7x8O9vAPhHdv2fPzyJ5BiADea+rqCg8AuCruv/m67rZbquV2L3u3lB1/WvAbgI4FcfPiaPVRrDv/rweeVloKDwC4Su60sA7muaVvfw0tMAhqC+qQoKnzbMATimaZrroS5MY1V9UxV+KaB9XPKradqL2I1VYAbwl7qu/8ePJWMFBYUUaJp2EkA3gAF8GDfkP2A3zs/3AZQDmAXwFV3X1x5+HP9f7LrDbgH4pq7rPR97wRUUfomhadoZAP+Lruuf1zStGrseQHkA7gD4H3Rdj2ma5gDwN9iN27UG4Nd1XZ/6hIqsoPBLA03TWrEbgN0GYArAN7G7uKq+qQoKnyJomvZ/APg17J5wewfAb2M3lo/6pip85vGxET8KCgoKCgoKCgoKCgoKCgoKCh8vVHBnBQUFBQUFBQUFBQUFBQUFhc8oFPGjoKCgoKCgoKCgoKCgoKCg8BmFIn4UFBQUFBQUFBQUFBQUFBQUPqNQxI+CgoKCgoKCgoKCgoKCgoLCZxSK+FFQUFBQUFBQUFBQUFBQUFD4jEIRPwoKCgoKCgoKCgoKCgoKCgqfUSjiR0FBQUFBQUFBQUFBQUFBQeEzCkX8KCgoKCgoKCgoKCgoKCgoKHxG8f8DOrxqAzw+EtMAAAAASUVORK5CYII=\n", + "text/plain": [ + "<Figure size 1440x1440 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 20))\n", + "plt.imshow(data.squeeze(0).numpy(), cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "from text_recognizer.datasets.transforms import Compose, AddTokens" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "target_transform = Compose([torch.tensor, AddTokens(init_token=\"<sos>\", eos_token=\"<eos>\")])" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IAM Lines Dataset\n", + "Number classes: 82\n", + "Mapping: {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: 'A', 11: 'B', 12: 'C', 13: 'D', 14: 'E', 15: 'F', 16: 'G', 17: 'H', 18: 'I', 19: 'J', 20: 'K', 21: 'L', 22: 'M', 23: 'N', 24: 'O', 25: 'P', 26: 'Q', 27: 'R', 28: 'S', 29: 'T', 30: 'U', 31: 'V', 32: 'W', 33: 'X', 34: 'Y', 35: 'Z', 36: 'a', 37: 'b', 38: 'c', 39: 'd', 40: 'e', 41: 'f', 42: 'g', 43: 'h', 44: 'i', 45: 'j', 46: 'k', 47: 'l', 48: 'm', 49: 'n', 50: 'o', 51: 'p', 52: 'q', 53: 'r', 54: 's', 55: 't', 56: 'u', 57: 'v', 58: 'w', 59: 'x', 60: 'y', 61: 'z', 62: ' ', 63: '!', 64: '\"', 65: '#', 66: '&', 67: \"'\", 68: '(', 69: ')', 70: '*', 71: '+', 72: ',', 73: '-', 74: '.', 75: '/', 76: ':', 77: ';', 78: '?', 79: '_', 80: '<sos>', 81: '<eos>'}\n", + "Data: (7101, 28, 952)\n", + "Targets: (7101, 97)\n", + "\n" + ] + } + ], + "source": [ + "dataset = IamLinesDataset(train=True, init_token=\"<sos>\", pad_token=\"_\", eos_token=\"<eos>\", target_transform=target_transform)\n", + "dataset.load_or_generate_data()\n", + "print(dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "data, target = dataset[0]\n", + "sentence = convert_y_label_to_string(target, dataset) " + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], [])" + ] + }, + "execution_count": 66, + "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": 176, + "metadata": {}, + "outputs": [], + "source": [ + "from text_recognizer.networks import VisionTransformer" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [], + "source": [ + "tt = Transformer(3, 3, 512, 8, 2048, 0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": {}, + "outputs": [], + "source": [ + "vt = VisionTransformer(6, 6, 256, 82, 8, 118, 512, 256, 0.1, 79, (28, 16), (1, 8), \"gelu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [], + "source": [ + "from torchsummary import summary" + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "VisionTransformer(\n", + " (slidning_window): Sequential(\n", + " (0): Unfold(kernel_size=(28, 16), dilation=1, padding=0, stride=(1, 8))\n", + " (1): Rearrange('b (c h w) t -> b t (c h w)', h=28, w=16, c=1)\n", + " )\n", + " (character_embedding): Embedding(82, 256)\n", + " (position_encoding): PositionalEncoding(\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (linear_projection): Linear(in_features=448, out_features=256, bias=True)\n", + " (transformer): Transformer(\n", + " (encoder): Encoder(\n", + " (layers): ModuleList(\n", + " (0): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (1): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (2): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (3): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (4): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (5): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (decoder): Decoder(\n", + " (layers): ModuleList(\n", + " (0): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (1): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (2): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (3): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (4): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (5): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (head): Sequential(\n", + " (0): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (1): Linear(in_features=256, out_features=256, bias=True)\n", + " (2): GELU()\n", + " (3): Dropout(p=0.1, inplace=False)\n", + " (4): Linear(in_features=256, out_features=82, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 194, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vt" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==========================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "==========================================================================================\n", + "├─Sequential: 1-1 [-1, 118, 448] --\n", + "| └─Unfold: 2-1 [-1, 448, 118] --\n", + "| └─Rearrange: 2-2 [-1, 118, 448] --\n", + "├─Linear: 1-2 [-1, 118, 256] 114,944\n", + "├─PositionalEncoding: 1-3 [-1, 118, 256] --\n", + "| └─Dropout: 2-3 [-1, 118, 256] --\n", + "├─Embedding: 1-4 [-1, 97, 256] 20,992\n", + "├─PositionalEncoding: 1-5 [-1, 97, 256] --\n", + "| └─Dropout: 2-4 [-1, 97, 256] --\n", + "├─Transformer: 1-6 [-1, 97, 256] --\n", + "| └─Encoder: 2-5 [-1, 118, 256] --\n", + "| └─Decoder: 2-6 [-1, 97, 256] --\n", + "├─Sequential: 1-7 [-1, 97, 82] --\n", + "| └─LayerNorm: 2-7 [-1, 97, 256] 512\n", + "| └─Linear: 2-8 [-1, 97, 256] 65,792\n", + "| └─GELU: 2-9 [-1, 97, 256] --\n", + "| └─Dropout: 2-10 [-1, 97, 256] --\n", + "| └─Linear: 2-11 [-1, 97, 82] 21,074\n", + "==========================================================================================\n", + "Total params: 223,314\n", + "Trainable params: 223,314\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 23.93\n", + "==========================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 0.86\n", + "Params size (MB): 0.85\n", + "Estimated Total Size (MB): 1.81\n", + "==========================================================================================\n" + ] + }, + { + "data": { + "text/plain": [ + "==========================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "==========================================================================================\n", + "├─Sequential: 1-1 [-1, 118, 448] --\n", + "| └─Unfold: 2-1 [-1, 448, 118] --\n", + "| └─Rearrange: 2-2 [-1, 118, 448] --\n", + "├─Linear: 1-2 [-1, 118, 256] 114,944\n", + "├─PositionalEncoding: 1-3 [-1, 118, 256] --\n", + "| └─Dropout: 2-3 [-1, 118, 256] --\n", + "├─Embedding: 1-4 [-1, 97, 256] 20,992\n", + "├─PositionalEncoding: 1-5 [-1, 97, 256] --\n", + "| └─Dropout: 2-4 [-1, 97, 256] --\n", + "├─Transformer: 1-6 [-1, 97, 256] --\n", + "| └─Encoder: 2-5 [-1, 118, 256] --\n", + "| └─Decoder: 2-6 [-1, 97, 256] --\n", + "├─Sequential: 1-7 [-1, 97, 82] --\n", + "| └─LayerNorm: 2-7 [-1, 97, 256] 512\n", + "| └─Linear: 2-8 [-1, 97, 256] 65,792\n", + "| └─GELU: 2-9 [-1, 97, 256] --\n", + "| └─Dropout: 2-10 [-1, 97, 256] --\n", + "| └─Linear: 2-11 [-1, 97, 82] 21,074\n", + "==========================================================================================\n", + "Total params: 223,314\n", + "Trainable params: 223,314\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 23.93\n", + "==========================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 0.86\n", + "Params size (MB): 0.85\n", + "Estimated Total Size (MB): 1.81\n", + "==========================================================================================" + ] + }, + "execution_count": 214, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "summary(vt, [(1, 28, 952), (97,)], device=\"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "metadata": {}, + "outputs": [], + "source": [ + "x = vt.preprocess_input(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 118, 256])" + ] + }, + "execution_count": 196, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [], + "source": [ + "x = vt.encoder(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "metadata": {}, + "outputs": [], + "source": [ + "trg = torch.tensor([10, 62, 22, 24, 31, 14, 62, 55, 50, 62, 54, 55, 50, 51, 62, 22, 53, 74,\n", + " 62, 16, 36, 44, 55, 54, 46, 40, 47, 47, 62, 41, 53, 50, 48, 79, 79, 79,\n", + " 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,\n", + " 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,\n", + " 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,\n", + " 79, 79, 79, 79, 79, 79, 79])[None, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [], + "source": [ + "t, tm = vt.preprocess_target(trg)" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "VisionTransformer(\n", + " (slidning_window): Sequential(\n", + " (0): Unfold(kernel_size=(28, 16), dilation=1, padding=0, stride=(1, 8))\n", + " (1): Rearrange('b (c h w) t -> b t (c h w)', h=28, w=16, c=1)\n", + " )\n", + " (character_embedding): Embedding(82, 256)\n", + " (position_encoding): PositionalEncoding(\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (linear_projection): Linear(in_features=448, out_features=256, bias=True)\n", + " (transformer): Transformer(\n", + " (encoder): Encoder(\n", + " (layers): ModuleList(\n", + " (0): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (1): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (2): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (3): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (4): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (5): EncoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (decoder): Decoder(\n", + " (layers): ModuleList(\n", + " (0): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (1): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (2): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (3): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (4): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (5): DecoderLayer(\n", + " (self_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (multihead_attention): MultiHeadAttention(\n", + " (fc_q): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_k): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_v): Linear(in_features=256, out_features=256, bias=False)\n", + " (fc_out): Linear(in_features=256, out_features=256, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (cnn): _ConvolutionalLayer(\n", + " (layer): Sequential(\n", + " (0): Linear(in_features=256, out_features=512, bias=True)\n", + " (1): GELU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=512, out_features=256, bias=True)\n", + " )\n", + " )\n", + " (block1): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block2): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (block3): _IntraLayerConnection(\n", + " (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (head): Sequential(\n", + " (0): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n", + " (1): Linear(in_features=256, out_features=256, bias=True)\n", + " (2): GELU()\n", + " (3): Dropout(p=0.1, inplace=False)\n", + " (4): Linear(in_features=256, out_features=82, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 209, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vt.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "t" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[-0.4344, 0.4939, 0.0382, ..., -0.0808, -0.0290, 0.4399],\n", + " [-0.4350, 0.5146, 0.0356, ..., -0.0634, -0.0289, 0.4271],\n", + " [-0.4303, 0.5245, 0.0435, ..., -0.0755, -0.0267, 0.4240],\n", + " ...,\n", + " [-0.4477, 0.5377, 0.0596, ..., -0.0866, -0.0283, 0.4457],\n", + " [-0.4475, 0.5435, 0.0606, ..., -0.0900, -0.0293, 0.4440],\n", + " [-0.4488, 0.5476, 0.0689, ..., -0.0914, -0.0276, 0.4411]]],\n", + " grad_fn=<AddBackward0>)" + ] + }, + "execution_count": 211, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vt.decoder(t, x, tm)" + ] + }, + { + "cell_type": "code", + "execution_count": 213, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "24.0" + "tensor([[[-0.4179, 0.4755, 0.0407, ..., -0.0609, -0.0870, 0.4562],\n", + " [-0.4262, 0.4845, 0.0361, ..., -0.0497, -0.0847, 0.4459],\n", + " [-0.4237, 0.4900, 0.0409, ..., -0.0573, -0.0812, 0.4434],\n", + " ...,\n", + " [-0.4477, 0.5053, 0.0394, ..., -0.0489, -0.0815, 0.4589],\n", + " [-0.4469, 0.5069, 0.0407, ..., -0.0500, -0.0808, 0.4573],\n", + " [-0.4464, 0.5079, 0.0416, ..., -0.0510, -0.0801, 0.4570]]],\n", + " grad_fn=<AddBackward0>)" ] }, - "execution_count": 13, + "execution_count": 213, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "32 * 0.75" + "vt(data, trg)" ] }, { @@ -387,7 +1584,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/src/notebooks/04b-look-at-iam-paragraphs.ipynb b/src/notebooks/04b-look-at-iam-paragraphs.ipynb index a442420..9c5ade4 100644 --- a/src/notebooks/04b-look-at-iam-paragraphs.ipynb +++ b/src/notebooks/04b-look-at-iam-paragraphs.ipynb @@ -245,7 +245,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/src/notebooks/05-sanity-check-multihead-attention.ipynb b/src/notebooks/05-sanity-check-multihead-attention.ipynb new file mode 100644 index 0000000..54f0432 --- /dev/null +++ b/src/notebooks/05-sanity-check-multihead-attention.ipynb @@ -0,0 +1,169 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import cv2\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('..')\n", + "\n", + "from text_recognizer.networks.transformer.attention import MultiHeadAttention" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "temp_mha = MultiHeadAttention(hidden_dim=512, num_heads=8)\n", + "def print_out(Q, K, V):\n", + " temp_out, temp_attn = temp_mha.scaled_dot_product_attention(Q, K, V)\n", + " print('Attention weights are:', temp_attn.squeeze())\n", + " print('Output is:', temp_out.squeeze())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "test_K = torch.tensor(\n", + " [[10, 0, 0],\n", + " [ 0,10, 0],\n", + " [ 0, 0,10],\n", + " [ 0, 0,10]]\n", + ").float()[None,None]\n", + "\n", + "test_V = torch.tensor(\n", + " [[ 1,0,0],\n", + " [ 10,0,0],\n", + " [ 100,5,0],\n", + " [1000,6,0]]\n", + ").float()[None,None]\n", + "\n", + "test_Q = torch.tensor(\n", + " [[0, 10, 0]]\n", + ").float()[None,None]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Attention weights are: tensor([8.4333e-26, 1.0000e+00, 8.4333e-26, 8.4333e-26])\n", + "Output is: tensor([1.0000e+01, 9.2766e-25, 0.0000e+00])\n" + ] + } + ], + "source": [ + "print_out(test_Q, test_K, test_V)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Attends to the second element, as it should!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Attention weights are: tensor([4.2166e-26, 4.2166e-26, 5.0000e-01, 5.0000e-01])\n", + "Output is: tensor([550.0000, 5.5000, 0.0000])\n" + ] + } + ], + "source": [ + "test_Q = torch.tensor([[0, 0, 10]]).float()[None,None]\n", + "print_out(test_Q, test_K, test_V)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Focuses equally on the third and fourth key." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Attention weights are: tensor([[4.2166e-26, 4.2166e-26, 5.0000e-01, 5.0000e-01],\n", + " [8.4333e-26, 1.0000e+00, 8.4333e-26, 8.4333e-26],\n", + " [5.0000e-01, 5.0000e-01, 4.2166e-26, 4.2166e-26]])\n", + "Output is: tensor([[5.5000e+02, 5.5000e+00, 0.0000e+00],\n", + " [1.0000e+01, 9.2766e-25, 0.0000e+00],\n", + " [5.5000e+00, 4.6383e-25, 0.0000e+00]])\n" + ] + } + ], + "source": [ + "test_Q = torch.tensor(\n", + " [[0, 0, 10], [0, 10, 0], [10, 10, 0]]\n", + ").float()[None,None]\n", + "print_out(test_Q, test_K, test_V)" + ] + }, + { + "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 +} diff --git a/src/notebooks/Untitled.ipynb b/src/notebooks/Untitled.ipynb new file mode 100644 index 0000000..f114ed9 --- /dev/null +++ b/src/notebooks/Untitled.ipynb @@ -0,0 +1,893 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "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": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def convert_y_label_to_string(y, dataset):\n", + " return ''.join([dataset.mapper(int(i)) for i in y])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from text_recognizer.models import VisionTransformerModel, TransformerEncoderModel\n", + "from text_recognizer.datasets import IamLinesDataset\n", + "from text_recognizer.datasets.transforms import Compose, AddTokens" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "target_transform = Compose([torch.tensor, AddTokens(init_token=\"<sos>\", pad_token=\"_\", eos_token=\"<eos>\")])\n", + "dataset = IamLinesDataset(train=False, init_token=\"<sos>\", pad_token=\"_\", eos_token=\"<eos>\", target_transform=target_transform)\n", + "dataset.load_or_generate_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "config_path = \"../training/experiments/VisionTransformerModel_IamLinesDataset_CNNTransformer/1102_221553/config.yml\"\n", + "with open(config_path, \"r\") as f:\n", + " experiment_config = yaml.safe_load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2020-11-03 07:32:07.256 | DEBUG | text_recognizer.models.base:load_weights:457 - Loading network with pretrained weights.\n" + ] + } + ], + "source": [ + "model = VisionTransformerModel(network_fn=network_fn_, dataset=dataset_, dataset_args=dataset_args)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2020-11-03 07:32:10.285 | DEBUG | text_recognizer.models.base:load_from_checkpoint:404 - Loading checkpoint...\n" + ] + } + ], + "source": [ + "checkpoint_path = \"../training/experiments/VisionTransformerModel_IamLinesDataset_CNNTransformer/1102_221553/model/last.pt\"\n", + "model.load_from_checkpoint(checkpoint_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "model.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "data, target = dataset[0]\n", + "sentence = convert_y_label_to_string(target, dataset) " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([98])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "target.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], [])" + ] + }, + "execution_count": 26, + "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": 32, + "metadata": {}, + "outputs": [], + "source": [ + " def make_len_mask(inp):\n", + " return (inp == 79).transpose(0, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([98, 1])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "make_len_mask(target.unsqueeze(0)).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "('to stel mire of a thar chishirchit<eos>', 0.20226626098155975)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.predict_on_image(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2020-10-31 16:35:40.255 | DEBUG | text_recognizer.models.base:load_weights:457 - Loading network with pretrained weights.\n", + "2020-10-31 16:35:40.837 | DEBUG | text_recognizer.models.base:load_from_checkpoint:404 - Loading checkpoint...\n" + ] + } + ], + "source": [ + "target_transform = Compose([torch.tensor, AddTokens(pad_token=\"_\", eos_token=\"<eos>\")])\n", + "dataset = IamLinesDataset(train=False, pad_token=\"_\", eos_token=\"<eos>\", target_transform=target_transform)\n", + "dataset.load_or_generate_data()\n", + "\n", + "\n", + "config_path = \"../training/experiments/TransformerEncoderModel_IamLinesDataset_CNNTransformerEncoder/1031_150630/config.yml\"\n", + "with open(config_path, \"r\") as f:\n", + " experiment_config = yaml.safe_load(f)\n", + "\n", + "\n", + "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\"])\n", + "\n", + "\n", + "checkpoint_path = \"../training/experiments/TransformerEncoderModel_IamLinesDataset_CNNTransformerEncoder/1031_150630/model/last.pt\"\n", + "\n", + "\n", + "model = TransformerEncoderModel(network_fn=network_fn_, dataset=dataset_, dataset_args=dataset_args)\n", + "model.load_from_checkpoint(checkpoint_path)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===============================================================================================\n", + "Layer (type:depth-idx) Output Shape Param #\n", + "===============================================================================================\n", + "├─WideResidualNetwork: 1-1 [-1, 256, 2, 60] --\n", + "| └─Sequential: 2-1 [-1, 256, 2, 60] --\n", + "| | └─Conv2d: 3-1 [-1, 8, 28, 952] 72\n", + "| | └─Sequential: 3-2 [-1, 16, 28, 952] --\n", + "| | | └─WideBlock: 4-1 [-1, 16, 28, 952] 3,632\n", + "| | └─Sequential: 3-3 [-1, 32, 14, 476] --\n", + "| | | └─WideBlock: 4-2 [-1, 32, 14, 476] 14,432\n", + "| | └─Sequential: 3-4 [-1, 64, 7, 238] --\n", + "| | | └─WideBlock: 4-3 [-1, 64, 7, 238] 57,536\n", + "| | └─Sequential: 3-5 [-1, 128, 4, 119] --\n", + "| | | └─WideBlock: 4-4 [-1, 128, 4, 119] 229,760\n", + "| | └─Sequential: 3-6 [-1, 256, 2, 60] --\n", + "| | | └─WideBlock: 4-5 [-1, 256, 2, 60] 918,272\n", + "├─Conv2d: 1-2 [-1, 97, 2, 60] 24,929\n", + "├─Linear: 1-3 [-1, 97, 96] 11,616\n", + "├─PositionalEncoding: 1-4 [-1, 97, 96] --\n", + "| └─Dropout: 2-2 [-1, 97, 96] --\n", + "├─TransformerEncoder: 1-5 [-1, 2, 96] --\n", + "| └─ModuleList: 2 [] --\n", + "| | └─TransformerEncoderLayer: 3-7 [-1, 2, 96] --\n", + "| | | └─MultiheadAttention: 4-6 [-1, 2, 96] 37,248\n", + "| | | └─Dropout: 4-7 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-8 [-1, 2, 96] 192\n", + "| | | └─Linear: 4-9 [-1, 2, 2048] 198,656\n", + "| | | └─Dropout: 4-10 [-1, 2, 2048] --\n", + "| | | └─Linear: 4-11 [-1, 2, 96] 196,704\n", + "| | | └─Dropout: 4-12 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-13 [-1, 2, 96] 192\n", + "| | └─TransformerEncoderLayer: 3-8 [-1, 2, 96] --\n", + "| | | └─MultiheadAttention: 4-14 [-1, 2, 96] 37,248\n", + "| | | └─Dropout: 4-15 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-16 [-1, 2, 96] 192\n", + "| | | └─Linear: 4-17 [-1, 2, 2048] 198,656\n", + "| | | └─Dropout: 4-18 [-1, 2, 2048] --\n", + "| | | └─Linear: 4-19 [-1, 2, 96] 196,704\n", + "| | | └─Dropout: 4-20 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-21 [-1, 2, 96] 192\n", + "| | └─TransformerEncoderLayer: 3-9 [-1, 2, 96] --\n", + "| | | └─MultiheadAttention: 4-22 [-1, 2, 96] 37,248\n", + "| | | └─Dropout: 4-23 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-24 [-1, 2, 96] 192\n", + "| | | └─Linear: 4-25 [-1, 2, 2048] 198,656\n", + "| | | └─Dropout: 4-26 [-1, 2, 2048] --\n", + "| | | └─Linear: 4-27 [-1, 2, 96] 196,704\n", + "| | | └─Dropout: 4-28 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-29 [-1, 2, 96] 192\n", + "| | └─TransformerEncoderLayer: 3-10 [-1, 2, 96] --\n", + "| | | └─MultiheadAttention: 4-30 [-1, 2, 96] 37,248\n", + "| | | └─Dropout: 4-31 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-32 [-1, 2, 96] 192\n", + "| | | └─Linear: 4-33 [-1, 2, 2048] 198,656\n", + "| | | └─Dropout: 4-34 [-1, 2, 2048] --\n", + "| | | └─Linear: 4-35 [-1, 2, 96] 196,704\n", + "| | | └─Dropout: 4-36 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-37 [-1, 2, 96] 192\n", + "| | └─TransformerEncoderLayer: 3-11 [-1, 2, 96] --\n", + "| | | └─MultiheadAttention: 4-38 [-1, 2, 96] 37,248\n", + "| | | └─Dropout: 4-39 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-40 [-1, 2, 96] 192\n", + "| | | └─Linear: 4-41 [-1, 2, 2048] 198,656\n", + "| | | └─Dropout: 4-42 [-1, 2, 2048] --\n", + "| | | └─Linear: 4-43 [-1, 2, 96] 196,704\n", + "| | | └─Dropout: 4-44 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-45 [-1, 2, 96] 192\n", + "| | └─TransformerEncoderLayer: 3-12 [-1, 2, 96] --\n", + "| | | └─MultiheadAttention: 4-46 [-1, 2, 96] 37,248\n", + "| | | └─Dropout: 4-47 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-48 [-1, 2, 96] 192\n", + "| | | └─Linear: 4-49 [-1, 2, 2048] 198,656\n", + "| | | └─Dropout: 4-50 [-1, 2, 2048] --\n", + "| | | └─Linear: 4-51 [-1, 2, 96] 196,704\n", + "| | | └─Dropout: 4-52 [-1, 2, 96] --\n", + "| | | └─LayerNorm: 4-53 [-1, 2, 96] 192\n", + "| └─LayerNorm: 2-3 [-1, 2, 96] 192\n", + "├─Linear: 1-6 [-1, 97, 81] 7,857\n", + "===============================================================================================\n", + "Total params: 3,866,250\n", + "Trainable params: 3,866,250\n", + "Non-trainable params: 0\n", + "Total mult-adds (M): 18.78\n", + "===============================================================================================\n", + "Input size (MB): 0.10\n", + "Forward/backward pass size (MB): 2.06\n", + "Params size (MB): 14.75\n", + "Estimated Total Size (MB): 16.91\n", + "===============================================================================================\n" + ] + } + ], + "source": [ + "model.summary(experiment_config[\"train_args\"][\"input_shape\"], 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [], + "source": [ + "data, target = dataset[110]\n", + "sentence = convert_y_label_to_string(target, dataset) " + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], [])" + ] + }, + "execution_count": 111, + "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": 112, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('Boyis cheed iitrincy- tarisaing one', 0.3990435302257538)" + ] + }, + "execution_count": 112, + "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": 61, + "metadata": {}, + "outputs": [], + "source": [ + "t=[12,1,1,1,1,1,4,4,4,4,4]" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t[t!=79]" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "x = torch.arange(10)\n", + "value = 5\n", + "x = x[x!=value]" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0, 1, 2, 3, 4, 6, 7, 8, 9])" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "t = torch.rand(98)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(1.7656e-43)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t.cumprod(dim=0)[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "pred_tokens = torch.Tensor([1,2,21,31, 89, 89])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "pred_tokens = torch.stack([pred_tokens, pred_tokens])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 1., 2., 21., 31., 89., 89.],\n", + " [ 1., 2., 21., 31., 89., 89.]])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pred_tokens" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "eos_token_index = torch.nonzero(\n", + " pred_tokens == 89, as_tuple=False,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + } + ], + "source": [ + "if eos_token_index.nelement():\n", + " print(eos_token_index[0][0].item())" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[0, 4],\n", + " [0, 5],\n", + " [1, 4],\n", + " [1, 5]])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eos_token_index" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eos_token_index.nelement()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "from text_recognizer.models import accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "pred = torch.Tensor([1,2,21,31, 80, 80]).unsqueeze(0)\n", + "target = torch.Tensor([1,2,1,31, 80, 80]).unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "pred = torch.stack([pred, pred])\n", + "target = torch.stack([target, target])" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [], + "source": [ + "target = torch.tensor([0, 1, 2, 3])\n", + "pred = torch.tensor([0, 2, 1, 3])" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.5" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "accuracy(pred, target)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "acc = (target.argmax(-1) == pred.argmax(-1)).float()\n", + "\n", + "# return float(100 * acc.sum() / len(acc))" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[1.],\n", + " [1.]])" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "acc" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "train_acc = (pred == target).sum().item()/target.shape[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.3333333333333335" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_acc" + ] + }, + { + "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 +} diff --git a/src/tasks/create_emnist_lines_datasets.sh b/src/tasks/create_emnist_lines_datasets.sh new file mode 100755 index 0000000..0940549 --- /dev/null +++ b/src/tasks/create_emnist_lines_datasets.sh @@ -0,0 +1,4 @@ +#!/bin/bash +command="python text_recognizer/datasets/emnist_lines_dataset.py --max_length 34 --min_overlap 0.0 --max_overlap 0.33 --num_train 100000 --num_test 10000" +echo $command +eval $command diff --git a/src/tasks/create_iam_paragraphs.sh b/src/tasks/create_iam_paragraphs.sh new file mode 100755 index 0000000..9063d44 --- /dev/null +++ b/src/tasks/create_iam_paragraphs.sh @@ -0,0 +1,2 @@ +#!/bin/bash +poetry run create-iam-paragraphs diff --git a/src/tasks/download_emnist.sh b/src/tasks/download_emnist.sh new file mode 100755 index 0000000..d142324 --- /dev/null +++ b/src/tasks/download_emnist.sh @@ -0,0 +1,3 @@ +#!/bin/bash +poetry run download-emnist +poetry run create-emnist-support-files diff --git a/src/tasks/download_iam.sh b/src/tasks/download_iam.sh new file mode 100755 index 0000000..4bf011c --- /dev/null +++ b/src/tasks/download_iam.sh @@ -0,0 +1,2 @@ +#!/bin/bash +poetry run download-iam diff --git a/src/tasks/prepare_experiments.sh b/src/tasks/prepare_experiments.sh index 9b91daa..f2787b3 100755 --- a/src/tasks/prepare_experiments.sh +++ b/src/tasks/prepare_experiments.sh @@ -1,3 +1,3 @@ #!/bin/bash experiments_filename=${1:-training/experiments/sample_experiment.yml} -python training/prepare_experiments.py --experiments_filename $experiments_filename +poetry run prepare-experiments --experiments_filename $experiments_filename diff --git a/src/tasks/train.sh b/src/tasks/train.sh new file mode 100755 index 0000000..71a68be --- /dev/null +++ b/src/tasks/train.sh @@ -0,0 +1,67 @@ +#!/bin/bash + +# Add checkpoint and resume experiment +usage() { + cat << EOF + usage: ./tasks/train_crnn_line_ctc_model.sh + -f | --experiment_config Name of the experiment config. + -c | --checkpoint (Optional) The experiment name to continue from. + -p | --pretrained_weights (Optional) Path to pretrained weights. + -n | --notrain (Optional) Evaluates a trained model. + -t | --test (Optional) If set, evaluates the model on test set. + -v | --verbose (Optional) Sets the verbosity. + -h | --help Shows this message. +EOF +exit 1 +} + +experiment_config="" +checkpoint="" +pretrained_weights="" +notrain="" +test="" +verbose="" +train_command="" + +while getopts 'f:c:p:nthv' flag; do + case "${flag}" in + f) experiment_config="${OPTARG}" ;; + c) checkpoint="${OPTARG}" ;; + p) pretrained_weights="${OPTARG}" ;; + n) notrain="--notrain" ;; + t) test="--test" ;; + v) verbose="${verbose}v" ;; + h) usage ;; + *) error "Unexpected option ${flag}" ;; + esac +done + + +if [ -z ${experiment_config} ]; +then + echo "experiment_config not specified!" + usage + exit 1 +fi + +experiments_filename="training/experiments/${experiment_config}" +train_command=$(./tasks/prepare_experiments.sh $experiments_filename) + +if [ ${checkpoint} ]; +then + train_command="${train_command} --checkpoint $checkpoint" +fi + +if [ ${pretrained_weights} ]; +then + train_command="${train_command} --pretrained_weights $pretrained_weights" +fi + +if [ ${verbose} ]; +then + train_command="${train_command} -$verbose" +fi + +train_command="${train_command} $test $notrain" +echo $train_command +eval $train_command diff --git a/src/tasks/train_crnn_line_ctc_model.sh b/src/tasks/train_crnn_line_ctc_model.sh deleted file mode 100644 index 9831289..0000000 --- a/src/tasks/train_crnn_line_ctc_model.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/bash -experiments_filename=${1:-training/experiments/line_ctc_experiment.yml} -exec ./prepare_experiments.sh experiments_filename=experiments_filename diff --git a/src/text_recognizer/character_predictor.py b/src/text_recognizer/character_predictor.py index df37e68..ad71289 100644 --- a/src/text_recognizer/character_predictor.py +++ b/src/text_recognizer/character_predictor.py @@ -4,6 +4,7 @@ from typing import Dict, Tuple, Type, Union import numpy as np from torch import nn +from text_recognizer import datasets, networks from text_recognizer.models import CharacterModel from text_recognizer.util import read_image @@ -11,9 +12,11 @@ from text_recognizer.util import read_image class CharacterPredictor: """Recognizes the character in handwritten character images.""" - def __init__(self, network_fn: Type[nn.Module]) -> None: + def __init__(self, network_fn: str, dataset: str) -> None: """Intializes the CharacterModel and load the pretrained weights.""" - self.model = CharacterModel(network_fn=network_fn) + network_fn = getattr(networks, network_fn) + dataset = getattr(datasets, dataset) + self.model = CharacterModel(network_fn=network_fn, dataset=dataset) self.model.eval() self.model.use_swa_model() diff --git a/src/text_recognizer/datasets/__init__.py b/src/text_recognizer/datasets/__init__.py index a3af9b1..d8372e3 100644 --- a/src/text_recognizer/datasets/__init__.py +++ b/src/text_recognizer/datasets/__init__.py @@ -1,5 +1,5 @@ """Dataset modules.""" -from .emnist_dataset import EmnistDataset, Transpose +from .emnist_dataset import EmnistDataset from .emnist_lines_dataset import ( construct_image_from_string, EmnistLinesDataset, @@ -8,6 +8,7 @@ from .emnist_lines_dataset import ( from .iam_dataset import IamDataset from .iam_lines_dataset import IamLinesDataset from .iam_paragraphs_dataset import IamParagraphsDataset +from .transforms import AddTokens, Transpose from .util import ( _download_raw_dataset, compute_sha256, @@ -19,6 +20,7 @@ from .util import ( __all__ = [ "_download_raw_dataset", + "AddTokens", "compute_sha256", "construct_image_from_string", "DATA_DIRNAME", diff --git a/src/text_recognizer/datasets/dataset.py b/src/text_recognizer/datasets/dataset.py index 05520e5..2de7f09 100644 --- a/src/text_recognizer/datasets/dataset.py +++ b/src/text_recognizer/datasets/dataset.py @@ -18,6 +18,9 @@ class Dataset(data.Dataset): subsample_fraction: float = None, transform: Optional[Callable] = None, target_transform: Optional[Callable] = None, + init_token: Optional[str] = None, + pad_token: Optional[str] = None, + eos_token: Optional[str] = None, ) -> None: """Initialization of Dataset class. @@ -26,12 +29,14 @@ class Dataset(data.Dataset): subsample_fraction (float): The fraction of the dataset to use for training. Defaults to None. transform (Optional[Callable]): Transform(s) for input data. Defaults to None. target_transform (Optional[Callable]): Transform(s) for output data. Defaults to None. + init_token (Optional[str]): String representing the start of sequence token. Defaults to None. + pad_token (Optional[str]): String representing the pad token. Defaults to None. + eos_token (Optional[str]): String representing the end of sequence token. Defaults to None. Raises: ValueError: If subsample_fraction is not None and outside the range (0, 1). """ - self.train = train self.split = "train" if self.train else "test" @@ -40,19 +45,18 @@ class Dataset(data.Dataset): raise ValueError("The subsample fraction must be in (0, 1).") self.subsample_fraction = subsample_fraction - self._mapper = EmnistMapper() + self._mapper = EmnistMapper( + init_token=init_token, eos_token=eos_token, pad_token=pad_token + ) self._input_shape = self._mapper.input_shape self._output_shape = self._mapper._num_classes self.num_classes = self.mapper.num_classes # Set transforms. - self.transform = transform - if self.transform is None: - self.transform = ToTensor() - - self.target_transform = target_transform - if self.target_transform is None: - self.target_transform = torch.tensor + self.transform = transform if transform is not None else ToTensor() + self.target_transform = ( + target_transform if target_transform is not None else torch.tensor + ) self._data = None self._targets = None diff --git a/src/text_recognizer/datasets/emnist_dataset.py b/src/text_recognizer/datasets/emnist_dataset.py index d01dcee..9884fdf 100644 --- a/src/text_recognizer/datasets/emnist_dataset.py +++ b/src/text_recognizer/datasets/emnist_dataset.py @@ -22,6 +22,7 @@ class EmnistDataset(Dataset): def __init__( self, + pad_token: str = None, train: bool = False, sample_to_balance: bool = False, subsample_fraction: float = None, @@ -32,6 +33,7 @@ class EmnistDataset(Dataset): """Loads the dataset and the mappings. Args: + pad_token (str): The pad token symbol. Defaults to _. train (bool): If True, loads the training set, otherwise the validation set is loaded. Defaults to False. sample_to_balance (bool): Resamples the dataset to make it balanced. Defaults to False. subsample_fraction (float): Description of parameter `subsample_fraction`. Defaults to None. @@ -45,6 +47,7 @@ class EmnistDataset(Dataset): subsample_fraction=subsample_fraction, transform=transform, target_transform=target_transform, + pad_token=pad_token, ) self.sample_to_balance = sample_to_balance @@ -53,8 +56,7 @@ class EmnistDataset(Dataset): if transform is None: self.transform = Compose([Transpose(), ToTensor()]) - # The EMNIST dataset is already casted to tensors. - self.target_transform = target_transform + self.target_transform = None self.seed = seed diff --git a/src/text_recognizer/datasets/emnist_lines_dataset.py b/src/text_recognizer/datasets/emnist_lines_dataset.py index 6268a01..6871492 100644 --- a/src/text_recognizer/datasets/emnist_lines_dataset.py +++ b/src/text_recognizer/datasets/emnist_lines_dataset.py @@ -4,6 +4,7 @@ from collections import defaultdict from pathlib import Path from typing import Callable, Dict, List, Optional, Tuple, Union +import click import h5py from loguru import logger import numpy as np @@ -37,6 +38,9 @@ class EmnistLinesDataset(Dataset): max_overlap: float = 0.33, num_samples: int = 10000, seed: int = 4711, + init_token: Optional[str] = None, + pad_token: Optional[str] = None, + eos_token: Optional[str] = None, ) -> None: """Set attributes and loads the dataset. @@ -50,13 +54,21 @@ class EmnistLinesDataset(Dataset): max_overlap (float): The maximum overlap between concatenated images. Defaults to 0.33. num_samples (int): Number of samples to generate. Defaults to 10000. seed (int): Seed number. Defaults to 4711. + init_token (Optional[str]): String representing the start of sequence token. Defaults to None. + pad_token (Optional[str]): String representing the pad token. Defaults to None. + eos_token (Optional[str]): String representing the end of sequence token. Defaults to None. """ + self.pad_token = "_" if pad_token is None else pad_token + super().__init__( train=train, transform=transform, target_transform=target_transform, subsample_fraction=subsample_fraction, + init_token=init_token, + pad_token=self.pad_token, + eos_token=eos_token, ) # Extract dataset information. @@ -118,11 +130,7 @@ class EmnistLinesDataset(Dataset): @property def data_filename(self) -> Path: """Path to the h5 file.""" - filename = f"ml_{self.max_length}_o{self.min_overlap}_{self.max_overlap}_n{self.num_samples}.pt" - if self.train: - filename = "train_" + filename - else: - filename = "test_" + filename + filename = "train.pt" if self.train else "test.pt" return DATA_DIRNAME / filename def load_or_generate_data(self) -> None: @@ -138,8 +146,8 @@ class EmnistLinesDataset(Dataset): """Loads the dataset from the h5 file.""" logger.debug("EmnistLinesDataset loading data from HDF5...") with h5py.File(self.data_filename, "r") as f: - self._data = f["data"][:] - self._targets = f["targets"][:] + self._data = f["data"][()] + self._targets = f["targets"][()] def _generate_data(self) -> str: """Generates a dataset with the Brown corpus and Emnist characters.""" @@ -148,7 +156,10 @@ class EmnistLinesDataset(Dataset): sentence_generator = SentenceGenerator(self.max_length) # Load emnist dataset. - emnist = EmnistDataset(train=self.train, sample_to_balance=True) + emnist = EmnistDataset( + train=self.train, sample_to_balance=True, pad_token=self.pad_token + ) + emnist.load_or_generate_data() samples_by_character = get_samples_by_character( emnist.data.numpy(), emnist.targets.numpy(), self.mapper.mapping, @@ -298,6 +309,18 @@ def convert_strings_to_categorical_labels( return np.array([[mapping[c] for c in label] for label in labels]) +@click.command() +@click.option( + "--max_length", type=int, default=34, help="Number of characters in a sentence." +) +@click.option( + "--min_overlap", type=float, default=0.0, help="Min overlap between characters." +) +@click.option( + "--max_overlap", type=float, default=0.33, help="Max overlap between characters." +) +@click.option("--num_train", type=int, default=10_000, help="Number of train examples.") +@click.option("--num_test", type=int, default=1_000, help="Number of test examples.") def create_datasets( max_length: int = 34, min_overlap: float = 0, @@ -306,17 +329,17 @@ def create_datasets( num_test: int = 1000, ) -> None: """Creates a training an validation dataset of Emnist lines.""" - emnist_train = EmnistDataset(train=True, sample_to_balance=True) - emnist_test = EmnistDataset(train=False, sample_to_balance=True) - datasets = [emnist_train, emnist_test] num_samples = [num_train, num_test] - for num, train, dataset in zip(num_samples, [True, False], datasets): + for num, train in zip(num_samples, [True, False]): emnist_lines = EmnistLinesDataset( train=train, - emnist=dataset, max_length=max_length, min_overlap=min_overlap, max_overlap=max_overlap, num_samples=num, ) - emnist_lines._load_or_generate_data() + emnist_lines.load_or_generate_data() + + +if __name__ == "__main__": + create_datasets() diff --git a/src/text_recognizer/datasets/iam_lines_dataset.py b/src/text_recognizer/datasets/iam_lines_dataset.py index 4a74b2b..fdd2fe6 100644 --- a/src/text_recognizer/datasets/iam_lines_dataset.py +++ b/src/text_recognizer/datasets/iam_lines_dataset.py @@ -32,12 +32,18 @@ class IamLinesDataset(Dataset): subsample_fraction: float = None, transform: Optional[Callable] = None, target_transform: Optional[Callable] = None, + init_token: Optional[str] = None, + pad_token: Optional[str] = None, + eos_token: Optional[str] = None, ) -> None: super().__init__( train=train, subsample_fraction=subsample_fraction, transform=transform, target_transform=target_transform, + init_token=init_token, + pad_token=pad_token, + eos_token=eos_token, ) @property diff --git a/src/text_recognizer/datasets/iam_paragraphs_dataset.py b/src/text_recognizer/datasets/iam_paragraphs_dataset.py index 4b34bd1..c1e8fe2 100644 --- a/src/text_recognizer/datasets/iam_paragraphs_dataset.py +++ b/src/text_recognizer/datasets/iam_paragraphs_dataset.py @@ -266,11 +266,16 @@ def _load_iam_paragraphs() -> None: @click.option( "--subsample_fraction", type=float, - default=0.0, + default=None, help="The subsampling factor of the dataset.", ) def main(subsample_fraction: float) -> None: """Load dataset and print info.""" + logger.info("Creating train set...") + dataset = IamParagraphsDataset(train=True, subsample_fraction=subsample_fraction) + dataset.load_or_generate_data() + print(dataset) + logger.info("Creating test set...") dataset = IamParagraphsDataset(subsample_fraction=subsample_fraction) dataset.load_or_generate_data() print(dataset) diff --git a/src/text_recognizer/datasets/transforms.py b/src/text_recognizer/datasets/transforms.py index 17231a8..8deac7f 100644 --- a/src/text_recognizer/datasets/transforms.py +++ b/src/text_recognizer/datasets/transforms.py @@ -3,6 +3,9 @@ import numpy as np from PIL import Image import torch from torch import Tensor +from torchvision.transforms import Compose, Resize, ToPILImage, ToTensor + +from text_recognizer.datasets.util import EmnistMapper class Transpose: @@ -11,3 +14,40 @@ class Transpose: def __call__(self, image: Image) -> np.ndarray: """Swaps axis.""" return np.array(image).swapaxes(0, 1) + + +class AddTokens: + """Adds start of sequence and end of sequence tokens to target tensor.""" + + def __init__(self, pad_token: str, eos_token: str, init_token: str = None) -> None: + self.init_token = init_token + self.pad_token = pad_token + self.eos_token = eos_token + if self.init_token is not None: + self.emnist_mapper = EmnistMapper( + init_token=self.init_token, + pad_token=self.pad_token, + eos_token=self.eos_token, + ) + else: + self.emnist_mapper = EmnistMapper( + pad_token=self.pad_token, eos_token=self.eos_token, + ) + self.pad_value = self.emnist_mapper(self.pad_token) + self.eos_value = self.emnist_mapper(self.eos_token) + + def __call__(self, target: Tensor) -> Tensor: + """Adds a sos token to the begining and a eos token to the end of a target sequence.""" + dtype, device = target.dtype, target.device + + # Find the where padding starts. + pad_index = torch.nonzero(target == self.pad_value, as_tuple=False)[0].item() + + target[pad_index] = self.eos_value + + if self.init_token is not None: + self.sos_value = self.emnist_mapper(self.init_token) + sos = torch.tensor([self.sos_value], dtype=dtype, device=device) + target = torch.cat([sos, target], dim=0) + + return target diff --git a/src/text_recognizer/datasets/util.py b/src/text_recognizer/datasets/util.py index 73968a1..d2df8b5 100644 --- a/src/text_recognizer/datasets/util.py +++ b/src/text_recognizer/datasets/util.py @@ -4,6 +4,7 @@ import importlib import json import os from pathlib import Path +import string from typing import Callable, Dict, List, Optional, Type, Union from urllib.request import urlopen, urlretrieve @@ -26,7 +27,7 @@ def save_emnist_essentials(emnsit_dataset: type = EMNIST) -> None: mapping = [(i, str(label)) for i, label in enumerate(labels)] essentials = { "mapping": mapping, - "input_shape": tuple(emnsit_dataset[0][0].shape[:]), + "input_shape": tuple(np.array(emnsit_dataset[0][0]).shape[:]), } logger.info("Saving emnist essentials...") with open(ESSENTIALS_FILENAME, "w") as f: @@ -43,11 +44,21 @@ def download_emnist() -> None: class EmnistMapper: """Mapper between network output to Emnist character.""" - def __init__(self) -> None: + def __init__( + self, + pad_token: str, + init_token: Optional[str] = None, + eos_token: Optional[str] = None, + ) -> None: """Loads the emnist essentials file with the mapping and input shape.""" + self.init_token = init_token + self.pad_token = pad_token + self.eos_token = eos_token + self.essentials = self._load_emnist_essentials() # Load dataset infromation. - self._mapping = self._augment_emnist_mapping(dict(self.essentials["mapping"])) + self._mapping = dict(self.essentials["mapping"]) + self._augment_emnist_mapping() self._inverse_mapping = {v: k for k, v in self.mapping.items()} self._num_classes = len(self.mapping) self._input_shape = self.essentials["input_shape"] @@ -103,7 +114,7 @@ class EmnistMapper: essentials = json.load(f) return essentials - def _augment_emnist_mapping(self, mapping: Dict) -> Dict: + def _augment_emnist_mapping(self) -> None: """Augment the mapping with extra symbols.""" # Extra symbols in IAM dataset extra_symbols = [ @@ -127,14 +138,20 @@ class EmnistMapper: ] # padding symbol, and acts as blank symbol as well. - extra_symbols.append("_") + extra_symbols.append(self.pad_token) + + if self.init_token is not None: + extra_symbols.append(self.init_token) + + if self.eos_token is not None: + extra_symbols.append(self.eos_token) - max_key = max(mapping.keys()) + max_key = max(self.mapping.keys()) extra_mapping = {} for i, symbol in enumerate(extra_symbols): extra_mapping[max_key + 1 + i] = symbol - return {**mapping, **extra_mapping} + self._mapping = {**self.mapping, **extra_mapping} def compute_sha256(filename: Union[Path, str]) -> str: diff --git a/src/text_recognizer/line_predictor.py b/src/text_recognizer/line_predictor.py new file mode 100644 index 0000000..981e2c9 --- /dev/null +++ b/src/text_recognizer/line_predictor.py @@ -0,0 +1,28 @@ +"""LinePredictor class.""" +import importlib +from typing import Tuple, Union + +import numpy as np +from torch import nn + +from text_recognizer import datasets, networks +from text_recognizer.models import VisionTransformerModel +from text_recognizer.util import read_image + + +class LinePredictor: + """Given an image of a line of handwritten text, recognizes the text content.""" + + def __init__(self, dataset: str, network_fn: str) -> None: + network_fn = getattr(networks, network_fn) + dataset = getattr(datasets, dataset) + self.model = VisionTransformerModel(network_fn=network_fn, dataset=dataset) + self.model.eval() + + def predict(self, image_or_filename: Union[np.ndarray, str]) -> Tuple[str, float]: + """Predict on a single images contianing a handwritten character.""" + if isinstance(image_or_filename, str): + image = read_image(image_or_filename, grayscale=True) + else: + image = image_or_filename + return self.model.predict_on_image(image) diff --git a/src/text_recognizer/models/__init__.py b/src/text_recognizer/models/__init__.py index a3cfc15..28aa52e 100644 --- a/src/text_recognizer/models/__init__.py +++ b/src/text_recognizer/models/__init__.py @@ -1,7 +1,19 @@ """Model modules.""" from .base import Model from .character_model import CharacterModel -from .line_ctc_model import LineCTCModel +from .crnn_model import CRNNModel from .metrics import accuracy, cer, wer +from .transformer_encoder_model import TransformerEncoderModel +from .vision_transformer_model import VisionTransformerModel -__all__ = ["Model", "cer", "CharacterModel", "LineCTCModel", "accuracy", "wer"] +__all__ = [ + "Model", + "cer", + "CharacterModel", + "CRNNModel", + "CNNTransfromerModel", + "accuracy", + "TransformerEncoderModel", + "VisionTransformerModel", + "wer", +] diff --git a/src/text_recognizer/models/base.py b/src/text_recognizer/models/base.py index caf8065..cc44c92 100644 --- a/src/text_recognizer/models/base.py +++ b/src/text_recognizer/models/base.py @@ -6,7 +6,7 @@ import importlib from pathlib import Path import re import shutil -from typing import Callable, Dict, Optional, Tuple, Type +from typing import Callable, Dict, List, Optional, Tuple, Type, Union from loguru import logger import torch @@ -15,6 +15,7 @@ from torch import Tensor from torch.optim.swa_utils import AveragedModel, SWALR from torch.utils.data import DataLoader, Dataset, random_split from torchsummary import summary +from torchvision.transforms import Compose from text_recognizer.datasets import EmnistMapper @@ -128,16 +129,42 @@ class Model(ABC): self._configure_criterion() self._configure_optimizers() - # Prints a summary of the network in terminal. - self.summary() - # Set this flag to true to prevent the model from configuring again. self.is_configured = True + def _configure_transforms(self) -> None: + # Load transforms. + transforms_module = importlib.import_module( + "text_recognizer.datasets.transforms" + ) + if ( + "transform" in self.dataset_args["args"] + and self.dataset_args["args"]["transform"] is not None + ): + transform_ = [] + for t in self.dataset_args["args"]["transform"]: + args = t["args"] or {} + transform_.append(getattr(transforms_module, t["type"])(**args)) + self.dataset_args["args"]["transform"] = Compose(transform_) + + if ( + "target_transform" in self.dataset_args["args"] + and self.dataset_args["args"]["target_transform"] is not None + ): + target_transform_ = [ + torch.tensor, + ] + for t in self.dataset_args["args"]["target_transform"]: + args = t["args"] or {} + target_transform_.append(getattr(transforms_module, t["type"])(**args)) + self.dataset_args["args"]["target_transform"] = Compose(target_transform_) + def prepare_data(self) -> None: """Prepare data for training.""" # TODO add downloading. if not self.data_prepared: + self._configure_transforms() + # Load train dataset. train_dataset = self.dataset(train=True, **self.dataset_args["args"]) train_dataset.load_or_generate_data() @@ -327,20 +354,20 @@ class Model(ABC): else: return self.network(x) - def loss_fn(self, output: Tensor, targets: Tensor) -> Tensor: - """Compute the loss.""" - return self.criterion(output, targets) - def summary( - self, input_shape: Optional[Tuple[int, int, int]] = None, depth: int = 3 + self, + input_shape: Optional[Union[List, Tuple]] = None, + depth: int = 4, + device: Optional[str] = None, ) -> None: """Prints a summary of the network architecture.""" + device = self.device if device is None else device if input_shape is not None: - summary(self.network, input_shape, depth=depth, device=self.device) + summary(self.network, input_shape, depth=depth, device=device) elif self._input_shape is not None: input_shape = (1,) + tuple(self._input_shape) - summary(self.network, input_shape, depth=depth, device=self.device) + summary(self.network, input_shape, depth=depth, device=device) else: logger.warning("Could not print summary as input shape is not set.") @@ -356,25 +383,29 @@ class Model(ABC): state["optimizer_state"] = self._optimizer.state_dict() if self._lr_scheduler is not None: - state["scheduler_state"] = self._lr_scheduler.state_dict() + state["scheduler_state"] = self._lr_scheduler["lr_scheduler"].state_dict() + state["scheduler_interval"] = self._lr_scheduler["interval"] if self._swa_network is not None: state["swa_network"] = self._swa_network.state_dict() return state - def load_from_checkpoint(self, checkpoint_path: Path) -> None: + def load_from_checkpoint(self, checkpoint_path: Union[str, Path]) -> None: """Load a previously saved checkpoint. Args: checkpoint_path (Path): Path to the experiment with the checkpoint. """ + checkpoint_path = Path(checkpoint_path) + self.prepare_data() + self.configure_model() logger.debug("Loading checkpoint...") if not checkpoint_path.exists(): logger.debug("File does not exist {str(checkpoint_path)}") - checkpoint = torch.load(str(checkpoint_path)) + checkpoint = torch.load(str(checkpoint_path), map_location=self.device) self._network.load_state_dict(checkpoint["model_state"]) if self._optimizer is not None: @@ -383,8 +414,11 @@ class Model(ABC): if self._lr_scheduler is not None: # Does not work when loadning from previous checkpoint and trying to train beyond the last max epochs # with OneCycleLR. - if self._lr_scheduler.__class__.__name__ != "OneCycleLR": - self._lr_scheduler.load_state_dict(checkpoint["scheduler_state"]) + if self._lr_scheduler["lr_scheduler"].__class__.__name__ != "OneCycleLR": + self._lr_scheduler["lr_scheduler"].load_state_dict( + checkpoint["scheduler_state"] + ) + self._lr_scheduler["interval"] = checkpoint["scheduler_interval"] if self._swa_network is not None: self._swa_network.load_state_dict(checkpoint["swa_network"]) diff --git a/src/text_recognizer/models/character_model.py b/src/text_recognizer/models/character_model.py index 50e94a2..f9944f3 100644 --- a/src/text_recognizer/models/character_model.py +++ b/src/text_recognizer/models/character_model.py @@ -47,8 +47,9 @@ class CharacterModel(Model): swa_args, device, ) + self.pad_token = dataset_args["args"]["pad_token"] if self._mapper is None: - self._mapper = EmnistMapper() + self._mapper = EmnistMapper(pad_token=self.pad_token,) self.tensor_transform = ToTensor() self.softmax = nn.Softmax(dim=0) @@ -65,6 +66,7 @@ class CharacterModel(Model): Tuple[str, float]: The predicted character and the confidence in the prediction. """ + self.eval() if image.dtype == np.uint8: # Converts an image with range [0, 255] with to Pytorch Tensor with range [0, 1]. diff --git a/src/text_recognizer/models/line_ctc_model.py b/src/text_recognizer/models/crnn_model.py index 16eaed3..1e01a83 100644 --- a/src/text_recognizer/models/line_ctc_model.py +++ b/src/text_recognizer/models/crnn_model.py @@ -1,4 +1,4 @@ -"""Defines the LineCTCModel class.""" +"""Defines the CRNNModel class.""" from typing import Callable, Dict, Optional, Tuple, Type, Union import numpy as np @@ -13,7 +13,7 @@ from text_recognizer.models.base import Model from text_recognizer.networks import greedy_decoder -class LineCTCModel(Model): +class CRNNModel(Model): """Model for predicting a sequence of characters from an image of a text line.""" def __init__( @@ -47,11 +47,13 @@ class LineCTCModel(Model): swa_args, device, ) + + self.pad_token = dataset_args["args"]["pad_token"] if self._mapper is None: - self._mapper = EmnistMapper() + self._mapper = EmnistMapper(pad_token=self.pad_token,) self.tensor_transform = ToTensor() - def loss_fn(self, output: Tensor, targets: Tensor) -> Tensor: + def criterion(self, output: Tensor, targets: Tensor) -> Tensor: """Computes the CTC loss. Args: @@ -82,11 +84,13 @@ class LineCTCModel(Model): torch.Tensor(target_lengths).type(dtype=torch.long).to(self.device) ) - return self.criterion(output, targets, input_lengths, target_lengths) + return self._criterion(output, targets, input_lengths, target_lengths) @torch.no_grad() def predict_on_image(self, image: Union[np.ndarray, Tensor]) -> Tuple[str, float]: """Predict on a single input.""" + self.eval() + if image.dtype == np.uint8: # Converts an image with range [0, 255] with to Pytorch Tensor with range [0, 1]. image = self.tensor_transform(image) @@ -110,6 +114,6 @@ class LineCTCModel(Model): log_probs, _ = log_probs.max(dim=2) predicted_characters = "".join(raw_pred[0]) - confidence_of_prediction = torch.exp(log_probs.sum()).item() + confidence_of_prediction = log_probs.cumprod(dim=0)[-1].item() return predicted_characters, confidence_of_prediction diff --git a/src/text_recognizer/models/metrics.py b/src/text_recognizer/models/metrics.py index 6a26216..42c3c6e 100644 --- a/src/text_recognizer/models/metrics.py +++ b/src/text_recognizer/models/metrics.py @@ -17,7 +17,10 @@ def accuracy(outputs: Tensor, labels: Tensor) -> float: float: The accuracy for the batch. """ - _, predicted = torch.max(outputs.data, dim=1) + # eos_index = torch.nonzero(labels == eos, as_tuple=False) + # eos_index = eos_index[0].item() if eos_index.nelement() else -1 + + _, predicted = torch.max(outputs, dim=-1) acc = (predicted == labels).sum().float() / labels.shape[0] acc = acc.item() return acc diff --git a/src/text_recognizer/models/transformer_encoder_model.py b/src/text_recognizer/models/transformer_encoder_model.py new file mode 100644 index 0000000..e35e298 --- /dev/null +++ b/src/text_recognizer/models/transformer_encoder_model.py @@ -0,0 +1,111 @@ +"""Defines the CNN-Transformer class.""" +from typing import Callable, Dict, List, Optional, Tuple, Type, Union + +import numpy as np +import torch +from torch import nn +from torch import Tensor +from torch.utils.data import Dataset +from torchvision.transforms import ToTensor + +from text_recognizer.datasets import EmnistMapper +from text_recognizer.models.base import Model + + +class TransformerEncoderModel(Model): + """A class for only using the encoder part in the sequence modelling.""" + + def __init__( + self, + network_fn: Type[nn.Module], + dataset: Type[Dataset], + network_args: Optional[Dict] = None, + dataset_args: Optional[Dict] = None, + metrics: Optional[Dict] = None, + criterion: Optional[Callable] = None, + criterion_args: Optional[Dict] = None, + optimizer: Optional[Callable] = None, + optimizer_args: Optional[Dict] = None, + lr_scheduler: Optional[Callable] = None, + lr_scheduler_args: Optional[Dict] = None, + swa_args: Optional[Dict] = None, + device: Optional[str] = None, + ) -> None: + super().__init__( + network_fn, + dataset, + network_args, + dataset_args, + metrics, + criterion, + criterion_args, + optimizer, + optimizer_args, + lr_scheduler, + lr_scheduler_args, + swa_args, + device, + ) + # self.init_token = dataset_args["args"]["init_token"] + self.pad_token = dataset_args["args"]["pad_token"] + self.eos_token = dataset_args["args"]["eos_token"] + if network_args is not None: + self.max_len = network_args["max_len"] + else: + self.max_len = 128 + + if self._mapper is None: + self._mapper = EmnistMapper( + # init_token=self.init_token, + pad_token=self.pad_token, + eos_token=self.eos_token, + ) + self.tensor_transform = ToTensor() + + self.softmax = nn.Softmax(dim=2) + + @torch.no_grad() + def _generate_sentence(self, image: Tensor) -> Tuple[List, float]: + logits = self.network(image) + # Convert logits to probabilities. + probs = self.softmax(logits).squeeze(0) + + confidence, pred_tokens = probs.max(1) + pred_tokens = pred_tokens + + eos_index = torch.nonzero( + pred_tokens == self._mapper(self.eos_token), as_tuple=False, + ) + + eos_index = eos_index[0].item() if eos_index.nelement() else -1 + + predicted_characters = "".join( + [self.mapper(x) for x in pred_tokens[:eos_index].tolist()] + ) + + confidence = np.min(confidence.tolist()) + + return predicted_characters, confidence + + @torch.no_grad() + def predict_on_image(self, image: Union[np.ndarray, Tensor]) -> Tuple[str, float]: + """Predict on a single input.""" + self.eval() + + if image.dtype == np.uint8: + # Converts an image with range [0, 255] with to Pytorch Tensor with range [0, 1]. + image = self.tensor_transform(image) + + # Rescale image between 0 and 1. + if image.dtype == torch.uint8: + # If the image is an unscaled tensor. + image = image.type("torch.FloatTensor") / 255 + + # Put the image tensor on the device the model weights are on. + image = image.to(self.device) + + (predicted_characters, confidence_of_prediction,) = self._generate_sentence( + image + ) + + return predicted_characters, confidence_of_prediction diff --git a/src/text_recognizer/models/vision_transformer_model.py b/src/text_recognizer/models/vision_transformer_model.py new file mode 100644 index 0000000..3d36437 --- /dev/null +++ b/src/text_recognizer/models/vision_transformer_model.py @@ -0,0 +1,119 @@ +"""Defines the CNN-Transformer class.""" +from typing import Callable, Dict, List, Optional, Tuple, Type, Union + +import numpy as np +import torch +from torch import nn +from torch import Tensor +from torch.utils.data import Dataset +from torchvision.transforms import ToTensor + +from text_recognizer.datasets import EmnistMapper +from text_recognizer.models.base import Model +from text_recognizer.networks import greedy_decoder + + +class VisionTransformerModel(Model): + """Model for predicting a sequence of characters from an image of a text line with a cnn-transformer.""" + + def __init__( + self, + network_fn: Type[nn.Module], + dataset: Type[Dataset], + network_args: Optional[Dict] = None, + dataset_args: Optional[Dict] = None, + metrics: Optional[Dict] = None, + criterion: Optional[Callable] = None, + criterion_args: Optional[Dict] = None, + optimizer: Optional[Callable] = None, + optimizer_args: Optional[Dict] = None, + lr_scheduler: Optional[Callable] = None, + lr_scheduler_args: Optional[Dict] = None, + swa_args: Optional[Dict] = None, + device: Optional[str] = None, + ) -> None: + super().__init__( + network_fn, + dataset, + network_args, + dataset_args, + metrics, + criterion, + criterion_args, + optimizer, + optimizer_args, + lr_scheduler, + lr_scheduler_args, + swa_args, + device, + ) + self.init_token = dataset_args["args"]["init_token"] + self.pad_token = dataset_args["args"]["pad_token"] + self.eos_token = dataset_args["args"]["eos_token"] + if network_args is not None: + self.max_len = network_args["max_len"] + else: + self.max_len = 120 + + if self._mapper is None: + self._mapper = EmnistMapper( + init_token=self.init_token, + pad_token=self.pad_token, + eos_token=self.eos_token, + ) + self.tensor_transform = ToTensor() + + self.softmax = nn.Softmax(dim=2) + + @torch.no_grad() + def _generate_sentence(self, image: Tensor) -> Tuple[List, float]: + src = self.network.preprocess_input(image) + memory = self.network.encoder(src) + + confidence_of_predictions = [] + trg_indices = [self.mapper(self.init_token)] + + for _ in range(self.max_len - 1): + trg = torch.tensor(trg_indices, device=self.device)[None, :].long() + trg = self.network.preprocess_target(trg) + logits = self.network.decoder(trg=trg, memory=memory, trg_mask=None) + + # Convert logits to probabilities. + probs = self.softmax(logits) + + pred_token = probs.argmax(2)[:, -1].item() + confidence = probs.max(2).values[:, -1].item() + + trg_indices.append(pred_token) + confidence_of_predictions.append(confidence) + + if pred_token == self.mapper(self.eos_token): + break + + confidence = np.min(confidence_of_predictions) + predicted_characters = "".join([self.mapper(x) for x in trg_indices[1:]]) + + return predicted_characters, confidence + + @torch.no_grad() + def predict_on_image(self, image: Union[np.ndarray, Tensor]) -> Tuple[str, float]: + """Predict on a single input.""" + self.eval() + + if image.dtype == np.uint8: + # Converts an image with range [0, 255] with to Pytorch Tensor with range [0, 1]. + image = self.tensor_transform(image) + + # Rescale image between 0 and 1. + if image.dtype == torch.uint8: + # If the image is an unscaled tensor. + image = image.type("torch.FloatTensor") / 255 + + # Put the image tensor on the device the model weights are on. + image = image.to(self.device) + + (predicted_characters, confidence_of_prediction,) = self._generate_sentence( + image + ) + + return predicted_characters, confidence_of_prediction diff --git a/src/text_recognizer/networks/__init__.py b/src/text_recognizer/networks/__init__.py index a39975f..6d88768 100644 --- a/src/text_recognizer/networks/__init__.py +++ b/src/text_recognizer/networks/__init__.py @@ -1,21 +1,33 @@ """Network modules.""" +from .cnn_transformer import CNNTransformer +from .cnn_transformer_encoder import CNNTransformerEncoder +from .crnn import ConvolutionalRecurrentNetwork from .ctc import greedy_decoder +from .densenet import DenseNet from .lenet import LeNet -from .line_lstm_ctc import LineRecurrentNetwork -from .losses import EmbeddingLoss -from .misc import sliding_window +from .loss import EmbeddingLoss from .mlp import MLP from .residual_network import ResidualNetwork, ResidualNetworkEncoder +from .sparse_mlp import SparseMLP +from .transformer import Transformer +from .util import sliding_window +from .vision_transformer import VisionTransformer from .wide_resnet import WideResidualNetwork __all__ = [ + "CNNTransformer", + "CNNTransformerEncoder", + "ConvolutionalRecurrentNetwork", + "DenseNet", "EmbeddingLoss", "greedy_decoder", "MLP", "LeNet", - "LineRecurrentNetwork", "ResidualNetwork", "ResidualNetworkEncoder", "sliding_window", + "Transformer", + "SparseMLP", + "VisionTransformer", "WideResidualNetwork", ] diff --git a/src/text_recognizer/networks/cnn_transformer.py b/src/text_recognizer/networks/cnn_transformer.py new file mode 100644 index 0000000..3da2c9f --- /dev/null +++ b/src/text_recognizer/networks/cnn_transformer.py @@ -0,0 +1,135 @@ +"""A DETR style transfomers but for text recognition.""" +from typing import Dict, Optional, Tuple + +from einops import rearrange +import torch +from torch import nn +from torch import Tensor + +from text_recognizer.networks.transformer import PositionalEncoding, Transformer +from text_recognizer.networks.util import configure_backbone + + +class CNNTransformer(nn.Module): + """CNN+Transfomer for image to sequence prediction, sort of based on the ideas from DETR.""" + + def __init__( + self, + num_encoder_layers: int, + num_decoder_layers: int, + hidden_dim: int, + vocab_size: int, + num_heads: int, + adaptive_pool_dim: Tuple, + expansion_dim: int, + dropout_rate: float, + trg_pad_index: int, + backbone: str, + out_channels: int, + max_len: int, + backbone_args: Optional[Dict] = None, + activation: str = "gelu", + ) -> None: + super().__init__() + self.trg_pad_index = trg_pad_index + + self.backbone = configure_backbone(backbone, backbone_args) + self.character_embedding = nn.Embedding(vocab_size, hidden_dim) + + # self.conv = nn.Conv2d(out_channels, max_len, kernel_size=1) + + self.position_encoding = PositionalEncoding(hidden_dim, dropout_rate) + self.row_embed = nn.Parameter(torch.rand(max_len, max_len // 2)) + self.col_embed = nn.Parameter(torch.rand(max_len, max_len // 2)) + + self.adaptive_pool = ( + nn.AdaptiveAvgPool2d((adaptive_pool_dim)) if adaptive_pool_dim else None + ) + + self.transformer = Transformer( + num_encoder_layers, + num_decoder_layers, + hidden_dim, + num_heads, + expansion_dim, + dropout_rate, + activation, + ) + + self.head = nn.Sequential(nn.Linear(hidden_dim, vocab_size),) + + def _create_trg_mask(self, trg: Tensor) -> Tensor: + # Move this outside the transformer. + trg_pad_mask = (trg != self.trg_pad_index)[:, None, None] + trg_len = trg.shape[1] + trg_sub_mask = torch.tril( + torch.ones((trg_len, trg_len), device=trg.device) + ).bool() + trg_mask = trg_pad_mask & trg_sub_mask + return trg_mask + + def encoder(self, src: Tensor) -> Tensor: + """Forward pass with the encoder of the transformer.""" + return self.transformer.encoder(src) + + def decoder(self, trg: Tensor, memory: Tensor, trg_mask: Tensor) -> Tensor: + """Forward pass with the decoder of the transformer + classification head.""" + return self.head( + self.transformer.decoder(trg=trg, memory=memory, trg_mask=trg_mask) + ) + + def preprocess_input(self, src: Tensor) -> Tensor: + """Encodes src with a backbone network and a positional encoding. + + Args: + src (Tensor): Input tensor. + + Returns: + Tensor: A input src to the transformer. + + """ + # If batch dimenstion is missing, it needs to be added. + if len(src.shape) < 4: + src = src[(None,) * (4 - len(src.shape))] + src = self.backbone(src) + # src = self.conv(src) + if self.adaptive_pool is not None: + src = self.adaptive_pool(src) + H, W = src.shape[-2:] + src = rearrange(src, "b t h w -> b t (h w)") + + # construct positional encodings + pos = torch.cat( + [ + self.col_embed[:W].unsqueeze(0).repeat(H, 1, 1), + self.row_embed[:H].unsqueeze(1).repeat(1, W, 1), + ], + dim=-1, + ).unsqueeze(0) + pos = rearrange(pos, "b h w l -> b l (h w)") + src = pos + 0.1 * src + return src + + def preprocess_target(self, trg: Tensor) -> Tuple[Tensor, Tensor]: + """Encodes target tensor with embedding and postion. + + Args: + trg (Tensor): Target tensor. + + Returns: + Tuple[Tensor, Tensor]: Encoded target tensor and target mask. + + """ + trg = self.character_embedding(trg.long()) + trg = self.position_encoding(trg) + return trg + + def forward(self, x: Tensor, trg: Optional[Tensor] = None) -> Tensor: + """Forward pass with CNN transfomer.""" + h = self.preprocess_input(x) + trg_mask = self._create_trg_mask(trg) + trg = self.preprocess_target(trg) + out = self.transformer(h, trg, trg_mask=trg_mask) + + logits = self.head(out) + return logits diff --git a/src/text_recognizer/networks/cnn_transformer_encoder.py b/src/text_recognizer/networks/cnn_transformer_encoder.py new file mode 100644 index 0000000..93626bf --- /dev/null +++ b/src/text_recognizer/networks/cnn_transformer_encoder.py @@ -0,0 +1,73 @@ +"""Network with a CNN backend and a transformer encoder head.""" +from typing import Dict + +from einops import rearrange +import torch +from torch import nn +from torch import Tensor + +from text_recognizer.networks.transformer import PositionalEncoding +from text_recognizer.networks.util import configure_backbone + + +class CNNTransformerEncoder(nn.Module): + """A CNN backbone with Transformer Encoder frontend for sequence prediction.""" + + def __init__( + self, + backbone: str, + backbone_args: Dict, + mlp_dim: int, + d_model: int, + nhead: int = 8, + dropout_rate: float = 0.1, + activation: str = "relu", + num_layers: int = 6, + num_classes: int = 80, + num_channels: int = 256, + max_len: int = 97, + ) -> None: + super().__init__() + self.d_model = d_model + self.nhead = nhead + self.dropout_rate = dropout_rate + self.activation = activation + self.num_layers = num_layers + + self.backbone = configure_backbone(backbone, backbone_args) + self.position_encoding = PositionalEncoding(d_model, dropout_rate) + self.encoder = self._configure_encoder() + + self.conv = nn.Conv2d(num_channels, max_len, kernel_size=1) + + self.mlp = nn.Linear(mlp_dim, d_model) + + self.head = nn.Linear(d_model, num_classes) + + def _configure_encoder(self) -> nn.TransformerEncoder: + encoder_layer = nn.TransformerEncoderLayer( + d_model=self.d_model, + nhead=self.nhead, + dropout=self.dropout_rate, + activation=self.activation, + ) + norm = nn.LayerNorm(self.d_model) + return nn.TransformerEncoder( + encoder_layer=encoder_layer, num_layers=self.num_layers, norm=norm + ) + + def forward(self, x: Tensor, targets: Tensor = None) -> Tensor: + """Forward pass through the network.""" + if len(x.shape) < 4: + x = x[(None,) * (4 - len(x.shape))] + + x = self.conv(self.backbone(x)) + x = rearrange(x, "b c h w -> b c (h w)") + x = self.mlp(x) + x = self.position_encoding(x) + x = rearrange(x, "b c h-> c b h") + x = self.encoder(x) + x = rearrange(x, "c b h-> b c h") + logits = self.head(x) + + return logits diff --git a/src/text_recognizer/networks/crnn.py b/src/text_recognizer/networks/crnn.py new file mode 100644 index 0000000..9747429 --- /dev/null +++ b/src/text_recognizer/networks/crnn.py @@ -0,0 +1,108 @@ +"""LSTM with CTC for handwritten text recognition within a line.""" +from typing import Dict, Tuple + +from einops import rearrange, reduce +from einops.layers.torch import Rearrange +from loguru import logger +from torch import nn +from torch import Tensor + +from text_recognizer.networks.util import configure_backbone + + +class ConvolutionalRecurrentNetwork(nn.Module): + """Network that takes a image of a text line and predicts tokens that are in the image.""" + + def __init__( + self, + backbone: str, + backbone_args: Dict = None, + input_size: int = 128, + hidden_size: int = 128, + bidirectional: bool = False, + num_layers: int = 1, + num_classes: int = 80, + patch_size: Tuple[int, int] = (28, 28), + stride: Tuple[int, int] = (1, 14), + recurrent_cell: str = "lstm", + avg_pool: bool = False, + use_sliding_window: bool = True, + ) -> None: + super().__init__() + self.backbone_args = backbone_args or {} + self.patch_size = patch_size + self.stride = stride + self.sliding_window = ( + self._configure_sliding_window() if use_sliding_window else None + ) + self.input_size = input_size + self.hidden_size = hidden_size + self.backbone = configure_backbone(backbone, backbone_args) + self.bidirectional = bidirectional + self.avg_pool = avg_pool + + if recurrent_cell.upper() in ["LSTM", "GRU"]: + recurrent_cell = getattr(nn, recurrent_cell) + else: + logger.warning( + f"Option {recurrent_cell} not valid, defaulting to LSTM cell." + ) + recurrent_cell = nn.LSTM + + self.rnn = recurrent_cell( + input_size=self.input_size, + hidden_size=self.hidden_size, + bidirectional=bidirectional, + num_layers=num_layers, + ) + + decoder_size = self.hidden_size * 2 if self.bidirectional else self.hidden_size + + self.decoder = nn.Sequential( + nn.Linear(in_features=decoder_size, out_features=num_classes), + nn.LogSoftmax(dim=2), + ) + + def _configure_sliding_window(self) -> nn.Sequential: + return nn.Sequential( + nn.Unfold(kernel_size=self.patch_size, stride=self.stride), + Rearrange( + "b (c h w) t -> b t c h w", + h=self.patch_size[0], + w=self.patch_size[1], + c=1, + ), + ) + + def forward(self, x: Tensor) -> Tensor: + """Converts images to sequence of patches, feeds them to a CNN, then predictions are made with an LSTM.""" + if len(x.shape) < 4: + x = x[(None,) * (4 - len(x.shape))] + + if self.sliding_window is not None: + # Create image patches with a sliding window kernel. + x = self.sliding_window(x) + + # Rearrange from a sequence of patches for feedforward network. + b, t = x.shape[:2] + x = rearrange(x, "b t c h w -> (b t) c h w", b=b, t=t) + + x = self.backbone(x) + + # Avgerage pooling. + if self.avg_pool: + x = reduce(x, "(b t) c h w -> t b c", "mean", b=b, t=t) + else: + x = rearrange(x, "(b t) h -> t b h", b=b, t=t) + else: + # Encode the entire image with a CNN, and use the channels as temporal dimension. + b = x.shape[0] + x = self.backbone(x) + x = rearrange(x, "b c h w -> c b (h w)", b=b) + + # Sequence predictions. + x, _ = self.rnn(x) + + # Sequence to classifcation layer. + x = self.decoder(x) + return x diff --git a/src/text_recognizer/networks/ctc.py b/src/text_recognizer/networks/ctc.py index 2493d5c..af9b700 100644 --- a/src/text_recognizer/networks/ctc.py +++ b/src/text_recognizer/networks/ctc.py @@ -33,7 +33,7 @@ def greedy_decoder( """ if character_mapper is None: - character_mapper = EmnistMapper() + character_mapper = EmnistMapper(pad_token="_") # noqa: S106 predictions = rearrange(torch.argmax(predictions, dim=2), "t b -> b t") decoded_predictions = [] diff --git a/src/text_recognizer/networks/densenet.py b/src/text_recognizer/networks/densenet.py new file mode 100644 index 0000000..7dc58d9 --- /dev/null +++ b/src/text_recognizer/networks/densenet.py @@ -0,0 +1,225 @@ +"""Defines a Densely Connected Convolutional Networks in PyTorch. + +Sources: +https://arxiv.org/abs/1608.06993 +https://github.com/pytorch/vision/blob/master/torchvision/models/densenet.py + +""" +from typing import List, Optional, Union + +from einops.layers.torch import Rearrange +import torch +from torch import nn +from torch import Tensor + +from text_recognizer.networks.util import activation_function + + +class _DenseLayer(nn.Module): + """A dense layer with pre-batch norm -> activation function -> Conv-layer x 2.""" + + def __init__( + self, + in_channels: int, + growth_rate: int, + bn_size: int, + dropout_rate: float, + activation: str = "relu", + ) -> None: + super().__init__() + activation_fn = activation_function(activation) + self.dense_layer = [ + nn.BatchNorm2d(in_channels), + activation_fn, + nn.Conv2d( + in_channels=in_channels, + out_channels=bn_size * growth_rate, + kernel_size=1, + stride=1, + bias=False, + ), + nn.BatchNorm2d(bn_size * growth_rate), + activation_fn, + nn.Conv2d( + in_channels=bn_size * growth_rate, + out_channels=growth_rate, + kernel_size=3, + stride=1, + padding=1, + bias=False, + ), + ] + if dropout_rate: + self.dense_layer.append(nn.Dropout(p=dropout_rate)) + + self.dense_layer = nn.Sequential(*self.dense_layer) + + def forward(self, x: Union[Tensor, List[Tensor]]) -> Tensor: + if isinstance(x, list): + x = torch.cat(x, 1) + return self.dense_layer(x) + + +class _DenseBlock(nn.Module): + def __init__( + self, + num_layers: int, + in_channels: int, + bn_size: int, + growth_rate: int, + dropout_rate: float, + activation: str = "relu", + ) -> None: + super().__init__() + self.dense_block = self._build_dense_blocks( + num_layers, in_channels, bn_size, growth_rate, dropout_rate, activation, + ) + + def _build_dense_blocks( + self, + num_layers: int, + in_channels: int, + bn_size: int, + growth_rate: int, + dropout_rate: float, + activation: str = "relu", + ) -> nn.ModuleList: + dense_block = [] + for i in range(num_layers): + dense_block.append( + _DenseLayer( + in_channels=in_channels + i * growth_rate, + growth_rate=growth_rate, + bn_size=bn_size, + dropout_rate=dropout_rate, + activation=activation, + ) + ) + return nn.ModuleList(dense_block) + + def forward(self, x: Tensor) -> Tensor: + feature_maps = [x] + for layer in self.dense_block: + x = layer(feature_maps) + feature_maps.append(x) + return torch.cat(feature_maps, 1) + + +class _Transition(nn.Module): + def __init__( + self, in_channels: int, out_channels: int, activation: str = "relu", + ) -> None: + super().__init__() + activation_fn = activation_function(activation) + self.transition = nn.Sequential( + nn.BatchNorm2d(in_channels), + activation_fn, + nn.Conv2d( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=1, + stride=1, + bias=False, + ), + nn.AvgPool2d(kernel_size=2, stride=2), + ) + + def forward(self, x: Tensor) -> Tensor: + return self.transition(x) + + +class DenseNet(nn.Module): + """Implementation of Densenet, a network archtecture that concats previous layers for maximum infomation flow.""" + + def __init__( + self, + growth_rate: int = 32, + block_config: List[int] = (6, 12, 24, 16), + in_channels: int = 1, + base_channels: int = 64, + num_classes: int = 80, + bn_size: int = 4, + dropout_rate: float = 0, + classifier: bool = True, + activation: str = "relu", + ) -> None: + super().__init__() + self.densenet = self._configure_densenet( + in_channels, + base_channels, + num_classes, + growth_rate, + block_config, + bn_size, + dropout_rate, + classifier, + activation, + ) + + def _configure_densenet( + self, + in_channels: int, + base_channels: int, + num_classes: int, + growth_rate: int, + block_config: List[int], + bn_size: int, + dropout_rate: float, + classifier: bool, + activation: str, + ) -> nn.Sequential: + activation_fn = activation_function(activation) + densenet = [ + nn.Conv2d( + in_channels=in_channels, + out_channels=base_channels, + kernel_size=3, + stride=1, + padding=1, + bias=False, + ), + nn.BatchNorm2d(base_channels), + activation_fn, + ] + + num_features = base_channels + + for i, num_layers in enumerate(block_config): + densenet.append( + _DenseBlock( + num_layers=num_layers, + in_channels=num_features, + bn_size=bn_size, + growth_rate=growth_rate, + dropout_rate=dropout_rate, + activation=activation, + ) + ) + num_features = num_features + num_layers * growth_rate + if i != len(block_config) - 1: + densenet.append( + _Transition( + in_channels=num_features, + out_channels=num_features // 2, + activation=activation, + ) + ) + num_features = num_features // 2 + + densenet.append(activation_fn) + + if classifier: + densenet.append(nn.AdaptiveAvgPool2d((1, 1))) + densenet.append(Rearrange("b c h w -> b (c h w)")) + densenet.append( + nn.Linear(in_features=num_features, out_features=num_classes) + ) + + return nn.Sequential(*densenet) + + def forward(self, x: Tensor) -> Tensor: + """Forward pass of Densenet.""" + # If batch dimenstion is missing, it will be added. + if len(x.shape) < 4: + x = x[(None,) * (4 - len(x.shape))] + return self.densenet(x) diff --git a/src/text_recognizer/networks/lenet.py b/src/text_recognizer/networks/lenet.py index 53c575e..527e1a0 100644 --- a/src/text_recognizer/networks/lenet.py +++ b/src/text_recognizer/networks/lenet.py @@ -5,7 +5,7 @@ from einops.layers.torch import Rearrange import torch from torch import nn -from text_recognizer.networks.misc import activation_function +from text_recognizer.networks.util import activation_function class LeNet(nn.Module): @@ -63,6 +63,6 @@ class LeNet(nn.Module): def forward(self, x: torch.Tensor) -> torch.Tensor: """The feedforward pass.""" # If batch dimenstion is missing, it needs to be added. - if len(x.shape) == 3: - x = x.unsqueeze(0) + if len(x.shape) < 4: + x = x[(None,) * (4 - len(x.shape))] return self.layers(x) diff --git a/src/text_recognizer/networks/line_lstm_ctc.py b/src/text_recognizer/networks/line_lstm_ctc.py deleted file mode 100644 index 9009f94..0000000 --- a/src/text_recognizer/networks/line_lstm_ctc.py +++ /dev/null @@ -1,120 +0,0 @@ -"""LSTM with CTC for handwritten text recognition within a line.""" -import importlib -from pathlib import Path -from typing import Callable, Dict, List, Optional, Tuple, Type, Union - -from einops import rearrange, reduce -from einops.layers.torch import Rearrange, Reduce -from loguru import logger -import torch -from torch import nn -from torch import Tensor - - -class LineRecurrentNetwork(nn.Module): - """Network that takes a image of a text line and predicts tokens that are in the image.""" - - def __init__( - self, - backbone: str, - backbone_args: Dict = None, - flatten: bool = True, - input_size: int = 128, - hidden_size: int = 128, - bidirectional: bool = False, - num_layers: int = 1, - num_classes: int = 80, - patch_size: Tuple[int, int] = (28, 28), - stride: Tuple[int, int] = (1, 14), - ) -> None: - super().__init__() - self.backbone_args = backbone_args or {} - self.patch_size = patch_size - self.stride = stride - self.sliding_window = self._configure_sliding_window() - self.input_size = input_size - self.hidden_size = hidden_size - self.backbone = self._configure_backbone(backbone) - self.bidirectional = bidirectional - self.flatten = flatten - - if self.flatten: - self.fc = nn.Linear( - in_features=self.input_size, out_features=self.hidden_size - ) - - self.rnn = nn.LSTM( - input_size=self.hidden_size, - hidden_size=self.hidden_size, - bidirectional=bidirectional, - num_layers=num_layers, - ) - - decoder_size = self.hidden_size * 2 if self.bidirectional else self.hidden_size - - self.decoder = nn.Sequential( - nn.Linear(in_features=decoder_size, out_features=num_classes), - nn.LogSoftmax(dim=2), - ) - - def _configure_backbone(self, backbone: str) -> Type[nn.Module]: - network_module = importlib.import_module("text_recognizer.networks") - backbone_ = getattr(network_module, backbone) - - if "pretrained" in self.backbone_args: - logger.info("Loading pretrained backbone.") - checkpoint_file = Path(__file__).resolve().parents[ - 2 - ] / self.backbone_args.pop("pretrained") - - # Loading state directory. - state_dict = torch.load(checkpoint_file) - network_args = state_dict["network_args"] - weights = state_dict["model_state"] - - # Initializes the network with trained weights. - backbone = backbone_(**network_args) - backbone.load_state_dict(weights) - if "freeze" in self.backbone_args and self.backbone_args["freeze"] is True: - for params in backbone.parameters(): - params.requires_grad = False - - return backbone - else: - return backbone_(**self.backbone_args) - - def _configure_sliding_window(self) -> nn.Sequential: - return nn.Sequential( - nn.Unfold(kernel_size=self.patch_size, stride=self.stride), - Rearrange( - "b (c h w) t -> b t c h w", - h=self.patch_size[0], - w=self.patch_size[1], - c=1, - ), - ) - - def forward(self, x: Tensor) -> Tensor: - """Converts images to sequence of patches, feeds them to a CNN, then predictions are made with an LSTM.""" - if len(x.shape) == 3: - x = x.unsqueeze(0) - x = self.sliding_window(x) - - # Rearrange from a sequence of patches for feedforward network. - b, t = x.shape[:2] - x = rearrange(x, "b t c h w -> (b t) c h w", b=b, t=t) - x = self.backbone(x) - - # Avgerage pooling. - x = ( - self.fc(reduce(x, "(b t) c h w -> t b c", "mean", b=b, t=t)) - if self.flatten - else rearrange(x, "(b t) h -> t b h", b=b, t=t) - ) - - # Sequence predictions. - x, _ = self.rnn(x) - - # Sequence to classifcation layer. - x = self.decoder(x) - return x diff --git a/src/text_recognizer/networks/loss.py b/src/text_recognizer/networks/loss.py new file mode 100644 index 0000000..cf9fa0d --- /dev/null +++ b/src/text_recognizer/networks/loss.py @@ -0,0 +1,69 @@ +"""Implementations of custom loss functions.""" +from pytorch_metric_learning import distances, losses, miners, reducers +import torch +from torch import nn +from torch import Tensor +from torch.autograd import Variable +import torch.nn.functional as F + +__all__ = ["EmbeddingLoss", "LabelSmoothingCrossEntropy"] + + +class EmbeddingLoss: + """Metric loss for training encoders to produce information-rich latent embeddings.""" + + def __init__(self, margin: float = 0.2, type_of_triplets: str = "semihard") -> None: + self.distance = distances.CosineSimilarity() + self.reducer = reducers.ThresholdReducer(low=0) + self.loss_fn = losses.TripletMarginLoss( + margin=margin, distance=self.distance, reducer=self.reducer + ) + self.miner = miners.MultiSimilarityMiner(epsilon=margin, distance=self.distance) + + def __call__(self, embeddings: Tensor, labels: Tensor) -> Tensor: + """Computes the metric loss for the embeddings based on their labels. + + Args: + embeddings (Tensor): The laten vectors encoded by the network. + labels (Tensor): Labels of the embeddings. + + Returns: + Tensor: The metric loss for the embeddings. + + """ + hard_pairs = self.miner(embeddings, labels) + loss = self.loss_fn(embeddings, labels, hard_pairs) + return loss + + +class LabelSmoothingCrossEntropy(nn.Module): + """Label smoothing loss function.""" + + def __init__( + self, + classes: int, + smoothing: float = 0.0, + ignore_index: int = None, + dim: int = -1, + ) -> None: + super().__init__() + self.confidence = 1.0 - smoothing + self.smoothing = smoothing + self.ignore_index = ignore_index + self.cls = classes + self.dim = dim + + def forward(self, pred: Tensor, target: Tensor) -> Tensor: + """Calculates the loss.""" + pred = pred.log_softmax(dim=self.dim) + with torch.no_grad(): + # true_dist = pred.data.clone() + true_dist = torch.zeros_like(pred) + true_dist.fill_(self.smoothing / (self.cls - 1)) + true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence) + if self.ignore_index is not None: + true_dist[:, self.ignore_index] = 0 + mask = torch.nonzero(target == self.ignore_index, as_tuple=False) + if mask.dim() > 0: + true_dist.index_fill_(0, mask.squeeze(), 0.0) + return torch.mean(torch.sum(-true_dist * pred, dim=self.dim)) diff --git a/src/text_recognizer/networks/losses.py b/src/text_recognizer/networks/losses.py deleted file mode 100644 index 73e0641..0000000 --- a/src/text_recognizer/networks/losses.py +++ /dev/null @@ -1,31 +0,0 @@ -"""Implementations of custom loss functions.""" -from pytorch_metric_learning import distances, losses, miners, reducers -from torch import nn -from torch import Tensor - - -class EmbeddingLoss: - """Metric loss for training encoders to produce information-rich latent embeddings.""" - - def __init__(self, margin: float = 0.2, type_of_triplets: str = "semihard") -> None: - self.distance = distances.CosineSimilarity() - self.reducer = reducers.ThresholdReducer(low=0) - self.loss_fn = losses.TripletMarginLoss( - margin=margin, distance=self.distance, reducer=self.reducer - ) - self.miner = miners.MultiSimilarityMiner(epsilon=margin, distance=self.distance) - - def __call__(self, embeddings: Tensor, labels: Tensor) -> Tensor: - """Computes the metric loss for the embeddings based on their labels. - - Args: - embeddings (Tensor): The laten vectors encoded by the network. - labels (Tensor): Labels of the embeddings. - - Returns: - Tensor: The metric loss for the embeddings. - - """ - hard_pairs = self.miner(embeddings, labels) - loss = self.loss_fn(embeddings, labels, hard_pairs) - return loss diff --git a/src/text_recognizer/networks/mlp.py b/src/text_recognizer/networks/mlp.py index d66af28..1101912 100644 --- a/src/text_recognizer/networks/mlp.py +++ b/src/text_recognizer/networks/mlp.py @@ -5,7 +5,7 @@ from einops.layers.torch import Rearrange import torch from torch import nn -from text_recognizer.networks.misc import activation_function +from text_recognizer.networks.util import activation_function class MLP(nn.Module): @@ -63,8 +63,8 @@ class MLP(nn.Module): def forward(self, x: torch.Tensor) -> torch.Tensor: """The feedforward pass.""" # If batch dimenstion is missing, it needs to be added. - if len(x.shape) == 3: - x = x.unsqueeze(0) + if len(x.shape) < 4: + x = x[(None,) * (4 - len(x.shape))] return self.layers(x) @property diff --git a/src/text_recognizer/networks/residual_network.py b/src/text_recognizer/networks/residual_network.py index 046600d..6405192 100644 --- a/src/text_recognizer/networks/residual_network.py +++ b/src/text_recognizer/networks/residual_network.py @@ -7,8 +7,8 @@ import torch from torch import nn from torch import Tensor -from text_recognizer.networks.misc import activation_function from text_recognizer.networks.stn import SpatialTransformerNetwork +from text_recognizer.networks.util import activation_function class Conv2dAuto(nn.Conv2d): @@ -225,8 +225,8 @@ class ResidualNetworkEncoder(nn.Module): in_channels=in_channels, out_channels=self.block_sizes[0], kernel_size=3, - stride=2, - padding=3, + stride=1, + padding=1, bias=False, ), nn.BatchNorm2d(self.block_sizes[0]), diff --git a/src/text_recognizer/networks/sparse_mlp.py b/src/text_recognizer/networks/sparse_mlp.py new file mode 100644 index 0000000..53cf166 --- /dev/null +++ b/src/text_recognizer/networks/sparse_mlp.py @@ -0,0 +1,78 @@ +"""Defines the Sparse MLP network.""" +from typing import Callable, Dict, List, Optional, Union +import warnings + +from einops.layers.torch import Rearrange +from pytorch_block_sparse import BlockSparseLinear +import torch +from torch import nn + +from text_recognizer.networks.util import activation_function + +warnings.filterwarnings("ignore", category=DeprecationWarning) + + +class SparseMLP(nn.Module): + """Sparse multi layered perceptron network.""" + + def __init__( + self, + input_size: int = 784, + num_classes: int = 10, + hidden_size: Union[int, List] = 128, + num_layers: int = 3, + density: float = 0.1, + activation_fn: str = "relu", + ) -> None: + """Initialization of the MLP network. + + Args: + input_size (int): The input shape of the network. Defaults to 784. + num_classes (int): Number of classes in the dataset. Defaults to 10. + hidden_size (Union[int, List]): The number of `neurons` in each hidden layer. Defaults to 128. + num_layers (int): The number of hidden layers. Defaults to 3. + density (float): The density of activation at each layer. Default to 0.1. + activation_fn (str): Name of the activation function in the hidden layers. Defaults to + relu. + + """ + super().__init__() + + activation_fn = activation_function(activation_fn) + + if isinstance(hidden_size, int): + hidden_size = [hidden_size] * num_layers + + self.layers = [ + Rearrange("b c h w -> b (c h w)"), + nn.Linear(in_features=input_size, out_features=hidden_size[0]), + activation_fn, + ] + + for i in range(num_layers - 1): + self.layers += [ + BlockSparseLinear( + in_features=hidden_size[i], + out_features=hidden_size[i + 1], + density=density, + ), + activation_fn, + ] + + self.layers.append( + nn.Linear(in_features=hidden_size[-1], out_features=num_classes) + ) + + self.layers = nn.Sequential(*self.layers) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """The feedforward pass.""" + # If batch dimenstion is missing, it needs to be added. + if len(x.shape) < 4: + x = x[(None,) * (4 - len(x.shape))] + return self.layers(x) + + @property + def __name__(self) -> str: + """Returns the name of the network.""" + return "mlp" diff --git a/src/text_recognizer/networks/transformer.py b/src/text_recognizer/networks/transformer.py deleted file mode 100644 index c091ba0..0000000 --- a/src/text_recognizer/networks/transformer.py +++ /dev/null @@ -1,5 +0,0 @@ -"""TBC.""" -from typing import Dict - -import torch -from torch import Tensor diff --git a/src/text_recognizer/networks/transformer/__init__.py b/src/text_recognizer/networks/transformer/__init__.py new file mode 100644 index 0000000..020a917 --- /dev/null +++ b/src/text_recognizer/networks/transformer/__init__.py @@ -0,0 +1,3 @@ +"""Transformer modules.""" +from .positional_encoding import PositionalEncoding +from .transformer import Decoder, Encoder, Transformer diff --git a/src/text_recognizer/networks/transformer/attention.py b/src/text_recognizer/networks/transformer/attention.py new file mode 100644 index 0000000..cce1ecc --- /dev/null +++ b/src/text_recognizer/networks/transformer/attention.py @@ -0,0 +1,93 @@ +"""Implementes the attention module for the transformer.""" +from typing import Optional, Tuple + +from einops import rearrange +import numpy as np +import torch +from torch import nn +from torch import Tensor + + +class MultiHeadAttention(nn.Module): + """Implementation of multihead attention.""" + + def __init__( + self, hidden_dim: int, num_heads: int = 8, dropout_rate: float = 0.0 + ) -> None: + super().__init__() + self.hidden_dim = hidden_dim + self.num_heads = num_heads + self.fc_q = nn.Linear( + in_features=hidden_dim, out_features=hidden_dim, bias=False + ) + self.fc_k = nn.Linear( + in_features=hidden_dim, out_features=hidden_dim, bias=False + ) + self.fc_v = nn.Linear( + in_features=hidden_dim, out_features=hidden_dim, bias=False + ) + self.fc_out = nn.Linear(in_features=hidden_dim, out_features=hidden_dim) + + self._init_weights() + + self.dropout = nn.Dropout(p=dropout_rate) + + def _init_weights(self) -> None: + nn.init.normal_( + self.fc_q.weight, + mean=0, + std=np.sqrt(self.hidden_dim + int(self.hidden_dim / self.num_heads)), + ) + nn.init.normal_( + self.fc_k.weight, + mean=0, + std=np.sqrt(self.hidden_dim + int(self.hidden_dim / self.num_heads)), + ) + nn.init.normal_( + self.fc_v.weight, + mean=0, + std=np.sqrt(self.hidden_dim + int(self.hidden_dim / self.num_heads)), + ) + nn.init.xavier_normal_(self.fc_out.weight) + + def scaled_dot_product_attention( + self, query: Tensor, key: Tensor, value: Tensor, mask: Optional[Tensor] = None + ) -> Tensor: + """Calculates the scaled dot product attention.""" + + # Compute the energy. + energy = torch.einsum("bhlk,bhtk->bhlt", [query, key]) / np.sqrt( + query.shape[-1] + ) + + # If we have a mask for padding some inputs. + if mask is not None: + energy = energy.masked_fill(mask == 0, -np.inf) + + # Compute the attention from the energy. + attention = torch.softmax(energy, dim=3) + + out = torch.einsum("bhlt,bhtv->bhlv", [attention, value]) + out = rearrange(out, "b head l v -> b l (head v)") + return out, attention + + def forward( + self, query: Tensor, key: Tensor, value: Tensor, mask: Optional[Tensor] = None + ) -> Tuple[Tensor, Tensor]: + """Forward pass for computing the multihead attention.""" + # Get the query, key, and value tensor. + query = rearrange( + self.fc_q(query), "b l (head k) -> b head l k", head=self.num_heads + ) + key = rearrange( + self.fc_k(key), "b t (head k) -> b head t k", head=self.num_heads + ) + value = rearrange( + self.fc_v(value), "b t (head v) -> b head t v", head=self.num_heads + ) + + out, attention = self.scaled_dot_product_attention(query, key, value, mask) + + out = self.fc_out(out) + out = self.dropout(out) + return out, attention diff --git a/src/text_recognizer/networks/transformer/positional_encoding.py b/src/text_recognizer/networks/transformer/positional_encoding.py new file mode 100644 index 0000000..1ba5537 --- /dev/null +++ b/src/text_recognizer/networks/transformer/positional_encoding.py @@ -0,0 +1,32 @@ +"""A positional encoding for the image features, as the transformer has no notation of the order of the sequence.""" +import numpy as np +import torch +from torch import nn +from torch import Tensor + + +class PositionalEncoding(nn.Module): + """Encodes a sense of distance or time for transformer networks.""" + + def __init__( + self, hidden_dim: int, dropout_rate: float, max_len: int = 1000 + ) -> None: + super().__init__() + self.dropout = nn.Dropout(p=dropout_rate) + self.max_len = max_len + + pe = torch.zeros(max_len, hidden_dim) + position = torch.arange(0, max_len).unsqueeze(1) + div_term = torch.exp( + torch.arange(0, hidden_dim, 2) * -(np.log(10000.0) / hidden_dim) + ) + + pe[:, 0::2] = torch.sin(position * div_term) + pe[:, 1::2] = torch.cos(position * div_term) + pe = pe.unsqueeze(0) + self.register_buffer("pe", pe) + + def forward(self, x: Tensor) -> Tensor: + """Encodes the tensor with a postional embedding.""" + x = x + self.pe[:, : x.shape[1]] + return self.dropout(x) diff --git a/src/text_recognizer/networks/transformer/transformer.py b/src/text_recognizer/networks/transformer/transformer.py new file mode 100644 index 0000000..c6e943e --- /dev/null +++ b/src/text_recognizer/networks/transformer/transformer.py @@ -0,0 +1,242 @@ +"""Transfomer module.""" +import copy +from typing import Dict, Optional, Type, Union + +import numpy as np +import torch +from torch import nn +from torch import Tensor + +from text_recognizer.networks.transformer.attention import MultiHeadAttention +from text_recognizer.networks.util import activation_function + + +def _get_clones(module: Type[nn.Module], num_layers: int) -> nn.ModuleList: + return nn.ModuleList([copy.deepcopy(module) for _ in range(num_layers)]) + + +class _IntraLayerConnection(nn.Module): + """Preforms the residual connection inside the transfomer blocks and applies layernorm.""" + + def __init__(self, dropout_rate: float, hidden_dim: int) -> None: + super().__init__() + self.norm = nn.LayerNorm(normalized_shape=hidden_dim) + self.dropout = nn.Dropout(p=dropout_rate) + + def forward(self, src: Tensor, residual: Tensor) -> Tensor: + return self.norm(self.dropout(src) + residual) + + +class _ConvolutionalLayer(nn.Module): + def __init__( + self, + hidden_dim: int, + expansion_dim: int, + dropout_rate: float, + activation: str = "relu", + ) -> None: + super().__init__() + self.layer = nn.Sequential( + nn.Linear(in_features=hidden_dim, out_features=expansion_dim), + activation_function(activation), + nn.Dropout(p=dropout_rate), + nn.Linear(in_features=expansion_dim, out_features=hidden_dim), + ) + + def forward(self, x: Tensor) -> Tensor: + return self.layer(x) + + +class EncoderLayer(nn.Module): + """Transfomer encoding layer.""" + + def __init__( + self, + hidden_dim: int, + num_heads: int, + expansion_dim: int, + dropout_rate: float, + activation: str = "relu", + ) -> None: + super().__init__() + self.self_attention = MultiHeadAttention(hidden_dim, num_heads, dropout_rate) + self.cnn = _ConvolutionalLayer( + hidden_dim, expansion_dim, dropout_rate, activation + ) + self.block1 = _IntraLayerConnection(dropout_rate, hidden_dim) + self.block2 = _IntraLayerConnection(dropout_rate, hidden_dim) + + def forward(self, src: Tensor, mask: Optional[Tensor] = None) -> Tensor: + """Forward pass through the encoder.""" + # First block. + # Multi head attention. + out, _ = self.self_attention(src, src, src, mask) + + # Add & norm. + out = self.block1(out, src) + + # Second block. + # Apply 1D-convolution. + cnn_out = self.cnn(out) + + # Add & norm. + out = self.block2(cnn_out, out) + + return out + + +class Encoder(nn.Module): + """Transfomer encoder module.""" + + def __init__( + self, + num_layers: int, + encoder_layer: Type[nn.Module], + norm: Optional[Type[nn.Module]] = None, + ) -> None: + super().__init__() + self.layers = _get_clones(encoder_layer, num_layers) + self.norm = norm + + def forward(self, src: Tensor, src_mask: Optional[Tensor] = None) -> Tensor: + """Forward pass through all encoder layers.""" + for layer in self.layers: + src = layer(src, src_mask) + + if self.norm is not None: + src = self.norm(src) + + return src + + +class DecoderLayer(nn.Module): + """Transfomer decoder layer.""" + + def __init__( + self, + hidden_dim: int, + num_heads: int, + expansion_dim: int, + dropout_rate: float = 0.0, + activation: str = "relu", + ) -> None: + super().__init__() + self.hidden_dim = hidden_dim + self.self_attention = MultiHeadAttention(hidden_dim, num_heads, dropout_rate) + self.multihead_attention = MultiHeadAttention( + hidden_dim, num_heads, dropout_rate + ) + self.cnn = _ConvolutionalLayer( + hidden_dim, expansion_dim, dropout_rate, activation + ) + self.block1 = _IntraLayerConnection(dropout_rate, hidden_dim) + self.block2 = _IntraLayerConnection(dropout_rate, hidden_dim) + self.block3 = _IntraLayerConnection(dropout_rate, hidden_dim) + + def forward( + self, + trg: Tensor, + memory: Tensor, + trg_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + ) -> Tensor: + """Forward pass of the layer.""" + out, _ = self.self_attention(trg, trg, trg, trg_mask) + trg = self.block1(out, trg) + + out, _ = self.multihead_attention(trg, memory, memory, memory_mask) + trg = self.block2(out, trg) + + out = self.cnn(trg) + out = self.block3(out, trg) + + return out + + +class Decoder(nn.Module): + """Transfomer decoder module.""" + + def __init__( + self, + decoder_layer: Type[nn.Module], + num_layers: int, + norm: Optional[Type[nn.Module]] = None, + ) -> None: + super().__init__() + self.layers = _get_clones(decoder_layer, num_layers) + self.num_layers = num_layers + self.norm = norm + + def forward( + self, + trg: Tensor, + memory: Tensor, + trg_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + ) -> Tensor: + """Forward pass through the decoder.""" + for layer in self.layers: + trg = layer(trg, memory, trg_mask, memory_mask) + + if self.norm is not None: + trg = self.norm(trg) + + return trg + + +class Transformer(nn.Module): + """Transformer network.""" + + def __init__( + self, + num_encoder_layers: int, + num_decoder_layers: int, + hidden_dim: int, + num_heads: int, + expansion_dim: int, + dropout_rate: float, + activation: str = "relu", + ) -> None: + super().__init__() + + # Configure encoder. + encoder_norm = nn.LayerNorm(hidden_dim) + encoder_layer = EncoderLayer( + hidden_dim, num_heads, expansion_dim, dropout_rate, activation + ) + self.encoder = Encoder(num_encoder_layers, encoder_layer, encoder_norm) + + # Configure decoder. + decoder_norm = nn.LayerNorm(hidden_dim) + decoder_layer = DecoderLayer( + hidden_dim, num_heads, expansion_dim, dropout_rate, activation + ) + self.decoder = Decoder(decoder_layer, num_decoder_layers, decoder_norm) + + self._reset_parameters() + + def _reset_parameters(self) -> None: + for p in self.parameters(): + if p.dim() > 1: + nn.init.xavier_uniform_(p) + + def forward( + self, + src: Tensor, + trg: Tensor, + src_mask: Optional[Tensor] = None, + trg_mask: Optional[Tensor] = None, + memory_mask: Optional[Tensor] = None, + ) -> Tensor: + """Forward pass through the transformer.""" + if src.shape[0] != trg.shape[0]: + print(trg.shape) + raise RuntimeError("The batch size of the src and trg must be the same.") + if src.shape[2] != trg.shape[2]: + raise RuntimeError( + "The number of features for the src and trg must be the same." + ) + + memory = self.encoder(src, src_mask) + output = self.decoder(trg, memory, trg_mask, memory_mask) + return output diff --git a/src/text_recognizer/networks/misc.py b/src/text_recognizer/networks/util.py index 1f853e9..b31e640 100644 --- a/src/text_recognizer/networks/misc.py +++ b/src/text_recognizer/networks/util.py @@ -1,7 +1,10 @@ """Miscellaneous neural network functionality.""" -from typing import Tuple, Type +import importlib +from pathlib import Path +from typing import Dict, Tuple, Type from einops import rearrange +from loguru import logger import torch from torch import nn @@ -25,7 +28,7 @@ def sliding_window( c = images.shape[1] patches = unfold(images) patches = rearrange( - patches, "b (c h w) t -> b t c h w", c=c, h=patch_size[0], w=patch_size[1] + patches, "b (c h w) t -> b t c h w", c=c, h=patch_size[0], w=patch_size[1], ) return patches @@ -43,3 +46,38 @@ def activation_function(activation: str) -> Type[nn.Module]: ] ) return activation_fns[activation.lower()] + + +def configure_backbone(backbone: str, backbone_args: Dict) -> Type[nn.Module]: + """Loads a backbone network.""" + network_module = importlib.import_module("text_recognizer.networks") + backbone_ = getattr(network_module, backbone) + + if "pretrained" in backbone_args: + logger.info("Loading pretrained backbone.") + checkpoint_file = Path(__file__).resolve().parents[2] / backbone_args.pop( + "pretrained" + ) + + # Loading state directory. + state_dict = torch.load(checkpoint_file) + network_args = state_dict["network_args"] + weights = state_dict["model_state"] + + # Initializes the network with trained weights. + backbone = backbone_(**network_args) + backbone.load_state_dict(weights) + if "freeze" in backbone_args and backbone_args["freeze"] is True: + for params in backbone.parameters(): + params.requires_grad = False + + else: + backbone_ = getattr(network_module, backbone) + backbone = backbone_(**backbone_args) + + if "remove_layers" in backbone_args and backbone_args["remove_layers"] is not None: + backbone = nn.Sequential( + *list(backbone.children())[:][: -backbone_args["remove_layers"]] + ) + + return backbone diff --git a/src/text_recognizer/networks/vision_transformer.py b/src/text_recognizer/networks/vision_transformer.py new file mode 100644 index 0000000..f227954 --- /dev/null +++ b/src/text_recognizer/networks/vision_transformer.py @@ -0,0 +1,159 @@ +"""VisionTransformer module. + +Splits each image into patches and feeds them to a transformer. + +""" + +from typing import Dict, Optional, Tuple, Type + +from einops import rearrange, reduce +from einops.layers.torch import Rearrange +from loguru import logger +import torch +from torch import nn +from torch import Tensor + +from text_recognizer.networks.transformer import PositionalEncoding, Transformer +from text_recognizer.networks.util import configure_backbone + + +class VisionTransformer(nn.Module): + """Linear projection+Transfomer for image to sequence prediction, sort of based on the ideas from ViT.""" + + def __init__( + self, + num_encoder_layers: int, + num_decoder_layers: int, + hidden_dim: int, + vocab_size: int, + num_heads: int, + max_len: int, + expansion_dim: int, + dropout_rate: float, + trg_pad_index: int, + mlp_dim: Optional[int] = None, + patch_size: Tuple[int, int] = (28, 28), + stride: Tuple[int, int] = (1, 14), + activation: str = "gelu", + backbone: Optional[str] = None, + backbone_args: Optional[Dict] = None, + ) -> None: + super().__init__() + + self.patch_size = patch_size + self.stride = stride + self.trg_pad_index = trg_pad_index + self.slidning_window = self._configure_sliding_window() + self.character_embedding = nn.Embedding(vocab_size, hidden_dim) + self.position_encoding = PositionalEncoding(hidden_dim, dropout_rate, max_len) + self.mlp_dim = mlp_dim + + self.use_backbone = False + if backbone is None: + self.linear_projection = nn.Linear( + self.patch_size[0] * self.patch_size[1], hidden_dim + ) + else: + self.backbone = configure_backbone(backbone, backbone_args) + if mlp_dim: + self.mlp = nn.Linear(mlp_dim, hidden_dim) + self.use_backbone = True + + self.transformer = Transformer( + num_encoder_layers, + num_decoder_layers, + hidden_dim, + num_heads, + expansion_dim, + dropout_rate, + activation, + ) + + self.head = nn.Sequential(nn.Linear(hidden_dim, vocab_size),) + + def _configure_sliding_window(self) -> nn.Sequential: + return nn.Sequential( + nn.Unfold(kernel_size=self.patch_size, stride=self.stride), + Rearrange( + "b (c h w) t -> b t c h w", + h=self.patch_size[0], + w=self.patch_size[1], + c=1, + ), + ) + + def _create_trg_mask(self, trg: Tensor) -> Tensor: + # Move this outside the transformer. + trg_pad_mask = (trg != self.trg_pad_index)[:, None, None] + trg_len = trg.shape[1] + trg_sub_mask = torch.tril( + torch.ones((trg_len, trg_len), device=trg.device) + ).bool() + trg_mask = trg_pad_mask & trg_sub_mask + return trg_mask + + def encoder(self, src: Tensor) -> Tensor: + """Forward pass with the encoder of the transformer.""" + return self.transformer.encoder(src) + + def decoder(self, trg: Tensor, memory: Tensor, trg_mask: Tensor) -> Tensor: + """Forward pass with the decoder of the transformer + classification head.""" + return self.head( + self.transformer.decoder(trg=trg, memory=memory, trg_mask=trg_mask) + ) + + def _backbone(self, x: Tensor) -> Tensor: + b, t = x.shape[:2] + if self.use_backbone: + x = rearrange(x, "b t c h w -> (b t) c h w", b=b, t=t) + x = self.backbone(x) + if self.mlp_dim: + x = rearrange(x, "(b t) c h w -> b t (c h w)", b=b, t=t) + x = self.mlp(x) + else: + x = rearrange(x, "(b t) h -> b t h", b=b, t=t) + else: + x = rearrange(x, "b t c h w -> b t (c h w)", b=b, t=t) + x = self.linear_projection(x) + return x + + def preprocess_input(self, src: Tensor) -> Tensor: + """Encodes src with a backbone network and a positional encoding. + + Args: + src (Tensor): Input tensor. + + Returns: + Tensor: A input src to the transformer. + + """ + # If batch dimenstion is missing, it needs to be added. + if len(src.shape) < 4: + src = src[(None,) * (4 - len(src.shape))] + src = self.slidning_window(src) # .squeeze(-2) + src = self._backbone(src) + src = self.position_encoding(src) + return src + + def preprocess_target(self, trg: Tensor) -> Tuple[Tensor, Tensor]: + """Encodes target tensor with embedding and postion. + + Args: + trg (Tensor): Target tensor. + + Returns: + Tuple[Tensor, Tensor]: Encoded target tensor and target mask. + + """ + trg_mask = self._create_trg_mask(trg) + trg = self.character_embedding(trg.long()) + trg = self.position_encoding(trg) + return trg, trg_mask + + def forward(self, x: Tensor, trg: Tensor) -> Tensor: + """Forward pass with vision transfomer.""" + src = self.preprocess_input(x) + trg, trg_mask = self.preprocess_target(trg) + out = self.transformer(src, trg, trg_mask=trg_mask) + logits = self.head(out) + return logits diff --git a/src/text_recognizer/networks/wide_resnet.py b/src/text_recognizer/networks/wide_resnet.py index 618f414..aa79c12 100644 --- a/src/text_recognizer/networks/wide_resnet.py +++ b/src/text_recognizer/networks/wide_resnet.py @@ -8,7 +8,7 @@ import torch from torch import nn from torch import Tensor -from text_recognizer.networks.misc import activation_function +from text_recognizer.networks.util import activation_function def conv3x3(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d: @@ -206,8 +206,8 @@ class WideResidualNetwork(nn.Module): def forward(self, x: Tensor) -> Tensor: """Feedforward pass.""" - if len(x.shape) == 3: - x = x.unsqueeze(0) + if len(x.shape) < 4: + x = x[(None,) * int(4 - len(x.shape))] x = self.encoder(x) if self.decoder is not None: x = self.decoder(x) diff --git a/src/text_recognizer/tests/support/create_emnist_support_files.py b/src/text_recognizer/tests/support/create_emnist_support_files.py index 5dd1a81..c04860d 100644 --- a/src/text_recognizer/tests/support/create_emnist_support_files.py +++ b/src/text_recognizer/tests/support/create_emnist_support_files.py @@ -2,10 +2,8 @@ from pathlib import Path import shutil -from text_recognizer.datasets.emnist_dataset import ( - fetch_emnist_dataset, - load_emnist_mapping, -) +from text_recognizer.datasets.emnist_dataset import EmnistDataset +from text_recognizer.datasets.util import EmnistMapper from text_recognizer.util import write_image SUPPORT_DIRNAME = Path(__file__).parents[0].resolve() / "emnist" @@ -16,15 +14,16 @@ def create_emnist_support_files() -> None: shutil.rmtree(SUPPORT_DIRNAME, ignore_errors=True) SUPPORT_DIRNAME.mkdir() - dataset = fetch_emnist_dataset(split="byclass", train=False) - mapping = load_emnist_mapping() + dataset = EmnistDataset(train=False) + dataset.load_or_generate_data() + mapping = EmnistMapper() for index in [5, 7, 9]: image, label = dataset[index] if len(image.shape) == 3: image = image.squeeze(0) image = image.numpy() - label = mapping[int(label)] + label = mapping(int(label)) print(index, label) write_image(image, str(SUPPORT_DIRNAME / f"{label}.png")) diff --git a/src/text_recognizer/tests/test_line_predictor.py b/src/text_recognizer/tests/test_line_predictor.py new file mode 100644 index 0000000..eede4d4 --- /dev/null +++ b/src/text_recognizer/tests/test_line_predictor.py @@ -0,0 +1,35 @@ +"""Tests for LinePredictor.""" +import os +from pathlib import Path +import unittest + + +import editdistance +import numpy as np + +from text_recognizer.datasets import IamLinesDataset +from text_recognizer.line_predictor import LinePredictor +import text_recognizer.util as util + +SUPPORT_DIRNAME = Path(__file__).parents[0].resolve() / "support" + +os.environ["CUDA_VISIBLE_DEVICES"] = "" + + +class TestEmnistLinePredictor(unittest.TestCase): + """Test LinePredictor class on the EmnistLines dataset.""" + + def test_filename(self) -> None: + """Test that LinePredictor correctly predicts on single images, for several test images.""" + predictor = LinePredictor( + dataset="EmnistLineDataset", network_fn="CNNTransformer" + ) + + for filename in (SUPPORT_DIRNAME / "emnist_lines").glob("*.png"): + pred, conf = predictor.predict(str(filename)) + true = str(filename.stem) + edit_distance = editdistance.eval(pred, true) / len(pred) + print( + f'Pred: "{pred}" | Confidence: {conf} | True: {true} | Edit distance: {edit_distance}' + ) + self.assertLess(edit_distance, 0.2) diff --git a/src/text_recognizer/weights/CRNNModel_IamLinesDataset_ConvolutionalRecurrentNetwork_weights.pt b/src/text_recognizer/weights/CRNNModel_IamLinesDataset_ConvolutionalRecurrentNetwork_weights.pt Binary files differnew file mode 100644 index 0000000..726c723 --- /dev/null +++ b/src/text_recognizer/weights/CRNNModel_IamLinesDataset_ConvolutionalRecurrentNetwork_weights.pt diff --git a/src/text_recognizer/weights/CharacterModel_EmnistDataset_DenseNet_weights.pt b/src/text_recognizer/weights/CharacterModel_EmnistDataset_DenseNet_weights.pt Binary files differnew file mode 100644 index 0000000..6a9a915 --- /dev/null +++ b/src/text_recognizer/weights/CharacterModel_EmnistDataset_DenseNet_weights.pt diff --git a/src/text_recognizer/weights/CharacterModel_EmnistDataset_LeNet_weights.pt b/src/text_recognizer/weights/CharacterModel_EmnistDataset_LeNet_weights.pt Binary files differdeleted file mode 100644 index 676eb44..0000000 --- a/src/text_recognizer/weights/CharacterModel_EmnistDataset_LeNet_weights.pt +++ /dev/null diff --git a/src/text_recognizer/weights/CharacterModel_EmnistDataset_MLP_weights.pt b/src/text_recognizer/weights/CharacterModel_EmnistDataset_MLP_weights.pt Binary files differdeleted file mode 100644 index 32c83cc..0000000 --- a/src/text_recognizer/weights/CharacterModel_EmnistDataset_MLP_weights.pt +++ /dev/null diff --git a/src/text_recognizer/weights/CharacterModel_EmnistDataset_ResidualNetworkEncoder_weights.pt b/src/text_recognizer/weights/CharacterModel_EmnistDataset_ResidualNetworkEncoder_weights.pt Binary files differdeleted file mode 100644 index 9f9deee..0000000 --- a/src/text_recognizer/weights/CharacterModel_EmnistDataset_ResidualNetworkEncoder_weights.pt +++ /dev/null diff --git a/src/text_recognizer/weights/CharacterModel_EmnistDataset_ResidualNetwork_weights.pt b/src/text_recognizer/weights/CharacterModel_EmnistDataset_ResidualNetwork_weights.pt Binary files differdeleted file mode 100644 index 0dc7eb5..0000000 --- a/src/text_recognizer/weights/CharacterModel_EmnistDataset_ResidualNetwork_weights.pt +++ /dev/null diff --git a/src/text_recognizer/weights/CharacterModel_EmnistDataset_SpinalVGG_weights.pt b/src/text_recognizer/weights/CharacterModel_EmnistDataset_SpinalVGG_weights.pt Binary files differdeleted file mode 100644 index e720299..0000000 --- a/src/text_recognizer/weights/CharacterModel_EmnistDataset_SpinalVGG_weights.pt +++ /dev/null diff --git a/src/text_recognizer/weights/CharacterModel_Emnist_LeNet_weights.pt b/src/text_recognizer/weights/CharacterModel_EmnistDataset_WideResidualNetwork_weights.pt Binary files differindex ed73c09..2d5a89b 100644 --- a/src/text_recognizer/weights/CharacterModel_Emnist_LeNet_weights.pt +++ b/src/text_recognizer/weights/CharacterModel_EmnistDataset_WideResidualNetwork_weights.pt diff --git a/src/text_recognizer/weights/CharacterModel_Emnist_MLP_weights.pt b/src/text_recognizer/weights/CharacterModel_Emnist_MLP_weights.pt Binary files differdeleted file mode 100644 index 4ec12c1..0000000 --- a/src/text_recognizer/weights/CharacterModel_Emnist_MLP_weights.pt +++ /dev/null diff --git a/src/text_recognizer/weights/LineCTCModel_IamLinesDataset_LineRecurrentNetwork_weights.pt b/src/text_recognizer/weights/LineCTCModel_IamLinesDataset_LineRecurrentNetwork_weights.pt Binary files differindex 93d34d7..7fe1fa3 100644 --- a/src/text_recognizer/weights/LineCTCModel_IamLinesDataset_LineRecurrentNetwork_weights.pt +++ b/src/text_recognizer/weights/LineCTCModel_IamLinesDataset_LineRecurrentNetwork_weights.pt diff --git a/src/training/experiments/default_config_emnist.yml b/src/training/experiments/default_config_emnist.yml index 12a0a9d..bf2ed0a 100644 --- a/src/training/experiments/default_config_emnist.yml +++ b/src/training/experiments/default_config_emnist.yml @@ -66,4 +66,5 @@ callback_args: null verbosity: 1 # 0, 1, 2 resume_experiment: null +train: true validation_metric: val_accuracy diff --git a/src/training/experiments/embedding_experiment.yml b/src/training/experiments/embedding_experiment.yml new file mode 100644 index 0000000..1e5f941 --- /dev/null +++ b/src/training/experiments/embedding_experiment.yml @@ -0,0 +1,64 @@ +experiment_group: Embedding Experiments +experiments: + - train_args: + transformer_model: false + batch_size: &batch_size 256 + max_epochs: &max_epochs 32 + input_shape: [[1, 28, 28]] + dataset: + type: EmnistDataset + args: + sample_to_balance: true + subsample_fraction: null + transform: null + target_transform: null + seed: 4711 + train_args: + num_workers: 8 + train_fraction: 0.85 + batch_size: *batch_size + model: CharacterModel + metrics: [] + network: + type: DenseNet + args: + growth_rate: 4 + block_config: [4, 4] + in_channels: 1 + base_channels: 24 + num_classes: 128 + bn_size: 4 + dropout_rate: 0.1 + classifier: true + activation: elu + criterion: + type: EmbeddingLoss + args: + margin: 0.2 + type_of_triplets: semihard + optimizer: + type: AdamW + args: + lr: 1.e-02 + betas: [0.9, 0.999] + eps: 1.e-08 + weight_decay: 5.e-4 + amsgrad: false + lr_scheduler: + type: CosineAnnealingLR + args: + T_max: *max_epochs + callbacks: [Checkpoint, ProgressBar, WandbCallback] + callback_args: + Checkpoint: + monitor: val_loss + mode: min + ProgressBar: + epochs: *max_epochs + WandbCallback: + log_batch_frequency: 10 + verbosity: 1 # 0, 1, 2 + resume_experiment: null + train: true + test: true + test_metric: mean_average_precision_at_r diff --git a/src/training/experiments/line_ctc_experiment.yml b/src/training/experiments/line_ctc_experiment.yml deleted file mode 100644 index 432d1cc..0000000 --- a/src/training/experiments/line_ctc_experiment.yml +++ /dev/null @@ -1,91 +0,0 @@ -experiment_group: Lines Experiments -experiments: - - train_args: - batch_size: 42 - max_epochs: &max_epochs 32 - dataset: - type: IamLinesDataset - args: - subsample_fraction: null - transform: null - target_transform: null - train_args: - num_workers: 8 - train_fraction: 0.85 - model: LineCTCModel - metrics: [cer, wer] - network: - type: LineRecurrentNetwork - args: - backbone: ResidualNetwork - backbone_args: - in_channels: 1 - num_classes: 64 # Embedding - depths: [2,2] - block_sizes: [32,64] - activation: selu - stn: false - # encoder: ResidualNetwork - # encoder_args: - # pretrained: training/experiments/CharacterModel_EmnistDataset_ResidualNetwork/0917_203601/model/best.pt - # freeze: false - flatten: false - input_size: 64 - hidden_size: 64 - bidirectional: true - num_layers: 2 - num_classes: 80 - patch_size: [28, 18] - stride: [1, 4] - criterion: - type: CTCLoss - args: - blank: 79 - optimizer: - type: AdamW - args: - lr: 1.e-02 - betas: [0.9, 0.999] - eps: 1.e-08 - weight_decay: 5.e-4 - amsgrad: false - lr_scheduler: - type: OneCycleLR - args: - max_lr: 1.e-02 - epochs: *max_epochs - anneal_strategy: cos - pct_start: 0.475 - cycle_momentum: true - base_momentum: 0.85 - max_momentum: 0.9 - div_factor: 10 - final_div_factor: 10000 - interval: step - # lr_scheduler: - # type: CosineAnnealingLR - # args: - # T_max: *max_epochs - swa_args: - start: 24 - lr: 5.e-2 - callbacks: [Checkpoint, ProgressBar, WandbCallback, WandbImageLogger] # EarlyStopping] - callback_args: - Checkpoint: - monitor: val_loss - mode: min - ProgressBar: - epochs: *max_epochs - # EarlyStopping: - # monitor: val_loss - # min_delta: 0.0 - # patience: 10 - # mode: min - WandbCallback: - log_batch_frequency: 10 - WandbImageLogger: - num_examples: 6 - verbosity: 1 # 0, 1, 2 - resume_experiment: null - test: true - test_metric: test_cer diff --git a/src/training/experiments/sample_experiment.yml b/src/training/experiments/sample_experiment.yml index 8664a15..a073a87 100644 --- a/src/training/experiments/sample_experiment.yml +++ b/src/training/experiments/sample_experiment.yml @@ -95,5 +95,6 @@ experiments: use_transpose: true verbosity: 0 # 0, 1, 2 resume_experiment: null + train: true test: true test_metric: test_accuracy diff --git a/src/training/prepare_experiments.py b/src/training/prepare_experiments.py index e00540c..6e20bcd 100644 --- a/src/training/prepare_experiments.py +++ b/src/training/prepare_experiments.py @@ -1,9 +1,7 @@ """Run a experiment from a config file.""" import json -from subprocess import run import click -from loguru import logger import yaml diff --git a/src/training/run_experiment.py b/src/training/run_experiment.py index a347d9f..0510d5c 100644 --- a/src/training/run_experiment.py +++ b/src/training/run_experiment.py @@ -6,12 +6,15 @@ import json import os from pathlib import Path import re -from typing import Callable, Dict, List, Tuple, Type +from typing import Callable, Dict, List, Optional, Tuple, Type +import warnings +import adabelief_pytorch import click from loguru import logger import numpy as np import torch +from torchsummary import summary from tqdm import tqdm from training.gpu_manager import GPUManager from training.trainer.callbacks import Callback, CallbackList @@ -21,26 +24,23 @@ import yaml from text_recognizer.models import Model -from text_recognizer.networks import losses - +from text_recognizer.networks import loss as custom_loss_module EXPERIMENTS_DIRNAME = Path(__file__).parents[0].resolve() / "experiments" -CUSTOM_LOSSES = ["EmbeddingLoss"] DEFAULT_TRAIN_ARGS = {"batch_size": 64, "epochs": 16} -def get_level(experiment_config: Dict) -> int: +def _get_level(verbose: int) -> int: """Sets the logger level.""" - if experiment_config["verbosity"] == 0: - return 40 - elif experiment_config["verbosity"] == 1: - return 20 - else: - return 10 + levels = {0: 40, 1: 20, 2: 10} + verbose = verbose if verbose <= 2 else 2 + return levels[verbose] -def create_experiment_dir(experiment_config: Dict) -> Path: +def _create_experiment_dir( + experiment_config: Dict, checkpoint: Optional[str] = None +) -> Path: """Create new experiment.""" EXPERIMENTS_DIRNAME.mkdir(parents=True, exist_ok=True) experiment_dir = EXPERIMENTS_DIRNAME / ( @@ -48,19 +48,21 @@ def create_experiment_dir(experiment_config: Dict) -> Path: + f"{experiment_config['dataset']['type']}_" + f"{experiment_config['network']['type']}" ) - if experiment_config["resume_experiment"] is None: + + if checkpoint is None: experiment = datetime.now().strftime("%m%d_%H%M%S") logger.debug(f"Creating a new experiment called {experiment}") else: available_experiments = glob(str(experiment_dir) + "/*") available_experiments.sort() - if experiment_config["resume_experiment"] == "last": + if checkpoint == "last": experiment = available_experiments[-1] logger.debug(f"Resuming the latest experiment {experiment}") else: - experiment = experiment_config["resume_experiment"] + experiment = checkpoint if not str(experiment_dir / experiment) in available_experiments: raise FileNotFoundError("Experiment does not exist.") + logger.debug(f"Resuming the from experiment {checkpoint}") experiment_dir = experiment_dir / experiment @@ -71,14 +73,10 @@ def create_experiment_dir(experiment_config: Dict) -> Path: return experiment_dir, log_dir, model_dir -def load_modules_and_arguments(experiment_config: Dict) -> Tuple[Callable, Dict]: +def _load_modules_and_arguments(experiment_config: Dict,) -> Tuple[Callable, Dict]: """Loads all modules and arguments.""" - # Import the data loader arguments. - train_args = experiment_config.get("train_args", {}) - # Load the dataset module. dataset_args = experiment_config.get("dataset", {}) - dataset_args["train_args"]["batch_size"] = train_args["batch_size"] datasets_module = importlib.import_module("text_recognizer.datasets") dataset_ = getattr(datasets_module, dataset_args["type"]) @@ -102,21 +100,24 @@ def load_modules_and_arguments(experiment_config: Dict) -> Tuple[Callable, Dict] network_args = experiment_config["network"].get("args", {}) # Criterion - if experiment_config["criterion"]["type"] in CUSTOM_LOSSES: - criterion_ = getattr(losses, experiment_config["criterion"]["type"]) - criterion_args = experiment_config["criterion"].get("args", {}) + if experiment_config["criterion"]["type"] in custom_loss_module.__all__: + criterion_ = getattr(custom_loss_module, experiment_config["criterion"]["type"]) else: criterion_ = getattr(torch.nn, experiment_config["criterion"]["type"]) - criterion_args = experiment_config["criterion"].get("args", {}) + criterion_args = experiment_config["criterion"].get("args", {}) or {} # Optimizers - optimizer_ = getattr(torch.optim, experiment_config["optimizer"]["type"]) + if experiment_config["optimizer"]["type"] == "AdaBelief": + warnings.filterwarnings("ignore", category=UserWarning) + optimizer_ = getattr(adabelief_pytorch, experiment_config["optimizer"]["type"]) + else: + optimizer_ = getattr(torch.optim, experiment_config["optimizer"]["type"]) optimizer_args = experiment_config["optimizer"].get("args", {}) # Learning rate scheduler lr_scheduler_ = None lr_scheduler_args = None - if experiment_config["lr_scheduler"] is not None: + if "lr_scheduler" in experiment_config: lr_scheduler_ = getattr( torch.optim.lr_scheduler, experiment_config["lr_scheduler"]["type"] ) @@ -146,10 +147,12 @@ def load_modules_and_arguments(experiment_config: Dict) -> Tuple[Callable, Dict] return model_class_, model_args -def configure_callbacks(experiment_config: Dict, model_dir: Dict) -> CallbackList: +def _configure_callbacks(experiment_config: Dict, model_dir: Path) -> CallbackList: """Configure a callback list for trainer.""" if "Checkpoint" in experiment_config["callback_args"]: - experiment_config["callback_args"]["Checkpoint"]["checkpoint_path"] = model_dir + experiment_config["callback_args"]["Checkpoint"]["checkpoint_path"] = str( + model_dir + ) # Initializes callbacks. callback_modules = importlib.import_module("training.trainer.callbacks") @@ -161,13 +164,13 @@ def configure_callbacks(experiment_config: Dict, model_dir: Dict) -> CallbackLis return callbacks -def configure_logger(experiment_config: Dict, log_dir: Path) -> None: +def _configure_logger(log_dir: Path, verbose: int = 0) -> None: """Configure the loguru logger for output to terminal and disk.""" # Have to remove default logger to get tqdm to work properly. logger.remove() # Fetch verbosity level. - level = get_level(experiment_config) + level = _get_level(verbose) logger.add(lambda msg: tqdm.write(msg, end=""), colorize=True, level=level) logger.add( @@ -176,20 +179,29 @@ def configure_logger(experiment_config: Dict, log_dir: Path) -> None: ) -def save_config(experiment_dir: Path, experiment_config: Dict) -> None: +def _save_config(experiment_dir: Path, experiment_config: Dict) -> None: """Copy config to experiment directory.""" config_path = experiment_dir / "config.yml" with open(str(config_path), "w") as f: yaml.dump(experiment_config, f) -def load_from_checkpoint(model: Type[Model], log_dir: Path, model_dir: Path) -> None: +def _load_from_checkpoint( + model: Type[Model], model_dir: Path, pretrained_weights: str = None, +) -> None: """If checkpoint exists, load model weights and optimizers from checkpoint.""" # Get checkpoint path. - checkpoint_path = model_dir / "last.pt" + if pretrained_weights is not None: + logger.info(f"Loading weights from {pretrained_weights}.") + checkpoint_path = ( + EXPERIMENTS_DIRNAME / Path(pretrained_weights) / "model" / "best.pt" + ) + else: + logger.info(f"Loading weights from {model_dir}.") + checkpoint_path = model_dir / "last.pt" if checkpoint_path.exists(): - logger.info("Loading and resuming training from last checkpoint.") - model.load_checkpoint(checkpoint_path) + logger.info("Loading and resuming training from checkpoint.") + model.load_from_checkpoint(checkpoint_path) def evaluate_embedding(model: Type[Model]) -> Dict: @@ -217,38 +229,50 @@ def evaluate_embedding(model: Type[Model]) -> Dict: def run_experiment( - experiment_config: Dict, save_weights: bool, device: str, use_wandb: bool = False + experiment_config: Dict, + save_weights: bool, + device: str, + use_wandb: bool, + train: bool, + test: bool, + verbose: int = 0, + checkpoint: Optional[str] = None, + pretrained_weights: Optional[str] = None, ) -> None: """Runs an experiment.""" logger.info(f"Experiment config: {json.dumps(experiment_config)}") # Create new experiment. - experiment_dir, log_dir, model_dir = create_experiment_dir(experiment_config) + experiment_dir, log_dir, model_dir = _create_experiment_dir( + experiment_config, checkpoint + ) # Make sure the log/model directory exists. log_dir.mkdir(parents=True, exist_ok=True) model_dir.mkdir(parents=True, exist_ok=True) # Load the modules and model arguments. - model_class_, model_args = load_modules_and_arguments(experiment_config) + model_class_, model_args = _load_modules_and_arguments(experiment_config) # Initializes the model with experiment config. model = model_class_(**model_args, device=device) - callbacks = configure_callbacks(experiment_config, model_dir) + callbacks = _configure_callbacks(experiment_config, model_dir) # Setup logger. - configure_logger(experiment_config, log_dir) + _configure_logger(log_dir, verbose) # Load from checkpoint if resuming an experiment. - if experiment_config["resume_experiment"] is not None: - load_from_checkpoint(model, log_dir, model_dir) + resume = False + if checkpoint is not None or pretrained_weights is not None: + resume = True + _load_from_checkpoint(model, model_dir, pretrained_weights) logger.info(f"The class mapping is {model.mapping}") # Initializes Weights & Biases if use_wandb: - wandb.init(project="text-recognizer", config=experiment_config) + wandb.init(project="text-recognizer", config=experiment_config, resume=resume) # Lets W&B save the model and track the gradients and optional parameters. wandb.watch(model.network) @@ -265,23 +289,30 @@ def run_experiment( experiment_config["device"] = device # Save the config used in the experiment folder. - save_config(experiment_dir, experiment_config) + _save_config(experiment_dir, experiment_config) + + # Prints a summary of the network in terminal. + model.summary(experiment_config["train_args"]["input_shape"]) # Load trainer. trainer = Trainer( - max_epochs=experiment_config["train_args"]["max_epochs"], callbacks=callbacks, + max_epochs=experiment_config["train_args"]["max_epochs"], + callbacks=callbacks, + transformer_model=experiment_config["train_args"]["transformer_model"], + max_norm=experiment_config["train_args"]["max_norm"], ) # Train the model. - trainer.fit(model) + if train: + trainer.fit(model) # Run inference over test set. - if experiment_config["test"]: + if test: logger.info("Loading checkpoint with the best weights.") model.load_from_checkpoint(model_dir / "best.pt") logger.info("Running inference on test set.") - if experiment_config["criterion"]["type"] in CUSTOM_LOSSES: + if experiment_config["criterion"]["type"] == "EmbeddingLoss": logger.info("Evaluating embedding.") score = evaluate_embedding(model) else: @@ -313,7 +344,26 @@ def run_experiment( @click.option( "--nowandb", is_flag=False, help="If true, do not use wandb for this run." ) -def run_cli(experiment_config: str, gpu: int, save: bool, nowandb: bool) -> None: +@click.option("--test", is_flag=True, help="If true, test the model.") +@click.option("-v", "--verbose", count=True) +@click.option("--checkpoint", type=str, help="Path to the experiment.") +@click.option( + "--pretrained_weights", type=str, help="Path to pretrained model weights." +) +@click.option( + "--notrain", is_flag=False, is_eager=True, help="Do not train the model.", +) +def run_cli( + experiment_config: str, + gpu: int, + save: bool, + nowandb: bool, + notrain: bool, + test: bool, + verbose: int, + checkpoint: Optional[str] = None, + pretrained_weights: Optional[str] = None, +) -> None: """Run experiment.""" if gpu < 0: gpu_manager = GPUManager(True) @@ -322,7 +372,18 @@ def run_cli(experiment_config: str, gpu: int, save: bool, nowandb: bool) -> None experiment_config = json.loads(experiment_config) os.environ["CUDA_VISIBLE_DEVICES"] = f"{gpu}" - run_experiment(experiment_config, save, device, use_wandb=not nowandb) + + run_experiment( + experiment_config, + save, + device, + use_wandb=not nowandb, + train=not notrain, + test=test, + verbose=verbose, + checkpoint=checkpoint, + pretrained_weights=pretrained_weights, + ) if __name__ == "__main__": diff --git a/src/training/trainer/callbacks/base.py b/src/training/trainer/callbacks/base.py index 8c7b085..500b642 100644 --- a/src/training/trainer/callbacks/base.py +++ b/src/training/trainer/callbacks/base.py @@ -62,6 +62,14 @@ class Callback: """Called at the end of an epoch.""" pass + def on_test_begin(self) -> None: + """Called at the beginning of test.""" + pass + + def on_test_end(self) -> None: + """Called at the end of test.""" + pass + class CallbackList: """Container for abstracting away callback calls.""" @@ -92,7 +100,7 @@ class CallbackList: def append(self, callback: Type[Callback]) -> None: """Append new callback to callback list.""" - self.callbacks.append(callback) + self._callbacks.append(callback) def on_fit_begin(self) -> None: """Called when fit begins.""" @@ -104,6 +112,16 @@ class CallbackList: for callback in self._callbacks: callback.on_fit_end() + def on_test_begin(self) -> None: + """Called when test begins.""" + for callback in self._callbacks: + callback.on_test_begin() + + def on_test_end(self) -> None: + """Called when test ends.""" + for callback in self._callbacks: + callback.on_test_end() + def on_epoch_begin(self, epoch: int, logs: Optional[Dict] = None) -> None: """Called at the beginning of an epoch.""" for callback in self._callbacks: diff --git a/src/training/trainer/callbacks/checkpoint.py b/src/training/trainer/callbacks/checkpoint.py index 6fe06d3..a54e0a9 100644 --- a/src/training/trainer/callbacks/checkpoint.py +++ b/src/training/trainer/callbacks/checkpoint.py @@ -21,7 +21,7 @@ class Checkpoint(Callback): def __init__( self, - checkpoint_path: Path, + checkpoint_path: Union[str, Path], monitor: str = "accuracy", mode: str = "auto", min_delta: float = 0.0, @@ -29,14 +29,14 @@ class Checkpoint(Callback): """Monitors a quantity that will allow us to determine the best model weights. Args: - checkpoint_path (Path): Path to the experiment with the checkpoint. + checkpoint_path (Union[str, Path]): Path to the experiment with the checkpoint. monitor (str): Name of the quantity to monitor. Defaults to "accuracy". mode (str): Description of parameter `mode`. Defaults to "auto". min_delta (float): Description of parameter `min_delta`. Defaults to 0.0. """ super().__init__() - self.checkpoint_path = checkpoint_path + self.checkpoint_path = Path(checkpoint_path) self.monitor = monitor self.mode = mode self.min_delta = torch.tensor(min_delta) diff --git a/src/training/trainer/callbacks/lr_schedulers.py b/src/training/trainer/callbacks/lr_schedulers.py index 907e292..630c434 100644 --- a/src/training/trainer/callbacks/lr_schedulers.py +++ b/src/training/trainer/callbacks/lr_schedulers.py @@ -22,7 +22,10 @@ class LRScheduler(Callback): def on_epoch_end(self, epoch: int, logs: Optional[Dict] = None) -> None: """Takes a step at the end of every epoch.""" if self.interval == "epoch": - self.lr_scheduler.step() + if "ReduceLROnPlateau" in self.lr_scheduler.__class__.__name__: + self.lr_scheduler.step(logs["val_loss"]) + else: + self.lr_scheduler.step() def on_train_batch_end(self, batch: int, logs: Optional[Dict] = None) -> None: """Takes a step at the end of every training batch.""" diff --git a/src/training/trainer/callbacks/wandb_callbacks.py b/src/training/trainer/callbacks/wandb_callbacks.py index d2df4d7..1627f17 100644 --- a/src/training/trainer/callbacks/wandb_callbacks.py +++ b/src/training/trainer/callbacks/wandb_callbacks.py @@ -64,37 +64,55 @@ class WandbImageLogger(Callback): """ super().__init__() + self.caption = None self.example_indices = example_indices + self.test_sample_indices = None self.num_examples = num_examples self.transpose = Transpose() if use_transpose else None def set_model(self, model: Type[Model]) -> None: """Sets the model and extracts validation images from the dataset.""" self.model = model + self.caption = "Validation Examples" if self.example_indices is None: self.example_indices = np.random.randint( 0, len(self.model.val_dataset), self.num_examples ) - self.val_images = self.model.val_dataset.dataset.data[self.example_indices] - self.val_targets = self.model.val_dataset.dataset.targets[self.example_indices] - self.val_targets = self.val_targets.tolist() + self.images = self.model.val_dataset.dataset.data[self.example_indices] + self.targets = self.model.val_dataset.dataset.targets[self.example_indices] + self.targets = self.targets.tolist() + + def on_test_begin(self) -> None: + """Get samples from test dataset.""" + self.caption = "Test Examples" + if self.test_sample_indices is None: + self.test_sample_indices = np.random.randint( + 0, len(self.model.test_dataset), self.num_examples + ) + self.images = self.model.test_dataset.data[self.test_sample_indices] + self.targets = self.model.test_dataset.targets[self.test_sample_indices] + self.targets = self.targets.tolist() + + def on_test_end(self) -> None: + """Log test images.""" + self.on_epoch_end(0, {}) def on_epoch_end(self, epoch: int, logs: Dict) -> None: """Get network predictions on validation images.""" images = [] - for i, image in enumerate(self.val_images): + for i, image in enumerate(self.images): image = self.transpose(image) if self.transpose is not None else image pred, conf = self.model.predict_on_image(image) - if isinstance(self.val_targets[i], list): + if isinstance(self.targets[i], list): ground_truth = "".join( [ self.model.mapper(int(target_index)) - for target_index in self.val_targets[i] + for target_index in self.targets[i] ] ).rstrip("_") else: - ground_truth = self.val_targets[i] + ground_truth = self.model.mapper(int(self.targets[i])) caption = f"Prediction: {pred} Confidence: {conf:.3f} Ground Truth: {ground_truth}" images.append(wandb.Image(image, caption=caption)) - wandb.log({"examples": images}, commit=False) + wandb.log({f"{self.caption}": images}, commit=False) diff --git a/src/training/trainer/population_based_training/__init__.py b/src/training/trainer/population_based_training/__init__.py deleted file mode 100644 index 868d739..0000000 --- a/src/training/trainer/population_based_training/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""TBC.""" diff --git a/src/training/trainer/population_based_training/population_based_training.py b/src/training/trainer/population_based_training/population_based_training.py deleted file mode 100644 index 868d739..0000000 --- a/src/training/trainer/population_based_training/population_based_training.py +++ /dev/null @@ -1 +0,0 @@ -"""TBC.""" diff --git a/src/training/trainer/train.py b/src/training/trainer/train.py index bd6a491..223d9c6 100644 --- a/src/training/trainer/train.py +++ b/src/training/trainer/train.py @@ -4,6 +4,7 @@ from pathlib import Path import time from typing import Dict, List, Optional, Tuple, Type +from einops import rearrange from loguru import logger import numpy as np import torch @@ -27,12 +28,20 @@ class Trainer: # TODO: proper add teardown? - def __init__(self, max_epochs: int, callbacks: List[Type[Callback]],) -> None: + def __init__( + self, + max_epochs: int, + callbacks: List[Type[Callback]], + transformer_model: bool = False, + max_norm: float = 0.0, + ) -> None: """Initialization of the Trainer. Args: max_epochs (int): The maximum number of epochs in the training loop. callbacks (CallbackList): List of callbacks to be called. + transformer_model (bool): Transformer model flag, modifies the input to the model. Default is False. + max_norm (float): Max norm for gradient clipping. Defaults to 0.0. """ # Training arguments. @@ -43,6 +52,10 @@ class Trainer: # Flag for setting callbacks. self.callbacks_configured = False + self.transformer_model = transformer_model + + self.max_norm = max_norm + # Model placeholders self.model = None @@ -97,10 +110,15 @@ class Trainer: # Forward pass. # Get the network prediction. - output = self.model.forward(data) + if self.transformer_model: + output = self.model.network.forward(data, targets[:, :-1]) + output = rearrange(output, "b t v -> (b t) v") + targets = rearrange(targets[:, 1:], "b t -> (b t)").long() + else: + output = self.model.forward(data) # Compute the loss. - loss = self.model.loss_fn(output, targets) + loss = self.model.criterion(output, targets) # Backward pass. # Clear the previous gradients. @@ -110,6 +128,11 @@ class Trainer: # Compute the gradients. loss.backward() + if self.max_norm > 0: + torch.nn.utils.clip_grad_norm_( + self.model.network.parameters(), self.max_norm + ) + # Perform updates using calculated gradients. self.model.optimizer.step() @@ -148,10 +171,15 @@ class Trainer: # Forward pass. # Get the network prediction. # Use SWA if available and using test dataset. - output = self.model.forward(data) + if self.transformer_model: + output = self.model.network.forward(data, targets[:, :-1]) + output = rearrange(output, "b t v -> (b t) v") + targets = rearrange(targets[:, 1:], "b t -> (b t)").long() + else: + output = self.model.forward(data) # Compute the loss. - loss = self.model.loss_fn(output, targets) + loss = self.model.criterion(output, targets) # Compute metrics. metrics = self.compute_metrics(output, targets, loss, loss_avg) @@ -237,6 +265,8 @@ class Trainer: # Configure callbacks. self._configure_callbacks() + self.callbacks.on_test_begin() + self.model.eval() # Check if SWA network is available. @@ -252,6 +282,8 @@ class Trainer: metrics = self.validation_step(batch, samples, loss_avg) summary.append(metrics) + self.callbacks.on_test_end() + # Compute mean of all test metrics. metrics_mean = { "test_" + metric: np.mean([x[metric] for x in summary]) |