bfarzin/Fast.ai_v1_CustomData&Model.ipynb

## Fast.ai_v1_CustomData&Model.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/farzin/anaconda3/envs/fastaiv1/lib/python3.7/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n",
      "/home/farzin/anaconda3/envs/fastaiv1/lib/python3.7/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n",
      "  return f(*args, **kwds)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "np.random.seed(12345)\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from fastai import Learner,DataBunch\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.utils.data as tdatautils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Create toy data set & dataloader objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.a Create double-XOR data set as a toy example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setting up XOR data <b>not</b> because it is interesting, but just to demonstrate what you do with NUMPY input data passed into the Learner() pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_generator(data_size=1024):\n",
    "    while 1:\n",
    "        x1 = np.random.randint(0, 2, size=data_size)\n",
    "        x2 = np.random.randint(0, 2, size=data_size)\n",
    "        x3 = np.random.randint(0, 2, size=data_size)\n",
    "        x4 = np.random.randint(0, 2, size=data_size)\n",
    "        x = np.concatenate((x1[:, None],\n",
    "                            x2[:, None],\n",
    "                            x3[:, None],\n",
    "                            x4[:,None]), axis=1).astype(float)\n",
    "        #encode y as one-hot so we can easily scale to multi-class problems.\n",
    "        y0 = (x1 != x2).astype(float)\n",
    "        y1 = (x3 != x4).astype(float)\n",
    "        y = np.concatenate((y0[:,None],y1[:,None]),axis=1).astype(float)\n",
    "        y = y.sum(axis=1) #creates classes 0,1,2\n",
    "        yield x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 1. 0.]\n",
      " [1. 0. 0. 0.]\n",
      " [1. 1. 0. 0.]\n",
      " [1. 1. 1. 0.]\n",
      " ...\n",
      " [0. 0. 0. 0.]\n",
      " [0. 1. 1. 1.]\n",
      " [0. 0. 0. 1.]\n",
      " [1. 0. 0. 0.]]\n",
      "[1. 1. 0. 1. ... 0. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "X,y = next(data_generator(data_size=1024))\n",
    "X_val,y_val = next(data_generator(data_size=512))\n",
    "X_test,y_test = next(data_generator(data_size=100))\n",
    "print(X)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.b Map the data to float/int as appropriate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classification requires that targets are type INT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_torch_data(x,np_type,tch_type):\n",
    "    return torch.from_numpy(x.astype(np_type)).to(tch_type)\n",
    "\n",
    "X,X_val,X_test = map(lambda x: to_torch_data(x,float,torch.float32),(X,X_val,X_test))\n",
    "y,y_val,y_test = map(lambda x: to_torch_data(x,int,torch.int64),(y,y_val,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = tdatautils.TensorDataset(X,y)\n",
    "valid_ds = tdatautils.TensorDataset(X_val,y_val)\n",
    "test_ds  = tdatautils.TensorDataset(X_test,y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.c Create fast.ai objects from Numpy data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "my_data_bunch = DataBunch.create(train_ds,valid_ds,test_ds,bs=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of what a single batch looks like.  As expected from the data definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([[1., 1., 1., 0.],\n",
       "         [0., 0., 1., 1.],\n",
       "         [0., 0., 0., 1.],\n",
       "         [0., 0., 1., 0.],\n",
       "         [0., 1., 1., 0.],\n",
       "         [0., 0., 0., 0.],\n",
       "         [0., 0., 0., 1.],\n",
       "         [1., 0., 0., 0.],\n",
       "         [0., 0., 1., 1.],\n",
       "         [1., 1., 1., 0.],\n",
       "         [1., 1., 0., 0.],\n",
       "         [1., 1., 0., 0.],\n",
       "         [0., 1., 1., 1.],\n",
       "         [1., 1., 0., 0.],\n",
       "         [1., 1., 0., 1.],\n",
       "         [1., 1., 1., 0.],\n",
       "         [1., 1., 1., 1.],\n",
       "         [1., 1., 0., 0.],\n",
       "         [0., 1., 0., 1.],\n",
       "         [1., 1., 1., 0.],\n",
       "         [1., 1., 1., 1.],\n",
       "         [1., 0., 1., 0.],\n",
       "         [0., 0., 0., 1.],\n",
       "         [1., 0., 0., 1.],\n",
       "         [1., 1., 1., 0.],\n",
       "         [1., 1., 1., 0.],\n",
       "         [0., 0., 0., 0.],\n",
       "         [0., 0., 1., 1.],\n",
       "         [1., 0., 0., 1.],\n",
       "         [0., 0., 1., 0.],\n",
       "         [0., 0., 1., 0.],\n",
       "         [1., 1., 1., 0.]], device='cuda:0'),\n",
       " tensor([1, 0, 1, 1, 2, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 2, 1, 0, 2, 1, 2,\n",
       "         1, 1, 0, 0, 2, 1, 1, 1], device='cuda:0')]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_data_bunch.one_batch()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Define Loss & Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.NLLLoss() # NLL + Log_softmax layer = multi-class Cross-entropy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.a nn.Sequential way to define a model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_model_params(net):\n",
    "    return sum(p.numel() for p in net.parameters() if p.requires_grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential(\n",
      "  (0): Linear(in_features=4, out_features=10, bias=True)\n",
      "  (1): ReLU()\n",
      "  (2): Linear(in_features=10, out_features=10, bias=True)\n",
      "  (3): ReLU()\n",
      "  (4): Linear(in_features=10, out_features=3, bias=True)\n",
      "  (5): LogSoftmax()\n",
      ")\n",
      "trainable params: 193\n"
     ]
    }
   ],
   "source": [
    "H = 10\n",
    "net = nn.Sequential(\n",
    "    nn.Linear(4, H),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(H, H),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(H, 3),\n",
    "    nn.LogSoftmax(dim=1)\n",
    ")#.cuda()\n",
    "print(net)\n",
    "print( 'trainable params: {}'.format(count_model_params(net)) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.b Class definition of model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (fc_0): Linear(in_features=4, out_features=10, bias=True)\n",
      "  (relu_0): ReLU()\n",
      "  (fc_1): Linear(in_features=10, out_features=10, bias=True)\n",
      "  (relu_1): ReLU()\n",
      "  (last): Linear(in_features=10, out_features=3, bias=True)\n",
      "  (log_softmax_layer): LogSoftmax()\n",
      ")\n",
      "trainable params: 193\n"
     ]
    }
   ],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, input_size=21, hidden_size=10, num_classes=10):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc_0 = nn.Linear(input_size, hidden_size) \n",
    "        self.relu_0 = nn.ReLU()\n",
    "        self.fc_1 = nn.Linear(hidden_size,hidden_size)        \n",
    "        self.relu_1 = nn.ReLU()\n",
    "        self.last = nn.Linear(hidden_size,num_classes)\n",
    "        self.log_softmax_layer = nn.LogSoftmax(dim=1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        out = self.relu_0(self.fc_0(x))\n",
    "        out = self.relu_1(self.fc_1(out))\n",
    "        out = self.log_softmax_layer(self.last(out))\n",
    "        \n",
    "        return out\n",
    "    \n",
    "#create instance of model\n",
    "net = Net(input_size=4,hidden_size=10,num_classes=3).cuda()\n",
    "print(net)  \n",
    "print( 'trainable params: {}'.format(count_model_params(net)) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Build Learner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_learner = Learner(my_data_bunch,\n",
    "                     net,\n",
    "                     opt_func=torch.optim.Adam,\n",
    "                     loss_func=criterion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### From here we can use the learner just like any other Fast.ai learner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    }
   ],
   "source": [
    "my_learner.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEKCAYAAAAB0GKPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xl8VPW9//HXJ/tCEgIJ+xJAVhVQAoK2iGgtWi32Wq222qq1tL2t1ra2t/211Xvr7b5Z761aapUualu1etViXdqCIiIEFQjKEvYAIQmBQLaZzMz398echABZBshkZsL7+XjMg5lzzsx5Z5jMJ9/z/Z7vMeccIiIiXUmKdQAREUkMKhgiIhIRFQwREYmICoaIiEREBUNERCKigiEiIhFRwRARkYioYIiISERUMEREJCIpsQ7QnQoKClxRUVGsY4iIJIzVq1dXO+cKI9m2VxWMoqIiSkpKYh1DRCRhmNmOSLfVISkREYmICoaIiEREBUNERCKigiEiIhFRwRARkYioYIiISERUMEREJCIqGCIiCaQ5GOIPK3ZQ29jc4/tWwRARSSDLyqr5zjOl3PTISup8gR7dtwqGiEgCWVdeC8Da8lo+vWgVjf5gj+1bBUNEJIGs213L6IJsfn7tFFZur2HBH0rwBXqmaKhgiIgkkNLdtZw1NI/5U4fyo6sn89rmar7w6Ns0B0NR33evmnxQRKQ3q67zsbe2ibOH5gFwbfFwfM1Blm6qIhhypCZHd/8qGCIiCWLd7nD/xVlewQC4cVYRnzhvJElJFvX965CUiEiCKPU6vM8cmnvU8p4oFqCCISKSMNbtrmVUQTa5Gakx2X/UCoaZPWxmlWZW2sH6T5jZWu+23MymtFm33czWmdk7ZqYrIomIcKTDO1ai2cJYBMzrZP024ELn3GTgHmDhMesvcs5Ndc4VRymfiEjC2F/nY09tE5NjWDCi1untnHvVzIo6Wb+8zcMVwLBoZRERSXTtdXj3tHjpw/g08EKbxw54ycxWm9mCGGUSEYkbpbvb7/DuSTEfVmtmFxEuGO9rs/gC59weMxsAvGxmG5xzr3bw/AXAAoARI0ZEPa+ISCzEusMbYtzCMLPJwEPAfOfc/pblzrk93r+VwNPAjI5ewzm30DlX7JwrLiwsjHZkEZGYWFce2w5viGHBMLMRwF+BG51zm9oszzaznJb7wKVAuyOtREROBy0d3mfH8HAURPGQlJk9DswBCsysHLgbSAVwzj0I3AX0B+43M4CANyJqIPC0tywFeMw59/do5RQRiXfx0OEN0R0ldX0X628Fbm1n+VZgyvHPEBE5PZXGScGIl1FSIiLSgXW7aynqnxXTDm9QwRARiVvOORa9vo1X3qtkelG/WMeJ/bBaERE5XlNzkO88U8oTq8u5ZOJA7rpyUqwjqWCIiMSb/XU+bvldCWt2HeT2i8dyx8Vje2xG2s6oYIiIxJk/rtjJuvKDPHjDNOadNSjWcVqpD0NEJM5s2neYEf2y4qpYgAqGiEjc2Vx5mDMG5MQ6xnFUMERE4kggGGJbdT1nDOgT6yjHUcEQEYkjO2oaaA46FQwREelcWWUdAGNVMEREpDMtBWOMCoaIiHSmrLKOIXkZ9EmPv7MeVDBEROJIWWVdXLYuQAVDRCRuhEKOsso6xsbhkFpQwRARiRt7ahtpbA7G5QgpUMEQEYkbm70ObxUMERHp1JY4HlILKhgiInGjrLKO/tlp5GenxTpKu1QwRETixObKurg9HAUqGCIiccG58AgpFQwREelUVZ2P2sbmuO2/ABUMEZG4UNY6Qio+z8EAFQwRkbjQOungQLUwRESkE2WVdeSkpzAgJz3WUTqkgiEiEgda5pAys1hH6ZAKhohIHNhcWRfXHd6ggiEiEnP763xUHfbF9ZBaUMEQEYm5l97dB8AFZxTEOEnnVDBERGLs+bV7GFWQzZlDcmMdpVMqGCIiMVRd5+ONLfv50NmD47rDG1QwRERi6oXSCkIOrpgyONZRuqSCISISQ39bu4cxhdmMHxi/Z3i3UMEQEYmRysNNvLmthismD4n7w1GggiEiEjMvrKvAObhicvwfjgIVDBGRmPnb2r2MH5jD2AQ4HAUqGCIiMVFR28SqHTV8KEFaF6CCISISE4vX7cU5VDAAzOxhM6s0s9IO1n/CzNZ6t+VmNqXNunlmttHMyszsG9HKKCISK6+XVTOmMJsxhfE9HUhb0WxhLALmdbJ+G3Chc24ycA+wEMDMkoFfAZcBk4DrzWxSFHOKiPS4en+A/tnxO5V5e6JWMJxzrwI1naxf7pw74D1cAQzz7s8AypxzW51zfuBPwPxo5RQRiQV/IERaSmL1CsRL2k8DL3j3hwK72qwr95aJiPQa/mDiFYyUWAcws4sIF4z3tSxqZzPXyfMXAAsARowY0e35RESiwdccIj3BCkZM05rZZOAhYL5zbr+3uBwY3mazYcCejl7DObfQOVfsnCsuLCyMXlgRkW6UiC2MmKU1sxHAX4EbnXOb2qxaBYw1s1FmlgZcBzwbi4wiItHiD4RIS06sghG1Q1Jm9jgwBygws3LgbiAVwDn3IHAX0B+435tDJeC1FAJm9kXgRSAZeNg5tz5aOUVEYsEXCJGeqoIBgHPu+i7W3wrc2sG6xcDiaOQSEYkH4RZGcqxjnJDEKm8iIr2EhtWKiEiXnHP4gxolJSIiXfAFQgBqYYiISOf8wXDBUAtDREQ65Q+oYIiISAR0SEpERCLiV8EQEZFItBYMnYchIiKd8QWCgPowRESkCzokJSIiEVHBEBGRiPg0rFZERCKhYbUiIhIRnektIiIROXKmt4bViohIJ1qG1eqQlIiIdOrIiXuJ9RWcWGlFRHoBDasVEZGIaFitiIhExB8IkWSQokNSIiLSGX8w8a7nDSoYIiI9ztccTLghtaCCISLS49TCEBGRiPgCoYQbUgsqGCIiPc4XCJGemnhfv4mXWEQkwfnVwhARkUj4A6GEOwcDIiwYZjbGzNK9+3PM7HYz6xvdaCIivVO4YPTeUVJPAUEzOwP4LTAKeCxqqUREejFfINirR0mFnHMB4CPAvc65LwODoxdLRKT36u3DapvN7HrgU8Dz3rLU6EQSEendenun983ALOB7zrltZjYK+GP0YomI9F6JOqw2JZKNnHPvArcDmFk+kOOc+2E0g4mI9Fa9uoVhZkvMLNfM+gFrgEfM7OfRjSYi0jv5A727DyPPOXcI+DfgEefcNOCS6MUSEem9fL18WG2KmQ0GruVIp7eIiJyE3t7C+C7wIrDFObfKzEYDm6MXS0Skd3LO9e5htc65J5xzk51zn/ceb3XOXd3Zc8zsYTOrNLPSDtZPMLM3zMxnZnces267ma0zs3fMrCTSH0ZEJN4l6uVZIfJO72Fm9rRXAPaZ2VNmNqyLpy0C5nWyvobwyKufdrD+IufcVOdccSQZRUQSgT/YywsG8AjwLDAEGAo85y3rkHPuVcJFoaP1lc65VUBzhBlERBKe32th9NpDUkChc+4R51zAuy0CCqOYywEvmdlqM1sQxf2IiPQof28/JAVUm9kNZpbs3W4A9kcx1wXOuXOBy4AvmNnsjjY0swVmVmJmJVVVVVGMJCJy6nynQQvjFsJDaiuAvcBHCU8XEhXOuT3ev5XA08CMTrZd6Jwrds4VFxZGs9EjInLqWg9JJffS8zCcczudcx92zhU65wY4564ifBJftzOzbDPLabkPXAq0O9JKRCTRJHIfRkRzSXXgK8C9Ha00s8eBOUCBmZUDd+PNcOuce9DMBgElQC4QMrM7gElAAfC0mbXke8w59/dTyCkiEjd8gSCQmH0Yp1IwrLOVzrnru1hfAbQ3NPcQMOUUcomIxK1EbmGcSmLXbSlERE4TvmDiFoxOWxhmdpj2C4MBmVFJJCLSi/maE3dYbacFwzmX01NBREROB6fDmd4iItINev2wWhER6R6to6QS8BKtiZdYRCSBHWlhJN7Xb+IlFhFJYKfrsFoRETlBKhgiIhIRXyBEkkFKUqfnPsclFQwRkR7UcnlWb/qjhKKCISLSg/yBUEJ2eIMKhohIj/IFgqSnJt45GKCCISLSo3xqYYiISCT8gVBCTgsCKhgiIj3KFwgl5JBaUMEQEelRamGIiEhE/GphiIhIJHyBIOkpGiUlIiJdaDlxLxElZmoRkQSlE/dERCQi6sMQEZGI+DRKSkREIqEWhoiIREQFQ0REIhI+JKVhtSIi0gnnnIbViohI1/zB8OVZ1ektIiKd8gVUMEREJAJ+r2DokJSIiHSqtWDoTG8REemMTy0MERGJhL+1D0PDakVEpBPqwxARkYj4AkFABUNERLrg17BaERGJhC+oQ1IiIhIBDavtgJk9bGaVZlbawfoJZvaGmfnM7M5j1s0zs41mVmZm34hWRhGRntQyrDYjVQXjWIuAeZ2srwFuB37adqGZJQO/Ai4DJgHXm9mkKGUUEekxR1oYGlZ7FOfcq4SLQkfrK51zq4DmY1bNAMqcc1udc37gT8D8aOUUEekpGlbb/YYCu9o8LveWiYgktJZhtRol1X2snWWuw43NFphZiZmVVFVVRTGWiMipUQuj+5UDw9s8Hgbs6Whj59xC51yxc664sLAw6uFERE6WCkb3WwWMNbNRZpYGXAc8G+NMAIRCjqdWl7Ox4nCso4hIAvIFQphBSlJ7B1LiX0q0XtjMHgfmAAVmVg7cDaQCOOceNLNBQAmQC4TM7A5gknPukJl9EXgRSAYeds6tj1bOSIVCjv94ai1PrC4H4KLxhXz2wjGcN6ofZu3/5zvn2LSvjpfWV/DSu/swg0U3z6BfdlpPRheROOEPhkhPSerwOyPeRa1gOOeu72J9BeHDTe2tWwwsjkaukxH0isWTq8v59zljyEhNZtHy7Vy3cAXD8jNxDur9AeqaAiSZkZWeTFZqMkHn2HfIhxlMGdaX9/Ye4lMPr+Sxz5xHTkZqrH8sEelh/kAoYU/agygWjN4iGHJ8/cm1PPVWOXdcMpY7LhkHwILZo3lidTnLy6rJTEumT3oK2ekpOAeN/gD1/iCBYIgZo/pzycQBDMjN4J8b9rHg96v59O9K+P0tM8hITcyx2CJycnyBIGkJOrU5qGB0qKbez4vrK/jrW+Ws2n6AL18yji9dMrZ1fUZqMjfOHMmNM0dG/JpzJwzkZ9dO4Y4/v8O/P/oWv75xGqkJ/NeGiJwYXyCUsENqQQUD5xyPvrmT2sZmDjU1c6ixmR37G3hzWw3BkKOofxbfnX8mn5xV1C37mz91KIebAnz7mVI+9us3+P6/nc2EQbnd8toiEt/8KhiJzcz4weL3qPcHSUtJIi8zlYI+6Xx29mg+NHkwkwbndnsH1Q0zR9InPYX/em49V9y3jFvfP5ovXTyWzLTEbaqKSNf8gVDCDqkFFQwAln79Ivqkp/Ron8JV5wxl9rhCfvjCezy4dAvPr93Dj6+ezPlnFPRYBhHpWYl+SCpxk3ejgj7pMemA7pedxo8/OoU/L5hJWnISH3/oTe76v1Ia/IEezyI9b+f+Bh55fRu/fGUz1XW+o9Y551iysZKv/Pkdfv/GdvYdaopNSOlWid7CMOc6nHUj4RQXF7uSkpJYxzgpjf4gP3lxI48s38bw/Cx+es0UZozqd9Q2oZDj/iVl/GNDJd//yNlMHKy+j0RysMHP6h0HWLmthn9uqGRzZV3ruqy0ZD79vlF8ZvZodtU08IPFG1hWVk12WjL1/iBmcO6IfK6aOoSPThuuw5cJ6uoHlpORmsSjt86MdZRWZrbaOVcc0bYqGPHlza37+dqTa9lZ08AnZ43k6/Mm0Cc9hUNNzXzlz2t45b19ZKYm43D86OrJzJ/a/fMybt53mKWbqhhVkM2sMf3JSjty5HJ/nY+V22rYd6gJfzCErzmEA2aN6c+0EfkkJegZrJEKhRwHGvxU1/k50OCnwR+g3hek3heg/EAj26rr2VZdT+VhH33Sk8nLTCU3M5W9tU2UeQUiNdk4b1R/5k4YwNwJAwg6x89f3sTf1u4lJz2FOn+AvMxUbp87lhtmjmTH/npeKK1g8bq9bKg4TH5WKp86v4hPzSoiXyeBJpQr/uc1Cvuk88jNM2IdpZUKRoJr8Af4yYsbWbR8O0PyMvnSxWN5YOkWdtU08O0PTeTyyYP54qNvs3J7DTedX8Q3L59A+gmO7XbeSYV1vgBNzUEa/EFKdtTw7Dt72NBm6pO05CRmjOrHiP5ZlGyvYdO+ug5fszAnnQ+eOZDZYwsZVZDN8H5ZcX+uSW1DMzkZKR0WusNNzby2uZp/vFfJG1uq2XfYRzDU/u9McpIxPD+TooJsBuVmUO8PcqixmdrGZvpmpTK9qB/FI/OZMrxvu+9L6e5afvPaVgbnZfL5OWPIyzz+5M6S7TU8uHQLr7xXSUZqEgV90gmGHM1BR3Z6MldOHsLHpg9neL+s1uf4AkG2Vze0DurIzUghRcO5Y+LSXyxldEEfHrxxWqyjtFLB6CVW76jh60+uZUtVPQV90rn/E+e2HqZqDob4/uL3eOT17QBkpiaTk5FCn/QU0lKSSEtJIjU5iYG56cydMJC5EwbQLzuNOl+AZ97ezWNv7uTdvYeO2+e5I/ry4SlD+MCZg9hRXc+STVUs3VjFrgMNTBuZz8zR/Zk1pj+j+meTlpJEekoSjc1B/rmhkr+XVrBkYxWNzcHW1xuUm8FV5wzltrlnkJ3e82MsKmqbePm9ffTNTGVQXgYDczIoP9jAko1V/Ms7LNTyZT6jKFwYd+yvZ2tVPWWVdawpP0hz0JGXmcr7xxYwsn8WhX3SKczJoG9WKtnpKWSnJZOZlsyAnIweOz69ad9hHl2xg8NNAZKTjJTkJPYcbOS1zVU44P1jCxnaN4N1u2vZWHGY5uDRv+dD8jK4ZNJA5p05iBmj+qmA9JA5P/kXk4f15b7rz4l1lFYqGL1IU3OQZ9fs4cJxhQzMzThu/ZKNlazZVUudr5nDTQEO+wL4AyECwRDNQUdZZR0Vh5pIMjh7WF/K9h2m3h9k4uBcrj53KANyM8hISSIzLZmi/tlH/WV6Mhr9QTZUHGJnTQM79zdQuqeWF9fvY3BeBt+5YhKXnTXopIYplx9ooNEfZEBuBrkZKZgZ++t8rC2v5Z1dBwGYP3UIowv7AOGC+rvl2/nFy5uo9wePe72WltPM0f3YWdPAym01bN/f0Lq+f3YaowuzOXdEPhdPHMi5I/omxJfq7oON/GXVLv5SsosGf5Czh+Zx9rA8JgzKIeQctQ3NHGxsZsPewyzZVElTc4j8rFSunT6cz80eo0NcUTbrB//ggjMK+Ok1U2IdpZUKhrRyzlG6+xAvv1vBa2XVjC7oww0zRzB1eN8emwBt9Y4avvPMet7de4jzRvVj3lmDOG9Uf8YPyiG5kz6PBn+Axesq+EvJLlZuO3LxxszUZPpkpFB1ODyyqOUlQg6KR+bzwTMH8eTqcjbuO8zcCQP4+rzxGMa+Q01UHGoiPyuN88f0P67FU3moiT21TRT1z6JvVuJ/cTrnOv0/bvAHWLqxiufW7uGF0gqy01K45X2juPX9o8jVXGdRMe2el5l31iC+95GzYx2llQqGxJ1AMMSjb+7kN69tpfxAIwC5GSm8f2wh86cOYc74AaSlJBEKOVZtr+Gpt8r529q91PuDFPXP4pri8HH5ykNNVNQ2UdvYzLiBOUwelsdZQ/Oo8wV4+u3dPFGyiy1V9Qztm8ndV07iA5MGJuzMoD1p077D3PvKJhavqyAvM5X/vuosrpwyJNaxep2z736RjxYP4+4rz4x1lFYqGBLXdh9sZNW2Gt7ctp+X391HdZ2fvlmpXDiukNU7DlB+oJHstGQuO3sw1xYPZ3pRfsRf+s45tlbXMyQvU0NPT8L6PbV8+5lS3t55kOumD+euKycdNUpOTs24b73Aze8r4puXTYx1lFYnUjD0SZAeN7RvJkPPGcpV5wzlnvkhlpVV88zbu/nXxiomD8vjq5eO44NnDjqpLyozY4zXjyEn7swhefzls7O495VN3L9kC6u21/Djj07m3BGRF21pn3POux5G4v4ho4IhMZWSnMSc8QOYM35ArKOIJzU5ia99cALnjyngy39+h6sfeIMheRnMnTiAiycOZOao/mq9nQR/MHx51kSeGkQFQ0TadcEZBbz85Qt5cX0Fr7y3j6dW7+aPK3aSlpzEuSP7cv6YAi44o4Cpw/t2OnhBwlqv550Ao+06ooIhIh3K84bcXjt9OE3NQVZs3c/rZdW8Xrafn7+8iZ+/vIn8rFTmjA+ftT5tZD4DczNUQNrh8wpGeqoKhoj0chmpyUcdPqyp9/N6WTX/2lDJvzZW8vTbu4Hw1CdD+mZS1D+bb14+Qdd78aiFISKnrX7ZaVw5ZQhXThlCMOR4Z9dBNlQcovxAI+UHGnljSzUf/82bPP6ZmYwflHPUcysPN5GXmZrQHcAnqrVgqA9DRE5nyUnGtJH5TBuZ37pse3U9H1v4Bh//zQoeXzCTcQNzqPMFuO8fm3l42TbGD8rh4ZumtzuDAUAw5Ph7afgyybPHFXLjzJEJPbmlrxcUjMRNLiJxraggm8c/M5PkJOPjv1nBb5dtY+5Pl7Dw1a188MxBbK+u56pfvc6GiqPnNGsOhniiZBcf+MVSvvDYW5TsOMDdz67nht++SfmBhg72Fv9aWhiJ3KpSC0NEomZ0YR8eXzCT6xau4J7n32XKsDwWfrKYqcP7sn5PLbcsWsVHH3iDH109mTpfM0s2VrGsrJrDTQEmDs7lfz9+DpedNZgnSnZxz/PvMu/e1/h/l0/k6mlDE+6L1x8Mz2mWyC0MnektIlG3q6aB9XtquXTSoKMOK+2tbeTmR1a1Tqk/OC+D2WMLmXf2IOaMKzzqZMFdNQ3c+cQa3txWQ9+sVOZPGcI1xcM5c0huQpxUuLysmo8/FO7TmTWmf6zjtNKZ3iISV4b3y2p3JuTBeZk88blZ/HNDJRMH5zJ2QJ8Ov/yH98vi8c/MZFlZNU+sLufxVbv43Rs7GF2QzUXexaimF/WL27/gfUENqxUROSU5GakRXzkyKcmYPa6Q2eMKqW1o5rm1e3jp3X38YcUOfrtsG+kpSeRmppLqXSPk7KF5/PxjU+Li8JWG1YqIxEheVio3zBzJDTNH0uAP8HrZflZs3U+DP0Bz0NHgD/C3dXvJy0rl+3EwnfiaXQcxg/59EnfqfBUMEUl4WWkpfGDSQD4waeBRy3/4wgYeXLqFc4b35Zri4Sf12pWHm9hWVc95o0++32F/nY9Fy7dzxeQhDM7LPOnXibXEbRuJiHThzkvHcf6Y/nz7mVJKd9cCsGN/Pf/x5Fpm/eAfrcva4w+EWPjqFub+dCkfW7ii02278utXt9LUHOSOS8ae9GvEAxUMEem1UpKTuO/6c8jPSuPzj67mq39Zw9yfLeXpd3bT4A9y2+NvU+cLHPe81zZXMe+Xr/L9xRuYXpRPTkYKDyzdclIZKg818bvl27nqnKEJP/W+CoaI9GoFfdK5/4Zzqaht4m/r9nDT+UUs+/pF/PrGaezYX89d/1fauq1zjvuXlHHjb1cSCjkevqmYR26ewY0zR/LCur1sq64/4f3fv2QLgZDjSxcndusC1IchIqeBc0fks/j299M3K43CnHQABuRmcPvFY7n3lc1cMKaAq84Zyt3PlvLHFTv58JQh/Pijk8lIDY+uuvmCUTy0bBsLX93CD/5tcsT73XOwkcfe3Mk104Yxsn92VH62nqQWhoicFsYOzGktFi1umzuW80b14zv/V8pNj6zkjyt28rkLx3Dvx6a2FguAwpx0ri0exlOrd7PvUFNE+3PO8ctXNuNwfHHuGd36s8SKCoaInLaSk4x7r5tKekoSy8qq+e78M/nGZRPaneTws7PHEHSO3y7b1uXrrtl1kI8tXMGfS3bxifNGMiz/+JMWE5EOSYnIaW1wXiaPL5hJXVOA4qJ+HW43vF8WV0wezKMrdvCFOWeQl5V63DaVh5v47+ff49k1eyjok8Y9V53F9dNPbjhvPFILQ0ROexMG5XZaLFp87sIx1PuDLFq+vd31X3tiLS+ur+C2uWew5GsXcePMkaQk8Jndx+o9P4mISJRNHJzLJRMH8NCyrRxs8B+1bm35QZZuquJLl4zlq5eOp0967zuAE7WCYWYPm1mlmZV2sN7M7D4zKzOztWZ2bpt1QTN7x7s9G62MIiIn6quXjqfOF+DBpVuPWv6rf5WRm5HCjTNHxihZ9EWzhbEImNfJ+suAsd5tAfBAm3WNzrmp3u3D0YsoInJiJg7OZf6UISxavo1Kb8TUxorDvLh+HzddMIqcjOP7NnqLqBUM59yrQE0nm8wHfu/CVgB9zWxwtPKIiHSXL39gHIGg475/bgbg/iVlZKUlc/P5RbENFmWx7MMYCuxq87jcWwaQYWYlZrbCzK7q+WgiIh0b2T+b62eM4E8rd7F0UxXPrdnDDTNHkp+duDPRRiKWBaO9q6S0XP5vhHcFqI8D95rZmA5fxGyBV1xKqqqqopFTROQ4t809g5Rk4zO/LyElOYlb3zcq1pGiLpYFoxxoO0B5GLAHwDnX8u9WYAlwTkcv4pxb6Jwrds4VFxYWRi+tiEgbA3IzuOWCUfgDIa6bPpwBuRmxjhR1sSwYzwKf9EZLzQRqnXN7zSzfzNIBzKwAuAB4N4Y5RUTa9bk5Y7jp/KJeM/VHV6I2UNjMHgfmAAVmVg7cDaQCOOceBBYDlwNlQANws/fUicCvzSxEuKD90DmngiEicSc3I5X//PCZsY7RY6JWMJxz13ex3gFfaGf5ciD211MUEZGj6ExvERGJiAqGiIhERAVDREQiooIhIiIRUcEQEZGIqGCIiEhEVDBERCQiFj4doncws1pgczur8oDaCB+33G9vWQFQfYKxjt1XpOvbW95epo7un0rmznJFmi9RMre3PBE/H5Fkbntfn4/I1/f2z8dY51xeRGmcc73mBiyMZHlnj1vud7CspLsynWjmjjJ1lf9kMp9s7kTM3Fs+H5FkjvV7rc9H/H8+urr1tkNSz0W4vLPHz3WyrDszdbW+veUdZeoq/8k4mdyJmLm95Yn4+Ygkc9v7+nxEvv50+nx0qlcdkoo2Mytx4WnXE4Yy95xEzK0dvP+KAAAHKUlEQVTMPSdRc7fV21oY0bYw1gFOgjL3nETMrcw9J1Fzt1ILQ0REIqIWhoiIROS0LRhm9rCZVZpZ6Uk8d5qZrTOzMjO7z8yszbrbzGyjma03sx/He2Yz+08z221m73i3y+M9c5v1d5qZ8y601a2i9F7fY2Zrvff5JTMbkgCZf2JmG7zcT5tZ3wTIfI33+xcys27rMziVrB283qfMbLN3+1Sb5Z1+7mPqZIan9YYbMBs4Fyg9ieeuBGYRvi75C8Bl3vKLgFeAdO/xgATI/J/AnYn0PnvrhgMvAjuAgkTIDeS22eZ24MEEyHwpkOLd/xHwowTIPBEYT/jyzsWxzurlKDpmWT9gq/dvvnc/v7OfKx5up20Lwzn3KlDTdpmZjTGzv5vZajN7zcwmHPs8MxtM+Bf/DRf+3/09cJW3+vOErxDo8/ZRmQCZoyqKmX8BfB2ISidcNHI75w612TS7u7NHKfNLzrmAt+kKYFgCZH7PObexO3OeStYOfBB42TlX45w7ALwMzIvl72okTtuC0YGFwG3OuWnAncD97WwzFChv87jcWwYwDni/mb1pZkvNbHpU04adamaAL3qHHB42s/zoRW11SpnN7MPAbufcmmgHPcYpv9dm9j0z2wV8ArgrillbdMfno8UthP/ijbbuzBxtkWRtz1BgV5vHLfnj5edqV9Qu0ZpozKwPcD7wRJtDhuntbdrOspa/FFMINy9nAtOBv5jZaO8vhW7XTZkfAO7xHt8D/IzwF0NUnGpmM8sCvkX4UEmP6ab3Gufct4Bvmdk3gS8SvtZ9VHRXZu+1vgUEgEe7M+NxQboxc7R1ltXMbga+5C07A1hsZn5gm3PuI3ScP+Y/V2dUMI5IAg4656a2XWhmycBq7+GzhL9g2zbLhwF7vPvlwF+9ArHSzEKE54+pitfMzrl9bZ73G+D5KGVtcaqZxwCjgDXeL+kw4C0zm+Gcq4jj3Md6DPgbUSwYdFNmr0P2CuDiaP3x00Z3v8/R1G5WAOfcI8AjAGa2BLjJObe9zSblwJw2j4cR7usoJ/Y/V8di3YkSyxtQRJsOLGA5cI1334ApHTxvFeFWREun1OXe8s8B3/XujyPc5LQ4zzy4zTZfBv4U7+/zMdtsJwqd3lF6r8e22eY24MkEyDwPeBcojMZ7HM3PB93c6X2yWem403sb4SMS+d79fpF+7mN1i3mAmP3g8DiwF2gmXNU/Tfgv178Da7xfkrs6eG4xUApsAf6XIydApgF/9Na9BcxNgMx/ANYBawn/5TY43jMfs812ojNKKhrv9VPe8rWE5+8ZmgCZywj/4fOOd+vukV3RyPwR77V8wD7gxVhmpZ2C4S2/xXt/y4CbT+RzH6ubzvQWEZGIaJSUiIhERAVDREQiooIhIiIRUcEQEZGIqGCIiEhEVDCkVzOzuh7e30NmNqmbXito4ZltS83sua5mijWzvmb2792xb5H2aFit9GpmVuec69ONr5fijkzGF1Vts5vZ74BNzrnvdbJ9EfC8c+6snsgnpx+1MOS0Y2aFZvaUma3ybhd4y2eY2XIze9v7d7y3/CYze8LMngNeMrM5ZrbEzJ608LUiHm25ZoG3vNi7X+dNNrjGzFaY2UBv+Rjv8Soz+26EraA3ODL5Yh8z+4eZvWXh6ybM97b5ITDGa5X8xNv2a95+1prZf3Xj2yinIRUMOR39EviFc246cDXwkLd8AzDbOXcO4Zlkv9/mObOATznn5nqPzwHuACYBo4EL2tlPNrDCOTcFeBX4TJv9/9Lbf5fzBHnzKF1M+Ex8gCbgI865cwlfg+VnXsH6BrDFOTfVOfc1M7sUGAvMAKYC08xsdlf7E+mIJh+U09ElwKQ2M4zmmlkOkAf8zszGEp4hNLXNc152zrW9FsJK51w5gJm9Q3iOoWXH7MfPkckcVwMf8O7P4sg1Dh4DftpBzsw2r72a8DUTIDzH0Pe9L/8Q4ZbHwHaef6l3e9t73IdwAXm1g/2JdEoFQ05HScAs51xj24Vm9j/Av5xzH/H6A5a0WV1/zGv42twP0v7vUrM70knY0TadaXTOTTWzPMKF5wvAfYSvpVEITHPONZvZdiCjnecb8APn3K9PcL8i7dIhKTkdvUT4WhQAmFnL9NR5wG7v/k1R3P8KwofCAK7ramPnXC3hS7reaWaphHNWesXiImCkt+lhIKfNU18EbvGu24CZDTWzAd30M8hpSAVDerssMytvc/sK4S/fYq8j+F3C09ID/Bj4gZm9DiRHMdMdwFfMbCUwGKjt6gnOubcJz4h6HeGLGBWbWQnh1sYGb5v9wOveMNyfOOdeInzI6w0zWwc8ydEFReSEaFitSA/zrhrY6JxzZnYdcL1zbn5XzxOJNfVhiPS8acD/eiObDhLFS+KKdCe1MEREJCLqwxARkYioYIiISERUMEREJCIqGCIiEhEVDBERiYgKhoiIROT/AxmDv1s6dCCNAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_learner.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total time: 00:15\n",
      "epoch  train_loss  valid_loss\n",
      "1      1.039077    0.990304    (00:01)\n",
      "2      0.711619    0.081215    (00:01)\n",
      "3      0.324179    0.000577    (00:01)\n",
      "4      0.157489    0.000473    (00:01)\n",
      "5      0.079666    0.000547    (00:01)\n",
      "6      0.041201    0.000580    (00:01)\n",
      "7      0.021641    0.000591    (00:01)\n",
      "8      0.011547    0.000587    (00:01)\n",
      "9      0.006296    0.000577    (00:01)\n",
      "10     0.003554    0.000575    (00:01)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "my_learner.fit_one_cycle(10,1e-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f5070224198>]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xd4XOWZ9/HvrW51y5KLii25Y8AFCxcIzeBgSkwIbMAJkGUJhOJkE8hmk928eXPxXsluCJssuzHFIRB6CYGskwBOQkxYcME2xgZX5CJLrnKTLRv15/1jZmRZVhnLks7Mmd/nunRpypmZ22PpN4+e+5zzmHMOERHxlzivCxARkZ6ncBcR8SGFu4iIDyncRUR8SOEuIuJDCncRER9SuIuI+JDCXUTEhxTuIiI+lODVC+fm5rri4mKvXl5EJCqtXLlyn3Mur6vtPAv34uJiVqxY4dXLi4hEJTMrD2c7TcuIiPiQwl1ExIcU7iIiPqRwFxHxIYW7iIgPKdxFRHxI4S4i4kOe7efeXSvLD/Be2X6Kc9MYnptGcW4a6clR988QEelVUZeKK7Yd5Gd/3nTCbbnpyZTkplI8IBD2JblpwcuppCZF3T9RROS0mVcLZJeWlrruHqH6aX0T5QeOsrXqKFv3H2XbvqNs23eMrfuPUnWk7oRtB2emUJyb2irwA+E/NCeVlMT4nviniIj0GTNb6Zwr7Wq7qBzW9kuKZ+zgTMYOzjzpvpq6xkDY7z8x/Beu3cOBo/Ut25lBfla/QOgHR/0lwWmeov6pJCWoHSEi0Ssqw70z6ckJnFWQxVkFWSfdV/1pw/Hg3xcI/a37jrLgw50crm1s2S4+zijIDgR/YMSf2jLiL8juR0K8gl9EIpvvwr0zWf0SmVCUzYSi7BNud85x8FhDS+C3hP/+o6wsP0hN3fHgT4w3ivoHwv6qs4dw3eTCvv5niIh0KabCvSNmRk5aEjlpSUwe1v+E+5xzVNXUsW3fscBIPzjNs3bnYf7pldVMKMpi5MAMjyoXEWmfwr0LZsbAjBQGZqQwpSSn5fYDR+u58IFFPLhwE4/ePNnDCkVETqbJ427KSUvi9guG8+ba3XxYccjrckRETtBluJvZE2a218w+7uB+M7P/MrMyM1tjZuf0fJmR6bYLShiQlsQDb27wuhQRkROEM3L/NTCrk/uvAEYFv+4AHjn9sqJDenICc2eMZPHm/bz7yT6vyxERadFluDvn3gEOdLLJNcDTLmApkG1mQ3qqwEj3palDKcjux0/e3IBXB4SJiLTVE3PuBUBFq+uVwdtiQnJCPPfOHM1HO6p54+PdXpcjIgL0TLhbO7e1O4Q1szvMbIWZraiqqur+K9Ye7v5je8HnJxUwelA6Dy7cSGNTs9fliIj0SLhXAkWtrhcCO9vb0Dk33zlX6pwrzcvL696rvftzeKAEGmq79/heEB9nfPuzY9iy7yivrKz0uhwRkR4J9wXALcG9ZqYB1c65XT3wvO3LGQ7NjbBnba+9RHfMHDeISUOzeeitT6htaPK6HBGJceHsCvkCsAQYY2aVZnabmd1pZncGN3kd2AKUAb8E7u61agGGTAx837WqV1/mVJkZ/zxrLLuqa3lmSbnX5YhIjOvyCFXn3Jwu7nfAPT1WUVeyh0K//rDzwz57yXBNGz6Ai0bnMe/tMm6YUkRmSqLXJYlIjIq+I1TNAqP3XZEX7gD/dPkYDh1r4JfvbPG6FBGJYdEX7gD5k2Dv+ohqqoacVZDF1eOH8Kt3t560cIiISF+J0nCfGJFN1ZD7PjuGusZm5i0q87oUEYlR0RnuEdpUDSnJTeOGc4t4blk5FQeOeV2OiMSg6Az3CG6qhvzjpaOIM+PnbRbzFhHpC9EZ7hHeVAUYlJnCreeX8NqHO9iwO7KOqBUR/4vOcIeIbqqG3HXRCNKTE3hw4UavSxGRGBPF4R7ZTVWArNRE7rxoBH9Zv5eV5Z2dWFNEpGdFb7hHeFM15Nbzi8nLSOYnb2zUKYFFpM9Eb7hHQVMVIDUpgW9cOor3tx3g7U2ncSZMEZFTEL3hHgVN1ZAbzy1i2IBUHnhzI83NGr2LSO+L3nCHwLx7hDdVARLj47h35mjW7zrM79e0ezZkEZEeFeXhPinim6ohnxufzxlDMvnZnzfRoAU9RKSXRXe4R0lTFSAuzvjO5WMo33+Ml5ZXdP0AEZHTEN3hHiVN1ZCLx+QxpTiHh976hE/rtaCHiPSe6A73KGqqQmBBj+/MGkPVkTqeXLzV63JExMeiO9whapqqIaXFOVx2xkAefXsz1ccavC5HRHzKB+EebKrujfymasi3Lx/DkbpGHvnbZq9LERGfiv5wDzVVd0Z+UzVk7OBMPj+xgF8v3sqew9HxF4eIRJfoD/coa6qGfOuy0TQ1O/7rrU+8LkVEfCj6wz3KmqohQwek8qUpQ3lxeQVb9x31uhwR8ZnoD3eIuqZqyNwZo0hOiONnWtBDRHqYP8J9yMSoa6oC5GUkc9tnSvj96p18vKPa63JExEf8Ee75kwLfo6ipGnL7hcPJTk3kwT9pQQ8R6Tn+CPcobaoCZKYkcvfFI3h7YxVLt+z3uhwR8Ql/hHuUNlVDbplezODMFB54c4MW9BCRHuGPcIeobaoCpCTG883LRvHB9kP8Zf1er8sRER/wT7hHaVM15PrJhQzPTeOnCzfQpAU9ROQ0hRXuZjbLzDaaWZmZfbed+4ea2SIzW2Vma8zsyp4vtQstTdXonJpJiI/jvs+OYdOeGn63aofX5YhIlOsy3M0sHpgHXAGMA+aY2bg2m30feNk5Nwm4EXi4pwvtUktTNfr2mAm54qzBnF2Qxc//som6Rp0SWES6L5yR+xSgzDm3xTlXD7wIXNNmGwdkBi9nAX2/llyUN1UhuKDHrDFUHvyUF5Zt97ocEYli4YR7AdB66aDK4G2t/RC4ycwqgdeBr/dIdacqipuqIZ8Zmct5Iwbw338to6au0etyRCRKhRPu1s5tbTt+c4BfO+cKgSuBZ8zspOc2szvMbIWZraiqqjr1arsS5U1VCC3oMZb9R+t54l0t6CEi3RNOuFcCRa2uF3LytMttwMsAzrklQAqQ2/aJnHPznXOlzrnSvLy87lXcmfzQ6X+jd2oGYGJRNrPOHMz8d7Zw4Gi91+WISBQKJ9yXA6PMrMTMkgg0TBe02WY7cCmAmZ1BINx7YWjehexhgaZqFM+7h3z78tEcq2/kkbfLvC5FRKJQl+HunGsE5gILgfUE9opZa2b3m9ns4Gb3Abeb2WrgBeDvnReHWoaaqlG8x0zIyIEZXHdOIU8tKWfnoU+9LkdEokxY+7k75153zo12zo1wzv0oeNsPnHMLgpfXOefOd85NcM5NdM79qTeL7pQPmqoh35w5Ghw89Bct6CEip8Y/R6iG+KCpGlKQ3Y+bpw/jNysrKNtb43U5IhJF/BfuPmmqhtx98QhSkxL4D50SWEROgf/C3UdNVYAB6cl89YIS3vh4N6srDnldjohECf+Fu4+aqiFfvWA4OWlJ/HShRu8iEh7/hTv4qqkKkJ6cwNxLRvJu2T7e/WSf1+WISBTwZ7j7qKka8uVpQynI7scDC7Wgh4h0zZ/h7rOmKkByQjzfmjmaNZXVvPnxbq/LEZEI589wzx4GKdm+aaqGXDupgFED03nwTxtpbGr2uhwRiWD+DHezwOIdPhq5A8THGd++fAybq47y6gda0ENEOubPcIdgU3Wdb5qqIZ8dN4iJRdn8/C+bqG3Qgh4i0j7/hrsPm6oQOCXwP88ay67qWp5dWu51OSISofwb7j5sqoZMHzGAC0fnMW9RGYdrG7wuR0QikH/D3adN1ZDvXD6Gg8caePydLV6XIiIRyL/h7tOmashZBVlcNX4Ij7+7lX01dV6XIyIRxr/hDr5tqobcN3M0dY3NzFukBT1E5ET+DnefNlVDhuelc905BTy/bDtVRzR6F5Hj/B3uPm6qhtx18Ugampp5/F3NvYvIcf4Od583VQFKctO4enw+zy4p59AxLaYtIgH+DnezwOjdxyN3gHsuGcnR+iZ+vXib16WISITwd7hDYI8ZH53+tz1jBmfw2XGDePK9bdTUNXpdjohEAP+H+5CJ0Nzg26ZqyNwZI6n+tEFHrYoIEAvhHgNNVYDxhdlcMCqXx/93i845IyIxEO4x0FQN+fqMUeyrqefF97d7XYqIeMz/4R4jTVWAKSU5TCnO4bF3tlDfqPO9i8Qy/4c7HG+qNvr/QJ97ZoxkV3Utr62q9LoUEfFQbIR7qKm6x99NVYALR+UyvjCLh9/erNWaRGJYbIR7S1N1lbd19AEz455LRlK+/xh//GiX1+WIiEdiI9xjqKkKMPOMQYwelM4v/lpGc7PzuhwR8UBshHsMNVUB4uICo/dP9tbwp3V7vC5HRDwQVrib2Swz22hmZWb23Q62+aKZrTOztWb2fM+W2QOGTIyZpirA1ePzKR6QyrxFZTin0btIrOky3M0sHpgHXAGMA+aY2bg224wCvgec75w7E/hmL9R6evInxUxTFSA+zrjr4hF8tKOav22q8rocEelj4YzcpwBlzrktzrl64EXgmjbb3A7Mc84dBHDO7e3ZMntADDVVQ66dVEh+VooW8xCJQeGEewFQ0ep6ZfC21kYDo83sPTNbamaz2nsiM7vDzFaY2Yqqqj4eTcZYUxUgKSGOr100guXbDrJsy36vyxGRPhROuFs7t7WdxE0ARgEXA3OAx80s+6QHOTffOVfqnCvNy8s71VpPT4w1VUNuOLeI3PRkfqHRu0hMCSfcK4GiVtcLgZ3tbPM/zrkG59xWYCOBsI8sMdZUBUhJjOerF5Twv5/sY3XFIa/LEZE+Ek64LwdGmVmJmSUBNwIL2mzzO+ASADPLJTBNE3nrvsVYUzXkpmnDyOqXqNG7SAzpMtydc43AXGAhsB542Tm31szuN7PZwc0WAvvNbB2wCPgn51zkTfKGmqoxNO8OkJ6cwK3nF/PndXvYsPuw1+WISB8Iaz9359zrzrnRzrkRzrkfBW/7gXNuQfCyc87d65wb55w72zn3Ym8W3W2hpmoM7TET8vfnFZOWFM+8RZu9LkVE+kBsHKEaEqNNVYDs1CRunl7MH9fsZEtVjdfliEgvi61wh5hsqobc9pkSEuPjeORtjd5F/C72wj0/dk7/21ZeRjJzpgzltVU7qDx4zOtyRKQXxWC4Twp8j7GmasgdFw7HDOa/E3k7M4lIz4m9cI/hpipAfnY/rjunkBeXV7D3cK3X5YhIL4m9cI/hpmrInReNoLGpmcff3ep1KSLSS2Iv3CGmm6oAxblpzJ6Qz7NLyzl4tN7rckSkF8RmuMdwUzXk7ktGcqy+iSff0+hdxI9iNNxju6kKMHpQBpefOYhfL97GkdoGr8sRkR4Wm+He0lSN3XAHmHvJKA7XNvLM0nKvSxGRHhab4d7SVI3NPWZCzi7M4qLRefzqf7fyaX2T1+WISA+KzXCHmG+qhsydMZL9R+t54f3tXpciIj0odsNdTVUAzi3OYWpJDvPf2UJdo0bvIn4Ru+E+JDZP/9ueuTNGsvtwLb9ducPrUkSkh8RuuPcvVlM16DMjc5lQmMWjf9tMY1Oz1+WISA+I3XBXU7WFmTF3xii2HzjG79e0XUFRRKJR7IY7qKnayqVjBzJ2cAbzFm2mubnt+uciEm1iO9zVVG0RF2fcfclIyvbWsHDtbq/LEZHTFNvhrqbqCa46ewgluWn8YlEZzmn0LhLNYjvc1VQ9QXyccdfFI1i78zBvb6zyuhwROQ2xHe6hpqpG7i2unVRAQXY/jd5FolxshzsEpmb2rFNTNSgxPo6vXTScleUHWbrlgNfliEg3KdzVVD3JF0uLyMtI5heLPvG6FBHpJoW7mqonSUmM5/YLSnivbD+rth/0uhwR6QaFu5qq7fry1GFkpyYyb1GZ16WISDco3NVUbVdacgL/cH4Jf1m/l3U7D3tdjoicIoU7qKnaga9MLyY9OYF5b2v0LhJtFO6gpmoHslITuXn6MF7/aBebq2q8LkdETkFY4W5ms8xso5mVmdl3O9nuejNzZlbacyX2ATVVO3TbZ0pITojj4UWbvS5FRE5Bl+FuZvHAPOAKYBwwx8zGtbNdBvANYFlPF9nr1FTtUG56MnOmDOV3H+6g4sAxr8sRkTCFM3KfApQ557Y45+qBF4Fr2tnu/wEPALU9WF/fUFO1U3dcOJw4g8fe0ehdJFqEE+4FQEWr65XB21qY2SSgyDn3hx6srW+pqdqhIVn9uH5yES8vr2TP4ej77BaJReGEu7VzW8tJR8wsDvg5cF+XT2R2h5mtMLMVVVURdmIqNVU7dddFI2hyjl++s8XrUkQkDOGEeyVQ1Op6IdB6uZ4M4CzgbTPbBkwDFrTXVHXOzXfOlTrnSvPy8rpfdW9QU7VTQwekMntCPs8t286Bo/VelyMiXQgn3JcDo8ysxMySgBuBBaE7nXPVzrlc51yxc64YWArMds6t6JWKe4uaql26++IR1DY28cS7W70uRUS60GW4O+cagbnAQmA98LJzbq2Z3W9ms3u7wD5jBkMmaOTeiVGDMph15mCeWryN6k8bvC5HRDoR1n7uzrnXnXOjnXMjnHM/Ct72A+fcgna2vTjqRu0h+ZPUVO3CPZeM5EhdI88s2eZ1KSLSCR2h2lqoqbp3ndeVRKyzCrK4ZEwev3p3K8fqG70uR0Q6oHBvLdRU3bnK2zoi3NwZIzl4rIHnl233uhQR6YDCvTU1VcMyeVgO04bnMP+dLdQ2NHldjoi0Q+HempqqYfv6jFHsPVLHKysrvS5FRNqhcG9LTdWwnDdiABOLsnn0b5tpaGr2uhwRaUPh3paaqmExM+ZeMpLKg5/yPx/u7PoBItKnFO5tqakatkvPGMjYwRk8/HYZTc2u6weISJ9RuLelpmrYzIy5M0aypeoob3682+tyRKQVhXtbaqqekivOGsLwvDR+sagM5zR6F4kUCvf25Ov0v+GKjzPuumgE63cd5vdrdnldjogEKdzbkz9JTdVT8PlJBZyZn8m9L33Ia6u0a6RIJFC4t6elqaqpmXAkxsfx/O3TKC3uz7deWs1jf9usKRoRjync29PSVNUeM+HK6pfIU/8whavGD+Hf3tjA/X9YR7P2oBHxTILXBUQkNVW7JTkhnv++cRKDMlJ44r2t7D1cx398cQIpifFelyYSczRy74iaqt0SF2f8n6vP4F+uHMsfP9rFV554X+d+F/GAwr0jaqp2m5lxx4Uj+M8bJvLB9oPc8NgSdldrYW2RvqRw74iaqqft85MKePLvp1Bx4BhfePg9PtlzxOuSRGKGwr0joaaq5t1Py2dG5fLS16ZT3+S4/tElLN92wOuSRGKCwr0joaaq9pg5bWcVZPHa3eeRk5bETY8v06kKRPqAwr0zaqr2mKKcVH5713mcMSSTu59byTNLy70uScTXFO6dGaLT//aknLQknr99KpeMGcj/+d3HPLhwow52EuklCvfO5E8KfFdTtcekJiXw2M2TuaG0iF8sKuM7r6zRYh8ivUAHMXVGTdVekRAfx79fdzaDs1J46K1PqKqp4+Evn0Nqkn4cRXqKRu6dUVO115gZ35o5mh9fezbvbKpizvyl7KtRb0Okpyjcu6Kmaq/60tShPHZzKRt2H+H6RxZTvv+o1yWJ+ILCvStqqva6meMG8fztUzn0aQPXPbKYjyqrvS5JJOop3LuipmqfmDwsh1fuPI/khHhumL+Ev22q8rokkaimcO+Kmqp9ZuTAdF69+zyGDUjjtl8v57crtfCHSHeFFe5mNsvMNppZmZl9t5377zWzdWa2xszeMrNhPV+qR1qaqgr3vjAoM4WXvjaNKSU53Peb1Tz8ttZmFemOLsPdzOKBecAVwDhgjpmNa7PZKqDUOTceeAV4oKcL9VT+RNizVk3VPpKZksiTt57L7An5PPDmRn64YC1NWvhD5JSEM3KfApQ557Y45+qBF4FrWm/gnFvknDsWvLoUKOzZMj2mpmqfS06I5z9vmMjtF5Tw1JJyvv7CB9Q2NHldlkjUCCfcC4CKVtcrg7d15DbgjdMpKuLk6/S/XoiLM/71qnF8/6ozeP2j3dzyxPtUH9PCHyLhCCfcrZ3b2v0b2cxuAkqBn3Zw/x1mtsLMVlRVRdHeEP1LICVLTVWPfPWC4fzXnEms2n6Qv3tsMbuqP/W6JJGIF064VwJFra4XAjvbbmRmlwH/Csx2zrU7Oe2cm++cK3XOlebl5XWnXm+YBaZmNHL3zOwJ+Tx16xR2HqrlCw8vZpMW/hDpVDjhvhwYZWYlZpYE3AgsaL2BmU0CHiMQ7Ht7vswIoKaq584bmcvLX5tOU7Pj+kcW8/5WLfwh0pEuw9051wjMBRYC64GXnXNrzex+M5sd3OynQDrwGzP70MwWdPB00UtN1YgwLj+T3951HrkZydz0q2W88dEur0sSiUhh7efunHvdOTfaOTfCOfej4G0/cM4tCF6+zDk3yDk3Mfg1u/NnjEJqqkaMopxUfnvneZyVn8ndz3/AU4u3eV2SSMTREarhUlM1ovRPS+K5r07j0rGD+L8L1vLAmxt0sJNIKwr3cKmpGnH6JcXz6E3nMGfKUB5+ezP3/Wa1Fv4QCVK4nwo1VSNOQnwcP772LO6dOZpXP9jBbU+tYOch7SoponA/FWqqRiQz4xuXjuIn153Ne2X7uOCBRdz5zEoWl+3TVI3ELK1rdipaN1VDpwKWiHHDuUM5b0Quzy4r5+XlFby5djcjB6Zzy/RhXDupgIyURK9LFOkz5tXIprS01K1YscKT1+425+Anw+DMa+FzD3ldjXSitqGJP6zZxdNLtrGmspq0pHi+cE4ht0wfxqhBGV6XJ9JtZrbSOVfa1XYauZ8KNVWjRkpiPNdPLuT6yYV8WHGIp5ds46UVFTyztJxpw3P4yvRiZo4bREK8ZibFnxTupyp/Iix9BBrrISHJ62okDBOLsplYNJHvXzWOl5ZX8OzScu567gMGZ6bwpalDuXFKEQMzUrwuU6RHadhyqoZMhKZ6NVWjUE5aEnddPIJ3vnMJv7yllFGD0vnZnzdx/r//la+/sIrl2w6oASu+oZH7qWppqq46flmiSnycMXPcIGaOG8SWqhqeXbqd36ys4Perd3LGkExumT6Maybmk5qkXw+JXhq5nyodqeorw/PS+cHnxrHsXy7lx9eejXOO7736EVN//Bb3/34dW/cd9bpEkW7R0ORUqanqS6lJCXxp6lDmTCliRflBnl5SztNLtvHEe1u5cHQet0wbxiVjBxIf197yBiKRR+HeHWqq+paZcW5xDucW57D36jN48f0KnltWzlefXkFh/358eeowbji3iJw0/b9LZNO0THeoqRoTBmak8I1LR/HuP8/g4S+fQ2H/fvzkzQ1M+7e3uPflD1ldccjrEkU6pJF7d6ipGlMS4+O48uwhXHn2EDbtOcIzS8p59YNKXv1gBxMKs7h5ejFXjx9CSmK816WKtNARqt2hI1Vj3pHaBl5btYOnl5RTtreG/qmJfPHcIm6aOoyinFSvyxMfC/cIVYV7dz01G/Ztgit/CmOuhDiN2mKRc44lm/fz9JJy/rx+D83OcenYgXxp6lDOLc7R+Wykxynce9vWd+B390D1duhfDNPuholfhuR0rysTj+yq/pTnl23nhfe3s6+mHjMYnpvGhMJsxhdmMb4om3FDMjV9I6dF4d4Xmhphwx9gyTyofB+Ss2DyV2Dq1yCr0OvqxCP1jc0s2bKfNRWHWF1ZzerKQ1QdCawBkBBnjBmcwfjCbCYUZjG+MJvRg9J1jhsJm8K9r1Ush6XzYF1wbfAzPw/T7oHCyd7WJZ5zzrH7cC1rKqtZU3mINZXVrK44xOHaRgBSEuM4Mz+L8YVZLaP84gFpxGmfemmHwt0rh7bDssfgg6eh7jAUTYPp98DYqzQvLy2cc5TvP8bqVmH/8c5qahsCywRmpCQEpnJajfCHZKVgpsCPdQp3r9UdgVXPBg52OlQO2cNg2l0w6SZI1vnE5WSNTc18sreGNZWB6Zw1lYfYsOsIjc2B39Hc9OSWoB9fFBjl62Cq2KNwjxTNTbDhj4F5+YqlkJwJ59wCU++E7CKvq5MIV9vQxPpdhwOj++Aof3NVDaFf28L+/Y43bAuzObswi/RkHb7iZwr3SFS5MjAvv/Z3gevjrglM2RR2+f8k0uJIbQMf7zh8fP6+8hCVBwOLgpvBiLz0lvn7M4ZkMiQrhYGZySQnaFrQDxTukexQBbw/H1Y+BXXVUDQ1sCvl2KshXqMuOXX7a+pYs6OaNRXVLdM6+2rqTtgmJy2JQZkpDM5MZnBWSvByCoOyAt8HZ6aQnZqoef0Ip3CPBnVH4MPnYenDcHAbZA8NTNdMuhlSMr2uTqKYc45d1bV8sreGPdW17D4c+Apd3nO4ln019Sc9Ljkhrk3oJweuBz8ABgW/khK066ZXFO7RpLkJNr4RmJffvhiSMgL7y0+5A/oP87o68an6xmb2HgkE/e7qupbQ393qA2B3dS11jc0nPXZA6K+ArFDgJ+uvgD6icI9WOz4IjOTXvgauGc6YHZiXL5ridWUSg5xzVH/aEBj5V7f/QbDncC37j3b+V8CA9CTSkxNIT0kgI/g9PTmxzfXAV0ZKAmnJCSTqwK529Wi4m9ks4CEgHnjcOffvbe5PBp4GJgP7gRucc9s6e06FexeqdwTn5Z+E2mooPDe4v/znNC8vEaeusYm9h+sCgd/6g+BwHXuqazl4rJ6aukZqahupqW8knDFlSmJcS+AfD/9EMlJOvC2j1QdD4MMi8YQPi5TEOF/9BdFj4W5m8cAmYCZQCSwH5jjn1rXa5m5gvHPuTjO7EbjWOXdDZ8+rcA9TXU1gXn7ZI3BgC2QNDZze4JybA8v9iUSZ5mbHsYamQNDXNVBTd/zykdrG4x8CdY0caXW5pjZw/Whd8L7aBhqauv6UiI+zlqDvlxRPUnwcSQmBr+TgV1JCHEnxcSQnxLfc13JbYui+0GPiW+5Lav34luc78f6khDgS4qzHPmB6MtynAz90zl0evP49AOfcv7XaZmFwmyVmlgDsBvJcJ0+ucD9FzU2w6U1Y8jCUvxuYlz/n5kDQ9y/2ujoRT9RrLWQaAAAEkUlEQVQ1Nh3/IOjggyH0YXC4toG6hmbqGpupb2qmrqGJ+qZm6hsDX3XB76Hb6hqbwvrwCEec0Srw4/nuFWO5fnL3zj8VbriH8/d9AVDR6nolMLWjbZxzjWZWDQwA9oVXrnQpLj5wCoOxVwXWb136cGDaZtmjwXDvYFTQ6Wihk/u6+7hOdfGLElb/pyee4zRfQyJGcvBrQNiP6OBnN4F209CFvpwL/FS4wI+Yw7X5Hrw9uN3J97mWH03nHAcPfRu4NeyquyOccG/v3Wj70x/ONpjZHcAdAEOHDg3jpaVd+RPhC/Phsh/CiifgwNYONuwkpDoNwQ7u6/IxYYR+l3+a9tFznPZrSNTpxge/0SM/TSfJLS7uhWc9UTjhXgm0Pk6+ENjZwTaVwWmZLOBA2ydyzs0H5kNgWqY7BUsrmfkw4/teVyEiESicfY2WA6PMrMTMkoAbgQVttlkAfCV4+Xrgr53Nt4uISO/qcuQenEOfCywksCvkE865tWZ2P7DCObcA+BXwjJmVERix39ibRYuISOfC2mHaOfc68Hqb237Q6nIt8Hc9W5qIiHSXDgETEfEhhbuIiA8p3EVEfEjhLiLiQwp3EREf8uyUv2ZWBZR38+G56NQGren9OJHej+P0XpzID+/HMOdcXlcbeRbup8PMVoRz4pxYoffjRHo/jtN7caJYej80LSMi4kMKdxERH4rWcJ/vdQERRu/HifR+HKf34kQx835E5Zy7iIh0LlpH7iIi0omoC3czm2VmG82szMy+63U9XjGzIjNbZGbrzWytmf2j1zVFAjOLN7NVZvYHr2vxmpllm9krZrYh+HMy3euavGJm3wr+nnxsZi+YWYrXNfW2qAr34GLd84ArgHHAHDMb521VnmkE7nPOnQFMA+6J4feitX8E1ntdRIR4CHjTOTcWmECMvi9mVgB8Ayh1zp1F4NTlvj8teVSFOzAFKHPObXHO1QMvAtd4XJMnnHO7nHMfBC8fIfCLW+BtVd4ys0LgKuBxr2vxmpllAhcSWGsB51y9c+6Qt1V5KgHoF1wpLpWTV5PznWgL9/YW647pQAMws2JgErDM20o895/Ad4BmrwuJAMOBKuDJ4DTV42aW5nVRXnDO7QAeBLYDu4Bq59yfvK2q90VbuIe1EHcsMbN04LfAN51zh72uxytmdjWw1zm30utaIkQCcA7wiHNuEnAUiMkelZn1J/AXfgmQD6SZ2U3eVtX7oi3cw1msO2aYWSKBYH/OOfeq1/V47HxgtpltIzBdN8PMnvW2JE9VApXOudBfc68QCPtYdBmw1TlX5ZxrAF4FzvO4pl4XbeEezmLdMcHMjMB86nrn3M+8rsdrzrnvOecKnXPFBH4u/uqc8/3orCPOud1AhZmNCd50KbDOw5K8tB2YZmapwd+bS4mB5nJYa6hGio4W6/a4LK+cD9wMfGRmHwZv+5fgerciAF8HngsOhLYAt3pcjyecc8vM7BXgAwJ7ma0iBo5U1RGqIiI+FG3TMiIiEgaFu4iIDyncRUR8SOEuIuJDCncRER9SuIuI+JDCXUTEhxTuIiI+9P8Bqdl6/28qUR8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(my_learner.recorder.losses[::batch_size]) #losses for each batch.  Take at end of epoch only\n",
    "plt.plot(my_learner.recorder.val_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python3 (fastai v1)",
   "language": "python",
   "name": "fastaiv1"
  },
  "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.0"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}