{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sheet 4 Tim Racs and Derrick Hines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import keras\n",
    "import keras.layers as layers\n",
    "from keras import backend as K\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task 4.1 and 4.2** Implement a TwoLayerNN and a stochastic gradient descent algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Activation function\n",
    "\n",
    "def ReLu(x):\n",
    "    return(max(0,x))\n",
    "\n",
    "vec_ReLu = np.vectorize(ReLu)\n",
    "\n",
    "\n",
    "## Derivative of ReLu\n",
    "\n",
    "def Heav(x):\n",
    "    return (1 * (x > 0))\n",
    "\n",
    "vec_Heav = np.vectorize(Heav)\n",
    "\n",
    "\n",
    "class TwoLayerNN():\n",
    "    '''Represents a fully-connected feed-forward two-layer neural network'''\n",
    "    \n",
    "    def __init__(self, d1, d2):\n",
    "        ''' Initializes'''\n",
    "        self.w = [np.random.uniform(-1,1,(d1,d2)), np.random.uniform(-1,1,d2)]\n",
    "        self.b = [np.random.uniform(-1,1,d2), np.random.uniform(-1,1)]\n",
    "        \n",
    "        self.d1 = d1\n",
    "        self.d2 = d2\n",
    "            \n",
    "        self.minibatch = None\n",
    "        self.data = None\n",
    "        \n",
    "        self.y_mini = None\n",
    "        self.y_data = None\n",
    "        \n",
    "        self.n = 0\n",
    "        self.K = 0\n",
    "        \n",
    "        self.f_mini = None\n",
    "        self.f_data = None\n",
    "        \n",
    "        self.grad_w = [None, None]\n",
    "        self.grad_b = [None, None] \n",
    "        \n",
    "       \n",
    "        self.net2_m = None\n",
    "        \n",
    "        self.o2_m = None\n",
    "        self.o3_m = None\n",
    "        \n",
    "            \n",
    "    \n",
    "    def set_batch(self,K):\n",
    "        '''Sets minibatch of size K to a random batch extracted from data '''\n",
    "        indices = np.random.choice(range(self.n), K, replace = False)\n",
    "        self.minibatch = self.data[indices]\n",
    "        self.y_mini =  self.y_data[indices]\n",
    "    \n",
    "    \n",
    "    def feedForward(self, zeta, batch = True, predict = False):\n",
    "        '''Calculates f for each observation of the data zeta'''\n",
    "         \n",
    "        net2 = lambda z: self.w[0].T.dot(z) + self.b[0].T\n",
    "        self.net2_m = np.apply_along_axis(net2, axis = 1, arr = zeta)\n",
    "        \n",
    "    \n",
    "        self.o2_m = vec_ReLu(self.net2_m)\n",
    "        \n",
    "        o3 = lambda z: self.w[1].T.dot(z) + self.b[1]\n",
    "        self.o3_m = np.apply_along_axis(o3, axis = 1, arr = self.o2_m)   ##o3 is the same as net3\n",
    "        \n",
    "    \n",
    "        if batch:\n",
    "            self.f_mini = self.o3_m\n",
    "        elif not predict:\n",
    "            self.f_data = self.o3_m\n",
    "        elif predict:\n",
    "            return  self.o3_m\n",
    "        \n",
    "        \n",
    "    def predict(self, dat):\n",
    "        '''Returns predicted output for dat'''\n",
    "        return(self.feedForward(dat, batch = False, predict = True))\n",
    "        \n",
    "        \n",
    "    def backprop(self):\n",
    "        '''Calculates stochastic gradient'''\n",
    "        \n",
    "        \n",
    "        delta_1 = 2*(self.f_mini - self.y_mini)\n",
    "        \n",
    "        aux = np.reshape(delta_1 , (-1,1))\n",
    "        \n",
    "        delta_0 = aux @ np.reshape(self.w[1], (1,-1))\n",
    "        \n",
    "        \n",
    "        self.grad_w[1] = np.dot(self.o2_m.T, delta_1 )  / self.K   # grad w(2)\n",
    "        \n",
    "        self.grad_b[1] = np.sum(delta_1) / self.K    # grad b(3)\n",
    "        \n",
    "        \n",
    "        \n",
    "        self.grad_w[0] = np.dot(self.minibatch.T, (delta_0 * vec_Heav(self.net2_m))) / self.K   # grad w(1)\n",
    "        \n",
    "        self.grad_b[0] = np.sum(np.transpose(delta_0 * vec_Heav(self.net2_m)), axis = 1) / self.K  # grad b(2)\n",
    "        \n",
    "\n",
    "    def update_weight_and_biases(self, ny): \n",
    "        '''Updates the weights and biases according to the learning rate ny and the current gradients'''\n",
    "        for l in range(2):\n",
    "            self.w[l] -= ny * self.grad_w[l]\n",
    "            self.b[l] -= ny * self.grad_b[l]\n",
    "        \n",
    "        \n",
    "\n",
    "        \n",
    "    def get_least_squares_error(self):\n",
    "        '''Returns the least-squares'''\n",
    "        self.feedForward(self.data, batch = False)\n",
    "        dist = self.f_data - self.y_data\n",
    "        error = (1/self.n) * np.dot(dist, dist)\n",
    "        return(error)\n",
    "        \n",
    "        \n",
    "        \n",
    "    def print_least_squares_error(self, step):\n",
    "        '''Prints least square error at the given step'''\n",
    "        error = self.get_least_squares_error()\n",
    "        print(\" The error at step \", str(step + 1), \" is \", str(error))\n",
    "        \n",
    "        \n",
    "    def get_f(self):\n",
    "        '''Returns current predicted f for batch'''\n",
    "        return(self.f)\n",
    "    \n",
    "    def get_f_data(self):\n",
    "        '''Returns the f predicted for the data used'''\n",
    "        return(self.f_data)\n",
    "        \n",
    "        \n",
    "    def get_w(self):\n",
    "        '''Returns weights'''\n",
    "        return(self.w)\n",
    "        \n",
    "    def get_b(self):\n",
    "        '''Returns biases'''\n",
    "        return(self.b)\n",
    "    \n",
    "    def initialize_param(self):\n",
    "        '''Initializes param'''\n",
    "        self.w = [np.random.uniform(-1,1,(self.d1,self.d2)), np.random.uniform(-1,1,self.d2)]\n",
    "        self.b = [np.random.uniform(-1,1,self.d2), np.random.uniform(-1,1)]\n",
    "        \n",
    "    \n",
    "    def smbgda(self, data,y,ny,K,S,output = False, every = 5000):\n",
    "        '''Performs stochastic gradient descent '''\n",
    "        self.data = data \n",
    "        self.y_data = y\n",
    "        self.n = data.shape[0]\n",
    "        self.K = K\n",
    "        \n",
    "        self.initialize_param()\n",
    "        \n",
    "        if output:\n",
    "            print(\"The errors for ny = \",ny, \" are \\n\")\n",
    "        \n",
    "        for s in range(S):\n",
    "            self.set_batch(K)\n",
    "            self.feedForward(self.minibatch)\n",
    "            self.backprop()\n",
    "            self.update_weight_and_biases(ny)\n",
    "            if output and not (s +1) % every: \n",
    "                self.print_least_squares_error(s)\n",
    "       \n",
    "        \n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task 4.3** Test your implementation: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate 250 uniformly distributed i.i.d. points which lie in $\\{ t \\in \\mathbb{R}^2 | \\| t \\|_2 \\leq 1 \\}$ (e.g. by drawing uniformly distributed points in $(− 1, 1 )^2$  until 50 of them are within the unit sphere) and label them by − 1.\n",
    "Now generate 250 data points, which are uniformly distributed in $\\{ t \\in \\mathbb{R}^2 | 1< \\| t \\|_2 \\leq 2 \\}$ \n",
    "and label them by 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_nonlin=np.random.uniform(-1,1,(250,2))\n",
    "bool_ind=np.linalg.norm(x_nonlin,axis=1)>1 #array of points not in the unit ball \n",
    "while np.any(bool_ind):\n",
    "    x_nonlin[bool_ind] = np.random.uniform(-1,1,(np.count_nonzero(bool_ind),2))\n",
    "    bool_ind=np.linalg.norm(x_nonlin,axis=1)>1\n",
    "x_nonlin_2=np.random.uniform(-2,2,(250,2))\n",
    "bool_ind=np.logical_or(np.linalg.norm(x_nonlin_2,axis=1)<=1 , np.linalg.norm(x_nonlin_2,axis=1)>2)\n",
    "while np.any(bool_ind):\n",
    "    x_nonlin_2[bool_ind]=np.random.uniform(-2,2,(np.count_nonzero(bool_ind),2))\n",
    "    bool_ind=np.logical_or(np.linalg.norm(x_nonlin_2,axis=1)<=1 , \n",
    "                           np.linalg.norm(x_nonlin_2,axis=1)>2)\n",
    "x_nonlin=np.append(x_nonlin,x_nonlin_2,axis=0)\n",
    "label_nonlin=np.append(-np.ones(250),np.ones(250))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use your two-Layer neural network with $d_2 = 20$ hidden layer neurons, $S = 50000$ iterations and $K = 20$ to classify the data. Try different learning rates v. Ouput the least squares error every 5000 iterations.\n",
    "After S iterations make a scatter plot of the data and draw the contour line of your learned classifier. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The errors for ny =  0.1  are \n",
      "\n",
      " The error at step  5000  is  0.28745445343111836\n",
      " The error at step  10000  is  0.23794402448292828\n",
      " The error at step  15000  is  0.2344417692512486\n",
      " The error at step  20000  is  0.21263147484438139\n",
      " The error at step  25000  is  0.21608357324971908\n",
      " The error at step  30000  is  0.21615068335049126\n",
      " The error at step  35000  is  0.21479611822343925\n",
      " The error at step  40000  is  0.19191562924160646\n",
      " The error at step  45000  is  0.16252309073550203\n",
      " The error at step  50000  is  0.1681184753656103\n",
      "The errors for ny =  0.01  are \n",
      "\n",
      " The error at step  5000  is  0.341003844764665\n",
      " The error at step  10000  is  0.308248809094142\n",
      " The error at step  15000  is  0.29638260978210357\n",
      " The error at step  20000  is  0.22186354233698305\n",
      " The error at step  25000  is  0.21781046858121447\n",
      " The error at step  30000  is  0.21766568470317008\n",
      " The error at step  35000  is  0.21351115626848607\n",
      " The error at step  40000  is  0.20983530792866273\n",
      " The error at step  45000  is  0.20696510757857092\n",
      " The error at step  50000  is  0.20409335579564192\n",
      "The errors for ny =  0.001  are \n",
      "\n",
      " The error at step  5000  is  0.2938039709471424\n",
      " The error at step  10000  is  0.2657747864949347\n",
      " The error at step  15000  is  0.25371074994377346\n",
      " The error at step  20000  is  0.24547873384331617\n",
      " The error at step  25000  is  0.37101392107424824\n",
      " The error at step  30000  is  0.36796599707225786\n",
      " The error at step  35000  is  0.35689968942611333\n",
      " The error at step  40000  is  0.34128871235008434\n",
      " The error at step  45000  is  0.3266227384360589\n",
      " The error at step  50000  is  0.3246721732291408\n",
      "The errors for ny =  0.0001  are \n",
      "\n",
      " The error at step  5000  is  0.7977498283149976\n",
      " The error at step  10000  is  0.5495294416302551\n",
      " The error at step  15000  is  0.42725005185898357\n",
      " The error at step  20000  is  0.35990261571721877\n",
      " The error at step  25000  is  0.32248069360710163\n",
      " The error at step  30000  is  0.3008330021675112\n",
      " The error at step  35000  is  0.28727463545142623\n",
      " The error at step  40000  is  0.27860448146058164\n",
      " The error at step  45000  is  0.27296596081360797\n",
      " The error at step  50000  is  0.26894126671768914\n"
     ]
    }
   ],
   "source": [
    "S = 50000\n",
    "k = 20\n",
    "V = (0.1,0.01,0.001, 0.0001)\n",
    "\n",
    "network = TwoLayerNN(2,20)\n",
    "\n",
    "for v in V:\n",
    "    network.smbgda(x_nonlin,label_nonlin, v,k,S, output = True)\n",
    "    \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The errors for ny =  0.01  are \n",
      "\n",
      " The error at step  5000  is  0.2478499983066276\n",
      " The error at step  10000  is  0.2326878461431114\n",
      " The error at step  15000  is  0.23179012043054617\n",
      " The error at step  20000  is  0.23518831565595522\n",
      " The error at step  25000  is  0.22855086052954204\n",
      " The error at step  30000  is  0.2300081269657588\n",
      " The error at step  35000  is  0.23293846806033938\n",
      " The error at step  40000  is  0.2350567158679421\n",
      " The error at step  45000  is  0.22606759822885888\n",
      " The error at step  50000  is  0.2273287592366492\n"
     ]
    }
   ],
   "source": [
    "v_opt = 0.01\n",
    "network.smbgda(x_nonlin,label_nonlin, v_opt,k,S, output = True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "def set_f(netw):\n",
    "    def f(vec):\n",
    "        return(netw.feedForward(np.reshape(np.asarray(vec), (1,-1)), batch = False, predict = True))\n",
    "    return f\n",
    "\n",
    "f = set_f(network)\n",
    "xmin,ymin = np.amin(x_nonlin,axis = 0)\n",
    "xmax,ymax = np.amax(x_nonlin,axis = 0)\n",
    "xx,yy = np.meshgrid(np.arange(xmin - 1, xmax + 1, 0.05),\n",
    "                    np.arange(ymin - 1, ymax + 1, 0.05))\n",
    "zz=np.apply_along_axis(f,1,np.array([xx.flatten(),yy.flatten()]).T).reshape(xx.shape)\n",
    "plt.contourf(xx,yy,zz,0, colors = ['cyan', 'pink'])\n",
    "\n",
    "plt.plot(x_nonlin[0:250, 0], x_nonlin[0:250, 1], 'ro', label = \"Class -1\")\n",
    "                \n",
    "plt.plot(x_nonlin[250:500, 0], x_nonlin[250:500, 1], 'bo', label = \"Class 1\")\n",
    "      \n",
    "plt.legend(loc = \"best\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do you observe? \n",
    "The neural network has identified the points in the respective groups. The answer really varies, sometimes points with greater radius can fall into any of the two groups. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if you increase S?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The errors for ny =  0.01  are \n",
      "\n",
      " The error at step  5000  is  0.21854532400139917\n",
      " The error at step  10000  is  0.21485255593168556\n",
      " The error at step  15000  is  0.2112483175744719\n",
      " The error at step  20000  is  0.20577738816275484\n",
      " The error at step  25000  is  0.20426625553765843\n",
      " The error at step  30000  is  0.2046170933243118\n",
      " The error at step  35000  is  0.20620817967118124\n",
      " The error at step  40000  is  0.20420158809656477\n",
      " The error at step  45000  is  0.1975404080139287\n",
      " The error at step  50000  is  0.19891912382558424\n",
      " The error at step  55000  is  0.20074703273268366\n",
      " The error at step  60000  is  0.19853036959649897\n",
      " The error at step  65000  is  0.19816274378625823\n",
      " The error at step  70000  is  0.20480040446655248\n",
      " The error at step  75000  is  0.1968375198006726\n",
      " The error at step  80000  is  0.20457831080146696\n",
      " The error at step  85000  is  0.19410010852853893\n",
      " The error at step  90000  is  0.20177805055088818\n",
      " The error at step  95000  is  0.18947096736314473\n",
      " The error at step  100000  is  0.1898401043730784\n"
     ]
    }
   ],
   "source": [
    "S2 = 100000\n",
    "\n",
    "network2 = TwoLayerNN(2,20)\n",
    "network2.smbgda(x_nonlin,label_nonlin, v_opt,k,S2, output = True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD8CAYAAABjAo9vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztnX18HFd5739nVytZku0kWlk2xNZKFAgvIQTihKRuGhPiYtyQQLkNVWUj7DjCNrhqCrckFi3Qsg582tvU14njKiFGsRY36W0hIbhpTUnCayg2NyFACuTGWtkGLGvVRLZX1svuuX/Mznpm9pyZMy/7otHz/SOOVrNnzqxmnznn97wxzjkIgiCI8BCp9gQIgiCIYCHDThAEETLIsBMEQYQMMuwEQRAhgww7QRBEyCDDThAEETLIsBMEQYQMMuwEQRAhgww7QRBEyKirxklbL7iQdyx7dTVOTRAEMWc58osXxjjnS5yOq4ph71j2ahweeKgapyYIgpizsNVXplWOIymGIAgiZJBhJwiCCBlk2AmCIEJGVTR2giDmHzMMON4Uxbkoq/ZUap4FOY7l2RxiHquqk2EnCKIiHG+KYtHSNnRccAEYI+Mug3OOzCuv4PjJUXSezXkag6QYgiAqwrkoQ5yMuiOMaZ+Tn50NGXaCICoGGXU1/H5OZNgJgiBCBhl2giDmDb85eRJ/9OEe/NZlb8GbrrwC6z7wB/jFL3+J4XQal77jyorMof+vPoMVb7wEC1+1tGznIMNOEERt8sjDwJvfCFywSPv3kYd9Dcc5x/v/uAurr70W/+/Hz+NnPzyCnZ/+DE6eGg1owmq8d+06/OeTT5f1HGTYCYKoPR55GNj+MeDYMYBz7d/tH/Nl3J/81tOIxeqw5dbNxdcuv+wyXPvbq0zHDafTuPbda/D2a1fh7deuwvd+8AwA4Ne/+Q1+d+3v4fJV1+DSd1yJb3/vu8jlcvjwlo/g0ndcibdcfRXuvucex3lcfdVVeNWyZZ6vQwUKdyQIovb47GeAyUnza5OT2uu3fNDTkD/52c9wxeVvczyubckSHHr0a1iwYAF++eKL6Lp1Iw4//W18+Z8ewbvfdQP6/+efI5fLIZvN4tkf/xgnfv0r/OQHPwQAvPzyy57mFjRk2AmCqD2OH3f3eoDMzMzgY5/4OJ59/seIRqP4xYsvAgCufPvbsWnbNszMzOB9N74Xl192GV7T0YGXjg5j+yc+jt9/91r83rveVfb5qUBSDEEQtcfy5e5eV+DNb3wjjjz7fx2Pu/vee7C0rQ3Pfe8ZHH7625iengYA/O6q38G3nvg3XPzqV2ND72Y89OUv46KLLsJz3/s+Vl97Le69fwCbP/ZR01i5XA6Xr7oGl6+6Bn/5ub/2PHe3kGEnCKL2+PRngMZG82uNjdrrHrn+utWYmprG/V/aV3zth0eO4OnvfNt03CsTE3jVsmWIRCLY/48HkMtp2Z/pkRG0LVmC2z68Ebdu6MGPnnsWY5kx5PN5fODm9+GvP/UX+NFzz5rGikajePa738ez3/0+/upTf+F57m4hw04QRO1xyweB3fcAK1YAjGn/7r7Hs74OaEk/X/nyARx68pv4rcvegjdftRKfuWsnXr3sVabjtm2+DYNfTuHq69+JX7z4IpqbmwEAT33727h81TV42+/8Nv75sa+ib+s2nPjVr7H699+Dy1ddgw9v/Qju+vRnHefx53/xKSx/w+uRzWax/A2vx2d2Jj1fk/RaOfdYZcYHKy95E6dGGwQxv3hhcR3e+NrXVXsac4YXXvwl3jgxa3qNrb7yCOd8pdN7acVOEAQRMsiwEwRBhAwy7ARBECGDDDtBEETIIMNOEAQRMsiwEwRBhAwy7ARBzBuqUbb3W9/9Dt5+7SrUXXQB/s9Xv1KWc1ghw04QRE2SeiSKjjc3InJBEzre3IjUI1Ff41WrbG/78hX40n3/gD/+w1vKeh4jZNgJgqg5Uo9E0bu9AeljEXDOkD4WQe/2Bl/GvVplezsSCVx26aWIRCpnbqm6I0EQNUf/Z+uRnTT3/cxOMvR/th7dt0xK3mUPle0lCIKoIiPHxc2cZa8HCZXtJQiCKAPty8U1rGSvq1CNsr3Vggw7QRA1R/LT02hqNBvxpkaO5KenPY9ZjbK91cK3YWeMrWCMPckYe4Ex9lPGWF8QEyMIYv7SfUsOA7unkFiRB2MciRV5DOyeQvctOc9jVqts7w+PHMHyN7we//TVr+AjfX1481WOxRl947tsL2PsVQBexTn/EWNsEYAjAN7HOf+Z7D1Utpcg5h9UttcdVS3byzn/Nef8R4X/Pw3gBQAX+x2XIGqB1KEWdHzwLYi88wp0fPAtSB1qqfaUCMKRQKNiGGMdAN4G4AeC3/UC6AWA9qXLgjwtQZSF1KEW9P5tAtkpLXY6fbIBvX+bAAB0rxmv5tQIwpbAnKeMsYUA/hnAn3LOJ6y/55wPcM5Xcs5XLrngoqBOSxBlo/+Bi4tGXSc7FUX/A7Qh9Uo1OrbNRfx+ToEYdsZYDJpRT3HO/yWIMQmi2oyM1rt6vRyESQpakOPIvPIKGXcHONc+pwU575+TbymGMcYAfBHAC5zzv/M7HkHUCu1t00ifbBC+Xi5Sh1rQ/8DFGBmtR8uiWZzORjE9q62/5roUtDybw/GTozg1dqraU6l5FuQ4lme9RwAFobGvArABwPOMMT2Icwfn/GAAYxNE1UhuPmHS2AGgqSGH5OYTZTmfVdPPTMRKjtGloLlo2GMc6Dzr3VgR6vg27Jzz7wAof54vQViwrm4BYPx0HdrbppHcfMK38dPfr58jqHFliDR9EZWUgoi5CdWKIeYkdqvbICWL7jXjFVsdqxps/SFGEDKopAAxJ3Fa3c7F6JVyavfE/IIMO1Fxgoj0UFnd1rpkYf0c1l39MpoanDXo8dO00SbsIcNOVBRdQkmfbNAaKBRkE7fGXWV1azym1sIGRZ/D4BOt6Fk7hsTSKTDGEY1IKhzSyp5wgAw7UVGCSvpJbj5hu7o1Rq8E9TAJEtnnMPC1NiQ3n0D+ySMYvPNoyTWWMyqHCA+0pyMqip+kH2MUTHvbNHrWjuHgMxdKo2IAoOODb0H6ZD2sgVvZqSj6dq+oWtig7HpzeVbi+K1UVA4RHsiwz0OsBtKLsfA6htekH1HdlsEnWjHwibTwvNbjRWQm6pA61FIVQyn7HABzrHolo3KI8EBSzDwjCFnCzxgiCUVFXnAr4ajFhDPT+yupwztJSbXu+CVqGzLs84wgNG63YxgNZv8DF5schImlU9JVtxG3Eo6qYdSPq7QO371mHAOfSJODlCgLZNjnGUEUtnIzhiz6Q3cQDj/8vLKEE8TrViLsvKxU6UqO3WvGK+4grbXoIKI8kGGfZ/g1hG7HKGcUjJ0BFEsdpatj3VmpOVhLKbckoq/c3e5gvFCL0UFEeSDDPs/wqnF7HSOo0rduDaDo+K03jwqlj+xUFFHJN6FckohVnnK7g1Ed27gqp/ry8weKipln6Eajb/cKZCa0P39jQ97TGCpRMUGWvnUbISI6fu9jbcJjc3nt4VSJSo7l7MxkN3YQD9kgIqqI8kMr9nnK5FQEWmw3Q2Yi5npL3r1mHMMPPy9cZRpXjGcmI4hFzQ+OaibZyB4oiaXTJSv8nrVj6H/g4sD16HKunO3G9ivDkZQzdyDDPg/xE9XiZOCsX/7MRAyMAfHFM2XXkFWwk5GMD6vk5hMYfKK1LEasnJ2Z7Mb2K8ORlDN3IMM+D/Eb1WJn4ERf/unZCBY25gPTkP2gqtWX04gF4cD2Mrb12uOLZ9DYkMeGnZ1KO5JaaBVIqEGGfR5SzqiWufDlt5ORdMp5HUE4sN2MDXCcmYwUs2yHH34e+3ccxeRUBJmJmPKORHbfcA4KnawxyLDPQazSyA1/9jrUXX8F2OorUHf9Fdh29wrb95czqqWcq9FKEsR1yCQsryGOKpKYPnZ88QzOh3eW+lG87Ejk2bKkt9caZNjnGCJp5D9+tBi5vOYIzeUZ7nu0zda4uzEsbg1cOVejlcTvdThJWCq7BjfjGeleM46FjXmICp/phlv2YE6frJc+PIz3jSgngPT22oEM+xxDXAPF2nKWYeBrbbYrPOOWHIBUZ3Vr4CqZcFNOuteMo2ftWCHuXauN3rN2TPk6gtboZeP17RY/wJ12WrIHMwNsHx76fcMkXY5rSXKbz5Bhn2OofnFyeTiu8FRWgSqG2voAAeBqNVqLpA61YPCJVtNOaPCJVmWpIWiNXvY+vUKlFaedluiBzcDBbVb5bsYnqgsZ9jmGmy+O04pRdVXpFLMexthmvyvuoA2f/H1MOCennZbogS0uRyZ+qIRFcgsrZNjnGGo1UGRfUfOXNIhVZbljm6tVtMrvZxO04dPeJ/67iuakstOyPrATS9UfRmGR3MIKlRSYY4jS+V978Tl880eLi1/7hY15NMTyyEzESt5v/JIGke5fzrBAP6n37LqV0t/xpw87nrtl0azw89M7NTkRdPej7jXjhTIQpXPSK1Rax3ZbgiG5+URJcxInf0qlGrQQ7mCcy1d35WLlJW/ihwceqvh5w4qoW1BdNI/ZnKYP69TX5bGoKVdsH7fu6pcx+ERryRfZzcpLaz1X+nBILJ3C8MPPe78om7Hji2cw9thzwvfYGXRXtALIlL4cYRwP7ThaFWNk1xXK7d/N7hzlMryi+Qc17/kCW33lEc65401Ohj0EyAygmfMxzTpNDTlT31AvX+Rtd6/A3kfbTE63oL6skXdeAc5F4RccQ/3njWtgxtx0csgVrSYAAwC61Vb/QZI61IKeuzoLTl0zQTxMy0k5FwHzBVXDThp7DSPTl62vy2qJmzGv3gFNCz/4zIWeI1j0yBGjUWdwFxZoh5PDkF23sjxGHQDspPwsgP7CTMo5BwHda8aRlzxwKhFqqOLzkB0zF7KSw0IgGjtj7EEANwIY5ZxfGsSY8x2ZvvzdnzSb5JP0yYZCmJo31B4KYkSOUw6Gg89cCOCY53F1kptPYH2yE6Vx+kB61GmHUmbS0JZFBbvGxlcC7cDQ+pfKLisEWQrZDSo+D7tjqjXv+UhQK/YvAVgb0FgE5NEmA19rExpT5tG0yxpMqGCXvRhE9Er3mnHEF0ucle2+h7cno/B5cmg6fKbw/2lg/d2vATte3hW8l4ibIKKLVCKg7I6hEMnKEYhh55x/CwB5PwJEZjRzkp4YHDBV7bPWQJchG08FO6kkqFj2zJ6YpmkbaQKQBJAC0AHtLu4o/BwAXakUVjCPO46CTFNOecZtqGFQuQYqUordMRQiWTlIY69RZEZTtsJOLJ0uauVjjz2HfXcMmwy9zBMoi11WQV4Uyn8se1G77obmqExAU2QShZ8BoBeaJFJYLaMXuGbbd3C0owO5SARHOzrQlXJv7Xf19eEufgeacNbyGw67HIHi3NN5dKVSZdXf3dSaCSrXQCXpyukYtzVyCG9UzLAzxnoZY4cZY4dPvfLflTrtnEW2be1976jSdtb4BRp77DlsvXm0RK7xuw3WV2BuEmecJAGhMewGMAwgX/i3G5rzMmsZPAsc39uOjnQaEc7RkU7j/t5eV8a9K5VCayaDbhzAAG5DAsNgyCOBYQyhGwmkHcdox4jpvJV2sFoJymmpIqWQ3FIbBBbuyBjrAPC4ivOUwh3VkMUUe401LleMcutNbxUmzljjzUVxzAwcW24exX1fXerupJJwRIY88jCvTocTCXQODzsO2ZVKYf+HPoRoXq5PpdCFXtyPLJqFv2/CWQzgNnTjgPS8QYRIuvlbBhlmqHJeSkIqHxWPYyfDPn9RNezSeHsGYD+0lbgqHYBo8ZzAMIbRaXotz5jUWHelUtjZ34/2dFoQEComhS70YydG0I6WQhbTOOJoxwiS2IFuHHA8rx/j7jbRhxKDwkNF49gZYwcAfB/AJYyx44yxW4MYl1CPZqhWTRUAGD8tjpq1vi7d+nMU48KVSaLEqdrIskhiR8mhI+3iEJquVAr39/Zq0g3UjDoAbTWOTuQRxRjaMIY25BHFMDqLRt3uvIBYnlH9G7rVzFWdltW8h4hgCSSOnXPeFcQ4hBnVWil+aqoEgWp8suw4AMCIu3N2IYWrGn+Au7N/hmNoR2M8i7fe8izeN/ioSXs/29SEHcmkcIyd/f1ozlqFem/kGUPEsPu1O68R3bgPfeol5b+hF83cqa5Lte8hIlgoKqaGUV2ZVbt7vJPDTF+dpv9Xg3RZ3NRyRvl8+kr7TzO7kS6snEcnl6JjVRr7enowG42CA5iNRrGvpwcHusUaT/uIy6dJgbyly8TZpibs2bIFw4kE8oxhOJHAvp4e7Ozvl0bndKVSpuid3r2l+Qlea6F7WXlX+h6i3UF5IcNewzi1L6tEqrabPpvWrf76z73GLDd0A9gCWL2eTTiL3RPblaNXRCvt5mwWu/r6sHFwEHW5HBiAulwOmx94AKOtrUIDayeVyOAAwDlmo1EtSCeRwG0DA9i+Zw86h4exfv9+tIyN4aP33SeNzjFJQIXfT2aswfqFObqshe41Zr2S6f5hreFfS5Bhr2HsEoCMXwYvTR10g603wGarSw232z6benhl+jcNWP+514hPvAe4O95nCiMcwG3YNPMl7OxXE9plK+3WTKbE4C+YmcGSTEZoYHckkzjbZDaoHPbR6gzal6Yul8NkQW7RdwRdqRT2bdqExWfPlmxM9AcPIH4wtUu0KLe10L2uvCvZEclpjrSa9w8Z9jLj5ya1SwACvKdqGw223vZN1GnerZFQjdf+k/F7is5Ho8NRVRrxstLWac5miw+QA93duG1gwCShdA8NIcI5uoeGMBstLY8rGwvQDHbDtNwQtmYy6EqlhNeZxI7ShKgmaPKVAFGiT+pQi7T2j9PKW/UeCsLo2u0OaDUfDFS2t4x4DTPbdvcKDHytDbm8tkJsbszjzKQsboODsfMNIPRa617imnX0+GZZ2VzGOPJPHjn/s4IxL4YVjowgH4mgLlf6wHITb35/b69p1Xu2qQk5xrD4rDVbtBQOoHtoSKq96+QiEZND1GksleOHE5pDsiNdGqv59/HtuH3h/9Ycye3QIn8MU+RPH7bNbZDVagfUYtad4s9l97Pb0s92cfUAqLSvDVS2twbwsi3edvcK3PdoW3EVzcFwZjKC5gWylTsD5wyZiRgmpyLYv+OoY6q20+rNqZO9/rrqCt2qKdflciVSh1MUSVcqhdHWVuQZQ2r9euQYw6l4vLjSvm1gAFMLFjjOBdAej6KMVKtDM9PivEo0jqWyk2gfGRFKQGebmvCfu95RzLDtSqZwtN9cGoEdXyldzYruNR3VzE+ndH/Z/bz30TZXK2y73QGV9g0GWrGXEdUVr5G6668QNlGIMI4F9Xnpl1dHZWWjumKXrdCyX4y6SiY62tEhXKHORqOI5PMYaW83adVWdO3aKnOci8Wwad++4vtUVsxGTsXjOLtwIdpHRpBpacHi06dN5zgXi4ExZiuv6AwnEtiRTArnaT1n29iYaQdjvX7ZjqSt8SSymYUlYyaWTmFktF6pKYkf5I1PSnG6D2W7A9m9GY1w5DnmfSYrdVCqAbykcrPVV0AmuQz1Hy1+GbQ/m7uHho6bFmv6FzA92iCUB1SQGVy7zEwjsgcDYJZvZMdxyD5R56SknCE+/fTChVh05ox0rO6hIQBaEbHWTEZ4nG7Y7ZBdRwQ5cMEmmzEuzRGw3msigwrY92Yt3gMn66GaxqVyH4oQ35vmv9R8zpolKaYG8FIQSVa9MRrRtsrJzSdsIxU4h6NTyxhVAXBEI1ociKyTffo3DVrKPwBsgOsSuTKJIh+JKIU42jlV9d91pVJoPnNGKPGcbhbXdVExUVHOi6UGovk8xuJx6Vj39/YCANrGxsCZePT4uLMxkl3vClnkDDuO5NVfd7zXRI7JTV/owMbPd0ilFKujvRTxwtBrNI014ke7N0s7f1UqR2OuQoa9jMjC0gBIIwt63zuK0i8LR+97RxW+ZIAoukU2t+GHnwd/6ghmv3kE/CmxrsquW6kZcUGJXFXjLtKUAS1kUKX6op12PdLeXpQulhhWyRzaTqExm0Xz5KTaRB3QpRHRtei/16NkZHNW0eFlx9we/7uSMgpNOItk/pN436ENGFj7qG3ZAJFGPj0bwUzObAaMhtNOuwc0ibC+zrzrCqJqqK71V7MN4FyGDHuZsTqkANiGc+25/Ri23jxaXEVHIxxbbx7FntuP2XzJSu9+t6saURhb0TEqKZGrWt9FDysUhQ9aQwZFPL5unXBdOB2JYEcyKYwL11fYkcK/QREfH8e+nh5pnLu+2pY5SEUOYqvT9vF166TO1Wt6voN2Sw5ANw6gOZvFqmf/DOnfNEidn26MoX6s03vyPILZHEN88UxZmmdUMr4+TJDGXmH8lFCVO6/EarGqzinUNZugNbTohrRELhi0GumKeNXa7bTzdCKB9kIRL7dYP7VzsRgaZmZsJRq7cEX997rmb+cg1ZE5Svf19ODGgwdL3mvnb7B+jtYKkk5OcyN6ZU7V95RL96bKlGZIY69R7MoEGBGtoN12VVJd1Qh3AsYVuUw9cJkn5FWekGnODAUDK9GznWDQInP0kMlN+/YhXTDcIvQVt2w+HDCtyA90d6NzeBjRfB6dw8PCqB9ZeYQbDx4UvtfO36DLT8XwSEsoqjjhzX5h55Qkp1Mu3Zva6XmDDHuFkRlbBggdVrpcsyHZifTJemEXpNWXT/jqjiTdbus2RFAit9h31IBVUrBq5zuSSZyLmeu2n4vFsCOZNL13tLXVVN/FKZ48wnlJYS5VIvm8yXjKygyciseLhb2YzS53Z3+/0Gcg+2xkhlr2ut1DMMp5SekEo3EXGUkZesllq6Pdrml6uXRvaqfnHjLsFSa5+YTwy8HBbB1WemwGByu8X/ti9qwdw/d/urDwew0Gjp61Y8pfAOnKXrchlr6jTfEzuLvxT5DbcN5IiQpbiRyjzGKAG2ZmsPcjH8GDGzcW37skkzHVd1l8+nTJA6EEzoulAU7F45iqVzMymZYWk8EFICwz0LdrFzYODqKj0JBDhL6DsF633WfjdhezI5lU6Lpq9l1YjbvRSMp63rYsmi3uGPWyFfypI9jff7Tg/ymFdO/agTT2KiCLVdc1cZVEEF2Tl2mg8cUzWNiYV0rzlsa1xwHsgiluXaYJZxsbsSSTKRlbJc5cBT2ZKCExrNZyBLq+LTseECcgnW1qwm0DAyWyyWhrq/D6ZLHwKtetJzWJPk/jHKxafUsmg8VnnMscGzV3Wccm0d++vi4PzmGKljHq2qL3xKJ5LG7OKZW0ILxDGnsNI1sl6SselZWPU9RCZqJOOc272JTaGqKdQUlYo0wTbhUYPcAsKXitfw5oBbRaxsZw79atStEmuqwigwOYrq8vyRI1VmHU0Rtcu6F9ZKQovyQkD7NEOo2hDRuQbWwsKY9gzUI1rvYXZLNKq3bjql9W+kEkzyxqytmGQFrfo0XEAJmJWMn9RpUaqwOt2KuAk6ffqaAT4Lxit3uPDNazUthHFAloNUzgPm0/qBW7zkw0in/o7RVGjBjpSqUw2NODmKDYmI5dRuq9W7cWzyErWgZozlfR707F42ianFTu0CTbKXj9zGTjqfRadVsKw27XODkV8RXRQo2xzdCKvYZx8vQ7OayMjlE3kQ6Ozi3ZgtrwupuSuXnG8Pi6dcWfZYlKbojlctKIESO7+vpsjTpgl+IFbNu711S0TAQHsLe3V7iDAOCq7Z4snt/NLocDwlW/EZWibW5jx+12japF8EQreyrh6x0y7FXCydNvzAzd33/U9iHQs3bMYvzFJstR4lEIa9yRTCo7JiOcY+PgYNGRqCcqnYrHSx49U/X1mhwB59B4FWPnVjqxorIrGYvHsX3PnhJn676eHun57Zp4GK9Ll3HsInCspBMJ24edjpNxd1sKw63T1PogkBnwvt0rqtrycS5Dhn0O4PQQOPjMhaaoGBFO4Y/supXKYY0Rh5WwEetK9EB3N9rGxtA9NGQyhhsffBBtY2MYSSQcb0rGuTCcspLoUTq5SAQ7+/uxI5lENJ/HjmQSGwcHpX+NnE3zDn03ZNTVReOci8VKHq66n8Ep5FQFt7HjsgdBfPGs8Hjrg0BWDjgzUSd8v/HBkDrUgtab3gq2WusC1nrTW2lFD0D8yRFzCrnEojXhUNYm9UVeP0qaPahEmchoT6dxtKOjRBMXrSpVVuPGsEIAwnFONzdLm26oVHW0g0ML29SjZIxz2dXXJ5VgOCCVdabq64vOXpGDWn9/uhBJox9n/EwBmCJs7D4jdt1KW729e8247f1i1b5FzTYACH1J1gWG2/h3Y9PujZ/vMDl6MxMx9OzsKF7DfIWcpyHATZkCO2eUbIsuCnF0Q95Q+haQO/YA96V3RV2XZPXb7ebkxtjbOUxl5XqdxjeW85U5qJ06P9mFVco6U6k4U624SfNXcX56db7aBQ7oJRHCBjlP5xGyrfC6q182OaS23b1CzRmVglaaN6L9e1XfD5SNujUD1GpAAfvCXyIHq11WqbFsry5BPNTT49wcw5DQNJxISHXv0jqbQFSy6pYZdRWM5XxlmbYMsC2YJs1i9RmJZMVNZzCVrFHZ/btr+zFbSchupS+TceYLZNhDgEgT7Vk7hsEnWk1GfO+jbbZfSP70YWGJ3v7MXUihy3Ee52IxHLr+esxGo+DQVrYy55/MCB3o7sa+nh6TMY9wLq1vbizb6xTFYiQfjRZ18c7hYYxIasRYz8qg1ZF3i5PBV402ak+npTq6dAzGpFq7SpRMyVwDbl9np+nbPRgo01UOSTEhxU18uzE+WRbLnsAwhtEpfD+HFiHy8C23YOPgoGl1L1qxA5rR/9DgoCs5xjrWTF0dIrkcItzJdSzGKAm5kZtEyU122bdu5gEUujbZnBswPyj09wPA0IYNws87SDnGT4XSIEkdasH6ZCfsOo6FTWcnKSakWON9t929QpjZ52b11LLIEL0g8V2OSGIh9WSetrEx3HjwYIlhlBXosmuyIXWgGuSTiYULUTc7W+xw5IRo+WKUhPRQzOFEAnnJ8ToMwMSiRabaNNnGRsQzGdfFyHKMFY3y0Y4O5BizvR69m5PoOg50dwMud0he8NIZrBxScNN0AAAgAElEQVR0rxnH1ptFjWkAGGovzUfIsM8hRPG+90k6xMu3qaVfgtPZaPGBkGgTV/xrt1h8XWq5d+tWbN+zRzvGxiC7abIhLYxVWHVG83k0TU46GnRjSV5p7LhhZ6CX2c3E445jx8fH0Tk8jPX796NpclIrWoaCbOTwXiMRzvHb3/3ueSkJ3iJ29M9eJim5SSzTkZUDqEYpXdlc9tx+TPqe+dxlKRDDzhhbyxj7OWPsRcbYHUGMGWZkN6lTXQ1xByVxP0jZqmphY2n6z/RspLi6SW4+IW6/hh2m19KJBGKzs0WjDsiNB4Pc4Sh6GDh1H+pKpaTjGY/f29uLkfZ2rSyALH5coD+rJDfpsfSi8EY3hpkB2DIw4DniSEf/7GVlh1ccO4YcY+c1eYOD3Jjpqd9/rTe9FZu+IO+FWslSuk4ZqE61l+Yjvg07YywK4F4A7wHwJgBdjLE3+R03rMhuUpWIFdUVyMhovXRVdfac+E+uj929ZhxDt79kKtG7O/YxdONA8VhrqQCdHcmkUIoQyQfF81oeBnq8fGM2q624AVOKvK6F2xlPDmBfT0+xzK7uUBWtpCOcO7bmE6HH0qtmuNplnDo9pFTGNhY8yzY2ms5nbBPYkU7jho3fQHTTbNFBnj7ZgI2f7zAZ8sxEDNOz8kJglcQpCmfd1S/76kcQRnw7Txlj1wD4DOf83YWf7wQAzvldsvfMZ+epzPEUjXDk8qXmylh+N8IgPMaKnRNL1fFljJbYvW0btu3dqxSLbuf4syIqT+tUwlalKNapeBwXvfyyUnQMUBof7rZErwrDiQRWHDsmbAHoN2FqcsECNE1OKjuAO3AUaXR4Opdqu0URXgt62RUl27/jaElMPQPHlkKf4LBRSefpxQCMn+DxwmvmCTHWyxg7zBg7fOqV/w7gtHMT2ao7JymQYiy/qxl1UWT1eZxWKq4cX4Xt+p/cdw9ew18yhTxK9XGb1nLWWVsfDLKSwMbzODkBpyMRLD59WtmoA5pRNTpy+3btEnZ68roEmqmrQ/OZM4hI+rpyQLn+joiGKc0vIstYtSJzhKvgVd7wU9BLds6WRbPouatT2JTm4DMXeppnWAjCsMsS7cwvcD7AOV/JOV+55IKLAjjt3MRt31JxJLW20Y4vnsHWm0dtnVhW3R6AkuNr6FMvFePZOSJIowO9uN9k3FX1cRHpRKJkta/SJs7JCRjL522Tk2TG2Rohs2nfPlMC0wObN8t1eoex62ZnscQmeSkTj8O6c3bzENE/E9XIF6sjXBU/8oadnOLkWxItRurr8pg4G5XuYOez4xQIxrAfB7DC8PNyAL8KYNxQIlsx97531EWjYU21npyKYNWlZ6VOLNkqCYCj46v/gYu1htYGsmhGP3YWfxYZWVPYYCEU0Lr6FTXGkI1nfd3pweEkaYj2PDpGw2hsRK0X9nKzC1Cdk34tC2ZmlN9jfb/+WapGvvxl7LOI1psLdMWiedTX5Ute05po+I98sWvi7rSSV20GYmQ+O06BYAz7DwG8jjHWyRirB/BHAB4LYNxQInNq7rm9NH3aCSdnlpvUbyvS7MLCNl5mnAGzUWwbGytZ/crqxDhFw+hj6w8Or9KIqiNXR0Xi4ABOL1yoPAeO805hYzkBJ87FYsJuS12pFJrPnCn5TPKMIQ+YHNHf2HcDcg/WFR3kSAD77hjGg58cNt1/++4Yxq7tx9DeNo30yXr03NUJttpbJyS7narKPWqNwtGbbYuY745TIKDMU8bYOgB/DyAK4EHOubwnGea381SGyLHUt3sFMhP2TZztnFluO+EYkTlZ2zGMpxOrhV2LgsDa39PuPG4LhtlhV5hMpWvUqbjWV1A189RtZyljZUdRtyir01TPBu7btUvp7yTKPrXr5OWlE5KocFh2Shy573SP2gUhDN4ZvoxTnYpmnnLOD3LOX885/y0nox52vPR4lEkmt7xzvGR7bMVuy+m2E44RYWemJmBkqKOkkYPfGuDG9xtrmzs1jJCt8FVR6TjUlUo51oY529SEvl27lFfeecZMuxC/naVEOwoG4OzChb4evuK8CQ23oY+ynarXGHSZpBlmo+4GyjwNEK+ef5lkcvCZC4vbY6cWecY56A+WsVeiEEXRrLv6ZcdrMbXnK2zXMYDzNdsLiJotD23YYE6GsUH0/n2bNmG0tdX0oBA9PKx6vm6g04qROQBsHyB6+V87bV2PmT/Q3a2kcecBnGlqwtCGDeLrgLiapbEGvfUzlVVv9FLV0di4In3S3gHp1kEpSmryWp6gGtmvcwkqAhYgXosjqUomTnHAKk2wVeZTMg+bCoBOMoKdxKHyfkALYeR1dSVFt2Tj7t62DR+97z5HOYbDvgWeLJ7dirEI14MbN5Y4QvUznG5uRsPMjON1ODU1sRb0mqmrEz58ZqNRxGbFXYys8KcPCxtX2BFU0S9qWK2OqhRDhj1AvGjaqUMt6LmrUxi2lVg6heTmE8o3vWpFRy9JJjLjrqI/21UWVHm/23FVHhaAubmFzu5t27BlYKCYDaqq1etzsXsYyCpdyq5D9tnkGTMlOsmSwvIAoi4+28SyKeWKoG41dh0y4v6g6o5VwK2mra+wRUZdb5ThRtpR3RoHGQqmIj8k0mnMRqN4ZeFC9RriCqjEvcs4F4uhb9cu02tP3HADPnrffajL5WzLIAjPWXiQ2OnssgeYbL4q4Z9dqZQ0vl41Wax4vO39wxGNaPkTbmUPXR5kq6/AhmSnpyQl2ZhufFnzCTLsAeJWL5Q5p6IRjoFPpHHwmQtdhSuqGOygQ8FUHH96rZLFZ88WdXRdK3583TrXpW6L4xZKAo+2tpp0Z5lBNFZ73LRvX4n88Xv/8R/eU/sLxcS8PKjykYjQ8fz4unXCPGO9To/unxDJMOdiMTSfOePKoW13/ySWTmP2m0fAn3JX9Mvod9KS/cVF69zgJ4t1vkCGPUDcOnRkK6Q818Zy26lG9GAJKslE1oyhxPGnOF5zNotdfX3YODhY0ntUeH7Ba/qqekkmgwc3biwaL1m0zIcGB6XO0p39/UpGfVYyF72YmNsIF73BtfWBBwA3HjwozDu+8eBBdKVSeKinRxhfn2Os2GxbNK6M5OYTiEVL/4L1dflAM06tODlpVcasVoGyWoU09iri5Gz14owtp4bp1EZNpYm0EVm8uez12WgU0YJMIsKoVavGwxs1dSfDngeQq6uTOiR17bsrlcKuvj7HHqiy69S1f7um1pC8125cO18HcN6BquVPaAlA8cWz2LX9mOd7SOZ3MhKNcMx+U93n4yc/Y65DztM5gFO3dzfd4P3Mwc2DwE+EjBW3hl2XbGRatdWp6IRq9IwqVsPpFN0iQ682ubO/39XnaXy/7POTfT5u2+OpoubQ5+BPqRvkWmnNVw3IeVrD6I6fDTs70dggl0rKHavrVqtMHWopNmdAB7TqjwbctF+bqZOnhOckzsB8JIJMi1xH1fVt1YSprXv3BmbURTXq9dIKbuLqAc0oe5F1AE1yGitkwVrx46j2ijDRzYIsScnNmFRGwAyt2CtMJVbhonOKVuVuVj7CGOcYgH0oJi3Z1THPRyKYqqtDo0GmERnVs01NxSYZIv34XCyGKOclcsi5WAyb9u0DAMea7jp5SX9RDu3h4rbol+w8bhplG+fmRtYBzjcIB9Q/A6B8q3Ud/f5Ln6wvFGE7fyUUNukOkmJqlEpvI6U1Or4YBdvAlbXK1pveKq5bEwcwJtfX7QyuFWPDC905KDKuel0WvXuRsSaKTA4S6ct2hn0sHi8xpio1aGQ6tltZxm0tGVHTEtWaO06GPUgjOl8NclCQYa9RKu34sXuQAFB+yLDVV0Bq1rjc+OiOQNVCV0b9XDVBx4idw9HYJcnpWKtBzzOmlOwjOo8RldW7dQynJC6ncyIFoB/ACIB2AEkUd1kqRr0cO0wy8N4gjb1G8VOYywt2IZNBapUyfV1P2FHR363x7CoJOqq/Y9DS/Y01aCAxlqIQQ9XsWGs3JisqZYc5YKolY+dXAMRNS4qkUGyYopWILPycUpNgyhFaSHHo5YcMe4WptOPH7kGiO2eNdbllK7H4YknNkYKfzskIqzjuphvMuweR85ADaD5zRmo47RyOC2ZmTLHdbhynbo6VtQ3U0Z2q3UNDJU1IOLQvpT7HBzduxIWvvCIdy64uPgBtpW7dHGSBxMed6/0D9gsDNxgzRUXt7CgOPVjIsFeBxoY8jO3tyuk4lSUtnZmMIPLOK9D/wMUYWv+SFqQ9DKz/3GuE4+zafqy0hHA9gEJWvlOTDJUIjwXnzpkMtr66PRWPm2K3l2Qy0lWx/h6V9XVQETEiVHYo1hZ8s9FoyZwWzMwI4+aNjTpKVuuFXrWIQFuhC/BbfkJlhykrJUDt7MoPGfYKom9BNSfk+fZ2QY0tqp1hDZnUQiuBzETMtA0e+tRLxbHYdStL4tW714zj1t8/VawXEo1w4FYUtVpZCV3d6KhIEAzAQz09Jcb97MKFJQbPblV8oLvbdYihkSC8TqqhhcZuU7Jm1yI4Y+Jyw1bpRYKq9Od1h+lUSsDPnAhnyLBXkCD1SqMhb73prdj0hQ6pZmmsg72wMY/pWfOfXZ+DVXM1GvfUoRYMPtFaWG0VVl2DMMWyG42UyOgc6O7GjmQSUzFBdE2BulyuZDUuW/0m0mlprLpqDLis9jlQCHu0abLBAUw0N2Oq3rzSdJRHJLiJM5ceK5JeLDBwpE/WKxXP8pJLoVcsdSolYITi0IOFDHsFCVKvNDqfMhMxqbH2Owd99b5+6DWlX9QsNEPigDFh6KGenpJ65Vasq3E7h6ixFsrubdtMnZj29fSYmmqLDPCeLVukuwgGYPyii6QPCAZgvLUVGx98UKmnqxOih9G5WMzVg4ON2LlktWYtvLBbVHVaihpkyLCrWGolGuGuHhZUzVEdMuwVJKiIGJXCSoDYWDvNQRopIZOMR+yjK6wdklSTfoyr8cfXrXNcfTdns9i2d6+pE9PGwcFim722sTGhAd6+Zw86h4fBJRUm4+Pjtpp9+8iI405FFZGctWnfPqUHB3/6MPjTh6V/38TSaSSWTgdSXdEO1XtTb2Pn5mFBUTTqkGGvICp6pcrKxI/jS2UOupEwDyY+R6JtSv4eaKnxX83ejA4cRQQ5dOAoUuhynLtxNb5xcNC0+pYZWWtIonXlb2eA7aJ67DR72fu89oEVzdFu3vrnrt83WnanuIViUDtGO+zGYvBWz52qObqHDHsFcdIrVVYmqUMtiCiEc8g0SzeaqclYJwFYFs36OYwPo8SyKZPu/p30KvTifqTRAY4I0uhAL+43GXcnZ2VzNosbDx4sGjc3jlHV+jVeonpkksjubdswtGGDafegUjbXDca/jchRKTKiLYvEIavW1/3IHrIdQzTCsb//qOt67kBwEuZ8ggx7hbHTK51WJnb6pazuuuhL6kYzBQpGZPlhDN3+UskDAUDJw6jp1lwxyuaO6BeQRbP5mtCMHbirKC3cu3Wr42rcaKBFRlbWrEO1MJibqB47SaQrlcK2vXsddw8qcxIh2hmJ7hsOhsTSaddG1K/sIdsRDt551HNIb6WT+sIAlRSoIZzKDcjKA0QjXPjFqUTBMafaN5HVV0hC3TgguFbVWi/WWig/f+1rSzogcQD3bt0KACXG1qnJtugcsnorxuPykYjUj5CH1q6ufWQEmZYWLD59WrlBt50fQ7VMhcpxQdQyCrpcQDUK59UqVCtmDuJoJF3WmalEwTFZDRmnhxESAIZLXxbVUlExwna1auLj40pNpI0GWtXwuqncKGtmbTcnkUE3Gs6WRbP479N1yAvuC+vfWeV+qNUmFlRbRoNqxdQ4IonEybHpdksatDZpnfO2u1dI0070OQnrcTdB0+wFqEoeJeeTaOmthRICTu+xRu8syWRKKlWK5JSd/f1KRt1a4EyGPier5CLL4sxMxIRGvb7ufHax6v0F1K7s4VY+nO+QYa8CMh0TgK1jU9y0gOPMZESogQb5JRXNee+jbUKZhYEXjYXIWYsBFDNWRXgJH/TSRML4HlUDbX2AqBY3U90XR9qWlqzS3WZxRhgH56XZxYD9/QX4r2VE8ea1AUkxVcCPRGLuSWnfsCBIbVKtxZmOvNWZMZuVP33YsY+qKiJJJM8YGBebwTxjWL9/v3JpXB2rVCKTgGajUUTy+aI2r9TmrmEB8IkdwJr3mF5299kDssrxqhKcV9mDtPDyUxEphjH2h4yxnzLG8oyxYL6h8wA/Ekn3mnEsbMzD+sW1Rs+otN4LYs4i3LY6A/x38TFJODgvfciM+p4tW5Ti2I2IwhtlYZAfGhw07TiEJQ6idcDiCwDGgKXLhEYdCC6sT3Ucr7KHLKqrb/cKWsVXGL9SzE8A/AGAbwUwl3mDX4nE7sEgKjcwORXB/h1HfWmTsrnJkmFKjhMUFtN/1o26rivLkp2c0CWcTDwu7Yw0nEhg/f792L5nj+l3snT+U/G4rdav6hP48vJL0Hz7HZoB1w35HX8JPPYN4Mn/BB7+mtCoA+6ks6aGnLTEst04QUgosvsyM1FHWaMVJhAphjH2FIBPcM6Vvo3zXYrxu2UNqitSEHPuWTuGg89c6Lhtt5NcVIy4G8nGruWdndzipp2cjHL0DxX2my08UHUjPn66rvj5A3B1fwUlobiRjMrVCjLsqEox8lbxRNnQvyxew7eSm08Iv4jJzSewYWen8D1+t/P2cz7m+H47Pd26cpe933q8HSl0oR87MYJ2tGMESezAH+OA7Xv09H2FwYF+reCW9W9XrrA8a/5VfR3Hg58cth1bNA/R/OwS49zMXXRfyvR+yhotL44rdsbYNwAsE/yqn3P+aOGYp+CwYmeM9UKrFI32pcuuSD/8Na9zDi1ujILs2FpMMNFxu2pXmYdozPsW9uLjZ+82ZbzGcA6L2FmMI17S91MFa/q+aHULuFspqxJUPoK0sflUBHa5CG6w/s3OTEaETdBpxe6NiiYokRTjn6C2w37HKXdkg8gQy4y613k0f+ANyGYW2k+kCdKwS1G4oW6sIgzCkg52Mlg0wpHn8PyQDCppyC5zWXZNKlFadg9fipQJFkpQmmMEVcHOGDeudzrKTkXQ/8DFSg6rclfSU3WM+pnH5Hiz4zF630+rw9YuhtyprZtMXsjlmS/HYRD5CKlDLUiflM0Pvrsk6de3IdkJttpcl8htow7CP740dsbY+wHsBrAEwNcZY89yzt8dyMzmGUFmiepfGuNKyZikYvelqlQlPSfj7mce7W3TSk48lbFU64vrRtbpvEFp126ThrS/vfihlFh6Xmt3I7/Jio8BpfcbGfLK4mvFzjn/Cud8Oee8gXO+lIy6d4JO5fa64q2VlHI/8xBn6HobS8X4683BRbXQvY5pxO+q1+7hpD8gvMSuO10H1UyvHiTF1Ah+U7mteF3xBj0Pr/iZh1WOEmEse2CHXX1xa3Nway10rfG3+ph2+KmVIv+bc1+ySFAPRiJ4yLDXCEFrkV5XvLWiiQY5D+sqmoFjy82jSmPZ1ReXNQfXa6EP3nm0Jh6Sdu3yvPYZTR1qwZnJCJzapFS7eNh8hWrFhBS7pBZdU3VrJOdK6VRRJIbWxNnbtdtdt1PESi18Zl4iU9yGdYpg0Lom1eI9MlehBCWiJKkFEseWCtYvupcxgsLJWMo7CnmLnbZz/rUsmhXGaesr1VpwHOrnP188DmhsyNu+x8lHo+JQ5qj8vUFokBQTUvofuLhEIjDi1rFVrjBItzVKVFq3qfgXgqiNkjrUgomzpQauvi5fcblFhcliIpJWQ8gu9FL2GaZP1kvDJq14KQZHBAMZ9pCi4rSSHSMyeuUIg/TSX9PuAaPPW6Yu6qtov309jXMxS10ai5pyNbdStau8KEJe9O38f+2ohi+BOA8Z9pCi4rQSHSMzerIO936cY152AXYrSWMzCitGQxPU7kM2l/HT9gpnNZpR2FVeFJ1f5DTW/BRio15fF0x5aCIYyLCHlHVXv2wbUy1bUcmMnv4elTFU8bILkIcfynTfUkMT1O7DS+RRULsFt8jnxIQPNFFUkvxu0gqSjT32HLWuqxHIsIeQ1KEWDD7RalldcTQvmHVcUdmtQoMOg/RiGGXhhzmJL5AxlBiaoJKwvMTayx6c65OdZV29a3MSm+b0yXrhea2x8zLN3Clskqg8ZNhDiDjTkKH1gpzjisrO6AXdUNiLYZTFt8uMjuh6gkrC8hJrL98VlHf13r1mXNqAA2BK562V5DXCGTLsIcSP1FDJL6/XJCTRA8bNvLvXjKNn7VghM1TLEO1ZO+bpQeX2Yee0KyhnGv6u7cekpRZUzlsryWuEMxTHHkJkRbBUpAa/TUDcElSct5t561KVXqkxlwcGn2jFqkvPlt1IiZtRmNFbHPqtzW9Ff219shNem1/UQlw+4QxlnoaQctXALmcWZSUzNINqXOEV/Vq1ePBSAxtfPIPJqYjS38/L37ra1094h+qxz2PKsWUuZzSH37Hdhg9WqjSxDF2+GeoX15IBSiN8ZFKJl9BN0srDDxn2kBK0o9OLAVE1uHbJM07v9/JQkElSEYaKxJTryB7Asjh40YPHy0OKtPLwQ4adUMKtAVHpruM0RmaiztFge12xxqKl8ZG5vFp0SLlxE47pp4pncvMJtLdNY2S0XrnDFjE3IMNOKOHWgMi765QaabvkGSMig+1VViktkCY/h5Egs0Zlu411V7+sLJV4lVX06p/Gc2/8fAcZ95BAhp1Qwq0BcdNdR9zxSOzUt47rZcXqVCAtfbJeaLyD9jPIdhsHn7lQWSrxKqv07V5RUudmJheR1o4h5hYU7kgo4TYMUqXvqG6kRWOfmYzYlsPV8dIP1HE1j/O9S43lie1kHy/6tN1uw01YoZcQRL18r+rrxNyC/oqEMm4MiEq8ttFIW8eWhfFZDbaXuHu7h46o0JVuvIOOpvGTb1ALDTyI2oWkGMI3It3Z2nfUWpDMa+kAmRzhJgJIJv3EF89IC12lT9YjItHlvVa49KOP+5WEZOUF5GUHiLkErdgJTxiTbBhQXOVaOyvpRtbLCrNcWY52q3xZ8g4DipmqRvzEf3vN8g1CEtq1/Rg2faHD5Guor8tj1/ZjLq+CqEUo85RwjUgmsTJXsxjl/VJLjXo0wjF4p7ynZ7nkEqc+q6qQnDP3oJ6nRNkQV480U6ksTifcGi/RKlrWCi7PteNF5wDMDZ+D7BHrR5s3QnVfwgtp7IRrVIy2n85KQeFVi1atQ97eNi09R9/uFWXpEQtQSQDCGTLshGucjHatGJmgWuDZGVLZOWRhg6KHotukJyoJQDhBUgzhGlEoo6ZDa910akWrDSo80c7JuWFnp6uxrA9Fq6avKtmQjELYQYadcE2la7Z7JSgtGpAbUtk54otnhaV3rTuZoJOeCALwKcUwxv6GMfZfjLEfM8a+whi7MKiJEbVN0NUjy0FQWrSdVCI7x67tx5TkkmqXECbCid8V+yEAd3LOZxljXwBwJ4BP+p8WQfgniJ2Fk1TidA6VVnlB7SoIQiewOHbG2PsB/A/OebfTsRTHTswVyt1tqFzdrohwUo0OSpsA/GuA4xFE1Sm3VEIRLkQ5cJRiGGPfALBM8Kt+zvmjhWP6AcwCSNmM0wugFwDal4qGI4jaoxJSCUW4EEHjaNg55zfY/Z4x1gPgRgDv4ja6Dud8AMAAoEkxLudJEFXBS1lggqg2vpynjLG10Jyl13HOs8FMiSBqh7kS2kkQRvxGxdwDoAHAIab1GnuGc77F96wIooYgqYSYa/gy7Jzz1wY1EYIgCCIYqFYMQRBEyCDDThAEETLIsBMEQYQMMuwEQRAhgww7QRBEyCDDThAEETLIsBMEQYQMMuwEQRAhgww7QRBEyCDDThAEETLIsBMEQYQMMuwEQRAhgww7QRBEyCDDThAEETLIsBMEQYQMMuwEQRAhgww7QRBEyCDDThAEETLIsBMEQYQMMuwEQRAhgww7QRBEyCDDThAEETLIsBMEQYQMMuwEQRAhgww7QRBEyCDDThAEETLIsBMEQYQMX4adMfbXjLEfM8aeZYz9O2Ps1UFNjCAIgvCG3xX733DOL+OcXw7gcQB/GcCcCIIgCB/4Muyc8wnDj80AuL/pEARBEH6p8zsAYywJ4EMAXgHwTt8zIgiCIHzBOLdfZDPGvgFgmeBX/ZzzRw3H3QlgAef805JxegH0Fn68BMDPPc24NmkFMFbtSZQZusZwEPZrDPv1JTjnS5wOcjTsqjDGEgC+zjm/NJAB5xCMscOc85XVnkc5oWsMB2G/xrBfnyp+o2JeZ/jxJgD/5W86BEEQhF/8auyfZ4xdAiAPIA1gi/8pEQRBEH7wZdg55x8IaiJznIFqT6AC0DWGg7BfY9ivT4nANHaCIAiiNqCSAgRBECGDDHtAMMb+hjH2X4USC19hjF1Y7TkFDWPsDxljP2WM5RljoYk8YIytZYz9nDH2ImPsjmrPpxwwxh5kjI0yxn5S7bmUA8bYCsbYk4yxFwr3aF+151RNyLAHxyEAl3LOLwPwCwB3Vnk+5eAnAP4AwLeqPZGgYIxFAdwL4D0A3gSgizH2purOqix8CcDaak+ijMwC+Djn/I0Argbw0ZD+HZUgwx4QnPN/55zPFn58BsDyas6nHHDOX+CchymxDACuAvAi5/wlzvk0gH8EcHOV5xQ4nPNvARiv9jzKBef815zzHxX+/zSAFwBcXN1ZVQ8y7OVhE4B/rfYkCCUuBnDM8PNxzGODEAYYYx0A3gbgB9WdSfXwXStmPqFSXoEx1g9tW5iq5NyCQrWERIhggtcoVGyOwhhbCOCfAfyppUjhvIIMuws45zfY/Z4x1gPgRgDv4nM0jtTpGkPIcQArDD8vB/CrKs2F8AFjLAbNqKc45/9S7flUE5JiAoIxthbAJwHcxDnPVns+hDI/BPA6xlgnY6wewB8BeKzKcyJcwhhjAL4I4AXO+d9Ve6tjI1QAAACgSURBVD7Vhgx7cNwDYBGAQ4WOUnurPaGgYYy9nzF2HMA1AL7OGPu3as/JLwWH98cA/Bs0h9sjnPOfVndWwcMYOwDg+wAuYYwdZ4zdWu05BcwqABsAXF/4/j3LGFtX7UlVC8o8JQiCCBm0YicIgggZZNgJgiBCBhl2giCIkEGGnSAIImSQYScIgggZZNgJgiBCBhl2giCIkEGGnSAIImT8f3l55HpnbWDuAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = set_f(network2)\n",
    "xmin,ymin = np.amin(x_nonlin,axis = 0)\n",
    "xmax,ymax = np.amax(x_nonlin,axis = 0)\n",
    "xx,yy = np.meshgrid(np.arange(xmin - 1, xmax + 1, 0.05),\n",
    "                    np.arange(ymin - 1, ymax + 1, 0.05))\n",
    "zz=np.apply_along_axis(f,1,np.array([xx.flatten(),yy.flatten()]).T).reshape(xx.shape)\n",
    "plt.contourf(xx,yy,zz,0, colors = ['cyan', 'pink'])\n",
    "\n",
    "plt.plot(x_nonlin[0:250, 0], x_nonlin[0:250, 1], 'ro', label = \"Class -1\")\n",
    "                \n",
    "plt.plot(x_nonlin[250:500, 0], x_nonlin[250:500, 1], 'bo', label = \"Class 1\")\n",
    "      \n",
    "plt.legend(loc = \"best\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When S is increased a similar result is obtained. The result varies. Always a form with two regions was obtained so far. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "0.01\n"
     ]
    }
   ],
   "source": [
    "## Comparison using keras\n",
    "\n",
    "\n",
    "model = keras.models.Sequential()\n",
    "model.add(layers.Dense(20, input_shape = (2,), activation = \"relu\"))\n",
    "model.add(layers.Dense(1))\n",
    "model.compile(loss = \"mse\", optimizer = \"sgd\", metrics = [\"accuracy\"])\n",
    "k = 20\n",
    "S = 50000\n",
    "history = model.fit(x_nonlin, label_nonlin, batch_size = k, epochs = 100, verbose = False)\n",
    "\n",
    "print(K.eval(model.optimizer.lr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "\n",
    "def set_f2(mod):\n",
    "    def f(vec):\n",
    "        return(mod.predict(np.reshape(np.asarray(vec), (1,-1))))\n",
    "    return f\n",
    "    \n",
    "f = set_f2(model)\n",
    "xmin,ymin = np.amin(x_nonlin,axis = 0)\n",
    "xmax,ymax = np.amax(x_nonlin,axis = 0)\n",
    "xx,yy = np.meshgrid(np.arange(xmin - 1, xmax + 1, 0.05),\n",
    "                    np.arange(ymin - 1, ymax + 1, 0.05))\n",
    "zz=np.apply_along_axis(f,1,np.array([xx.flatten(),yy.flatten()]).T).reshape(xx.shape)\n",
    "plt.contourf(xx,yy,zz,0, colors = ['cyan', 'pink'])\n",
    "\n",
    "plt.plot(x_nonlin[0:250, 0], x_nonlin[0:250, 1], 'ro', label = \"Class -1\")\n",
    "                \n",
    "plt.plot(x_nonlin[250:500, 0], x_nonlin[250:500, 1], 'bo', label = \"Class 1\")\n",
    "      \n",
    "plt.legend(loc = \"best\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Template for Keras tasks of sheet 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load MNIST data\n",
    "(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()\n",
    "img_rows, img_cols = 28, 28\n",
    "\n",
    "# Normalize it\n",
    "X_train = X_train.astype('float32') / 255\n",
    "X_test = X_test.astype('float32') / 255\n",
    "# Store it in the correct format for Keras\n",
    "# The image data has a single channel (grayscale values)\n",
    "if K.image_data_format() == 'channels_first':\n",
    "    X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols)\n",
    "    X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols)\n",
    "    input_shape = (1, img_rows, img_cols)\n",
    "else:\n",
    "    X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)\n",
    "    X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)\n",
    "    input_shape = (img_rows, img_cols, 1)\n",
    "# Store the labels in the correct format for Keras\n",
    "Y_train = keras.utils.np_utils.to_categorical(y_train, 10)\n",
    "Y_test = keras.utils.np_utils.to_categorical(y_test, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use `X_train` for fully-connected inputs, reshape it. Use the `input_shape` variable in the first layer of your networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_history(history):\n",
    "    \"\"\"Create a plot showing the training history of `model.fit`.\n",
    "    \n",
    "    Example:\n",
    "        history = model.fit(...)\n",
    "        plot_history(history)\n",
    "    \"\"\"\n",
    "    x = range(history.params['epochs'])\n",
    "    acc, val_acc = history.history['acc'], history.history.get('val_acc')\n",
    "    f, axarr = plt.subplots(2, sharex=True)\n",
    "    axarr[0].set_title('accuracy')\n",
    "    axarr[0].plot(x, acc, label='train')\n",
    "    if val_acc:\n",
    "        axarr[0].plot(x, val_acc, label='validation')\n",
    "    axarr[0].legend()\n",
    "    \n",
    "    loss, val_loss = history.history['loss'], history.history.get('val_loss')\n",
    "    axarr[1].set_title('loss')\n",
    "    axarr[1].plot(x, loss, label='train')\n",
    "    if val_loss:\n",
    "        axarr[1].plot(x, val_loss, label='validation')\n",
    "    axarr[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task 4.4** (a) Build a model with two Fully-connected layers ( 128 output nodes + ReLU) and one Fully-connected layer (10 output nodes + softmax). Use SGD (batch size=128), categorical crossentropy loss, train for 20 episodes; model fit; plot history."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60000, 28, 28, 1)\n",
      "(60000,)\n",
      "(10000, 28, 28, 1)\n",
      "(28, 28, 1)\n",
      "(60000, 784)\n",
      "(10000, 784)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(y_train.shape)\n",
    "print(X_test.shape)\n",
    "print(input_shape)\n",
    "\n",
    "#use a flat vector as input\n",
    "X_train = X_train.reshape(X_train.shape[0],-1)\n",
    "X_test = X_test.reshape(X_test.shape[0],-1)\n",
    "\n",
    "print(X_train.shape)\n",
    "print(X_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 128)               100480    \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 128)               16512     \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 118,282\n",
      "Trainable params: 118,282\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/20\n",
      "60000/60000 [==============================] - 5s 78us/step - loss: 1.4222 - acc: 0.6327 - val_loss: 0.6793 - val_acc: 0.8405\n",
      "Epoch 2/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.5313 - acc: 0.8642 - val_loss: 0.4196 - val_acc: 0.8866\n",
      "Epoch 3/20\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.3953 - acc: 0.8902 - val_loss: 0.3510 - val_acc: 0.8984\n",
      "Epoch 4/20\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.3458 - acc: 0.9008 - val_loss: 0.3183 - val_acc: 0.9064\n",
      "Epoch 5/20\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.3172 - acc: 0.9085 - val_loss: 0.2951 - val_acc: 0.9135\n",
      "Epoch 6/20\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.2961 - acc: 0.9148 - val_loss: 0.2785 - val_acc: 0.9197\n",
      "Epoch 7/20\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.2796 - acc: 0.9201 - val_loss: 0.2647 - val_acc: 0.9244\n",
      "Epoch 8/20\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.2655 - acc: 0.9241 - val_loss: 0.2538 - val_acc: 0.9274\n",
      "Epoch 9/20\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.2531 - acc: 0.9278 - val_loss: 0.2430 - val_acc: 0.9307\n",
      "Epoch 10/20\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.2423 - acc: 0.9312 - val_loss: 0.2342 - val_acc: 0.9334\n",
      "Epoch 11/20\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.2321 - acc: 0.9343 - val_loss: 0.2249 - val_acc: 0.9365\n",
      "Epoch 12/20\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.2230 - acc: 0.9371 - val_loss: 0.2179 - val_acc: 0.9368\n",
      "Epoch 13/20\n",
      "60000/60000 [==============================] - 2s 41us/step - loss: 0.2148 - acc: 0.9391 - val_loss: 0.2108 - val_acc: 0.9394\n",
      "Epoch 14/20\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.2070 - acc: 0.9416 - val_loss: 0.2022 - val_acc: 0.9415\n",
      "Epoch 15/20\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.1998 - acc: 0.9437 - val_loss: 0.1954 - val_acc: 0.9415\n",
      "Epoch 16/20\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.1931 - acc: 0.9457 - val_loss: 0.1894 - val_acc: 0.9434\n",
      "Epoch 17/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.1868 - acc: 0.9474 - val_loss: 0.1857 - val_acc: 0.9459\n",
      "Epoch 18/20\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.1810 - acc: 0.9490 - val_loss: 0.1783 - val_acc: 0.9459\n",
      "Epoch 19/20\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.1753 - acc: 0.9505 - val_loss: 0.1755 - val_acc: 0.9476\n",
      "Epoch 20/20\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.1702 - acc: 0.9522 - val_loss: 0.1702 - val_acc: 0.9498\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEICAYAAACktLTqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl4W+WZ8P/vLelo875kceIkdmhLQoLJYkIKhYbSBWjZ2hRCYabQUt6hpQx9YS6Ytr8WOuU3TMvwMnQd6NA1LGl4WdqBLkxDAy0JcSCYLNAktkOMszh2vGvX8/5xZEd25NhJbMmS7891netsz5Funyj3Obr16JEYY1BKKZVbHJkOQCml1NjT5K6UUjlIk7tSSuUgTe5KKZWDNLkrpVQO0uSulFI5SJO7UkrlIE3uSimVgzS5KzUKYtP/Lypr6ItVZRURuVNEdotIt4hsF5ErkvZ9QUR2JO1bktg+S0T+r4i0ikibiHw/sf0uEflV0vFVImJExJVYf1FE7hGRvwB9wFwRuT7pORpE5H8Nie8yEdkiIl2JOC8UkU+LyOYh7W4TkafH70ypyU6Tu8o2u4FzgSLgbuBXIlIhIp8G7gL+HigELgXaRMQJ/BbYA1QBM4HHj+P5/g64EShIPMZB4BOJ57ge+D9JF5FlwC+AfwKKgfOAJuBZoFpE5ic97rXAL4/rL1fqOGhyV1nFGPNrY0yLMSZujHkC2AksA24AvmOM2WRsu4wxexL7ZgD/ZIzpNcYEjTEvH8dT/swYs80YEzXGRIwx/22M2Z14jj8Df8C+2AB8HnjEGPPHRHzvGmPeMsaEgCewEzoisgD7QvPbMTglSqWkyV1lFRH5+0TZo0NEOoCFQDkwC/uufqhZwB5jTPQEn3LvkOe/SEQ2iEh74vkvTjx//3OligHg58BnRESw3w2sSSR9pcaFJneVNURkDvAwcDNQZowpBrYCgp2ET0lx2F5gdn8dfYhewJ+0Pj1Fm4FhU0XEAzwJ3AdMSzz/c4nn73+uVDFgjNkAhLHv8j+DlmTUONPkrrJJHnaybQUQkeux79wBfgLcLiJLEz1b3pO4GLwK7APuFZE8EfGKyDmJY7YA54nIbBEpAv55hOd3A57E80dF5CLgo0n7/wu4XkQuEBGHiMwUkXlJ+38BfB+IHmdpSKnjpsldZQ1jzHbg34FXgAPA6cBfEvt+DdwDPAp0A08DpcaYGHAJ8B7gHaAZuCpxzB+xa+H1wGZGqIEbY7qBW4A1wGHsO/Bnk/a/SuJDVqAT+DMwJ+khfol9MdK7djXuRH+sQ6n0EBEfdm+bJcaYnZmOR+U2vXNXKn1uAjZpYlfpkOpDJqXUGBORJuwPXi/PcChqktCyjFJK5SAtyyilVA7KWFmmvLzcVFVVZerplVIqK23evPmQMWbKSO0yltyrqqqoq6vL1NMrpVRWEpE9o2mnZRmllMpBmtyVUioHaVdIpdSkE48bwrG4PUXtKZJYDiUth2NDt5vEcoxQNE4okrQcjSXW4wNtIpEIRPogGkAiARxRe1r5oeV8/OzF4/o3anJXSqWFMYZQNE4wEhuUAEPRIwkxHB2cHPsTbCgcIxYNEg/2EI8EiERjduKNmoHkG4nb60eSdoxIzBBJStL2egynieAmgofEXPqXo3gI45YoHiJ4COMhmrTfnhdKGC8hfITxy5HJRwivhPGaEG7CWKQejLSh818ATe5KqXESjcUJRuMEwjGCEXsKRGL2eqrtkRjBSHxgWzASIxwOEwsHiUcCxCNBiAQwkSBEg0g0ANEQjlgQZyyMR8J4CeMnhF9C+AjhJ4hPQuQlloslZO8nmNQmhEviJ/8HO7CHfzsBcacHnG6MywOWH7F8iNuPuIrB8iUm/zBz36A2c6eedvJ/ywg0uSs1QZlomFCgh3BfN5FAF+FAD7FgN9FAD5FQL5FQH7FgH7FwH/FIABMOYMJ9A0nVEQ0mkmoQVzyEFU/MTRgwGJM0njH212d9ielYBIOXCF4J4yGCi9jIf4wzMQ0RdfqIuXzEXX6My0fcygN3OVh54PYjnnwc7jxinjzw5OH05iOWH07252xdHntyeo4suzzg8g6zzY1DZOTHnUA0uSuVzBi7RhrqTkxdEOpJWu+GcA+YGBhDLJ54+x+JEonZZYRoNGrPY1Ei0RiRWJxYLJa0HMUVDeCKB7BifbhjAdwmiDcewGuCeAniN0HcEsULeEcZetwIAdyEcBMSD+HEFHV4iDo9BK0i4k4vxunB4XDgcgpOhwOngNORWHYILock1iXlutMhiMsLLp+d/KzEPNW65bWTY//Uv275wfLjcjg0CY0TPa8quxkD0aCdgMM9EO5NTD3DzHsxoW7iwW5igS7iwS4IdSPhbhzhHlyRHoTRv/13MvhuN2YEgxDHnjNoGYw4MDgIioeww0vI4Sfs9BFxlNDhmkHU6Sfm8hGz8jAuP8adh7HyEHce4slDPPk4Pfm4vXlYvjy8Pj8ebz6+vHz8Ph8+y0WeI7vuMNX40OSuMsMYiATsO+NgV+IOOWl5YFt3YrkTgl2YUDcm2IkJ9UKkF0ekFzGjS8ZxhD689BoPPcZHNz56jI8eCulhGt3GR8/ANh8Bh5+4lU/cXQCeAsRTgNNXiOUtwOv14Pe4yPe48Lnd5Hst/B4neR4XeW4XeR5nYp5oYzmQpLf1+eN1XpVK0OSujk88BoGOI4k3nKJk0V/GCPdv70naZydoQt1IfOSfNQ2In17x042fzriPzriXLjOFHjPbTtR46DNeevEemeMl7s7D4c7H4cnH6c3H5c3H48unwGdR4LUo8Loo8NqJt8BrMdPjGthW4LXI8zjxuFIUiZXKEprcJ7tYFPraoLcV+g5B76HE+qEh6632cuAwgz+GSy3s8BN02He/vfjoMV464346YiV0RD1046fb+OnGR5fxJ9Z9dOMnIH7EW4TLV0C+30uRz6LQ66LIZ9nLPjs5T/FazPW6KEwk5PxEgs5zu3BoaUJNcprcc1UsAt37oXsfdL0LXS2J6V17e3+yDnakPNwgRNzFBKwSup1FdMgM2qx5HHDksy/ipzXsoTXipsd4B8oYvcZLDz768GLEQaHXothjUex3U+yzKPZbFPssivxuinwWU/uTtddFkb9/2cLvdg4qYSiljp8m92wUCUJ3C3TtO5KwB81boOcAQ++w4y4vQV8F3VY5nY5qDufX0OovYF80n+ZwHnsCfprDftpNIR3kEw8e6W5WmuemPN9NebGH8nwPJX6LeX63nbD9FsW+/mU7kRf6LJx696xUxmhyn4giAejYCx3vQMeexDxp6j141CExdyEB3zS6rKm0+Zexz1fKO5FidoUK2dFbQGO4iC7yoOdIwi3yWUwp8FCe72ZKgZfqfDfLCuzkPaXAw5TEvDTPjeXUYYiUyiajSu4iciHwH9g9v35ijLl3yP45wCPAFKAduNYY0zzGseaOcB90Hit5tw5qbhwWofyZdHkqOFhwNs15ZeyJlLArWMD23gKawkX0Bn3QZbd3CEwt8DK9yMuMKV6WFvq4pNheryjyMb3IS3m+Wz8wVCqHjZjcRcQJ/AD4CNAMbBKRZ40x25Oa3Qf8whjzcxH5EPCvwN+NR8BZI9gJ7Q1JU+OR5Z4Dg5oap5toQSU93goOlZzHuyVTaAiXsi1QzOtdhTT25WP6jtw5Ty3wMKPYR8VML2cV+bi8yEtFsZeKRPKeWuDBpXfaSk1qo7lzXwbsMsY0AIjI48BlQHJyPw34SmJ5HfD0WAY5IRlj9xwZlMCTpr62wc3zpxMpqqJtygfYO2UajbFy3gqUsKW7iDe7PER7j5RL3C4Hs0p8zC71c95787i21M/sUj9zyvzMKvXjtfSOWyl1bKNJ7jOBvUnrzcBZQ9q8AXwKu3RzBVAgImXGmDZyQSwCB7ZBy2vw7mtwYKudwIOdSY0EiiqhtJrYvE/Q5q6kITaV+r5SNh4uZMuBCG2HwgOti/0Wc0r9zJrt5+wyP3NK85hdZifx6YVe7cqnlDopo0nuqbLM0I7OtwPfF5HrgPXAu3D0WJciciNwI8Ds2bOPK9C0icehbaedxPuT+f43IRay93uLoeIMOP3TUDqX3rzZ7IxO5Y3uIt48GGLHvi52/q2HcMz+1qTb5eB905xcML+E+RWFzK8oZN70Aor9Jzg0nVJKjcJoknszMCtpvRJoSW5gjGkBPgkgIvnAp4wxybe1/e0eAh4CqK2tHfmbMOPNGPuDzeREvu8N+9uXYI9MV3EGLPsCzFgMM5ewM1zOb+r3sX1fFzve7ObdjgBwCDhEeb6b+RWFXH9OFfMrCjltRiFzy/O0/q2USrvRJPdNwHtFpBr7jnwV8JnkBiJSDrQbY+LAP2P3nJmYuvfD5p/Bu5vtZN53yN7usGD6QvuOfOYSmLEEppwKDifGGDY0tPPQM7tZ9/YOnA5hbnkeS+eUcO3yOZw2o5D5FQVMLRjt+H1KKTW+RkzuxpioiNwM/B67K+QjxphtIvItoM4Y8yywAvhXETHYZZkvjWPMJ27vq/DEtXZXwynz4H0fG7gjZ9pCe5jSJNFYnN/Vt/DQ+gbqmzspy3Pzvz/yPq5dPofSPC2rKKUmLjEmM9WR2tpaU1dXl74nfO0X8N+3QeEMWPUYTBv+l1D6wlHWbNrLf/2lkb3tAarL87jh3Go+taRSe6oopTJKRDYbY2pHapf731CNReD3X4VXH4K558PKR8BfmrJpa3eIn/+1iV9u2ENnIMLSOSV8/eOn8ZH507T3ilIqq+R2cu89BL++DppegvffDB++G5xH/8m7W3v4yUsNPPnau0RicT4yfxr/64NzWTon9UVAKaUmutxN7vvq4fFr7G+DXvEQnHHVoN3GGOr2HOY//9zACzsO4HY5WLm0khs+UM3cKfpTCkqp7JabyX3rk/D0l+zyy+d+Z39gmmCM4ffb9vOf6xt4/Z0Oiv0Wt3zoPfz92VWU53uO8aBKKZU9ciu5x2PwP9+CvzwAs5bDVb+E/KmDmqyp28sdT77J7FI/37psASuXVuJ359ZpUEqp3MlqgQ548gbY9UdYej1c9B1wHd1d8X92HGR2qZ91t6/Q8caVUjkrN5J769vw2NX28Lkfvx/O/HzKZvG44dWmdj562jRN7EqpnJb9yf3t5+HJL4Dlhc/+BuacPWzTvx3spqMvwlnVZWkMUCml0i97k7sxsP4+WHcPVNTAqkftURmPYWNDOwBnzdUujkqp3JadyT3UA0/fBDuehdOvhEsfBMs34mEbG9uYWeyjssSfhiCVUipzsi+5tzfa/ddbd8BH/gXO/jLIyPVzYwyvNrZz3vumpCFIpZTKrOxL7tufga5muObX8J4Pj/qw3a09HOoJc1a1lmSUUrkv+5L72bdAzZX2AGDHYUN/vV0/TFVKTQLZ9ysSDsdxJ3aAjY3tTCv0MKdM6+1KqdyXfcn9BBhj2NjQxlnVZcgo6vNKKZXtJkVyb2rr42B3SLtAKqUmjUmR3Dc2tAFab1dKTR6TI7k3tlOe7+GUKXmZDkUppdIi55P7kXp7qdbblVKTxqiSu4hcKCJvi8guEbkzxf7ZIrJORF4XkXoRuXjsQz0xzYcDtHQGtd6ulJpURkzuIuIEfgBcBJwGXC0iQ39d+uvAGmPMYmAV8MOxDvREbdB6u1JqEhrNnfsyYJcxpsEYEwYeBy4b0sYAhYnlIqBl7EI8ORsb2ynxW7x3qv50nlJq8hjNN1RnAnuT1puBs4a0uQv4g4h8GcgDRj8uwDjb2NjGsupSHDp+u1JqEhnNnXuqrGiGrF8N/MwYUwlcDPxSRI56bBG5UUTqRKSutbX1+KM9Ti0dAfa2B7Qko5SadEaT3JuBWUnrlRxddvk8sAbAGPMK4AXKhz6QMeYhY0ytMaZ2ypTxH51xY2Oi3q4fpiqlJpnRJPdNwHtFpFpE3NgfmD47pM07wAUAIjIfO7mP/635CDY2tFPodTFveuHIjZVSKoeMmNyNMVHgZuD3wA7sXjHbRORbInJpotltwBdE5A3gMeA6Y8zQ0k3abWxsZ1l1qf5eqlJq0hnVkL/GmOeA54Zs+0bS8nbgnLEN7eQc7ArSeKiXzyybnelQlFIq7XL2G6obGvX3UpVSk1fOJveNDW3ke1ycVqH1dqXU5JO7yb2xndqqElzOnP0TlVJqWDmZ+Q71hNh1sEf7tyulJq2cTO6var1dKTXJ5WRy39jQht/t5PSZRZkORSmlMiI3k3tjO0vnlGBpvV0pNUnlXPY73Bvmrf3dnFWtJRml1OQ1qi8xZZNXm/rr7fphqlLpFIlEaG5uJhgMZjqUnOD1eqmsrMSyrBM6PueS+8aGdjwuBzWVWm9XKp2am5spKCigqqpKf9LyJBljaGtro7m5merq6hN6jJwry2xsbGPJ7BI8LmemQ1FqUgkGg5SVlWliHwMiQllZ2Um9C8qp5N4ZiLB9X5d2gVQqQzSxj52TPZc5ldzrmtoxRn8vVSmlciq5b2xsx+10sHh2caZDUUqlWUdHBz/84Q+P+7iLL76Yjo6OcYgos3IruTe0sWhWMV5L6+1KTTbDJfdYLHbM45577jmKi3PvhjBnkntPKMrWFq23KzVZ3XnnnezevZtFixZx5plncv755/OZz3yG008/HYDLL7+cpUuXsmDBAh566KGB46qqqjh06BBNTU3Mnz+fL3zhCyxYsICPfvSjBAKBTP05Jy1nukLWNbUTixuttys1Adz9m21sb+ka08c8bUYh37xkwbD77733XrZu3cqWLVt48cUX+fjHP87WrVsHuhI+8sgjlJaWEggEOPPMM/nUpz5FWdngfLFz504ee+wxHn74Ya688kqefPJJrr322jH9O9IlZ5L7xsZ2XA5hyZzce3ullDp+y5YtG9RH/MEHH+Spp54CYO/evezcufOo5F5dXc2iRYsAWLp0KU1NTWmLd6zlTnJvaKOmsgi/O2f+JKWy1rHusNMlLy9vYPnFF1/khRde4JVXXsHv97NixYqUfcg9Hs/AstPpzOqyTE7U3PvCUeqbO3XIAaUmsYKCArq7u1Pu6+zspKSkBL/fz1tvvcWGDRvSHF36jeo2V0QuBP4DcAI/McbcO2T//wHOT6z6ganGmLTVR17b00E0bnSwMKUmsbKyMs455xwWLlyIz+dj2rRpA/suvPBCfvzjH1NTU8Opp57K8uXLMxhpeoyY3EXECfwA+AjQDGwSkWeNMdv72xhjvpLU/svA4nGIdVgbG9twOoTaKk3uSk1mjz76aMrtHo+H559/PuW+/rp6eXk5W7duHdh+++23j3l86TSasswyYJcxpsEYEwYeBy47RvurgcfGIrjR2tjQzsIZheR7tN6ulFIwuuQ+E9ibtN6c2HYUEZkDVAN/Gmb/jSJSJyJ1ra2txxtrSsFIjC17O7TerpRSSUaT3FONXmOGabsKWGuMSfmVMGPMQ8aYWmNM7ZQpU0Yb4zG9/k4H4Vhc6+1KKZVkNMm9GZiVtF4JtAzTdhXpLsk0tiGC1tuVUirJaJL7JuC9IlItIm7sBP7s0EYicipQArwytiEe28aGduZPL6TId2K/VqKUUrloxORujIkCNwO/B3YAa4wx20TkWyJyaVLTq4HHjTHDlWzGXCga47V3Dut4MkopNcSovsRkjHnOGPM+Y8wpxph7Etu+YYx5NqnNXcaYO8cr0FTqmzsJReM6noxS6rjl5+cD0NLSwsqVK1O2WbFiBXV1dcd8nAceeIC+vr6B9YkyhHBWf0N1Y0MbAMv0w1Sl1AmaMWMGa9euPeHjhyb3iTKEcHYn98Z2Tp1WQGmeO9OhKKUy7I477hg0nvtdd93F3XffzQUXXMCSJUs4/fTTeeaZZ446rqmpiYULFwIQCARYtWoVNTU1XHXVVYPGlrnpppuora1lwYIFfPOb3wTswchaWlo4//zzOf98+0v6/UMIA9x///0sXLiQhQsX8sADDww8XzqGFs7ab/1EYnE27znMyqWVmQ5FKTXU83fC/jfH9jGnnw4X3Tvs7lWrVnHrrbfyxS9+EYA1a9bwu9/9jq985SsUFhZy6NAhli9fzqWXXjrs75P+6Ec/wu/3U19fT319PUuWLBnYd88991BaWkosFuOCCy6gvr6eW265hfvvv59169ZRXl4+6LE2b97MT3/6UzZu3IgxhrPOOosPfvCDlJSUpGVo4ay9c3/z3U76wjGttyulAFi8eDEHDx6kpaWFN954g5KSEioqKvjqV79KTU0NH/7wh3n33Xc5cODAsI+xfv36gSRbU1NDTU3NwL41a9awZMkSFi9ezLZt29i+fftwDwPAyy+/zBVXXEFeXh75+fl88pOf5KWXXgLSM7Rw1t65b2xoB7TertSEdIw77PG0cuVK1q5dy/79+1m1ahWrV6+mtbWVzZs3Y1kWVVVVKYf6TZbqrr6xsZH77ruPTZs2UVJSwnXXXTfi4xyr42A6hhbO2jv3jY1tnDIljykFnpEbK6UmhVWrVvH444+zdu1aVq5cSWdnJ1OnTsWyLNatW8eePXuOefx5553H6tWrAdi6dSv19fUAdHV1kZeXR1FREQcOHBg0CNlwQw2fd955PP300/T19dHb28tTTz3FueeeO4Z/7bFl5Z17NBanrukwly6akelQlFITyIIFC+ju7mbmzJlUVFRwzTXXcMkll1BbW8uiRYuYN2/eMY+/6aabuP7666mpqWHRokUsW7YMgDPOOIPFixezYMEC5s6dyznnnDNwzI033shFF11ERUUF69atG9i+ZMkSrrvuuoHHuOGGG1i8eHHaft1J0vido0Fqa2vNSP1Hh1Pf3MGl3/8L/7FqEZctSjmGmVIqzXbs2MH8+fMzHUZOSXVORWSzMaZ2pGOzsizTX29friNBKqVUStmZ3BvbqCrzM63Qm+lQlFJqQsq65B6LG15tbNcukEpNQJkq8+aikz2XWZfc39rfRVcwqoOFKTXBeL1e2traNMGPAWMMbW1teL0nXp3Iut4y/fV2/eUlpSaWyspKmpubGatfWZvsvF4vlZUn/g38rEvuy6pL+aePncrMYl+mQ1FKJbEsi+rq6kyHoRKyLrkvnFnEwplFmQ5DKaUmtKyruSullBqZJnellMpBGfuGqoi0Asce6GF45cChMQxnrGl8J0fjO3kTPUaN78TNMcZMGalRxpL7yRCRutF8/TZTNL6To/GdvIkeo8Y3/rQso5RSOUiTu1JK5aBsTe4PZTqAEWh8J0fjO3kTPUaNb5xlZc1dqRMhIk3ADcaYFzIdi1LjLVvv3JVSSh2DJnellMpBmtzVpCMiHhF5QERaEtMDIuJJ7CsXkd+KSIeItIvISyLiSOy7Q0TeFZFuEXlbRC7I7F+i1PCybmwZpcbA14DlwCLAAM8AXwf+P+A2oBno/5LIcsCIyKnAzcCZxpgWEakCnOkNW6nR0zt3NRldA3zLGHPQGNMK3A38XWJfBKjA/hZgxBjzkrF7HcQAD3CaiFjGmCZjzO6MRK/UKGhyV5PRDAYPfbEnsQ3gu8Au4A8i0iAidwIYY3YBtwJ3AQdF5HERmYFSE5QmdzUZtQBzktZnJ7ZhjOk2xtxmjJkLXAL87/7aujHmUWPMBxLHGuDf0hu2UqOnyV1NRo8BXxeRKSJSDnwD+BWAiHxCRN4jIgJ0YZdjYiJyqoh8KPHBaxAIJPYpNSFpcleT0beBOqAeeBN4LbEN4L3AC0AP8ArwQ2PMi9j19nuxRwrcD0wFvprWqJU6DvoNVaWUykF6566UUjlIk7tSSuUgTe5KKZWDNLkrpVQOytjwA+Xl5aaqqipTT6+UUllp8+bNh0bzG6oZS+5VVVXU1dVl6umVUioriciekVtpWUYppXJS1iX3/Z1Bfrd1X6bDUEqpCS3rkvuTrzXzD796jUM9oUyHopRSE1bWjee+fG4ZAK82tnPx6RUZjkYp1S8SidDc3EwwGMx0KDnB6/VSWVmJZVkndHzWJfeayiL8bicbGto0uSs1gTQ3N1NQUEBVVRX2uGvqRBljaGtro7m5merq6hN6jKwry1hOB7VVpWxoaMt0KEqpJMFgkLKyMk3sY0BEKCsrO6l3QVmX3AGWzy3lbwd6tO6u1ASjiX3snOy5zNLkfqTurpRS6mhZmdxPn2nX3V/ZraUZpZSto6ODH/7wh8d93MUXX0xHR8c4RJRZWZncte6ulBpquOQeix37B7Oee+45iouLxyusjMm63jL9ls8t5Tu/e5tDPSHK8z2ZDkcpleTu32xje0vXmD7maTMK+eYlC4bdf+edd7J7924WLVqEZVnk5+dTUVHBli1b2L59O5dffjl79+4lGAzyj//4j9x4443AkaFQenp6uOiii/jABz7AX//6V2bOnMkzzzyDz+cb078jXbLyzh3g/Ym6+8YGrbsrpeDee+/llFNOYcuWLXz3u9/l1Vdf5Z577mH79u0APPLII2zevJm6ujoefPBB2tqOfue/c+dOvvSlL7Ft2zaKi4t58skn0/1njJmsvXNfOLOIvER/94/XaH93pSaSY91hp8uyZcsG9RF/8MEHeeqppwDYu3cvO3fupKysbNAx1dXVLFq0CIClS5fS1NSUtnjHWtYmd627K6WOJS8vb2D5xRdf5IUXXuCVV17B7/ezYsWKlH3IPZ4jJV6n00kgEEhLrOMha8syYHeJ3HlQ+7srpaCgoIDu7u6U+zo7OykpKcHv9/PWW2+xYcOGNEeXfll75w72h6pg1921NKPU5FZWVsY555zDwoUL8fl8TJs2bWDfhRdeyI9//GNqamo49dRTWb58eQYjTY+sTu79dfdXGg5pcldK8eijj6bc7vF4eP7551Pu66+rl5eXs3Xr1oHtt99++5jHl05ZXZY5UnfXHjNKKZUsq5M7wPtPKWPXwR5au7XurpRS/bI+ufePM7OxUXvNKKVUv6xP7gtnFA70d1dKKWXL+uTucjo4s1rr7koplSzrkzvYpRmtuyul1BE5k9wBLc0opUYtPz8fgJaWFlauXJmyzYoVK6irqzvm4zzwwAP09fUNrE+UIYRzIrkvnFFIvselyV0pddxmzJjB2rVrT/j4ocl9ogwhnNVfYurncjo4s6pEk7tSE8Xzd8L+N8f2MaefDhfdO+zuO+64gzlz5vDFL3761KO3AAAXW0lEQVQRgLvuugsRYf369Rw+fJhIJMK3v/1tLrvsskHHNTU18YlPfIKtW7cSCAS4/vrr2b59O/Pnzx80tsxNN93Epk2bCAQCrFy5krvvvpsHH3yQlpYWzj//fMrLy1m3bt3AEMLl5eXcf//9PPLIIwDccMMN3HrrrTQ1NaVlaOGcuHMHuzSzu7WXg90n/oOySqnstWrVKp544omB9TVr1nD99dfz1FNP8dprr7Fu3Tpuu+02jDHDPsaPfvQj/H4/9fX1fO1rX2Pz5s0D++655x7q6uqor6/nz3/+M/X19dxyyy3MmDGDdevWsW7dukGPtXnzZn7605+yceNGNmzYwMMPP8zrr78OpGdo4Zy4c4ek/u4N7VxyxowMR6PUJHeMO+zxsnjxYg4ePEhLSwutra2UlJRQUVHBV77yFdavX4/D4eDdd9/lwIEDTJ8+PeVjrF+/nltuuQWAmpoaampqBvatWbOGhx56iGg0yr59+9i+ffug/UO9/PLLXHHFFQOjU37yk5/kpZde4tJLL03L0MI5k9wXJNXdNbkrNTmtXLmStWvXsn//flatWsXq1atpbW1l8+bNWJZFVVVVyqF+k4nIUdsaGxu577772LRpEyUlJVx33XUjPs6x3iGkY2jhnCnLaN1dKbVq1Soef/xx1q5dy8qVK+ns7GTq1KlYlsW6devYs2fPMY8/77zzWL16NQBbt26lvr4egK6uLvLy8igqKuLAgQODBiEbbqjh8847j6effpq+vj56e3t56qmnOPfcc8fwrz22EZO7iDwiIgdFZOsw+0VEHhSRXSJSLyJLxj7M0Rmou3dp3V2pyWjBggV0d3czc+ZMKioquOaaa6irq6O2tpbVq1czb968Yx5/00030dPTQ01NDd/5zndYtmwZAGeccQaLFy9mwYIFfO5zn+Occ84ZOObGG2/koosu4vzzzx/0WEuWLOG6665j2bJlnHXWWdxwww0sXrx47P/oYcix3joAiMh5QA/wC2PMwhT7Lwa+DFwMnAX8hzHmrJGeuLa21ozUf/R41Td3cOn3/8KDVy/mUi3NKJVWO3bsYP78+ZkOI6ekOqcistkYUzvSsSPeuRtj1gPH+m7/ZdiJ3xhjNgDFIpKRwdVPqyikQPu7K6XUmNTcZwJ7k9abE9uOIiI3ikidiNS1traOwVMPdmScGU3uSqnJbSyS+9EfLUPKWo8x5iFjTK0xpnbKlClj8NRHWz63lAatuyuVESOVedXoney5HIvk3gzMSlqvBFrG4HFPyMA4M406SqRS6eT1emlra9MEPwaMMbS1teH1ek/4Mcain/uzwM0i8jj2B6qdxph9Y/C4JyS57q4fqiqVPpWVlTQ3NzMeJdfJyOv1UllZecLHj5jcReQxYAVQLiLNwDcBC8AY82PgOeyeMruAPuD6E45mDGjdXanMsCyL6urqTIehEkZM7saYq0fYb4AvjVlEY+D9c8v401sHOdAVZFrhib+tUUqpbJUz31BNpuO7K6Umu5xM7qfN6K+764eqSqnJKSeTu9MhLKsuZaPeuSulJqmcTO5gl2YaDvVyQPu7K6UmoZxO7qB1d6XU5JSzyf20GYUUeLXurpSanHI2uTsdwlna310pNUnlbHIHuzTTeKiX/Z1ad1dKTS45n9wBNjbq3btSanLJ6eQ+v6K/7q7JXSk1ueR0cj9Sd9cPVZVSk0tOJ3fQurtSanKaFMkdtO6ulJpccj65z68opFDr7kqpSSbnk7s9zkwZr+zW5K6UmjyyM7n3Hjqu5svnltLU1se+zsA4BaSUUhNL9iX3v34PfnAWHG4a9SEDdXftNaOUmiSyL7m/7yKIR2H1pyFweFSHaN1dKTXZZF9yL38PrHoU2hvhib+DaHjEQ/rr7prclVKTRfYld4Cqc+CyH0DTS/DbW8GYEQ/RurtSajLJzuQOcMZVsOKfYctqeOm+EZu//xStuyulJo/sTe4AH7wDaq6CP30b3lx7zKbzpxdS5LO0S6RSalJwZTqAkyICl34POpvh6ZugcCbMeX/Kpo7E76pu0G+qKqUmgey+cwdweeCqX0HxbHj8M9C2e9imy+eWsaetj5YOrbsrpXJb9id3AH8pfGaNvbz609CXuq6+fG4poOPMKKVyX24kd4CyU+Dqx6BzLzxxLURDRzXpr7tv2K0fqiqlctuokruIXCgib4vILhG5M8X+60SkVUS2JKYbxj7UUZi9HC7/Eez5Czz75aO6SDoS47u/0tCGGUX3SaWUylYjJncRcQI/AC4CTgOuFpHTUjR9whizKDH9ZIzjHL3TV8KHvg71T8Cf/+2o3R+aN5V32vu48j9f4a39XRkIUCmlxt9o7tyXAbuMMQ3GmDDwOHDZ+IZ1ks69HRZdAy/+K7zxxKBdV9bO4jufqmHXwR4+/uDL/P/P7aA3FM1QoEopNT5Gk9xnAnuT1psT24b6lIjUi8haEZk1JtGdKBH4xANQdS488yVo+svALodDuPLMWfzpthVcWVvJQ+sbuODf/8zzb+7TUo1SKmeMJrlLim1Ds+BvgCpjTA3wAvDzlA8kcqOI1IlIXWtr6/FFerxcbrjql1BabXeRPLRz0O6SPDf/+skanrzpbEry3Ny0+jWu++kmmg71jm9cSimVBqNJ7s1A8p14JdCS3MAY02aM6e+e8jCwNNUDGWMeMsbUGmNqp0yZciLxHh9fCVzza3C4YPXKlOPAL51Twm9uPodvXnIam/cc5qMPrOeBF/5GMBIb//iUUmqcjCa5bwLeKyLVIuIGVgHPJjcQkYqk1UuBHWMX4kkqqYKrH4fu/fYdfOToH8p2OR1cf041/3PbB/nYguk88MJOPvbAel58+2D641VKqTEwYnI3xkSBm4HfYyftNcaYbSLyLRG5NNHsFhHZJiJvALcA141XwCdk1plwxX/C3o32MAXxeMpm0wq9fO/qxfzq82fhFOG6n27ii6s360iSSqmsI5n6ELG2ttbU1dWl90lffgBe+Ca8/2Y4/6vgzhu2aSga4+H1DXzvT7twOYSvfOR9fPbsKixn7nzvSymVfURkszGmdsR2kyq5G2OP/775Z+D0wNwVMO9ieN+FUDA95SF72/v45rPb+NNbB5k3vYB/uXwhZ1aVpjNqpZQaoMl9OMZA08vw9nPw1n9Dxx57+8xaO9GfejFMmWd3pxw4xPDH7Qe4+zfbebcjwKVnzOBD86ayZHYJs0p9iKTqUKSUUmNPk/toGAMHd8Db/w1vPQctr9nbS6ph3sfh1Itg1nJw2iMj94WjfO9Pu/jFX5voDdu9acrz3SyaVcKSOcUsmV1CTWURfnd2j6SslJq4NLmfiK598Lfn7UTf+GeIhcFXCu/7mJ3oT7kAPPlEY3H+dqCH1945zGvvHOb1dzpoTPSPdzqEedMLWDK7hMWz7YQ/p8yvd/dKqTGhyf1khbph95/sRL/z9xA4nKjTfxDe8xGYOg9KT4HCGSDC4d4wr+89zGt7Onh972G2vNMxcHdfmudm8axilsyxE35NZTH5Hr27V0odP03uYykWhXdegbeft0s4h5uO7LP8UDrXHnK49BR7XvYeYiVz+Vu3h9f3dg7c4Te0Hvn2a3m+h8oSH7NK/cwamPuZVepjRrFPe+UopVLS5D5ejLF/1q9tF7TvhraGI8uHmyCeNAiZpwjK5kLZe6D0FHrz57AjMpXXu0vY1eVib0eA5sMBWjoCRONH/h0cAhVFPipLfFQmEr6d+O3laQVeHA4t8yg1GWlyz4RYBDresX/qr323Pe9P/B17GTQkj+W3u18WzCCeP41ez1QOOcrYFy/mnXARuwIFbOvx0Xg4xoHu4KCh6V0OYUqBx57yPUeWE+tTCz1MyfcypcCDz+1M+2lQSo2f0SZ3LfyOJaeVKMuccvS+SNC+s2/fDe2N0L0Pulqgez+Ols0UdO2jIBaiGjg7+Th/GfFZ0wl6p9FpldMqJeyLFXMgkkdLxMfedi/1zR4aet0Ejfuop833uFJeBIr9FiV+98C8f9lr6cVAqVygyT1dLK/9IezUean3G2N/aNu9z+61071v4ALg6N6Pv7sFf9tWKnpbqTlqUE7AA8byE/GUELKK6HMW0iWFdJDPoVgeB/ryaOnwsTfg5fWwjy7y6DJ+uvETxhp4GJ/lpMRvUex3U5KXmA9cCI4sF/pcFHotinwWhT4Lj8uhPYKUmkA0uU8UIvYPfftLYdqC4dvFItBzEALt9g+BJ82l7zDuQDvuvnYKAu1M69tt7w90MFASEsAz5CEdHsJWAQFnPn2SRw95dIX8HA74aI/5OBT1cjDsYY/Jowsf3cZPLz568NJnvPTixTg9FPosCr0WBb5E0ve6BrYV+lyJbRYFXhcFiXm+x0WB10We26WfIyg1hjS5ZxunBUUz7Wm04jEIdg6+GIS67G3BDpzBLnzBTnzBTkqDnYl9zfb+cAeYCEk396mfAich4yMY9NEX9NF72EuP8dIdd9MR89AT99KDl4PGnvfhpdf46MVDH156jM8e68edj8Obj9OTT57PM3AByPdY5HtdFHhc5Htd5Hlc5LmdibmLPI+97Hc79UKhFJrcJweH88i7guNlDESDEOy/GCSmcA+EexPzHhyhHnzhXnzhHkrCPRA6st+EDw2sS3SEETYjiakbQnjoEy+9xp66jGfgnUIAD/uMmwAeArgJGg99eOx14ybu9GEsH7j9iOXH6fHjcPuxvHk4PXl4vH78iYuB352YJy4YvsQFYug2t1NLTyp7aHJXxyYCls+eCqad2EMkr8Si9gUh0pdI+D1HLhShnkEXDU+4B0+oh5L+i0Soh3ioh3joMEQCEAngiNqTpPocIg4EE1P34F0xhICxLwwBY797COKmL3GRaMczsBxMLIfEQ8zlI+b0gcsLLi8Oy4NYXhyWD6fbi8vjxeH2Ybl9WB4flseP1+PF53His1z43E78bidelxOf24HH5cRr2RcPr8uBS7/foMaIJneVXk4X+Irt6TgJ4ExMgxgD0ZB9wUgkfXu5L8W2AIR7cUYC5Ef68IV6iIX6iIV6iYd6MJEAhPuQSAeOaBBHtA9nLIArHj7yfLHEFBoaSGpxI4RxEcIihJuQsQhhEcRNJ9ag9TBuYg43UYeHmNND3OEh7vSAq3/uRSwvxvIhlg+x/DjcPsSdh8Ptw+XJw+XNw/L48Lg9eC0nXssxMO+/mPQvW07RdyM5SpO7yn4idm8ky3vch6a8WKQSj9kXh3DighEN2eWqYeYmGiQWDhINBYiG7SkWDiCRIO5wACsaJj8ahGgQiYWQaBBHrAdHPIQzFsYZD2PFQljREA5S/7jMSMLGSZAj706CuOnBTRC722z/BScqHqIO+6JiX1DcGKd9MTGJSVz9FxYP4vLisNw4XF6cbi8Olwenx4PL8uJ0e+x3LW4vltuNx+XE43LgsRy4nQ48ljMxT6xrL6txo8ldqdFwOMFTYE+jINj/ucbkP1gsOuQCEhz0bsRE+ogEe+0LSaiXaLCXeLiPWKiPeKQPEw7gjvThjgQo6i9jxcI4Yn04YiGc8TCOeBhXPIwrGsIykbGImpgRwliEcRHGfncSMi66sYjiJIqDKC7iOIiLCyNO4uLEOFz2usMJ/XOHCxwWOFyI02VfgFxe4k4vJnHhMYl3Nf3vbhyWD4fbZ88tL06PH5fHh9Ptw225sVwu3JYTt8uB5RQ8TieWS3A7HTgd2f+ORpO7UhOd0wXOfPDkp9wtgDsxjYl43B4RNRo8Mh+4sIQhGoBoCBMNEY2EEu9MQsTCQWKRELFIkHgkRDxqz03EbkvMvni4YiGIxzCxqD1ch4ki8RjEozjiQcREERNDTAxHPIYjGsVhYjhMDCcxnCaKmwgW0ZH/lhHEjBDDQRwHMRxEcRDCObDN4CAuDuI4MXJkOSYWMYeLmFjExSLmsOdxp4Vx2FM8MTdODzgtjNMNTgtxupm66ELmLlw+Bv9Yw9PkrpQazOEAx8hlLsHuITtCL9nxE48NXHhMpI9oOEgk2Ec0FCAW7iMasrfFI33Ew0Hi4QDxSBATCRCPRYjHYsTjUUwsRjweS8yjmFgUE49h4jH7ItS/bOx14jEcJoIjHsFpojhiITzRHlwmitNEcBHFGphH7TlRLIkNhL7Rk6/JXSmlUnI4E9+NyEMozeyFZhRisRiRsP1uZ5HbM/IBJ0mTu1JKpYHT6cTp84PPn5bn0061SimVgzS5K6VUDsrYeO4i0grsOcHDy4FDYxjOWNP4To7Gd/Imeowa34mbY4yZMlKjjCX3kyEidaMZrD5TNL6To/GdvIkeo8Y3/rQso5RSOUiTu1JK5aBsTe4PZTqAEWh8J0fjO3kTPUaNb5xlZc1dKaXUsWXrnbtSSqlj0OSulFI5aEIndxG5UETeFpFdInJniv0eEXkisX+jiFSlMbZZIrJORHaIyDYR+ccUbVaISKeIbElM30hXfInnbxKRNxPPXZdiv4jIg4nzVy8iS9IY26lJ52WLiHSJyK1D2qT9/InIIyJyUES2Jm0rFZE/isjOxLxkmGM/m2izU0Q+m6bYvisibyX+/Z4SkZS/gjLSa2GcY7xLRN5N+ne8eJhjj/n/fRzjeyIptiYR2TLMsWk5h2PGGDMhJ+zfUNgNzMUezfQN4LQhbb4I/DixvAp4Io3xVQBLEssFwN9SxLcC+G0Gz2ETUH6M/RcDz2MP8Lcc2JjBf+v92F/OyOj5A84DlgBbk7Z9B7gzsXwn8G8pjisFGhLzksRySRpi+yjgSiz/W6rYRvNaGOcY7wJuH8Vr4Jj/38crviH7/x34RibP4VhNE/nOfRmwyxjTYIwJA48Dlw1pcxnw88TyWuACSdMI+8aYfcaY1xLL3cAOYGY6nnsMXQb8wtg2AMUiUpGBOC4AdhtjTvQby2PGGLMeaB+yOfl19nPg8hSHfgz4ozGm3RhzGPgjcOF4x2aM+YMxpn9g8w1A5Vg+5/Ea5vyNxmj+v5+0Y8WXyB1XAo+N9fNmwkRO7jOBvUnrzRydPAfaJF7gnUBZWqJLkigHLQY2ptj9fhF5Q0SeF5EFaQ0MDPAHEdksIjem2D+ac5wOqxj+P1Qmz1+/acaYfWBf1IGpKdpMhHP5Oex3YqmM9FoYbzcnSkePDFPWmgjn71zggDFm5zD7M30Oj8tETu6p7sCH9tscTZtxJSL5wJPArcaYriG7X8MuNZwBfA94Op2xAecYY5YAFwFfEpHzhuyfCOfPDVwK/DrF7kyfv+OR0XMpIl8DosDqYZqM9FoYTz8CTgEWAfuwSx9DZfy1CFzNse/aM3kOj9tETu7NwKyk9UqgZbg2IuICijixt4QnREQs7MS+2hjzf4fuN8Z0GWN6EsvPAZaIlKcrPmNMS2J+EHgK+61vstGc4/F2EfCaMebA0B2ZPn9JDvSXqxLzgynaZOxcJj68/QRwjUkUh4caxWth3BhjDhhjYsaYOPDwMM+d0ddiIn98EnhiuDaZPIcnYiIn903Ae0WkOnF3twp4dkibZ4H+XgkrgT8N9+Iea4n63H8BO4wx9w/TZnr/ZwAisgz7fLelKb48ESnoX8b+4G3rkGbPAn+f6DWzHOjsLz+k0bB3S5k8f0Mkv84+CzyTos3vgY+KSEmi7PDRxLZxJSIXAncAlxpj+oZpM5rXwnjGmPw5zhXDPPdo/r+Ppw8DbxljmlPtzPQ5PCGZ/kT3WBN2b46/YX+K/rXEtm9hv5ABvNhv53cBrwJz0xjbB7DfNtYDWxLTxcA/AP+QaHMzsA37k/8NwNlpjG9u4nnfSMTQf/6S4xPgB4nz+yZQm+Z/Xz92si5K2pbR84d9odkHRLDvJj+P/TnO/wA7E/PSRNta4CdJx34u8VrcBVyfpth2Ydeq+1+D/b3HZgDPHeu1kMbz98vE66seO2FXDI0xsX7U//d0xJfY/rP+111S24ycw7GadPgBpZTKQRO5LKOUUuoEaXJXSqkcpMldKaVykCZ3pZTKQZrclVIqB2lyV0qpHKTJXSmlctD/A6KnTpwtFqSRAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "K.clear_session()\n",
    "model1 = keras.models.Sequential()\n",
    "#model1.add(layers.Dense (128, input_shape =input_shape, activation ='relu'))\n",
    "model1.add(layers.Dense (128, input_shape =(img_rows*img_cols,), activation ='relu'))\n",
    "model1.add(layers.Dense (128, activation ='relu'))\n",
    "model1.add(layers.Dense (10, activation='softmax'))\n",
    "model1.summary()\n",
    "model1.compile(loss=\"categorical_crossentropy\", optimizer ='sgd', metrics =['accuracy'])\n",
    "history = model1.fit(X_train , Y_train , batch_size=128, epochs=20, validation_data=(X_test, Y_test))\n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(b) Build a new network by adding dropout (p=0.3) to the first andsecond layer of the model from (a). Train it for 250 episodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 128)               100480    \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 128)               16512     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 118,282\n",
      "Trainable params: 118,282\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/250\n",
      "60000/60000 [==============================] - 5s 82us/step - loss: 1.6070 - acc: 0.4865 - val_loss: 0.7839 - val_acc: 0.8225\n",
      "Epoch 2/250\n",
      "60000/60000 [==============================] - 3s 53us/step - loss: 0.8205 - acc: 0.7479 - val_loss: 0.4815 - val_acc: 0.8758\n",
      "Epoch 3/250\n",
      "60000/60000 [==============================] - 4s 58us/step - loss: 0.6201 - acc: 0.8114 - val_loss: 0.3900 - val_acc: 0.8945\n",
      "Epoch 4/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.5338 - acc: 0.8396 - val_loss: 0.3451 - val_acc: 0.9044\n",
      "Epoch 5/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.4794 - acc: 0.8568 - val_loss: 0.3159 - val_acc: 0.9124\n",
      "Epoch 6/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.4431 - acc: 0.8680 - val_loss: 0.2950 - val_acc: 0.9179\n",
      "Epoch 7/250\n",
      "60000/60000 [==============================] - 3s 54us/step - loss: 0.4103 - acc: 0.8794 - val_loss: 0.2761 - val_acc: 0.9209\n",
      "Epoch 8/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.3900 - acc: 0.8845 - val_loss: 0.2630 - val_acc: 0.9252\n",
      "Epoch 9/250\n",
      "60000/60000 [==============================] - 3s 47us/step - loss: 0.3687 - acc: 0.8910 - val_loss: 0.2497 - val_acc: 0.9300\n",
      "Epoch 10/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.3523 - acc: 0.8953 - val_loss: 0.2403 - val_acc: 0.9306\n",
      "Epoch 11/250\n",
      "60000/60000 [==============================] - 3s 57us/step - loss: 0.3388 - acc: 0.9016 - val_loss: 0.2298 - val_acc: 0.9338\n",
      "Epoch 12/250\n",
      "60000/60000 [==============================] - 5s 76us/step - loss: 0.3236 - acc: 0.9054 - val_loss: 0.2207 - val_acc: 0.9354\n",
      "Epoch 13/250\n",
      "60000/60000 [==============================] - 4s 64us/step - loss: 0.3145 - acc: 0.9073 - val_loss: 0.2122 - val_acc: 0.9378\n",
      "Epoch 14/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.3032 - acc: 0.9116 - val_loss: 0.2054 - val_acc: 0.9397\n",
      "Epoch 15/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.2982 - acc: 0.9116 - val_loss: 0.2002 - val_acc: 0.9415\n",
      "Epoch 16/250\n",
      "60000/60000 [==============================] - 4s 69us/step - loss: 0.2851 - acc: 0.9162 - val_loss: 0.1932 - val_acc: 0.9428\n",
      "Epoch 17/250\n",
      "60000/60000 [==============================] - 4s 59us/step - loss: 0.2784 - acc: 0.9179 - val_loss: 0.1870 - val_acc: 0.9453\n",
      "Epoch 18/250\n",
      "60000/60000 [==============================] - 3s 58us/step - loss: 0.2677 - acc: 0.9221 - val_loss: 0.1823 - val_acc: 0.9454\n",
      "Epoch 19/250\n",
      "60000/60000 [==============================] - 5s 79us/step - loss: 0.2635 - acc: 0.9236 - val_loss: 0.1770 - val_acc: 0.9471\n",
      "Epoch 20/250\n",
      "60000/60000 [==============================] - 5s 76us/step - loss: 0.2548 - acc: 0.9257 - val_loss: 0.1725 - val_acc: 0.9483\n",
      "Epoch 21/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.2501 - acc: 0.9267 - val_loss: 0.1678 - val_acc: 0.9502\n",
      "Epoch 22/250\n",
      "60000/60000 [==============================] - 2s 42us/step - loss: 0.2433 - acc: 0.9282 - val_loss: 0.1642 - val_acc: 0.9516\n",
      "Epoch 23/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.2399 - acc: 0.9289 - val_loss: 0.1603 - val_acc: 0.9523\n",
      "Epoch 24/250\n",
      "60000/60000 [==============================] - 2s 41us/step - loss: 0.2349 - acc: 0.9312 - val_loss: 0.1573 - val_acc: 0.9543\n",
      "Epoch 25/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.2307 - acc: 0.9333 - val_loss: 0.1548 - val_acc: 0.9547\n",
      "Epoch 26/250\n",
      "60000/60000 [==============================] - 2s 42us/step - loss: 0.2263 - acc: 0.9331 - val_loss: 0.1514 - val_acc: 0.9550\n",
      "Epoch 27/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.2198 - acc: 0.9349 - val_loss: 0.1486 - val_acc: 0.9564\n",
      "Epoch 28/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.2159 - acc: 0.9375 - val_loss: 0.1460 - val_acc: 0.9560\n",
      "Epoch 29/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.2115 - acc: 0.9381 - val_loss: 0.1429 - val_acc: 0.9574\n",
      "Epoch 30/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.2078 - acc: 0.9391 - val_loss: 0.1396 - val_acc: 0.9582\n",
      "Epoch 31/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.2056 - acc: 0.9396 - val_loss: 0.1380 - val_acc: 0.9592\n",
      "Epoch 32/250\n",
      "60000/60000 [==============================] - 3s 57us/step - loss: 0.2017 - acc: 0.9407 - val_loss: 0.1362 - val_acc: 0.9597\n",
      "Epoch 33/250\n",
      "60000/60000 [==============================] - 3s 48us/step - loss: 0.1993 - acc: 0.9416 - val_loss: 0.1331 - val_acc: 0.9593\n",
      "Epoch 34/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.1957 - acc: 0.9434 - val_loss: 0.1311 - val_acc: 0.9610\n",
      "Epoch 35/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.1909 - acc: 0.9432 - val_loss: 0.1295 - val_acc: 0.9608\n",
      "Epoch 36/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.1867 - acc: 0.9453 - val_loss: 0.1275 - val_acc: 0.9612\n",
      "Epoch 37/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.1884 - acc: 0.9437 - val_loss: 0.1249 - val_acc: 0.9625\n",
      "Epoch 38/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.1838 - acc: 0.9462 - val_loss: 0.1232 - val_acc: 0.9632\n",
      "Epoch 39/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.1817 - acc: 0.9466 - val_loss: 0.1215 - val_acc: 0.9632\n",
      "Epoch 40/250\n",
      "60000/60000 [==============================] - 3s 48us/step - loss: 0.1776 - acc: 0.9473 - val_loss: 0.1199 - val_acc: 0.9642\n",
      "Epoch 41/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.1749 - acc: 0.9482 - val_loss: 0.1185 - val_acc: 0.9651\n",
      "Epoch 42/250\n",
      "60000/60000 [==============================] - 2s 41us/step - loss: 0.1748 - acc: 0.9490 - val_loss: 0.1170 - val_acc: 0.9652\n",
      "Epoch 43/250\n",
      "60000/60000 [==============================] - 3s 50us/step - loss: 0.1721 - acc: 0.9495 - val_loss: 0.1158 - val_acc: 0.9655\n",
      "Epoch 44/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.1695 - acc: 0.9502 - val_loss: 0.1140 - val_acc: 0.9657\n",
      "Epoch 45/250\n",
      "60000/60000 [==============================] - 4s 59us/step - loss: 0.1688 - acc: 0.9500 - val_loss: 0.1129 - val_acc: 0.9657\n",
      "Epoch 46/250\n",
      "60000/60000 [==============================] - 5s 84us/step - loss: 0.1675 - acc: 0.9511 - val_loss: 0.1125 - val_acc: 0.9658\n",
      "Epoch 47/250\n",
      "60000/60000 [==============================] - 4s 68us/step - loss: 0.1619 - acc: 0.9522 - val_loss: 0.1108 - val_acc: 0.9665\n",
      "Epoch 48/250\n",
      "60000/60000 [==============================] - 4s 63us/step - loss: 0.1625 - acc: 0.9521 - val_loss: 0.1086 - val_acc: 0.9674\n",
      "Epoch 49/250\n",
      "60000/60000 [==============================] - 5s 80us/step - loss: 0.1616 - acc: 0.9522 - val_loss: 0.1087 - val_acc: 0.9667\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 50/250\n",
      "60000/60000 [==============================] - 3s 56us/step - loss: 0.1590 - acc: 0.9525 - val_loss: 0.1076 - val_acc: 0.9676\n",
      "Epoch 51/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.1573 - acc: 0.9541 - val_loss: 0.1064 - val_acc: 0.9674\n",
      "Epoch 52/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.1563 - acc: 0.9539 - val_loss: 0.1053 - val_acc: 0.9677\n",
      "Epoch 53/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.1521 - acc: 0.9550 - val_loss: 0.1036 - val_acc: 0.9686\n",
      "Epoch 54/250\n",
      "60000/60000 [==============================] - 4s 62us/step - loss: 0.1513 - acc: 0.9546 - val_loss: 0.1032 - val_acc: 0.9688\n",
      "Epoch 55/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.1508 - acc: 0.9560 - val_loss: 0.1019 - val_acc: 0.9690\n",
      "Epoch 56/250\n",
      "60000/60000 [==============================] - 4s 62us/step - loss: 0.1488 - acc: 0.9552 - val_loss: 0.1017 - val_acc: 0.9693\n",
      "Epoch 57/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.1459 - acc: 0.9560 - val_loss: 0.1007 - val_acc: 0.9696\n",
      "Epoch 58/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.1461 - acc: 0.9569 - val_loss: 0.0997 - val_acc: 0.9702\n",
      "Epoch 59/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.1452 - acc: 0.9573 - val_loss: 0.0995 - val_acc: 0.9699\n",
      "Epoch 60/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.1411 - acc: 0.9588 - val_loss: 0.0981 - val_acc: 0.9706\n",
      "Epoch 61/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.1411 - acc: 0.9589 - val_loss: 0.0978 - val_acc: 0.9708\n",
      "Epoch 62/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.1401 - acc: 0.9575 - val_loss: 0.0964 - val_acc: 0.9710\n",
      "Epoch 63/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.1404 - acc: 0.9579 - val_loss: 0.0964 - val_acc: 0.9713\n",
      "Epoch 64/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.1382 - acc: 0.9600 - val_loss: 0.0954 - val_acc: 0.9713\n",
      "Epoch 65/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.1393 - acc: 0.9586 - val_loss: 0.0953 - val_acc: 0.9716\n",
      "Epoch 66/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.1364 - acc: 0.9599 - val_loss: 0.0940 - val_acc: 0.9715\n",
      "Epoch 67/250\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.1343 - acc: 0.9600 - val_loss: 0.0933 - val_acc: 0.9720\n",
      "Epoch 68/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.1323 - acc: 0.9600 - val_loss: 0.0936 - val_acc: 0.9720\n",
      "Epoch 69/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.1315 - acc: 0.9609 - val_loss: 0.0931 - val_acc: 0.9718\n",
      "Epoch 70/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.1322 - acc: 0.9606 - val_loss: 0.0917 - val_acc: 0.9721\n",
      "Epoch 71/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.1298 - acc: 0.9610 - val_loss: 0.0913 - val_acc: 0.9730\n",
      "Epoch 72/250\n",
      "60000/60000 [==============================] - 3s 56us/step - loss: 0.1290 - acc: 0.9624 - val_loss: 0.0905 - val_acc: 0.9727\n",
      "Epoch 73/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.1291 - acc: 0.9611 - val_loss: 0.0903 - val_acc: 0.9733\n",
      "Epoch 74/250\n",
      "60000/60000 [==============================] - 3s 47us/step - loss: 0.1267 - acc: 0.9623 - val_loss: 0.0893 - val_acc: 0.9730\n",
      "Epoch 75/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.1252 - acc: 0.9629 - val_loss: 0.0891 - val_acc: 0.9730\n",
      "Epoch 76/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.1264 - acc: 0.9619 - val_loss: 0.0889 - val_acc: 0.9736\n",
      "Epoch 77/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.1249 - acc: 0.9624 - val_loss: 0.0880 - val_acc: 0.9737\n",
      "Epoch 78/250\n",
      "60000/60000 [==============================] - 4s 67us/step - loss: 0.1234 - acc: 0.9635 - val_loss: 0.0881 - val_acc: 0.9740\n",
      "Epoch 79/250\n",
      "60000/60000 [==============================] - 4s 67us/step - loss: 0.1219 - acc: 0.9641 - val_loss: 0.0878 - val_acc: 0.9739\n",
      "Epoch 80/250\n",
      "60000/60000 [==============================] - 4s 65us/step - loss: 0.1218 - acc: 0.9631 - val_loss: 0.0868 - val_acc: 0.9737\n",
      "Epoch 81/250\n",
      "60000/60000 [==============================] - 5s 81us/step - loss: 0.1219 - acc: 0.9636 - val_loss: 0.0861 - val_acc: 0.9744\n",
      "Epoch 82/250\n",
      "60000/60000 [==============================] - 5s 87us/step - loss: 0.1209 - acc: 0.9638 - val_loss: 0.0855 - val_acc: 0.9741\n",
      "Epoch 83/250\n",
      "60000/60000 [==============================] - 4s 60us/step - loss: 0.1195 - acc: 0.9645 - val_loss: 0.0854 - val_acc: 0.9747\n",
      "Epoch 84/250\n",
      "60000/60000 [==============================] - 4s 58us/step - loss: 0.1180 - acc: 0.9648 - val_loss: 0.0850 - val_acc: 0.9747\n",
      "Epoch 85/250\n",
      "60000/60000 [==============================] - 4s 65us/step - loss: 0.1164 - acc: 0.9653 - val_loss: 0.0849 - val_acc: 0.9744\n",
      "Epoch 86/250\n",
      "60000/60000 [==============================] - 3s 57us/step - loss: 0.1179 - acc: 0.9649 - val_loss: 0.0843 - val_acc: 0.9752\n",
      "Epoch 87/250\n",
      "60000/60000 [==============================] - 3s 50us/step - loss: 0.1183 - acc: 0.9652 - val_loss: 0.0842 - val_acc: 0.9746\n",
      "Epoch 88/250\n",
      "60000/60000 [==============================] - 4s 62us/step - loss: 0.1156 - acc: 0.9655 - val_loss: 0.0840 - val_acc: 0.9750\n",
      "Epoch 89/250\n",
      "60000/60000 [==============================] - 3s 48us/step - loss: 0.1132 - acc: 0.9656 - val_loss: 0.0834 - val_acc: 0.9755\n",
      "Epoch 90/250\n",
      "60000/60000 [==============================] - 3s 53us/step - loss: 0.1159 - acc: 0.9647 - val_loss: 0.0830 - val_acc: 0.9752\n",
      "Epoch 91/250\n",
      "60000/60000 [==============================] - 3s 48us/step - loss: 0.1099 - acc: 0.9672 - val_loss: 0.0827 - val_acc: 0.9754\n",
      "Epoch 92/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.1123 - acc: 0.9668 - val_loss: 0.0828 - val_acc: 0.9760\n",
      "Epoch 93/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.1130 - acc: 0.9663 - val_loss: 0.0828 - val_acc: 0.9760\n",
      "Epoch 94/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.1110 - acc: 0.9667 - val_loss: 0.0824 - val_acc: 0.9764\n",
      "Epoch 95/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.1114 - acc: 0.9668 - val_loss: 0.0815 - val_acc: 0.9764\n",
      "Epoch 96/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.1091 - acc: 0.9667 - val_loss: 0.0816 - val_acc: 0.9761\n",
      "Epoch 97/250\n",
      "60000/60000 [==============================] - 4s 68us/step - loss: 0.1106 - acc: 0.9666 - val_loss: 0.0815 - val_acc: 0.9763\n",
      "Epoch 98/250\n",
      "60000/60000 [==============================] - 4s 59us/step - loss: 0.1067 - acc: 0.9682 - val_loss: 0.0809 - val_acc: 0.9764\n",
      "Epoch 99/250\n",
      "60000/60000 [==============================] - 3s 56us/step - loss: 0.1078 - acc: 0.9680 - val_loss: 0.0804 - val_acc: 0.9774\n",
      "Epoch 100/250\n",
      "60000/60000 [==============================] - 3s 54us/step - loss: 0.1081 - acc: 0.9671 - val_loss: 0.0801 - val_acc: 0.9766\n",
      "Epoch 101/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.1065 - acc: 0.9682 - val_loss: 0.0799 - val_acc: 0.9764\n",
      "Epoch 102/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.1069 - acc: 0.9675 - val_loss: 0.0804 - val_acc: 0.9763\n",
      "Epoch 103/250\n",
      "60000/60000 [==============================] - 3s 53us/step - loss: 0.1072 - acc: 0.9672 - val_loss: 0.0795 - val_acc: 0.9766\n",
      "Epoch 104/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.1056 - acc: 0.9679 - val_loss: 0.0790 - val_acc: 0.9760\n",
      "Epoch 105/250\n",
      "60000/60000 [==============================] - 3s 48us/step - loss: 0.1031 - acc: 0.9687 - val_loss: 0.0790 - val_acc: 0.9767\n",
      "Epoch 106/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.1034 - acc: 0.9691 - val_loss: 0.0790 - val_acc: 0.9768\n",
      "Epoch 107/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.1025 - acc: 0.9685 - val_loss: 0.0798 - val_acc: 0.9772\n",
      "Epoch 108/250\n",
      "60000/60000 [==============================] - 3s 50us/step - loss: 0.1028 - acc: 0.9690 - val_loss: 0.0787 - val_acc: 0.9769\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 109/250\n",
      "60000/60000 [==============================] - 2s 41us/step - loss: 0.1008 - acc: 0.9693 - val_loss: 0.0785 - val_acc: 0.9774\n",
      "Epoch 110/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.1005 - acc: 0.9698 - val_loss: 0.0778 - val_acc: 0.9772\n",
      "Epoch 111/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.0999 - acc: 0.9702 - val_loss: 0.0776 - val_acc: 0.9779\n",
      "Epoch 112/250\n",
      "60000/60000 [==============================] - 3s 52us/step - loss: 0.1001 - acc: 0.9700 - val_loss: 0.0771 - val_acc: 0.9774\n",
      "Epoch 113/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0976 - acc: 0.9709 - val_loss: 0.0772 - val_acc: 0.9770\n",
      "Epoch 114/250\n",
      "60000/60000 [==============================] - 3s 57us/step - loss: 0.0998 - acc: 0.9701 - val_loss: 0.0773 - val_acc: 0.9772\n",
      "Epoch 115/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0991 - acc: 0.9695 - val_loss: 0.0769 - val_acc: 0.9773\n",
      "Epoch 116/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.0968 - acc: 0.9710 - val_loss: 0.0768 - val_acc: 0.9776\n",
      "Epoch 117/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.0980 - acc: 0.9706 - val_loss: 0.0768 - val_acc: 0.9776\n",
      "Epoch 118/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.0958 - acc: 0.9709 - val_loss: 0.0769 - val_acc: 0.9777\n",
      "Epoch 119/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.0956 - acc: 0.9709 - val_loss: 0.0760 - val_acc: 0.9770\n",
      "Epoch 120/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0955 - acc: 0.9702 - val_loss: 0.0764 - val_acc: 0.9784\n",
      "Epoch 121/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0946 - acc: 0.9715 - val_loss: 0.0757 - val_acc: 0.9771\n",
      "Epoch 122/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0927 - acc: 0.9720 - val_loss: 0.0751 - val_acc: 0.9768\n",
      "Epoch 123/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0936 - acc: 0.9717 - val_loss: 0.0752 - val_acc: 0.9776\n",
      "Epoch 124/250\n",
      "60000/60000 [==============================] - 4s 61us/step - loss: 0.0943 - acc: 0.9714 - val_loss: 0.0752 - val_acc: 0.9776\n",
      "Epoch 125/250\n",
      "60000/60000 [==============================] - 4s 66us/step - loss: 0.0923 - acc: 0.9722 - val_loss: 0.0755 - val_acc: 0.9772\n",
      "Epoch 126/250\n",
      "60000/60000 [==============================] - 4s 61us/step - loss: 0.0932 - acc: 0.9719 - val_loss: 0.0750 - val_acc: 0.9778\n",
      "Epoch 127/250\n",
      "60000/60000 [==============================] - 3s 56us/step - loss: 0.0923 - acc: 0.9727 - val_loss: 0.0750 - val_acc: 0.9773\n",
      "Epoch 128/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.0904 - acc: 0.9731 - val_loss: 0.0749 - val_acc: 0.9775\n",
      "Epoch 129/250\n",
      "60000/60000 [==============================] - 3s 54us/step - loss: 0.0906 - acc: 0.9724 - val_loss: 0.0744 - val_acc: 0.9782\n",
      "Epoch 130/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.0903 - acc: 0.9722 - val_loss: 0.0740 - val_acc: 0.9776\n",
      "Epoch 131/250\n",
      "60000/60000 [==============================] - 4s 61us/step - loss: 0.0903 - acc: 0.9730 - val_loss: 0.0736 - val_acc: 0.9788\n",
      "Epoch 132/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.0899 - acc: 0.9725 - val_loss: 0.0731 - val_acc: 0.9781\n",
      "Epoch 133/250\n",
      "60000/60000 [==============================] - 4s 61us/step - loss: 0.0889 - acc: 0.9726 - val_loss: 0.0732 - val_acc: 0.9784\n",
      "Epoch 134/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.0891 - acc: 0.9726 - val_loss: 0.0735 - val_acc: 0.9784\n",
      "Epoch 135/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.0891 - acc: 0.9727 - val_loss: 0.0742 - val_acc: 0.9776\n",
      "Epoch 136/250\n",
      "60000/60000 [==============================] - 3s 56us/step - loss: 0.0885 - acc: 0.9732 - val_loss: 0.0729 - val_acc: 0.9785\n",
      "Epoch 137/250\n",
      "60000/60000 [==============================] - 3s 54us/step - loss: 0.0865 - acc: 0.9734 - val_loss: 0.0727 - val_acc: 0.9785\n",
      "Epoch 138/250\n",
      "60000/60000 [==============================] - 3s 57us/step - loss: 0.0869 - acc: 0.9737 - val_loss: 0.0729 - val_acc: 0.9780\n",
      "Epoch 139/250\n",
      "60000/60000 [==============================] - 3s 58us/step - loss: 0.0874 - acc: 0.9733 - val_loss: 0.0728 - val_acc: 0.9786\n",
      "Epoch 140/250\n",
      "60000/60000 [==============================] - 3s 52us/step - loss: 0.0869 - acc: 0.9734 - val_loss: 0.0723 - val_acc: 0.9784\n",
      "Epoch 141/250\n",
      "60000/60000 [==============================] - 3s 56us/step - loss: 0.0858 - acc: 0.9738 - val_loss: 0.0725 - val_acc: 0.9785\n",
      "Epoch 142/250\n",
      "60000/60000 [==============================] - 5s 78us/step - loss: 0.0864 - acc: 0.9730 - val_loss: 0.0723 - val_acc: 0.9790\n",
      "Epoch 143/250\n",
      "60000/60000 [==============================] - 4s 70us/step - loss: 0.0832 - acc: 0.9749 - val_loss: 0.0724 - val_acc: 0.9786\n",
      "Epoch 144/250\n",
      "60000/60000 [==============================] - 2s 41us/step - loss: 0.0844 - acc: 0.9739 - val_loss: 0.0720 - val_acc: 0.9784\n",
      "Epoch 145/250\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.0844 - acc: 0.9739 - val_loss: 0.0724 - val_acc: 0.9783\n",
      "Epoch 146/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.0837 - acc: 0.9741 - val_loss: 0.0718 - val_acc: 0.9787\n",
      "Epoch 147/250\n",
      "60000/60000 [==============================] - 3s 58us/step - loss: 0.0856 - acc: 0.9745 - val_loss: 0.0720 - val_acc: 0.9792\n",
      "Epoch 148/250\n",
      "60000/60000 [==============================] - 4s 73us/step - loss: 0.0858 - acc: 0.9742 - val_loss: 0.0712 - val_acc: 0.9794\n",
      "Epoch 149/250\n",
      "60000/60000 [==============================] - 3s 58us/step - loss: 0.0827 - acc: 0.9742 - val_loss: 0.0712 - val_acc: 0.9794\n",
      "Epoch 150/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.0834 - acc: 0.9750 - val_loss: 0.0710 - val_acc: 0.9792\n",
      "Epoch 151/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0817 - acc: 0.9754 - val_loss: 0.0712 - val_acc: 0.9795\n",
      "Epoch 152/250\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.0804 - acc: 0.9746 - val_loss: 0.0711 - val_acc: 0.9793\n",
      "Epoch 153/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0814 - acc: 0.9754 - val_loss: 0.0707 - val_acc: 0.9787\n",
      "Epoch 154/250\n",
      "60000/60000 [==============================] - 3s 50us/step - loss: 0.0836 - acc: 0.9742 - val_loss: 0.0707 - val_acc: 0.9789\n",
      "Epoch 155/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.0812 - acc: 0.9752 - val_loss: 0.0710 - val_acc: 0.9790\n",
      "Epoch 156/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0827 - acc: 0.9751 - val_loss: 0.0707 - val_acc: 0.9789\n",
      "Epoch 157/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0803 - acc: 0.9753 - val_loss: 0.0710 - val_acc: 0.9790\n",
      "Epoch 158/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0794 - acc: 0.9751 - val_loss: 0.0707 - val_acc: 0.9789\n",
      "Epoch 159/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0799 - acc: 0.9754 - val_loss: 0.0699 - val_acc: 0.9791\n",
      "Epoch 160/250\n",
      "60000/60000 [==============================] - 2s 35us/step - loss: 0.0785 - acc: 0.9757 - val_loss: 0.0702 - val_acc: 0.9795\n",
      "Epoch 161/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.0776 - acc: 0.9765 - val_loss: 0.0705 - val_acc: 0.9793\n",
      "Epoch 162/250\n",
      "60000/60000 [==============================] - 3s 54us/step - loss: 0.0803 - acc: 0.9750 - val_loss: 0.0698 - val_acc: 0.9795\n",
      "Epoch 163/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0788 - acc: 0.9756 - val_loss: 0.0695 - val_acc: 0.9799\n",
      "Epoch 164/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.0782 - acc: 0.9763 - val_loss: 0.0691 - val_acc: 0.9792\n",
      "Epoch 165/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.0768 - acc: 0.9759 - val_loss: 0.0695 - val_acc: 0.9793\n",
      "Epoch 166/250\n",
      "60000/60000 [==============================] - 2s 41us/step - loss: 0.0783 - acc: 0.9763 - val_loss: 0.0691 - val_acc: 0.9795\n",
      "Epoch 167/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.0778 - acc: 0.9753 - val_loss: 0.0701 - val_acc: 0.9790\n",
      "Epoch 168/250\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.0759 - acc: 0.9758 - val_loss: 0.0694 - val_acc: 0.9791\n",
      "Epoch 169/250\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.0763 - acc: 0.9764 - val_loss: 0.0693 - val_acc: 0.9791\n",
      "Epoch 170/250\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.0751 - acc: 0.9772 - val_loss: 0.0697 - val_acc: 0.9796\n",
      "Epoch 171/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0773 - acc: 0.9758 - val_loss: 0.0695 - val_acc: 0.9795\n",
      "Epoch 172/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.0750 - acc: 0.9765 - val_loss: 0.0687 - val_acc: 0.9794\n",
      "Epoch 173/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.0768 - acc: 0.9763 - val_loss: 0.0691 - val_acc: 0.9796\n",
      "Epoch 174/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0730 - acc: 0.9776 - val_loss: 0.0688 - val_acc: 0.9792\n",
      "Epoch 175/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.0747 - acc: 0.9772 - val_loss: 0.0686 - val_acc: 0.9791\n",
      "Epoch 176/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.0731 - acc: 0.9773 - val_loss: 0.0689 - val_acc: 0.9790\n",
      "Epoch 177/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0740 - acc: 0.9774 - val_loss: 0.0685 - val_acc: 0.9798\n",
      "Epoch 178/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.0732 - acc: 0.9772 - val_loss: 0.0686 - val_acc: 0.9801\n",
      "Epoch 179/250\n",
      "60000/60000 [==============================] - 3s 52us/step - loss: 0.0740 - acc: 0.9766 - val_loss: 0.0681 - val_acc: 0.9794\n",
      "Epoch 180/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.0730 - acc: 0.9775 - val_loss: 0.0688 - val_acc: 0.9796\n",
      "Epoch 181/250\n",
      "60000/60000 [==============================] - 4s 72us/step - loss: 0.0724 - acc: 0.9775 - val_loss: 0.0681 - val_acc: 0.9797\n",
      "Epoch 182/250\n",
      "60000/60000 [==============================] - 3s 53us/step - loss: 0.0728 - acc: 0.9771 - val_loss: 0.0690 - val_acc: 0.9790\n",
      "Epoch 183/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.0738 - acc: 0.9778 - val_loss: 0.0684 - val_acc: 0.9794\n",
      "Epoch 184/250\n",
      "60000/60000 [==============================] - 3s 57us/step - loss: 0.0698 - acc: 0.9783 - val_loss: 0.0678 - val_acc: 0.9797\n",
      "Epoch 185/250\n",
      "60000/60000 [==============================] - 3s 58us/step - loss: 0.0731 - acc: 0.9773 - val_loss: 0.0687 - val_acc: 0.9794\n",
      "Epoch 186/250\n",
      "60000/60000 [==============================] - 3s 47us/step - loss: 0.0732 - acc: 0.9776 - val_loss: 0.0685 - val_acc: 0.9800\n",
      "Epoch 187/250\n",
      "60000/60000 [==============================] - 3s 54us/step - loss: 0.0707 - acc: 0.9786 - val_loss: 0.0677 - val_acc: 0.9798\n",
      "Epoch 188/250\n",
      "60000/60000 [==============================] - 4s 60us/step - loss: 0.0716 - acc: 0.9775 - val_loss: 0.0674 - val_acc: 0.9796\n",
      "Epoch 189/250\n",
      "60000/60000 [==============================] - 3s 53us/step - loss: 0.0692 - acc: 0.9787 - val_loss: 0.0683 - val_acc: 0.9798\n",
      "Epoch 190/250\n",
      "60000/60000 [==============================] - 3s 50us/step - loss: 0.0723 - acc: 0.9777 - val_loss: 0.0679 - val_acc: 0.9797\n",
      "Epoch 191/250\n",
      "60000/60000 [==============================] - 4s 63us/step - loss: 0.0709 - acc: 0.9776 - val_loss: 0.0674 - val_acc: 0.9797\n",
      "Epoch 192/250\n",
      "60000/60000 [==============================] - 5s 82us/step - loss: 0.0693 - acc: 0.9781 - val_loss: 0.0672 - val_acc: 0.9800\n",
      "Epoch 193/250\n",
      "60000/60000 [==============================] - 4s 61us/step - loss: 0.0697 - acc: 0.9787 - val_loss: 0.0678 - val_acc: 0.9794\n",
      "Epoch 194/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.0703 - acc: 0.9783 - val_loss: 0.0673 - val_acc: 0.9798\n",
      "Epoch 195/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.0684 - acc: 0.9784 - val_loss: 0.0674 - val_acc: 0.9804\n",
      "Epoch 196/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0682 - acc: 0.9788 - val_loss: 0.0673 - val_acc: 0.9799\n",
      "Epoch 197/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0696 - acc: 0.9785 - val_loss: 0.0677 - val_acc: 0.9801\n",
      "Epoch 198/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0676 - acc: 0.9792 - val_loss: 0.0670 - val_acc: 0.9800\n",
      "Epoch 199/250\n",
      "60000/60000 [==============================] - 3s 48us/step - loss: 0.0678 - acc: 0.9793 - val_loss: 0.0672 - val_acc: 0.9799\n",
      "Epoch 200/250\n",
      "60000/60000 [==============================] - 3s 47us/step - loss: 0.0665 - acc: 0.9789 - val_loss: 0.0676 - val_acc: 0.9798\n",
      "Epoch 201/250\n",
      "60000/60000 [==============================] - 2s 42us/step - loss: 0.0676 - acc: 0.9785 - val_loss: 0.0676 - val_acc: 0.9802\n",
      "Epoch 202/250\n",
      "60000/60000 [==============================] - 2s 42us/step - loss: 0.0675 - acc: 0.9785 - val_loss: 0.0672 - val_acc: 0.9800\n",
      "Epoch 203/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0664 - acc: 0.9795 - val_loss: 0.0665 - val_acc: 0.9797\n",
      "Epoch 204/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.0659 - acc: 0.9797 - val_loss: 0.0667 - val_acc: 0.9798\n",
      "Epoch 205/250\n",
      "60000/60000 [==============================] - 3s 48us/step - loss: 0.0658 - acc: 0.9788 - val_loss: 0.0675 - val_acc: 0.9802\n",
      "Epoch 206/250\n",
      "60000/60000 [==============================] - 3s 52us/step - loss: 0.0658 - acc: 0.9792 - val_loss: 0.0664 - val_acc: 0.9801\n",
      "Epoch 207/250\n",
      "60000/60000 [==============================] - 3s 50us/step - loss: 0.0669 - acc: 0.9789 - val_loss: 0.0670 - val_acc: 0.9804\n",
      "Epoch 208/250\n",
      "60000/60000 [==============================] - 3s 52us/step - loss: 0.0660 - acc: 0.9788 - val_loss: 0.0668 - val_acc: 0.9797\n",
      "Epoch 209/250\n",
      "60000/60000 [==============================] - 3s 55us/step - loss: 0.0641 - acc: 0.9801 - val_loss: 0.0663 - val_acc: 0.9798\n",
      "Epoch 210/250\n",
      "60000/60000 [==============================] - 3s 47us/step - loss: 0.0644 - acc: 0.9799 - val_loss: 0.0668 - val_acc: 0.9800\n",
      "Epoch 211/250\n",
      "60000/60000 [==============================] - 3s 47us/step - loss: 0.0651 - acc: 0.9791 - val_loss: 0.0662 - val_acc: 0.9805\n",
      "Epoch 212/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0646 - acc: 0.9801 - val_loss: 0.0663 - val_acc: 0.9795\n",
      "Epoch 213/250\n",
      "60000/60000 [==============================] - 3s 50us/step - loss: 0.0640 - acc: 0.9800 - val_loss: 0.0667 - val_acc: 0.9798\n",
      "Epoch 214/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0640 - acc: 0.9808 - val_loss: 0.0665 - val_acc: 0.9799\n",
      "Epoch 215/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0646 - acc: 0.9799 - val_loss: 0.0658 - val_acc: 0.9802\n",
      "Epoch 216/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0648 - acc: 0.9795 - val_loss: 0.0655 - val_acc: 0.9803\n",
      "Epoch 217/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0647 - acc: 0.9798 - val_loss: 0.0659 - val_acc: 0.9803\n",
      "Epoch 218/250\n",
      "60000/60000 [==============================] - 3s 48us/step - loss: 0.0642 - acc: 0.9800 - val_loss: 0.0660 - val_acc: 0.9805\n",
      "Epoch 219/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0641 - acc: 0.9801 - val_loss: 0.0656 - val_acc: 0.9802\n",
      "Epoch 220/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0627 - acc: 0.9800 - val_loss: 0.0662 - val_acc: 0.9798\n",
      "Epoch 221/250\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0640 - acc: 0.9797 - val_loss: 0.0658 - val_acc: 0.9801\n",
      "Epoch 222/250\n",
      "60000/60000 [==============================] - 3s 54us/step - loss: 0.0635 - acc: 0.9802 - val_loss: 0.0662 - val_acc: 0.9803\n",
      "Epoch 223/250\n",
      "60000/60000 [==============================] - 2s 40us/step - loss: 0.0643 - acc: 0.9800 - val_loss: 0.0656 - val_acc: 0.9804\n",
      "Epoch 224/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0621 - acc: 0.9811 - val_loss: 0.0660 - val_acc: 0.9800\n",
      "Epoch 225/250\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0636 - acc: 0.9800 - val_loss: 0.0663 - val_acc: 0.9801\n",
      "Epoch 226/250\n",
      "60000/60000 [==============================] - 3s 56us/step - loss: 0.0613 - acc: 0.9807 - val_loss: 0.0665 - val_acc: 0.9801\n",
      "Epoch 227/250\n",
      "60000/60000 [==============================] - 4s 71us/step - loss: 0.0633 - acc: 0.9806 - val_loss: 0.0660 - val_acc: 0.9807\n",
      "Epoch 228/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0615 - acc: 0.9806 - val_loss: 0.0655 - val_acc: 0.9801\n",
      "Epoch 229/250\n",
      "60000/60000 [==============================] - 3s 45us/step - loss: 0.0615 - acc: 0.9815 - val_loss: 0.0659 - val_acc: 0.9798\n",
      "Epoch 230/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0625 - acc: 0.9801 - val_loss: 0.0656 - val_acc: 0.9807\n",
      "Epoch 231/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0599 - acc: 0.9808 - val_loss: 0.0658 - val_acc: 0.9804\n",
      "Epoch 232/250\n",
      "60000/60000 [==============================] - 3s 54us/step - loss: 0.0595 - acc: 0.9809 - val_loss: 0.0657 - val_acc: 0.9801\n",
      "Epoch 233/250\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0602 - acc: 0.9809 - val_loss: 0.0656 - val_acc: 0.9804\n",
      "Epoch 234/250\n",
      "60000/60000 [==============================] - 2s 35us/step - loss: 0.0596 - acc: 0.9815 - val_loss: 0.0662 - val_acc: 0.9804\n",
      "Epoch 235/250\n",
      "60000/60000 [==============================] - 2s 38us/step - loss: 0.0592 - acc: 0.9814 - val_loss: 0.0662 - val_acc: 0.9803\n",
      "Epoch 236/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.0602 - acc: 0.9810 - val_loss: 0.0652 - val_acc: 0.9806\n",
      "Epoch 237/250\n",
      "60000/60000 [==============================] - 2s 39us/step - loss: 0.0593 - acc: 0.9815 - val_loss: 0.0649 - val_acc: 0.9806\n",
      "Epoch 238/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0599 - acc: 0.9813 - val_loss: 0.0662 - val_acc: 0.9802\n",
      "Epoch 239/250\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.0592 - acc: 0.9811 - val_loss: 0.0658 - val_acc: 0.9809\n",
      "Epoch 240/250\n",
      "60000/60000 [==============================] - 2s 35us/step - loss: 0.0600 - acc: 0.9813 - val_loss: 0.0656 - val_acc: 0.9803\n",
      "Epoch 241/250\n",
      "60000/60000 [==============================] - 2s 41us/step - loss: 0.0603 - acc: 0.9816 - val_loss: 0.0658 - val_acc: 0.9809\n",
      "Epoch 242/250\n",
      "60000/60000 [==============================] - 3s 46us/step - loss: 0.0585 - acc: 0.9812 - val_loss: 0.0657 - val_acc: 0.9811\n",
      "Epoch 243/250\n",
      "60000/60000 [==============================] - 2s 37us/step - loss: 0.0585 - acc: 0.9813 - val_loss: 0.0658 - val_acc: 0.9802\n",
      "Epoch 244/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.0576 - acc: 0.9817 - val_loss: 0.0654 - val_acc: 0.9808\n",
      "Epoch 245/250\n",
      "60000/60000 [==============================] - 2s 41us/step - loss: 0.0579 - acc: 0.9819 - val_loss: 0.0660 - val_acc: 0.9801\n",
      "Epoch 246/250\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0577 - acc: 0.9820 - val_loss: 0.0654 - val_acc: 0.9809\n",
      "Epoch 247/250\n",
      "60000/60000 [==============================] - 3s 51us/step - loss: 0.0566 - acc: 0.9816 - val_loss: 0.0653 - val_acc: 0.9808\n",
      "Epoch 248/250\n",
      "60000/60000 [==============================] - 2s 36us/step - loss: 0.0579 - acc: 0.9816 - val_loss: 0.0649 - val_acc: 0.9809\n",
      "Epoch 249/250\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.0562 - acc: 0.9823 - val_loss: 0.0655 - val_acc: 0.9799\n",
      "Epoch 250/250\n",
      "60000/60000 [==============================] - 3s 52us/step - loss: 0.0580 - acc: 0.9819 - val_loss: 0.0652 - val_acc: 0.9804\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "K.clear_session()\n",
    "model2 = keras.models.Sequential()\n",
    "model2.add(layers.Dense (128, input_shape =(28*28,), activation ='relu'))\n",
    "model2.add(layers.Dropout(0.3))\n",
    "model2.add(layers.Dense (128, activation ='relu'))\n",
    "model2.add(layers.Dropout(0.3))\n",
    "model2.add(layers.Dense (10, activation='softmax'))\n",
    "model2.summary()\n",
    "model2.compile(loss=\"categorical_crossentropy\", optimizer ='sgd', metrics =['accuracy'])\n",
    "history = model2.fit(X_train , Y_train , batch_size=128, epochs=250, validation_data=(X_test, Y_test))\n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(c) Build a third network by using the model from (b) with the optimizer \"adam\" instead of SGD.  Train for 20 episodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 128)               100480    \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 128)               16512     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 118,282\n",
      "Trainable params: 118,282\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/20\n",
      "60000/60000 [==============================] - 4s 61us/step - loss: 0.4506 - acc: 0.8623 - val_loss: 0.1659 - val_acc: 0.9492\n",
      "Epoch 2/20\n",
      "60000/60000 [==============================] - 3s 50us/step - loss: 0.2057 - acc: 0.9382 - val_loss: 0.1215 - val_acc: 0.9627\n",
      "Epoch 3/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.1579 - acc: 0.9526 - val_loss: 0.1017 - val_acc: 0.9696\n",
      "Epoch 4/20\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.1338 - acc: 0.9601 - val_loss: 0.0914 - val_acc: 0.9730\n",
      "Epoch 5/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.1168 - acc: 0.9640 - val_loss: 0.0805 - val_acc: 0.9757\n",
      "Epoch 6/20\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.1043 - acc: 0.9674 - val_loss: 0.0861 - val_acc: 0.9746\n",
      "Epoch 7/20\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.0966 - acc: 0.9701 - val_loss: 0.0745 - val_acc: 0.9779\n",
      "Epoch 8/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0911 - acc: 0.9718 - val_loss: 0.0707 - val_acc: 0.9794\n",
      "Epoch 9/20\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0847 - acc: 0.9738 - val_loss: 0.0716 - val_acc: 0.9789\n",
      "Epoch 10/20\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0791 - acc: 0.9747 - val_loss: 0.0673 - val_acc: 0.9794\n",
      "Epoch 11/20\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0767 - acc: 0.9751 - val_loss: 0.0651 - val_acc: 0.9806\n",
      "Epoch 12/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0719 - acc: 0.9772 - val_loss: 0.0643 - val_acc: 0.9809\n",
      "Epoch 13/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0673 - acc: 0.9787 - val_loss: 0.0610 - val_acc: 0.9817\n",
      "Epoch 14/20\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0649 - acc: 0.9798 - val_loss: 0.0696 - val_acc: 0.9801\n",
      "Epoch 15/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0623 - acc: 0.9793 - val_loss: 0.0709 - val_acc: 0.9794\n",
      "Epoch 16/20\n",
      "60000/60000 [==============================] - 3s 42us/step - loss: 0.0573 - acc: 0.9812 - val_loss: 0.0649 - val_acc: 0.9816\n",
      "Epoch 17/20\n",
      "60000/60000 [==============================] - 3s 43us/step - loss: 0.0579 - acc: 0.9815 - val_loss: 0.0642 - val_acc: 0.9828\n",
      "Epoch 18/20\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0525 - acc: 0.9828 - val_loss: 0.0680 - val_acc: 0.9817\n",
      "Epoch 19/20\n",
      "60000/60000 [==============================] - 3s 44us/step - loss: 0.0566 - acc: 0.9816 - val_loss: 0.0725 - val_acc: 0.9797\n",
      "Epoch 20/20\n",
      "60000/60000 [==============================] - 3s 49us/step - loss: 0.0521 - acc: 0.9830 - val_loss: 0.0665 - val_acc: 0.9816\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "K.clear_session()\n",
    "model3 = keras.models.Sequential()\n",
    "model3.add(layers.Dense (128, input_shape =(28*28,), activation ='relu'))\n",
    "model3.add(layers.Dropout(0.3))\n",
    "model3.add(layers.Dense (128, activation ='relu'))\n",
    "model3.add(layers.Dropout(0.3))\n",
    "model3.add(layers.Dense (10, activation='softmax'))\n",
    "model3.summary()\n",
    "model3.compile(loss=\"categorical_crossentropy\", optimizer ='adam', metrics =['accuracy'])\n",
    "history = model3.fit(X_train , Y_train , batch_size=128, epochs=20, validation_data=(X_test, Y_test), verbose=True)\n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While SGD has one single learning rate, which isn't changed,\n",
    "Adam optimization computes individual adaptive learning rates for different parameters using the first and second moments of the gradients.\n",
    "Hence you only need 10% of episodes untill the model is trained"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Task 4.5.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60000, 28, 28, 1)\n",
      "(10000, 28, 28, 1)\n"
     ]
    }
   ],
   "source": [
    "#reshaping the data back to its moredimensional form\n",
    "\n",
    "X_train = X_train.reshape((-1,)+input_shape)\n",
    "X_test = X_test.reshape((-1,)+input_shape)\n",
    "\n",
    "print(X_train.shape)\n",
    "print(X_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Build a CNN with [...]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_1 (Conv2D)            (None, 26, 26, 16)        160       \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 24, 24, 32)        4640      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 12, 12, 32)        0         \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 12, 12, 32)        0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 4608)              0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 128)               589952    \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 596,042\n",
      "Trainable params: 596,042\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/15\n",
      "60000/60000 [==============================] - 93s 2ms/step - loss: 0.2726 - acc: 0.9160 - val_loss: 0.0607 - val_acc: 0.9810\n",
      "Epoch 2/15\n",
      "60000/60000 [==============================] - 89s 1ms/step - loss: 0.0948 - acc: 0.9714 - val_loss: 0.0407 - val_acc: 0.9866\n",
      "Epoch 3/15\n",
      "60000/60000 [==============================] - 126s 2ms/step - loss: 0.0716 - acc: 0.9785 - val_loss: 0.0325 - val_acc: 0.9900\n",
      "Epoch 4/15\n",
      "60000/60000 [==============================] - 116s 2ms/step - loss: 0.0585 - acc: 0.9817 - val_loss: 0.0317 - val_acc: 0.9891\n",
      "Epoch 5/15\n",
      "60000/60000 [==============================] - 128s 2ms/step - loss: 0.0507 - acc: 0.9840 - val_loss: 0.0322 - val_acc: 0.9896\n",
      "Epoch 6/15\n",
      "60000/60000 [==============================] - 123s 2ms/step - loss: 0.0455 - acc: 0.9860 - val_loss: 0.0290 - val_acc: 0.9902\n",
      "Epoch 7/15\n",
      "60000/60000 [==============================] - 121s 2ms/step - loss: 0.0405 - acc: 0.9868 - val_loss: 0.0261 - val_acc: 0.9912\n",
      "Epoch 8/15\n",
      "60000/60000 [==============================] - 112s 2ms/step - loss: 0.0358 - acc: 0.9889 - val_loss: 0.0261 - val_acc: 0.9922\n",
      "Epoch 9/15\n",
      "60000/60000 [==============================] - 89s 1ms/step - loss: 0.0325 - acc: 0.9897 - val_loss: 0.0284 - val_acc: 0.9912\n",
      "Epoch 10/15\n",
      "60000/60000 [==============================] - 95s 2ms/step - loss: 0.0306 - acc: 0.9903 - val_loss: 0.0256 - val_acc: 0.9922\n",
      "Epoch 11/15\n",
      "60000/60000 [==============================] - 127s 2ms/step - loss: 0.0283 - acc: 0.9910 - val_loss: 0.0284 - val_acc: 0.9915\n",
      "Epoch 12/15\n",
      "60000/60000 [==============================] - 125s 2ms/step - loss: 0.0273 - acc: 0.9909 - val_loss: 0.0279 - val_acc: 0.9919\n",
      "Epoch 13/15\n",
      "60000/60000 [==============================] - 96s 2ms/step - loss: 0.0257 - acc: 0.9915 - val_loss: 0.0278 - val_acc: 0.9917\n",
      "Epoch 14/15\n",
      "60000/60000 [==============================] - 113s 2ms/step - loss: 0.0241 - acc: 0.9921 - val_loss: 0.0266 - val_acc: 0.9920\n",
      "Epoch 15/15\n",
      "60000/60000 [==============================] - 114s 2ms/step - loss: 0.0232 - acc: 0.9924 - val_loss: 0.0306 - val_acc: 0.9918\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "K.clear_session()\n",
    "modelCNN1 = keras.models.Sequential()\n",
    "modelCNN1.add(layers.Conv2D (16, kernel_size =(3, 3), activation =\"relu\", input_shape=input_shape))\n",
    "modelCNN1.add(layers.Conv2D (32, kernel_size =(3, 3), activation =\"relu\"))\n",
    "modelCNN1.add(layers.MaxPooling2D(pool_size=(2,2)))\n",
    "modelCNN1.add(layers.Dropout(0.25))\n",
    "modelCNN1.add(layers.Flatten())\n",
    "modelCNN1.add(layers.Dense(128, activation='relu'))\n",
    "modelCNN1.add(layers.Dropout(0.5))\n",
    "modelCNN1.add(layers.Dense(10, activation='softmax'))\n",
    "\n",
    "modelCNN1.summary()\n",
    "modelCNN1.compile(loss=\"categorical_crossentropy\", optimizer ='adam', metrics =['accuracy'])\n",
    "history = modelCNN1.fit(X_train , Y_train , batch_size=128, epochs=15, validation_data=(X_test, Y_test))\n",
    "plot_history(history)"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}