SigNet_BHSig260_Hindi_Signatures.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "SigNet_BHSig260_Hindi_Signatures.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "latex_envs": {
      "LaTeX_envs_menu_present": true,
      "autoclose": false,
      "autocomplete": true,
      "bibliofile": "biblio.bib",
      "cite_by": "apalike",
      "current_citInitial": 1,
      "eqLabelWithNumbers": true,
      "eqNumInitial": 1,
      "hotkeys": {
        "equation": "Ctrl-E",
        "itemize": "Ctrl-I"
      },
      "labels_anchors": false,
      "latex_user_defs": false,
      "report_style_numbering": false,
      "user_envs_cfg": false
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/anshupandey/Computer-Vision/blob/master/SigNet_BHSig260_Hindi_Signatures.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GTEqqZMIiom-"
      },
      "source": [
        "### Problem Statement\n",
        "Signature is one of the most popular and commonly accepted biometric hallmarks that has been used since the ancient times for verifying different entities related to human beings, viz. documents, forms, bank checks, individuals, etc. Therefore, signature verification is a critical task and many efforts have been made to remove the uncertainty involved in the manual authentication procedure, which makes signature verification an important research line in the field of machine learning and pattern recognition. \n",
        "\n",
        "\n",
        "In this notebook, we model a writer independent **signature verification** task with a **convolutional Siamese network**.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z5aDCGKFnWEd"
      },
      "source": [
        "import sys\n",
        "import numpy as np\n",
        "import pickle\n",
        "import os\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "import cv2\n",
        "import time\n",
        "import itertools\n",
        "import random\n",
        "\n",
        "from sklearn.utils import shuffle\n",
        "\n",
        "import tensorflow as tf\n",
        "from keras.models import Sequential\n",
        "from keras.optimizers import Adam, RMSprop\n",
        "from keras.layers import Conv2D, ZeroPadding2D, Activation, Input, concatenate, Dropout\n",
        "from keras.models import Model\n",
        "\n",
        "from keras.layers.normalization import BatchNormalization\n",
        "from keras.layers.pooling import MaxPooling2D\n",
        "from keras.layers.merge import Concatenate\n",
        "from keras.layers.core import Lambda, Flatten, Dense\n",
        "from keras.initializers import glorot_uniform\n",
        "\n",
        "from keras.engine.topology import Layer\n",
        "from keras.regularizers import l2\n",
        "from keras import backend as K\n",
        "from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rQ6uGxWagd1G"
      },
      "source": [
        "### Dataset Links:\n",
        "\n",
        "https://drive.google.com/open?id=0B29vNACcjvzVc1RfVkg5dUh2b1E"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V6kP3WD_hlYA"
      },
      "source": [
        "### About the Dataset:\n",
        "\n",
        "\n",
        "The BHSig260 signature dataset contains the signatures of 260 persons, among them 100 were signed in Bengali and 160 are signed in Hindi. \n",
        "\n",
        "For each of the signers, 24 genuine and 30 forged signatures are available. This results in 100 × 24 = 2, 400 genuine and 100 × 30 = 3, 000 forged signatures in Bengali, and 160 × 24 = 3, 840 genuine and 160×30 = 4, 800 forged signatures in Hindi.\n",
        "\n",
        "In this task we are considering only Hindi singatures for easeness. \n",
        "\n",
        "\n",
        "**Paper Link:**  https://arxiv.org/pdf/1707.02131.pdf"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "go2w2yTW1XRR"
      },
      "source": [
        "!wget -q https://www.dropbox.com/s/s59wvm0uxxx4oag/BHSig260.zip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUTs4SGb1dXN"
      },
      "source": [
        "#project_path = \"/content/drive/My Drive/AIML Notes/Siamese/\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLLR_9XE2BEe"
      },
      "source": [
        "from zipfile import ZipFile\n",
        "\n",
        "with ZipFile('BHSig260.zip', 'r') as z:\n",
        "  z.extractall()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4riEsNPriAzR"
      },
      "source": [
        "### Considering only Hindi signatures from the dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9JUlueyvnWEh"
      },
      "source": [
        "path = \"./BHSig260/Hindi/\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rp9uAdz8nWEi"
      },
      "source": [
        "# Get the list of all directories and sort them\n",
        "dir_list = next(os.walk(path))[1]\n",
        "dir_list.sort()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RGVjXiD33BVC",
        "outputId": "25aa6762-ef23-4a7c-bca7-9db43c47947d"
      },
      "source": [
        "dir_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['001',\n",
              " '002',\n",
              " '003',\n",
              " '004',\n",
              " '005',\n",
              " '006',\n",
              " '007',\n",
              " '008',\n",
              " '009',\n",
              " '010',\n",
              " '011',\n",
              " '012',\n",
              " '013',\n",
              " '014',\n",
              " '015',\n",
              " '016',\n",
              " '017',\n",
              " '018',\n",
              " '019',\n",
              " '020',\n",
              " '021',\n",
              " '022',\n",
              " '023',\n",
              " '024',\n",
              " '025',\n",
              " '026',\n",
              " '027',\n",
              " '028',\n",
              " '029',\n",
              " '030',\n",
              " '031',\n",
              " '032',\n",
              " '033',\n",
              " '034',\n",
              " '035',\n",
              " '036',\n",
              " '037',\n",
              " '038',\n",
              " '039',\n",
              " '040',\n",
              " '041',\n",
              " '042',\n",
              " '043',\n",
              " '044',\n",
              " '045',\n",
              " '046',\n",
              " '047',\n",
              " '048',\n",
              " '049',\n",
              " '050',\n",
              " '051',\n",
              " '052',\n",
              " '053',\n",
              " '054',\n",
              " '055',\n",
              " '056',\n",
              " '057',\n",
              " '058',\n",
              " '059',\n",
              " '060',\n",
              " '061',\n",
              " '062',\n",
              " '063',\n",
              " '064',\n",
              " '065',\n",
              " '066',\n",
              " '067',\n",
              " '068',\n",
              " '069',\n",
              " '070',\n",
              " '071',\n",
              " '072',\n",
              " '073',\n",
              " '074',\n",
              " '075',\n",
              " '076',\n",
              " '077',\n",
              " '078',\n",
              " '079',\n",
              " '080',\n",
              " '081',\n",
              " '082',\n",
              " '083',\n",
              " '084',\n",
              " '085',\n",
              " '086',\n",
              " '087',\n",
              " '088',\n",
              " '089',\n",
              " '090',\n",
              " '091',\n",
              " '092',\n",
              " '093',\n",
              " '094',\n",
              " '095',\n",
              " '096',\n",
              " '097',\n",
              " '098',\n",
              " '099',\n",
              " '100',\n",
              " '101',\n",
              " '102',\n",
              " '103',\n",
              " '104',\n",
              " '105',\n",
              " '106',\n",
              " '107',\n",
              " '108',\n",
              " '109',\n",
              " '110',\n",
              " '111',\n",
              " '112',\n",
              " '113',\n",
              " '114',\n",
              " '115',\n",
              " '116',\n",
              " '117',\n",
              " '118',\n",
              " '119',\n",
              " '120',\n",
              " '121',\n",
              " '122',\n",
              " '123',\n",
              " '124',\n",
              " '125',\n",
              " '126',\n",
              " '127',\n",
              " '128',\n",
              " '129',\n",
              " '130',\n",
              " '131',\n",
              " '132',\n",
              " '133',\n",
              " '134',\n",
              " '135',\n",
              " '136',\n",
              " '137',\n",
              " '138',\n",
              " '139',\n",
              " '140',\n",
              " '141',\n",
              " '142',\n",
              " '143',\n",
              " '144',\n",
              " '145',\n",
              " '146',\n",
              " '147',\n",
              " '148',\n",
              " '149',\n",
              " '150',\n",
              " '151',\n",
              " '152',\n",
              " '153',\n",
              " '154',\n",
              " '155',\n",
              " '156',\n",
              " '157',\n",
              " '158',\n",
              " '159',\n",
              " '160']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tgDwb6QinWEk"
      },
      "source": [
        "# For each person segregate the genuine signatures from the forged signatures\n",
        "# Genuine signatures are stored in the list \"orig_groups\"\n",
        "# Forged signatures are stored in the list \"forged_groups\"\n",
        "orig_groups, forg_groups = [], []\n",
        "for directory in dir_list:\n",
        "    images = os.listdir(path+directory)\n",
        "    images.sort()\n",
        "    images = [path+directory+'/'+x for x in images]\n",
        "    forg_groups.append(images[:30]) # First 30 signatures in each folder are forrged\n",
        "    orig_groups.append(images[30:]) # Next 24 signatures are genuine"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d3I2PbRpnWEm",
        "outputId": "8d3c2030-0514-4eee-a019-b27b4fb74f8c"
      },
      "source": [
        "# Quick check to confirm we have data of all the 160 individuals\n",
        "len(orig_groups), len(forg_groups)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(160, 160)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J2wsugOEnWEq"
      },
      "source": [
        "orig_lengths = [len(x) for x in orig_groups]\n",
        "forg_lengths = [len(x) for x in forg_groups]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k2BcZNg4nWEr",
        "outputId": "52d3dd65-0856-4a51-e801-7c3d1ff9bb01"
      },
      "source": [
        "# Quick check to confirm that there are 24 Genuine signatures for each individual\n",
        "print(orig_lengths)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6BRlxrMynWEu",
        "outputId": "2d126bba-a444-4a3a-8b33-c3c4b6079c20"
      },
      "source": [
        "# Quick check to confirm that there are 30 Forged signatures for each individual\n",
        "print(forg_lengths)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qEnPfM3YnWEw"
      },
      "source": [
        "#### Train-Validation-Test Split\n",
        "* Signatures of 120 people are used for training\n",
        "* Signatures of 20 people are used for validation\n",
        "* Signatures of 20 people are used for testing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CKzLFT5snWEx"
      },
      "source": [
        "orig_train, orig_val, orig_test = orig_groups[:120], orig_groups[120:140], orig_groups[140:]\n",
        "forg_train, forg_val, forg_test = forg_groups[:120], forg_groups[120:140], forg_groups[140:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tB0Q2clbnWE0"
      },
      "source": [
        "# Delete unnecessary variables\n",
        "del orig_groups, forg_groups"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "efvMVtVanWE2"
      },
      "source": [
        "# All the images will be converted to the same size before processing\n",
        "img_h, img_w = 155, 220"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dSxGYc3ZnWE5"
      },
      "source": [
        "def visualize_sample_signature():\n",
        "    '''Function to randomly select a signature from train set and\n",
        "    print two genuine copies and one forged copy'''\n",
        "    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize = (10, 10))\n",
        "    k = np.random.randint(len(orig_train))\n",
        "    orig_img_names = random.sample(orig_train[k], 2)\n",
        "    forg_img_name = random.sample(forg_train[k], 1)\n",
        "    orig_img1 = cv2.imread(orig_img_names[0], 0)\n",
        "    orig_img2 = cv2.imread(orig_img_names[1], 0)\n",
        "    forg_img = cv2.imread(forg_img_name[0], 0)\n",
        "    orig_img1 = cv2.resize(orig_img1, (img_w, img_h))\n",
        "    orig_img2 = cv2.resize(orig_img2, (img_w, img_h))\n",
        "    forg_img = cv2.resize(forg_img, (img_w, img_h))\n",
        "\n",
        "    ax1.imshow(orig_img1, cmap = 'gray')\n",
        "    ax2.imshow(orig_img2, cmap = 'gray')\n",
        "    ax3.imshow(forg_img, cmap = 'gray')\n",
        "\n",
        "    ax1.set_title('Genuine Copy')\n",
        "    ax1.axis('off')\n",
        "    ax2.set_title('Genuine Copy')\n",
        "    ax2.axis('off')\n",
        "    ax3.set_title('Forged Copy')\n",
        "    ax3.axis('off')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 163
        },
        "id": "1ZsvrJh6nWE7",
        "outputId": "aeb36043-b8e1-495b-e1a7-8972ac3f797c"
      },
      "source": [
        "visualize_sample_signature()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAACSCAYAAABBhhAtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deVxU1fvA8c+ZYRMBEQFRXFHcEvcldzNTo8xdc0sr03LNLb9aqRW2qZm7lmmGmUvlUpZZlmvl2uIKuKCiLArKooDA3N8fA/NjZFgDkfF5v17zambudm7eMzz33OecozRNQwghhBDCmumKuwBCCCGEEEVNAh4hhBBCWD0JeIQQQghh9STgEUIIIYTVk4BHCCGEEFZPAh4hhBBCWD0JeP4jpVSCUsqnuMshxINC6oQQBaOU6qiUCivuclgrqwh4lFLPKqUOKaVuK6Wi0t+PVkqpoj62pmlOmqZdKIp9K6W6KqX2KaXilVLXlVJ7lVLPFMWxhHWROiFEzpRSoUqpxPQAPeNVsbjLlRNlNF4pdTK9bocppTYrpfyKu2wlQYkPeJRSk4GFwFzACygPvAy0AeyKsWj/iVKqL7AZ+AKohPG8ZgLdi7Nc4sEndUKIPOueHqBnvK7lZ2OllE1RFSwbC4EJwHjADagFbAWeus/lKJk0TSuxL6AMcBvok8t69sA84DIQCawASqUv6wiEAZOBKCAceD7TtnuAEZk+DwcOZPqsATXT338OLAV2APHAIaBGpnXrAD8DMUAQ0D+b8qr0sk7N4Zx0wBvApfRyfwGUSV9WLb1cI4Fr6ec0JX2ZF3AHKJdpX02A64Btcf+byuu/vaROSJ2QV95eQCjQ2cL39sDH6dfJtfT39unLMurGNCACCARKAWuBm8AZ4DUgLNP+KgLfpF9PF4HxmZaVSq8jN4HTwNTM295TLl8gDWiRwzmVSb/ur6fXgzcAXfqy4cBBYAkQC5wFHk9f1g84ds++JgHbivvfqTBfJb2FpxXGi3NbLuu9jzESbgTUBLwx3hlm8MJ4oXgDLwJLlVJlC1imZ4G3gLLAOWAOgFKqNMYf9vWAZ/p6y5RS9SzsozZQGfg6h+MMT389BvgAThgv5Mwew1hJugDTlFKdNU2LwPgHq3+m9YYCGzRNS8njOYoHl9QJqRPiv3kdeBRj3WgItMAYOGTwwti6UhVjAD0LY0DtAzwBDMlYUSmlA74D/sFYlx4HXlVKdU1fZRZQI/3VFRiWQ7kexxgMHc5hncUY660P0AF4Dng+0/KWwHnAPf3Y3yql3IDtQHWlVN1M6w7FGDxZj+KOuP5jhD4EiLjnu9+BW0Ai0B7jneFtzO8qWwEXtf+P2BMBm0zLo4BH09/vIX93s6syLfMHzqa/HwDsv6esK4FZFs6rTfp+HXI4993A6EyfawMpgA3/fzdbJ9PyD4HPMpXlYPp7PcY7lWzvGuRVcl5SJ6ROyCtvL4wtPAnpdeMWsDX9+/OAf6b1ugKh6e87AnczX4fABaBrps8jSG+lwRhgXL7nuNOBNZm27ZZp2Uiyb+F5Hfgzh/PRp5etXqbvRgF70t8Px9hipTItPwwMTX+/HJiT/v4RjK1O9sX971SYr/v9/LGwRQPuSikbTdNSATRNaw2QnumuAzwAR+BYpnxNhfHiMO0nY/t0dzDeHRZERDb7qQq0VErdyrTcBmOT6L2i0/9bAWMTqCUVMTZZZriUvr/ymb67cs/yjMS2bcAKpVR1jH8UYrWc7xpEySF14v9JnRC56alp2i/3fGfpOsqczHxd07Ske9bPfF1lfl8VqHjPNa4H9mezbebj3isa4/WfHXfA1kLZvTN9vqqlRzSZlmec21rgK6XUGxhbdzZpmpacw/FKnJL+SOsPIBnokcM6NzDerT6iaZpr+quMpml5/fG+jfGPQwavghWVK8DeTGVw1YxJcq9YWDcoff0+OezvGsbKlKEKkIoxHyND5XuWXwNIr6ybMLYGDMXyHxhRMkmd+H9SJ0RBWLqOMicza+arE44xiT5D5mvsCsaW08zXuLOmaf6Ztr33mszObqCSUqpZNstvYGzRvLfsVzN99r6np2bmOvAnxhaidsAgrLAOlOiAR9O0WxhzA5YppfoqpZyVUjqlVCOgdPo6BuBTYIFSyhNAKeWd6Rlqbv4GeiulHJVSNTHmMxTE90AtpdRQpZRt+qv5Pc9MM85Lw5gw9qZS6nmllEv6ebVVSn2SvtpXwESlVHWllBPwLrDxnrvyN9PL/QjG57gbMy37AmMT5zNY4YX9sJI6IXVC/GdfAW8opTyUUu4Yc9vW5bD+JmC6UqqsUsobGJtp2WEgXik1TSlVSimlV0rVV0o1t7BtJWBcdgfRNC0EWIaxFaajUspOKeWgjENQ/E/TtLT0/c1Jr/dVMdaZzGX3BMan17V+QF3gh0zLv8CY95aiadqB3P5HlTQlOuAB0DTtQ4z/qK9hvJOLxJgHMA1j7gLp788Bfyql4oBfMDZb58UCjFFvJMYmvy8LWM54jImSz2KMqCOADzAmmFpa/2uMeQUvpK8fCQTw/8moqzH+KO/D2MSfRNbKshfjee8G5mmativT/g8CBuC4pmk5NaOKEkbqhNQJ8Z8EAEeBf4ETwPH077LzNsaeWxcx1qOvMbaykh6EPI0xAfoixlaYVRgTi8F4c3Ipfdkucg+0x2MMSJZizDs6D/TCmBgNxuv9NsbcoAMYOwSszrT9IYxJ+zcwdh7oq2ladKblgUB9cg7wSixl/jhPWAOlVDWMFcj2nrvbe9f7FVivadqq+1Q0IYqF1AlxvyilXgGe1TStQ3GXJTOl1HCMnQ3a5rBOKYwdFJqktyhZlRLfwiMKJr1JtQnmTfpCPLSkToiCUEpVUEq1SX/EWhvj+FVbirtcBfQKcMQagx2gxPfSEgWglFoL9AQmpD9WEOKhJnVC/Ad2GB8ZV8f4mGkDxlybEkUpFYqxt2bPYi5KkZFHWkIIIYSwevJISwghhBBWTwIeIYQQQli93HJ45HmXeNCo3FcpUlInxING6oQQ5izWCWnhEUIIIYTVk4BHCCGEEFZPAh4hhBBCWD0JeIQQQghh9STgEUIIIYTVk4BHCCGEEFZPAh4hhBBCWD0JeIQQQghh9STgEUIIIYTVk4BHCCGEEFZPAh4hhBBCWD0JeIQQQghh9STgEUIIIYTVk4BHCCGEVTEYDCQmJmIwGIq7KOIBIgGPEEIIq7Jjxw4aNGjA6tWriY2NLe7iiAeEBDxCCCGsytGjRzl37hxTpkzhq6++IjU1tbiLJB4AEvAIIYSwGgkJCURGRrJixQpcXV0JCAjg8OHDxV0s8QCQgEcIIYTVSEhI4Nq1azzyyCOcOXOGF154gf79+3P37t3iLpooZhLwCCGEsBqhoaH89ttvAJQqVYohQ4bg4eHBpUuXirlkorhJwCOEEMJq3L17l4SEBHQ645+3WrVq4e3tzZdfflnMJcvqzJkzREVFkZKSgqZpxV0cq2dT3AUQQgghClONGjVwdXU1fd68eTM9evQoxhJZtnHjRsLCwnBzc6Np06Z07drVrNyicEnAI4QQwqo0b94cLy8v0+eM1p4HSXh4OIcPH+bHH38EQCnFgQMHaN26dTGXzHo9eFeBEEKIh15ycjJpaWmFsu2aNWseuEEIy5Yti6+vLzY2Nrz00kvY2dnlqfv8+fPnGTly5H0oofWRFh4hhBAPnPfeew8nJycmT56MUirP27m4uHD06FFCQkLw8PAgNTWVL7/8kiZNmhRhafMvMTGRmJgY9Ho9ixcvxsvLi0OHDtG2bdscW6SGDx/+QLZYlQQS8AghhHigBAcHs3PnTo4ePcrly5fR6/UopWjdujXPPPOM2bq2trZmAZGPjw+dO3c2tejs2LGD0NBQFixYcF/PITdnzpzh66+/xt3dHYPBgFIqT4nLAwcOxMPD4z6U0PpIwCOEEOKBMWnSJH766SdOnz4NwOLFi03L1q5dy6xZs8zWL1++PPb29qbPqampnDlzhgEDBvDHH38wefJkrl+/jo+PT7bHTElJISUlBYPBgKZp6PV6HB0dC/nMsqpZsybz58/P1xhBI0aMwM7OrghLZb0k4BFCCPHAOHz4MBcvXqRmzZqEh4fTsWNHdDodmqYRHBxsCg6SkpIICwszBUb3evLJJwFMrSZt2rQhICAAOzs7HB0d8fHxoUKFCpw5c4YNGzbw+++/c+vWLeLj46lWrRrvvPMO7dq1K9JzLVOmDD4+PpQpUybP20iwU3AS8AghhHhgjBgxgosXL9KtWzfGjx/Pt99+i52dHZqmcejQIVMAEx8fz5kzZ8y2XbRoEQ4ODly/fp3r16+bLTt79ix9+/YFjHk+jRo1wtfXl4MHD3L27FmzdS9dusRzzz1HYGAgbdu2LZLzNBgMZonVrVq14osvvsBgMEiOThGRgEcIIcQDY+jQody9e5dSpUqZtXwopXj00UdNn2NjY3n88cfR6/Wm77Zt28ann37KkiVL+Oabb2jWrBleXl4sX76cSpUq4ejoSFxcHElJSRw6dIh9+/ah1+vx9vamZ8+ejBo1Cr1ez/Tp0/n+++/Zs2dPkQY8SUlJxMXFERYWhru7O6dOnSImJgZ7e3tKly5NREQElSpVKpLjP4wk4BFCCPHA0Ov1lCpVKsd1kpOTad26NePGjaNBgwa4uLhQv359dDodlStXxsXFhfXr19OmTRs++ugjunbtytdff03p0qVJTEwkJSWFr7/+mmnTpvH888/zzjvv4ODgYNr/5s2b6dKlC7dv3yY1NRUbm6L5U3nixAk6dOhg6o6elJRErVq1AJg2bRrbt29n+/btkqRcSFQuWeEy1nUmO3fuRClF165di7soD7O8908tGlZXJ9atWwfAkCFDirkkooCstk506tSJZcuWUadOHbPvk5OTcXFxwcHBARcXF2rWrMmKFSsYM2YMP/zwA3PmzCEyMpKlS5cSGhpKuXLlsoxgbDAY6Ny5Mzt37rSYF7Nv3z5mz57NF198USStLPv27aNDhw45rlO6dGk6d+5Mr169suT5lC9fnsaNG5sFasLEYp2QFp48CAoK4r333uPnn39G0zQ6d+5MQEAAVapUKe6iCVEgqamp7Nu3jzFjxhAeHg7AqVOnmDFjBs7OzsVcOiH+36+//pol4MkQHx/P7du3iYiIYNu2baau6D4+Pmzfvh2DwUCNGjXMtomLiwPA2dk5x1wZnU7H0aNHCQsLK7LHSuXLl6d169a89NJLVKtWjcDAQAYOHIimaTz33HP8888/bNu2jd9++w17e3uznB97e3tcXFxMXfJtbGwYOHAggYGBdO3alb59+xbZ47iSSgKeXNy6dYsOHTrQrFkzxo8fT3x8PN999x2zZ8/m008/NXt+LERJoGkaa9asYcKECdSuXZuOHTsSFxfH4sWLadOmDU8//XRxF1E8xH7//XceffRRdDoddnZ2VKxYMdt1W7RoQYsWLfjrr7/Yt28fkZGRgDEYSEpKyjKuzYkTJ+jXrx9paWkEBAQQGxub7b79/Pzo3bt3nkY/LgilFGPHjuWNN94wfffuu++a3js5OeHg4ECjRo3w8vLC09OTo0eP8u+//5rKlHGzkuH1118HjAnaf//9N3v27CmSspdUEvDkYsGCBZQrV47333+f+vXrAzBgwACeffZZtm3bRu/eve9LGS5cuIC/v7+pq6UQBbVjxw7efvttPvroI9q3b0/dunW5efMm7733Hp9++indunUrspyFvEpISMDJyalYyyCKx+uvv067du1wcnLi0qVLnD59muDgYKKiovDw8OD27dvodDrS0tLw9/dn5syZnDhxgt69exMWFmbaT0ZLToawsDAmTZpEUFAQAC+++CIGg4HvvvuOPn36ZClHqVKlcHNzK7Lz1Ov1BAUFcePGDdzd3bMsHzduHHPnzmXjxo1UrlwZpRRr165lwoQJxMbG8uSTT+Lv759lu7S0NMLDw/ntt9+IiorC09OzyM6hxNE0LafXQ++pp57Szp07l+X7o0ePak8//XSRHvvPP//UWrdurXl4eGhly5bVqlatqnXt2lWLjo4u0uM+4HK7Zov6VaKdP39ea926tebp6aklJyebLYuPj9e6dOlS7NfX9evXteeee65Yy1DCWFWdaNOmjWZra6vZ29trOp1Os7e3N3tvY2Oj2dnZaYDm7u6uHT9+XEtJSdGmTJmi2dvba8nJydqmTZs0b29vs2t89+7dmp2dnWZvb69t3bpV69atm6bT6bRnn30227LMnDlT279/f2GfoqZpmnbw4EGtbdu22vnz5y0uT0pK0p544gmz7zZs2KC5ublpgPbWW2+ZLYuJidGmTZumTZ48Wdu/f79Wv3597a+//iqSspcAFq9V6eyfgxs3bvD2229bHKGzQYMG+Pj4ZBnrobDcvXuXsWPHUr16ddavX8/FixdZtWoVSik6dOhgNv7EmTNniI6OLpJyCOuhaRp79uzBYDBw4MCBLImaTk5OBAQE8MorrxRTCY0mTZpEcHBwjo8bhPVq164daWlpJCcnYzAY8Pb2xt/fnx49euDv70/37t3x9/dHp9Ph6emJo6MjNjY2ZiMjN23a1Gy29LS0NDZt2kSjRo2oUKEC7du3Z+bMmVSpUoXY2Ngie2yVGw8Pjyw90lJTU0lMTLS4/oABA6hbt262yz744APmz59Pu3btuHLlCv/880+hl7kkk0daOdiyZQstW7a0OHGdra0tffv2ZcuWLUUyc+2uXbto3Lgxb731FhUqVACgc+fOVKpUiVWrVvHcc8+xceNGfHx82LVrF8eOHWPNmjWSUySylZKSwtq1awkICMDX19fiOg0aNODmzZtFVgZN0zh79my2P9phYWG8+OKLHDlyhKioqHyNQCusw+zZs/n4449JSkpiypQp9OjRI0vybUYvrQEDBlC7dm3AGLBnBPE+Pj5mvbLS0tLYu3cvzzzzDPv27ePrr7/mpZdewtvbm8uXL3Px4kVTnfj+++/ZtWsX8+fPL/JzDQ8P5/bt22bfnTx5kpMnT+Lp6Ulqairbtm1j586dpuXnz5+3uK87d+5Qr149Bg8ezPLlywkLC+PSpUtFWv6SRgKeHISFhWX7wwzGH++IiIgiOfbnn3/O8uXLs4y/UKdOHd555x1mz55NSEgIPj4+NG3alK+++oq0tDQJeES2Tpw4gb29PR07dsx2HaUU3t7eRXL8K1euMGrUKP79918GDRrEG2+8gYuLi9k6X331Fe3ataNBgwZUr169SMohHmx2dnYsW7aMV155hbZt2+a5p1HZsmVNXbR//fVXsz/2mqbh4uLCuHHjiIiIYPPmzYwYMQIwBk8Z+T5RUVGsXr2arVu3kpqaWqTj39SvX59GjRpx48YNatasCRhb9nv16kVcXBx6vZ6EhAT+/vtvs5sQR0dHi/N82dnZsWPHDipVqkS3bt3w9/c3m2NMII+0/gs3NzfTIFGFKSwsjD59+lCuXDmLy0uVKsUHH3zAqVOnSEtL45dffqF///7Y2toWelmE9Zg8eTL9+vXLMSi2s7Pjo48+4sKFC4V67OvXrzNx4kR++uknvLy8mDt3LkuWLDF1I86QkJDA3r17+fDDD4s9cVoUD6UUffv2ZeTIkQwePJhDhw7labsRI0bQoEEDwBi43Dsh5507dzh37hyTJk3i8uXLbNmyhYSEBNzd3U2tRGfPnmXLli2UK1eOvXv3ZjtPV2FwcXExteJk0DSNa9euERMTw/Xr10lJScHZ2ZlHHnmEPn360K9fPwIDAy22Pul0OipWrIiNjQ1NmjQhJCSEwYMHF1n5SyIJeHJQsWLFHMckqVu3bpH00vruu++oUaNGrvOplClThj/++AM3Nzfmz59PSkpKoZdFWIdr166RlJTEsGHDcl337NmzfPvtt4V27LS0NObPn88333zD1KlTWbduHQMHDmTu3LkWcyfmzJmT60i7wro5OzszZswYKleubNZVOzcZ0zWA8RFX5nSE6OhoRowYwfz58wkJCeHll18mODgYOzu7LD0CW7duzdmzZ4mIiKBy5cqFc1J5oJTCz88PT09PbGxsWLp0KatXr2bt2rVs3ryZTZs20bt3b+rVq5dlW4PBYHaj4uzsLNNS3EMCnhzY2dnleDes1+u5evVqoSdXRkVF5SmJbsCAASxdupTnn3/eYhKqEBm+/PJLRo0aladWwLS0NNMfjcIQFxfHZ599xvTp05k9ezZ16tRhxYoVNGzYMEty5oQJE5g1axaDBg0qtOOLkql27dq0atWKX375hcWLF5stU0pRpUoV09QPGVJSUhg5ciT29vbcuXPHNA6Pvb09y5cvJzw8nMDAQAwGA9HR0WYD+YFxZGMvLy9+++03DAYD7dq1u69Bg52dHd9//z0HDx6kfv36/Pbbbzz++OM0bdrUYi5pZo6OjkyYMIEZM2YQEBBAaGjo/Sl0CSJtxjnw8/OzOD5CZkWRZ2AwGLI09VtSqlQpBg8ejLOzs4yOK3KUkJBAq1atcv3RBKhWrRqdOnXKdvm5c+eoUaNGnvYFMGvWLBo2bGh2p+7i4sKQIUN47733eP/9903fu7m5MXny5DztV1i/lStXcuvWLbMeV2AMDBYuXEjv3r3p3bs3LVu2BOCxxx7DYDDQvXt3/v77b7NW8qeffpqVK1fyxRdfAMbrPCEhwWzwvqZNm/Lpp5+ybNky4uPj2b9/P1evXr2vo+pnnGv16tU5efIkISEh2XYyyCwwMBAvLy927doFwO7du/ntt9+KtKwljQQ8OWjWrFlxFyFHer1eRsUVha5SpUpZ7mq3b9/Onj170DTNNNx9XoPsf//9l7Fjx2b5fujQoXTv3r1Qyiysk62tLevXr7eYfOvk5ISvr69Zb6y3337bNNnnrFmzzAIevV7PkCFD6NatG0opypUrx6hRo7KMVvz000/TqlUrQkND6du3L5cvXy7SgCe71tTXXnuNjh078vXXXzN9+vRc9+Pi4sLEiRP54IMPqF+/PklJScTGxkpPx0wk4Mmn1NRUUlNT8zRhW3x8vGnd/OQkODk5SXa9yLf4+Hju3r1LamoqISEhLFy40LTs5MmTrF69Gj8/PxITEylbtiyJiYnEx8eb5iPKSUxMjOnRra2tLcnJyXkOeGxsbCQwFwWW3W9tixYt2LVrV5aRhDOS3bPLgczcah8UFGTxt7lcuXKUKVOGfv36sX//flq3bp1rTmVBhYaGomlalhbTZs2a0aVLF/bv38/w4cNNw5NkyHhcl0Gv1+Pv78+hQ4eYP38+S5YsYffu3fdlNoCSQgKeXAQFBXHr1i0iIiJITEzk8uXLhIaG0r59e8AYnHh4eBAZGUnz5s2Ji4vj+vXrhIWFsXbtWq5cucKgQYOYPHlynoOYvn37FumQ5qJk0TSN3bt3c+PGDXx9fSlbtixXr17l6tWrpnVSU1NZu3YtJ0+eJCIiAldXV9zc3DAYDKZchtq1axMcHIymaYSGhhIaGkrZsmUpW7asxeMaDAZiY2O5efMmbdu2NbX6nDt3jtKlS+e5/LVq1bKYC6eUyvKoQoi8cnBwyBIE5JenpydPPfWUxWU2Nja0bt2aCRMmMHny5CLLkRw3bhzPPfdclv3b2Ngwe/ZsnnrqKc6fP5/lXMPDwy1OwdKxY0eaNGnCokWLiI+PL5Iyl1QS8KQzGAzs378fg8HAzz//bBpB+cSJE0RHR3P16lVq1KiBjY0Nt27d4vTp0+zbtw9nZ2c8PT0JDw9n5syZHDt2jEOHDnHp0iVeeeUVevfuzSOPPJKvLrZBQUHUrl1bmiIFYBybY/jw4Vy9epU6derg7u7O5cuXuXz5stl69vb2VKhQAScnJz755BO8vLxIS0tj1apVnDlzhnnz5pGSkmIaZj0kJAQ3N7ds89TS0tJYsWIFO3bswMnJiQULFuDl5cWJEyfy1MKZ4emnn7YY8Oh0OtONgxDFYcaMGTRs2DDb5T179sTOzq7Ihkjo2LEj69evz3Z5rVq16NmzJ8uWLaNVq1Zm9cjGxsZivfr9999NM7zLfHTm1L3NYvfIceGDJCPJNyPi1TSN2NhYXF1duXnzJikpKVy7dg29Xs+VK1cA+Pjjjzl//jw6nQ6lFPHx8RgMBvR6PWXLljUNBlWjRg0mTJiAo6Mjhw8f5uDBg0ydOpW//vqL//3vf8THx+Pl5cW5c+dQStGnTx9effVVypcvb3GAqNwkJydnezHn9/8HZN+0W0LlLVO26Nz3OpGcnEyNGjVM44oopbh16xYVK1bkww8/5NSpUwwbNgydToetrS0DBgxg9+7d2NnZkZaWxsSJE3FwcGDOnDnZ9tLSNM2U+5DRtJ6cnEyvXr1o2bIl8+bN47HHHmPDhg35vqZ/+OEHunXrZvE63Lt3L2fPnmXUqFH5/L8iMnno6oS1SEtLIzIyMscZ4efNm4etrS3jxo0z1aGkpCSSkpLM8pcAjh49ytNPP826devo3LlzkZb9AWexTlhFC094eLhpZMzt27fTu3dvUlJSWL58OePHj2fevHkWB1Lr2LEjVatW5fbt2zRv3hyAI0eOsGDBgmxH9yxTpgyOjo6UK1eOzp07c/ToUdOyWbNm8cQTT+R5ZNDsFCR/x2AwsH37dtLS0tA0zdRCpZSibt26dOjQ4T+VSRQfe3t7jh49anrOHxQUxIgRI9i2bRv16tWjX79+WdbPoJSicuXKJCYm5tglPSEhgS1bttCxY0ezBM1r167Rp08fqlSpwsKFC1mxYgWTJk3KV/krVqyYbY8uW1tbbt26le22mqZx6tQp6tevn69jClES6PX6HIMdgClTpmT5zsHBwWIrq4+PD506deL1118nKSmJTp06Feim21pZRcATEhLC6NGj0ev1TJ482dSC06tXL65cucKAAQNMo1pm1qVLF4KCgjh48CAzZ84EjEFLTipXrkyzZs0wGAymaPvAgQO0bt26CM4sZ4GBgYSEhBAWFobBYGDz5s2mMSkyjzJar149AgMDadKkyX0voygcmXNdgoODuXbtGgkJCblup9PpaNmyJXv27MlxvUuXLrF69WoaNmxoCnhsbGx49dVXSU1NZfjw4djY2HDx4sU8lffYsWOsXLky1/Gkrl+/TkREBJ8idEQAABZoSURBVOXLl+fGjRtcuHDBrNeKpmkEBwfz/vvv065duzwdW4iHlZubG1OnTqV///4MGzaMzp07U7ZsWZYsWSIjl2MlAU/Lli25ePEiSik8PDz4/vvv+fXXX/H396dTp07Y2tqi1+st/oPf2/JTvnz5HJ97litXjipVqpCammpKMluyZAktW7bE39+fn376Kcuz1tzExcWxc+dODhw4ABhzeIKDg7Osl/GIwsHBAaUU0dHR2NrakpKSwtChQ3n//fepXbs28+bNY+nSpaxZs4bPP/8cNze3fOVciAebra0tmqZlGTr/v4iJicHNzc3sblOv1zN8+HDT51atWhEZGUl0dHS2055kePPNN9m1axeOjo7Url2ba9euoWkaN27cAIz1SClFSkoKN2/e5NVXXyUtLY27d++aWikzHssqpejVqxfTpk2jatWqgPFxW9OmTS2OOCvEw6xx48Zs3LiRZ555hu3bt+Pk5MSiRYuKu1gPBKsIeOzt7alWrRoAERER/PDDD9y4cYPJkyezYMGCfHWJ7datW5Yf87t373Ljxg3c3d0pVaoUR44cwdbW1jT/ysiRI9Hr9bRs2ZJ33nknX5N4pqSkMGDAAH7//Xfat29PmTJl8PDwsDhpna+vLzExMTRv3hydToder6dfv35ZciM++ugjqlatyltvvUVAQIC15fA89EqVKpXrgJgFYW9vn+N1W7NmTeLj4zlz5kyuj22bN29OtWrV6NKlCz179jR937ZtWyIiIpg+fTo9evQgNjaWJUuWAMbARq/Xk5KSQnBwMD/++CM1atSgSZMmnDp1itdee83sGO3bt2fv3r3/4YyFsE5NmjThn3/+4auvvqJatWoyz2I6qwh4MitbtiyTJ0+mcuXKLFu2jL1799K1a9c8/4P7+PiYNamnpqYyYsQIwsPD8fb2ZtWqVYSGhuLr62sKeDKPSpvfIfn1ej2NGzemfPnyLFy4MNeeWWlpafz8889069Yt23UyHiPIRf5wMhgMXL582ZR0f6/k5GTmzp1LmTJl6N69u+lmoTDNnDkzS6D9xx9/mIZvGDlyJH///Tcff/wxCxYsAOD06dOcPHmSfv36sXv3bvz9/WnUqBEtWrTgxIkTPPvssyQnJzNkyBACAwMLvcxCWJNy5cpZHPDzYWZ1t/729vb4+fnh6urK6NGjSUpK4p9//snz9nfu3GHdunWmOVaSkpLYunUrZ86c4ZdffmHgwIHcuXOn0Mqr0+no1q0bPj4+pmAnPj6eqKgoi+unpqaybNmyQju+KHk8PT1zTOLVNI1Lly5ZXJaSksKHH37I+++/z6xZs1i+fHmeg/S0tDSSk5PztK5erycyMpLDhw+bHk0dOnSIsWPHsnLlSl5//XW+/PJL/vjjD1OZf/31V86ePYtSivbt2zN69Gjatm2LnZ0dTZs2pXbt2lStWpVZs2Yxb9485s6dm6eyCCEEWGHAk1mZMmVwdXXNV6vLsWPHOH/+vOnzli1bGD9+PGFhYWzdupWdO3fy6aefFkVxTebNm0fTpk3ZsGGDKQE7s8Kc2FGUPFFRUZw8eTLHdbIbbuKvv/5i1apVPP/887z88sssWLCAzZs352kC3FOnTrFjx4489yK8ceMGK1asMF3Djz/+OPXq1cPZ2Zm3336bkSNH8uabbwLGQOyzzz4zbWtnZ5elhWj58uU4ODhgb2/PgAEDaNGiRZ7KIYQQYOUBj1LKYv5KTEwM3333HTdv3syyrF27dnh7e5s+r1mzhsmTJxMUFMT06dOpX79+oc+OXrFiRbN5u6pUqUK9evV48cUXGTZsGCEhIYV6PGHdsuuNoWkaQUFBdOrUiYCAACZNmkTPnj15//33CQsLy3W/N2/epFGjRnmayBCMc3Lp9XrTXEV+fn4EBgaaHrlOmzbNVFZN00hMTMxx0lJPT888T1gqhBD3suqAxxKDwcDSpUsZPnw4TZo0MRue3xKdTkfp0qX59ttvKV26NDNmzCj0MpUpU8Zs7JNBgwaxceNGdu7cye3bt+nSpQspKSmFflxRMmXuwWTJzJkzLV4vd+/eZdq0aaZRvMuUKUPVqlW5cOFClslCLW07adIkGjdunGWws+y4urri7e1t1jX9o48+MuWWOTo6mgUwlSpVKpbhHYQQD4eHLuCJjIxk9erVPP/886SlpTFo0KBct0lISCAqKooZM2bkmFQcExNDYmJigcp14sQJ02CBpUqVwtXVlXbt2rFx40bc3d2zfUQhHj63b9/ONscLjPO7ZTdcvaenp6nX4rFjx9iyZQulSpXKcdiClJQUfvjhBxwdHXn55Zf/U9lz6l2m0+mkR6EQoshY9a/LhQsXuH37ttnd6/Lly6lWrRrz5s1j5cqV1KpVK9f9hISE4ODgkGtT/rfffstjjz2W7ykhnJyc+OOPPzh37lyWZdWqVcvTnFqpqaksXryY6OjofB1blDwZrTvZPbqqWLEiERERFpdlJDynpKTw9ttv07lzZ9q3b09kZGS2x/v22295+eWXmT59eqGO2nrkyBFOnz7NsmXLiIuLk6BeCFGkrK5bemanTp0iNTWVTz75xDTR4t69e/nkk08AePLJJylTpkyWHi3Hjh0zzakFxl5Tjo6OlC1blkceeYTAwEBT8JOSkkJiYiK//vorq1atYtWqVfkOeApjXJUpU6awfv16oqKi8tyTRpQc8fHxXLp0yey6y/xYKyoqigsXLqBpGjVr1sw21yXjer106RLx8fHMnTuXO3fu0KBBgyz5M1FRUezbt4+XXnqJGjVq8MQTTxTqOQUEBHD16lWmTJnCO++8YxrmIUNcXBzLli1j+fLl9OnTh+nTpxfq8YUQDxerDXhCQ0OZOHEi58+fp2LFijg4OHDz5k3S0tJ4/PHHTeu1bt06S97AlStXzO42nZycTEP7Ozs788QTT5gGJ/zpp59YvXo1Bw4cYNGiRYU+58/NmzdzHZ4f4J9//mHOnDksXbqUs2fPFmoZRPH766+/GDlyJFu2bDF9lxHwhISE0LdvX/79918Apk6dmu01Exoayp49e/jggw9o1aoVzs7O2NnZcevWLZycnEz5NTdv3qRHjx4cOXIEPz8/Nm/eXOBxnSzlyZ0/f56rV6/yzDPP4ObmRnR0NPHx8WbrLFy4kFmzZqFpGgsWLMDBwSFPdUEIISyxuoAnKCjIdOd4/fp1xo4dS8+ePbG3t2f16tWEhITkO0+gdu3a1KhRAzAmb965c8cU8Bw5coTvv/+eb775ptDvgMH4OKF9+/YcPHiQ1atXM2zYMItN/3q9nmHDhhETE0NAQEChl0MUv/Pnz2eZaDM+Pp4lS5YQFBTEhAkTiI6O5uOPP6ZVq1ZZtrexsaFXr16sXLmS6Ohopk6dChivna5du1KhQgXTtCrBwcFERESQlpZGr169sh3EMDdPPPEEp0+fNs09ZzAY2LJlC1u2bKFu3bosX76ccuXKERkZyZAhQ8y2TU1N5amnnqJfv35s3bqVuXPnSlKzEKLArC7giYyMZN26dfj4+HDy5Ek8PDxMCZk///wzAwYMyNckasnJycycOZPFixcDWQdfmzJlCv/88w/r1q2je/fuBS63wWAwDXaYIWPQxMDAQFauXImtrS3Hjx/PMu1EQkICHTt2RKfT0aVLF9atW1fgcogHj8Fg4PDhw2iaRkJCgtk4OCdOnGD16tVs3ryZJ554gtTUVG7cuGExeV6v19O/f3+eeeYZYmNj+fzzz/Hz86NNmzaMHDmS48ePmx6FeXp68uKLL3LixIn/VPY6deqwY8cOU8CTnJzMyJEjqV69OqtXrzbdOLi6upo9hktNTSUxMZFXX32Vxx9/nF69euXYZV0IIXJjdUnLXl5eNGrUiAkTJlCpUqUsvU9Kly6d733mNEaJs7Mz69atIyYmJt/7zezeVpvDhw/z9ttv8+OPP6LX6xk9ejR///03P/30U5ZHCz/++CNPPfUUNjY2pmkqhPVITU3ll19+YfDgwaaJNcH4ODUmJoZHH32Uxo0b4+DggJOTE0uXLs328dOjjz7Kp59+iru7O6+99hpPPvkkY8aMYcOGDWbrVa9enTfeeIOJEydy9epVi2NW5dWePXvMHr/Fx8fTvn37LDk7mV24cIFdu3aZgjtnZ2dat24tvbiEEAVmdb8etWrVYsWKFWzevLlQnvdrmsaVK1dMXcYvX77Mn3/+aZaYbGtrS0JCQrY9Y/Jr3759jBo1is8++4w33niDdu3aMWPGDNzd3fHw8MiSkBobG5vvRGlRcuh0Oho1akT16tXZtGmT6bp+9913CQgIoG3btmY9Eb29vXMcoK9Hjx4EBgaycOFCunbtSmBgIF9++aXFdevUqYNSqtAGvzx//jxeXl6EhoYSHBycr2179+4t17kQosCsLuABaNGiBba2thZzXe59bJSbzZs3c/PmTUaNGsWff/5JTEwMly9fNvuDYm9vz9y5czl69Oh/LjsYE5BDQ0M5duwYgwYN4vPPP88xYfTq1askJCSYPm/atAk7O7tCKYsofkop4uLiOHz4MH/88QcGgwFXV1eqVKnCoUOH+Oyzz8wePen1egYPHmz6bGdnl6Vls1OnTowZM4ZNmzYRHh7Ot99+a9Z6lMHV1ZXy5ctz9+7dApc/80CF/v7+HD9+nDp16piNWB4VFUWjRo1Mn2vUqEG3bt3MBlBs1aoVmzZtKnA5hBAPN6sMeJRS6PX6LMGNh4cHW7duzdJt29IPfYYKFSqwc+dOrly5QteuXbMd8Tg1NZXjx48XSvnHjRtHo0aNOHnyJLa2trmOw2MwGMy6KJcuXZoff/yxUMoiip9er2f48OFER0cTExPDjz/+yMSJEwkKCqJOnTrMmjULPz8/0/o2NjYMGzbMbB+JiYlZrl29Xo+LiwteXl6UK1eO2NjYbAObggY8cXFxDB061JQ3Z29vj7u7e5YAftSoUXTs2NGsbPb29qxZs8ZUj+3s7HBzcytQOYQQwioDHoAJEyZw8OBBs+969OjBnj17mDJlCleuXCEtLY1Fixbx/PPPExQUlO2+fH19+eKLL1i7dm22Cc+FnVswZswYFi1aVKBtZ8+ezUsvvcT3339fqGUSxadOnTo88sgjREVFsWDBAsAY2Lz11lvUq1cvx22VUhw+fNg0p1V24uLiLI7hlPFIqyADA+7atYvQ0NAs39vY2Jg9ntLr9XTu3NlsHScnJ7Zs2cK1a9dM34WHh5u1ZgohRF5ZbcDTuXPnLAFD5cqVee2119i0aRONGzemYsWKvPbaa+zYsYPbt2/nuL+6devSs2fP+5Y0+dRTT3H37t0c50zK4OzszPr160lLSyM+Pp7jx4/j4ODAmDFjOHLkyH0orShqLi4uNGzY0GyQSp1Oh6OjI/v27ctx28aNG9OzZ88cpz2xt7fH0dHR4vXWt29fHBwcChTwhIeHW3yMXKVKFbMcu6SkpCzrjBkzhg4dOtC0aVNmzZqFv78/fn5++Pr6SgumECLfrDbgUUpZ/BEdMGAAS5cupXnz5nh6ejJ06FDWrl1L06ZNi6GU2dPr9ZQuXZoLFy7kuu6wYcM4duwYX331FXPnzmXw4MGEhITw8ccf53miR/HgmzBhAo8++igbNmygSZMmgDEQym1kbTs7O/R6fY4T0DZq1Ig5c+ZYvF7c3d1Zvnx5gTsBtGrVKsuNgk6n44MPPjDt01Iw5ejoyPLly6lSpQoBAQH89NNPVK5cGTs7O1555RWZUFcIkS9WNw5PbnQ6HX379qVNmzZERkbSsGHDLD1a+vXrV+y9QWxtbenXrx87d+5k7NixOa7r4eGBr68vo0ePpnTp0jRs2JBBgwbRo0ePHHvriJJHp9PRrl07s6T0TZs2UbVqVcqXL0/NmjUtDhJ45cqVHLuB29vbm43vk5m7u3uB59Dq168fFSpUyHZZbvWsUqVKTJ06lWeffZZ33nmHnj17cuvWLcaOHStzbwkh8uWhC3gyVKhQIdsf4hdeeCHbH2IXFxe8vb2LpEyZE0OVUlSpUiVPLTxgnBS1f//+9O/fn3379mEwGPI1wKIomXx9falevTqjR49Gp9Nha2vLjBkzmDRpklmriqenZ4GDFhsbmwI/ys1uqpWEhARatWplCsizq28pKSn873//480332TatGmmZOc9e/ZIT0QhRL7IX0QLcuoC3qhRI7Pus4WlTp06hIWFoWmaWavMkSNHiIiIMM3llR1nZ2d8fHzo3bs3FStWLPYWKnF/VKhQgbFjx+Lh4UFKSgp///0306dPx9fXlx49epjWGzlyZDGW0lxycjJBQUFmPcv69+9v8ZrVNA1XV1cGDhxoVi/lUa0QIr8k4HlAJCcns27dOrMf9sqVK9O0adN85U50796dgQMHFlUxxQOoa9eudOzYEYPBQHBwMJ999hlLly41C3geJHfu3OHGjRtm37344ovZru/h4UHdunWLulhCCCtntQGPjY1NlskIi5K9vT3Ozs4F3r5v376kpqaaPTqoVq0ar7/+ep5nqU5OTs4yuaR4OGTk3zRs2JA5c+Ywfvz4Qt1/YT4+cnV1pVmzZgV+xCaEEAVhtQGPXq/nueeeu2/H8/X1/U+Dojk5OTFixAiz75RSFoOdUqVKWdyHo6MjcXFx3Lp1S5r8H2LOzs6sWbOmUPf5wgsvFFpOmFKKV199Nc/rx8bGcunSJapWrVooxxdCPJystlv6/ebg4JBtEnRhsrW15c0337S4rHLlyly/fr3Q5j0SIkPfvn2LZeLOjN6K27dvv+/HFkJYFwl4CsHdu3eZMWMGTk5ORX4snU5Hs2bNLC5zcnLCy8uLcePGcfLkST744ANWr14t3XdFiaXT6WjRogWXLl36T/N5CSGEBDyFwM7Ojo8//ri4iwHAoEGDSExMxM/Pj0WLFvHLL7/ke8JUIR4krq6uHDhwgNOnTxd3UYQQJZjV5vA8rCpWrMjixYuJjo7G3d0dPz8/GY9HlGi1atWiZcuWTJ06lR9++CHPSfxCCJGZ/CW0Qu3bty/uIogi4u3t/dCNnu3g4ICfnx9r1qyhc+fOLF68mFq1auHg4FDcRRNClCAql/wOSf4QD5ri/mtfrHUiISHhvuSKPYjeffdd3nzzTWxtbdm7dy8tW7Ys7iI9KB7qOiGEBRbrhOTwCFGCPKzBDsDEiRMZOHAgd+/elYlDhRD5Ji08oqSRu9mHWFxcHMHBwdSqVQsXF5fiLs6DQuqEEOYs1gkJeERJIz/uQpiTOiGEOXmkJYQQQoiHkwQ8QgghhLB6EvAIIYQQwupJwCOEEEIIqycBjxBCCCGsngQ8QgghhLB6EvAIIYQQwupJwCOEEEIIqycBjxBCCCGsngQ8QgghhLB6EvAIIYQQwupJwCOEEEIIqycBjxBCCCGsngQ8QgghhLB6EvAIIYQQwupJwCOEEEIIqycBjxBCCCGsngQ8QgghhLB6EvAIIYQQwupJwCOEEEIIqycBjxBCCCGsngQ8QgghhLB6EvAIIYQQwupJwCOEEEIIqycBjxBCCCGsngQ8QgghhLB6EvAIIYQQwupJwCOEEEIIqycBjxBCCCGsngQ8QgghhLB6EvAIIYQQwuopTdOKuwxCCCGEEEVKWniEEEIIYfUk4BFCCCGE1ZOARwghhBBWTwIeIYQQQlg9CXiEEEIIYfUk4BFCCCGE1fs/ZOiaXY8G9wEAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 720x720 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_ck9wd_AnWFa"
      },
      "source": [
        "def generate_batch(orig_groups, forg_groups, batch_size = 32):\n",
        "    '''Function to generate a batch of data with batch_size number of data points\n",
        "    Half of the data points will be Genuine-Genuine pairs and half will be Genuine-Forged pairs'''\n",
        "    while True:\n",
        "        orig_pairs = []\n",
        "        forg_pairs = []\n",
        "        gen_gen_labels = []\n",
        "        gen_for_labels = []\n",
        "        all_pairs = []\n",
        "        all_labels = []\n",
        "        \n",
        "        # Here we create pairs of Genuine-Genuine image names and Genuine-Forged image names\n",
        "        # For every person we have 24 genuine signatures, hence we have \n",
        "        # 24 choose 2 = 276 Genuine-Genuine image pairs for one person.\n",
        "        # To make Genuine-Forged pairs, we pair every Genuine signature of a person\n",
        "        # with 12 randomly sampled Forged signatures of the same person.\n",
        "        # Thus we make 24 * 12 = 288 Genuine-Forged image pairs for one person.\n",
        "        # In all we have 120 person's data in the training data.\n",
        "        # Total no. of Genuine-Genuine pairs = 120 * 276 = 33120\n",
        "        # Total number of Genuine-Forged pairs = 120 * 288 = 34560\n",
        "        # Total no. of data points = 33120 + 34560 = 67680\n",
        "        for orig, forg in zip(orig_groups, forg_groups):\n",
        "            orig_pairs.extend(list(itertools.combinations(orig, 2)))\n",
        "            for i in range(len(forg)):\n",
        "                forg_pairs.extend(list(itertools.product(orig[i:i+1], random.sample(forg, 12))))\n",
        "        \n",
        "        # Label for Genuine-Genuine pairs is 1\n",
        "        # Label for Genuine-Forged pairs is 0\n",
        "        gen_gen_labels = [1]*len(orig_pairs)\n",
        "        gen_for_labels = [0]*len(forg_pairs)\n",
        "        \n",
        "        # Concatenate all the pairs together along with their labels and shuffle them\n",
        "        all_pairs = orig_pairs + forg_pairs\n",
        "        all_labels = gen_gen_labels + gen_for_labels\n",
        "        del orig_pairs, forg_pairs, gen_gen_labels, gen_for_labels\n",
        "        all_pairs, all_labels = shuffle(all_pairs, all_labels)\n",
        "        \n",
        "        # Note the lists above contain only the image names and\n",
        "        # actual images are loaded and yielded below in batches\n",
        "        # Below we prepare a batch of data points and yield the batch\n",
        "        # In each batch we load \"batch_size\" number of image pairs\n",
        "        # These images are then removed from the original set so that\n",
        "        # they are not added again in the next batch.\n",
        "            \n",
        "        k = 0\n",
        "        pairs=[np.zeros((batch_size, img_h, img_w, 1)) for i in range(2)]\n",
        "        targets=np.zeros((batch_size,))\n",
        "        for ix, pair in enumerate(all_pairs):\n",
        "            img1 = cv2.imread(pair[0], 0)\n",
        "            img2 = cv2.imread(pair[1], 0)\n",
        "            img1 = cv2.resize(img1, (img_w, img_h))\n",
        "            img2 = cv2.resize(img2, (img_w, img_h))\n",
        "            img1 = np.array(img1, dtype = np.float64)\n",
        "            img2 = np.array(img2, dtype = np.float64)\n",
        "            img1 /= 255\n",
        "            img2 /= 255\n",
        "            img1 = img1[..., np.newaxis]\n",
        "            img2 = img2[..., np.newaxis]\n",
        "            pairs[0][k, :, :, :] = img1\n",
        "            pairs[1][k, :, :, :] = img2\n",
        "            targets[k] = all_labels[ix]\n",
        "            k += 1\n",
        "            if k == batch_size:\n",
        "                yield pairs, targets\n",
        "                k = 0\n",
        "                pairs=[np.zeros((batch_size, img_h, img_w, 1)) for i in range(2)]\n",
        "                targets=np.zeros((batch_size,))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eMaOGzbRnWFb"
      },
      "source": [
        "def euclidean_distance(vects):\n",
        "    '''Compute Euclidean Distance between two vectors'''\n",
        "    x, y = vects\n",
        "    return K.sqrt(K.sum(K.square(x - y), axis=1, keepdims=True))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q2QzzPdsnWFd"
      },
      "source": [
        "def eucl_dist_output_shape(shapes):\n",
        "    shape1, shape2 = shapes\n",
        "    return (shape1[0], 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YZogiZ3UnWFf"
      },
      "source": [
        "def contrastive_loss(y_true, y_pred):\n",
        "    '''Contrastive loss from Hadsell-et-al.'06\n",
        "    Source: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf\n",
        "    \n",
        "    Explanation:\n",
        "    When ytrue is 1, that means the sample are duplicates of each other, \n",
        "    so the Euclidean distance (ypred) between their outputs must be minimized.\n",
        "    So the loss is taken as the square of that Euclidean distance itself - K.square(y_pred).\n",
        "    When ytrue is 0, i.e. the samples are not duplicates, then the Euclidean distance \n",
        "    between them must be maximized, at least to the margin. So the loss to be minimized\n",
        "    is the difference of the margin and the Euclidean distance - (margin - y_pred).\n",
        "    If the Euclidean distance (ypred) is already greater than the margin, \n",
        "    then nothing is to be learned, so the loss is made to be zero in \n",
        "    that case by saying K.maximum(margin - y_pred, 0).\n",
        "    '''\n",
        "    margin = 1\n",
        "    return K.mean(y_true * K.square(y_pred) + (1 - y_true) * K.square(K.maximum(margin - y_pred, 0)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X_ZCMO1PnWFg"
      },
      "source": [
        "def create_base_network_signet(input_shape):\n",
        "    '''Base Siamese Network'''\n",
        "    \n",
        "    seq = Sequential()\n",
        "    seq.add(Conv2D(96, kernel_size=(11, 11), activation='relu', name='conv1_1', strides=4, input_shape= input_shape))\n",
        "    seq.add(BatchNormalization())\n",
        "    seq.add(MaxPooling2D((3,3), strides=(2, 2)))    \n",
        "    seq.add(ZeroPadding2D((2, 2)))\n",
        "    \n",
        "    seq.add(Conv2D(256, kernel_size=(5, 5), activation='relu', name='conv2_1'))\n",
        "    seq.add(BatchNormalization())\n",
        "    seq.add(MaxPooling2D((3,3), strides=(2, 2)))\n",
        "    seq.add(Dropout(0.3))\n",
        "    seq.add(ZeroPadding2D((1, 1)))\n",
        "    \n",
        "    seq.add(Conv2D(384, kernel_size=(3, 3), activation='relu', name='conv3_1'))\n",
        "    seq.add(ZeroPadding2D((1, 1)))\n",
        "    \n",
        "    seq.add(Conv2D(256, kernel_size=(3, 3), activation='relu', name='conv3_2'))    \n",
        "    seq.add(MaxPooling2D((3,3), strides=(2, 2)))\n",
        "    seq.add(Dropout(0.3))\n",
        "    seq.add(Flatten(name='flatten'))\n",
        "    seq.add(Dense(1024, activation='relu'))\n",
        "    seq.add(Dropout(0.5))\n",
        "    \n",
        "    seq.add(Dense(128, activation='relu')) # softmax changed to relu\n",
        "    \n",
        "    return seq"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ATNgZH4DnWFi"
      },
      "source": [
        "input_shape=(img_h, img_w, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fERanusdnWFk"
      },
      "source": [
        "# network definition\n",
        "base_network = create_base_network_signet(input_shape)\n",
        "\n",
        "input_a = Input(shape=(input_shape))\n",
        "input_b = Input(shape=(input_shape))\n",
        "\n",
        "# because we re-use the same instance `base_network`,\n",
        "# the weights of the network\n",
        "# will be shared across the two branches\n",
        "processed_a = base_network(input_a)\n",
        "processed_b = base_network(input_b)\n",
        "\n",
        "# Compute the Euclidean distance between the two vectors in the latent space\n",
        "distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)([processed_a, processed_b])\n",
        "\n",
        "model = Model(inputs=[input_a, input_b], outputs=distance)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VD6jzf-XnWFn",
        "outputId": "ca10f707-7776-4221-f697-1efc361d5e1f"
      },
      "source": [
        "batch_sz = 128\n",
        "num_train_samples = 276*120 + 300*120\n",
        "num_val_samples = num_test_samples = 276*20 + 300*20\n",
        "num_train_samples, num_val_samples, num_test_samples"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(69120, 11520, 11520)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eGGpGBl-nWFq"
      },
      "source": [
        "# compile model using RMSProp Optimizer and Contrastive loss function defined above\n",
        "rms = RMSprop(lr=1e-4, rho=0.9, epsilon=1e-08)\n",
        "model.compile(loss=contrastive_loss, optimizer=rms)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ez4LVXT3nWFs"
      },
      "source": [
        "# Using Keras Callbacks, save the model after every epoch\n",
        "# Reduce the learning rate by a factor of 0.1 if the validation loss does not improve for 5 epochs\n",
        "# Stop the training using early stopping if the validation loss does not improve for 12 epochs\n",
        "callbacks = [\n",
        "    EarlyStopping(patience=12, verbose=1),\n",
        "    ReduceLROnPlateau(factor=0.1, patience=5, min_lr=0.000001, verbose=1),\n",
        "    ModelCheckpoint('./signet-bhsig260-{epoch:03d}.h5', verbose=1, save_weights_only=True)\n",
        "]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yU3jpTHWnWFt",
        "outputId": "436c71ff-5b3e-449c-e931-65d68c6919de"
      },
      "source": [
        "results = model.fit_generator(generate_batch(orig_train, forg_train, batch_sz),\n",
        "                              steps_per_epoch = num_train_samples//batch_sz,\n",
        "                              epochs = 5,\n",
        "                              validation_data = generate_batch(orig_val, forg_val, batch_sz),\n",
        "                              validation_steps = num_val_samples//batch_sz,\n",
        "                              callbacks = callbacks)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/engine/training.py:1844: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
            "  warnings.warn('`Model.fit_generator` is deprecated and '\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "540/540 [==============================] - 225s 417ms/step - loss: 0.1349 - val_loss: 0.3785\n",
            "\n",
            "Epoch 00001: saving model to ./signet-bhsig260-001.h5\n",
            "Epoch 2/5\n",
            "540/540 [==============================] - 219s 406ms/step - loss: 0.0666 - val_loss: 0.4109\n",
            "\n",
            "Epoch 00002: saving model to ./signet-bhsig260-002.h5\n",
            "Epoch 3/5\n",
            "540/540 [==============================] - 218s 404ms/step - loss: 0.0340 - val_loss: 0.4721\n",
            "\n",
            "Epoch 00003: saving model to ./signet-bhsig260-003.h5\n",
            "Epoch 4/5\n",
            "540/540 [==============================] - 218s 405ms/step - loss: 0.0207 - val_loss: 0.5076\n",
            "\n",
            "Epoch 00004: saving model to ./signet-bhsig260-004.h5\n",
            "Epoch 5/5\n",
            "540/540 [==============================] - 219s 405ms/step - loss: 0.0152 - val_loss: 0.2985\n",
            "\n",
            "Epoch 00005: saving model to ./signet-bhsig260-005.h5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8-P6xy_JJk3e"
      },
      "source": [
        "### Accuracy ROC"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H6sQrs2VnWFx"
      },
      "source": [
        "def compute_accuracy_roc(predictions, labels):\n",
        "    '''Compute ROC accuracy with a range of thresholds on distances.\n",
        "    '''\n",
        "    dmax = np.max(predictions)\n",
        "    dmin = np.min(predictions)\n",
        "    nsame = np.sum(labels == 1)\n",
        "    ndiff = np.sum(labels == 0)\n",
        "   \n",
        "    step = 0.01\n",
        "    max_acc = 0\n",
        "    best_thresh = -1\n",
        "   \n",
        "    for d in np.arange(dmin, dmax+step, step):\n",
        "        idx1 = predictions.ravel() <= d\n",
        "        idx2 = predictions.ravel() > d\n",
        "       \n",
        "        tpr = float(np.sum(labels[idx1] == 1)) / nsame       \n",
        "        tnr = float(np.sum(labels[idx2] == 0)) / ndiff\n",
        "        acc = 0.5 * (tpr + tnr)       \n",
        "#       print ('ROC', acc, tpr, tnr)\n",
        "       \n",
        "        if (acc > max_acc):\n",
        "            max_acc, best_thresh = acc, d\n",
        "           \n",
        "    return max_acc, best_thresh"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XYtVsXTtnWFy"
      },
      "source": [
        "#### Load the weights from the epoch which gave the best validation accuracy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZNp3lXV7nWFy"
      },
      "source": [
        "model.load_weights('./signet-bhsig260-005.h5')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "khoJxhf4nWF0"
      },
      "source": [
        "test_gen = generate_batch(orig_test, forg_test, 1)\n",
        "pred, tr_y = [], []\n",
        "for i in range(num_test_samples):\n",
        "    (img1, img2), label = next(test_gen)\n",
        "    tr_y.append(label)\n",
        "    pred.append(model.predict([img1, img2])[0][0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oHfM7N0OnWF1",
        "outputId": "416dffd9-b1f0-434b-b930-527d55a1c06c"
      },
      "source": [
        "tr_acc, threshold = compute_accuracy_roc(np.array(pred), np.array(tr_y))\n",
        "tr_acc, threshold"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7997812136837946, 0.03)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xSP7Z6hDnWF4"
      },
      "source": [
        "#### Accuracy = 79.37% and Threshold = 0.32\n",
        "Thus if the differnce score is less than 0.32, we predict the test image as Genuine and if the difference score is greater than 0.32, we predict it to be as forged\n",
        "\n",
        "#### Below we see some sample results"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ut9LUxfZnWF5"
      },
      "source": [
        "def predict_score():\n",
        "    '''Predict distance score and classify test images as Genuine or Forged'''\n",
        "    test_point, test_label = next(test_gen)\n",
        "    img1, img2 = test_point[0], test_point[1]\n",
        "    \n",
        "    fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (10, 10))\n",
        "    ax1.imshow(np.squeeze(img1), cmap='gray')\n",
        "    ax2.imshow(np.squeeze(img2), cmap='gray')\n",
        "    ax1.set_title('Genuine')\n",
        "    if test_label == 1:\n",
        "        ax2.set_title('Genuine')\n",
        "    else:\n",
        "        ax2.set_title('Forged')\n",
        "    ax1.axis('off')\n",
        "    ax2.axis('off')\n",
        "    plt.show()\n",
        "    result = model.predict([img1, img2])\n",
        "    diff = result[0][0]\n",
        "    print(\"Difference Score = \", diff)\n",
        "    if diff > threshold:\n",
        "        print(\"Its a Forged Signature\")\n",
        "    else:\n",
        "        print(\"Its a Genuine Signature\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 260
        },
        "id": "cHGCy1EEnWF8",
        "outputId": "67ea1632-8b06-4638-b585-b66cee284900"
      },
      "source": [
        "predict_score()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Difference Score =  0.52416015\n",
            "Its a Forged Signature\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2iSJxGC_nWGB"
      },
      "source": [
        "### Note: The first image is always Genuine. Score prediction and classification is done for the second image"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 260
        },
        "id": "KZZeA1SnnWGF",
        "outputId": "05bfb53c-8f9b-4dc9-84d7-c7c3416eeac6"
      },
      "source": [
        "predict_score()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Difference Score =  0.011033133\n",
            "Its a Genuine Signature\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 260
        },
        "id": "_VWmvVlGnWGI",
        "outputId": "d90d71cc-6bd6-4673-8d93-f9cfa1a5ba27"
      },
      "source": [
        "predict_score()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAADRCAYAAADISmjvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd1gU19cH8O9spSwgSBNBmkZAsSvYsUSjib3/rInGRBMLxqixRRONGjUxsSXRWKPG3qImltiwExXFggJiUHpnYRe2zPsH2XlZt7B0XM/neXiUnbrAzpy599xzGZZlQQghhBBiznjVfQKEEEIIIZWNAh5CCCGEmD0KeAghhBBi9ijgIYQQQojZo4CHEEIIIWaPAh5CCCGEmD0KeEiZMAwjZRjGp7rPgxBCSouuX28mCnhecwzDDGcY5gbDMHkMw6T89//JDMMwlXlclmUlLMvGVuYxCCHmja5fpCpRwPMaYxjmMwA/AFgJwBWAC4CPAbQHIKrGUyOEEKPo+kWqGgU8rymGYewAfAVgMsuyB1iWzWWL3GFZdiTLsgUMw4gZhlnFMMy/DMMkMwzzE8Mwlv9tH8IwzAuGYT7778kqkWGY94vt/wLDMBOKfT+OYZiwYt+zDMPU/+//2xiGWc8wzAmGYXL/e0rzLbauH8MwZxiGyWAYJophmKFV8TMihNRMdP0i1YECntdXWwBiAEeNrLMcwFsAmgGoD6AugIXFlrsCsPvv9fEA1jMMY1/G8xkOYDEAewDRAJYCAMMw1gDOANgNwPm/9TYwDBNQxuMQQl5/dP0iVY4CnteXI4A0lmWVmhcYhrnKMEwWwzAyhmE6A5gIIJRl2QyWZXMBfIOiD6yGAsBXLMsqWJY9CUAKoGEZz+cwy7I3/zufXSi6SAHAewDiWJbdyrKskmXZOwAOAhhSxuMQQl5/dP0iVU5Q3SdAyiwdgCPDMALNRYNl2XYAwDDMCxT1h1sB+KdY/h8DgF98H8UvOADyAUjKeD5JBvbjCSCIYZisYssFAHaW8TiEkNcfXb9IlaOA5/V1DUABgH4oeuJ4VRoAGYBGLMu+LMP+81B0wdFwLcM+ACAewEWWZd8u4/aEEPND1y9S5ahL6zXFsmwWivqcNzAMM5hhGBuGYXgMwzQDYA1ADWATgO8ZhnEGAIZh6jIM09PEQ9wFMJBhGKv/kvvGl/FU/wDwFsMwoxmGEf731ZphGP8y7o8Q8pqj6xepDhTwvMZYlv0WwAwAswAk//f1M4DZAK7+9280gOsMw+QAOAvT+7i/B1D43z63o6hfuyznmAugB4r63hNQ1HS8AkUJi4SQNxRdv0hVY1iWre5zIIQQQgipVNTCQwghhBCzRwEPIYQQQsweBTyEEEIIMXsU8BBCCCHE7FHAQwghhBCzV1LhQRrCRcibhyl5ldcGXcMIefPovYZRCw8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsUcBDCCGEELNHAQ8hhBBCzB4FPIQQQggxexTwEEIIIcTsCar7BAghpCbr378/vLy80KdPHzAMA0tLS7Rt2xYAcOPGDXh5ecHFxaWaz9I0V69eRZMmTSCRSEq9rVKpRHx8PG7duoXjx4/j1KlTsLOzQ0xMTCWcKSEVj2FZ1thyowsJIWaJqe4TqEDluoadOXMGM2bMQEpKChwcHAAAfD4fdnZ2AICcnBxYWFhAJBIZ3MfIkSPRv39/AIBarcb169cRFBQEPp/PraNSqZCamoqpU6fi4sWLWstKIzExEZpruo2NDWxsbMCyLAoLCyEWi5GTkwNra2ud/UulUkgkEqhUKvB4PEilUuTm5iI1NRWTJ0/mzl0ul0MqlSI9PR2ZmZmws7NDVlZWmc6VkEqk9xpGLTyEEGJAWloaFAoFUlJSkJKSYvJ2AwYMwKlTpyCXy5Gfn4/r168DAFiWRVxcHDw9PcHj/X9GgVqthlQqxZUrVxAaGsota9iwIRwdHZGeno6JEyfi5MmTePr0KRISEqBQKHSOm5GRwf3f0tISlpaWYFkWCoUCIpEIy5Ytw8GDBxEZGYmcnBzunORyOSwsLKBWq8Hj8SCXyyGTySCVSnH16tUy/ewIqWmqPeBhWRaZmZmQSqWoV69edZ8OIYRwvL29YWlpyX3PMAwsLCwgFovRvn17rqUkNjYWkZGR3HpisRgMU/SQeffuXdy9e1drv2FhYbCxsUFBQQEKCwu1lm3YsIH7f6NGjeDk5IS0tDSIxWIcOXIEDx8+xMuXL3W2A4paioqfqyZwYlkWDMMgKCgIhw8fxpUrV5CcnMytqwl0in+vr/X/rbfeQnp6OtLT0+Hg4IBhw4YZ+ekRUrNUaZdWQUEBHj9+DDs7O3h6eiIuLg5ZWVmIiopCYmIiunXrBjs7O7i7u5e5SdeYxMREuLq6chciQohe5vQBKdc1TCqVolevXggLCwMAWFlZoV27drCzs8OiRYtgYWEBADh58iTWrl2LuLg4NG7cWP+J/Het1Vx/PDw88PLlS2RkZEAulyM5ORnOzs5agYgxmmPL5XLweDyjD4wsy+L58+cICQmBRCJBQkICMjIyUFhYiIyMDLi4uOD58+cAAGdnZ1hZWUEgEEAikUCtVuPevXsAgDlz5iAqKgoPHjxAy5YtsXv3bpPO9U1WUFAAqVSK2rVrV/epvEn0XsOqLOBRqVSIiIhAmzZt0KdPH/zyyy8YPXo0rly5AqlUCqDoqah37974/vvv4ezsDD6fzz2lMAyjtwn31WPw+XyuH1qtVnNPPEqlEl999RXmzp3LXSiKE4lEep+YihMIBODxeNx5CIVCreUKhQICgcCkgErzvgQC3Ua24k3QFYVlWbAsq/UUR4gBFPD85+zZswgNDcXjx4/BMAy8vb3xzz//6E36DQsLw6BBg4wGLJqWFs3/b9++jfj4eDx+/Bhff/015s+fjxUrVkCtVuvdPjc3FwBgbW2NwMBAqNVq3L9/H3w+Hz///DOsrKz0bqdQKDB06FDs3LkT7u7ukMvlkMvlePHiBX777TfMnj0bQ4cOhVKpxLx589CqVSu4uLigbdu2WteiGzduQCwWQ61Wo3nz5qX6Wb7uNLlQGiKRCAzDQKVSQaVSgWEYnXuCWq3Gw4cPceHCBXz66ac6+1Sr1VCr1XrvA/qOW/z4fD4fQqFQ55gEQHUHPKdOncLkyZMRFxdn0vrTpk2Du7s77O3t4eHhATc3N+zdu9fg+gqFAmFhYQgJCcGVK1dQv359REZGcn3nxlhaWmLGjBlYtmwZ1Go1GIbR25z77rvvws/PD+fOnQMAvPfee1rL161bh549e6JBgwYlHlMsFsPf3x+DBg3SWfb06VMcPXoUM2fOLHE/pnr27BmUSqVJ50beeBTw/MfNzQ3p6ekYOnQo7OzssHHjRjg5OSEpKUlnXVMCHkOuXr2Kfv36ITU11eA6crmc6167ffs2mjdvDqlUinPnzmHIkCHo2bMnjhw5ord1vKCgABYWFsjMzEStWrX07l8sFqOwsBDHjx/Xura9GvC0adOm1O/PHKSmpuLHH3/kvp8yZQosLS1x48YNXLt2DfXq1cPYsWO1tnn48CG2b9+OI0eOICoqSmefjx49QkxMjM69RKOwsBD//vsvtm/fDgBYuXIlCgoKAAAtWrTAxIkT8dFHH1XUWzQn+q9hmid/A18V5vjx46yLiwuLogtQiV98Pp8VCASsUChkRSIRKxaLWYFAoPVVq1Yt1s7Ojvv/tm3bWLFYzPJ4PJbP57MMw+jdd6tWrVhXV1et1wQCAQuA7dy5M+vo6KhzLqtXr2atra1ZPp/Penh4sB4eHlrn8t5777FWVlYsj8fTOU9DX3Z2duyePXtYGxsb1sLCgvvSvFcbGxtWrVaX+2d/9OhRtkePHmxISAh76tSpCvhtEjNX0nXhdfoqlzp16rB//vknW1hYyMbHx7MbNmxgrays9K57+fJl1tnZuUzHuXLlCuvo6GhweVxcHOvl5cUCYENDQ9mEhARuWUxMDDty5EiWz+ezhYWFOtsmJSWx/fr1YwGwmZmZBo8hEonY48ePs9nZ2VqvFxYWctfCGzdulOHdmeby5ctsREREpe1fn5MnT7LPnz9nWZZlU1JS2D179rA7duxgg4ODDV6XNV9isZi1sLBgRSIRd68qvr5mG829yNbWlt2zZ4/W16pVq9jBgwezjRo1YlmWZffu3cvu2bOH/f7779np06ezXbp00Tpu8fsSwzDcMS0tLfX+7t9geq8HVZa0HBISgn379mHKlCno1KkTLl++DJVKBZZlkZeXh6ysLK3hjcWT7wyxsbGBvb09l3C3a9curgXj888/R4sWLbgnk4KCAjRp0gRBQUFYtWoV3Nzc8PLlS7x8+RK2traYPXs2AEAmk3FdVl26dMHy5cuxb98+XL9+Hb6+vlrNj3Z2dmBZFrm5uTh//jxkMhlYljXYHP2qnJwchIaGcs3Ur5JKpWjdujXOnTvHDYMti9OnT+PBgwdIT0/H119/jXr16sHf359ymQgpwYQJE+Dr6wuhUIg6deogODgYarUakZGRCAgIqJIuYrVajfz8fMTHxwMoallwdnbmlnt4eGD+/PnYtWuX3u1ZloVSqcSgQYOMdp0ARXlBht7T+vXr4ePjU8Z3YdzGjRuxa9cuvHjxAmKxGDY2Nvjkk0+wYsUKfPzxx+jatSssLS251o1XrVq1CteuXQMAODg4YNOmTdyyBQsW4OHDh+jYsSOmT58OuVyOkSNHAgDy8vIgFothb28PoVDI9UBkZmaidevWiIyMNDjsXqlU6rxmLO1Cc71/dR9yuRwFBQVo2LAhcnNzwbIsVCoVFAoFt0wsFnP3tujoaIjFYrAsi5ycnBJTPcj/q7KARyKRoFWrVlizZg1cXV0xcOBArttIqVSisLAQBQUFYFkWU6dO5RLq6tati5CQEK6OBQD8+++/WLlyJUaOHIm3335b7/ECAwNRu3Zt7sMrl8sBAIsWLUKzZs0gkUjg5uaGRo0aQSgU4ocffgAAfPTRR8jLywNQ1Ny4adMmzJw5E6mpqVAoFHq7uhQKBaRSKSZPnoyUlBQIBAKIRCLw+XyDwQwA8Hg8ZGVlcflDs2fPRuvWrQEA6enpmDFjBhYsWKA1SqQsxo0bh6SkJBw+fBgRERGYOnUqbG1tsW3bNohEIohEogq/cLP/5SGVFPwJBIISL8KEVJcxY8bAzc0NQFHOhOazqLmeVIWCggKkpaWBx+Nh79698PDw0Oq2EgqFcHJyMrh9YWEh7t27h8OHD5d4LSksLDT4md25cye6dOkCR0fHsr0RI9LT05GUlMQlTguFQqxZswZRUVH4+eefcezYMfD5fC4H6tUH4gcPHqBBgwZo0KABdu/ejalTp3LLEhMT0bZtWzRq1Aj79u3DjRs3MGPGDEydOpXLiREKheDz+dzvVSQS4d9//8X06dPx4sUL5OXlYdCgQSgoKMDIkSPRq1cvDBo0SKd7kGVZjB07Fp9++ikaNWqEI0eO4PDhw1y+TfHgSalUcg/9APDkyRPw+XytPNCWLVsiNDQUfD4ftra2AIruUXXr1kWLFi0glUqxadOmct8j3hRVeqexsrJCly5dAAD+/v4G13v+/DnS09Oxe/duFBQUwMnJSSvXJTIyEj/99BMCAgLQtWvXUp1D27ZtuYRDCwsLLoG5a9eukMvlKCws5CL3pKQknDhxAmPHjkWHDh1K3PfMmTPx3nvvwd/fH9bW1sjNzcXq1asBAEFBQYiJiUHTpk3h5+fHJbjZ2NhAoVBg48aNaNu2Lfr16wcAyM7ORlJSEvd9ebRq1QqjR49Gfn4+Tp06xeUgaYI9GxubCk98U6lUsLS0RF5entGgz8LCgku05PF46NSpEyIjIxESEgJXV9cKPSdCSqt+/frVfQrg8/mwsrJC7dq19eb8lUSpVCI5ORktW7YscV25XG4w4Klfv77eAR8VoVWrVjh+/DhXtVmhUHAjwx4/fozHjx8DKLpG8Hg8va0rrq6uSEtLQ2FhIc6fP8+97ujoiLS0NK48wKNHj9CiRQt8+OGHWtvn5+cjNjYWly5dQmhoKMRiMYYPH47MzEzI5XKEhIQgPz8fQNH1uWvXrvD29tY5jwcPHmDIkCHw8fHBo0ePUL9+ffTr1w/W1tZa68nlciQmJuLRo0d4+vQpRo0axV0PNQGPvjxPiUSC5s2b45133kFMTAwsLS0xa9asShnZbG5q5KP1Z599hsLCQty9exfXrl3TaVLMyckxqcurtP766y/IZDI0a9YMdnZ2SE5OxsuXL7Fz506TAh7g/6uqWlhYIDk5mau/MWzYMNy4cQM+Pj7w9fWFra0tOnTowAU8ryZk29nZYeHChRX23nr16gU+nw+ZTMb9PJcuXQqWZWFjY1OmEWH+/v5ISkpCZmamzjKlUgknJydkZmYiPT1d7/ZCoVCrSi3DMPjggw9w+vRpZGRkoGHDhnq3s7W15Z6CNCP4AgMDS33+hJSFpitBX2tvZRCJRPDw8MC7775b6cfSJEPrS2weN26c0Zak8ujUqRN69OgBGxsbKJVKFBQUaAUIubm5KCwshEAggFwu16p5BACNGzeGk5MTZDIZunXrBpVKBalUChsbG8hkMoSHh2utd+vWLWzbtk2rZSQ+Ph5bt25FWFiYVskBffLy8gwGhl9++aXW9wEBAVi0aJHOyD6ZTIb79+9j3759yMjIwOLFiyEWi2FtbV1iuoGPjw/eeustZGdnIzg4GIsWLTK6PilSIwMeoOhD7urqinr16mn1VwNAXFxciUPIy2LIkCFwcHDAd999h5YtW+LEiROYOXMm/vrrL5P3IZFIuA+Ki4sLzp49yy378MMPMWnSJCxatAhBQUG4fPkygKIbf2Xn04hEIrz33nvo2rUrbt++DQAYMWIEpFIpl0dlrJleKBTqDHkdM2YMDh06xPWdv0oz4qR4/lF2djbs7OzA5/Nhb28PpVKpFdCuXbsWMpkMn3zyicFz0XRJCoVCrjvul19+0VlP0zxcPJiztLTU+/OWy+UQi8XIy8vjgmm1Ws11b2pYWFjA2tqampDfYCzL4tmzZ+jUqVOZts/Ozub+ruzt7U36W3J2dsbmzZvLdDxTOTs7Y+3atejQoYPelouMjIxKedAEilr/v/76a+4zl56eDi8vL275vXv3uHyVBw8eYMqUKVrbT5kyBUOHDoWtrS0YhoFMJkNUVBQCAwPx7NkzfPXVV1CpVEbrBsXGxuLPP/+Eh4dHiQ+AK1euRJ06dUx6b0KhUG8ZA0tLS9jY2EAikUAikZSqTo+NjQ3c3NzQsWPHSsurMkc1NuDRePnyJaKjo7Vea9KkSYXfcDRPazdu3ICnpyeAooAgKCjIaPdbWTRq1AijR4+u0H2aysrKimut+uuvv3Dr1i3k5+fjzJkzOHz4MBiG4b6KV1tt2rQpxo8fr7UvlUqFfv36oU+fPiXWkgCK8gOmTZtm8OmJZVlcvHgRJ06cgEwm01mueaKKiIjQ2gYA6tWrp/PELZFI4Ovry030CBS1wDVq1IjrD9fs4+jRo+jWrRt2796NR48eASi6Me3Zs0drn507d8aECRMwYsQIakJ+Q/F4PDRr1qxMeW8ymQxz5szBr7/+CqVSiW3btlXbteBVp0+fxrFjxwzeQFu2bFmmSUdLg8fjcXOAFdekSRMARddnzYNi8YeWjz76COHh4Vi8eDHq1KkDKysrrk6Qk5MTJBIJsrOzjR47Pz8fOTk5SExMLPE827Zta7DmUWk5Ojpq5aiaStMoQF3/pqvxAY+Li0ulTzmhVCpx8eJFo03Umsn1KkLz5s0xceJE7vsXL17o7ZOubAEBAQgICMCLFy8QGxsLd3d3DBo0CF5eXpgyZQoWLFiA7du3IyEhAQ0aNMDHH3+sdz/r1q3DyZMncfLkSaPHk0qlmDZtGsaPH69zQQOKApqpU6fi2bNnXKKohkKh0KlL9OjRI4SFhYFhGLz//vv46aeftH6HUqkUERERWgHSzz//rLc1TZMMqRm+aMjFixdx6dIlrF27Fjdu3DD6fol54vF4JuXDvOrp06cICAjQ+qxv27YNYrEYHh4eFXmKZfL777/j33//5fJUapqLFy9i8+bNOHbsGBo3boyQkBBu2alTp7Bp0ybExsZqtaoD0MrLrIlSUlKwZ88eLF68uLpPxezV6IDn5cuXAKDTb+zv71+q5Dm5XG705iSXy3H48GH06tVLJ2oXCoWoV68efHx88PTp03INDzckKyvL5KHslWHhwoXYu3cvWrVqhSVLloDP54PP52Pu3LkYNWoUlixZYnR7hUKht0XmVTweDxYWFga774oXfHz16VksFmPZsmVarymVSly9ehVjxozBihUrdPqxT506hUmTJiEoKEjr9cePH+stHKcv0NGM1vjiiy8QHx+PBw8eIDExEXl5eXj48CECAgJKfN/EPMhksjIVFQSKbrqZmZlQq9UICQnBpEmTuBFD169fL1fAI5VKER4ezg2GKKtr166hoKDApM9yVcvKysKBAwdw9uxZ9OzZE1u2bNHqdrKzs8OePXvw6NEjzJ49GytWrOCWFRYWVlpXXEWoqlwwUsMDHpVKBQsLC53WgNJ2JQiFQqP9nFZWVpg2bRr69OmjU9PAxsYGo0aNwqJFiyrtDzMrK6taP5C5ublQq9VwcHDQasWSSCRo0KABnJycjFaABUz/0Jbnfb7awlZQUMBNP/JqM/hvv/2Gn376CXXr1sXatWu1tsvPz0dhYSGSkpKwY8cOHD9+XO/x+Hw+XFxc4OLignnz5qGgoAA7duzAgQMHIBaLabLbN8yrM5kXd+DAAXz99dcGt01PT8fdu3e5v0d3d3c0bdoUn3/+OcLCwkrsbjHm2bNnmD9/PsaPH1+u8hIzZszAp59+ys2iXpPMmjULx48fR8uWLbF8+XI4ODhoLf/oo4/g4OCAnTt34uTJk1oBj0KhqNEBj1AorJSh/kRXjQ147t27h+zsbDRv3rzMyYEaSqWSK9qlD4/HQ4MGDTB16lSd4Mra2hr9+/ev1Cz46mzdAYDRo0cbTH4TCoXw9PTUGVJZVhV54VGr1QaLbsXExCAuLg4dO3bUO5mjTCbDrVu3dP4umjZtitzcXDx79gz29vb46quvAAC+vr4AivK6GjVqBEA3ACPmLSMjAykpKVi6dKnW63/88Qd+++033Lt3T2eAhUZMTAz+/PNPLFq0iPt7rFWrFgICAvDkyROdbpjSyM/PR3R0NPr27VuugKd+/fooKCgw+Jlavnw55s2bx+U4VqWHDx8iJSUFtWvXhp+fn85yDw8P9O3bF/n5+di4caPWMgcHB1hZWZUrqKxMHh4e+Oyzz6r7NN4INTbg+f3335GYmIjGjRuX+yapUCi47jFjPvzwQ516NEKhsMKTlmsazXBXQy1nzs7OFTKRKcMwFZboVxKFQgEXFxe9yYBJSUlISUlBXFwccnNz0atXLwBFzeJt27ZFdnY2zp8/j+fPn2PcuHFa2zZt2pSbtJG8OaKionD37l3UqlULY8aMwalTpwAUlcjYvXs3IiMj4eHhYbAScHJyMh48eID9+/drvd6pUydERUXhyJEj5XrK5/P5eOutt8q8PQCtQQr6ZGRkVGsuTIsWLdCuXTuDy+vXr4927drpBDx2dnawtLSssQGPvb293npyGRkZiI2NRXR0NOzt7dGzZ89qODvzUqMCHpZlkZ2djYSEBPz6669ISUnBiRMnIJFI8N1335lcHC8xMRHZ2dlQKpWwtbWFk5OT3iTZV1XVrLOa0uHFAwxLS8tqG/VT0nFLM11GSRwdHSusqnNmZiYSExPh4uKid7m3tzf+97//6bweFxeHhIQEiMVi9O3bl0sgr1+/PjfSrFmzZpg+fbre/WqKn5E3Q2pqKnbt2oXt27dDIBDg5s2bmDFjBoD/n5S3bdu2CAgIwJEjRwzup6CgAFFRUVp5X71790ZsbKzR7YzJzc1FQkJCmbZ9VUmf8fnz51drcvXo0aNNmihTqVQiOjq6yopGSqVSpKWlQSqVAoDeFmVD5HI5UlJS8OzZMzRt2lRrWUREBH755RccPHgQ/v7+8PX1pSHo5VQjAh5NAJCdnY2DBw9i+vTpKCgogEAgQHp6Oh4/foyYmBj4+vpyw6UNfTgVCgUWL16MI0eOIDk5Ge+99x527NhRYV0yFUEulyMzM1Pria5Ro0YGZzGubsaKB1ak0tZWOnToEFavXs3Ng2aq4OBg7v/Dhg0r1bbkzaGZ8ubHH3/Evn37uMBC86TN4/G4PK+ePXsiJCTEaODy/PlztG7dGsnJyaXqDlWr1VAqlVx19uLOnz+PpUuXVkjLqaaIpyFhYWFwd3evlnwTTf2skjAMg6ysLPTv3x/37t2rkgeTS5cuYeXKlbhw4QIYhkFmZiZXD6gkMTExOHXqFBwdHbmAR6FQQKFQ4NSpU9i7dy8EAgEiIyMxYMAAg7NRoWUAACAASURBVDXPiGlqRMDz8uVLHD58WGv+k0aNGiEkJAQRERE4e/YsOnTogKlTp8LHxwfXr183WCth+fLl2LNnD5d498cff6BZs2ZlfoKqDAqFAnl5eVoXjvDw8CoJKsoiLi5O76imipSfn48ffviBRiyQGmP//v2YPHmywckjg4OD0a5dO4wZMwaBgYEICwsrcZ/5+fmwsbFBTk6OSa3OQNFUOr/++iucnJwwf/58rWWaIOz+/fsm7cuYt956y2gtrd69e8Pe3r7cxymLM2fOmLSevb092rVrV+Igi4oUHR2NCxcuACh6eK9Vqxbi4+Ph7u5e4rZWVlbIysrC7NmzMXDgQABFZT7Wr1+PmJgY+Pn5oVevXtixYwciIyNrdPL166BGBDxHjhzRSdqysbHBmDFjEBUVBaVSievXr2PJkiVcC4++vmSWZbFs2TLIZDLs3bsXubm52LJlC2JjY7m5WGqCFy9e4Nq1a9WS/FfRIiIiSvWzzc/P19s6x+fzUb9+fYwfP75UT78WFhZcQjEhFUWtVmP8+PE6Q7QbNmzIVSrXtPCUVHDzyJEj+OWXXyCRSNCtWzccPXpUa3lISAhmzpyJbdu26d3+2bNn2LBhAywtLbUCnrVr1+LXX3+FhYVFmcplbN26FVu2bOEK+ZkDgUAAe3v7Kg14AKBdu3Y4c+YM1Gp1qVrqLS0tYW9vjxcvXnCv/fjjj9wkqm+99RZWrFiBBQsWwMHBAXXq1DGYJ0ZKViMSEUQikU6TbEREBB49eoQOHTpg2rRp8PHxgUKhMFhEKj8/HwsWLEBBQQE++eQTNGvWDIMHD8YHH3wApVKp9QdVGmq1GhkZGSWuZ2p3TN++fTFq1CidZuFPP/3U4NxRNVleXl6pCpUZujnk5eVh0aJF+Oijj3S6HxMTEzFkyBA0atQImzZt0pq7S5NoTEhFKywshK2tLXx8fLhh0JrEeysrK1hYWJg0LYxKpUKtWrXw7rvv4vvvv0evXr0QGhrKXZM0M2kbEhgYiC+++AIymQxLlizhbngPHz5EdHS0yTXJEhMTtVpQlUolwsPDERwcbFKAEBMTUyNr9BSXkZGBy5cvw9vbm/u9VGYdnuXLl+POnTuYOHEirKysYG1tDQcHByQlJRmdqkfDysoKbm5uWg9txWdQ5/F43ATPEydOhEqlogET5VAjAp7u3btj69at+P3337kvCwsLrFu3Drdu3UKXLl2wbt06reWv1kApKCjArl27oFarwefzwePxYGdnh9q1ayM3Nxc7duwo07nJ5XJcvny5xP7jkp7yNGrVqoWXL19qzeni5+eHgICAGjnMOTEx0WCTPlCUsPfqfFPG6JtoFCj6kCcmJuptVs/Pz8e5c+fw8OFD/Pjjj1oXbj6fXyN/buT1xuPxsHv3bmzbtg3r1q3Dr7/+imnTppV5f3w+H3Z2dvD09MSCBQtw7tw5rtu9bt26aNGiBQD99awcHBzQrFkzqFQqbN++HQqFAkqlEvn5+Wjfvr3OZJWv0kyy++qklN26dcOCBQtw+/ZtfPjhhyU+uHz11VdlfnCsKpqH4dmzZ3PvNSUlBbm5uZVyvJSUFDg5OaFHjx4Ain7WmzZtwrfffouoqKgSt7ewsECTJk24ljvNBNYa9+/fx7Jly8Dn8/Hpp59WyGjZN1mNCHh8fHwwYMAADBs2jPvq2rUroqOjERsbCxcXF/Tq1Utr+avNhiqVCnFxcQCK5lvR3Fi9vb0xcOBAndl1TZWbm4tdu3ZhwoQJEIvFBtczNTnOxcUFDMNoTXdQUFCAy5cvIy0trUznWJkOHjwIqVRqsKJwaZ6eWJYt8QnRyspK54lZpVJxv8/IyEhs3rwZDx48MOmYhJTV0KFDMWDAAPTq1Qv9+/dHu3btkJOTg3379pV5nzweD23btkV6ejp3c7a1tYWbmxvUarXegMLKygru7u5gWRbR0dFQqVTYuXMnCgoK0L17d3Tp0sXoMQUCATw9PREWFqbVOu7j44ORI0dixIgROHr0KL777jujQ7fr1q37WtxwRSIRN18gAPz5558Grxf79+9HbGws931+fj62bNlici6hTCaDQCDQmki0X79+uHr1KtLS0uDt7W20GjvDMLC3t+fO9+nTpxCJRFztoBcvXuDYsWNgGAaBgYE0f1851YiAR5+xY8ealPT1qsaNG+P27dtIS0uDWq2Gv78/QkNDTdr2/v37WkW3cnNzcefOHZw6dcrghJelVadOHZ15omJjY2tkwBMfH4+dO3ciKyvLYHdbVlZWpVZmVSqVyMvLA4/HQ+fOndGqVSts2rQJhw8fxr///ltpxyVvlkePHiEmJsboOhKJBFZWVlpVfE3h5OQEZ2dnoy2lQFFgHxsbq3Oz1dwANa5cuYJvvvkGEokEHTt2LPH4QqEQXl5eOHDggE7Xe926dTFv3jwAwIIFCwy2wAJA+/bttSbdrWlevHih98H2yJEjuHfvnt5tDh06hPPnzyMxMZHrXlq8eLHJAU92drbRFu6AgAC0adPG4PLMzEzuQR0o6jbs0KEDunTpgnr16nFTkpCKUS0BjynNi3369IGLiwvy8vJMvqEyDIPvv/8e3t7eSE1NRWZmJkQikckjC0JDQxEVFcVdFB4+fIhly5ZBJBLB2dm5TPPUvHqB0Qw5fPW833vvPdStW7fU+68sKpUKmzdvxsuXLxEbG4s7d+7oHUUWHh5ucIRIQUFBuQuV5ebmIiYmBmKxGBcuXMCOHTvg5uaGDRs2YPv27eXaNyEaixcvxvr1642u4+/vj7Fjx5Z6AESnTp3QsWNH3L171+h6LMsavHlquuiBokKhGRkZ6N69u1aJBUPUajVyc3P1zmMnEAjg7OyM2rVrc6/J5XK91ZanTp2q1RpSk7AsiwMHDmDOnDnc+83NzUVycjLS09MN5tP06NED586dw8GDB+Hh4YHPP/8cycnJegMelUpVqrnUNIUaLS0tDa7z6NEjbtJllmWxefNmrF69GsuXL0fbtm25ki2kYlR5wKNQKDB37lyTMs0ZhsGGDRswZ84ck/ffuXNnHDhwABs3btSpuFmSS5cuITAwEGfPngXLskhKSsLNmzdNuqjoI5PJ8Pfff2u9Zmtrq3dExc8//4ynT5+W6TgVjWVZbmRIQkICYmJisHLlSrzzzjs6CXNJSUkGh9OfOHECERERJj8t6ZupvLCwENnZ2VyXob+/P6ysrLhqyYRUBFMeZry9vTF48OByHcfYZ0Eul2Pz5s16k1KdnZ2xZs0a7jyPHj2KQYMGmXRMHo8HR0dHDBw4UG8uoo2NDf7880+uy/748eO4fv261jo1vStFKpUiOzsbMpkMubm5mDt3LubOnQtvb2/cvHnT4O+3Z8+ekEqluH79OpKSkuDn52dwao0nT56UqvDf0KFDsW7dOqPr+Pr6onPnzgCK/gZ79+4NS0tL1K9fX6cnADA9dYLoVy0Bz/r16w3+URU3evRodO3atVRdSZq+zuJNr2KxGM2aNTN5HydPnkTfvn0xcOBAuLq64q+//jJ52+JSUlIwYMAAk9YNCQkxWDG4KmnmovH390daWhpGjRqFNm3acCM6ireW7du3z2g3wLp169CmTRu91Y71KSwsxP79+7XyfGJiYnDp0iX88ccf3GunT58u942HkOK6detmdNqCipCVlYVffvkFZ86c0dvyWVhYiKNHj+oNiiQSCUaOHImPP/4YIpEIUqnUpGuohkqlwu+//653NCmfz0erVq0QGxsLDw8P+Pr6auWkCAQCnD592uS6QdVhwoQJWLx4MYCiEZ/r16/H+vXrIZPJcO7cOYMJ525ubhgwYACeP3+O4cOHGxyin52djSdPnph8Pj169DCpQGPdunXRsmVLAEXBcEpKik6LjlKp5LpDz5w5U+4pRN5k1RIumvrEP2TIEHh5eZk0D5YxhYWFpUpa3rp1K86cOYNatWqhTZs2ZY6q+Xw+nJyc4ObmZrT/Pjg4GP/880+V1454VVhYGHx9ffHFF19wF2QXFxc0bdqUy+HJzc2Fm5sb3Nzc8NFHH2klX78qMDAQderUwZkzZ0oMeliWhVwuR58+fbSagOVyOeLj4/Ho0SPuNUdHR6PNxISU1uXLlxEeHl5p+7e1tUWtWrUwa9YsDB8+XCd538bGBi1btjR6bRQKhVi+fDlat26NCRMm4NixY6U6h5KGM7u6uiI8PBwzZsyAt7c397pKpcLXX39dY4ek//PPP0hJSYGjoyNatmyJNm3agGVZtG/fHqtXr0bDhg2NtuANHz4cvXv3RnR0tM7EsBoXLlzA+++/b/I5ff/999wkw8Y8ePAAhw8fBlD0sP7uu+/iyZMnyMnJQa1ateDk5AS1Ws3dG0qqhk2Mq/KARyAQYNCgQRg3bpzRGcyBoqJMAoGgVH2YqampOh9slmVNyiU5c+YMPD09IZfL0bBhQ0yZMqVcs6Q7OTlh165dSExMRJ8+fXD9+nWtOVc0oqOjkZeXV+19tYWFhUhKStLKmdq3bx+8vLywc+dO7NixAw4ODkhMTOSGq/N4PIMjN6ZOnYq+fftCpVLh1q1bOHHihN71UlNTcejQIbAsqxPIeHl5oWvXrlr5FQzDQCAQmFwKwBClUqlVY6n4HGzkzVJQUFBiLa0LFy5g7NixZXoAql+/PkaOHImcnBxkZGRgwYIFcHV15ZYrFAqkp6eX2Cpga2uLzz77DEKh0KQ6L6XB4/Hg7OwMiUSi1YXF4/EwatQoo6NUqxrLsoiLi0PPnj0xceJEpKSkYMyYMfjll1/w008/4fz581i7di1GjBhR4s/U0tISo0ePxpo1awwGnAUFBcjLy+NaV/Lz88GyLPh8PtRqtU6Khp2dnUnXJ6lUikuXLmH06NEAioapf/HFF3j48CGGDRuGuXPnwtnZmcvvLO81701X5T89gUCAyZMnY9iwYRVeG4FlWXz55ZdwdHREdHS0SSMYiuvcuTPmzZuH7777DllZWZDL5eWaKV0sFiM4OBgCgQBhYWH49ttv4eLiopP0mJWVVWOLSf3777+wtLRE69atUb9+fUilUiQlJWHZsmWYNGkSrl69arCVx9fXF2PGjIFCocCePXsM5lQlJSXht99+AwAcO3YMvXr14roxnZ2dERwcjG+++UZrG29v7zKN4tO4efMmDh06BKlUCk9PT/j5+eHMmTNcAjl581y5cgW//vorxo8fr3d5SkoKwsPDtQIVU7m4uKBTp04QiUQYMGAAhg8frlVaw83NDbNmzQLDMCXmy3Ts2BESiQTR0dF49uyZVmuMIWq1Grdv3y7TQxXDMPD19a0x+SMymYybWPPcuXNQqVRwdHSEg4MDV8+otNzd3dG/f3+uvpG+9+ro6IhZs2ZhwoQJOH/+PHr37g0bGxvcu3cPmzZtwqefflrq4yoUCgiFQq54anBwMJYsWYKcnBwEBwejf//+cHFxqZC50kg1BDw8Hg9du3aFXC6v0Ju8SCTCe++9h82bN0MkEmn1b1tYWCAoKAg3btwocT/vv/8+YmNjsX//fpMKR5WEx+NhyJAhOHjwINd06ebmhn79+nHrqNXqGjGHlLOzM4YOHQqg6IMolUpx69YtREVFITIyEo0bN8akSZOQnZ2N2NhYTJs2DVlZWXj69KnB4n/BwcFQq9V4/vy5wflwsrOzcePGDbAsi3PnzmnlbUkkEri7u0OlUuHs2bPo0qUL+Hw+2rdvjwcPHpTYSqjPw4cP8fvvv3O5ZHXq1EHTpk1x4cIFFBQUIDk52Sym/SCma9u2LaKjo/HTTz9xv/vu3bsDKOrSefDgAW7evAlbW1sMGTKk1Pu3srKCn58fhg8fjg8++AANGzbUCmxcXV0xadIkk/bl6OgIa2trhIeHo0mTJiUGPBYWFmjXrh0WLVpU7a3IFSEzMxNbtmzB1q1budeys7Nx//593Lp1C61bty7Tft3d3TFlyhRuolaNFy9eIDY2Fra2thgxYgQmTJiA8PBwhISEoHnz5rhz5w4OHDigN+BJTk42WqxRpVJBIBDAz88PANC8eXOtxHIvLy94eXlx39va2tb4BPKarFpDdplMVmHdBzY2Nti8eTM8PDwgEong6OjIJS7XqlVLa2JSYwQCASZOnIju3bsjLy+v3COB+Hw+du/ejRYtWsDPzw9+fn7o16+fztxhNUHjxo2xd+9e7N27F7/99ht+/PFHtGrVCmfOnNGqVG1nZ4edO3fCx8cHrq6ucHd316oT8qrg4GCsXLnS6LE1fwcKhUJvHRJXV1dMnz6dyyPo2rWrVnGx0tizZw+XwMmyLBISEnDq1CnY2trC1tYWhw8fxrffflumfZPX07Rp0zBlyhRIpVJMnz4doaGhePjwIR4/fox79+5hzZo1+PXXX9GkSROsWbPG6L4MPby4urpi+/bt6Ny5s85NS6FQICEhgZsMtCQBAQF49uwZN6+XMZrcofIEO2KxuMbkjqSnp2Pz5s1wdXXl8gn5fD5OnTqFH374oVz75vP5Ol13Fy5cwLlz5/S2KPft2xfdu3eHTCbTO2T93r17uHLlisHj8Xg8pKam4ueff+aOb+zn7Onp+VoUf6ypqq1D0NLSEjdu3ECdOnXK1TWhwTAMXFxcsHLlShw/fhytWrXintA0y03l7e0NV1dXnDhxAkuXLi33hwgArl27ZnCZo6NjjYvaNU+kEyZMwIYNGww+pYSEhCAqKspoEUAejwcLCwtYWlrqJD4qlUrI5XLweDyuT/zV31WdOnXw888/o1evXsjPz9cpkW+IoXVevHiBlJQULl9Ic07z58/HkydPuGksyJtl7Nix8PHxQc+ePaFQKLSSTgUCAdq1a1diiQxNLZ3STHeiVCrx+PFjLF26FAzDYNu2bSXmy2zZsgXvv/8+MjMzoVKpTLp+lLVLStOlZW1tXSO6tRiGQa1atbB06VKuMvuGDRtw7do1JCQkQK1WV+h53rt3DwzDcIEuwzBc8Oji4gJnZ2fExcVhwYIF+OGHHyAUCqFQKKBWq7mcLUOcnJy4wR3FKZXKCn8fpBpbeGJjY7Fx40ZcunSpQvc7dOhQ7Ny5E9OmTeNKeotEolJPzOnp6YlatWppDYeuLMnJyTW2qXnYsGHcsEl9fH19deY106dhw4ZIT0/XmRJkw4YNGDhwIFq1aoVatWqhd+/eOmUILC0tuVoVLi4uBgsdFmdjY2N01mLN3EHFu8T69OmDH3/8kYa8v8E6duyIlJQUrbmYhEIh5syZgwMHDqBXr14l7qO03dM//fQTmjRpgr179+L333/HihUrTC62evv2bZPmCWQYBk2aNCnzg5WzszMSEhLQqlWrMm1fkRo3boyMjAx88MEHGD58OIYNG4aLFy9i6dKlyMzM1KkhVBHs7e0REBAAhmHg5uaGW7ducXOPubq6wtnZGZs2bYK1tTW++eYbuLi44Pz58yXu19/fH8HBwToDOjZs2IDTp0/r3UYikVDychlVW8AjkUhKjF7v3LmjVXa7rIpXKTXV6NGjyzVCqzRqSlOxMQkJCQgLC9N5PS8vz+ThqpaWloiPj9d5+g0MDMSBAwfAsizefvttvU+3fD4fAwYMgEAgwLlz58qUuwMU9fWbUvSSvLkkEgkWLlyInJwc5ObmcqOqTKmrwjBMmerVODg4cMHU0qVLsW/fvhK7052dnREfH48tW7aUuH+hUIirV6/W6Fo65WVhYYHY2FhuxFNFOHv2rFZrL8MwEIvFcHBw4ILHAQMGYOfOnejVqxdYlsXSpUuRm5sLgUBQphaazp07Izw83GBl7qCgoBpVlf91Uu3tZfPmzcOqVav0Llu9ejXOnTtX7jmsBAJBqYv6CQQCiEQivHz5skY81VSWiIgIo02uGvfv39dbej81NdVgpWV9igc7Bw8exMmTJ8Hj8SAWi5Gfn4+MjAy9yexCoRBr1qyBg4MDVq1ahR49emDZsmVGjyWXy3XmJxs/fjxq166N4cOHG9yOx+NRU/IbTiQSQSKRcF8ikcikBxO1Wl2q6Qd27NiB/fv3w9vbGxs3bkRERARUKhW+/PJL3L9/32jLb2hoKCZNmsR1n5TE3GtX/e9//8OaNWsqdLj+pk2bEBERoZWjKBKJcPHiRW4aEIFAAH9/f+735+3tjQsXLqBjx456K1u/SqVSaY1YXrZsGRo0aMAF3K+aOXNmmROz33TVelXv0KEDFAoF4uPjdT6wKpUKCQkJ6N69OyZPnlzuY1laWmLx4sWlCp6aN2+OZcuW4f79+8jIyKi0kVQNGzaslkS0v//+G998841JRRnlcrneC7mmr7ksrly5gtu3b3N5OyKRCAcPHuSaiotjGAb16tXDxo0bIRAI8Pjx4xITPF++fKlTnC0mJgYCgUBr7qBXDRgwwOQJZwkpjmXZUlVATktLQ4sWLbB06VJ4enoiMDAQDMMgISEBS5YswfHjxw1u6+rqChcXF0RHR1fINbImM2Uka+3atSt8dGVKSgq6deuGDz74gHvNwsICubm5WsGoWCyGp6cnmjRpgu+++w5BQUH48ssv8c4775h0nOL7cnd3h5WVFY4dO6a3lIerq2upcsTI/6vWgGfIkCHw9fXF7du3sX//fhQWFuLhw4fYvn071q5di/j4eDRp0sRgyfebN2/izp07Jh2Lx+Nh8ODBJkXcGu7u7tzwcWMz4pZX7dq1q6VF4cmTJ7C0tCwx2HJxcdE7rwtQlOBtaJkxCoUCiYmJqFu3LpczIxAIcP/+faMj9wYOHIixY8eiXbt2cHJyMnqM7OxsrQrNGvb29kbze5o0acLlDBFS2Ro2bIiePXvqvH7hwoUSH0bc3d3RoEEDHDhwoLJOr0bYv39/iZOvVrRnz55BJpOhUaNGWi0qJeXPaPIQO3fuXGIdNwcHBwQFBem0OL/zzjsQCAQ4dOgQDh48iG3btpX5fZD/V60BT9euXREUFISnT59iyZIl+Pvvv7Fz507MmzcPn332GRQKhcGbmq+vLxITE02ecJNhmDLNeG5hYYH27dubXGU0Ly+v1Dki1VV0MCkpCe+//z5XA8IQDw8Pg7U+PDw8yhTw3LhxA8nJyejUqVOpC3ZNmTIFkyZNMppM7ejoaPC86tSpU6bicYQYY2VlBX9//1K11tauXRsikUin61UgEIBhGOTl5SE7O9vg9s2aNcPIkSPLfM6vi7179+LgwYOlms+qvA4fPozU1NRKfRh1cXFB7969MX/+fK3Xx48fj65duyIqKgpLlizBggULKu0c3iTVnqgwatQoDB8+HPHx8RgyZAjWrVuH7OxsODg4IDQ0VGtoeXFz5szBunXruEJ5pnB0dCx1wOPm5oa///7bpGCpdu3aSExMLFUfPgCT8wMq2okTJyCTyUo8tqY2jr7uwKdPnyIlJcVoi4k+kyZNws2bN3UqiJrSHeDk5IRRo0bh3XffNbhO9+7dMXz4cL2tRQzDcO+ZYRhYW1vXqDoj5PXk6+uLb775Bs7OziZv06VLFzg4OOCPP/4Ay7LctDNeXl6QSCSIiooyOseXu7v7G5HP0adPH5w7dw5ff/11lT0grlq1Cvn5+ZWe6C0UCnVyTG1tbbl5tO7evasTEJOyqfaxbU2aNMGcOXPQu3dvrWz4CRMmGO2nbNOmTVWcXqmUd/LBqr7hOjk5YdCgQdi2bRsGDx5s8PgRERHIycnBrFmzdJY1b94cgYGBZRpWP2fOHIwdO1brtVu3bpU4p5EpPD09UbduXezevVtn2YMHD/Do0SM0btwYVlZWWLJkCa5cuULl20m52NnZlXo6m3r16uHYsWP47bff0Lt3b3zzzTdQq9X4+++/MXfuXGRnZyMxMbHE/Zh7sN69e3dcuHABmZmZePbsGXx9favkuHv27EFISIjO61Xx8/7iiy8QEBCAAQMGmP3vt6pUe8AD/H/y3dtvv829Vpm/4EOHDiE9PR3+/v5lrtZb0YYPH17l0xnMmjULXl5emDVrFv755x8sX77c4Lo+Pj4YOHCg3mVlncjTy8sLHh4e3PcsyyIyMrJUAU9CQgJ++eUXTJw4UWdZbm4uYmJijG5vYWGBadOmYerUqTQyi1SbGzduwM3NTSs5d/v27Zg/fz4OHTqEUaNGGdw2KCgISUlJVXWq1cLDwwO9e/fGzz//jMGDB5ucu1lcUlISbt68Wa6HZaFQiNmzZ2P37t1cJX9jvL29S5U3+qq+ffuWKgmeGFdjrvCabobi3Q0ViWVZXL9+HQ0bNsSHH36IWbNmYeDAgejbt2+FH6ssZs2axRVKrCrt2rWDUCiEUqnE+vXr9Q7VvnDhAp48eVKhv5dJkyYhMTFRqwiaUChE69aty3SM0jRx+/r6QiaTad0gGIahYIdUm7fffhsLFizgWkmfPXsGNzc3rjyCKaNDa1ql9srQt29fDBs2DHFxcfjoo49Kta2XlxfatWuHZs2albguy7IYOHAgeDyezoMcn8/Hu+++i8uXL3Pdj8b873//w8yZM0t1rsVpJpN9E36/VeGNuMonJCSgR48emDJlCmJiYpCRkYGsrCykpqbi2rVrNWJIp62tbbmeBMpCJBJh8uTJaN26NdRqNc6dO4dhw4YhMzMTmZmZGDJkCEJDQxEREQFra+sKO+6ff/6JVatWoUuXLtxrarUaqamppR76n5KSgr1795q8/pdffonCwkJcvnzZ6HpCodCkJzhCysvT0xPjx4/H6dOncfr0aXh6etINTg9LS0v069cPq1evxl9//YWsrCyt5WfOnMH333+vd9uBAwdi/PjxJiWUsyyLixcvIjAwUG/BWktLS5Mnv5ZIJHQdqUHMPuCJjY3FTz/9hLNnzyI8PBwzZ87UGqGTmZmJP/74A3fu3KkRM5ZXtYYNG2LixImYPXs2OnTogBMnTmDhwoVYuHAhTpw4gbt376J169ZlmiHakLS0NLRq1Urr92BlZYVJkyaVuqVFk4dkqsDAQLAsW2IVWz8/P7OvxfPw4UOdmwapk2cCYwAACBlJREFUehYWFvD09MTbb7+N7t27U76GEa6urmjdujUSEhLw5Zdfct09MpkM9+/fR2RkpN4uK3d39xJnlS8uOzsbw4YN05njSuOLL74oVXI6qRlqRA5PZYqOjsbWrVvB4/HQr18/tGzZEnv37kWLFi3g4uKC5ORkPHr0CPv370fTpk3fyIvNO++8g+DgYJw/fx6PHz/GunXruGWdOnXC+++/jx49epT7OGq1GhcuXNCb4Mzn8xEQEABra2uTn259fX0xYsQIfPzxx3qXOzo6IigoSO+yhIQE3L59Gy1atNC73MvLC15eXiadx+tKKpVSfgB57djZ2eGdd97Bjz/+iLfffhsSiQRJSUm4du0aLCwsMGLEiDLvu7CwEGFhYWBZFl26dDFYoHT69OlmX7naLLEsa+zrtXf48GEWAGttbc0mJSWxjRs3Zh0dHdldu3axaWlp7J49e1hHR0fWw8ODVSgU1X261SohIYH94Ycf2Pr163NfN2/erLD9y2Qy1s/Pj3VxcWEfPXqktSw7O5sdM2YM26FDBzY1NbVCjpedna1zHJZl2dDQUNbX15cdMWIEK5fLK+RYZqak68Lr9PVamzdvHtu/f//qPo0aJzc3l3VycmJ9fHzYxo0bs3Z2dqydnR07cuTIcu03LS2Nbdy4MQuATUhIqKCzJdVA7/XA7Lu0gKJRRE5OTpg5cyaioqLQr18/+Pn5oXbt2ujcuTOmTp2K+Pj4N7JLq7g6depg6tSpePr0KfdVkTU+1Go1Hj9+jLlz5+qtO7F9+3Zs2bKl1DV9DLG1tdVbVHHixIno06cP7ty5g1u3bkGpVBqt7kxIRaLJa8tPLBZjyZIlSEpKwuPHjyGXy/HBBx/onYqhNJRKJaKjo2FhYfFGtvabO7Pv0gKK/ojj4uK4mdc/+eQTNG/eHEBRDsiIESOwcOHCajxDotGgQYNKP4afnx8aNmyINWvWoGfPnlyV008++YQSDEmlKigoQJs2bXDlyhWaD6kchEIhJk6cCKFQiLi4OAwZMgSNGzcu935dXFwgk8kq4AxJTWT2AY+rqyu6dOmC8+fPAwDi4+O1phwQCAQV1qJADMvMzMT27dvRrVs3jBs3rtKrl5bE09MTHTp0QFhYGBYvXgwAGDlyJAU8pFIJBAJ89tlnJk9V4+TkBHd390o+q9fXqFGjoFarq3yEK3k9MSV047z2fTz5+flISkpCTk4OgKLKzq+OBEpPT4ejoyMKCwvpg1NJVCoV0tPTIZVK4e3tXe3Nxbm5uYiIiMCGDRuwZ88eAEBcXFyVF3+socypLb9GXcPkcjn8/PwQGRlZYgvPkiVLsHfvXgQEBJSq9AIhRP81zOxbeKysrODj41Pdp/HG4/P5cHZ2rjFDOW1sbNCsWTNMmzaNG4FmaEQGIRWFZVk8f/4cmzZtwujRo+Ho6Ghw3du3b4PP56Np06ZVeIaEmC+zD3hMwefzUb9+/WpvdSBVSyKRICgoyODQdUIqmkAgwLhx47B7927k5eVhyJAhaNiwoc56hw8fxtOnT9GsWTOtKXcIIWVHAQ+KLkKBgYGIiYmBr69vmeaFIoSQkgiFQqxevRqenp4IDw+HSCRCv379ABSNYszOzgYALFy4EHK5HO3bt38jZkMnpCqYfQ6PKXJzczFkyBDY2Nhg48aNRpuZCXkDmFNTZ428hnl5eSEtLQ0NGjTgunkLCwtx4cIFAEXTFyxatAiDBw+mLnlCSu/NzOExBcMwcHd3x/HjxyGXy6v7dAghZi4uLg5bt27FunXrcPr0aZ3ln332GYYNG0ZJ9IRUIAp4ilmxYgUNUSeEVIlx48ZBqVTi2rVrOsumTZtGLc2EVDDq0kJRl9bo0aOxY8cO2NjYUPIyedOZ0wegRl/DpFKp3srL9vb2pZ5IlxDC0XsNo4AHRUXx/Pz88OLFC6rDQwgFPISQ15veaxg9QqBodERKSkp1nwYhhBBCKonZBjyRkZGIj4+v7tMghBBCSA1glgFPTk4OfvjhBxw6dIibUsIQpVKJ1NTUKjozQgghhFQHsxyl9fvvv+PSpUsIDw8Hy7KYPHky+Hw++Hy+zroxMTH4/PPPKUGQEEIIMWNmeZefOHEivLy8cPfuXYSGhqJu3br44YcfdNaLi4vDsWPH8Ndff6FHjx4U9BBCCCFmymxHaUmlUixatAirV68GwzCwsLCAWCzGjBkz0LhxY2zfvh3nz59HYWEhrKys8Pz58xJnLybkDUGjtAghr7M3b1h6QkIC/vzzT6xduxYvXrxAWloaXF1dYWVlhdTUVOTm5kIikaBdu3b466+/qvt0CakpKOAh5P/au3tbB4EgCqNjyTUQQC80QAtENABlExJB6uClT7JkyT9czklJJkKfZqVdzux6T0u0bVvDMFTTNLVtW+37Xsuy1LquVVXV931N01Rd1315UgDgnaI3PP+Z57mO46iqv+AZx/HLE8HPseEBzux6R1rASwQPcGZuWgYArknwAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEE/wAADxBA8AEO/+5PvtI1MAvId/GFBVNjwAwAUIHgAgnuABAOIJHgAgnuABAOIJHgAg3gO3Kh7J8c4mEgAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Difference Score =  0.49201375\n",
            "Its a Forged Signature\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 260
        },
        "id": "C8ICcWijnWGM",
        "outputId": "5f26d580-8e2c-447d-9e03-e32030bf822b"
      },
      "source": [
        "predict_score()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Difference Score =  0.61000997\n",
            "Its a Forged Signature\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mp8-ehO4_7TB"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}