eq_spike_v3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Important packages\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters\n",
    "dt = 0.5  # timestep (in seconds), represents max frequency\n",
    "num_epochs = 20  # number of epochs\n",
    "num_class = 10  # number of classes\n",
    "num_images = num_class * 600  # number of images in training/testing set\n",
    "tau = 0.01\n",
    "tau_LI = 0.1\n",
    "RC = 10\n",
    "f = 0.1 # fraction dt_sp/dt\n",
    "beta = 0.5  # nudge factor\n",
    "nu = 3e-5  # learning rate\n",
    "gamma = 50  # timesteps to delay\n",
    "L_filt = 10  # timesteps to be filtered\n",
    "v_rst = 0  # reset voltage\n",
    "v_th = 1  # threshold voltage\n",
    "T_free = 150  # free phase timesteps\n",
    "T_nudge = 200  # nudge phase timesteps\n",
    "N_input = 784  # number input neurons\n",
    "N_hidden = 10  # number hidden neurons\n",
    "N_output = num_class  # number output neurons\n",
    "ternary = True # ternary gradients?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Prep data (ONLY RUN IF NOT ALREADY SAVED)\n",
    "# train_images = open('./mnist/train-images.idx3-ubyte',mode='rb')\n",
    "# train_labels = open('./mnist/train-labels.idx1-ubyte',mode='rb')\n",
    "# test_images = open('./mnist/t10k-images.idx3-ubyte',mode='rb')\n",
    "# test_labels = open('./mnist/t10k-labels.idx1-ubyte',mode='rb')\n",
    "\n",
    "# train_images.read(4)\n",
    "# train_labels.read(4)\n",
    "# test_images.read(4)\n",
    "# test_labels.read(4)\n",
    "\n",
    "# num_train_images = unpack('>I',train_images.read(4))[0]\n",
    "# num_train_labels = unpack('>I',train_labels.read(4))[0]\n",
    "# train_rows = unpack('>I',train_images.read(4))[0]\n",
    "# train_cols = unpack('>I',train_images.read(4))[0]\n",
    "# num_test_images = unpack('>I',test_images.read(4))[0]\n",
    "# num_test_labels = unpack('>I',test_labels.read(4))[0]\n",
    "# test_rows = unpack('>I',test_images.read(4))[0]\n",
    "# test_cols = unpack('>I',test_images.read(4))[0]\n",
    "\n",
    "# tr_images = np.zeros((num_train_images,train_rows,train_cols),dtype=np.uint8)\n",
    "# tr_labels = np.zeros((num_train_labels,1),dtype=np.uint8)\n",
    "# te_images = np.zeros((num_test_images,test_rows,test_cols),dtype=np.uint8)\n",
    "# te_labels = np.zeros((num_test_labels,1),dtype=np.uint8)\n",
    "\n",
    "# for i in range(num_train_images):\n",
    "#     tr_labels[i] = unpack('>B',train_labels.read(1))[0]\n",
    "#     for j in range(train_rows):\n",
    "#         for k in range(train_cols):\n",
    "#             tr_images[i][j][k] = unpack('>B',train_images.read(1))[0]\n",
    "            \n",
    "# for i in range(num_test_images):\n",
    "#     te_labels[i] = unpack('>B',test_labels.read(1))[0]\n",
    "#     for j in range(test_rows):\n",
    "#         for k in range(test_cols):\n",
    "#             te_images[i][j][k] = unpack('>B',test_images.read(1))[0]\n",
    "            \n",
    "# np.save('./mnist/train_images.npy',tr_images)\n",
    "# np.save('./mnist/train_labels.npy',tr_labels)\n",
    "# np.save('./mnist/test_images.npy',te_images)\n",
    "# np.save('./mnist/test_labels.npy',te_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate spiking inputs\n",
    "\n",
    "# Load and flatten\n",
    "train_images = np.load('./mnist/train_images.npy')\n",
    "train_labels = np.load('./mnist/train_labels.npy')\n",
    "test_images = np.load('./mnist/test_images.npy')\n",
    "test_labels = np.load('./mnist/test_labels.npy')\n",
    "\n",
    "train_images = np.reshape(train_images,(60000,784))\n",
    "test_images = np.reshape(test_images,(10000,784))\n",
    "\n",
    "# Take subsets of each\n",
    "count0 = 0\n",
    "count1 = 0\n",
    "count2 = 0\n",
    "count3 = 0\n",
    "count4 = 0\n",
    "count5 = 0\n",
    "count6 = 0\n",
    "count7 = 0\n",
    "count8 = 0\n",
    "count9 = 0\n",
    "train_images_sub = np.zeros((num_images,784))\n",
    "train_labels_sub = np.zeros((num_images,1))\n",
    "\n",
    "for i in range(60000):\n",
    "    if train_labels[i] == 0:\n",
    "        if count0 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count0 += 1\n",
    "    if train_labels[i] == 1:\n",
    "        if count1 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count1 += 1\n",
    "    if train_labels[i] == 2:\n",
    "        if count2 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count2 += 1\n",
    "    if train_labels[i] == 3:\n",
    "        if count3 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count3 += 1\n",
    "    if train_labels[i] == 4:\n",
    "        if count4 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count4 += 1\n",
    "    if train_labels[i] == 5:\n",
    "        if count5 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count5 += 1\n",
    "    if train_labels[i] == 6:\n",
    "        if count6 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count6 += 1\n",
    "    if train_labels[i] == 7:\n",
    "        if count7 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count7 += 1\n",
    "    if train_labels[i] == 8:\n",
    "        if count8 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count8 += 1\n",
    "    if train_labels[i] == 9:\n",
    "        if count9 < 600:\n",
    "            train_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_images[i]\n",
    "            train_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = train_labels[i]\n",
    "            count9 += 1\n",
    "            \n",
    "count0 = 0\n",
    "count1 = 0\n",
    "count2 = 0\n",
    "count3 = 0\n",
    "count4 = 0\n",
    "count5 = 0\n",
    "count6 = 0\n",
    "count7 = 0\n",
    "count8 = 0\n",
    "count9 = 0\n",
    "test_images_sub = np.zeros((num_images,784))\n",
    "test_labels_sub = np.zeros((num_images,1))\n",
    "\n",
    "for i in range(10000):\n",
    "    if test_labels[i] == 0:\n",
    "        if count0 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count0 += 1\n",
    "    if test_labels[i] == 1:\n",
    "        if count1 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count1 += 1\n",
    "    if test_labels[i] == 2:\n",
    "        if count2 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count2 += 1\n",
    "    if test_labels[i] == 3:\n",
    "        if count3 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count3 += 1\n",
    "    if test_labels[i] == 4:\n",
    "        if count4 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count4 += 1\n",
    "    if test_labels[i] == 5:\n",
    "        if count5 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count5 += 1\n",
    "    if test_labels[i] == 6:\n",
    "        if count6 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count6 += 1\n",
    "    if test_labels[i] == 7:\n",
    "        if count7 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count7 += 1\n",
    "    if test_labels[i] == 8:\n",
    "        if count8 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count8 += 1\n",
    "    if test_labels[i] == 9:\n",
    "        if count9 < 600:\n",
    "            test_images_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_images[i]\n",
    "            test_labels_sub[count0+count1+count2+count3+count4+count5+count6+count7+count8+count9] = test_labels[i]\n",
    "            count9 += 1\n",
    "            \n",
    "train_images = train_images_sub / 510\n",
    "train_labels = train_labels_sub\n",
    "test_images = test_images_sub / 510\n",
    "test_labels = test_labels_sub\n",
    "\n",
    "f_max = np.zeros((1,T_free+T_nudge))\n",
    "f_max[:,1::2] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initial synaptic weights\n",
    "\n",
    "# Xavier normal initialization\n",
    "syn_IH = np.random.normal(0,np.sqrt(2/(N_input+N_hidden)),(N_input,N_hidden))\n",
    "syn_HO = np.random.normal(0,np.sqrt(2/(N_hidden+N_output)),(N_hidden,N_output))\n",
    "syn_OH = np.copy(syn_HO).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 11%|█         | 661/6000 [00:59<07:57, 11.17it/s]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-4a5c756e7a18>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     76\u001b[0m             \u001b[0mreset_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mv_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mv_th\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m             \u001b[0mv_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mreset_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m             \u001b[0mv_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mv_rst\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mreset_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     79\u001b[0m             \u001b[0mspikes_output\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreset_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Training Code\n",
    "\n",
    "# For each epoch\n",
    "for epoch in range(num_epochs):\n",
    "        \n",
    "    # For each training image\n",
    "    for i in tqdm(range(num_images)):\n",
    "        \n",
    "        # Instantiate membrane potential and spikes for this images\n",
    "        v_input = np.zeros((N_input,T_free+T_nudge))\n",
    "        v_hidden = np.zeros((N_hidden,T_free+T_nudge))\n",
    "        v_output = np.zeros((N_output,T_free+T_nudge))\n",
    "        spikes_input = np.zeros((N_input,T_free+T_nudge))\n",
    "        spikes_hidden = np.zeros((N_hidden,T_free+T_nudge))\n",
    "        spikes_output = np.zeros((N_output,T_free+T_nudge))\n",
    "        p_input = np.zeros((N_input,T_free+T_nudge))\n",
    "        p_hidden = np.zeros((N_hidden,T_free+T_nudge))\n",
    "        p_output = np.zeros((N_output,T_free+T_nudge))\n",
    "        p_dot_input = np.zeros((N_input,T_free+T_nudge))\n",
    "        p_dot_hidden = np.zeros((N_hidden,T_free+T_nudge))\n",
    "        p_dot_output = np.zeros((N_output,T_free+T_nudge))\n",
    "        p_dot_input_LPF = np.zeros((N_input,T_free+T_nudge))\n",
    "        p_dot_hidden_LPF = np.zeros((N_hidden,T_free+T_nudge))\n",
    "        p_dot_output_LPF = np.zeros((N_output,T_free+T_nudge))\n",
    "        p_target = np.zeros((N_output,T_free+T_nudge))\n",
    "        \n",
    "        # Generate target vectors\n",
    "        target_spikes = np.zeros((N_output,T_free+T_nudge))\n",
    "        target_spikes[train_labels[i].astype(int)] = f_max.copy()\n",
    "        error = np.zeros((N_output,T_free+T_nudge))\n",
    "        \n",
    "        # For each free-phase timestep\n",
    "        for t in range(T_free):\n",
    "            \n",
    "            # LIF of input neurons with normalized MNIST inputs\n",
    "            dvdt_input = (v_rst - v_input[:,t-1]) * tau + train_images[i,:]\n",
    "            v_input[:,t] = v_input[:,t-1] + dvdt_input * dt\n",
    "            reset_input = v_input[:,t] > v_th\n",
    "            v_input[:,t] -= np.multiply(v_input[:,t],reset_input.astype(int))\n",
    "            v_input[:,t] += v_rst * reset_input.astype(int)\n",
    "            spikes_input[:,t] = reset_input.astype(int)\n",
    "            \n",
    "            # LI of input neurons' output spikes and derivative computation\n",
    "            dpdt_input = -p_input[:,t-1] * tau_LI + spikes_input[:,t]\n",
    "            p_input[:,t] = p_input[:,t-1] + dpdt_input * dt\n",
    "            p_dot_input[:,t] = p_input[:,t] - p_input[:,t-gamma]\n",
    "            p_dot_input_LPF[:,t] = np.sum(p_dot_input[:,t-L_filt:t],axis=1) / L_filt\n",
    "            \n",
    "            # Find the synaptic response based on current input and previous outputs\n",
    "            result_IH = np.matmul(syn_IH.T,spikes_input[:,t])\n",
    "            result_HO = np.matmul(syn_HO.T,spikes_hidden[:,t-1])\n",
    "            result_OH = np.matmul(syn_OH.T,spikes_output[:,t-1])\n",
    "            \n",
    "            # Compute error of target - output\n",
    "            dpdt_target = -p_target[:,t-1] * tau_LI + target_spikes[:,t]\n",
    "            p_target[:,t] = p_target[:,t-1] + dpdt_target * dt\n",
    "            error[:,t] = p_target[:,t-1] - p_output[:,t-1]\n",
    "            \n",
    "            # LIF of hidden neurons with incoming spikes from input/output neurons\n",
    "            dvdt_hidden = (v_rst - v_hidden[:,t-1]) * tau + result_IH + result_OH\n",
    "            v_hidden[:,t] = v_hidden[:,t-1] + dvdt_hidden * dt\n",
    "            reset_hidden = v_hidden[:,t] > v_th\n",
    "            v_hidden[:,t] -= np.multiply(v_hidden[:,t],reset_hidden.astype(int))\n",
    "            v_hidden[:,t] += v_rst * reset_hidden.astype(int)\n",
    "            spikes_hidden[:,t] = reset_hidden.astype(int)\n",
    "            \n",
    "            # LI of hidden neurons' output spikes and derivative computation\n",
    "            dpdt_hidden = -p_hidden[:,t-1] * tau_LI + spikes_hidden[:,t]\n",
    "            p_hidden[:,t] = p_hidden[:,t-1] + dpdt_hidden * dt\n",
    "            p_dot_hidden[:,t] = p_hidden[:,t] - p_hidden[:,t-gamma]\n",
    "            p_dot_hidden_LPF[:,t] = np.sum(p_dot_hidden[:,t-L_filt:t],axis=1) / L_filt\n",
    "            \n",
    "            # LIF of output neurons with incoming spikes from hidden neurons\n",
    "            dvdt_output = (v_rst - v_output[:,t-1]) * tau + result_HO\n",
    "            v_output[:,t] = v_output[:,t-1] + dvdt_output * dt\n",
    "            reset_output = v_output[:,t] > v_th\n",
    "            v_output[:,t] -= np.multiply(v_output[:,t],reset_output.astype(int))\n",
    "            v_output[:,t] += v_rst * reset_output.astype(int)\n",
    "            spikes_output[:,t] = reset_output.astype(int)\n",
    "            \n",
    "            # LI of output neurons' output spikes\n",
    "            dpdt_output = -p_output[:,t-1] * tau_LI + spikes_output[:,t]\n",
    "            p_output[:,t] = p_output[:,t-1] + dpdt_output * dt\n",
    "            p_dot_output[:,t] = p_output[:,t] - p_output[:,t-gamma]\n",
    "            p_dot_output_LPF[:,t] = np.sum(p_dot_output[:,t-L_filt:t],axis=1) / L_filt\n",
    "            \n",
    "            # Make derivatives tertiary (-1, 0, or 1)\n",
    "            inc_output = p_dot_output_LPF[:,t] > 0\n",
    "            dec_output = p_dot_output_LPF[:,t] < 0\n",
    "            inc_hidden = p_dot_hidden_LPF[:,t] > 0\n",
    "            dec_hidden = p_dot_hidden_LPF[:,t] < 0\n",
    "            p_dot_output_LPF[:,t] = inc_output.astype(int) - dec_output.astype(int)\n",
    "            p_dot_hidden_LPF[:,t] = inc_hidden.astype(int) - dec_hidden.astype(int)\n",
    "            \n",
    "        # For each nudged-phase timestep \n",
    "        for t in range(T_free,T_free+T_nudge):\n",
    "            \n",
    "            # LIF of input neurons with normalized MNIST inputs\n",
    "            dvdt_input = (v_rst - v_input[:,t-1]) * tau + train_images[i,:]\n",
    "            v_input[:,t] = v_input[:,t-1] + dvdt_input * dt\n",
    "            reset_input = v_input[:,t] > v_th\n",
    "            v_input[:,t] -= np.multiply(v_input[:,t],reset_input.astype(int))\n",
    "            v_input[:,t] += v_rst * reset_input.astype(int)\n",
    "            spikes_input[:,t] = reset_input.astype(int)\n",
    "            \n",
    "            # LI of input neurons' output spikes and derivative computation\n",
    "            dpdt_input = -p_input[:,t-1] * tau_LI + spikes_input[:,t]\n",
    "            p_input[:,t] = p_input[:,t-1] + dpdt_input * dt\n",
    "            p_dot_input[:,t] = p_input[:,t] - p_input[:,t-gamma]\n",
    "            p_dot_input_LPF[:,t] = np.sum(p_dot_input[:,t-L_filt:t],axis=1) / L_filt\n",
    "            \n",
    "            # Find the synaptic response based on current input and previous outputs\n",
    "            result_IH = np.matmul(syn_IH.T,spikes_input[:,t])\n",
    "            result_HO = np.matmul(syn_HO.T,spikes_hidden[:,t-1])\n",
    "            result_OH = np.matmul(syn_OH.T,spikes_output[:,t-1])\n",
    "            \n",
    "            # Compute error of target - output\n",
    "            dpdt_target = -p_target[:,t-1] * tau_LI + target_spikes[:,t]\n",
    "            p_target[:,t] = p_target[:,t-1] + dpdt_target * dt\n",
    "            error[:,t] = p_target[:,t-1] - p_output[:,t-1]\n",
    "            \n",
    "            # LIF of hidden neurons with incoming spikes from input/output neurons\n",
    "            dvdt_hidden = (v_rst - v_hidden[:,t-1]) * tau + result_IH + result_OH\n",
    "            v_hidden[:,t] = v_hidden[:,t-1] + dvdt_hidden * dt\n",
    "            reset_hidden = v_hidden[:,t] > v_th\n",
    "            v_hidden[:,t] -= np.multiply(v_hidden[:,t],reset_hidden.astype(int))\n",
    "            v_hidden[:,t] += v_rst * reset_hidden.astype(int)\n",
    "            spikes_hidden[:,t] = reset_hidden.astype(int)\n",
    "            \n",
    "            # LI of hidden neurons' output spikes and derivative computation\n",
    "            dpdt_hidden = -p_hidden[:,t-1] * tau_LI + spikes_hidden[:,t]\n",
    "            p_hidden[:,t] = p_hidden[:,t-1] + dpdt_hidden * dt\n",
    "            p_dot_hidden[:,t] = p_hidden[:,t] - p_hidden[:,t-gamma]\n",
    "            p_dot_hidden_LPF[:,t] = np.sum(p_dot_hidden[:,t-L_filt:t],axis=1) / L_filt\n",
    "            \n",
    "            # LIF of output neurons with incoming spikes from hidden neurons\n",
    "            dvdt_output = (v_rst - v_output[:,t-1]) * tau + result_HO + beta * error[:,t]\n",
    "            v_output[:,t] = v_output[:,t-1] + dvdt_output * dt\n",
    "            reset_output = v_output[:,t] > v_th\n",
    "            v_output[:,t] -= np.multiply(v_output[:,t],reset_output.astype(int))\n",
    "            v_output[:,t] += v_rst * reset_output.astype(int)\n",
    "            spikes_output[:,t] = reset_output.astype(int)\n",
    "            \n",
    "            # LI of output neurons' output spikes and derivative computation\n",
    "            dpdt_output = -p_output[:,t-1] * tau_LI + spikes_output[:,t]\n",
    "            p_output[:,t] = p_output[:,t-1] + dpdt_output * dt\n",
    "            p_dot_output[:,t] = p_output[:,t] - p_output[:,t-gamma]\n",
    "            p_dot_output_LPF[:,t] = np.sum(p_dot_output[:,t-L_filt:t],axis=1) / L_filt\n",
    "            \n",
    "            # Make derivatives ternary (-1, 0, or 1)\n",
    "            if ternary == True:\n",
    "                inc_output = p_dot_output_LPF[:,t] > 0\n",
    "                dec_output = p_dot_output_LPF[:,t] < 0\n",
    "                inc_hidden = p_dot_hidden_LPF[:,t] > 0\n",
    "                dec_hidden = p_dot_hidden_LPF[:,t] < 0\n",
    "                p_dot_output_LPF[:,t] = inc_output.astype(int) - dec_output.astype(int)\n",
    "                p_dot_hidden_LPF[:,t] = inc_hidden.astype(int) - dec_hidden.astype(int)\n",
    "            \n",
    "            # Update weights for synapses with post-synaptic spikes\n",
    "            # Use spike data and LPF for this timestep\n",
    "            syn_HO += nu*np.matmul(spikes_hidden[:,t].reshape((N_hidden,1)),p_dot_output_LPF[:,t].reshape((N_output,1)).T)\n",
    "            syn_OH += nu*np.matmul(spikes_output[:,t].reshape((N_output,1)),p_dot_hidden_LPF[:,t].reshape((N_hidden,1)).T)\n",
    "            syn_IH += nu*np.matmul(spikes_input[:,t].reshape((N_input,1)),p_dot_hidden_LPF[:,t].reshape((N_hidden,1)).T)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAOiElEQVR4nO3cX4xcZ33G8e9TJ6Z/oErSOMHYTtdQX3SLEFgjK1IqLhpCbZdieudILRatZEUiUpCKqGmkFu7SVqVV1CiRWyKFFtVCAoRbGYWQUvUqkHVInBhjsqShMXbjhaqEKlJTl18v9rhsprO7s57ZzGzf70cazZz3vGfOkzdZPz5nZ5KqQpLUrp+YdABJ0mRZBJLUOItAkhpnEUhS4ywCSWrcVZMOcCWuv/76mpmZmXQMSdpQTp48+b2q2tI/viGLYGZmhrm5uUnHkKQNJcl3Bo17a0iSGmcRSFLjLAJJapxFIEmNswgkqXEWgSQ1ziKQpMZZBJLUOItAkhpnEUhS4ywCSWqcRSBJjbMIJKlxFoEkNc4ikKTGWQSS1DiLQJIaZxFIUuMsAklqnEUgSY2zCCSpcRaBJDXOIpCkxlkEktQ4i0CSGjeWIkiyN8nZJPNJjgzYnyT3dvtPJdndt39Tkq8n+ftx5JEkDW/kIkiyCbgP2AfMArcnme2btg/Y1T0OA/f37b8LODNqFknS2o3jimAPMF9Vz1XVK8Ax4EDfnAPAp2rRY8A1SbYCJNkO/BrwV2PIIklao3EUwTbghSXb57qxYef8OfAR4EcrnSTJ4SRzSeYWFhZGCixJ+rFxFEEGjNUwc5K8B7hYVSdXO0lVHa2qXlX1tmzZciU5JUkDjKMIzgE7lmxvB84POecW4L1JnmfxltKvJPmbMWSSJA1pHEXwOLAryc4km4GDwPG+OceB93efHroZ+EFVXaiqj1bV9qqa6Y77h6r6zTFkkiQN6apR36CqLiW5E3gY2AQ8WFWnk9zR7X8AOAHsB+aBl4EPjHpeSdJ4pKr/dv706/V6NTc3N+kYkrShJDlZVb3+cb9ZLEmNswgkqXEWgSQ1ziKQpMZZBJLUOItAkhpnEUhS4ywCSWqcRSBJjbMIJKlxFoEkNc4ikKTGWQSS1DiLQJIaZxFIUuMsAklqnEUgSY2zCCSpcRaBJDXOIpCkxlkEktQ4i0CSGmcRSFLjLAJJapxFIEmNswgkqXEWgSQ1ziKQpMZZBJLUOItAkho3liJIsjfJ2STzSY4M2J8k93b7TyXZ3Y3vSPKVJGeSnE5y1zjySJKGN3IRJNkE3AfsA2aB25PM9k3bB+zqHoeB+7vxS8DvVtUvAjcDHxxwrCRpHY3jimAPMF9Vz1XVK8Ax4EDfnAPAp2rRY8A1SbZW1YWqegKgqn4InAG2jSGTJGlI4yiCbcALS7bP8X//MF91TpIZ4B3AV8eQSZI0pHEUQQaM1VrmJHk98FngQ1X10sCTJIeTzCWZW1hYuOKwkqRXG0cRnAN2LNneDpwfdk6Sq1ksgU9X1eeWO0lVHa2qXlX1tmzZMobYkiQYTxE8DuxKsjPJZuAgcLxvznHg/d2nh24GflBVF5IE+CRwpqo+MYYskqQ1umrUN6iqS0nuBB4GNgEPVtXpJHd0+x8ATgD7gXngZeAD3eG3AL8FPJ3kyW7s96vqxKi5JEnDSVX/7fzp1+v1am5ubtIxJGlDSXKyqnr9436zWJIaZxFIUuMsAklqnEUgSY2zCCSpcRaBJDXOIpCkxlkEktQ4i0CSGmcRSFLjLAJJapxFIEmNswgkqXEWgSQ1ziKQpMZZBJLUOItAkhpnEUhS4ywCSWqcRSBJjbMIJKlxFoEkNc4ikKTGWQSS1DiLQJIaZxFIUuMsAklqnEUgSY2zCCSpcRaBJDXOIpCkxo2lCJLsTXI2yXySIwP2J8m93f5TSXYPe6wkaX2NXARJNgH3AfuAWeD2JLN90/YBu7rHYeD+NRwrSVpHV43hPfYA81X1HECSY8AB4BtL5hwAPlVVBTyW5JokW4GZIY4dm4//3Wm+cf6l9XhrSXpNzL7pZ/nDX/+lsb7nOG4NbQNeWLJ9rhsbZs4wxwKQ5HCSuSRzCwsLI4eWJC0axxVBBozVkHOGOXZxsOoocBSg1+sNnLOacbeoJP1/MI4iOAfsWLK9HTg/5JzNQxwrSVpH47g19DiwK8nOJJuBg8DxvjnHgfd3nx66GfhBVV0Y8lhJ0joa+Yqgqi4luRN4GNgEPFhVp5Pc0e1/ADgB7AfmgZeBD6x07KiZJEnDy+IHeTaWXq9Xc3Nzk44hSRtKkpNV1esf95vFktQ4i0CSGmcRSFLjLAJJapxFIEmNswgkqXEWgSQ1ziKQpMZZBJLUOItAkhpnEUhS4ywCSWqcRSBJjbMIJKlxFoEkNc4ikKTGWQSS1DiLQJIaZxFIUuMsAklqnEUgSY2zCCSpcRaBJDXOIpCkxlkEktQ4i0CSGmcRSFLjLAJJapxFIEmNswgkqXEjFUGS65I8kuTZ7vnaZebtTXI2yXySI0vG/yTJN5OcSvL5JNeMkkeStHajXhEcAR6tql3Ao932qyTZBNwH7ANmgduTzHa7HwHeWlVvA74FfHTEPJKkNRq1CA4AD3WvHwLeN2DOHmC+qp6rqleAY91xVNWXqupSN+8xYPuIeSRJazRqEdxYVRcAuucbBszZBrywZPtcN9bvt4EvjphHkrRGV602IcmXgTcO2HX3kOfIgLHqO8fdwCXg0yvkOAwcBrjpppuGPLUkaTWrFkFVvWu5fUleTLK1qi4k2QpcHDDtHLBjyfZ24PyS9zgEvAe4taqKZVTVUeAoQK/XW3aeJGltRr01dBw41L0+BHxhwJzHgV1JdibZDBzsjiPJXuD3gPdW1csjZpEkXYFRi+Ae4LYkzwK3ddskeVOSEwDdL4PvBB4GzgCfqarT3fF/AbwBeCTJk0keGDGPJGmNVr01tJKq+j5w64Dx88D+JdsngBMD5v3CKOeXJI3ObxZLUuMsAklqnEUgSY2zCCSpcRaBJDXOIpCkxlkEktQ4i0CSGmcRSFLjLAJJapxFIEmNswgkqXEWgSQ1ziKQpMZZBJLUOItAkhpnEUhS4ywCSWqcRSBJjbMIJKlxFoEkNc4ikKTGWQSS1DiLQJIaZxFIUuMsAklqnEUgSY2zCCSpcRaBJDXOIpCkxlkEktS4kYogyXVJHknybPd87TLz9iY5m2Q+yZEB+z+cpJJcP0oeSdLajXpFcAR4tKp2AY9226+SZBNwH7APmAVuTzK7ZP8O4DbgX0bMIkm6AqMWwQHgoe71Q8D7BszZA8xX1XNV9QpwrDvusj8DPgLUiFkkSVdg1CK4saouAHTPNwyYsw14Ycn2uW6MJO8FvltVT612oiSHk8wlmVtYWBgxtiTpsqtWm5Dky8AbB+y6e8hzZMBYJfnp7j3ePcybVNVR4ChAr9fz6kGSxmTVIqiqdy23L8mLSbZW1YUkW4GLA6adA3Ys2d4OnAfeAuwEnkpyefyJJHuq6l/X8M8gSRrBqLeGjgOHuteHgC8MmPM4sCvJziSbgYPA8ap6uqpuqKqZqpphsTB2WwKS9NoatQjuAW5L8iyLn/y5ByDJm5KcAKiqS8CdwMPAGeAzVXV6xPNKksZk1VtDK6mq7wO3Dhg/D+xfsn0COLHKe82MkkWSdGX8ZrEkNc4ikKTGWQSS1DiLQJIaZxFIUuMsAklqnEUgSY2zCCSpcRaBJDXOIpCkxlkEktQ4i0CSGmcRSFLjLAJJapxFIEmNswgkqXEWgSQ1ziKQpMZZBJLUOItAkhpnEUhS4ywCSWqcRSBJjbMIJKlxqapJZ1izJAvAd67w8OuB740xznrbSHk3UlYw73raSFlhY+UdJevPV9WW/sENWQSjSDJXVb1J5xjWRsq7kbKCedfTRsoKGyvvemT11pAkNc4ikKTGtVgERycdYI02Ut6NlBXMu542UlbYWHnHnrW53xFIkl6txSsCSdISFoEkNa6pIkiyN8nZJPNJjkw6T78kzyd5OsmTSea6seuSPJLk2e752gnmezDJxSTPLBlbNl+Sj3ZrfTbJr05J3o8l+W63xk8m2T8NeZPsSPKVJGeSnE5yVzc+deu7QtZpXdufTPK1JE91eT/ejU/d2q6Sd/3Wt6qaeACbgG8DbwY2A08Bs5PO1ZfxeeD6vrE/Bo50r48AfzTBfO8EdgPPrJYPmO3W+HXAzm7tN01B3o8BHx4wd6J5ga3A7u71G4BvdZmmbn1XyDqtaxvg9d3rq4GvAjdP49quknfd1relK4I9wHxVPVdVrwDHgAMTzjSMA8BD3euHgPdNKkhV/RPwb33Dy+U7AByrqv+sqn8G5ln8d/CaWSbvciaat6ouVNUT3esfAmeAbUzh+q6QdTmTXtuqqv/oNq/uHsUUru0qeZczct6WimAb8MKS7XOs/B/vJBTwpSQnkxzuxm6sqguw+AMI3DCxdIMtl2+a1/vOJKe6W0eXbwdMTd4kM8A7WPyb4FSvb19WmNK1TbIpyZPAReCRqprqtV0mL6zT+rZUBBkwNm2fnb2lqnYD+4APJnnnpAONYFrX+37gLcDbgQvAn3bjU5E3yeuBzwIfqqqXVpo6YOw1zTsg69SubVX9d1W9HdgO7Eny1hWmT2vedVvflorgHLBjyfZ24PyEsgxUVee754vA51m8vHsxyVaA7vni5BIOtFy+qVzvqnqx+yH7EfCX/PgSeuJ5k1zN4h+sn66qz3XDU7m+g7JO89peVlX/DvwjsJcpXdulluZdz/VtqQgeB3Yl2ZlkM3AQOD7hTP8ryc8kecPl18C7gWdYzHiom3YI+MJkEi5ruXzHgYNJXpdkJ7AL+NoE8r3K5R/8zm+wuMYw4bxJAnwSOFNVn1iya+rWd7msU7y2W5Jc073+KeBdwDeZwrVdKe+6ru9r9ZvwaXgA+1n8hMO3gbsnnacv25tZ/M3/U8Dpy/mAnwMeBZ7tnq+bYMa/ZfGS9L9Y/FvI76yUD7i7W+uzwL4pyfvXwNPAqe4HaOs05AV+mcXL+VPAk91j/zSu7wpZp3Vt3wZ8vcv1DPAH3fjUre0qeddtff1fTEhS41q6NSRJGsAikKTGWQSS1DiLQJIaZxFIUuMsAklqnEUgSY37H+PGf7ByqjJNAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "#plt.plot(np.arange(T_free+T_nudge),p_dot_output_LPF[0,:])\n",
    "#plt.show()\n",
    "#plt.plot(np.arange(T_free+T_nudge),p_dot_output_LPF[1,:])\n",
    "#plt.show()\n",
    "#plt.plot(np.arange(T_free+T_nudge),p_dot_output_LPF[2,:])\n",
    "#plt.show()\n",
    "#plt.plot(np.arange(T_free+T_nudge),p_dot_output_LPF[3,:])\n",
    "#plt.show()\n",
    "#plt.plot(np.arange(T_free+T_nudge),p_dot_output_LPF[4,:])\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Testing Code\n",
    "acc = 0\n",
    "guess = np.zeros((num_images,1))\n",
    "\n",
    "# For each training image\n",
    "for i in tqdm(range(num_images)):\n",
    "        \n",
    "    # Instantiate membrane potential and spikes for this images\n",
    "    v_input = np.zeros((N_input,T_free+T_nudge))\n",
    "    v_hidden = np.zeros((N_hidden,T_free+T_nudge))\n",
    "    v_output = np.zeros((N_output,T_free+T_nudge))\n",
    "    spikes_input = np.zeros((N_input,T_free+T_nudge))\n",
    "    spikes_hidden = np.zeros((N_hidden,T_free+T_nudge))\n",
    "    spikes_output = np.zeros((N_output,T_free+T_nudge))\n",
    "        \n",
    "    # For each free-phase timestep\n",
    "    for t in range(T_free+T_nudge):\n",
    "        \n",
    "        # LIF of input neurons with normalized MNIST inputs\n",
    "        dvdt_input = (v_rst - v_input[:,t-1]) * tau + test_images[i,:]\n",
    "        v_input[:,t] = v_input[:,t-1] + dvdt_input * dt\n",
    "        reset_input = v_input[:,t] > v_th\n",
    "        v_input[:,t] -= np.multiply(v_input[:,t],reset_input.astype(int))\n",
    "        v_input[:,t] += v_rst * reset_input.astype(int)\n",
    "        spikes_input[:,t] = reset_input.astype(int)\n",
    "           \n",
    "        # Find the synaptic response based on current input and previous outputs\n",
    "        result_IH = np.matmul(syn_IH.T,spikes_input[:,t])\n",
    "        result_HO = np.matmul(syn_HO.T,spikes_hidden[:,t-1])\n",
    "        result_OH = np.matmul(syn_OH.T,spikes_output[:,t-1])\n",
    "            \n",
    "        # LIF of hidden neurons with incoming spikes from input/output neurons\n",
    "        dvdt_hidden = (v_rst - v_hidden[:,t-1]) * tau + result_IH + result_OH\n",
    "        v_hidden[:,t] = v_hidden[:,t-1] + dvdt_hidden * dt\n",
    "        reset_hidden = v_hidden[:,t] > v_th\n",
    "        v_hidden[:,t] -= np.multiply(v_hidden[:,t],reset_hidden.astype(int))\n",
    "        v_hidden[:,t] += v_rst * reset_hidden.astype(int)\n",
    "        spikes_hidden[:,t] = reset_hidden.astype(int)\n",
    "            \n",
    "        # LIF of output neurons with incoming spikes from hidden neurons\n",
    "        dvdt_output = (v_rst - v_output[:,t-1]) * tau + result_HO\n",
    "        v_output[:,t] = v_output[:,t-1] + dvdt_output * dt\n",
    "        reset_output = v_output[:,t] > v_th\n",
    "        v_output[:,t] -= np.multiply(v_output[:,t],reset_output.astype(int))\n",
    "        v_output[:,t] += v_rst * reset_output.astype(int)\n",
    "        spikes_output[:,t] = reset_output.astype(int)\n",
    "        \n",
    "    # Calculate output neuron with highest spike-rate\n",
    "    classification = np.argmax(np.sum(spikes_output,axis=1))\n",
    "    guess[i] = classification\n",
    "    if classification.astype(int) == test_labels[i].astype(int):\n",
    "        acc += 1\n",
    "        \n",
    "# Calculate error-rate\n",
    "acc_rate = acc / num_images * 100\n",
    "print(acc_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "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": [
    "plt.hist(guess)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAXNUlEQVR4nO2dXYzcZ3XGnzNfO/vp9dqO7TgOcRILSKkI1TaqlFJR0aKQXgQuqMgFSiVUcwESqFwU0QtyGVUFhKoKyUBEaCmIChC5iFqiQBVRqYgFmXzgNnHDEuxde22vvd+zszNzerGTdgn7PmeZ2Z1Z8T4/abW7c+b9v+f/zjzzn5nznnPM3SGE+O2n0G8HhBC9QWIXIhMkdiEyQWIXIhMkdiEyodTTyQaHvTI2kb5DEBhwS9uIaZNWYC5ze3E9moAcO1hlL3K7dbEuhQYfG6559AzpIpgTnVc3z4fNCTq0IX68m8HzJTw3Mn90Xkaey/WleTTWVrY9QldiN7MHAHwOQBHAF939MXb/ytgE7n74r5L2wgZfoeZAehWsSYeiuM6PvXqMr/D4y+kVjsS6doi/gdoY4+Ojc2PzD8zzscUaX5faEb4uhQ1+fDp3IKjo+dCoBqogy94Y5EMPvsQXfek2/qCH60JcDy885DF76V8+m/YpcCmJmRUB/AOAdwO4B8DDZnZPp8cTQuwt3Xxmvw/ABXd/xd3rAL4O4KHdcUsIsdt0I/YTAH655f+L7dt+BTM7Y2ZTZjbVWFvpYjohRDd0I/btPnX82ocJdz/r7pPuPlkaHO5iOiFEN3Qj9osATm75/zYAM925I4TYK7oR+48AnDazU2ZWAfB+AE/ujltCiN2m49CbuzfM7CMA/g2bobfH3f1FOqYANIbS9sJGGC1PwmKPAFA7FAUvuXnhzvTr4uA1HiKKwjCDc0GIaZA7V1pLj98Y5mNZOBMAhi5z3+qjfPzGKJm7Qoei0AzOe5WPb5FLWfU6P6+FO4PQWhA2XB/ndrb/oVjnYzfImrMwbFdxdnd/CsBT3RxDCNEbtF1WiEyQ2IXIBIldiEyQ2IXIBIldiEyQ2IXIhJ7ms7vx2Gr1ahDTHU/HF6OUxYGb/NhRzLbQSI9vVng8uDHOj71yhNsHbnC7LadtLAYPxHH2jaEgTl+lZgySx9S7vNSEewiIb9F5jVyK9j5QMwo3+PHXD6VtlQU+NztvWtuAHlUI8VuDxC5EJkjsQmSCxC5EJkjsQmSCxC5EJvQ09GYtoLJE7EH5XZYuOTQThCtGgiqpJLQGALXD6dfFsWleibQxyNMlR16lZtQOczsruVwI0iUrizw3OArNFYLKt4zaRPSY8PFRiW5WpXV0OghJBiHFaF2aA3y8kXNjKawArzbMNKQruxCZILELkQkSuxCZILELkQkSuxCZILELkQkSuxCZ0NM4e6EBDNxIBwJXjvP4IutIuhZ0G41SFutjQS1pMvzm3TyOHqUsRt1MR1+NSlWn7VGJ7ShNNOog2wo6qbZI6fBoX0V9LFi3WudlsJdPdl62HIgfM/Y8B4AGWfeoxDZLG2bxe13ZhcgEiV2ITJDYhcgEiV2ITJDYhcgEiV2ITJDYhciEnsbZW2Vg5VYS3wziruUlFk/mcdPlE921bGZtdEtrfGyU+9wK4qrV6zxYzsoisxa+QJw7HT0mUd42a2cdtaKuLHB7eaXzVtljP+dr6kU+d7QnJDq34dn0/Aun+DWYPqZk2q7EbmbTAJYANAE03H2ym+MJIfaO3biy/7G7X9uF4wgh9hB9ZhciE7oVuwP4rpn92MzObHcHMztjZlNmNtVYXelyOiFEp3T7Nv5+d58xs1sAPG1m/+Xuz269g7ufBXAWAAaPnwy+7hFC7BVdXdndfab9ew7AtwHctxtOCSF2n47FbmbDZjb62t8A3gXghd1yTAixu3TzNv4ogG+b2WvH+Wd3/1c2wJo8z7d+gMcmWc55VL+8HLVkJjFZADTevD7OhxaDYxdr3B61hGb10ZtBvLd+gH+yivYvrB8M6s6T+Ydmo1r9Uc36zls2WzA2qkl/IIjTR30I5t+YDpaz3goA0CoT3/cizu7urwB4a6fjhRC9RaE3ITJBYhciEyR2ITJBYhciEyR2ITKhpymuMJ46yEJIAC/fuxG12B3k9upVbq+PpW3lZT42CutFYZryGrezNR28xENEq8eCUtItPneUhlqfSM/frASpnGXue2WBj2cltqvzQYtvkjYMALVxbl+6g9uPnEuf2/Kt/LyK68R3tWwWQkjsQmSCxC5EJkjsQmSCxC5EJkjsQmSCxC5EJvQ0zm5NoETK/0YpjZWb6bGLd/G5h2aD9r5XeUy3Mdz56+LgPD921FZ54CbpwwugWCe1hYPaQEOX+XnVDvMDrB/jvtGUy2u8zrWtdNdWeWQmnfe8fCufuxHE2VlZcwAYvMLHr5IW4+Vlfmy2N4Kl5urKLkQmSOxCZILELkQmSOxCZILELkQmSOxCZILELkQm9LZlc5GXgx5/iQecr78lPXb4Eo9rRq2LF+7kr3s0Zz2IZdP8Y/C8awAorvJYdqGeXrfGED/x6jV+3stvCHwfCuLshI0R7tux/wzWJVjXDbI3IqoxMBLUAagHra7rB/nxq6QV6mrQDtrIkpvy2YUQErsQmSCxC5EJErsQmSCxC5EJErsQmSCxC5EJvc1nbwElUgN9/p4oh5jYg1h3aZXfoVXicxdr6fEjl3isuXYoiHUH+e5e4q/JpeV60taq8IL619/K1+XYm+ao/a2HZqj9339xd9I2MM2L+Q/Mk0YBAIo1vu5eHEiPXQ/i5KN8zVvBvo1S0EugPpq2DV3mj8niqbSN7ScJr+xm9riZzZnZC1tumzCzp83s5fbvYAuBEKLf7ORt/JcBPPC62z4B4Bl3Pw3gmfb/Qoh9TCh2d38WwPzrbn4IwBPtv58A8J7ddUsIsdt0+gXdUXefBYD271tSdzSzM2Y2ZWZTjdpKh9MJIbplz7+Nd/ez7j7p7pOl6vBeTyeESNCp2K+Y2XEAaP/mX9kKIfpOp2J/EsAj7b8fAfCd3XFHCLFXhHF2M/sagHcAOGxmFwF8CsBjAL5hZh8E8CqA9+1kMi8CGyQPuHIzciZtagzxoVVScx4ASiSODgCrR9Ovi+srPOgaHTvK6y4v8uTrpVPpj0erR4IY/50L1P7FN/0TtS+00rFsAPjuS29O2vhIYPVYmdoHgv7sjYG0vbKUrikPAIO1oNb/BF/X5kBQ856Yl+7gQ4dn0oNZnn4odnd/OGF6ZzRWCLF/0HZZITJBYhciEyR2ITJBYhciEyR2ITKhtymuDhTS2ZhoBrGYoSvpENbSSR7qWDrJX9eq14IWvHNpe9RyOSp5XF7mobXlkzxNtVlJn/vNSbLgAP7kxDS1v7nCY5qvNnguZ3MtHaJiacMAMDjH12Xhrgq1szbc1uRzrwRhvxafmpZ0BoDKQvoOwzOBbyfSj7eTp7mu7EJkgsQuRCZI7EJkgsQuRCZI7EJkgsQuRCZI7EJkQh9aNqftBZ51SNvkRrHu0hq3l0mJa4DHL4v1IKgasDHCH4ahIN68eHs66Fua4/HiP3v7T6k9iqP//bW3U3vpenr+kVleCnqJnBcAVG/wdWf7D2oH+LpEez7GL/D9C1d+nx/AC2nfwvTYDtGVXYhMkNiFyASJXYhMkNiFyASJXYhMkNiFyASJXYhM6H3L5hq5QxCujnKIGZVFfvAoTl8bT78ujlxkJwU0SUljAKheWaX2+iHe2njwRnqDwuIGL3n8H0unqf1nayeo/XuX+PiJF9K2Vrm7eHJ5mW/MWDmWfnqPzPAYPxsLxLn05aBlM2tdvj7B16VEni7seawruxCZILELkQkSuxCZILELkQkSuxCZILELkQkSuxCZ0NM4OxDUteYpwrwtcxCybfH0ZczfyQ8wOp2Oi1Yu3aRjfYDHZAtLK9Q+MH2J2sunb0/aRo6O0LFP/fweaq+v84XzS3wPwKnp9B6EtaPBxolg38Xc27hv1eukz8AJ/tT3QBnDl4MY/9HOWzq3+FB4h9sTwiu7mT1uZnNm9sKW2x41s0tmdq7982Bn0wshesVO3sZ/GcAD29z+WXe/t/3z1O66JYTYbUKxu/uzAOZ74IsQYg/p5gu6j5jZc+23+QdTdzKzM2Y2ZWZTzTX+2VQIsXd0KvbPA7gLwL0AZgF8OnVHdz/r7pPuPlkcHO5wOiFEt3Qkdne/4u5Nd28B+AKA+3bXLSHEbtOR2M3s+JZ/3wuAJDIKIfYDYZzdzL4G4B0ADpvZRQCfAvAOM7sXm5HQaQAf2tFsxuPd5WUeWGW132uHePBxY4TbBy9TM0Yvkk0ABf6aaVeuU3vj6lU+vsQfpsJCOsF5/AKPZU+/cZTao8vB4DW+rsW1dM374Vd5TrndxnvDw7hzrJ5/7SAfW1rlz8W1QzwYPjzH4/A37yKPaRBHp7UXiNuh2N394W1u/lI0Tgixv9B2WSEyQWIXIhMkdiEyQWIXIhMkdiEyoacproUNYGg2HRtoDAdhnPX0WJY6CwANnomJ4aD9b2mZtE2+xlMHWou8rnDxYHK3MQDAhrjzjYn0zsSodXBlgZphQRvt4Rm+biwsuPS7R+jYjSH+fGgE9mHSEpq1/waAShAGHljgC9MqRSHJtK0ZZP6ytudOIoK6sguRCRK7EJkgsQuRCRK7EJkgsQuRCRK7EJkgsQuRCT2NszcrwPLt6fjj4ByPbbI01ahFbkQU2yyupFNcbZDHwQtBiirW16m5tbhE7bUjtyVt1Wt8TRd4x2VUrwftg8neBwConxhP2qwZxbIjO++zXZtIB52HrvKxDVLqeSfUx4K05xYpTb7U+dxq2SyEkNiFyAWJXYhMkNiFyASJXYhMkNiFyASJXYhM6G3L5gLQrKbji/UDPL7IYojGqxJjI6iYDAtyp8eqaeMozxkv3Uy3LQaAwnI65xsAGicmqJ3l8jcrQd72TWpGgaTxR3MDQGGd5X0HJbI3eJx95SgfX1lOP2FYmWkAWJuI4uS8lHQ3+fIrx4Ky52TvBKs/oCu7EJkgsQuRCRK7EJkgsQuRCRK7EJkgsQuRCRK7EJnQ27rx68Doz9N2VhceANZuSccf6wf43EUe6g7roy/dno6lhzXCN0iMHkBxnTu/foC/Jjeq6fmrN3je9vohfuyNEWrGwqmg9XGN70Fg3DhN+nsDqCwFcfjj6Vj44DW+LsNX+BNi5RiPs7PHJLJHexvWD6bHtoiiwyu7mZ00s++b2Xkze9HMPtq+fcLMnjazl9u/eacDIURf2cnb+AaAj7v7mwH8AYAPm9k9AD4B4Bl3Pw3gmfb/Qoh9Sih2d59195+0/14CcB7ACQAPAXiifbcnALxnj3wUQuwCv9EXdGZ2B4C3AfghgKPuPgtsviAAuCUx5oyZTZnZVKO20qW7QohO2bHYzWwEwDcBfMzdF3c6zt3Puvuku0+WqukGhEKIvWVHYjezMjaF/lV3/1b75itmdrxtPw5gbm9cFELsBmHozcwMwJcAnHf3z2wxPQngEQCPtX9/J5ytADRJyCFKO2QprgO8azJaPIqDJo+O0TLWUdhu7Qh/Ta3OB+WYg9Tf4lp6/Pzv8LFeilpVB+N5BAqLJ9NPsZFZvnAlcl47YeRS+vhxOJOfWCFdWXyToEU4yKkVgnTtVlD2PMVO4uz3A/gAgOfN7Fz7tk9iU+TfMLMPAngVwPs6c0EI0QtCsbv7DwCkXt7fubvuCCH2Cm2XFSITJHYhMkFiFyITJHYhMkFiFyITeltKGjxWzlL3AKC0mg5ORmmmZVK6FwBW0l2Pw+NbEA5uDPE7rN7G7V7i6ZhgJbZbQZy8ELRFfiNvF718mefAVhbTT7HaQX6tKa8E63aUj28V0/ZCsDcigqVbA0AxiMOzPQC1oIx1aS1tY+elK7sQmSCxC5EJErsQmSCxC5EJErsQmSCxC5EJErsQmdDTOLs1gcpiOna69AYeu2yV0/bGEJ+7vBTE4Xk4GcX1tC1qB83K+wIADpODAygVeZy9NZNOnm6O8YBycYgnT6/8kp+cBfnsK7emH+/qNf6YrNzK7WOvdJ7vvhq0RY5Kjw9dDmovRHsvqunrbNRmu0mqc7MW2rqyC5EJErsQmSCxC5EJErsQmSCxC5EJErsQmSCxC5EJPY2zexGoj6VjiOWgzwxrZVtaDuYOzjRqTVwmnavKwdzRsSsXeJFxC+qIs7r1NhfURx/mC1MO6sY3gnr7LK+7FMSyx37B9wgsnwhqu5N1K63yuaOa9YUmty/ewdd9cC49Ptozwsay54Ku7EJkgsQuRCZI7EJkgsQuRCZI7EJkgsQuRCZI7EJkwk76s58E8BUAx7BZofysu3/OzB4F8JcArrbv+kl3f4odyw1oRH2rCazHehQ3LWzwuGhlofMe6NHcUU17VksfAJbv4PHmA+fT8eaol3dhI/AtyMuOStqz/u3VeT7Yi9w3tu8C4M+18LyCxzSqed8c6DzXvnqtu770KXayqaYB4OPu/hMzGwXwYzN7um37rLv/3Z54JoTYVXbSn30WwGz77yUzOw/gxF47JoTYXX6jz+xmdgeAtwH4Yfumj5jZc2b2uJkdTIw5Y2ZTZjbVXCN7ToUQe8qOxW5mIwC+CeBj7r4I4PMA7gJwLzav/J/ebpy7n3X3SXefLA4Od++xEKIjdiR2MytjU+hfdfdvAYC7X3H3pru3AHwBwH1756YQoltCsZuZAfgSgPPu/pkttx/fcrf3Anhh990TQuwWO/k2/n4AHwDwvJmda9/2SQAPm9m9ABzANIAPhUey9k+CJgmtATxE1SLldQHAGkGIKWjhuz6RHl8I2vOWl3gopTnAfRu6FNRrJi/ZrOwwELcWLpPS30CcOlwj67Z8a5AGGoSgohLeNPU4KvU8zB+T9W2/ofp/xl/m9qXbSap3kDLdJGnFNDzNDwu4+w+wvURpTF0Isb/QDjohMkFiFyITJHYhMkFiFyITJHYhMkFiFyITetuyuQEMXE8HODdImWmAx4xZCioQx5NZKiYA1MfTvrE2uQBv9wwAjS53EbPSw6ycMhDvAVg/GKSZBvsTxi+k73Dzbr7oa0f43BHrB9K2aH9AtO+iMczXrT7S+b6O2iF+7PJKZ+uiK7sQmSCxC5EJErsQmSCxC5EJErsQmSCxC5EJErsQmWDue1O2dtvJzK4C+MWWmw4DuNYzB34z9qtv+9UvQL51ym769gZ3P7Kdoadi/7XJzabcfbJvDhD2q2/71S9AvnVKr3zT23ghMkFiFyIT+i32s32en7FffduvfgHyrVN64ltfP7MLIXpHv6/sQogeIbELkQl9EbuZPWBm/21mF8zsE/3wIYWZTZvZ82Z2zsym+uzL42Y2Z2YvbLltwsyeNrOX27+DCuY99e1RM7vUXrtzZvZgn3w7aWbfN7PzZvaimX20fXtf14741ZN16/lndjMrAngJwJ8CuAjgRwAedvef9dSRBGY2DWDS3fu+AcPM/gjAMoCvuPtb2rf9LYB5d3+s/UJ50N3/ep/49iiA5X638W53Kzq+tc04gPcA+Av0ce2IX3+OHqxbP67s9wG44O6vuHsdwNcBPNQHP/Y97v4sgPnX3fwQgCfafz+BzSdLz0n4ti9w91l3/0n77yUAr7UZ7+vaEb96Qj/EfgLAL7f8fxH7q9+7A/iumf3YzM7025ltOOrus8DmkwfALX325/WEbbx7yevajO+bteuk/Xm39EPs2xXQ2k/xv/vd/fcAvBvAh9tvV8XO2FEb716xTZvxfUGn7c+7pR9ivwjg5Jb/bwMw0wc/tsXdZ9q/5wB8G/uvFfWV1zrotn/P9dmf/2M/tfHers049sHa9bP9eT/E/iMAp83slJlVALwfwJN98OPXMLPh9hcnMLNhAO/C/mtF/SSAR9p/PwLgO3305VfYL228U23G0ee163v7c3fv+Q+AB7H5jfz/APibfviQ8OtOAD9t/7zYb98AfA2bb+s2sPmO6IMADgF4BsDL7d8T+8i3fwTwPIDnsCms433y7Q+x+dHwOQDn2j8P9nvtiF89WTdtlxUiE7SDTohMkNiFyASJXYhMkNiFyASJXYhMkNiFyASJXYhM+F9uvkgbo3yX/QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAaxElEQVR4nO2de2yc53XmnzMX3ilREnWhJEqyZEqRYseSTcuNHdfxJYbrNnDSpIv4j9jFZqsWaBbtpsA2yP7RYBdYZIMm3XbRm7I24qaOi3QT107jJva6rr12Elm0wsiSZVkSRUkUaVEkRYp3zuXsHxrvqgnf51N5mSH6Pj+AIDnPvN/3zjffM9/MnPecY+4OIcS/flKVnoAQojzI7EJEgswuRCTI7EJEgswuRCRkyrmzdF29Z5tWBnWvKfINFC0oZavyc50WACA3nXAoyMvi6rpROnRgZBnVvSrhcRfCjxsALBfWLemQ1iXcIZ9wPUjzaE4qHd5+sci3XVs1Q/VsqkD1y+N1ZGJ83pkM33ZSDKuQSyfcY+6kpsLPd25kCPnJ8VnvMC+zm9kDAP4YQBrA/3T3L7H7Z5tWYvO+zwX1me2TdH/FyfB0WzcN0LEF54bp7W6mOoghf+vWl+nQx753H9ULG6eoXhzLUr2mN3xcMhN0KCZu4sfch6u4Xs9N0bAiPIHx0Ro6dveWc1RfV8tfZL//+k1kYjk6trmZbztf4C9Uly42Up1duJJeiBqPhp+TU3/91fBm+YzCmFkawJ8C+CUAuwA8bGa75ro9IcTiMp/P7HsBnHT3LnefAfA3AB5amGkJIRaa+Zh9A4Cr32f1lG77Z5jZPjPrMLOOwsT4PHYnhJgP8zH7bB86fu7Dhrvvd/d2d29P19XPY3dCiPkwH7P3AGi96v+NAHrnNx0hxGIxH7MfBNBmZteZWRWATwF4dmGmJYRYaOYcenP3vJl9FsAPcCX09ri7H6WDDChmw2GFzBkeisnXhccOvtxCxz74yR9R/dmRBqpXvx7WH6//IB2bFJNN9fDHvewcDxsO3xKOR1f18rBdfSMP+40lhCxXvVLNx29aHtRqyPoAABjdwI/L4YPbqI6q8JGvP8q3PQmuj2/mIcfsSn5ca2rDz1kmxdc+jLSuCGpFEimdV5zd3Z8D8Nx8tiGEKA9aLitEJMjsQkSCzC5EJMjsQkSCzC5EJMjsQkRCmfPZ81i2ZzCoD54Jxw8B0ID1RNs0Hfpy3/VUX9vEUxrfvZWIp/ky4PwKnmu/euMw1S8u58eluiH82IsZHmfP53nedU1dQk75J0aojtfXBiVLKEGQlK9erE7ISR8LX8vGtvKdN7Vcprr38hoFv/7+H1P9yafuDWoTq3icPT0zt/oFurILEQkyuxCRILMLEQkyuxCRILMLEQkyuxCRUNbQW6GYwthkOCXSszzkYDXhUExNLa8WOtLJq8eObh+jOisN3NDHUzXTkzz8NXSZz21n+xmqHzu+MaitOkmHYnAtT1G1UX6KzOR4arBvC1evzSSE9fq/uZnq6bt5Zdx1beGw4OA/8ZTonTdeoPqhznBJdAD42g/vonq2MRw2LCznIcf2XaeC2tAT4dRaXdmFiASZXYhIkNmFiASZXYhIkNmFiASZXYhIkNmFiISyxtndDdMk5ty8nqdLjh5aFdRy9bzb6L0f6aT682/cSPWaC+FDlePZjsg18vUD9ef4a+5t93dT/eRwOB6d/UQ/HZt6ezXV0+t4LLuWlEQGgDQpi3xpgHc6ndlKZaQT2ioP/WM4lp7hGdHo/IedVJ9Zx/eNDH/ON9/WF9R6/3drUAOANwZ3BDXWGVdXdiEiQWYXIhJkdiEiQWYXIhJkdiEiQWYXIhJkdiEiobylpMcMK14L50/f81uH6Pi/Hbw5LPKUcrzU1cbvkJBLP31dOE/49rYuOvZQbzjfHADW7Rmm+tcP3k71zzz4UlD75t/eQ8emSF41AKSP8zLZk1V1VF/+gXDp8GxCDYLUNh4MrzrA4/S09PjeCTq02M9bNmdG+XWyuJLP/WR3uMR2DS8xgAJbt0Eqg8/L7GbWDWAUQAFA3t3b57M9IcTisRBX9rvdfWABtiOEWET0mV2ISJiv2R3A82b2hpntm+0OZrbPzDrMrCM/OT7P3Qkh5sp838bf4e69ZrYGwAtm9ra7v3L1Hdx9P4D9AFC3ppV/GySEWDTmdWV3997S734ATwPYuxCTEkIsPHM2u5nVm1nje38DuB/AkYWamBBiYZnP2/i1AJ42s/e28013/z4bkGrKoebj4Xrc//ANHk9ec184N3twOKF+eTePF6++kQcURg6Fa7ufXcdbKk8O1VL9ZA+f+/r38Zz03ummoLb9vnCNcQCoyfBY96GzPLd661p+3N45Gl5jsPl979KxPYfWU310F8+lz9SG2zLnJxNO/ZqEtskTvNU1zvPnvH5buCX0ZBXPlWc9EiwbHjtns7t7F4Cb5jpeCFFeFHoTIhJkdiEiQWYXIhJkdiEiQWYXIhLKmuKam8yi/3A4tS+/PRwqAYCxrnAp6dQUz3Hdfhtve5whJY8BoPGD4ZTFvpd5CmvtTeEwCwD86t6fUv17Z95P9cZMOP12dQ0PETVlearnp9pfp/q6NC///R9znwxq3T28VTWW8RDULdu7qf7G0XAt6nQjDzmme3mb7dW38pbO57v5Y8sdC9cfz7bx9uG5rnBqr0+Hn29d2YWIBJldiEiQ2YWIBJldiEiQ2YWIBJldiEiQ2YWIhLLG2WFAgaQO1p7n05m8LpzSWCzwsQ1ZXtr3jdObqH79+otBrXYvT/McPrWS6s9mbqD66ABPz33u1XBq8Ng2vnah9brw4wKA//X6rVRPKsFt6XBxoq2tfN+nj4dbLgNA5zm+vqFhbTheXehoomOndoTXLgDA+S4eR2/awNdWDCMcZ69PaPfcuCtcnvvdmvDzrSu7EJEgswsRCTK7EJEgswsRCTK7EJEgswsRCTK7EJFQ1jh7qqqAxk2khO7qKjr+zi2ng1rnhQ10bGcP173I8+FPnAvn4a/4EZ933XK+7dFq3no4M8Jz0tMkJJya4q/nF1/jsexVvbyJz9DuhF7ZJGTcdWYNHZoZ43PP1/LTd+xy+HnJ3shzxuur+fqE2heXU33gXt7KOjUZfmzjI7xd9FRV+HHlC+Ht6souRCTI7EJEgswuRCTI7EJEgswuRCTI7EJEgswuRCSUNc6eHkqj8a/DebypT/Ma5P/nyI6gVn+K1/nOXc/b+1pCXrbnwq+Lk8081jy5gcdsr3+Sz+3iHh6zrRoNx8Ibu/jr+VQzj6PnfmWY6p6Qaw+Sz54e5M9Zdtso1QvneavrNOklUN/Cj/myr4XPUwC48AiP0//Chh6qd9aF131M9vPnu0Bqw6MQfsyJV3Yze9zM+s3syFW3rTSzF8zsROk3b1AuhKg41/I2/usAHviZ2z4P4EV3bwPwYul/IcQSJtHs7v4KgKGfufkhAE+U/n4CwMcWdlpCiIVmrl/QrXX3PgAo/Q4ucjazfWbWYWYduWn+OUcIsXgs+rfx7r7f3dvdvT1bzb9QEUIsHnM1+wUzawGA0u/+hZuSEGIxmKvZnwXwaOnvRwE8szDTEUIsFolxdjN7CsCHATSbWQ+APwDwJQDfMrPPADgL4NeuZWe5BqD3znAcsNETeqxv7QtqJ6Z4vjqL9wKAT/JDUbUinDReqONjr/sO7zN+4TYeVy0mPEsZ0mJ9dCtfP9Cwha9t+HdtP6T6jht6qf7a+Pag9vdned95TzgffJBfq+r7ws/56m/ybZ96mNcQWPU0X19w8KObqV5TG47zZy7zffumybBIzvNEs7v7wwHp3qSxQoilg5bLChEJMrsQkSCzCxEJMrsQkSCzCxEJ5S0lnQPqesOvLzvbL9DxB968PqhZQkVj1joYADLDPNyx+oXaoDbcxnd+/m5eanrLd/ky4hMP89DcbR8/EtQe2/QqHfvtMZ7K+YkG3nr4kTO/SPX31Yef05k8P/3u2niK6h1dPNmydiAc8ry4t4mObTpGZVz8Fd4C3M6FzxcAKJBW2vlVPCW6sS6871QqfJ7ryi5EJMjsQkSCzC5EJMjsQkSCzC5EJMjsQkSCzC5EJJQ1zl7MApMt4ZTLgwfC6ZAAgKZw/DHVyNNI7Rxvg1vXy2PlgzeE4/BZXvEYzZ08zfTS+xLKMTfxmG5LTThN9e/GeXWgMzPNVP+LYd5OOm18/cInlx8Kat+v20XHHrjA00Qv7aEymo6FT+9Clj/f6Wn+uLLv8Dh6rpE/55OD4fGZEW7LycGmoFacCp+nurILEQkyuxCRILMLEQkyuxCRILMLEQkyuxCRILMLEQlljbMjUwRWkVzcPh4LL5LQZSrN4+xNNw5Qferiaqov6wrHXavGeUzVijxm23sXbx+87gc8H75z88ag1pgOl8AGgOYMXyTwZyd5vvp0jrdd/ljPbwa1FQ2kBjaAVXXjVL/UwvP8h1aFY86NTXzf/b18fUFDF7fOFFlPAgCZ4fD4fHOOjk1fIvsmywd0ZRciEmR2ISJBZhciEmR2ISJBZhciEmR2ISJBZhciEsoaZ6/O5rF1fTjefa66iY7PD5M4fDfPCR/K8phsNiGlfJJ0F24+zHOjp5fx19S6d/jTsOwkj4Wf/sF1Qa0rHdYAYKaJx4Prz/O5T+zmcXxWr7+1ZZiO/dz6H1D9wNpwHwEAePLMrUGtqYa0PQaQP8Br0k9s4Mdt5YZhqt95a1dQ++7L7XTs9lvOBrXBuvCajcQru5k9bmb9Znbkqtu+aGbnzayz9PNg0naEEJXlWt7Gfx3AA7Pc/kfuvrv089zCTksIsdAkmt3dXwEwVIa5CCEWkfl8QfdZMztcepsf/IBjZvvMrMPMOmZG+OckIcTiMVez/zmAbQB2A+gD8JXQHd19v7u3u3t71XJepE8IsXjMyezufsHdC+5eBPA1AHsXdlpCiIVmTmY3s5ar/v04gHDPYCHEkiAxzm5mTwH4MIBmM+sB8AcAPmxmuwE4gG4A4aTlq5iezuLkqXVBPdvI87pZru7yGwbp0NFDq6hefYnvevmpcLy4diChn/Zpnp+cW87z1VMTfLyRkO+y7oR48EunqT54L4/T597hNQim1obrDAy28MUNByZ4HP0vj3+I6uMj4bkNDPF6+XW38RMic7SJ6iOjfF3HM6/fHNQaevk1+FhtuH7B1FS4vkCi2d394VlufixpnBBiaaHlskJEgswuRCTI7EJEgswuRCTI7EJEQllTXC3tqFoeLiXtRZ4qatlwGGn4KA+t2XZelnhkDQ8hTQyHyxJX/Zi/Zo5u4GGYTEJ74KphHprb+JXXg1rhjhvp2JEPbaH68id/TPWJz91O9V0fCKdjvnVkEx2baumk+jO3/CXVHzn2SFD797e/RMf+52/MFoT6/xQSUoO9wM/lVEM4nDq2k28bbNsqJS2EkNmFiASZXYhIkNmFiASZXYhIkNmFiASZXYhIKGucvSqTx6bmcOrg+X9speO3fyScjnlP+3E6Nmu8pfOffI8XyC1mwrHwy638MFYP8zh6w7nw2gMASE3xFNqJB8LpkvWvnaBjq5qWUX3q3luonnBYaSy9ceNlOnYgx9sm/4fuT1K96OGg85eP30/HZtp5iuuqJ/hxG27jVZkKZOlEbhdvJ71xdXhuQ9Xhc0VXdiEiQWYXIhJkdiEiQWYXIhJkdiEiQWYXIhJkdiEioaxx9umpLE6+0xLUszeO0fGXpsKxyz/9yV107CMfOED1TTef5/ueCO/bdvA4en/vcqqnZ6qpnqvnufbNr4fjrpce2JGwbZ53XUw4Q1ac4GWuxzaH6wBc7uVx9J+s4Osu7ml+m+r/4/nZ+pFeYcfucJ49AJx6bTPVe+7nCwya1vP2iPbyyrB4lNc/GPtgOA5fJDUhdGUXIhJkdiEiQWYXIhJkdiEiQWYXIhJkdiEiQWYXIhLKGmdHwZAZCcddN2/nOcTnXg3HXYvrebz3vkbeQv7uxreo/ofnwjHbtoZ+OvbvRm6i+rt38tfcunNcv3DniqDmKR5HX3Y2IVd+dfj5AoD+PeEWwQCAVLgGemqKP661tTzf/bF3eM36Yn04Fj6WsLYhPcWPW9UgPy7D4PnudWT306sSatIfDLebLoyHLZ14ZTezVjN7ycyOmdlRM/ud0u0rzewFMztR+h0+44QQFeda3sbnAfyeu+8E8AsAftvMdgH4PIAX3b0NwIul/4UQS5REs7t7n7sfKv09CuAYgA0AHgLwROluTwD42CLNUQixAPyLvqAzsy0A9gA4AGCtu/cBV14QAKwJjNlnZh1m1lEc5/3WhBCLxzWb3cwaAHwbwO+6O//m5Crcfb+7t7t7e6q+fi5zFEIsANdkdjPL4orRn3T375RuvmBmLSW9BQD/SloIUVESQ29mZgAeA3DM3b96lfQsgEcBfKn0+5nEvRngJGKRK/BwRm55OCRxx/t5yeTxIg+1/NeuX6b6dcsGg9r5qSY6tnUNDym2tV2k+ksr26g+Phl+GrN1PCTZ1tpD9VOXeCts7wiHgQAgOxK+nuy+j6eovvr0HqpbQmdjbA0/9jQJCQJAvp6nLedW8ZCl5fh1NN8Q3n5j99yXv6RI5u21xNnvAPBpAG+aWWfpti/gism/ZWafAXAWwK/NeYZCiEUn0ezu/irCLd7vXdjpCCEWCy2XFSISZHYhIkFmFyISZHYhIkFmFyISzJ3HExeSurYW3/Hf/21QzyfE2TevCMerJ/M81fL25i4+t9QM1X96eWNQmyrwoEZDlrdkPjtKygoDyKZ52eKJXPix9/U30bG19QntolP8/EgZ1+u+FS6j/e5d/HHVnOfPaVIsPEWWGFQN8xRWNhYAigmZvQndprHqtneD2kyen08DfeSY/pc/wXR3z6wPTld2ISJBZhciEmR2ISJBZhciEmR2ISJBZhciEmR2ISKhrKWks+kiWhpHg/rRt3iL3iNnwvHFlh28dsZTx26hen4g3JIZADZtvxDURqer6Nj2teeofubkrBW9/h+t23i++wTZfyrNY9HL6qaofuEkz1dHI8/r3vAb4dbIgz/ibZHre/nch3dyPT1GrmV3DNOx46d4KehUnsfpc2t4oH7oh+vC206I8TfeFl5v0p8hpbv5ZoUQ/1qQ2YWIBJldiEiQ2YWIBJldiEiQ2YWIBJldiEgoa5x9aiaDt3vXhu9QzWt5Z1eFY8K9fQlNZPP8de337/l7qn/5hY8GtRt2d9OxIzkew9+6PZzbDAC1GR54/eiGw0HtzdENdOzRgXC8FwDqN4bXRQBAPs9rEBw/H36+fQPPpR/O8lr/WMfH+2j4uI/18+5E1RM8jj69ISEYXuDj83XhNQIfufcndOzAdHju58m5oiu7EJEgswsRCTK7EJEgswsRCTK7EJEgswsRCTK7EJFwLf3ZWwH8FYB1AIoA9rv7H5vZFwH8BoD3kq2/4O7PsW1VZ/PYtnYgqI9M19C5DFwKF+Ou7eIx2cINY1T/bwceoHq6ORzTPTXAe5hXZXh99OGBBqo3vsXz5f9sZziWblm+diGVpCf0MUcXj1eT9GoaawaAYsK6Cwzx49J4a7gOQFsDXz/w1tgWqjevvUz1JC5dDvcKOHhhEx070NMU1CYmwz64lkU1eQC/5+6HzKwRwBtm9kJJ+yN3/8Nr2IYQosJcS3/2PgB9pb9HzewYAL4sSwix5PgXfWY3sy0A9gA4ULrps2Z22MweN7NZ16ua2T4z6zCzjtzI5PxmK4SYM9dsdjNrAPBtAL/r7pcB/DmAbQB248qV/yuzjXP3/e7e7u7t2eV8jbgQYvG4JrObWRZXjP6ku38HANz9grsX3L0I4GsA9i7eNIUQ8yXR7GZmAB4DcMzdv3rV7S1X3e3jAI4s/PSEEAvFtXwbfweATwN408w6S7d9AcDDZrYbgAPoBvCbSRuayWdwdiicilo4xUNQ7JXJeEVjJHWmrqrjKYupY+G5TS3jYb/cDE93zGzi32WM7qIy7th5MqgNz/CPTkdP8e9aH/jAm1R//vTNVK+5YTiozXTytORcY0LorYWXwR48Hg6JXlzBS0Uv7+bXwbFRXmI7M05lNN8dLn1++TVeWrx2Tzjsx0Kt1/Jt/KsAZjtbaUxdCLG00Ao6ISJBZhciEmR2ISJBZhciEmR2ISJBZhciEspaShrmMAsHvPPreWngpqZw8HL07XDKIACkTvJUzNwmvu9aIq/ZyVsqv3uap8BWJ6TAFkcSUn+nwo+t77u8LXJ2Lw8IP3dgN9XTCZcLlt471sTj6MtO8I2ntk9QffpwXVBb+f4hOrZnlMe6m7fx8ZP/tJrqI+Ph9Q9TW2fo2I9uOR7UvlUVPlF1ZRciEmR2ISJBZhciEmR2ISJBZhciEmR2ISJBZhciEsyTEr0XcmdmFwGcueqmZgDh2tKVZanObanOC9Dc5spCzm2zu88a5C+r2X9u52Yd7t5esQkQlurcluq8AM1trpRrbnobL0QkyOxCREKlzb6/wvtnLNW5LdV5AZrbXCnL3Cr6mV0IUT4qfWUXQpQJmV2ISKiI2c3sATM7bmYnzezzlZhDCDPrNrM3zazTzDoqPJfHzazfzI5cddtKM3vBzE6UfvPi6+Wd2xfN7Hzp2HWa2YMVmlurmb1kZsfM7KiZ/U7p9ooeOzKvshy3sn9mN7M0gHcAfARAD4CDAB5297fKOpEAZtYNoN3dK74Aw8x+EcAYgL9y9xtKt30ZwJC7f6n0QrnC3X9/icztiwDGKt3Gu9StqOXqNuMAPgbg11HBY0fm9W9QhuNWiSv7XgAn3b3L3WcA/A2AhyowjyWPu78C4GdLojwE4InS30/gyslSdgJzWxK4e5+7Hyr9PQrgvTbjFT12ZF5loRJm3wDg3FX/92Bp9Xt3AM+b2Rtmtq/Sk5mFte7eB1w5eQDw+knlJ7GNdzn5mTbjS+bYzaX9+XyphNlnayW1lOJ/d7j7zQB+CcBvl96uimvjmtp4l4tZ2owvCeba/ny+VMLsPQBar/p/I4DeCsxjVty9t/S7H8DTWHqtqC+810G39DvcIbDMLKU23rO1GccSOHaVbH9eCbMfBNBmZteZWRWATwF4tgLz+DnMrL70xQnMrB7A/Vh6raifBfBo6e9HATxTwbn8M5ZKG+9Qm3FU+NhVvP25u5f9B8CDuPKN/CkA/6kScwjMayuAn5Z+jlZ6bgCewpW3dTlceUf0GQCrALwI4ETp98olNLdvAHgTwGFcMVZLheb2IVz5aHgYQGfp58FKHzsyr7IcNy2XFSIStIJOiEiQ2YWIBJldiEiQ2YWIBJldiEiQ2YWIBJldiEj4v8auAS4fT+g7AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(syn_IH[:,0].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,1].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,2].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,3].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,4].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,5].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,6].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,7].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,8].reshape((28,28)))\n",
    "plt.show()\n",
    "plt.imshow(syn_IH[:,9].reshape((28,28)))\n",
    "plt.show()"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}