SNN_Evolutionary_Ensemble.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IE590 Project Experiment - 2\n",
    "\n",
    "### Experiment-2 involves training a Spiking Neural Network using 3 evolutionary algorithms which include Real Coded GA, Differential Evolution and Particle Swarm Optimizer. Results from all these algorithms are combined by majority voting to investigate any improvement in results\n",
    "\n",
    "\n",
    "### Tensor Flow Functions pertaining to Spiking Neural Networks have been obtained from this source : \n",
    "\n",
    "### https://github.com/kaizouman/tensorsandbox/blob/master/snn/STDP_masquelier_2008.ipynb\n",
    "\n",
    "### Functions have been modified to conduct the experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Importing Libraries in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np \n",
    "from scipy import stats\n",
    "import pandas as pd \n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import pyplot as plt\n",
    "import math\n",
    "import random as r\n",
    "import time\n",
    "import statistics\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Leaky Integrate and Fire Neuron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LIFNeuron(object):\n",
    "    \n",
    "    def __init__(self, u_rest=0.0, u_thresh=1.0, tau_rest=4.0, r=1.0, tau=10.0):\n",
    "        \n",
    "        # Membrane resting potential in mV\n",
    "        self.u_rest = u_rest\n",
    "        # Membrane threshold potential in mV\n",
    "        self.u_thresh = u_thresh\n",
    "        # Duration of the resting period in ms\n",
    "        self.tau_rest = tau_rest\n",
    "        # Membrane resistance in Ohm\n",
    "        self.r = r\n",
    "        # Membrane time constant in ms\n",
    "        self.tau = tau\n",
    "        \n",
    "        # Instantiate a graph for this neuron\n",
    "        self.graph = tf.Graph()\n",
    "        \n",
    "        # Build the graph\n",
    "        with self.graph.as_default():\n",
    "        \n",
    "            # Variables and placeholders\n",
    "            self.get_vars_and_ph()\n",
    "            \n",
    "            # Operations\n",
    "            self.input = self.get_input_op()\n",
    "            self.potential = self.get_potential_op()\n",
    "            # Note that input is a prerequisite of potential, so it will\n",
    "            # always be evaluated when potential is\n",
    "            \n",
    "    # Variables and placeholders\n",
    "    def get_vars_and_ph(self):\n",
    "\n",
    "        # The current membrane potential\n",
    "        self.u = tf.Variable(self.u_rest, dtype=tf.float32, name='u')\n",
    "        # The duration left in the resting period (0 most of the time except after a neuron spike)\n",
    "        self.t_rest = tf.Variable(0.0, dtype=tf.float32, name='t_rest')\n",
    "        # Input current\n",
    "        self.i_app = tf.placeholder(dtype=tf.float32, name='i_app')\n",
    "        # The chosen time interval for the stimulation in ms\n",
    "        self.dt = tf.placeholder(dtype=tf.float32, name='dt')\n",
    "\n",
    "    # Evaluate input current\n",
    "    def get_input_op(self):\n",
    "        \n",
    "        return self.i_app\n",
    "        \n",
    "    # Neuron behaviour during integration phase (below threshold)\n",
    "    def get_integrating_op(self):\n",
    "\n",
    "        # Get input current\n",
    "        i_op = self.get_input_op()\n",
    "\n",
    "        # Update membrane potential\n",
    "        du_op = tf.divide(tf.subtract(tf.multiply(self.r, i_op), self.u), self.tau) \n",
    "        u_op = self.u.assign_add(du_op * self.dt)\n",
    "        # Refractory period is 0\n",
    "        t_rest_op = self.t_rest.assign(0.0)\n",
    "        \n",
    "        return u_op, t_rest_op\n",
    "\n",
    "    # Neuron behaviour during firing phase (above threshold)    \n",
    "    def get_firing_op(self):                  \n",
    "\n",
    "        # Reset membrane potential\n",
    "        u_op = self.u.assign(self.u_rest)\n",
    "        # Refractory period starts now\n",
    "        t_rest_op = self.t_rest.assign(self.tau_rest)\n",
    "\n",
    "        return u_op, t_rest_op\n",
    "\n",
    "    # Neuron behaviour during resting phase (t_rest > 0)\n",
    "    def get_resting_op(self):\n",
    "\n",
    "        # Membrane potential stays at u_rest\n",
    "        u_op = self.u.assign(self.u_rest)\n",
    "        # Refractory period is decreased by dt\n",
    "        t_rest_op = self.t_rest.assign_sub(self.dt)\n",
    "        \n",
    "        return u_op, t_rest_op\n",
    "\n",
    "    def get_potential_op(self):\n",
    "        \n",
    "        return tf.case(\n",
    "            [\n",
    "                (self.t_rest > 0.0, self.get_resting_op),\n",
    "                (self.u > self.u_thresh, self.get_firing_op),\n",
    "            ],\n",
    "            default=self.get_integrating_op\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Leaky Integrate and Fire Neuron with Synaptic Inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It takes synaptic spikes as input and remember them over a specified time period\n",
    "class LIFSynapticNeuron(LIFNeuron):\n",
    "    \n",
    "    def __init__(self, n_syn, w, max_spikes=50, u_rest=0.0, u_thresh=1.0, tau_rest=4.0, r=1.0, tau=10.0, q=1.5, tau_syn=5.0):\n",
    "      \n",
    "        # Number of synapses\n",
    "        self.n_syn = n_syn\n",
    "        # Maximum number of spikes we remember\n",
    "        self.max_spikes = max_spikes\n",
    "        # The neuron synaptic 'charge'\n",
    "        self.q = q\n",
    "        # The synaptic time constant (ms)\n",
    "        self.tau_syn = tau_syn\n",
    "        # The synaptic efficacy\n",
    "        self.w = w\n",
    "\n",
    "        super(LIFSynapticNeuron, self).__init__(u_rest, u_thresh, tau_rest, r, tau)\n",
    "    \n",
    "    # Update the parent graph variables and placeholders\n",
    "    def get_vars_and_ph(self):\n",
    "        \n",
    "        # Get parent grah variables and placeholders\n",
    "        super(LIFSynapticNeuron, self).get_vars_and_ph()\n",
    "\n",
    "        # Add ours\n",
    "        \n",
    "        # The history of synaptic spike times for the neuron \n",
    "        self.t_spikes = tf.Variable(tf.constant(-1.0, shape=[self.max_spikes, self.n_syn], dtype=tf.float32))\n",
    "        # The last index used to insert spike times\n",
    "        self.t_spikes_idx = tf.Variable(self.max_spikes-1, dtype=tf.int32)\n",
    "        # A placeholder indicating which synapse spiked in the last time step\n",
    "        self.syn_has_spiked = tf.placeholder(shape=[self.n_syn], dtype=tf.bool)\n",
    "\n",
    "    # Operation to update spike times\n",
    "    def update_spike_times(self):\n",
    "        \n",
    "        # Increase the age of older spikes\n",
    "        old_spikes_op = self.t_spikes.assign_add(tf.where(self.t_spikes >=0,\n",
    "                                                          tf.constant(1.0, shape=[self.max_spikes, self.n_syn]) * self.dt,\n",
    "                                                          tf.zeros([self.max_spikes, self.n_syn])))\n",
    "\n",
    "        # Increment last spike index (modulo max_spikes)\n",
    "        new_idx_op = self.t_spikes_idx.assign(tf.mod(self.t_spikes_idx + 1, self.max_spikes))\n",
    "\n",
    "        # Create a list of coordinates to insert the new spikes\n",
    "        idx_op = tf.constant(1, shape=[self.n_syn], dtype=tf.int32) * new_idx_op\n",
    "        coord_op = tf.stack([idx_op, tf.range(self.n_syn)], axis=1)\n",
    "\n",
    "        # Create a vector of new spike times (non-spikes are assigned a negative time)\n",
    "        new_spikes_op = tf.where(self.syn_has_spiked,\n",
    "                                 tf.constant(0.0, shape=[self.n_syn]),\n",
    "                                 tf.constant(-1.0, shape=[self.n_syn]))\n",
    "        \n",
    "        # Replace older spikes by new ones\n",
    "        return tf.scatter_nd_update(old_spikes_op, coord_op, new_spikes_op)\n",
    "\n",
    "    # Override parent get_input_op method\n",
    "    def get_input_op(self):\n",
    "        \n",
    "        # Update our memory of spike times with the new spikes\n",
    "        t_spikes_op = self.update_spike_times()\n",
    "\n",
    "        # Evaluate synaptic input current for each spike on each synapse\n",
    "        i_syn_op = tf.where(t_spikes_op >=0,\n",
    "                            self.q/self.tau_syn * tf.exp(tf.negative(t_spikes_op/self.tau_syn)),\n",
    "                            t_spikes_op*0.0)\n",
    "\n",
    "        # Add each synaptic current to the input current\n",
    "        i_op =  tf.reduce_sum(self.w * i_syn_op)\n",
    "        \n",
    "        return tf.add(self.i_app, i_op)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spike Response Model with Synaptic Inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LIFNeuron(object):\n",
    "\n",
    "    def __init__(self,\n",
    "                 n_syn, w, max_spikes=None, \n",
    "                 p_rest=0.0, tau_rest=1.0, tau_m=10.0, tau_s=2.5, T=None,\n",
    "                 K=2.1, K1=2.0, K2=4.0):\n",
    "\n",
    "        # Model parameters\n",
    "\n",
    "        # Membrane resting potential\n",
    "        self.p_rest = p_rest\n",
    "        \n",
    "        # Duration of the recovery period\n",
    "        self.tau_rest = tau_rest\n",
    "        \n",
    "        # Membrane time constant\n",
    "        self.tau_m = tau_m\n",
    "        \n",
    "        # Synaptic time constant\n",
    "        self.tau_s = tau_s\n",
    "        \n",
    "        # Spiking threshold\n",
    "        if T is None:\n",
    "            self.T = n_syn/4\n",
    "        else:\n",
    "            self.T = T\n",
    "        \n",
    "        # Model constants\n",
    "        self.K = K\n",
    "        self.K1 = K1\n",
    "        self.K2 = K2\n",
    "\n",
    "        # The number of synapses\n",
    "        self.n_syn = n_syn\n",
    "        \n",
    "        # The incoming spike times memory window\n",
    "        if max_spikes is None:\n",
    "            self.max_spikes = 70\n",
    "        else:\n",
    "            self.max_spikes = max_spikes\n",
    "\n",
    "        # Instantiate a specific tensorflow graph for the Neuron Model\n",
    "        self.graph = tf.Graph()\n",
    "        \n",
    "        ################################\n",
    "        # Build the neuron model graph #\n",
    "        ################################\n",
    "        with self.graph.as_default():\n",
    "\n",
    "            ##############################\n",
    "            # Variables and placeholders #\n",
    "            ##############################    \n",
    "            self.get_vars_and_ph(w)\n",
    "            \n",
    "            ##############\n",
    "            # Operations #\n",
    "            ##############\n",
    "            self.potential = self.get_potential_op()\n",
    "\n",
    "    ###############################################\n",
    "    # Define the graph Variables and placeholders #\n",
    "    ###############################################\n",
    "    def get_vars_and_ph(self, w):\n",
    "\n",
    "        # Placeholders (ie things that are passed to the graph as inputs)\n",
    "        \n",
    "        # A boolean tensor indicating which synapses have spiked during dt\n",
    "        self.new_spikes = tf.placeholder(shape=[self.n_syn], dtype=tf.bool, name='new_spikes')\n",
    "\n",
    "        # The time increment since the last update\n",
    "        self.dt = tf.placeholder(dtype=tf.float32, name='dt')\n",
    "        \n",
    "        # Variables (ie things that are modified by the graph at runtime)\n",
    "\n",
    "        # The neuron memory of incoming spike times\n",
    "        self.t_spikes = tf.Variable(tf.constant(100000.0, shape=[self.max_spikes, self.n_syn]), dtype=tf.float32)\n",
    "        \n",
    "        # The last spike time insertion index\n",
    "        self.t_spikes_idx = tf.Variable(self.n_syn - 1, dtype=tf.int32)\n",
    "\n",
    "        # The relative time since the last spike (assume it was a very long time ago)\n",
    "        self.last_spike = tf.Variable(1000.0, dtype=tf.float32, name='last_spike')\n",
    "        \n",
    "        # The membrane potential\n",
    "        self.p = tf.Variable(self.p_rest,dtype=tf.float32, name='p')\n",
    "        \n",
    "        # The duration remaining in the resting period (between 0 and self.tau_s)\n",
    "        self.t_rest = tf.Variable(0.0,dtype=tf.float32, name='t_rest')\n",
    "        \n",
    "        # The synapse efficacy weights\n",
    "        self.w = tf.Variable(w)\n",
    "\n",
    "    # Excitatory post-synaptic potential (EPSP)\n",
    "    def epsilon_op(self):\n",
    "\n",
    "        # We only use the negative value of the relative spike times\n",
    "        spikes_t_op = tf.negative(self.t_spikes)\n",
    "\n",
    "        return self.K *(tf.exp(spikes_t_op/self.tau_m) - tf.exp(spikes_t_op/self.tau_s))\n",
    "    \n",
    "    # Membrane spike response\n",
    "    def eta_op(self):\n",
    "        \n",
    "        # We only use the negative value of the relative time\n",
    "        t_op = tf.negative(self.last_spike)\n",
    "        \n",
    "        # Evaluate the spiking positive pulse\n",
    "        pos_pulse_op = self.K1 * tf.exp(t_op/self.tau_m)\n",
    "        \n",
    "        # Evaluate the negative spike after-potential\n",
    "        neg_after_op = self.K2 * (tf.exp(t_op/self.tau_m) - tf.exp(t_op/self.tau_s))\n",
    "\n",
    "        # Evaluate the new post synaptic membrane potential\n",
    "        return self.T * (pos_pulse_op - neg_after_op)\n",
    "    \n",
    "    # Neuron behaviour during integrating phase (t_rest = 0)\n",
    "    def w_epsilons_op(self):\n",
    "        \n",
    "        # Evaluate synaptic EPSPs. We ignore synaptic spikes older than the last neuron spike\n",
    "        epsilons_op = tf.where(tf.logical_and(self.t_spikes >=0, self.t_spikes < self.last_spike - self.tau_rest),\n",
    "                               self.epsilon_op(),\n",
    "                               self.t_spikes*0.0)\n",
    "                          \n",
    "        # Agregate weighted incoming EPSPs \n",
    "        return tf.reduce_sum(self.w * epsilons_op)\n",
    "\n",
    "    # Neuron behaviour during resting phase (t_rest > 0)\n",
    "    def post_firing_p_op(self):\n",
    "   \n",
    "        # Membrane potential is only impacted by the last post-synaptic spike (ignore EPSPs)\n",
    "        return self.eta_op()\n",
    "    \n",
    "    def update_spikes_times(self):\n",
    "        \n",
    "        # Increase the age of all the existing spikes by dt\n",
    "        old_spikes_op = self.t_spikes.assign_add(tf.ones(tf.shape(self.t_spikes), dtype=tf.float32) * self.dt)\n",
    "\n",
    "        # Increment last spike index (modulo max_spikes)\n",
    "        new_idx_op = self.t_spikes_idx.assign(tf.mod(self.t_spikes_idx + 1, self.max_spikes))\n",
    "\n",
    "        # Create a list of coordinates to insert the new spikes\n",
    "        idx_op = tf.constant(1, shape=[self.n_syn], dtype=tf.int32) * new_idx_op\n",
    "        coord_op = tf.stack([idx_op, tf.range(self.n_syn)], axis=1)\n",
    "\n",
    "        # Create a vector of new spike times (non-spikes are assigned a very high time)\n",
    "        new_spikes_op = tf.where(self.new_spikes,\n",
    "                                 tf.constant(0.0, shape=[self.n_syn]),\n",
    "                                 tf.constant(100000.0, shape=[self.n_syn]))\n",
    "        \n",
    "        # Replace older spikes by new ones\n",
    "        return tf.scatter_nd_update(old_spikes_op, coord_op, new_spikes_op)\n",
    "    \n",
    "    def resting_w_op(self):\n",
    "        \n",
    "        # For the base LIF Neuron, the weights remain constants when resting\n",
    "        return tf.identity(self.w)\n",
    "    \n",
    "    def default_w_op(self):\n",
    "        \n",
    "        # For the base LIF Neuron, the weights remain constants when integrating\n",
    "        return tf.identity(self.w)\n",
    "\n",
    "    def firing_w_op(self):\n",
    "\n",
    "        # For the base LIF Neuron, the weights remain constants when firing\n",
    "        return tf.identity(self.w)\n",
    "    \n",
    "    def resting_op(self):\n",
    "        \n",
    "        # Update weights\n",
    "        w_op = self.resting_w_op()\n",
    "        \n",
    "        # Update the resting period\n",
    "        t_rest_op = self.t_rest.assign(tf.maximum(self.t_rest - self.dt, 0.0))\n",
    "        \n",
    "        # During the resting period, the membrane potential is only given by the eta kernel\n",
    "        with tf.control_dependencies([w_op, t_rest_op]):\n",
    "            return self.eta_op()\n",
    "    \n",
    "    def firing_op(self):\n",
    "\n",
    "        # Update weights\n",
    "        w_op = self.firing_w_op()\n",
    "        \n",
    "        # Reset the time of the last spike, but only once the weights have been updated\n",
    "        with tf.control_dependencies([w_op]):\n",
    "            last_spike_op = self.last_spike.assign(0.0)\n",
    "\n",
    "        # Start the resting period\n",
    "        t_rest_op = self.t_rest.assign(self.tau_rest)\n",
    "        \n",
    "        # At spiking time, the membrane potential is only given by the eta kernel\n",
    "        with tf.control_dependencies([last_spike_op, t_rest_op]):\n",
    "            return self.eta_op()\n",
    "        \n",
    "    def default_op(self):\n",
    "        \n",
    "        # Update weights\n",
    "        w_op = self.default_w_op()\n",
    "        \n",
    "        # By default, the membrane potential is given by the sum of the eta kernel and the weighted epsilons\n",
    "        with tf.control_dependencies([w_op]):\n",
    "            return self.eta_op() + self.w_epsilons_op()\n",
    "        \n",
    "    def integrating_op(self):\n",
    "\n",
    "        # Evaluate the new membrane potential, integrating both synaptic input and spike dynamics\n",
    "        p_op = self.eta_op() + self.w_epsilons_op()\n",
    "\n",
    "        # We have a different behavior if we reached the threshold\n",
    "        return tf.cond(p_op > self.T,\n",
    "                       self.firing_op,\n",
    "                       self.default_op)\n",
    "    \n",
    "    def get_potential_op(self):\n",
    "        \n",
    "        # Update our internal memory of the synapse spikes (age older spikes, add new ones)\n",
    "        update_spikes_op = self.update_spikes_times()\n",
    "        \n",
    "        # Increase the relative time of the last spike by the time elapsed\n",
    "        last_spike_age_op = self.last_spike.assign_add(self.dt)\n",
    "        \n",
    "        # Update the internal state of the neuron and evaluate membrane potential\n",
    "        with tf.control_dependencies([update_spikes_op, last_spike_age_op]):\n",
    "            return tf.cond(self.t_rest > 0.0,\n",
    "                           self.resting_op,\n",
    "                           self.integrating_op)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SpikeTrains(object):\n",
    "    \n",
    "    def __init__(self, n_syn, r_min=0.0, r_max=90.0, r=None, s_max=1800, ds_max=360, s=None, auto_vrate=True, delta_max=0):\n",
    "        \n",
    "        # Number of synapses\n",
    "        self.n_syn = n_syn\n",
    "        # Minimum and maximum spiking rate (in Hz)\n",
    "        self.r_min = r_min\n",
    "        self.r_max = r_max\n",
    "        # Spiking rate for each synapse (in Hz)\n",
    "        if r is None:\n",
    "            self.r = np.random.uniform(self.r_min, self.r_max, size=(n_syn))\n",
    "        else:\n",
    "            self.r = r\n",
    "        # Rate variation parameters\n",
    "        self.s_max = s_max\n",
    "        self.ds_max = ds_max\n",
    "        # Rate variation\n",
    "        if s is None:\n",
    "            self.s = np.random.uniform(-self.s_max, self.s_max, size=(self.n_syn))\n",
    "        else:\n",
    "            self.s = s\n",
    "        # Automatically apply rate variation when\n",
    "        self.auto_vrate = auto_vrate\n",
    "        # Maximum time between two spikes on each synapse (0 means no maximum) in ms\n",
    "        self.delta_max = delta_max\n",
    "\n",
    "        # Memory of spikes\n",
    "        self.spikes = None\n",
    "    \n",
    "    # Generate new spikes for the specified time interval (in ms)\n",
    "    # The new spikes are added to the existing spike trains.\n",
    "    # The method returns only the new set of spikes\n",
    "    def add_spikes(self, t):\n",
    "        \n",
    "        for step in range(t):\n",
    "            # Draw a random number for each synapse\n",
    "            x = np.random.uniform(0,1, size=(self.n_syn))\n",
    "            # Each synapse spikes if the drawn number is lower than the probablity\n",
    "            # given by the integration of the rate over one millisecond\n",
    "            spikes = x < self.r * 1e-3\n",
    "            # Keep a memory of our spikes\n",
    "            if self.spikes is None:\n",
    "                self.spikes = np.array([spikes])\n",
    "            else:\n",
    "                if self.delta_max > 0:\n",
    "                    # We force each synapse to spike at least every delta_max ms\n",
    "                    if self.spikes.shape[0] < self.delta_max - 1:\n",
    "                        # At the beginning of the trains, we try to 'fill' as much holes\n",
    "                        # as possible to avoid a 'wall of spikes' when we reach delta_max.\n",
    "                        # For each synapse, count non-zero items\n",
    "                        n_spikes = np.count_nonzero(self.spikes, axis=0)\n",
    "                        # Draw a random number for each synapse \n",
    "                        r = np.random.uniform(0.0, 1.0, size=self.n_syn)\n",
    "                        # The closer we get to delta_max, the higher probability we have to force a spike\n",
    "                        forced_spikes = r < step * 1.0/self.delta_max\n",
    "                        # Modify our random vector of spikes for synapse that did not spike\n",
    "                        spikes = np.where(n_spikes > 0, spikes, spikes | forced_spikes)\n",
    "                    else:\n",
    "                        # Get the last delta_max -1 spike trains\n",
    "                        last_spikes = self.spikes[-(self.delta_max - 1):,:]\n",
    "                        # For each synapse, count non-zero items\n",
    "                        n_spikes = np.count_nonzero(last_spikes, axis=0)\n",
    "                        # Modify spikes to force a spike on synapses where the spike count is zero\n",
    "                        spikes = np.where(n_spikes > 0, spikes, True)\n",
    "                # Store spikes\n",
    "                self.spikes = np.append(self.spikes, [spikes], axis=0)\n",
    "            if self.auto_vrate:\n",
    "                self.change_rate()\n",
    "\n",
    "        return self.spikes[-t:,:]\n",
    "    \n",
    "    # Format a list of spike indexes\n",
    "    def get_spikes(self):\n",
    "        \n",
    "        real_spikes = np.argwhere(self.spikes > 0)\n",
    "        # We prefer having spikes in the range [1..n_syn]\n",
    "        spike_index = real_spikes[:,1] + 1\n",
    "        spike_timings = real_spikes[:,0]\n",
    "        \n",
    "        return spike_timings, spike_index\n",
    "    \n",
    "    # Change rate, applying the specified delta in Hz\n",
    "    def change_rate(self, delta=None):\n",
    "\n",
    "        # Update spiking rate\n",
    "        if delta is None:\n",
    "            delta = self.s\n",
    "        self.r = np.clip( self.r + delta, self.r_min, self.r_max)\n",
    "        # Update spiking rate variation\n",
    "        ds = np.random.uniform(-self.ds_max, self.ds_max, size=(self.n_syn))\n",
    "        self.s = np.clip( self.s + ds, -self.s_max, self.s_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing Iris Dataset and conversion to Spike Trains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iris data set to spike trains\n",
    "df = pd.read_csv('C:\\\\Users\\\\Anirudh Shankar\\\\Desktop\\\\Fall 2019\\\\Thesis\\\\Codes\\\\iris.csv',sep = ',')\n",
    "df = df.sample(frac=1).reset_index(drop=True)\n",
    "\n",
    "df['sepal.length'] = np.round(scale_values(df['sepal.length'],10,0))\n",
    "df['sepal.width'] = np.round(scale_values(df['sepal.length'],10,0))\n",
    "df['petal.length'] = np.round(scale_values(df['sepal.length'],10,0))\n",
    "df['petal.width'] = np.round(scale_values(df['sepal.length'],10,0))\n",
    "                              \n",
    "df_x = df[['sepal.length','sepal.width','petal.length','petal.width']]\n",
    "\n",
    "df['class'] = 0\n",
    "df['class'][df['variety']=='Setosa'] = 1\n",
    "df['class'][df['variety']=='Virginica'] = 3\n",
    "df['class'][df['variety']=='Versicolor'] = 2\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scaling Function\n",
    "def scale_values(feature,n,m):\n",
    "    l = ((feature-feature.min())/(feature.max()-feature.min()))*(n - m) + m\n",
    "    #l = np.round((n-l),2)\n",
    "    return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert this data to spike trains \n",
    "\n",
    "spike_trains_list = []\n",
    "for i in range(0,150):\n",
    "    s1 = np.random.randint(low=1,high=200,size=df.iloc[i][0].astype(int))\n",
    "    s2 = np.random.randint(low=1,high=200,size=df.iloc[i][1].astype(int))\n",
    "    s3 = np.random.randint(low=1,high=200,size=df.iloc[i][2].astype(int))\n",
    "    s4 = np.random.randint(low=1,high=200,size=df.iloc[i][3].astype(int))\n",
    "    \n",
    "    spike_train_1 = np.zeros(200,dtype = bool)\n",
    "    spike_train_2 = np.zeros(200,dtype = bool)\n",
    "    spike_train_3 = np.zeros(200,dtype = bool)\n",
    "    spike_train_4 = np.zeros(200,dtype = bool)\n",
    "    \n",
    "    spike_train_1[s1] = True\n",
    "    spike_train_2[s2] = True\n",
    "    spike_train_3[s3] = True\n",
    "    spike_train_4[s4] = True\n",
    "    \n",
    "    spike_trains = np.array([spike_train_1,spike_train_2,spike_train_3,spike_train_4])\n",
    "    spike_trains = np.reshape(spike_trains,(200,4))\n",
    "    spike_trains_list.append(spike_trains)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SNN Function which takes weights as input and produces Accuracy as output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 921,
   "metadata": {},
   "outputs": [],
   "source": [
    "def snn(weights):\n",
    "    T = 200\n",
    "    # Duration of each time step in ms\n",
    "    dt = 1.0\n",
    "    # Number of iterations = T/dt\n",
    "    steps = int(T / dt)\n",
    "    # Number of synapses\n",
    "    n_syn = 4\n",
    "    # Our random spike trains\n",
    "    spike_trains = SpikeTrains(n_syn)\n",
    "    # Generate spikes over the specified period\n",
    "    syn_has_spiked = spike_trains.add_spikes(T)\n",
    "    #Generate boolean spike trains corresponding to the above spike times\n",
    "    syn_has_spiked = spike_trains_list \n",
    "    count = 0\n",
    "    # We define the base synaptic efficacy as a uniform vector\n",
    "    # Output variables\n",
    "    np.random.seed(123)\n",
    "    W = weights\n",
    "\n",
    "    P = []\n",
    "    # Instantiate our LIF neuron\n",
    "    neuron = LIFNeuron(n_syn, W,T=0.1)\n",
    "    actual_spike_times_list = []\n",
    "\n",
    "    with tf.Session(graph=neuron.graph) as sess:\n",
    "\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "\n",
    "        for batch in range(0,30):\n",
    "\n",
    "            actual_spike_times = []\n",
    "\n",
    "            for step in range(steps):\n",
    "                t = step * dt\n",
    "                feed = { neuron.new_spikes: syn_has_spiked[batch][step], neuron.dt: dt}\n",
    "                p = sess.run(neuron.potential, feed_dict=feed)\n",
    "                P.append((t,p))\n",
    "                if(p>0.1):\n",
    "                    actual_spike_times.append(step) \n",
    "                    count = count + 1\n",
    "\n",
    "            actual_spike_times_list.append(count)\n",
    "            count = 0\n",
    "    tf.reset_default_graph()\n",
    "    return(actual_spike_times_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = 200\n",
    "# Duration of each time step in ms\n",
    "dt = 1.0\n",
    "# Number of iterations = T/dt\n",
    "steps = int(T / dt)\n",
    "# Number of synapses\n",
    "n_syn = 4\n",
    "# Our random spike trains\n",
    "spike_trains = SpikeTrains(n_syn)\n",
    "# Generate spikes over the specified period\n",
    "syn_has_spiked = spike_trains.add_spikes(T)\n",
    "#Generate boolean spike trains corresponding to the above spike times\n",
    "syn_has_spiked = spike_trains_list \n",
    "count = 0\n",
    "# We define the base synaptic efficacy as a uniform vector\n",
    "# Output variables\n",
    "np.random.seed(123)\n",
    "W = w2[np.argmax(fit_de)]\n",
    "P = []\n",
    "# Instantiate our LIF neuron\n",
    "neuron = LIFNeuron(n_syn, W,T=0.1)\n",
    "actual_spike_times_list = []\n",
    "\n",
    "with tf.Session(graph=neuron.graph) as sess:\n",
    "\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    for batch in range(3,4):\n",
    "\n",
    "        actual_spike_times = []\n",
    "\n",
    "        for step in range(steps):\n",
    "            t = step * dt\n",
    "            feed = { neuron.new_spikes: syn_has_spiked[batch][step], neuron.dt: dt}\n",
    "            p = sess.run(neuron.potential, feed_dict=feed)\n",
    "            P.append((t,p))\n",
    "            if(p>0.1):\n",
    "                actual_spike_times.append(step) \n",
    "                count = count + 1\n",
    "\n",
    "        actual_spike_times_list.append(count)\n",
    "        count = 0\n",
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting Output Spike Train of a training instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1074,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Graph of SNN \n",
    "plt.rcParams[\"figure.figsize\"] =(12,6)\n",
    "## Draw input spikes\n",
    "#plt.figure()\n",
    "#plt.axis([0, T, 0, spike_trains.n_syn])\n",
    "#plt.title('Synaptic spikes')\n",
    "#plt.ylabel('synapses')\n",
    "#plt.xlabel('Time (msec)')\n",
    "#t, spikes = spike_trains.get_spikes()\n",
    "#plt.scatter(t, spikes, s=2)\n",
    "# Draw membrane potential\n",
    "plt.figure()\n",
    "plt.plot(*zip(*P))\n",
    "plt.axhline(y=neuron.T, color='r', linestyle='-')\n",
    "plt.axhline(y=neuron.p_rest, color='y', linestyle='--')\n",
    "plt.title('LIF response for one training example of Iris Dataset (Setosa)')\n",
    "plt.ylabel('Membrane Potential')\n",
    "plt.xlabel('Simulation Time (ms)')\n",
    "plt.savefig('Project/Images/iris_snn_3.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evolutionary Algorithms for Training SNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm - 1 : Real Coded Genetic Algorithm "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fitness Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 928,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitness_function(desired_class,population):\n",
    "    err = []\n",
    "    s = []\n",
    "    spike_count_list = []\n",
    "    acc_list = []\n",
    "    acc = []\n",
    "    \n",
    "    for i in range(0,len(population)):\n",
    "        spike_count_list.append(snn(population[i]))\n",
    "        spike_count_list[i] = np.array(spike_count_list[i])\n",
    "        spike_count_list[i][((spike_count_list[i]>=0) & (spike_count_list[i]<=10))] = 1\n",
    "        spike_count_list[i][((spike_count_list[i]>10) & (spike_count_list[i]<=20))] = 2\n",
    "        spike_count_list[i][(spike_count_list[i]>20)] = 3\n",
    "    for i in range(0,len(spike_count_list)):\n",
    "        for j in range(0,len(spike_count_list[i])):\n",
    "            s.append(spike_count_list[i][j] - desired_class[j])\n",
    "        l = s.count(0)\n",
    "        err.append(l/len(desired_class)) \n",
    "        s = []\n",
    "        acc.append((err[i])*100)\n",
    "    return(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population = []\n",
    "start_time = time.time()\n",
    "for i in range(0,20):\n",
    "    s = np.float32(np.random.uniform(low=-1,high=1,size=4))\n",
    "    population.append(s)\n",
    "\n",
    "f = fitness_function(np.array(df['class'][0:30]),population)\n",
    "print((time.time()-start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def crossover(p1,p2):\n",
    "    h1 = 0.5*p1 + 0.5*p2\n",
    "    h2 = 1.5*p1 - 0.5*p2\n",
    "    h3 = 1.5*p2 - 0.5*p1\n",
    "    return(h1,h2,h3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 932,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutation(solution,max_solution,min_solution,current_gen,max_gen):\n",
    "    rand = np.random.uniform(0,1)\n",
    "    if(rand<=0.5):\n",
    "        tau = 1\n",
    "    else:\n",
    "        tau = -1\n",
    "    b = 1\n",
    "    d = math.pow((1 - (current_gen/max_gen)),b)\n",
    "    new_solution = solution + tau*(max_solution - min_solution)*(1-math.pow(rand,d))\n",
    "    return(new_solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 933,
   "metadata": {},
   "outputs": [],
   "source": [
    "def genetic_algorithm(population,desired_times,num_epochs):\n",
    "    \n",
    "    max_fitness_copy = []\n",
    "    mean_fitness_copy = []\n",
    "    \n",
    "    fitness = fitness_function(desired_times,population)\n",
    "    fitness_copy = fitness\n",
    "    \n",
    "    for epochs in range(0,num_epochs):\n",
    "    # Compute Fitness Value of entire population and store it in a list\n",
    "    \n",
    "        indexes = np.argsort(-np.array(fitness))\n",
    "        fitness = -np.sort(-np.array(fitness))\n",
    "\n",
    "        index = indexes[0:2]\n",
    "\n",
    "        # Compare fitness values of population and pick best 2 parents\n",
    "\n",
    "        parent_1 = population[index[0]]\n",
    "        parent_2 = population[index[1]]\n",
    "\n",
    "        # Do crossover to get 3 children \n",
    "\n",
    "        child_1,child_2,child_3 = crossover(parent_1,parent_2)\n",
    "        \n",
    "\n",
    "        # Decide whether to add them to population based on their fitness\n",
    "\n",
    "        children = []\n",
    "        children.extend([child_1,child_2,child_3])\n",
    "        \n",
    "        best_solution = population[indexes[0]]\n",
    "        worst_solution = population[indexes[len(indexes)-1]]\n",
    "        \n",
    "        for i in range(0,len(children)):\n",
    "            children[i] = mutation(children[i],best_solution,worst_solution,epochs+1,num_epochs)\n",
    "            children[i][children[i]>2] = 2\n",
    "            children[i][children[i]<-2] = -2\n",
    "            \n",
    "        population.append(child_1)\n",
    "        population.append(child_2)\n",
    "        population.append(child_3)\n",
    "        \n",
    "        fitness_copy.extend(fitness_function(desired_times,children))\n",
    "        \n",
    "        index = np.argsort(-np.array(fitness_copy))\n",
    "        fitness_copy = -np.sort(-np.array(fitness_copy))\n",
    "        \n",
    "        index_remove = index[len(index)-4:len(index)-1]\n",
    "        fitness_copy = [i for j, i in enumerate(fitness_copy) if j not in index_remove]\n",
    "        population = [i for j, i in enumerate(population) if j not in index_remove]\n",
    "\n",
    "        print(epochs+1)\n",
    "        max_fitness_copy.append(max(fitness_copy))\n",
    "        mean_fitness_copy.append(statistics.mean(fitness_copy))\n",
    "        \n",
    "        max_fitness_array = np.array(max_fitness_copy)\n",
    "        mean_fitness_array = np.array(mean_fitness_copy)\n",
    "        \n",
    "        population_array = np.array(population)\n",
    "        \n",
    "        np.save('max_fitness_array',max_fitness_array)\n",
    "        np.save('mean_fitness_array',mean_fitness_array)\n",
    "        np.save('population_array',population_array)\n",
    "        \n",
    "        fitness = fitness_function(desired_times,population)\n",
    "        \n",
    "    return(fitness,population,max_fitness_copy,mean_fitness_copy)\n",
    "    \n",
    "    # End GA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population = []\n",
    "for i in range(0,20):\n",
    "    s = np.float32(np.random.uniform(low=-1,high=1,size=4))\n",
    "    population.append(s)\n",
    "print(len(population))\n",
    "fit,weights,max_fit,mean_fit = genetic_algorithm(population,np.array(df['class'][0:30]),20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(fit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 937,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plots for Genetic Algorithm\n",
    "plt.rcParams[\"figure.figsize\"] =(10,6)\n",
    "plt.title('Convergence Plot of Real Coded Genetic Algorithm for training SNN')\n",
    "plt.ylabel('Accuracy(%)')\n",
    "plt.xlabel('Iterations')\n",
    "x1 = np.arange(20)\n",
    "y1 = max_fit\n",
    "plt.plot(x1,y1,'-bo',color='red',label='Max Population Fitness')\n",
    "plt.xlim(-1,21)\n",
    "x2 = np.arange(20)\n",
    "y2 = mean_fit\n",
    "plt.plot(x2,y2,'-bo',color='blue',label='Mean Population Fitness')\n",
    "plt.xticks(np.arange(0, 21, 2.0))\n",
    "plt.tick_params(axis='x',length=2, width=1)\n",
    "plt.legend(prop={'size': 12})\n",
    "plt.savefig('Project/Images/rgca_snn_1.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm - 2 : Differential Evolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 977,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diff_evol(desired_class,population,min_val,max_val,mut,crossp,num_epochs):\n",
    "    \n",
    "    fitness = fitness_function(desired_class,population)\n",
    "    fitness_copy_de = np.array(fitness)\n",
    "\n",
    "    mean_fitness = np.zeros(num_epochs)\n",
    "    max_fitness = np.zeros(num_epochs)\n",
    "    \n",
    "    for epochs in range(0,num_epochs):\n",
    "        \n",
    "        mean_fitness[epochs] = np.mean(fitness_copy_de)\n",
    "        max_fitness[epochs] = np.max(fitness_copy_de)\n",
    "        \n",
    "        print(mean_fitness[epochs])\n",
    "        print(max_fitness[epochs])\n",
    "        \n",
    "        np.save('max_fitness_array_de',max_fitness)\n",
    "        np.save('mean_fitness_array_de',mean_fitness)\n",
    "        np.save('population_array_de',population)\n",
    "        \n",
    "        for i in range(0,len(population)):\n",
    "            index = [index for index in range(len(population)) if index != i]\n",
    "            a,b,c = population[np.random.choice(index,3,replace=False)] #Remember to initialise population as an np array\n",
    "            \n",
    "            new_solution = np.clip(a + mut*(b-c),min_val,max_val)\n",
    "            cross_points = np.random.rand(len(population[i])) < crossp\n",
    "            if not np.any(cross_points): # Just ensuring recombination is happening\n",
    "                cross_points[np.random.randint(0, dimensions)] = True\n",
    "            \n",
    "            trial = np.where(cross_points, new_solution, population[i])\n",
    "            \n",
    "            fitness_trial = fitness_function(desired_class,[trial])\n",
    "            \n",
    "            if(fitness_trial > fitness_copy_de[i]):\n",
    "                fitness_copy_de[i] = np.copy(fitness_trial)\n",
    "                population[i] = np.copy(trial)\n",
    "                print(True)\n",
    "                \n",
    "        print(epochs+1) \n",
    "    return(fitness_copy_de,population,mean_fitness,max_fitness)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_time = time.time()\n",
    "population = []\n",
    "for i in range(0,20):\n",
    "    s = np.float32(np.random.uniform(low=-1,high=1,size=4))\n",
    "    population.append(s)\n",
    "f1 = fitness_function(np.array(df['class'][0:30]),population)\n",
    "population = np.array(population)\n",
    "print(f1)\n",
    "fit_de,weights_de,mean_de,max_de = diff_evol(np.array(df['class'][0:30]),population,-2,2,0.8,0.7,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(fit_de)\n",
    "max_de = np.load('max_fitness_array_de.npy')\n",
    "mean_de = np.load('mean_fitness_array_de.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 981,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plots for Differential Evolution\n",
    "plt.rcParams[\"figure.figsize\"] =(10,6)\n",
    "plt.title('Convergence Plot of Differential Evolution for training SNN')\n",
    "plt.ylabel('Accuracy(%)')\n",
    "plt.xlabel('Iterations')\n",
    "x1 = np.arange(20)\n",
    "y1 = max_de\n",
    "plt.plot(x1,y1,'-bo',color='red',label='Max Population Fitness')\n",
    "plt.xlim(-1,21)\n",
    "x2 = np.arange(20)\n",
    "y2 = mean_de\n",
    "plt.plot(x2,y2,'-bo',color='blue',label='Mean Population Fitness')\n",
    "plt.xticks(np.arange(0, 21, 2.0))\n",
    "plt.tick_params(axis='x',length=2, width=1)\n",
    "plt.legend(prop={'size': 12})\n",
    "plt.savefig('Project/Images/de_snn_1.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm - 3 :  Particle Swarm Optimization "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1067,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pso(desired_class,position,velocity,min_val,max_val,num_epochs):\n",
    "    \n",
    "    fitness = fitness_function(desired_class,list(position))\n",
    "    fitness_copy_pso = np.array(fitness)\n",
    "    \n",
    "    particle_best = position\n",
    "\n",
    "    c1 = 1\n",
    "    c2 = 1\n",
    "    r1 = np.random.uniform(0,1)\n",
    "    r2 = np.random.uniform(0,1)\n",
    "    w = 0.5\n",
    "    \n",
    "    mean_fitness = np.zeros(num_epochs)\n",
    "    max_fitness = np.zeros(num_epochs)\n",
    "        \n",
    "    for epochs in range(0,num_epochs):\n",
    "        \n",
    "        mean_fitness[epochs] = np.mean(fitness_copy_pso)\n",
    "        print(mean_fitness[epochs])\n",
    "        \n",
    "        np.save('max_fitness_array_pso',max_fitness)\n",
    "        np.save('mean_fitness_array_pso',mean_fitness)\n",
    "        np.save('population_array_pso',population)\n",
    "        \n",
    "        for i in range(0,len(fitness_copy_pso)): # Set best particle fitness value\n",
    "            fitness_pbest = fitness_function(desired_class,[particle_best[i]])\n",
    "            if(fitness_pbest<fitness_copy_pso[i]):\n",
    "                particle_best[i] = np.copy(position[i])\n",
    "        \n",
    "        index = np.argmax(fitness_copy_pso)\n",
    "        global_best = position[index]\n",
    "        max_fitness[epochs] = fitness_copy_pso[index]\n",
    "        print(max_fitness[epochs])\n",
    "        \n",
    "        for i in range(0,len(position)):\n",
    "            for j in range(0,len(position[i])):\n",
    "                velocity[i][j] = w*velocity[i][j] + c1*r1*(particle_best[i][j]-position[i][j])\n",
    "                +c2*r2*(global_best[j]-position[i][j])\n",
    "        \n",
    "            velocity[velocity<0] = 0\n",
    "            velocity[velocity>2] = 2\n",
    "        \n",
    "            position[i] = position[i] + velocity[i]\n",
    "    \n",
    "        position[position>2] = 2\n",
    "        position[position<-2] = -2\n",
    "        \n",
    "        fitness_copy_pso = np.array(fitness_function(desired_class,list(position)))\n",
    "        \n",
    "        print(epochs)\n",
    "        \n",
    "    return(position,fitness_copy_pso,mean_fitness,max_fitness)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "position = np.float32(np.random.uniform(-1,1,size = (10,4)))\n",
    "velocity = np.float32(np.random.uniform(0,1,size = (10,4)))\n",
    "\n",
    "print(len(position))\n",
    "p,f,mean_pso,max_pso = pso(np.array(df['class'][0:30]),position,velocity,-2,2,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 971,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plots for PSO\n",
    "plt.rcParams[\"figure.figsize\"] =(10,6)\n",
    "plt.title('Convergence Plot of PSO for training SNN')\n",
    "plt.ylabel('Accuracy(%)')\n",
    "plt.xlabel('Iterations')\n",
    "x1 = np.arange(20)\n",
    "y1 = mean_pso\n",
    "plt.plot(x1,y1,'-bo',color='blue',label='Mean Population Fitness')\n",
    "plt.xlim(-1,21)\n",
    "x2 = np.arange(20)\n",
    "y2 = max_pso\n",
    "plt.plot(x2,y2,'-bo',color='red',label='Max Population Fitness')\n",
    "plt.xticks(np.arange(0, 21, 2.0))\n",
    "plt.tick_params(axis='x',length=2, width=1)\n",
    "plt.legend(prop={'size': 12})\n",
    "plt.savefig('Project/Images/pso_snn_1.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ensemble using all 3 methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 983,
   "metadata": {},
   "outputs": [],
   "source": [
    "w1 = np.load('population_array.npy')\n",
    "w2 = np.load('population_array_de.npy')\n",
    "w3 = np.load('population_array_pso.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = snn(weights[np.argmax(fit)])\n",
    "s1 = np.array(s1)\n",
    "print(s)\n",
    "s1[((s1>=0) & (s1<=10))] = 1\n",
    "s1[((s1>10) & (s1<=20))] = 2\n",
    "s1[(s1>20)] = 3\n",
    "\n",
    "err = s1 - np.array(df['class'][0:30])\n",
    "print(err)\n",
    "print(len(err) - np.count_nonzero(err))\n",
    "\n",
    "s2 = snn(w2[np.argmax(fit_de)])\n",
    "s2 = np.array(s2)\n",
    "print(s)\n",
    "s2[((s2>=0) & (s2<=10))] = 1\n",
    "s2[((s2>10) & (s2<=20))] = 2\n",
    "s2[(s2>20)] = 3\n",
    "\n",
    "err = s2 - np.array(df['class'][0:30])\n",
    "print(err)\n",
    "print(len(err) - np.count_nonzero(err))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s3 = snn(p[5])\n",
    "s3 = np.array(s3)\n",
    "print(s)\n",
    "s3[((s3>=0) & (s3<=10))] = 1\n",
    "s3[((s3>10) & (s3<=20))] = 2\n",
    "s3[(s3>20)] = 3\n",
    "\n",
    "err = s3 - np.array(df['class'][0:30])\n",
    "print(err)\n",
    "len(err) - np.count_nonzero(err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Voting by averaging the weights\n",
    "w_avg = (weights[np.argmax(fit)]+ p[5])/2\n",
    "s = snn(w_avg)\n",
    "s = np.array(s)\n",
    "print(s)\n",
    "s[((s>=0) & (s<=10))] = 1\n",
    "s[((s>10) & (s<=20))] = 2\n",
    "s[(s>20)] = 3\n",
    "\n",
    "err = s - np.array(df['class'][0:30])\n",
    "print(err)\n",
    "len(err) - np.count_nonzero(err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1065,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 2 2 1 2 2 1 1 3 2 3 1 2 3 2 3 1 2 1 1 2 2 3 3 3 1 1 1 1 2]\n",
      " [3 2 3 1 2 2 1 1 3 2 3 1 2 3 2 3 1 2 1 1 2 2 3 3 3 1 1 1 2 2]]\n",
      "[[2 2 2 1 2 2 1 1 3 2 3 1 2 3 2 3 1 2 1 1 2 2 3 3 3 1 1 1 1 2]] Final Classification\n",
      "[[-1  0 -1  0 -1  0  0  0  0  0  1  0  0  0  0  0  0 -1  0 -1 -1  1  0  0\n",
      "   0 -1  0  0  0  0]]\n"
     ]
    }
   ],
   "source": [
    "# Majority Voting\n",
    "final_result = np.vstack([s1,s3])\n",
    "print(final_result)\n",
    "m = stats.mode(final_result)\n",
    "\n",
    "print(m[0],\"Final Classification\")\n",
    "\n",
    "err = m[0]- np.array(df['class'][0:30])\n",
    "print(err)"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}