LSM_SVMclassifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:49.226528Z",
     "start_time": "2021-11-26T15:17:47.692416Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rcdI748AEYa8",
    "outputId": "c4fc5cc7-78d6-4127-8ce0-2e3548942304"
   },
   "outputs": [],
   "source": [
    "#!/usr/bin/python3\n",
    "import numpy as np\n",
    "from math import exp\n",
    "from numpy.random import binomial,shuffle,seed, choice\n",
    "import pandas as pd\n",
    "from IPython.display import display, clear_output\n",
    "import os\n",
    "import CompactLSM\n",
    "\n",
    "seedval =15 # for replicating results (used for 2,3,6,7,11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reservoir Dimension set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:49.242530Z",
     "start_time": "2021-11-26T15:17:49.227529Z"
    }
   },
   "outputs": [],
   "source": [
    "nx = 5\n",
    "ny = 5\n",
    "nz = 5\n",
    "N = nx*ny*nz                                          # Reservoir size\n",
    "\n",
    "N_read = 10                                           # No. of Readout neurons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-23T12:37:57.345267Z",
     "start_time": "2021-10-23T12:37:57.330268Z"
    }
   },
   "source": [
    "Important constants related to LIF neuron and synaptic model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:49.466547Z",
     "start_time": "2021-11-26T15:17:49.245532Z"
    }
   },
   "outputs": [],
   "source": [
    "global vrest, vth, t_refrac\n",
    "vrest, vth, t_refrac = 0, 20, 2\n",
    "\n",
    "tau_m = 32\n",
    "params_potential = {'C':1, 'g_L':1/tau_m, 'E_L':vrest, 'V_T':vth, 'R_p':t_refrac}\n",
    "\n",
    "Delay = 1 #constant delay for all synapses in ms\n",
    "\n",
    "tau_c = 64\n",
    "C_theta = 5\n",
    "del_C = 3\n",
    "n_bits = 8\n",
    "delta_c = 1\n",
    "params_conc = {'C_theta':C_theta, 'del_C':del_C, 'tau_c':64, 'nbits':n_bits, 'delta_c':delta_c}\n",
    "\n",
    "syn_string = \"second-order\"\n",
    "\n",
    "sampling_freq = 12.5 # in khz\n",
    "h = 1 # in ms\n",
    "α_w = 0.8\n",
    "time_params = {'h':h, 'Delay':Delay}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set Reservoir Connections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:49.762575Z",
     "start_time": "2021-11-26T15:17:49.468549Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total synapse: 1115 ,E --> E : 724 ,E --> I: 121 ,I --> E/I: 270\n",
      "Total Connections: for neuron 64:1, [7, 33, 38, 58, 61, 67, 69, 74, 78, 83, 98, 107, 118, 119, 122]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Storing the IDs of the neurons\n",
    "LSM_ID = np.zeros((nx,ny,nz),dtype=np.int64)\n",
    "l = 0\n",
    "for i in range(nx):\n",
    "    for j in range(ny):\n",
    "        for k in range(nz):\n",
    "            LSM_ID[i,j,k] = l\n",
    "            l = l + 1\n",
    "\n",
    "# Storing the synapse connections, and creating the initial weight matrix\n",
    "\n",
    "k_prob = [0.45, 0.3, 0.6, 0.15]\n",
    "r_sq = 2**2\n",
    "\n",
    "W_arr = [3, 6, -2, -2]\n",
    "W_init = 3\n",
    "Weights_temp = np.zeros((N,N))\n",
    "\n",
    "N_in = int(N*0.8)\n",
    "neuron_type = [ int(i<N_in) for i in range(N)]\n",
    "seed(seedval)\n",
    "shuffle(neuron_type) # 1 for excitatory, 0 for inhibitory\n",
    "\n",
    "synapes = [dict() for i in range(N)]    # an array of dictonaries which store the location of neuron, \n",
    "                                        # type of neuron, and the IDs of the neurons it is connected to\n",
    "\n",
    "for l in range(N):\n",
    "    loc = CompactLSM.ID_to_ind(nx,ny,nz,l)\n",
    "    n_type = neuron_type[l]\n",
    "    cons = []\n",
    "    for i in range(nx):\n",
    "        for j in range(ny):\n",
    "            for k in range(nz):\n",
    "                if l != int(LSM_ID[i,j,k]):\n",
    "                    dist_sq = (loc[0]-i)**2 + (loc[1]-j)**2 + (loc[2]-k)**2\n",
    "                    k_probl = 0\n",
    "                    if n_type == 1:\n",
    "                      if neuron_type[int(LSM_ID[i,j,k])] == 1:\n",
    "                        k_probl = k_prob[0]\n",
    "                        W_init = W_arr[0]\n",
    "                      else:\n",
    "                        k_probl = k_prob[1]\n",
    "                        W_init = W_arr[1]\n",
    "                    else:\n",
    "                      if neuron_type[int(LSM_ID[i,j,k])] == 1:\n",
    "                        k_probl = k_prob[2]\n",
    "                        W_init = W_arr[2]\n",
    "                      else:\n",
    "                        k_probl = k_prob[3]\n",
    "                        W_init = W_arr[3]\n",
    "\n",
    "                    probability = k_probl* exp(-1*dist_sq/r_sq)\n",
    "#                     print(probability)\n",
    "                    check = binomial(1,probability)\n",
    "                    if check == 1:\n",
    "                        cons.append(int(LSM_ID[i,j,k]))\n",
    "                        Weights_temp[l,int(LSM_ID[i,j,k])] = W_init    \n",
    "    synapes[l] = {\"Location\":loc, \"Neuron_type\":n_type, \"connections\":cons}\n",
    "\n",
    "global Weights\n",
    "Weights = Weights_temp * α_w\n",
    "print(\"Total synapse:\", len(np.argwhere(Weights!=0)), \n",
    "        \",E --> E :\", len(np.argwhere(Weights==W_arr[0] * α_w)), \n",
    "        \",E --> I:\",len(np.argwhere(Weights==W_arr[1] * α_w)),\n",
    "        \",I --> E/I:\",len(np.argwhere(Weights==W_arr[2] * α_w)))\n",
    "i = 64\n",
    "print(\"Total Connections: for neuron {}:{}, {}\".format(i,synapes[i][\"Neuron_type\"],synapes[i][\"connections\"]) )\n",
    "Weights[1,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-23T13:37:08.001869Z",
     "start_time": "2021-10-23T13:37:07.984870Z"
    }
   },
   "source": [
    "Set Readout neuron initial Weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:49.855585Z",
     "start_time": "2021-11-26T15:17:49.764577Z"
    }
   },
   "outputs": [],
   "source": [
    "All_labels = [str(x) for x in range(10)]\n",
    "# N_read = 10                                           # No. of Readout neurons\n",
    "\n",
    "Weights_temp_readOut = -8 + 16 * np.random.rand(N_read, N) # random weight initialization\n",
    "\n",
    "\n",
    "synapes_read = []        # an array of dictonaries which store the label of neuron, \n",
    "                                                      # and the IDs of the neurons it is connected to\n",
    "\n",
    "for l in range(N_read):\n",
    "    label = All_labels[l]\n",
    "    synapes_read.append(label)\n",
    "\n",
    "Weights_readOut = Weights_temp_readOut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:50.088602Z",
     "start_time": "2021-11-26T15:17:49.857587Z"
    }
   },
   "outputs": [],
   "source": [
    "# creating file location and label arrays for train and validate\n",
    "\n",
    "base = 'PreProcessing/trainBSA'\n",
    "os.listdir(base)\n",
    "\n",
    "All_Labels = []\n",
    "file_name_List = []\n",
    "\n",
    "for human in os.listdir(base):\n",
    "    base_up = base + '/' + human\n",
    "    for train_sample in os.listdir(base_up):\n",
    "        train_Label = train_sample[0:2]\n",
    "        file_loc = base_up + '/' + train_sample\n",
    "        file_name_List.append(file_loc)\n",
    "        All_Labels.append(train_Label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:50.103605Z",
     "start_time": "2021-11-26T15:17:50.089604Z"
    }
   },
   "outputs": [],
   "source": [
    "L = 78\n",
    "Fin = 4\n",
    "reservoir_ID = [i for i in range(N)]\n",
    "seed(seedval)\n",
    "Input_CXNs = choice(reservoir_ID, size = (L,Fin))\n",
    "sign_win_matrix = (binomial(1,1/2, size = (L, Fin)) - 0.5)*2\n",
    "# Input_CXNs * sign_win_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding input neurons to reservoir current and then using the spike train to find the current input to the reservoir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:50.118609Z",
     "start_time": "2021-11-26T15:17:50.105605Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of Reservoir = 5 X 5 X 5 ,Total total neurons = 125\n",
      "Total no.of read out neurons = 10\n"
     ]
    }
   ],
   "source": [
    "# print(\"Input neurons =\",L)\n",
    "print(\"Size of Reservoir =\",nx,\"X\",ny,\"X\",nz,\",Total total neurons =\",N)\n",
    "print(\"Total no.of read out neurons =\",N_read)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:51.281699Z",
     "start_time": "2021-11-26T15:17:50.121608Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, accuracy_score\n",
    "from sklearn.preprocessing import normalize\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import svm\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "from matplotlib import rc\n",
    "matplotlib.rcParams['text.usetex'] = True\n",
    "import matplotlib.pylab as pylab\n",
    "params = {'legend.fontsize': 'large',\n",
    "          'figure.figsize': (6.4 * 2, 4.8 * 2),\n",
    "         'axes.labelsize': 'x-large',\n",
    "         'axes.titlesize':'x-large',\n",
    "         'xtick.labelsize':'medium',\n",
    "         'ytick.labelsize':'medium',\n",
    "         'figure.titlesize':'xx-large'}\n",
    "pylab.rcParams.update(params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Network Learning with different synaptic configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:17:51.296703Z",
     "start_time": "2021-11-26T15:17:51.283699Z"
    }
   },
   "outputs": [],
   "source": [
    "syn_string = \"static\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:21:51.434712Z",
     "start_time": "2021-11-26T15:17:51.298701Z"
    },
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibSVM]Training Completed \n",
      "\n",
      "Validation Completed \n",
      "\n",
      "Accuracy:91.66666666666666\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1382.4x345.6 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "############### Training ###################\n",
    "Input_gen_func = CompactLSM.Input_current_gen(file_name_List,\n",
    "                                                syn_string,\n",
    "                                                N,\n",
    "                                                time_params,\n",
    "                                                Input_CXNs,\n",
    "                                                sign_win_matrix,\n",
    "                                                training=True,\n",
    "                                                train_Labels=All_Labels)\n",
    "NUM_INPUTS = len(All_Labels)\n",
    "\n",
    "X = np.zeros((NUM_INPUTS,N))\n",
    "Y = np.zeros((NUM_INPUTS,))\n",
    "\n",
    "for i in range(NUM_INPUTS):\n",
    "    In_app, L, M, Label, input_num, In_spikes = next(\n",
    "        Input_gen_func)  # Generates next input\n",
    "\n",
    "    [Reservoir_potential, Reservoir_Spikes\n",
    "        ] = CompactLSM.reservoir_solver(N, Delay, synapes, M, h, In_app,\n",
    "                                        params_potential, Weights, syn_string)\n",
    "    \n",
    "\n",
    "    X[i,:] = np.sum(Reservoir_Spikes,axis=1)\n",
    "    Y[i] = Label\n",
    "\n",
    "X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size=0.2, random_state=seedval)\n",
    "\n",
    "#Create a svm Classifier\n",
    "clf = svm.SVC(kernel='linear', verbose=True, tol=1e-10) # Linear Kernel\n",
    "\n",
    "#Train the model using the training sets\n",
    "clf.fit(X_train, Y_train)\n",
    "\n",
    "print('Training Completed \\n')\n",
    "\n",
    "#Predict the response for test dataset\n",
    "Y_pred = clf.predict(X_val)\n",
    "\n",
    "\n",
    "Acc = accuracy_score(Y_val, Y_pred)\n",
    "\n",
    "print('Validation Completed \\n')\n",
    "\n",
    "display_string = \"Accuracy:{}\".format(Acc * 100)\n",
    "print(display_string)\n",
    "\n",
    "cm_validate = confusion_matrix(Y_val,\n",
    "                                   Y_pred,\n",
    "                                   labels=[i for i in range(10)])\n",
    "disp_validate = ConfusionMatrixDisplay(\n",
    "    confusion_matrix=cm_validate, display_labels=[i for i in range(10)])\n",
    "disp_validate.plot();\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:27:06.842369Z",
     "start_time": "2021-11-26T15:27:06.828372Z"
    }
   },
   "outputs": [],
   "source": [
    "syn_string = \"first-order\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:33:11.989356Z",
     "start_time": "2021-11-26T15:27:06.843370Z"
    },
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibSVM]Training Completed \n",
      "\n",
      "Validation Completed \n",
      "\n",
      "Accuracy:93.33333333333333\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1382.4x345.6 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "############### Training ###################\n",
    "Input_gen_func = CompactLSM.Input_current_gen(file_name_List,\n",
    "                                                syn_string,\n",
    "                                                N,\n",
    "                                                time_params,\n",
    "                                                Input_CXNs,\n",
    "                                                sign_win_matrix,\n",
    "                                                training=True,\n",
    "                                                train_Labels=All_Labels)\n",
    "NUM_INPUTS = len(All_Labels)\n",
    "\n",
    "X = np.zeros((NUM_INPUTS,N))\n",
    "Y = np.zeros((NUM_INPUTS,))\n",
    "\n",
    "for i in range(NUM_INPUTS):\n",
    "    In_app, L, M, Label, input_num, In_spikes = next(\n",
    "        Input_gen_func)  # Generates next input\n",
    "\n",
    "    [Reservoir_potential, Reservoir_Spikes\n",
    "        ] = CompactLSM.reservoir_solver(N, Delay, synapes, M, h, In_app,\n",
    "                                        params_potential, Weights, syn_string)\n",
    "    \n",
    "\n",
    "    X[i,:] = np.sum(Reservoir_Spikes,axis=1)\n",
    "    Y[i] = Label\n",
    "\n",
    "X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size=0.2, random_state=seedval)\n",
    "\n",
    "#Create a svm Classifier\n",
    "clf = svm.SVC(kernel='linear', verbose=True, tol=1e-10) # Linear Kernel\n",
    "\n",
    "#Train the model using the training sets\n",
    "clf.fit(X_train, Y_train)\n",
    "\n",
    "print('Training Completed \\n')\n",
    "\n",
    "#Predict the response for test dataset\n",
    "Y_pred = clf.predict(X_val)\n",
    "\n",
    "\n",
    "Acc = accuracy_score(Y_val, Y_pred)\n",
    "\n",
    "print('Validation Completed \\n')\n",
    "\n",
    "display_string = \"Accuracy:{}\".format(Acc * 100)\n",
    "print(display_string)\n",
    "\n",
    "cm_validate = confusion_matrix(Y_val,\n",
    "                                   Y_pred,\n",
    "                                   labels=[i for i in range(10)])\n",
    "disp_validate = ConfusionMatrixDisplay(\n",
    "    confusion_matrix=cm_validate, display_labels=[i for i in range(10)])\n",
    "disp_validate.plot();\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:27:06.842369Z",
     "start_time": "2021-11-26T15:27:06.828372Z"
    }
   },
   "outputs": [],
   "source": [
    "syn_string = \"second-order\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:33:11.989356Z",
     "start_time": "2021-11-26T15:27:06.843370Z"
    },
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibSVM]Training Completed \n",
      "\n",
      "Validation Completed \n",
      "\n",
      "Accuracy:92.5\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1382.4x345.6 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "############### Training ###################\n",
    "Input_gen_func = CompactLSM.Input_current_gen(file_name_List,\n",
    "                                                syn_string,\n",
    "                                                N,\n",
    "                                                time_params,\n",
    "                                                Input_CXNs,\n",
    "                                                sign_win_matrix,\n",
    "                                                training=True,\n",
    "                                                train_Labels=All_Labels)\n",
    "NUM_INPUTS = len(All_Labels)\n",
    "\n",
    "X = np.zeros((NUM_INPUTS,N))\n",
    "Y = np.zeros((NUM_INPUTS,))\n",
    "\n",
    "for i in range(NUM_INPUTS):\n",
    "    In_app, L, M, Label, input_num, In_spikes = next(\n",
    "        Input_gen_func)  # Generates next input\n",
    "\n",
    "    [Reservoir_potential, Reservoir_Spikes\n",
    "        ] = CompactLSM.reservoir_solver(N, Delay, synapes, M, h, In_app,\n",
    "                                        params_potential, Weights, syn_string)\n",
    "    \n",
    "\n",
    "    X[i,:] = np.sum(Reservoir_Spikes,axis=1)\n",
    "    Y[i] = Label\n",
    "\n",
    "X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size=0.2, random_state=seedval)\n",
    "\n",
    "#Create a svm Classifier\n",
    "clf = svm.SVC(kernel='linear', verbose=True, tol=1e-10) # Linear Kernel\n",
    "\n",
    "#Train the model using the training sets\n",
    "clf.fit(X_train, Y_train)\n",
    "\n",
    "print('Training Completed \\n')\n",
    "\n",
    "#Predict the response for test dataset\n",
    "Y_pred = clf.predict(X_val)\n",
    "\n",
    "\n",
    "Acc = accuracy_score(Y_val, Y_pred)\n",
    "\n",
    "print('Validation Completed \\n')\n",
    "\n",
    "display_string = \"Accuracy:{}\".format(Acc * 100)\n",
    "print(display_string)\n",
    "\n",
    "cm_validate = confusion_matrix(Y_val,\n",
    "                                   Y_pred,\n",
    "                                   labels=[i for i in range(10)])\n",
    "disp_validate = ConfusionMatrixDisplay(\n",
    "    confusion_matrix=cm_validate, display_labels=[i for i in range(10)])\n",
    "disp_validate.plot();\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T05:53:39.434642Z",
     "start_time": "2021-11-26T05:53:39.418639Z"
    }
   },
   "source": [
    "### Network Learning without reservoir, only input spikes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-26T15:37:07.979466Z",
     "start_time": "2021-11-26T15:33:11.991356Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LibSVM]Training Completed \n",
      "\n",
      "Validation Completed \n",
      "\n",
      "Accuracy:91.66666666666666\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1382.4x345.6 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "############### Training ###################\n",
    "Input_gen_func = CompactLSM.Input_current_gen(file_name_List,\n",
    "                                                syn_string,\n",
    "                                                N,\n",
    "                                                time_params,\n",
    "                                                Input_CXNs,\n",
    "                                                sign_win_matrix,\n",
    "                                                training=True,\n",
    "                                                train_Labels=All_Labels)\n",
    "NUM_INPUTS = len(All_Labels)\n",
    "\n",
    "X = np.zeros((NUM_INPUTS,78))\n",
    "Y = np.zeros((NUM_INPUTS,))\n",
    "\n",
    "for i in range(NUM_INPUTS):\n",
    "    In_app, L, M, Label, input_num, In_spikes = next(\n",
    "        Input_gen_func)  # Generates next input\n",
    "    \n",
    "\n",
    "    X[i,:] = np.sum(In_spikes,axis=1)\n",
    "    Y[i] = Label\n",
    "\n",
    "X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size=0.2, random_state=seedval)\n",
    "\n",
    "#Create a svm Classifier\n",
    "clf = svm.SVC(kernel='linear', verbose=True, tol=1e-10) # Linear Kernel\n",
    "\n",
    "#Train the model using the training sets\n",
    "clf.fit(X_train, Y_train)\n",
    "\n",
    "print('Training Completed \\n')\n",
    "\n",
    "#Predict the response for test dataset\n",
    "Y_pred = clf.predict(X_val)\n",
    "\n",
    "\n",
    "Acc = accuracy_score(Y_val, Y_pred)\n",
    "\n",
    "print('Validation Completed \\n')\n",
    "\n",
    "display_string = \"Accuracy:{}\".format(Acc * 100)\n",
    "print(display_string)\n",
    "\n",
    "cm_validate = confusion_matrix(Y_val,\n",
    "                                   Y_pred,\n",
    "                                   labels=[i for i in range(10)])\n",
    "disp_validate = ConfusionMatrixDisplay(\n",
    "    confusion_matrix=cm_validate, display_labels=[i for i in range(10)])\n",
    "disp_validate.plot();\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "cb34221c29cbd393528f59737984b7cee90fecb74dfd32a425a37477f31f3c8a"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}