GAMTalk.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imaging Time-Series to Improve Classification\n",
    "\n",
    "The Deep Learning boom is largely fueled by its success in computer vision and speech recognition. However, when it comes to time series, building predictive models can be gruesome (Recurrent Neural Networks are difficult to train, research is less applicable, and no pre-trained models exist, 1D-CNN can be inconvenient).\n",
    "\n",
    "https://arxiv.org/pdf/1506.00327.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mathematics pre-requistes\n",
    "The inner product between two vectors, is a measure of how close the two vectors are.\n",
    "In the simplest case (2D space), the inner production between two vector $\\vec{u}$ and $\\vec{v}$ is defined as: <br>\n",
    "$\\left<\\vec{u}, \\vec{v}\\right> = u_1 . v_1 + u_2 . v_2$<br>\n",
    "In other way, <br>\n",
    "$\\left<\\vec{u}, \\vec{v}\\right> = ||\\vec{v}|| . ||\\vec{v}|| .\\text{cos}(\\theta)$ <br>\n",
    "If the vectors of norm 1, we have: <br>\n",
    "$\\left<\\vec{u}, \\vec{v}\\right> = \\cos(\\theta)$ <br>\n",
    "Therefore, when dealing with unit vectors, their inner product is solely characterized by the angle θ (expressed in radian) between u and v. Furthermore, the resulting value lies within [-1, 1]. <br>\n",
    "\n",
    "## Gram Matrix\n",
    "The Gram Matrix is a useful tool in Linear Algebra and Geometry. Among others, it is frequently used to compute the linear dependence of a set of vectors.<br>\n",
    "Definition: the Gram Matrix of a set of n vectors is a matrix defined by the dot-product (see similarity) of every couple of vectors. Mathematically, this translates to:<br>\n",
    "$G = \\begin{bmatrix}\n",
    "\\left<\\vec{v_1}, \\vec{v_1}\\right> & \\left<\\vec{v_1}, \\vec{v_2}\\right> & \\cdots & \\left<\\vec{v_1}, \\vec{v_n}\\right> \\\\\n",
    "\\left<\\vec{v_2}, \\vec{v_1}\\right>  & \\left<\\vec{v_2}, \\vec{v_2}\\right>  & \\cdots & \\left<\\vec{v_2}, \\vec{v_n}\\right> \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "\\left<\\vec{v_n}, \\vec{v_1}\\right>  & \\left<\\vec{v_n}, \\vec{v_2}\\right>  & \\cdots & \\left<\\vec{v_n}, \\vec{v_n}\\right>  \n",
    "\\end{bmatrix}  $<br>\n",
    "\n",
    "Assuming all 2D vectors of norm 1: <br>\n",
    "$G = \\begin{bmatrix}\n",
    "\\cos(\\phi_{1,1}) & \\cos(\\phi_{1,2}) & \\cdots & \\cos(\\phi_{1,n}) \\\\\n",
    "\\cos(\\phi_{2,1})  & \\cos(\\phi_{2,2})  & \\cdots & \\cos(\\phi_{2,n}) \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "\\cos(\\phi_{n,1})  & \\cos(\\phi_{n,2})  & \\cdots & \\cos(\\phi_{n,n})  \n",
    "\\end{bmatrix}  $<br>\n",
    "\n",
    "The Gram Matrix preserves the temporal dependency. Since time increases as the position moves from top-left to bottom-right, the time dimension is encoded into the geometry of the matrix. <br>\n",
    "Any inner product will remove information about the two vectors of observation, so instead we define new operation for the inner product:<br>\n",
    "$x\\bigoplus y = \\cos(\\phi_1+\\phi_2)$<br>\n",
    "And so the gram matrix\n",
    "$G = \\begin{bmatrix}\n",
    "\\cos(\\phi_1+\\phi_1) & \\cos(\\phi_1+\\phi_2) & \\cdots & \\cos(\\phi_1+\\phi_n) \\\\\n",
    "\\cos(\\phi_2+\\phi_1)  & \\cos(\\phi_2+\\phi_2)  & \\cdots & \\cos(\\phi_2+\\phi_n) \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "\\cos(\\phi_n+\\phi_1)  & \\cos(\\phi_n+\\phi_2)  & \\cdots & \\cos(\\phi_n+\\phi_n)  \n",
    "\\end{bmatrix}  $<br>\n",
    "\n",
    "\n",
    "## Implementation\n",
    "### Scale timeseries onto [-1,1] using min max scaler\n",
    "Scale the timeseries between [-1,1] this is useful if we convert the data into polar coordinate, since $\\cos(\\phi)$ lies between [-1,1] <br>\n",
    "![polar](image/polar.png\")\n",
    "Assuming our time series is composed of $N$ timestamps $t$ with corresponding values $x$, then:\n",
    "* The angles are computed using $\\cos^{-1}(x)$, they lie between [0,$\\Pi$].\n",
    "* The radius variable is computed as:$\\frac{t}{N}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example\n",
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.vision import *\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from pyts.image import GASF, GADF\n",
    "import pandas as pd\n",
    "# Math\n",
    "import math\n",
    "import numpy as np\n",
    "from datetime import datetime, timedelta\n",
    "import scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#parameters\n",
    "bs = 64\n",
    "n_classes = 3\n",
    "n_samples = 28\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# Tools\n",
    "def tabulate(x, y, f):\n",
    "    \"\"\"Return a table of f(x, y). Useful for the Gram-like operations.\"\"\"\n",
    "    return np.vectorize(f)(*np.meshgrid(x, y, sparse=True))\n",
    "def cos_sum(a, b):\n",
    "    \"\"\"To work with tabulate.\"\"\"\n",
    "    return(math.cos(a+b))\n",
    "\n",
    "class GAF:\n",
    "\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    def __call__(self, serie):\n",
    "        \"\"\"Compute the Gramian Angular Field of an image\"\"\"\n",
    "        # Min-Max scaling\n",
    "        min_ = np.amin(serie)\n",
    "        max_ = np.amax(serie)\n",
    "        scaled_serie = (2*serie - max_ - min_)/(max_ - min_)\n",
    "\n",
    "        # Floating point inaccuracy!\n",
    "        scaled_serie = np.where(scaled_serie >= 1., 1., scaled_serie)\n",
    "        scaled_serie = np.where(scaled_serie <= -1., -1., scaled_serie)\n",
    "\n",
    "        # Polar encoding\n",
    "        phi = np.arccos(scaled_serie)\n",
    "        # Note! The computation of r is not necessary\n",
    "        r = np.linspace(0, 1, len(scaled_serie))\n",
    "\n",
    "        # GAF Computation (every term of the matrix)\n",
    "        gaf = tabulate(phi, phi, cos_sum)\n",
    "\n",
    "        return(gaf, phi, r, scaled_serie)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(28, 28)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Toy dataset\n",
    "X = np.linspace(0,1,num=n_samples) **2\n",
    "gaf = GAF()\n",
    "g, _,_,_ = gaf(X)\n",
    "print(g.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'GAF')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAHkCAYAAADGuommAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAIABJREFUeJzs3Xl8XGXZ//HvNZlMJ2mapmnSvaV7aaFYoLTslFU2gcftoSyCIkUBFcWfIgIibriLylYEWUQQBaTKJrILFFugdKVbuqVr0jRp0qwzc//+SOAJJW0nd5Yzk/m8X6++ksyca67vTJLpXLnPnGPOOQEAAAAAEIRQ0AEAAAAAAJmLoRQAAAAAEBiGUgAAAABAYBhKAQAAAACBYSgFAAAAAASGoRQAAAAAEBiGUqCdzOwUM3vazLabWb2ZrTCzn5pZvyTrZ5iZM7MZHr1vNLMuPY+Tma01s3u7sgcAAADwPoZSoB3M7FpJz0qql/RFSR+XdIekiyXNM7PhSdzM25KOaPnYXn9oqQUAAAB6BHOuSxddgB7DzI6X9LykW5xzX9/tulGS3pL0rnPu+D3UZ6n5dy7W5WE7wMzWSnrJOXdxwFEAAACQAVgpBZL3LUkVkr6z+xXOuTWSbpY0w8ymS1LLLro/MrNrzGyNpEZJk9vafdfMsszsh2a22cxqzewFM9u/ZbsbW233kd13W7b5oZl91czWmFm1mb1sZgfstt0pZvZUqx6LzezqlmEZAAAACARDKZAEMwtLOk7Sc865+j1sNqfl4wmtLrtY0hmSvtnycdMear8v6VpJ90s6W827CM/Zw7ZtuaDl9r8m6fOSRkh6oiX3+0areaX3Cy3b3ifpRkk/akcfAAAAoFOF970JAEn9JeVIWruXbd6/rvX7Sk3SKc65ug8uMJvYuqjlAElXSbrDOfftloufM7MmSb9MMl+TpDOdc00ttylJf5U0TdLrkuScu6NVT5P0qqSIpG+a2bXOuUSSvQAAAIBOw0opkBzzrHum9UC6B5Ml9VbzENna39rR57n3B9IWi1o+jnj/AjMbbGZ3mtk6Ne9K3CTph5IKJA1oRy8AAACg07BSCiSnXFKdpJF72eb96za0umxzErc9uOXjtt0u35pMsBYVu33d0PIxKklmFlLz7sBD1LzL7ntqvj/nSPru+9sBAAAA3Y2hFEiCcy5mZq9IOtnMont4X+lZLR9faF2axM2/P7gOkLSk1eUD2590j8ZImirpQufcn96/0Mw+0Yk9AAAAgHZj910geT9X83tLf7z7FS2nhPm2pFecc2+283YXSdol6TO7Xb771x2R2/Lxg118zSxb0vmd2AMAAABoN1ZKgSQ55543sxsk3WRmI9V8pNwdkg6RdI2kKkkXetzuDjP7jaRrzaxa0r9bbvOSlk064wBEyyStk/QjM4ureTj9+t5LAAAAgK7HSinQDs65H0g6Tc0HJvqjpH9JulzNA+pU59x6z5v+nqSfSLpIze/9PE3Np5ORmofdDnHONar5/aNb1Jz1VkmvqPncqgAAAEBgzLlk3vIGoLuZ2WckPSLpWOfcq0HnAQAAALoCQymQAsxsuqQzJL0pqV7SoWreJXi5pCMdv6gAAADooXhPKZAaaiQdK+kKSflqPj3MI5K+w0AKAACAnoyVUgAAAGQ0MztC0tckHa3mU7TVq3lvpWck3eac27zb9kdLelXNf0Qe6pyLtXGbe3qR/aBz7oJOjA+kPVZKAQAAkLHM7Go1n/btRUnXSSqRlCfpSEmz1Hye79N2K7uo5eOAluv+sYebv1fSnbtdVtbh0EAPw0opAAAAMpKZHS/peUm3OOc+cqo0M+st6TPOuXtbXZYjabOkdyRNk/S0c+7TbdQ6ST9yzl3XRfGBHiOwldKioiI3cuTIoNoDAHqYt956q9w5Vxx0DgBp5duSyls+foRzbpeaVztbO0dSX0m3Sdoo6dNm1s85t6MLcwI9WmBD6ciRIzV//vyg2gMAehgzWxd0BgDpw8zCko6T9FjL+byTdZGkSjWfV7xK0vmSzpV0e9tt7EOvt9t6/ymQ6UJBBwAAAAAC0F9SVNL63a8ws3Drf60uHyLpJEmPOOcaJP1bzaulF+1+Gy2uldTU+p+Zje3cuwGkP4ZSAAAAZCJr80KzQfroIPn+YHqBpCxJ90uScy4h6U+SppvZhDZu7h5Jh+32b0Mn3gegR2AoBQAAQCYqV/OpX0a0cfn7A+Rdu133OTWvrC4xswIzK5D0RKvrdrfZOTd/t38NnXcXgJ6BoRQAAAAZp+W9na9IOtnMIq0vf3+AlLTp/cvNbKqkA9Q8xO5o9e/1lk0uNDNeWwMe+MUBAABApvqZpCJJP01i24skOUmfknT8bv9uljRc0owuSQn0cIEdfRcAAAAIknPueTO7RtLNZnaQmt8rukbNB0Aar+aj6u5S8/tIz5X0snPusd1vx8wWSLpKzYPrC90UH+gxWCkFAABAxnLO/UzSMZK2S/qxmo+o+zc1D5h/kTRO0ulqXlG9Zw+3USnpMUmfMrO8bogN9CislAIAACCjOedek/TaXjZ5XHs4Wm+r2zh/t6/3uj2A/8NKKQAAAAAgMAylAAAAAIDAMJQCAAAAAALDUAoAAAAACAwHOgIAAJKkXCtyBRoZdIykdOQQMs7zT/K+dZKU8KxNZHWgp2dtIuy8e8Y9X1nGA+gZy/bvqXDCqyy7A/cznOXX07dOkrJDfrURi/v3dH61kUTMu2ck5lfbq8m/Z6i+ya+wzrNOknY1etb593xLKnfOFe9rO4ZSAAAgSSrQSM3S/G7tmcjye5Eei/j39K1tzPXvWe95kpDaAv8hpravX21NoX/PnUV+Q8zOIv8hprLYr7ZigP8LbVfk9+J+QHGDd8+ignqvukF9a717Dsqp8aobEt7p3XNYvNKvrnaHd88R28u96kZu2Obds8/yzX6FizzrJGleqV/dXM86SSatS2a7ff7dzszuMbNtZrZ4D9ebmf3WzFaZ2UIzO6S9YQEAAAAAmSmZnUnulXTqXq4/Tc0nFR4naZak2zseCwAAAACQCfY5lDrnXpFUsZdNzpZ0v2s2V1KBmQ3urIAAgJ4pkXDaUOG/WxkAAOgZOuPou0MlbWj1dWnLZQAA7NEL723TcT9/UW+WbA86CgAACFBnDKVtHf+uzXfIm9ksM5tvZvPLyso6oTUAIB0553TrS6s0uG+ODtmvX9BxAABAgDpjKC2VNLzV18MkbWprQ+fcbOfcVOfc1OLifR4ZGADQQ80tqdA76yv1peNGKzuLU2YDAJDJOuOVwBxJn2s5Cu/hkqqccx04VjEAoKe77aVVKsrrpc9MHb7vjQEAQI+2z/OUmtlDkmZIKjKzUknfk5QtSc65OyQ9Jel0Sask1Ur6fFeFBQCkv4WllXp1ZbmuOW1/RbOzgo4DAAACts+h1Dk3cx/XO0lXdFoiAECPdtuLq5UfDev86SOCjgIAAFIAb+QBAHSbVduq9cySLbroyJHqE80OOg4AAEgBDKUAgG5z+0slysnO0uePGhV0FAAAkCIYSgEA3WJDRa3+vmCjzp02XIW9I0HHAQAAKYKhFADQLe56tUQhky49ZnTQUQAAQArZ54GOAADoqLLqBv1l3gZ98uBhGlKQE3Qc7EFDb2nV5ES763IrzbtntMavLlLr3VKROr8636ySVLDZ9zHyf2x9JbJcB2r9jqjdmOP/HvPGXL+62r7eLVVb4PcY1RT6P7Y7i9v/uylJGwfHvXsuGhTzqts2tNG7Z86QBq+6IQP9nxRGFld71Y3eb4d3z/FHl3nVHbhjo3fPaYtWetX1/s4/vHtqbmlSm7FSCgDocve8tkaN8YQuO45VUgAA8GEMpQCALlVV16QH3lin0ycP1ujivKDjAACAFMNQCgDoUn+au041DTFdPmNM0FEAAEAKYigFAHSZusa47v7PGh0/oVgHDOnAG7gAAECPxVAKAOgyD89br4pdjbr8+LFBRwEAACmKoRQA0CUaYwnd9UqJpo0s1GEjC4OOAwAAUhRDKQCgS/x9wUZtqqrX5cfzXlIAALBnDKUAgE4XTzjd8dJqHTAkX8eNLw46DgAASGEMpQCATvfski0qKd+ly2eMlZkFHQcAAKQwhlIAQKdyzunWF1dpdFFvnXrgoKDjAACAFMdQCgDoVC+vKNOSTTv1pePGKCvEKikAANg7hlIAQKe67aXVGtw3qnMOHhp0FAAAkAYYSgEAnWbe2gr9d02FZh07WpEw/8UAAIB9CwcdAADQc9z24ioV9o7o3MNGBB0FHhp6O606rKnddXk7/P8AkVfhV5tb5b9reG6lX220xrulotXOqy5S598z3OhXF4r7P7ahuF+db1ZJitb4Pba5lf49G7f5PUb1ffwf29q+frVF6/1/P3cW+40Kg4Zke/csH9rLq27NiKh3zy0jcvzqhuZ69ywv9qvdWeh/PzXZr+z4w4b595xbmtRm/BkbANAplmyq0ovLy/SFo0YqJ5IVdBwAAJAmGEoBAJ3i9pdWK69XWBceMTLoKAAAII0wlAIAOmxN+S49tWizLjxiP/XN8d9tCwAAZB6GUgBAh9358mplZ4X0haNGBR0l45jZcDN70cyWmdkSM/tay+U3mtlGM1vQ8u/0oLMCANAWDnQEAOiQjZV1evTtUp172AgV9/E7QAU6JCbpaufc22bWR9JbZvZcy3W/ds79IsBsAADsE0MpAKBDbn9plSTpSzPGBJwkMznnNkva3PJ5tZktk8RJYgEAaYPddwEA3jZX1emReaX6zNThGlrgd0h9dB4zGynpYElvtlx0pZktNLN7zKxfYMEAANgLhlIAgLc7XlqthHP68nGskgbNzPIkPSrpKufcTkm3SxojaYqaV1J/uYe6WWY238zmN9WVdVteAADex1AKAPCydWe9Hpq3QZ8+dJiGF/qfQBwdZ2bZah5IH3TOPSZJzrmtzrm4cy4h6S5J09qqdc7Nds5Ndc5Nzc4p7r7QAAC0YCgFAHi54+XViiecLp8xNugoGc3MTNLdkpY5537V6vLBrTb7H0mLuzsbAADJ4EBHAIB221Zdrz+/uV7/c/BQjejPKmnAjpJ0oaRFZrag5bJrJc00symSnKS1ki4LJh4AAHvHUAoAaLfZL5eoKZ7QlcezSho059x/JFkbVz3V3VkAAPDB7rsAgHYpr2nQn95cp3OmDNXIot5BxwEAAGmOoRQA0C53vVqixlhCV5zAKikAAOg4dt8FACStYlejHnhjnT7xsSEaU5wXdBx0soachEomN7S7Lr8iy7tn/na/2vxy/555O9ra2zmJugr/v+XnVvrVRWv8skpStNqvLlLnvHuGG33r/O9nKO5XG6nzbqlwo99j1JGe0Wq/+5lb5f/Y5lb63c+O9Mzb4fd7llfp//u5pcrv+WRprf/zUGPMs3bwvjfZk/x+9V51x0/uQNMksVIKAEjaH14tUV1TXF9hlRQAAHQShlIAQFJ27GrUfa+v1RmTB2vsgD5BxwEAAD0EQykAICn3vLZGuxrj+uqJ44KOAgAAehCGUgDAPlXVNune19bq9MmDNH4gq6QAAKDzMJQCAPbpntfWqLohpq+cwCopAADoXAylAIC9qqpr0j2vrdHHDxioiYPzg44DAAB6GIZSAMBe3ff6WlXXx3gvKQAA6BIMpQCAPaqub9Ld/1mjkyYO1AFD+gYdBwAA9EAMpQCAPbr/jXWqqmvS11glBQAAXYShFADQppqGmO56tUQn7D9Ak4exSgoAALoGQykAoE0PvLFOlbVNvJcUAAB0KYZSAMBH7GpZJT1ufLGmDC8IOg4AAOjBGEoBAB/x4JvrVLGrkVVSAADQ5cJBBwAApJa6xrhmv1KiY8YV6dD9+gUdB90oEU2obkJtu+sqt0e8exaU+70Uye+f5d0zf7tfbX65f8+8HeZXV+G/fpBb6VcXrfHLKknRar+6SJ3z7hlu9K3zv5+huF9tpM67pcKNfo+R7+PTXOt7PzvwM+T589eRnr73c1PCv+cqz7pIOO7ds2ho+5/fJal6wmDvnslipRQA8CEPvrlO5TWskgIAgO7BUAoA+EB9U1x3vlKiI8f012EjC4OOAwAAMgBDKQDgAw/9d73KqhtYJQUAAN2GoRQAIKn5vaS3vbRa00cV6vDR/YOOAwAAMgRDKQBAkvTA3LUqq27Q1adMCDoKAADIIAylAADVNMR0+0urdcy4Ik0bxXtJAQBA92EoBQDo3tfWaEdtE6ukAACg2zGUAkCGq6pr0uxXSnTSxIGaMrwg6DgAACDDMJQCQIa7+9US7ayP6Rsnjw86CgAAyEAMpQCQwSp2Neru/6zRGZMHa9KQ/KDjAACADMRQCgAZ7M6XV6u2Ka6rTuK8pAAAIBgMpQCQobZV1+u+N9bqnClDNW5gn6DjAACADMVQCgAZ6rYXV6sp7vS1E1klBQAAwWEoBYAMtKmyTn9+c70+fcgwjSzqHXQcAACQwcJBBwAAdL/fv7hKTk5fOXFs0FGQQiLZCY0cvqvddRX5Td49K/pGvOp29sv27llQ4Fdbm5/w7pm/PcuvZ1/n37PMb+0ht8q7pXJzrNt7Rmo96+r8H9two19dKO73+HSktiP3MxT3qws3eLdUuNHvfobi/mttoXj3j0SJUI5X3dpcz2+KpEF9+/n1HD7Au2eyWCkFgAyzfnutHpm3QTOnjdCwfrlBxwEAABmOoRQAMsxvX1iprJDpiuNZJQUAAMFjKAWADLK6rEaPvV2qCw/fTwPzo0HHAQAAYCgFgEzym3+vVDQ7S1+aMSboKAAAAJIYSgEgY7y3Zaf+uXCTLj5ypIryegUdBwAAQBJDKQBkjF8/t0J5kbBmHTs66CgAAAAfYCgFgAywqLRKzy7ZqkuOGaWCXL9TcAAAAHSFpIZSMzvVzJab2Sozu6aN60eY2Ytm9o6ZLTSz0zs/KgDA16+eW66C3Gx94ehRQUcBAAD4kH0OpWaWJelWSadJmiRppplN2m2z6yQ94pw7WNK5km7r7KAAAD9vrduhF5eX6bJjxyg/mh10HAAAgA9JZqV0mqRVzrkS51yjpIclnb3bNk5SfsvnfSVt6ryIAICO+NVzy1WUF9FFR+4XdBQAAICPSGYoHSppQ6uvS1sua+1GSReYWamkpyR9pVPSAQA65PXV5Xpt1XZ9ecZY5UbCQccBAAD4iGSGUmvjMrfb1zMl3eucGybpdEkPmNlHbtvMZpnZfDObX1ZW1v60AICkOef0q3+t0KD8qM6fPiLoOAAAAG1KZigtlTS81dfD9NHdcy+R9IgkOefekBSVVLT7DTnnZjvnpjrnphYXF/slBgAk5ZWV5Zq/boeuOGGsotlZQccBAABoUzL7cs2TNM7MRknaqOYDGZ232zbrJZ0o6V4zm6jmoZSlUAAIiHNOv/zXcg0tyNH/Th2+7wJAUiQc14j+1e2uy+0V9e6ZG4171VXmxbx7luX59azN8z9QWG0fv93n8/P9/6BU39uvNr/c/4yBjTlt7WC3b7GIX50kRWv8anMrvVsqUudXF27cfWfD9tT63c9Q3P+x9b2fobj//fTnfz99z5KZyPJ/W0ws4vcYreqb491zbXEfr7r1xR9Za+x0+/wOOOdikq6U9KykZWo+yu4SM7vJzM5q2exqSZea2buSHpJ0sXMuiJ9GAICkfy3dqoWlVfraieMUCXNKagAAkLqSGu+dc0+p+QBGrS+7odXnSyUd1bnRAAA+YvGEfv7sco0u7q1PHrL7cekAAABSC38+B4Ae5rG3N2rVthp96+MTFM7iaR4AAKQ2Xq0AQA9S3xTXr/+9QlOGF+jjBwwKOg4AAMA+MZQCQA9y3+trtbmqXt8+dX+ZdeSgDwAAAN2DoRQAeoiquibd9tJqzZhQrCPG9A86DgAAQFIYSgGgh7jj5dXaWd+kb318/6CjAAAAJI2hFAB6gC1V9frja2t09seGaNKQ/KDjAAAAJI2hFAB6gFueX6F4wunqUyYEHQUAAKBdGEoBIM2tLqvRI/NLdf70/TS8MDfoOAAAAO3CUAoAae4Xzy5XNBzSlSeMDToKAABAuzGUAkAae2f9Dj29eIsuPXa0ivJ6BR0HAACg3RhKASBNOef002feU//eEX3xmNFBxwEAAPDCUAoAaerlFWWaW1Khr5wwVnm9wkHHAQAA8MKrGABIQ4mE00+fWa7hhTk6b/p+QcdBDxEJJTQsd2e763Kzm7x75vaK+dVFo949o9GEV11lbty755bciFddfa7/S7XGqPOry8ny75njt94Ri/ivk+RW+dUlssy7Z7TGs67au6Ukv+9nuNH/fvrqSM9ojd/97Bi/vIks/5/bxhy/3+2aAr/nEknaNMzvYIil+/Xz7pksVkoBIA3NeXeTlm3eqW+eMkGRME/lAAAgffFKBgDSTGMsoV8+t1yTBufrEwcNCToOAABAhzCUAkCa+fOb67Shok7fOnWCQqHu3y0LqcXMhpvZi2a2zMyWmNnXWi4vNLPnzGxly8eu3/8KAAAPDKUAkEZqGmL63QurdMTo/jpufHHQcZAaYpKuds5NlHS4pCvMbJKkayQ975wbJ+n5lq8BAEg5DKUAkEbueqVE23c16tun7S8zVkkhOec2O+febvm8WtIySUMlnS3pvpbN7pN0TjAJAQDYO4ZSAEgT5TUN+sOrJTrtwEGaMrwg6DhIQWY2UtLBkt6UNNA5t1lqHlwlDQguGQAAe8ZQCgBp4vcvrFJ9LKFvfnxC0FGQgswsT9Kjkq5yziV9Xhczm2Vm881sfn15ZdcFBABgDxhKASANrN9eqwffXKfPTh2uMcV5QcdBijGzbDUPpA865x5ruXirmQ1uuX6wpG1t1TrnZjvnpjrnpkaLWIEHAHQ/hlIASAO/fG65skKmq04aF3QUpBhrfnPx3ZKWOed+1eqqOZIuavn8IklPdHc2AACSEQ46AABg75ZsqtITCzbpyzPGaGB+NOg4SD1HSbpQ0iIzW9By2bWSbpb0iJldImm9pM8ElA8AgL1iKAWAFPezZ5arb062vnTcmKCjIAU55/4jaU+HYj6xO7MAAOCD3XcBIIW9urJML68o0xXHj1HfnOyg4wAAAHQ6hlIASFHxhNOPnlym4YU5+twRI4OOAwAA0CXYfRcAUtTf3tqg97ZU6/fnHaxodlbQcZABIhbXsKyqdtdFQzHvntEsv9poOO7fM+LZM+L/nu6KSMKrriwS8e7ZGPXr2Rj1f3kYy/arjWU7/54RvzWWRJb/2kzM89uSyNrTnvbJ1PrVRer8H9tInX9eX+FGv57RGv/76SsW8X98CvL8fv6K+vn/fm7a1MurrjSr64/MzkopAKSgXQ0x/eJfK3TIiAKdMXlw0HEAAAC6DEMpAKSgO19erbLqBl135iQ1n/EDAACgZ2IoBYAUs7mqTrNfLdGZBw3WISP6BR0HAACgSzGUAkCK+fmzy5Vw0rdP3T/oKAAAAF2OoRQAUsjijVV67O2N+vxRIzW8MDfoOAAAAF2OoRQAUoRzTj98cqkKe0d0xfFjg44DAADQLRhKASBFPLd0q+aWVOjrJ41TfjQ76DgAAADdgqEUAFJAUzyhm59+T2OKe2vmtBFBxwEAAOg2DKUAkAIenLtOJeW7dO3pExXuwAndAQAA0g2vfAAgYFW1TfrN8yt11Nj+OmH/AUHHAQAA6FYMpQAQsN+/uFJVdU367umTZGZBxwEAAOhWDKUAEKB123fpvtfX6TOHDtOkIflBxwEAAOh2DKUAEKCfPvOeskKmq0+ZEHQUAACAQDCUAkBA5q+t0FOLtuiy40ZrYH406DgAAACBCAcdAAAyUSLh9IMnl2lgfi/NOnZ00HEASVK2i2tIrKrddZFw3LtnNDvmVRexDvQMe/YMJ7x7RrL98kYi/j0rekW86hp7Oe+eMc9TLMciWf49/e6md50kJbKCeP9/ED39fhYidd2fNdzo3zNS53c/c9v/dPmB/G1+eQv7+v+uDNjo90O/Kdb1by9ipRQAAvCPhZv07oZKffOUCcqN8PdBAACQuRhKAaCb1TfF9bNnlmvS4Hx96pBhQccBAAAIFEMpAHSzP762Vhsr63TdGRMVCnEKGAAAkNkYSgGgG5XXNOjWF1fppIkDdOTYoqDjAAAABI6hFAC60W/+vUJ1TXFdc9rEoKMAAACkBIZSAOgmK7dW66H/btAF00do7IC8oOMAAACkBIZSAOgGzjn98Mllyo1k6WsnjQ86DgAAQMpgKAWAbvD8sm16eUWZrjppvAp7d+DkeAAAAD0MQykAdLH6prhu+udSjR2Qp88dsV/QcQAAAFIKQykAdLG7/7NG6ytq9b1PTFJ2Fk+7AAAArfHqCAC60Jaqet364ip9/ICBOmZccdBxAAAAUg5DKQB0oZufXqZYwum6MyYFHQUAACAlMZQCQBeZv7ZCf1+wSV86drSGF+YGHQcAACAlhYMOAAA9UTzh9L05SzSkb1RfnjE26DhAUrITMQ2qq2p3XSQa8+4ZCfvV+tZJUiQU79Y6SYqEPXtmJ7x7hsPOq67Cs06StmX71cays717xjx7JrKyvHsmPI8P4FvXXOtbad49/fn/DEXquj9vuNGvLlrt3zMv4nc/88v8H5/CLX6j35a6rj+3OiulANAF/jJvg5Zs2qlrz5ionIj/Cx8AAICejqEUADpZVW2Tfv7se5o+qlBnTB4cdBwAAICUxlAKAJ3s1/9eoaq6Jt141gEyC2K3KQAAgPTBUAoAnei9LTv1wNx1uuDw/TRxcH7QcQAAAFIeQykAdBLnnL4/Z6n6RMP6xsnjg44DAACQFhhKAaCTPL14i94o2a5vnjJBBbmRoOMAAACkBYZSAOgEdY1x/ejJZZo4OF8zp40IOg4AAEDaYCgFgE5wx8urtbGyTt8/6wBlhTi4EQAAQLIYSgGggzZU1OqOl1frrI8N0bRRhUHHAQAASCsMpQDQQT9+aplCZvrO6fsHHQUAACDtMJQCQAe8tqpcTy/eoitPGKvBfXOCjgMAAJB2GEoBwFNTPKHv/2OJRhTm6pKjRwUdBwAAIC0xlAKApz/NXacVW2t0/ZmTFM3OCjoOAABAWmIoBQAP22sa9KvnVujY8cU6aeKAoOMAAACkrXAyG5nZqZJukZT9p4BKAAAgAElEQVQl6Q/OuZvb2Oazkm6U5CS965w7rxNzAkBK+cW/lquuMa4bzpwkM04Bg54hOx7XoKrKdteFEwnvnuGoX20kO+7fM+TZs1f39wyHnH/PLM+ennWSVBH2qy3vwP1MhLL96jqwg0tHav0FsZbU/f+/heJ+PwvhRv+sobhfbaTO/+c2Wu1Xl7fd/34Wbvb7wd1SlevdM1n7HErNLEvSrZJOllQqaZ6ZzXHOLW21zThJ35F0lHNuh5mxbACgx1pYWqmH523QF48epbED8oKOAwAAkNaS+ZPLNEmrnHMlzrlGSQ9LOnu3bS6VdKtzbockOee2dW5MAEgN8YTTdx9frKK8XvrKieOCjgMAAJD2khlKh0ra0Orr0pbLWhsvabyZvWZmc1t29wWAHufBN9dp0cYq3XDmJOVH/XYZAwAAwP9J5j2lbe24vPsO1GFJ4yTNkDRM0qtmdqBz7kNvTDGzWZJmSdKIESPaHRYAgrRtZ71+/sxyHTOuSGceNDjoOAAAAD1CMiulpZKGt/p6mKRNbWzzhHOuyTm3RtJyNQ+pH+Kcm+2cm+qcm1pcXOybGQAC8cMnl6khntBNZx/IwY0AAAA6STJD6TxJ48xslJlFJJ0rac5u2/xd0vGSZGZFat6dt6QzgwJAkP6zslxz3t2kLx83RqOKegcdBwAAoMfY51DqnItJulLSs5KWSXrEObfEzG4ys7NaNntW0nYzWyrpRUn/zzm3vatCA0B3qm+K6/onFmtk/1x9ecaYoOMAAAD0KEmdp9Q595Skp3a77IZWnztJ32j5BwA9yp0vl2hN+S49cMk0RbMDOTkdAABAjxXEWXgBIG2sLd+lW19apTMPGqxjxvFeeAAAgM7GUAoAe+Cc0/VPLFavrJCuP3NS0HEAAAB6JIZSANiDJxdt1qsry3X1KeM1MD8adBwAAIAeiaEUANpQXd+km/6xVAcOzdeFR4wMOg4AAECPldSBjgAg0/zyXytUVtOguz43VVkhzkkKAADQVRhKAWA3izdW6f431uqC6fvpY8MLgo4DdJtwPKGiymqvOu+e+XG/uhy/OkkKZ3v2zPK/n6Fs59fTOvDYhvxqQ+aXVZLCWX615R3Yd8+3NpExB1P3f3BD3r9m/n/M9e/ZgZ/bRr+8obj//YzU+eXNrfLvmV/m97OwurLr38LE7rsA0Eo84fTdxxepsHcvffPjE4KOAwAA0OMxlAJAK3/+73q9W1ql686YqL452UHHAQAA6PEYSgGgRVl1g372zHs6ckx/nT1lSNBxAAAAMgJDKQC0+NGTS9XQlNAPzjlQZhzcCOnBzO4xs21mtrjVZTea2UYzW9Dy7/QgMwIAsDcMpQAg6fVV5fr7gk267LjRGlOcF3QcoD3ulXRqG5f/2jk3peXfU92cCQCApDGUAsh4DbG4rntisUYU5uqK48cGHQdoF+fcK5Iqgs4BAIAvhlIAGW/2yyUqKdulm84+QNHsjDlHAHq+K81sYcvuvf2CDgMAwJ4wlALIaOu31+r3L67S6ZMHacaEAUHHATrL7ZLGSJoiabOkX+5pQzObZWbzzWx+xY7a7soHAMAHGEoBZCznnG6Ys1jhkOmGMw8IOg7QaZxzW51zcedcQtJdkqbtZdvZzrmpzrmphf1yuy8kAAAtGEoBZKw5727SS8vLdPUpEzSobzToOECnMbPBrb78H0mL97QtAABBCwcdAACCsL2mQd//x1JNGV6gi44cGXQcwJuZPSRphqQiMyuV9D1JM8xsiiQnaa2kywILCADAPjCUAshIN/1zqarrm/TTTx2krBDnJEX6cs7NbOPiu7s9CAAAnth9F0DGeeG9rXpiwSZdPmOsJgzqE3QcAACAjMZQCiCjVNc36brHF2vcgDxdfvyYoOMAAABkPHbfBZBRfvbMcm3eWa9Hv3ykeoU5JynQWjgW04CyyvbXxePePUMu4VXXkZ7hXL+eoV7Ov2eW5/3M9quTpJD55fWta671rAt1oKdnbYV3x8wRinf/+lUo7vdDFPJ/SlAo7vm74plVksKNfnXRau+Wyqvwy7utrJd/0ySxUgogY8xbW6EH5q7TxUeO1CEj+gUdBwAAAGIoBZAh6pvi+vajCzWsX46+ecqEoOMAAACgBbvvAsgIv3thpUrKdun+L0xT71489QEAAKQKVkoB9HhLN+3UnS+X6FOHDNOx44uDjgMAAIBWGEoB9GixeELffnShCnKzdf2ZE4OOAwAAgN2wDxuAHu3u/6zRoo1VuvW8Q1SQGwk6DgAAAHbDSimAHmtt+S796rkVOnnSQJ0+eVDQcQAAANAGhlIAPZJzTtc8tlCRcEg/POdAmfmfSwwAAABdh6EUQI/08LwNmltSoWtPn6iB+dGg4wAAAGAPGEoB9Dhbqur14yeX6YjR/XXuYcODjgMAAIC9YCgF0KM453T9E4vVGE/oJ5+czG67AAAAKY6hFECP8tSiLXpu6VZ94+TxGlnUO+g4AAAA2AeGUgA9RmVto743Z7EmD+2rS44eFXQcAAAAJIHzlALoMX7wz2WqrG3S/V+YrnAWf3MD2isUSyinvLrddUUJ59/TszYcT/j3dH49feskKdzLL28o3IHH1rM2FO1AT/PsGfLvGYSKoAO0QyjekVq/t8D41klSuNGzrsG7pfdjFKnrSE+/xyhS5/+7klvp19PKu/4877xqA9AjvLKiTI++XarLjhutSUPyg44DAACAJDGUAkh7O+ubdM2jCzW6uLe+csK4oOMAAACgHdh9F0Da+8E/lmrLzno9dvlRimZnBR0HAAAA7cBKKYC09u+lW/XXt0p1+YyxmjK8IOg4AAAAaCeGUgBpq2JXo655bJEmDs7XV09kt10AAIB0xO67ANKSc07X/32xquoa9cAl0xQJ8zc2AACAdMSrOABp6R8LN+vJRZt11UnjNXEwR9sFAABIVwylANLOtp31uv7vi3XwiAJdduzooOMAAACgAxhKAaQV55y+/ehCNcTi+uVnPqZwFk9jAAAA6YxXcwDSyiPzN+jF5WX69qn7a3RxXtBxAAAA0EEMpQDSxoaKWt30j6U6YnR/XXTEyKDjAAAAoBMwlAJIC4mE0//727syM/3s0wcpFLKgIwEAAKATMJQCSAv3vbFWc0sqdP2ZEzW8MDfoOAAAAOgkDKUAUt7qshrd/PR7OmH/Afrs1OFBxwEAAEAnCgcdAAD2JhZP6OpH3lU0O0s3f3KyzNhtF+gyTXFpW3W7y3olnHfLokTCqy4ci3v3DPn2jHegp/Prqah3S4XCfj1DYf/vZ8j8azNBRQdqQ54/fr51zbV+/+eGGzvS02/NzDdrc61vnf/Pe7ix+x/b3Cq/usJt2d49Nya5HUMpgJR25yslWrChUr+debAG5Hfg1RkAAABSErvvAkhZyzbv1G/+vUJnTB6sTxw0OOg4AAAA6AIMpQBSUmMsoW888q765kT0g3MOZLddAACAHorddwGkpN8+v1LLNu/UXZ+bqsLekaDjAAAAoIuwUgog5byzfodue2mVPn3oMJ08aWDQcQAAANCFGEoBpJT6priu/uu7GpQf1Q2fmBR0HAAAAHQxdt8FkFJ+9OQylZTt0p8uma78qP8hyAEAAJAeWCkFkDKeW7pVD8xdp0uPGaWjxxUFHQcAAADdgKEUQErYUlWvb/3tXR0wJF/f/PiEoOMAAACgmzCUAghcIuH0jUcWqL4pod/OPFi9wllBRwIAAEA34T2lAAI3+9USvb56u376qckaU5wXdBwAAAB0I1ZKAQRqYWmlfvHscp0+eZA+O3V40HEAAADQzRhKAQSmpiGmrz70jgb06aWf/M9BMrOgIwEAAKCbsfsugMDcOGeJ1lfU6uFZR6hvLqd/AQIXS0hlNe2viye8W2Z71hYmnHfPdBJy/vczFPWs7cjTse8hAaId6JlGEgn/P75WeP6ahTrQM9zkVxtu9G6pcKNfz0itf89IXRD3068uFPf/fkZq/Z4TCsr8j/WxMcntWCkFEIg5727S394q1ZXHj9W0UYVBxwEAAEBAGEoBdLsNFbX67uOLdMiIAn31xHFBxwEAAECAGEoBdKtYPKGr/rJActIt5x6scBZPQwAAAJmM95QC6Fa/e2GV3lq3Q7ecO0XDC3ODjgMAAICAsUQBoNvMW1uh372wUp88ZKjOnjI06DgAAABIAQylALpFVV2Trnp4gYYX5uqmsw8MOg4AAABSRFJDqZmdambLzWyVmV2zl+0+bWbOzKZ2XkQA6c45p2sfX6StO+t1y7kHK68X7xwAAABAs30OpWaWJelWSadJmiRppplNamO7PpK+KunNzg4JIL399a1SPblws75xynhNGV4QdBwAAACkkGRWSqdJWuWcK3HONUp6WNLZbWz3A0k/k1TfifkApLmSshrdOGeJjhjdX5cdOyboOAAAAEgxyQylQyVtaPV1actlHzCzgyUNd879sxOzAUhzjbGEvvbwAkXCIf36f6coK2RBRwIAAECKSeaNXW29inQfXGkWkvRrSRfv84bMZkmaJUkjRoxILiGAtPXLfy3Xoo1VuvPCQzWobzToOAAAAEhByayUlkoa3urrYZI2tfq6j6QDJb1kZmslHS5pTlsHO3LOzXbOTXXOTS0uLvZPDSDlvfDeVt35SonOnz5CHz9gUNBxAAAAkKKSGUrnSRpnZqPMLCLpXElz3r/SOVflnCtyzo10zo2UNFfSWc65+V2SGEDKK91Rq6//5V0dMCRf15/5keOiAQAAAB/Y51DqnItJulLSs5KWSXrEObfEzG4ys7O6OiCA9NIQi+uKB99Wwjnddv4himZnBR0JAAAAKSypkwU6556S9NRul92wh21ndDwWgHT14yeX6d3S5veR7te/d9BxALRHLC6V72p/XTzR+Vn2ISvh9r3RHhR61oUS/vcz5Jk35PzvZyCyPes68vfLAA5ZkEj4HbjPt6651q+uogM9w01+teHGIHomswPonmo9ezZ4t1S40e93uyOPbaTOry6/vOsXGPy/ewCwm3+8u0n3vbFOlx4ziveRAgAAICkMpQA6xaptNbrm0YWaul8/fevU/YOOAwAAgDTBUAqgw2obY7r8wbcUzc7S7887RNlZPLUA3cnM7jGzbWa2uNVlhWb2nJmtbPnYL8iMAADsCa8cAXSIc07XPb5YK7fV6JZzD+Z8pEAw7pV06m6XXSPpeefcOEnPt3wNAEDKYSgF0CEPz9ugx97ZqKtOHK+jxxUFHQfISM65VyRV7Hbx2ZLua/n8PknndGsoAACSxFAKwNvijVX63pwlOmZckb5ywtig4wD4sIHOuc2S1PJxQMB5AABoE0MpAC9VdU26/MG31b93RL/53ykKhfwPUQ4gOGY2y8zmm9n8srpY0HEAABmIoRRAuznn9P/++q42Vdbp9+cdov55vYKOBOCjtprZYElq+bitrY2cc7Odc1Odc1OLc5I6fTkAAJ2KoRRAu/3h1TX619Kt+s7pE3XofhzQE0hRcyRd1PL5RZKeCDALAAB7xFAKoF3mra3Qzc+8p9MOHKQvHDUy6DgAJJnZQ5LekDTBzErN7BJJN0s62cxWSjq55WsAAFIO++kASFp5TYOu/PPbGt4vRz/99EEy432kQCpwzs3cw1UndmsQAAA8sFIKICnxhNNVDy9QZW2Tbj3/EOVHs4OOBAAAgB6AlVIASbnl+ZX6z6py/fRTk3XAkL5BxwEAAEAPwVAKYJ9eXlGm372wUp8+dJg+O3V40HEAdJVYQirf1f66uOv8LPuS8O+Z5VlXGE9498Q+dGTnG89vaKKX/1tQEs6vtgM/torF/Xpui/nvGFnR5Ncz3OTdUmHPnpE6/+9npM7vG9Oxnn514UbvlgrF/eryy7t+51p23wWwV2vLd+mrD72jCQP76AdnH8j7SAEAANCpGEoB7FFNQ0yX3j9fZtLsC6cqJ+K7vgAAAAC0jd13AbQpkXD6+l8WqKR8lx74wjSN6J8bdCQAAAD0QKyUAmjTb55fqeeWbtX1Z0zUkWOLgo4DAACAHoqhFMBHPL1os377/Ep9duowXXTkyKDjAAAAoAdjKAXwIcs279TVf31XB48o0A/O4cBGAAAA6FoMpQA+ULGrUZfeP199omHdecGh6hXmwEYAAADoWhzoCIAkqSme0BUPvq1t1Q165LIjNCA/GnQkAAAAZABWSgFIkn705DK9UbJdP/mfyZoyvCDoOAAAAMgQDKUA9Jd563Xv62v1xaNH6VOHDgs6DgAAADIIQymQ4d5aV6Hr/r5Yx4wr0jWn7R90HAAAAGQYhlIgg22uqtNlD7ytIQU5+t3MgxXO4ikBAAAA3YsDHQEZqr4prsseeEt1jTH9+dLpKsiNBB0JAAAAGYihFMhAzjl957FFWlhapdkXHqrxA/sEHQkAAAAZiqEUyEB3/2eNHn9no75x8nidcsCgoOMASBWxhFRRF3SKlGUdqC30rAslXAe6Zohsv7JE2P87moj61SZcB3p61sbi/m/N2Rbz61nZ4H8/I/V+eSN1/j2jNX610WrvlopW+/WM1Pk/J4Tifj3zKjry7Jcc3kAGZJhXVpTpx08t02kHDtKVx48NOg4AAAAyHEMpkEFKymp05Z/f1viBffSLz3xMoVDX/+ULAAAA2BuGUiBDbK9p0OfvnafsrJDu+txU9e7F3vsAAAAIHq9KgQxQ3xTXF++fry1V9Xpo1uEaXpgbdCQAAABAEkMp0OMlEk5f/8sCLdhQqdvOO0SHjOgXdCQAAADgA+y+C/RwP3l6mZ5evEXfPX2iTps8OOg4AAAAwIcwlAI92P1vrNVdr67RRUfsp0uOHhV0HAAAAOAjGEqBHur5ZVt145wlOmniAN3wiQNkxpF2AQAAkHoYSoEeaFFpla788zs6YEhf/Xbmwcri1C8AAABIUQylQA9TuqNWX7hvngp7R3T3xVOVG+F4ZgAAAEhdvFoFepCquiZ9/o/zVN8U14NfnK4BfaJBRwIAAAD2ipVSoIdojCX05T+9pbXbd+nOCw7V+IF9go4EAAAA7BMrpUAP4JzTNY8t1Ourt+uXn/mYjhxbFHQkAAAAICkMpUAPcMvzK/XY2xv19ZPG61OHDgs6DoB0FXdSVX339+xuAfS0eMKrrqCTc/RECc+jyyfC/jsMJsKePaP+Bx6MJfzyxuL+9zMW88u7pcG/Z6TerzZS7//YRnf51UZrsvx71nRvnSRF6vzqcqu6/oCZ7L4LpLm/vVWq3/x7pT51yDB99cSxQccBAAAA2oWhFEhjr60q1zWPLtSRY/rrJ5+czLlIAQAAkHYYSoE0tWJrtb70p7c0uri3br/gUEU6sBsSAAAAEBRexQJpaFNlnT7/x3mKZmfpnosPU9+c7KAjAQAAAF4YSoE0s72mQRfc/aZ21jXpjxcfpmH9coOOBAAAAHjj6LtAGtlZ36SL/vhfbdxRpwcuma4Dh/YNOhIAAADQIayUAmmivimuL943X+9trtYdFxyqaaMKg44EAAAAdBgrpUAaaIondPmDb2ve2grdcu7BOn7/AUFHAgAAADoFK6VAiosnnK5+5F298N42/fCcA3XWx4YEHQkAAADoNAylQApzzumGJxZrzrub9K1TJ+j86fsFHQkAAADoVAylQAr7+bPL9eCb63XZcaN1+YyxQccBAAAAOh1DKZCi7nx5tW57abVmThuha07dP+g4AAAAQJdgKAVS0EP/Xa+fPP2ezjxosH54zoEys6AjAQAAAF2CoRRIMf9cuEnXPr5IMyYU61efnaKsEAMpAAAAei5OCQOkkJeWb9PX/7JAU/frp9vPP1SRMH83AtCN4gmpsj7oFF0vngg6QdI68mfJAs+6RAB/DE10YI8g79qod0slwn49Yx34fz2W41cbS/g/to1Nfj0bG/3vZ6VnbbTWv2fuTr/a3Cr/xza30vOxzfHvGanzq8ut7PrnBF7xAili/toKfelPb2ncgD76w0WHKSeSFXQkAAAAoMsxlAIpYMmmKn3+3nka0jdH918yTX1zsoOOBAAAAHQLhlIgYCVlNbronv+qT6+wHvjidBXl9Qo6EgAAANBtGEqBAK0p36WZd82Vc9IDX5yuoQU5QUcCAAAAuhUHOgICsrqsRjNnz1U84fTnSw/XmOK8oCMBAAAA3Y6hFAjAqm01Ou+uuUo4p4dmHa7xA/sEHQkAAAAIBEMp0M1WbavWzLvelHPSQ5cernEMpAAAAMhgDKVAN1q5tXkglaSHZ03X2AEMpAAAAMhsHOgI6CYrtlZr5l1zZSY9POtwBlIAAABADKVAt1i+pVozZ89VyKxlIOWgRgAAAIDEUAp0ufe27NTMu+YqnNU8kHKUXQAAAOD/MJQCXWjppp2aOXuuIlkhPTzrCI1mIAUAAAA+JKmh1MxONbPlZrbKzK5p4/pvmNlSM1toZs+b2X6dHxVIL0s2Ven8P8xVNDtLD886XKOKegcdCQAAAEg5+zz6rpllSbpV0smSSiXNM7M5zrmlrTZ7R9JU51ytmX1Z0s8k/W9XBAbSweKNVbrg7jeVm52lh2Ydrv36M5ACSAMJJ9U0dm/PmOvefhnEsvx2iCvs5BzJSISs+3ua/w6DMc/amOf3RJIS2X6PUSzHv2djLMuvrsmvTpIaG/3yVtb638/car/a3Cr/nnkFfnW5Vd4tlVvl93wbrfHvmaxkHslpklY550qcc42SHpZ0dusNnHMvOudqW76cK2lY58YE0sfijVU6/w9vqnckrIdnHcFACgAAAOxFMkPpUEkbWn1d2nLZnlwi6emOhALS1aLSKp1311zl9Qrr4VmHa0T/3KAjAQAAACltn7vvSmprX4E2137N7AJJUyUdt4frZ0maJUkjRoxIMiKQHt5ev0MX3/Nf5edk66FLD9fwQgZSAAAAYF+SWSktlTS81dfDJG3afSMzO0nSdyWd5ZxraOuGnHOznXNTnXNTi4uLffICKenF5dt03l1zVdg7oodnMZACSA1mttbMFpnZAjObH3QeAADaksxK6TxJ48xslKSNks6VdF7rDczsYEl3SjrVObet01MCKezxd0r1//66UBMG9dG9n5+m4j69go4EAK0d75wrDzoEAAB7ss+h1DkXM7MrJT0rKUvSPc65JWZ2k6T5zrk5kn4uKU/SX81MktY7587qwtxASvjDqyX64ZPLdMTo/pr9uUPVJ5oddCQAAAAgrSSzUirn3FOSntrtshtafX5SJ+cCUppzTj97drluf2m1TjtwkH79v1MUzfY//DkAdBEn6V9m5iTd6ZybHXQgAAB2l9RQCuD/xOIJXfv4Ij0yv1TnTR+hH5x9oLICOL8aACThKOfcJjMbIOk5M3vPOfdK6w0+dBDCLJ7LAADdz/+Mr0AGqm+K68sPvq1H5pfqqyeO04/OYSAFkLqcc5taPm6T9Liazz2++zb/dxBCns8AAAFgKAWSVFXXpM/d/V/9e9lWff+sA/SNk8er5T3UAJByzKy3mfV5/3NJp0haHGwqAAA+it13gSRs21mvz93zX60uq9Fvzz1Y/7+9O4+uu6zzOP755iZp0iVJQ9Il6V66KHQ1tliUHUQHLChVEEc66IBHUFCcI8OcEYYZZkRAxRlGB6VakGVY2+ogyyDHgmAhXaAbtKWkIQtt0zZJ0yw3995n/sgtky5Z+GV57vJ+ncPJzU1+/X3vl6dpPr/7/J7nwjklvksCgJ6MlvRU/OJZpqSHnHPP+C0JAIBjEUqBHlTUHdJfL1ujfU1hLVv6cX1qGnvsAkh8zrmdkub4rgMAgJ4QSoFubKpu0NJfv6aYkx7+21M0Z3yB75IAAACAlEIoBbrwyjt1uur+tcrPzdL9X1ugqcXDfZcEAAAApBxCKXAcf9hYq+se2aBJRUN1/5ULNSY/x3dJADDwYk5qbvddxcCLxnxXkND6soRfQSjYGpqxjMFfezMSCr6/eCzgQoexIcG7GwnY23B28NcZHhbs2HAk+P/P1nCwc9Y0B3+d9U3Bjh3aGPx1Dj8QbCwM3xf8dUaygx2X3Rz4lL1GKAU6cc7pv1bv1O3PvKX5E0bqvivKVDA04N9gAAAAAD0ilAJxbZGo/v7JjXpyXbUunFOiOy6ZrZys4FejAAAAAPSMUApIqmtq09UPrNXaXQf03XOn61tnncgepAAAAMAgIJQi7W2tbdTXl5dr36E2/efl8/XZWWN9lwQAAACkDUIp0trzW3brukfWKy8nS49dvUizxuX7LgkAAABIK4RSpKXOCxrNLs3XvV8t0+g8VtgFAAAABhuhFGmn84JGF8weqzuXzGFBIwAAAMATQinSSl1Tm77xwFqV7zqg75wzXd8+mwWNAAAAAJ8IpUgbnRc0uufL8/VXs1nQCAAAAPCNUIq08L/xBY2G52SyoBEAAACQQAilSGmdFzSaVZqvX7KgEQAAAJBQCKVIWYfaIrrpqY1auaFGF8weqzsumaPcbBY0AgAAABIJoRQp6e33D+qbD67Vu3WH9L3zpuuaM1nQCAAAAEhEhFKknEfL39MPVm7SiJws/fbrC7VoapHvkgAgOcScFI76riJxhTKS65yhwb8YG3Q+UmG/VtE7sYzgvY0FvNAd6cM5Ixasu305ZzjgDLPWYcEjRms42LGtrcFfZ31TsNc5vD74OfPqgp2zucAFPmc4N9i4zW4JfMpeI5QiZTSHI/rHFZv1xLoqLZp6gu6+dJ6KRwzxXRYAAACAbhBKkRK27z6obz64Tjv2Num6s6fp22dPUyiD6boAAABAoiOUIuk9ua5K//DUJg0bEtIDVy7UJ6cxXRcAAABIFoRSJK3W9qhuXrlZ/13+nhZOLtTPLpvHdi8AAABAkiGUIim9s7dJ1zy4Tm+9f1DXnnmirj9nmjJ9LEABAAAAoE8IpUg6KzdU66YnN2pIVkjLr1yg06cX+y4JAAAAQECEUiSN1vaobv39Fj20plIfnzRSP7tsnsbm5/ouCwAAAEAfEEqRFHbsOYLhfiAAABDUSURBVKhvP7xBW2ob9Y3Tp+qG86Yri+m6AAAAQNIjlCKhRWNO9728U3c+t03DskNatrRMZ80c7bssAAAAAP2EUIqE9W7dIX3vsTe0dtcBffqk0fqXi2apeMQQ32UBAAAA6EeEUiScWMxp+asVuv2ZtzQkM6SffmmuFs8tkZn5Lg0AAABAPyOUIqFU7mvW3z3+hta8u19nzRylf/v8LPYeBQAAAFIYoRQJwTmnB9dU6l+f3qqQmX50yWwt+dg43h0FAAAAUhyhFN5V17fo+4+/qZd31OlT04p0+xdmq6SArV4AAACAdEAohTfOOT1WXqV//v0WRZ3TbRefrC8vmMC7owDgi5MUjvquAsksI9i/4aGAx0lSQcBjI5mhwOeMBNyWLhLqwzkt2LHh7ODnDGcGiwrh3ODnbI0EO7a5NXisaSoMdmzjgeDnbCwK9rO2YHfwLRHDQ4P9XRnaEPiUvUYohRe7G1t14xNv6sW39+qUKYW645I5Gl841HdZAAAAAAYZoRSDyjmnJ9dV659+t1nhaEy3XPhRffUTk5TRhyukAAAAAJIXoRSDZmtto25euVmvVezXxyaO1J1L5mhy0TDfZQEAAADwiFCKAdfQ0q6fPL9ND/xll/JyMvXDz8/SF8vG8+4oAAAAAEIpBk4s5vT4uird/oe3dKA5rMsXTtQN501XwdBs36UBAAAASBCEUgyIjVUN+sGqTVpfWa/5Ewq0/MoFOrk033dZAAAAABIMoRT96sChsO587m099FqlThg2RHctmaOL55UyVRcAAADAcRFK0S+iMadHXq/UHc++rYOtES1dNEnfOXe68nKyfJcGAAAAIIERStFn6yoP6OaVm7WxukELJhfq1sUnaeaYPN9lAQAAAEgChFIEtvdgm+549i09Wl6l0XlDdPelc/W5OSUyY6ouAAAAgN4hlOJDq28O697VO/XrP1eoPRrT1adN0bfOnqbhQxhOAAAAAD4cUgR67WBru5a9XKFfvbRTTeGILpxdouvPmaYpxcN9lwYAAAAgSRFK0aPmcET3v7pLv/jTO6pvbtenTxqt7547QzPGjPBdGgAAAIAkRyhFl1rbo3r4tUrd8+I7qmtq0xkzinXDuTM0axz7jQJAyoq6D39MONr/daSaTA/rLYTSY42HrFBGoOMKM4IdJ0mxgFvdxSz4OSMZoYDHBT9nOCtYVGjNDB4xWocGO7Y5L/g5m1uD9XZvQ/BdJvL2BztnU2Gw4ySpdXiwsZARHfifJYRSHKM9GtNj5VX69z9uV21Dq06ZUqhffGW+yiYV+i4NAAAAQIohlOID0ZjTivXVuvuF7arc36x5Ewp015I5WnRike/SAAAAAKQoQikUjTn9YVOtfvL8Nr2z95BOKsnTr5d+XGfMKGZ7FwAAAAADilCaxg62tuvR8iotf6VClfubNW3UcP388vn69EljlBHwXgkAAAAA+DAIpWlo175D+s0rFXqsvEpNbRGVTRyp758/U+efPEYhwigAAACAQUQoTRPOOb26c5+WvVyhF97arcwM0wWzS/Q3p07S7HEFvssDAAAAkKYIpSmutT2qVRtqtOzP7+qt9w+qcFi2rj3zRH3llIkanZfjuzwAAAAAaY5QmqL2NLbqt3/ZpQfXVGrfobBmjhmhH31htj43t0Q5WcH3NwIAAACA/kQoTSHOOb1R1aD7X6nQ796sUSTmdPbM0bry1En6xNQTWEkXAAAAQMIhlKaAXfsOaeWGGq1YX62ddYc0LDukyxdO1NJFkzSpaJjv8gAAAACgS4TSJLWvqU3/s7FWK9ZXa11lvSRp4eRCXXXaFH129ljl5WR5rhAAAAAAekYoTSIt4aie2/K+Vm6o0eptexWJOc0cM0I3fmamPjenRCUFub5LBAAAAIAPhVCa4CLRmF55Z59WrK/Ws5vf16FwVGPzc/S1T03WRXNL9ZGxeb5LBAAAAIDACKUJqD0a0/rKej2z6X2teqNGdU1tGpGTqQvnlOiieaVaMKlQGRksWgQAAAAg+RFKE8R7+5v1p217tXrbXr36zj4dbIsoO5Shs2aO0kXzSnTGjFFs5QIASExRF/zYcLT/6oB/oYAXzUMZfThnsGOH9OECf2HAYyOh4L/LRQK+zkhG8N6GLVhUCGcGf52tWcHO2Tw8+HoqzW3Bjm08Ifg5GwuDvc6mkbHA52wuCPqzeuDfDCOUetIcjugvO/dp9bY6rd62VzvrDkmSSgtydcGcEp0+vUiLTixiwSIAAAAAKY1QOkicc9pae1Crt3e8G1pecUDhaEw5WRk6ZcoJ+sopE3X6jGJNKRrGfqIAAAAA0gahdIC0tke1pbZRm6sbtP69er20vU57D7ZJkmaOGaGlp07SadOKVTZpJNNyAQADwszOl3S3pJCkXznnfui5JAAAjkEo7Qct4ai21DZoU3WjNlY3aFN1g7bvaVI01jFvu3BYthZNPUGnTS/WadOKNSY/x3PFAIBUZ2YhSfdIOldSlaTXzWyVc26L38oAADhSr0JpT1dazWyIpPslfUzSPklfcs5V9G+pieFQW0Rbahu1sapBm2o6AuiOPU2K508VDc/WyaX5Oucjo3Vyab5mjctXSX4OU3IBAINtgaQdzrmdkmRmj0haLIlQCgBIKD2G0l5eaf2apAPOuRPN7FJJt0v60kAUPNDaIlHV1reqpr5FVfUtqqlvUfWBFtU0dHzctb9ZLh5Ai0cM0azSfJ1/0pgPAuiYPAIoACAhlEp6r9PnVZIWeqoFAIAu9ead0t5caV0s6Zb448cl/YeZmXOuD2vE951zTm2RmJrDUbW0R9USjqq1veNxfXO7qg80q6ahVdUHWlRd3/Hf4fs+Oxs1YohKR+bqpNJ8LZ5bqlnxADo6j2m4AICEdbwrpMf8u2xmV0m6SpImDHRFAAAcR29CaW+utH7wPc65iJk1SDpBUl1/FNmVt98/qNue3qrWcFTN7ZF46Ix9EEBb2nve+yw7M0OlBbkqLcjVmTOKVVowVCUFOSod2fHcmPwcDenDXksAAHhSJWl8p8/HSao5+pucc/dKuleSysy8XkwGAKSn3oTS3lxp/fBXYyf0/Xqsk1NjS7tys0IaNSJHuVkh5WSFlJudoaHZmR2Ps0LKzcpQbnbH14ZmZyo3K6QROZkqKchV0fBsptsCAFLR65KmmdlkSdWSLpX0Zb8lAQBwrN6E0t5caT38PVVmlikpX9L+o/+gI67GlpX1+WrszDF5WnHNqX39YwAASDnxmUvXSnpWHQsVLnPObfZcFgAAx+hNKO3NldZVkq6Q9KqkSyT90ff9pAAApDvn3NOSnvZdBwAA3ekxlHZ1pdXMbpVU7pxbJek+SQ+Y2Q51vEN66UAWDQAAAABIDb3ap/R4V1qdcz/o9LhV0pL+LQ0AAAAAkOp6FUoBAEDqWyvVmbSriy8XaSBW1Y8GvNunJRL8nEGPbTh227ijDEyPUgf96Rk96l7K9Kcp4HF7e/6WLnu0JuA5+2hib76JUAoAACRJzrnirr5mZuXOubLBrCfZ0KPu0Z+e0aPu0Z+eJWuPMnwXAAAAAABIX4RSAAAAAIA3hFIAANAb9/ouIAnQo+7Rn57Ro+7Rn54lZY/M13aiZWVlrry83Mu5AQCpx8zWJuN9NAAApDveKQUAAAAAeEMoBQAAAAB4QygFAADdMrPzzextM9thZjf6rifRmFmFmW00sw1mxr1JksxsmZntMbNNnZ4rNLPnzWx7/ONInzX61EV/bjGz6vg42mBmn/VZo29mNt7MXjSzrWa22cyuiz/POFK3/UnKcUQoBQAAXTKzkKR7JH1G0kclXWZmH/VbVUI60zk3l/uaP/AbSecf9dyNkl5wzk2T9EL883T1Gx3bH0n6SXwczXXOPT3INSWaiKQbnHMfkXSKpGviP3sYRx266o+UhOOIUAoAALqzQNIO59xO51xY0iOSFnuuCQnOObda0v6jnl4saXn88XJJFw1qUQmki/6gE+dcrXNuXfzxQUlbJZWKcSSp2/4kJUIpAADoTqmk9zp9XqUk/sVngDhJz5nZWjO7yncxCWy0c65W6viFWtIoz/UkomvN7M349N60nJZ6PGY2SdI8SWvEODrGUf2RknAcEUoBAEB37DjP+dlPLnGd6pybr44pzteY2Wm+C0JS+rmkqZLmSqqVdJffchKDmQ2X9ISk651zjb7rSTTH6U9SjiNCKQAA6E6VpPGdPh8nqcZTLQnJOVcT/7hH0lPqmPKMY+02s7GSFP+4x3M9CcU5t9s5F3XOxST9UowjmVmWOgLXg865J+NPM47ijtefZB1HhFIAANCd1yVNM7PJZpYt6VJJqzzXlDDMbJiZjTj8WNJ5kjZ1f1TaWiXpivjjKySt9FhLwjkctOIuVpqPIzMzSfdJ2uqc+3GnLzGO1HV/knUcmXN+ZuCY2V5Ju/rpjyuSVNdPf1YqoB9Hoh9Hoh/HoidHStZ+THTOFfsuIhXFtxT4qaSQpGXOuds8l5QwzGyKOt4dlaRMSQ/RH8nMHpZ0hjp+nuyWdLOkFZIelTRBUqWkJc65tFzsp4v+nKGOKZdOUoWkqw/fO5mOzOyTkl6StFFSLP70Teq4bzLtx1E3/blMSTiOvIXS/mRm5SzB/v/ox5Hox5Hox7HoyZHoBwAAGExM3wUAAAAAeEMoBQAAAAB4kyqh9F7fBSQY+nEk+nEk+nEsenIk+gEAAAZNStxTCgAAAABITqnyTikAAAAAIAkldSg1s/PN7G0z22FmN/quxzczqzCzjWa2wczKfdfjg5ktM7M9Zrap03OFZva8mW2Pfxzps8bB1EU/bjGz6vg42RDf6iEtmNl4M3vRzLaa2WYzuy7+fFqOkW76kbZjBAAADL6knb5rZiFJ2ySdK6lKHZt7X+ac2+K1MI/MrEJSmXMuGfcX7BdmdpqkJkn3O+dOjj/3I0n7nXM/jF+8GOmc+77POgdLF/24RVKTc+5On7X5EN9Qeqxzbl18s/u1ki6StFRpOEa66ccXlaZjBAAADL5kfqd0gaQdzrmdzrmwpEckLfZcEzxzzq2WdPQGyoslLY8/Xq6OX7rTQhf9SFvOuVrn3Lr444OStkoqVZqOkW76AQAAMGiSOZSWSnqv0+dV4pcpJ+k5M1trZlf5LiaBjHbO1Uodv4RLGuW5nkRwrZm9GZ/emxZTVY9mZpMkzZO0RoyRo/shMUYAAMAgSeZQasd5LjnnIvefU51z8yV9RtI18ambwNF+LmmqpLmSaiXd5becwWdmwyU9Iel651yj73p8O04/0n6MAACAwZPMobRK0vhOn4+TVOOploTgnKuJf9wj6Sl1THGGtDt+79zhe+j2eK7HK+fcbudc1DkXk/RLpdk4MbMsdQSwB51zT8afTtsxcrx+pPsYAQAAgyuZQ+nrkqaZ2WQzy5Z0qaRVnmvyxsyGxRcqkZkNk3SepE3dH5U2Vkm6Iv74CkkrPdbi3eHwFXex0micmJlJuk/SVufcjzt9KS3HSFf9SOcxAgAABl/Srr4rSfFtCn4qKSRpmXPuNs8leWNmU9Tx7qgkZUp6KB37YWYPSzpDUpGk3ZJulrRC0qOSJkiqlLTEOZcWi/900Y8z1DEt00mqkHT14fspU52ZfVLSS5I2SorFn75JHfdRpt0Y6aYflylNxwgAABh8SR1KAQAAAADJLZmn7wIAAAAAkhyhFAAAAADgDaEUAAAAAOANoRQAAAAA4A2hFAAAAADgDaEUAAAAAOANoRQAAAAA4A2hFAAAAADgzf8B2aG86M4GVOYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show the results for the first time series\n",
    "plt.figure(figsize=(16, 8))\n",
    "plt.subplot(121)\n",
    "plt.plot(X)\n",
    "plt.title(\"Original\", fontsize=16)\n",
    "plt.subplot(122)\n",
    "plt.imshow(g, cmap='rainbow', origin='lower')\n",
    "plt.title(\"GAF\", fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Date         2014-01-08    2014-01-09    2014-01-12    2014-01-13  \\\n",
      "Open       5.316000e+03  5.324400e+03  5.312400e+03  5.292100e+03   \n",
      "High       5.324400e+03  5.324400e+03  5.318000e+03  5.292100e+03   \n",
      "Low        5.295400e+03  5.306300e+03  5.288100e+03  5.207500e+03   \n",
      "Close      5.324400e+03  5.312400e+03  5.292100e+03  5.212000e+03   \n",
      "Adj Close  5.324400e+03  5.312400e+03  5.292100e+03  5.212000e+03   \n",
      "Volume     4.591164e+08  4.708812e+08  3.945188e+08  6.046564e+08   \n",
      "\n",
      "Date         2014-01-14  \n",
      "Open       5.212000e+03  \n",
      "High       5.256100e+03  \n",
      "Low        5.212000e+03  \n",
      "Close      5.245400e+03  \n",
      "Adj Close  5.245400e+03  \n",
      "Volume     5.360873e+08  \n"
     ]
    }
   ],
   "source": [
    "xjo = pd.read_csv('./data/axjo.csv', parse_dates=['Date'], index_col=[0])\n",
    "print(xjo.head().T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Date\n",
      "2014-01-08    1\n",
      "2014-01-09    0\n",
      "2014-01-12    0\n",
      "2014-01-13    0\n",
      "2014-01-14    2\n",
      "2014-01-15    2\n",
      "2014-01-16    0\n",
      "2014-01-19    2\n",
      "2014-01-20    1\n",
      "2014-01-21    0\n",
      "Name: Value, dtype: int32 Date\n",
      "2014-01-08    5309.899902\n",
      "2014-01-09    5315.349853\n",
      "2014-01-12    5303.050049\n",
      "2014-01-13    5249.800049\n",
      "2014-01-14    5234.050049\n",
      "2014-01-15    5277.250000\n",
      "2014-01-16    5301.599853\n",
      "2014-01-19    5283.149902\n",
      "2014-01-20    5303.800049\n",
      "2014-01-21    5308.449951\n",
      "Name: Value, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "xjo['Value'] = (xjo['High']+xjo['Low'])/2.0\n",
    "y = xjo['Value']\n",
    "ahead = y.shift(-1)\n",
    "new_y = 100.0*(ahead/y-1)\n",
    "y = pd.qcut(new_y, 3,labels=False).dropna().astype('int')\n",
    "print(y.head(10), xjo['Value'].head(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[WindowsPath('data/AXJO.csv'), WindowsPath('data/Bearish'), WindowsPath('data/Bullish'), WindowsPath('data/models'), WindowsPath('data/Neutral')]\n"
     ]
    }
   ],
   "source": [
    "path = Path('./data')\n",
    "print(path.ls())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\workspace\\continuum\\anaconda3\\envs\\py36\\lib\\site-packages\\numpy\\core\\fromnumeric.py:83: RuntimeWarning: invalid value encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "c:\\workspace\\continuum\\anaconda3\\envs\\py36\\lib\\site-packages\\ipykernel_launcher.py:23: RuntimeWarning: invalid value encountered in greater_equal\n",
      "c:\\workspace\\continuum\\anaconda3\\envs\\py36\\lib\\site-packages\\ipykernel_launcher.py:24: RuntimeWarning: invalid value encountered in less_equal\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "for i in range(n_samples, len(y)):\n",
    "    index = y.index[i]\n",
    "    start = y.index[i-n_samples]\n",
    "    series = xjo[start:index].Value[:n_samples]\n",
    "    img, _,_,_  = gaf(series.values)\n",
    "    img = (1+img)*255/2.0\n",
    "    img = img.astype('int').reshape(n_samples, n_samples, 1)\n",
    "    \n",
    "    \n",
    "  \n",
    "    if y[index] == 0:\n",
    "        file = f'./data/Bearish/{index.date()}.png'\n",
    "        #print(f'Write bearish to : {file}')\n",
    "        cv2.imwrite(file, img)\n",
    "    elif y[index] == 1:\n",
    "        file = f'./data/Neutral/{index.date()}.png'\n",
    "        #print(f'Write neutral to : {file}')\n",
    "        cv2.imwrite(file, img)\n",
    "    else:\n",
    "        file = f'./data/Bullish/{index.date()}.png'\n",
    "        #print(f'Write bullish to : {file}')\n",
    "        cv2.imwrite(file, img)\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "il = ImageItemList.from_folder(path, convert_mode='L')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "WindowsPath('data/Bearish/2014-02-25.png')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "il.items[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "defaults.cmap='binary'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ImageItemList (1233 items)\n",
       "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n",
       "Path: data"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "il"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "il[0].show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "sd = il.random_split_by_pct(valid_pct = 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ItemLists;\n",
       "\n",
       "Train: ImageItemList (987 items)\n",
       "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n",
       "Path: data;\n",
       "\n",
       "Valid: ImageItemList (246 items)\n",
       "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n",
       "Path: data;\n",
       "\n",
       "Test: None"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll = sd.label_from_folder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LabelLists;\n",
       "\n",
       "Train: LabelList\n",
       "y: CategoryList (987 items)\n",
       "[Category Bearish, Category Bearish, Category Bearish, Category Bearish, Category Bearish]...\n",
       "Path: data\n",
       "x: ImageItemList (987 items)\n",
       "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n",
       "Path: data;\n",
       "\n",
       "Valid: LabelList\n",
       "y: CategoryList (246 items)\n",
       "[Category Neutral, Category Bullish, Category Neutral, Category Bearish, Category Bullish]...\n",
       "Path: data\n",
       "x: ImageItemList (246 items)\n",
       "[Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28), Image (1, 28, 28)]...\n",
       "Path: data;\n",
       "\n",
       "Test: None"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = ll.train[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bearish torch.Size([1, 28, 28])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x.show()\n",
    "print(y,x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not using imagenet_stats because not using pretrained model\n",
    "data = ll.databunch(bs=bs).normalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = data.train_ds[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bearish\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x.show()\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def _plot(i,j,ax): data.train_ds[0][0].show(ax, cmap='gray')\n",
    "plot_multi(_plot, 3, 3, figsize=(8,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([128, 1, 28, 28]), torch.Size([128]))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xb,yb = data.one_batch()\n",
    "xb.shape,yb.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.show_batch(rows=3, figsize=(5,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic CNN with batchnorm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv(ni,nf): return nn.Conv2d(ni, nf, kernel_size=3, stride=2, padding=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = nn.Sequential(\n",
    "    conv(1, 8), # 14\n",
    "    nn.BatchNorm2d(8),\n",
    "    nn.ReLU(),\n",
    "    conv(8, 16), # 7\n",
    "    nn.BatchNorm2d(16),\n",
    "    nn.ReLU(),\n",
    "    conv(16, 32), # 4\n",
    "    nn.BatchNorm2d(32),\n",
    "    nn.ReLU(),\n",
    "    conv(32, 16), # 2\n",
    "    nn.BatchNorm2d(16),\n",
    "    nn.ReLU(),\n",
    "    conv(16, n_classes), # 1\n",
    "    nn.BatchNorm2d(n_classes),\n",
    "    Flatten()     # remove (1,1) grid\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = Learner(data, model, loss_func = nn.CrossEntropyLoss(), metrics=accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======================================================================\n",
      "Layer (type)         Output Shape         Param #    Trainable \n",
      "======================================================================\n",
      "Conv2d               [128, 8, 14, 14]     80         True      \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 8, 14, 14]     16         True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 8, 14, 14]     0          False     \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 16, 7, 7]      1168       True      \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 16, 7, 7]      32         True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 16, 7, 7]      0          False     \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 32, 4, 4]      4640       True      \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 32, 4, 4]      64         True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 32, 4, 4]      0          False     \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 16, 2, 2]      4624       True      \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 16, 2, 2]      32         True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 16, 2, 2]      0          False     \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 3, 1, 1]       435        True      \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 3, 1, 1]       6          True      \n",
      "______________________________________________________________________\n",
      "Lambda               [128, 3]             0          False     \n",
      "______________________________________________________________________\n",
      "\n",
      "Total params:  11097\n",
      "Total trainable params:  11097\n",
      "Total non-trainable params:  0\n"
     ]
    }
   ],
   "source": [
    "learn.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "xb = xb.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([128, 3])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(xb).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='8' class='' max='15', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      53.33% [8/15 04:35<04:01]\n",
       "    </div>\n",
       "    \n",
       "<table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>1.132128</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>1.133404</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>1.130979</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>1.130567</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>1.129786</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>1.128399</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>1.124946</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>1.119788</th>\n",
       "  </tr>\n",
       "</table>\n",
       "\n",
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='0' class='' max='7', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      0.00% [0/7 00:00<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.lr_find(end_lr=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 03:36 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>1.168968</th>\n",
       "    <th>1.097522</th>\n",
       "    <th>0.345528</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>1.129363</th>\n",
       "    <th>1.093452</th>\n",
       "    <th>0.402439</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>1.101324</th>\n",
       "    <th>1.090720</th>\n",
       "    <th>0.353659</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(3, max_lr=0.03)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fit one cycle\n",
    "https://sgugger.github.io/the-1cycle-policy.html\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Refactor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv2(ni,nf): return conv_layer(ni,nf,stride=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = nn.Sequential(\n",
    "    conv2(1, 8),   # 14\n",
    "    conv2(8, 16),  # 7\n",
    "    conv2(16, 32), # 4\n",
    "    conv2(32, 16), # 2\n",
    "    conv2(16, n_classes), # 1\n",
    "    Flatten()      # remove (1,1) grid\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = Learner(data, model, loss_func = nn.CrossEntropyLoss(), metrics=accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 11:26 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>1.253398</th>\n",
       "    <th>1.104679</th>\n",
       "    <th>0.337398</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>1.165214</th>\n",
       "    <th>1.112205</th>\n",
       "    <th>0.317073</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>1.114024</th>\n",
       "    <th>1.127045</th>\n",
       "    <th>0.382114</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>1.078905</th>\n",
       "    <th>1.132521</th>\n",
       "    <th>0.341463</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>1.042105</th>\n",
       "    <th>1.217651</th>\n",
       "    <th>0.325203</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>1.001665</th>\n",
       "    <th>1.211643</th>\n",
       "    <th>0.369919</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>0.952044</th>\n",
       "    <th>1.219726</th>\n",
       "    <th>0.369919</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>0.901123</th>\n",
       "    <th>1.283984</th>\n",
       "    <th>0.333333</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>9</th>\n",
       "    <th>0.850093</th>\n",
       "    <th>1.270016</th>\n",
       "    <th>0.333333</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>10</th>\n",
       "    <th>0.808134</th>\n",
       "    <th>1.259383</th>\n",
       "    <th>0.329268</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(10, max_lr=0.03)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resnet-ish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResBlock(nn.Module):\n",
    "    def __init__(self, nf):\n",
    "        super().__init__()\n",
    "        self.conv1 = conv_layer(nf,nf)\n",
    "        self.conv2 = conv_layer(nf,nf)\n",
    "        \n",
    "    def forward(self, x): return x + self.conv2(self.conv1(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function res_block in module fastai.layers:\n",
      "\n",
      "res_block(nf, dense:bool=False, norm_type:Union[fastai.layers.NormType, NoneType]=<NormType.Batch: 1>, bottle:bool=False, **kwargs)\n",
      "    Resnet block of `nf` features.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(res_block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = nn.Sequential(\n",
    "    conv2(1, 8),\n",
    "    res_block(8),\n",
    "    conv2(8, 16),\n",
    "    res_block(16),\n",
    "    conv2(16, 32),\n",
    "    res_block(32),\n",
    "    conv2(32, 16),\n",
    "    res_block(16),\n",
    "    conv2(16, n_classes),\n",
    "    Flatten()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_and_res(ni,nf): return nn.Sequential(conv2(ni, nf), res_block(nf))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = nn.Sequential(\n",
    "    conv_and_res(1, 8),\n",
    "    conv_and_res(8, 16),\n",
    "    conv_and_res(16, 32),\n",
    "    conv_and_res(32, 16),\n",
    "    conv2(16, n_classes),\n",
    "    Flatten()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = Learner(data, model, loss_func = nn.CrossEntropyLoss(), metrics=accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.lr_find(end_lr=0.2)\n",
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 13:59 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>accuracy</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>1.138217</th>\n",
       "    <th>1.096357</th>\n",
       "    <th>0.357724</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>1.092659</th>\n",
       "    <th>1.096493</th>\n",
       "    <th>0.349593</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>1.042000</th>\n",
       "    <th>1.096244</th>\n",
       "    <th>0.390244</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.996576</th>\n",
       "    <th>1.103899</th>\n",
       "    <th>0.369919</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>0.951297</th>\n",
       "    <th>1.133930</th>\n",
       "    <th>0.325203</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>0.911662</th>\n",
       "    <th>1.154461</th>\n",
       "    <th>0.321138</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>0.870015</th>\n",
       "    <th>1.159694</th>\n",
       "    <th>0.341463</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>0.829943</th>\n",
       "    <th>1.171255</th>\n",
       "    <th>0.321138</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>9</th>\n",
       "    <th>0.792723</th>\n",
       "    <th>1.184213</th>\n",
       "    <th>0.300813</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>10</th>\n",
       "    <th>0.759569</th>\n",
       "    <th>1.187976</th>\n",
       "    <th>0.292683</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>11</th>\n",
       "    <th>0.730892</th>\n",
       "    <th>1.188908</th>\n",
       "    <th>0.292683</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>12</th>\n",
       "    <th>0.707262</th>\n",
       "    <th>1.189016</th>\n",
       "    <th>0.292683</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(12, max_lr=0.005)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======================================================================\n",
      "Layer (type)         Output Shape         Param #    Trainable \n",
      "======================================================================\n",
      "Conv2d               [128, 8, 14, 14]     72         True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 8, 14, 14]     0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 8, 14, 14]     16         True      \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 8, 14, 14]     576        True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 8, 14, 14]     0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 8, 14, 14]     16         True      \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 8, 14, 14]     576        True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 8, 14, 14]     0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 8, 14, 14]     16         True      \n",
      "______________________________________________________________________\n",
      "MergeLayer           [128, 8, 14, 14]     0          False     \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 16, 7, 7]      1152       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 16, 7, 7]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 16, 7, 7]      32         True      \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 16, 7, 7]      2304       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 16, 7, 7]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 16, 7, 7]      32         True      \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 16, 7, 7]      2304       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 16, 7, 7]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 16, 7, 7]      32         True      \n",
      "______________________________________________________________________\n",
      "MergeLayer           [128, 16, 7, 7]      0          False     \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 32, 4, 4]      4608       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 32, 4, 4]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 32, 4, 4]      64         True      \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 32, 4, 4]      9216       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 32, 4, 4]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 32, 4, 4]      64         True      \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 32, 4, 4]      9216       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 32, 4, 4]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 32, 4, 4]      64         True      \n",
      "______________________________________________________________________\n",
      "MergeLayer           [128, 32, 4, 4]      0          False     \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 16, 2, 2]      4608       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 16, 2, 2]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 16, 2, 2]      32         True      \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 16, 2, 2]      2304       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 16, 2, 2]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 16, 2, 2]      32         True      \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 16, 2, 2]      2304       True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 16, 2, 2]      0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 16, 2, 2]      32         True      \n",
      "______________________________________________________________________\n",
      "MergeLayer           [128, 16, 2, 2]      0          False     \n",
      "______________________________________________________________________\n",
      "Conv2d               [128, 3, 1, 1]       432        True      \n",
      "______________________________________________________________________\n",
      "ReLU                 [128, 3, 1, 1]       0          False     \n",
      "______________________________________________________________________\n",
      "BatchNorm2d          [128, 3, 1, 1]       6          True      \n",
      "______________________________________________________________________\n",
      "Lambda               [128, 3]             0          False     \n",
      "______________________________________________________________________\n",
      "\n",
      "Total params:  40110\n",
      "Total trainable params:  40110\n",
      "Total non-trainable params:  0\n"
     ]
    }
   ],
   "source": [
    "learn.summary()"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}