SNN_Training-Visualisation-CSP_Currents-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3c0b54b4-64f2-4313-b4bc-10ca42558d6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "%pylab is deprecated, use %matplotlib inline and import the required libraries.\n",
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ef92803e-0e97-4c95-bf37-2408638a1701",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import snntorch as snn\n",
    "from snntorch import spikeplot as splt\n",
    "from snntorch import spikegen\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import scipy.io\n",
    "import scipy.signal \n",
    "\n",
    "from matplotlib import mlab\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4e436c7c-eee1-4ad8-b199-5791afda45b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def psd(trials):\n",
    "    \n",
    "    ntrials = trials.shape[2]\n",
    "    trials_PSD = np.zeros((nchannels, 101, ntrials))\n",
    "\n",
    "    # Iterate over trials and channels\n",
    "    for trial in range(ntrials):\n",
    "        for ch in range(nchannels):\n",
    "            # Calculate the PSD\n",
    "            (PSD, freqs) = mlab.psd(trials[ch,:,trial], NFFT=int(nsamples), Fs=sample_rate)\n",
    "            trials_PSD[ch, :, trial] = PSD.ravel()\n",
    "                \n",
    "    return trials_PSD, freqs\n",
    "\n",
    "\n",
    "def plot_psd(trials_PSD, freqs, chan_ind, chan_lab=None, maxy=None):\n",
    "    plt.figure(figsize=(12,5))\n",
    "    \n",
    "    nchans = len(chan_ind)\n",
    "    \n",
    "    # Maximum of 3 plots per row\n",
    "    nrows = int(np.ceil(nchans / 3))\n",
    "    ncols = min(3, nchans)\n",
    "    \n",
    "    # Enumerate over the channels\n",
    "    for i,ch in enumerate(chan_ind):\n",
    "        # Figure out which subplot to draw to\n",
    "        plt.subplot(nrows,ncols,i+1)\n",
    "    \n",
    "        # Plot the PSD for each class\n",
    "        for cl in trials.keys():\n",
    "            plt.plot(freqs, np.mean(trials_PSD[cl][ch,:,:], axis=1), label=cl)\n",
    "    \n",
    "        # All plot decoration below...\n",
    "        \n",
    "        plt.xlim(1,30)\n",
    "        \n",
    "        if maxy != None:\n",
    "            plt.ylim(0,maxy)\n",
    "    \n",
    "        plt.grid()\n",
    "    \n",
    "        plt.xlabel('Frequency (Hz)')\n",
    "        \n",
    "        if chan_lab == None:\n",
    "            plt.title('Channel %d' % (ch+1))\n",
    "        else:\n",
    "            plt.title(chan_lab[i])\n",
    "\n",
    "        plt.legend()\n",
    "        \n",
    "    plt.tight_layout()\n",
    "\n",
    "def bandpass(trials, lo, hi, sample_rate):\n",
    " \n",
    "    a, b = scipy.signal.iirfilter(6, [lo/(sample_rate/2.0), hi/(sample_rate/2.0)])\n",
    "\n",
    "    ntrials = trials.shape[2]\n",
    "    trials_filt = np.zeros((nchannels, nsamples, ntrials))\n",
    "    for i in range(ntrials):\n",
    "        trials_filt[:,:,i] = scipy.signal.filtfilt(a, b, trials[:,:,i], axis=1)\n",
    "    \n",
    "    return trials_filt\n",
    "\n",
    "def logvar(trials):\n",
    "    return np.var(trials, axis=1)\n",
    "\n",
    "def plot_logvar(trials, trial_no = None):\n",
    "    plt.figure(figsize=(12,5))\n",
    "\n",
    "    print(trials[cl1].shape)\n",
    "    \n",
    "    x0 = np.arange(nchannels)\n",
    "    x1 = np.arange(nchannels) + 0.4\n",
    "\n",
    "    if trial_no == None:\n",
    "        y0 = np.mean(trials[cl1], axis=1)\n",
    "        y1 = np.mean(trials[cl2], axis=1)\n",
    "    else:\n",
    "        y0 = trials[cl1][:,trial_no]\n",
    "        y1 = trials[cl2][:,trial_no]\n",
    "\n",
    "    plt.bar(x0, y0, width=0.5, color='b')\n",
    "    plt.bar(x1, y1, width=0.4, color='r')\n",
    "\n",
    "    plt.xlim(-0.5, nchannels+0.5)\n",
    "\n",
    "    plt.gca().yaxis.grid(True)\n",
    "    plt.title('log-var of each channel/component')\n",
    "    plt.xlabel('channels/components')\n",
    "    plt.ylabel('log-var')\n",
    "    plt.legend(cl_lab)\n",
    "\n",
    "from numpy import linalg\n",
    "\n",
    "def cov(trials):\n",
    "    ntrials = trials.shape[2]\n",
    "    covs = [ trials[:,:,i].dot(trials[:,:,i].T) / nsamples for i in range(ntrials) ]\n",
    "    return np.mean(covs, axis=0)\n",
    "\n",
    "def whitening(sigma):\n",
    "    U, l, _ = linalg.svd(sigma)\n",
    "    return U.dot( np.diag(l ** -0.5) )\n",
    "\n",
    "def csp(trials_r, trials_f):\n",
    "    cov_r = cov(trials_r)\n",
    "    cov_f = cov(trials_f)\n",
    "    P = whitening(cov_r + cov_f)\n",
    "    B, _, _ = linalg.svd( P.T.dot(cov_f).dot(P) )\n",
    "    W = P.dot(B)\n",
    "    return W\n",
    "\n",
    "def apply_mix(W, trials):\n",
    "    ntrials = trials.shape[2]\n",
    "    trials_csp = np.zeros((nchannels, nsamples, ntrials))\n",
    "    for i in range(ntrials):\n",
    "        trials_csp[:,:,i] = W.T.dot(trials[:,:,i])\n",
    "    return trials_csp\n",
    "\n",
    "import torch\n",
    "import snntorch.spikeplot as splt\n",
    "from snntorch import spikegen\n",
    "\n",
    "def spike_latency(trials, trial_n, cls, num_steps):\n",
    "    input_data = trials[cl1] if cls == 1 else trials[cl2]\n",
    "    \n",
    "    tensor = torch.tensor(input_data[:,trial_n])\n",
    "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "    tensor = tensor.to(device)\n",
    "    \n",
    "    spike_data = spikegen.latency(tensor, num_steps=num_steps, threshold=(np.mean(input_data[:,trial_n])+1)*1/2, bypass=True)\n",
    "\n",
    "    return spike_data\n",
    "\n",
    "def spike_rate(trials, trial_n, cls, num_steps):\n",
    "    input_data = trials[cl1] if cls == 1 else trials[cl2]\n",
    "    \n",
    "    tensor = torch.tensor(input_data[:,trial_n])\n",
    "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "    tensor = tensor.to(device)\n",
    "    \n",
    "    spike_data = spikegen.rate(tensor, num_steps=num_steps)\n",
    "\n",
    "    return spike_data\n",
    "\n",
    "def plot_raster(spike_data):\n",
    "    \n",
    "    fig = plt.figure(facecolor=\"w\", figsize=(10, 5))\n",
    "    ax = fig.add_subplot(111)\n",
    "    \n",
    "    spike_data_sample = spike_data\n",
    "    splt.raster(spike_data_sample, ax, s=1.5, c=\"black\")\n",
    "    plt.ylim(0, 60)\n",
    "    \n",
    "    plt.title(\"Input Layer\")\n",
    "    plt.xlabel(\"Time step\")\n",
    "    plt.ylabel(\"Neuron Number\")\n",
    "    plt.show()\n",
    "\n",
    "def plot_snn_spikes(spk_in, spk1_rec, spk2_rec, num_steps, title):\n",
    "  # Generate Plots\n",
    "  fig, ax = plt.subplots(3, figsize=(8,7), sharex=True, \n",
    "                        gridspec_kw = {'height_ratios': [1, 1, 0.4]})\n",
    "\n",
    "  # Plot input spikes\n",
    "  splt.raster(spk_in[:,0], ax[0], s=0.1, c=\"black\")\n",
    "  ax[0].set_ylabel(\"Input Spikes\")\n",
    "  ax[0].set_title(title)\n",
    "\n",
    "  # Plot hidden layer spikes\n",
    "  splt.raster(spk1_rec.reshape(num_steps, -1), ax[1], s = 0.1, c=\"black\")\n",
    "  ax[1].set_ylabel(\"Hidden Layer\")\n",
    "\n",
    "  # Plot output spikes\n",
    "  splt.raster(spk2_rec.reshape(num_steps, -1), ax[2], c=\"black\", marker=\"|\")\n",
    "  ax[2].set_ylabel(\"Output Spikes\")\n",
    "  ax[2].set_ylim([0, 10])\n",
    "\n",
    "  plt.show()\n",
    "\n",
    "def plot_snn_spikes(spk_in, spk1_rec, spk2_rec, num_steps, title):\n",
    "  # Generate Plots\n",
    "  fig, ax = plt.subplots(3, figsize=(8,7), sharex=True, \n",
    "                        gridspec_kw = {'height_ratios': [1, 1, 0.4]})\n",
    "\n",
    "  # Plot input spikes\n",
    "  splt.raster(spk_in[:,0], ax[0], s=0.1, c=\"black\")\n",
    "  ax[0].set_ylabel(\"Input Spikes\")\n",
    "  ax[0].set_title(title)\n",
    "\n",
    "  # Plot hidden layer spikes\n",
    "  splt.raster(spk1_rec.reshape(num_steps, -1), ax[1], s = 0.1, c=\"black\")\n",
    "  ax[1].set_ylabel(\"Hidden Layer\")\n",
    "\n",
    "  # Plot output spikes\n",
    "  splt.raster(spk2_rec.reshape(num_steps, -1), ax[2], c=\"black\", marker=\"|\")\n",
    "  ax[2].set_ylabel(\"Output Spikes\")\n",
    "  ax[2].set_yticks([0, 1], ['left', 'right'])\n",
    "  ax[2].set_ylim([-0.5, 1.5])\n",
    "\n",
    "\n",
    "  plt.show()\n",
    "\n",
    "def plot_snn_spikes_modified(spk_in, spk1_rec, spk2_rec, num_steps, title):\n",
    "  # Generate Plots\n",
    "  fig, ax = plt.subplots(3, figsize=(8,7), sharex=False, \n",
    "                        gridspec_kw = {'height_ratios': [1, 1, 0.4]})\n",
    "\n",
    "  # Plot input spikes\n",
    "\n",
    "  neuron_numbers = list(range(59))\n",
    "  currents = spk_in.tolist()  # Currents fed to each neuron\n",
    "    \n",
    "  # Create bar chart\n",
    "  ax[0].bar(neuron_numbers, currents, color='skyblue')\n",
    "  ax[0].set_ylabel(\"Input Currents\")\n",
    "  ax[0].set_title(title)\n",
    "\n",
    "  # Plot hidden layer spikes\n",
    "  splt.raster(spk1_rec.reshape(num_steps, -1), ax[1], s = 0.1, c=\"black\")\n",
    "  ax[1].set_ylabel(\"Hidden Layer\")\n",
    "\n",
    "  # Plot output spikes\n",
    "  splt.raster(spk2_rec.reshape(num_steps, -1), ax[2], c=\"black\", marker=\"|\")\n",
    "  ax[2].set_ylabel(\"Output Spikes\")\n",
    "  ax[2].set_yticks([0, 1], ['left', 'right'])\n",
    "  ax[2].set_ylim([-0.5, 1.5])\n",
    "\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0f9d2b61-e4b2-441b-830d-bf478b3c9d23",
   "metadata": {},
   "outputs": [],
   "source": [
    "m = scipy.io.loadmat('BCICIV_1_mat\\BCICIV_calib_ds1d.mat', struct_as_record=True)\n",
    "\n",
    "sample_rate = m['nfo']['fs'][0][0][0][0]\n",
    "EEG = m['cnt'].T\n",
    "nchannels, nsamples = EEG.shape\n",
    "\n",
    "channel_names = [s[0] for s in m['nfo']['clab'][0][0][0]]\n",
    "event_onsets = m['mrk'][0][0][0]\n",
    "event_codes = m['mrk'][0][0][1]\n",
    "labels = np.zeros((1, nsamples), int)\n",
    "labels[0, event_onsets] = event_codes\n",
    "\n",
    "cl_lab = [s[0] for s in m['nfo']['classes'][0][0][0]]\n",
    "cl1 = cl_lab[0]\n",
    "cl2 = cl_lab[1]\n",
    "nclasses = len(cl_lab)\n",
    "nevents = len(event_onsets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a4b8e6b1-c762-49b1-a3c1-2834cde6d88b",
   "metadata": {},
   "outputs": [],
   "source": [
    "trials = {}\n",
    "\n",
    "win = np.arange(int(0.5*sample_rate), int(2.5*sample_rate))\n",
    "\n",
    "nsamples = len(win)\n",
    "\n",
    "for cl, code in zip(cl_lab, np.unique(event_codes)):\n",
    "    \n",
    "    cl_onsets = event_onsets[event_codes == code]\n",
    "\n",
    "    trials[cl] = np.zeros((nchannels, nsamples, len(cl_onsets)))\n",
    "    \n",
    "    for i, onset in enumerate(cl_onsets):\n",
    "        trials[cl][:,:,i] = EEG[:, win+onset]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "02cab55d-2ee6-4ea2-b173-78322d7b334c",
   "metadata": {},
   "outputs": [],
   "source": [
    "trials_filt = {cl1: bandpass(trials[cl1], 2, 30, sample_rate),\n",
    "               cl2: bandpass(trials[cl2], 2, 30, sample_rate)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "886326e2-8579-4eb8-ac3b-66b19466e54b",
   "metadata": {},
   "outputs": [],
   "source": [
    "W = csp(trials_filt[cl1], trials_filt[cl2])\n",
    "trials_csp = {cl1: apply_mix(W, trials_filt[cl1]),\n",
    "              cl2: apply_mix(W, trials_filt[cl2])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1eddca94-1501-4c61-9109-f65f9705ff21",
   "metadata": {},
   "outputs": [],
   "source": [
    "trials_logvar = {cl1: logvar(trials_csp[cl1]),\n",
    "                 cl2: logvar(trials_csp[cl2])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6c51458d-aa0f-4ac3-b3b8-ba3cfb439822",
   "metadata": {},
   "outputs": [],
   "source": [
    "normalized_within_trial = {cl1: ((trials_logvar[cl1]-np.min(trials_logvar[cl1],axis=0))/(np.max(trials_logvar[cl1],axis=0)-np.min(trials_logvar[cl1],axis=0))),\n",
    "                 cl2: ((trials_logvar[cl2]-np.min(trials_logvar[cl2],axis=0))/(np.max(trials_logvar[cl2],axis=0)-np.min(trials_logvar[cl2],axis=0)))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "7084c644-e665-4a10-8844-28f80b9e62e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "max_value = np.max(trials_logvar[cl1]) or np.max(trials_logvar[cl2])\n",
    "min_value = np.min(trials_logvar[cl1]) or np.min(trials_logvar[cl2])\n",
    "\n",
    "\n",
    "normalized_trials_logvar = {cl1: ((trials_logvar[cl1]-min_value)/(max_value-min_value)),\n",
    "                 cl2: ((trials_logvar[cl2]-min_value)/(max_value-min_value))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "533f8a99-a0c9-43a2-a338-dca47d0c6e27",
   "metadata": {},
   "outputs": [],
   "source": [
    "dtype = torch.float\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "24797234-e175-42b5-99e8-c09d4fe08257",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "\n",
    "    def __len__(self):\n",
    "        if len(self.data.shape) > 1:\n",
    "            return self.data.shape[1]\n",
    "        else:\n",
    "            return 1\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        sample = self.data[1:,idx]\n",
    "        label = self.data[0,idx]\n",
    "        return torch.tensor(sample, dtype=torch.float32), torch.tensor(label, dtype=torch.long)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "475f6d0f-346c-4e1d-adfb-702767c659d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 59]) torch.Size([32])\n",
      "torch.Size([32, 59]) torch.Size([32])\n",
      "torch.Size([32, 59]) torch.Size([32])\n",
      "torch.Size([32, 59]) torch.Size([32])\n",
      "torch.Size([32, 59]) torch.Size([32])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_22108\\1880285545.py:18: DeprecationWarning: an integer is required (got type numpy.float64).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.\n",
      "  return torch.tensor(sample, dtype=torch.float32), torch.tensor(label, dtype=torch.long)\n"
     ]
    }
   ],
   "source": [
    "data = normalized_within_trial\n",
    "\n",
    "# Additional column for class identifiers\n",
    "class_column_left = np.zeros((1, 100))  # Assuming all instances belong to class 0\n",
    "class_column_right = np.ones((1, 100))  # Assuming all instances belong to class 0\n",
    "\n",
    "# Concatenate class column along with left and right arrays\n",
    "left_with_class = np.concatenate([class_column_left, data['left']], axis=0)\n",
    "right_with_class = np.concatenate([class_column_right, data['right']], axis=0)\n",
    "\n",
    "# Concatenate left and right arrays along axis 1\n",
    "result = np.concatenate([left_with_class, right_with_class], axis=1)\n",
    "\n",
    "cl1_split_idx = int(result.shape[1]*0.5*0.8)\n",
    "cl2_split_idx = int(result.shape[1]*0.5*1.8)\n",
    "\n",
    "train_data = np.concatenate([result[:, :cl1_split_idx],result[:, 100:cl2_split_idx]], axis=1)\n",
    "test_data = np.concatenate([result[:, cl1_split_idx:100],result[:, cl2_split_idx:]], axis=1)\n",
    "\n",
    "# Create CustomDataset instance\n",
    "train_dataset = CustomDataset(train_data)\n",
    "test_dataset = CustomDataset(test_data)\n",
    "\n",
    "# Create DataLoader\n",
    "batch_size = 32\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "for samples, labels in train_loader:\n",
    "    # Your training code here\n",
    "    print(samples.shape, labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "9f536ff7-1823-415f-b667-6a105c9a92cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60, 40)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "83aa766e-32c4-4758-aff4-43f1d056ac83",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_inputs = 59\n",
    "num_hidden = 1000\n",
    "num_outputs = 2\n",
    "beta = 0.99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "029343f6-1daa-4052-831f-e38b989eca38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Network\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        # Initialize layers\n",
    "        self.fc1 = nn.Linear(num_inputs, num_hidden)\n",
    "        self.lif1 = snn.Leaky(beta=beta)\n",
    "        self.fc2 = nn.Linear(num_hidden, num_outputs)\n",
    "        self.lif2 = snn.Leaky(beta=beta)\n",
    "\n",
    "        self.spkIn = []\n",
    "        self.spk1 = []\n",
    "        self.spk2 = []\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        # Initialize hidden states at t=0\n",
    "        mem1 = self.lif1.init_leaky()\n",
    "        mem2 = self.lif2.init_leaky()\n",
    "\n",
    "        self.spkIn = []\n",
    "        self.spk1 = []\n",
    "        self.spk2 = []\n",
    "        \n",
    "        # Record the final layer\n",
    "        spk2_rec = []\n",
    "        mem2_rec = []\n",
    "\n",
    "        for step in range(num_steps):\n",
    "            cur1 = self.fc1(x)\n",
    "            spk1, mem1 = self.lif1(cur1, mem1)\n",
    "            cur2 = self.fc2(spk1)\n",
    "            spk2, mem2 = self.lif2(cur2, mem2)\n",
    "\n",
    "            self.spkIn.append(x)\n",
    "            self.spk1.append(spk1)\n",
    "            self.spk2.append(spk2)\n",
    "            \n",
    "            spk2_rec.append(spk2)\n",
    "            mem2_rec.append(mem2)\n",
    "\n",
    "        return torch.stack(spk2_rec, dim=0), torch.stack(mem2_rec, dim=0)\n",
    "        \n",
    "# Load the network onto CUDA if available\n",
    "net = Net().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "8347af1b-181d-48d2-b2b5-252647129568",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_22108\\1880285545.py:18: DeprecationWarning: an integer is required (got type numpy.float64).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.\n",
      "  return torch.tensor(sample, dtype=torch.float32), torch.tensor(label, dtype=torch.long)\n"
     ]
    }
   ],
   "source": [
    "for samples, labels in train_loader:\n",
    "    # Your training code here\n",
    "    net.forward(samples[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "4e0f2158-9ae7-4c1a-bfaf-db14c9fac710",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_batch_accuracy(data, targets, train=False):\n",
    "    output, _ = net(data.view(batch_size, -1))\n",
    "    _, idx = output.sum(dim=0).max(1)\n",
    "    acc = np.mean((targets == idx).detach().cpu().numpy())\n",
    "\n",
    "    if train:\n",
    "        print(f\"Train set accuracy for a single minibatch: {acc*100:.2f}%\")\n",
    "    else:\n",
    "        print(f\"Test set accuracy for a single minibatch: {acc*100:.2f}%\")\n",
    "\n",
    "def train_printer(\n",
    "    data, targets, epoch,\n",
    "    counter, iter_counter,\n",
    "        loss_hist, test_loss_hist, test_data, test_targets):\n",
    "    print(f\"Epoch {epoch}, Iteration {iter_counter}\")\n",
    "    print(f\"Train Set Loss: {loss_hist[counter]:.2f}\")\n",
    "    print(f\"Test Set Loss: {test_loss_hist[counter]:.2f}\")\n",
    "    print_batch_accuracy(data, targets, train=True)\n",
    "    print_batch_accuracy(test_data, test_targets, train=False)\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "c58a6092-5d1f-4e70-8e99-360890edfd2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=5e-4, betas=(0.9, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "609113bc-321b-40fd-b3a2-dc4b6547e5db",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_22108\\1880285545.py:18: DeprecationWarning: an integer is required (got type numpy.float64).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.\n",
      "  return torch.tensor(sample, dtype=torch.float32), torch.tensor(label, dtype=torch.long)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n",
      "torch.Size([25, 32, 2]) torch.Size([25, 32, 2])\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 20\n",
    "loss_hist = []\n",
    "test_loss_hist = []\n",
    "counter = 0\n",
    "num_steps = 25\n",
    "\n",
    "# Outer training loop\n",
    "for epoch in range(num_epochs):\n",
    "    iter_counter = 0\n",
    "    train_batch = iter(train_loader)\n",
    "\n",
    "    # Minibatch training loop\n",
    "    for data, targets in train_batch:\n",
    "        data = data.to(device)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        # forward pass\n",
    "        net.train()\n",
    "        spk_rec, mem_rec = net(data.view(batch_size, -1))\n",
    "\n",
    "        print(spk_rec.shape, mem_rec.shape)\n",
    "\n",
    "        break\n",
    "\n",
    "        # initialize the loss & sum over time\n",
    "        loss_val = torch.zeros((1), dtype=dtype, device=device)\n",
    "        for step in range(num_steps):\n",
    "            loss_val += loss(mem_rec[step], targets)\n",
    "\n",
    "        # Gradient calculation + weight update\n",
    "        optimizer.zero_grad()\n",
    "        loss_val.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # Store loss history for future plotting\n",
    "        loss_hist.append(loss_val.item())\n",
    "\n",
    "        # Test set\n",
    "        with torch.no_grad():\n",
    "            net.eval()\n",
    "            test_data, test_targets = next(iter(test_loader))\n",
    "            test_data = test_data.to(device)\n",
    "            test_targets = test_targets.to(device)\n",
    "\n",
    "            # Test set forward pass\n",
    "            test_spk, test_mem = net(test_data.view(batch_size, -1))\n",
    "\n",
    "            # Test set loss\n",
    "            test_loss = torch.zeros((1), dtype=dtype, device=device)\n",
    "            for step in range(num_steps):\n",
    "                test_loss += loss(test_mem[step], test_targets)\n",
    "            test_loss_hist.append(test_loss.item())\n",
    "\n",
    "            # Print train/test loss/accuracy\n",
    "            if counter % 1 == 0:\n",
    "                train_printer(\n",
    "                    data, targets, epoch,\n",
    "                    counter, iter_counter,\n",
    "                    loss_hist, test_loss_hist,\n",
    "                    test_data, test_targets)\n",
    "            counter += 1\n",
    "            iter_counter +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "8548ce3d-0a0e-4983-b71f-a8200246ba69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot Loss\n",
    "fig = plt.figure(facecolor=\"w\", figsize=(10, 5))\n",
    "plt.plot(loss_hist)\n",
    "plt.plot(test_loss_hist)\n",
    "plt.title(\"Loss Curves\")\n",
    "plt.legend([\"Train Loss\", \"Test Loss\"])\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "0c8afd20-9f56-43a6-b61f-0802262e8ccd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "tensor(0)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_22108\\1880285545.py:18: DeprecationWarning: an integer is required (got type numpy.float64).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.\n",
      "  return torch.tensor(sample, dtype=torch.float32), torch.tensor(label, dtype=torch.long)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "tensor(1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for samples, labels in test_loader:\n",
    "    \n",
    "\n",
    "    output = net(samples[3])\n",
    "    print()\n",
    "    print(labels[3])\n",
    "\n",
    "    tensor_output = output[0]  # Extract the tensor from the tuple\n",
    "    numpy_array = tensor_output.detach().numpy()  # Convert tensor to numpy array\n",
    "    plt.plot(numpy_array)\n",
    "    # Plot the numpy array\n",
    "    plt.plot(numpy_array)\n",
    "    plt.xlabel('Index')\n",
    "    plt.ylabel('Value')\n",
    "    plt.title('Plot of Tensor')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "66b87aff-3e4c-4241-8eb1-dbcaf2f03962",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "print(len(numpy_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "f5bc460a-b770-495a-8387-879de96b2b0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter containing:\n",
      "tensor([[-0.0788, -0.0448, -0.1006,  ...,  0.1146,  0.0033, -0.0583],\n",
      "        [ 0.0099,  0.0005,  0.0447,  ...,  0.1299, -0.0444,  0.0911],\n",
      "        [ 0.1193,  0.0855,  0.0415,  ..., -0.0176,  0.0375,  0.0705],\n",
      "        ...,\n",
      "        [ 0.0024, -0.0694,  0.0571,  ..., -0.0860,  0.0681,  0.1259],\n",
      "        [ 0.1107,  0.0065, -0.0762,  ...,  0.0568,  0.0894, -0.0154],\n",
      "        [ 0.1213, -0.0287,  0.1280,  ...,  0.0409,  0.0424, -0.0201]],\n",
      "       requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([-8.2091e-02,  5.6683e-02, -4.5422e-02, -2.7839e-02, -8.9843e-02,\n",
      "        -4.5010e-02, -6.6885e-02,  8.9181e-03, -2.5016e-02, -9.0458e-02,\n",
      "         6.3491e-02,  6.0940e-03, -7.6700e-02,  5.1936e-02, -5.8269e-02,\n",
      "         8.5204e-02, -5.4352e-02, -4.0654e-02, -6.0252e-02, -1.1195e-01,\n",
      "        -6.4797e-02,  8.7620e-02,  6.2277e-02,  1.8012e-02,  9.7836e-02,\n",
      "         3.3919e-02,  3.3760e-02,  5.3643e-04, -1.2451e-01, -7.4864e-02,\n",
      "        -5.5901e-02,  5.0129e-02,  1.0402e-01,  2.4328e-03, -6.3495e-02,\n",
      "         5.6371e-02,  1.1485e-01, -1.5463e-02,  7.7260e-02, -5.0563e-02,\n",
      "        -1.1886e-01,  5.0578e-02, -8.1997e-02, -3.9707e-02,  6.3643e-02,\n",
      "        -9.1742e-02,  7.7116e-02, -3.6646e-02,  8.9614e-02,  1.0682e-01,\n",
      "        -3.7794e-02,  2.8614e-02,  1.7893e-02, -7.4903e-02, -2.3586e-02,\n",
      "        -4.2214e-02, -8.9402e-02,  5.0127e-02, -3.2466e-02,  1.2285e-01,\n",
      "         1.2488e-01,  1.0633e-01,  4.5426e-02,  9.1926e-03,  1.1523e-02,\n",
      "        -5.3526e-02,  4.0209e-02, -4.6900e-02,  1.1939e-01,  1.3134e-01,\n",
      "        -3.9008e-02, -1.1315e-01, -2.5186e-02,  1.0007e-02,  1.1821e-01,\n",
      "         2.7035e-02, -2.2272e-02, -1.1557e-02, -2.2120e-02,  1.2755e-02,\n",
      "         9.1169e-02, -1.1311e-01,  2.8001e-02, -6.3609e-02, -1.2149e-01,\n",
      "         1.0179e-01, -1.2967e-01,  4.7803e-02,  2.8451e-02,  8.9278e-02,\n",
      "         5.4152e-02, -6.5278e-02,  1.0900e-01, -6.9327e-03,  9.5097e-03,\n",
      "         1.2702e-01,  1.1844e-01, -3.8136e-03,  3.5360e-02, -1.0562e-01,\n",
      "        -5.2595e-02,  1.2757e-01,  2.4003e-02, -6.3497e-02,  1.2258e-01,\n",
      "        -5.3289e-02, -1.8091e-02,  1.0045e-01,  2.8966e-02, -7.8627e-02,\n",
      "        -1.1313e-01,  6.2487e-03,  4.9594e-02, -6.3012e-02,  9.8431e-02,\n",
      "         8.8494e-02, -8.1814e-02, -9.2939e-02,  1.0893e-01, -7.6234e-02,\n",
      "        -1.2146e-01,  8.6572e-02, -1.1794e-01, -1.1569e-01,  8.0325e-02,\n",
      "         2.8995e-02,  9.1223e-02, -5.5114e-02,  3.2133e-02,  9.2468e-02,\n",
      "        -9.3707e-02,  2.3707e-02,  1.2750e-01, -1.7538e-02,  3.6927e-02,\n",
      "         6.8369e-03,  6.9990e-02, -4.3949e-02,  3.6719e-03,  1.0235e-01,\n",
      "         3.2182e-03,  1.0476e-01, -1.1606e-02,  9.2827e-03, -9.8082e-02,\n",
      "         8.0263e-02, -9.1823e-03,  3.1894e-02, -8.8445e-02,  5.0743e-02,\n",
      "         2.3191e-02, -8.7881e-02, -2.1096e-02, -3.6618e-02, -2.1508e-02,\n",
      "         2.8010e-02,  3.6387e-02,  2.8202e-03, -7.0143e-02,  7.8757e-02,\n",
      "         8.1956e-02, -7.5177e-02, -1.3367e-02,  1.1129e-01,  8.9998e-02,\n",
      "         1.1255e-01, -5.8682e-02,  1.0574e-01, -1.0803e-01,  1.0909e-01,\n",
      "        -1.0898e-01, -8.6156e-02,  4.5988e-02,  2.3381e-02, -1.0704e-02,\n",
      "         9.6402e-02, -7.2663e-03, -5.7260e-02, -1.2427e-02, -1.1514e-01,\n",
      "         2.8416e-02, -2.9168e-02,  4.6915e-02, -4.1925e-02, -1.2316e-01,\n",
      "         4.2251e-02,  6.6193e-02,  9.8503e-02,  1.2837e-01,  7.9623e-02,\n",
      "         5.7067e-02, -8.9131e-02,  5.9792e-03,  1.3754e-02,  4.1360e-02,\n",
      "        -1.3319e-02, -8.4591e-02, -3.6518e-02, -6.5906e-02, -9.4442e-02,\n",
      "        -4.3264e-02, -1.6585e-02, -9.5460e-03,  3.5832e-02, -6.3867e-03,\n",
      "        -6.2676e-02,  1.1158e-01,  3.7634e-02, -3.9436e-02, -7.1158e-02,\n",
      "         4.2116e-02, -1.3631e-01,  1.0117e-01,  5.7335e-02,  1.3596e-01,\n",
      "         2.2108e-02,  1.3257e-01, -1.3639e-02,  2.9625e-02, -3.5037e-02,\n",
      "        -1.1062e-01,  6.1704e-02,  1.1866e-02, -9.9638e-02, -3.9843e-02,\n",
      "         9.8716e-02, -2.2689e-02,  6.3889e-02,  1.3651e-02,  2.4232e-02,\n",
      "        -7.3897e-02,  6.3054e-02, -5.5741e-02,  3.6817e-03, -4.9464e-03,\n",
      "        -1.8690e-02,  1.2256e-01,  7.8328e-02, -9.4661e-02, -8.4057e-02,\n",
      "         5.8846e-02,  2.3417e-02,  1.2514e-01, -2.1461e-02,  1.2971e-01,\n",
      "         1.9197e-02,  4.8979e-02,  1.1522e-01, -7.7549e-02,  7.1708e-02,\n",
      "        -1.2129e-01,  6.9983e-02,  1.9924e-02,  2.6079e-02,  2.1656e-02,\n",
      "         7.7678e-02,  3.3068e-02, -4.2997e-02,  9.8754e-02,  9.8700e-02,\n",
      "        -2.5396e-02, -3.5087e-02,  1.2405e-01, -1.7497e-02, -4.5899e-02,\n",
      "         1.6342e-02, -5.8935e-02,  9.3932e-02, -9.0904e-02,  5.4119e-02,\n",
      "        -4.9671e-03,  8.9149e-02, -6.6133e-02, -3.1211e-02,  4.8907e-02,\n",
      "         5.7556e-02, -2.9263e-02,  9.0393e-02, -1.0597e-01, -6.2182e-02,\n",
      "        -9.0838e-02, -1.3014e-02, -1.1498e-01,  1.2797e-01,  1.1502e-01,\n",
      "         5.0627e-03, -9.5480e-02,  1.9826e-02,  1.1205e-01, -4.5297e-02,\n",
      "        -8.0762e-03, -3.3163e-02,  3.4398e-02, -1.2638e-01,  3.3170e-02,\n",
      "        -5.0274e-03, -5.2018e-02,  2.0426e-02, -6.2922e-02,  1.1123e-01,\n",
      "        -8.1946e-02, -2.8638e-03, -9.0627e-02, -1.3078e-01,  3.4056e-02,\n",
      "         5.4533e-02, -3.7172e-02,  7.3305e-02,  4.1545e-02, -8.7356e-02,\n",
      "         5.9871e-02,  1.7197e-02,  3.9488e-02,  9.9948e-02,  6.8790e-02,\n",
      "         1.0293e-01, -6.5935e-02,  9.5273e-02,  2.9826e-02, -4.9869e-02,\n",
      "        -5.9235e-03,  5.9419e-02,  9.0636e-02,  1.2636e-01,  5.2511e-02,\n",
      "        -1.4883e-02, -1.0882e-01, -1.6991e-02, -6.8262e-02, -8.1926e-02,\n",
      "        -6.7314e-02, -9.6456e-02,  1.0286e-01,  1.0471e-01,  1.7853e-03,\n",
      "         1.0991e-01, -9.8097e-02,  1.2706e-01, -3.0590e-02, -1.3162e-01,\n",
      "        -5.0476e-02,  6.9035e-02, -9.6515e-02,  9.1173e-02, -1.2699e-01,\n",
      "         6.4587e-02,  8.0633e-02,  1.3498e-02,  5.3475e-02, -1.0196e-01,\n",
      "        -7.4590e-02, -5.6936e-02,  7.6303e-02, -7.3431e-02,  7.1571e-03,\n",
      "         6.4517e-02,  1.0115e-01, -1.0001e-01,  3.1463e-02, -9.4752e-02,\n",
      "         9.1189e-02, -1.1979e-01, -4.8893e-02,  8.9979e-02,  1.4565e-02,\n",
      "        -8.0107e-03,  2.5841e-02, -5.3745e-02,  9.6068e-02, -1.6334e-02,\n",
      "        -5.3701e-02, -8.3128e-02,  2.6640e-02,  8.5399e-02,  1.1791e-01,\n",
      "        -2.9484e-02,  1.4822e-02, -5.6587e-02,  6.4238e-03, -5.9415e-02,\n",
      "         7.2405e-02, -9.0257e-02,  1.9517e-02, -1.2443e-02, -1.0618e-01,\n",
      "        -7.9203e-02, -5.0643e-02,  1.0282e-02, -6.8756e-02,  7.0283e-02,\n",
      "        -1.1648e-01, -9.7483e-02, -3.2603e-02, -7.1847e-02,  3.7190e-02,\n",
      "        -1.0219e-01,  1.3585e-01,  1.0147e-01, -9.7830e-02,  6.4670e-02,\n",
      "        -4.8825e-02,  7.5406e-02, -1.0004e-01, -5.8346e-02,  8.1188e-02,\n",
      "         2.7108e-02,  2.4476e-02,  1.2778e-01, -6.6271e-02, -5.9549e-02,\n",
      "        -1.0491e-01,  4.3786e-02,  6.4606e-02,  1.1755e-01, -1.1092e-01,\n",
      "         9.2447e-02,  1.1187e-01, -5.8728e-02,  3.7047e-02, -4.2809e-02,\n",
      "        -2.3700e-02, -8.4378e-02,  6.5900e-02,  7.7210e-02,  7.8384e-02,\n",
      "        -4.6963e-02, -7.4824e-02, -1.1296e-01, -7.3641e-02, -7.9148e-02,\n",
      "         6.1682e-02, -1.2019e-01, -1.0511e-01, -1.1755e-01,  3.4367e-02,\n",
      "         6.1649e-02,  1.1178e-03,  3.3927e-02, -5.4834e-02, -3.0774e-04,\n",
      "        -4.2591e-02, -6.8969e-02, -9.1380e-02, -4.0677e-02,  1.2826e-02,\n",
      "        -3.4128e-02, -3.6685e-02,  7.3363e-02, -4.8922e-02,  2.3111e-02,\n",
      "         1.1946e-01,  8.1177e-03, -1.3195e-01, -1.7433e-02, -6.1947e-02,\n",
      "        -1.0434e-01, -3.5848e-02, -3.1724e-02,  9.3558e-02, -2.0086e-02,\n",
      "        -1.1125e-01, -1.8984e-03,  3.0192e-02, -4.6980e-02,  4.0492e-03,\n",
      "        -1.0166e-01, -4.0185e-02,  2.7344e-02,  1.0505e-01,  6.6626e-02,\n",
      "         8.3597e-02, -1.0733e-01,  6.9542e-02,  4.8398e-02, -2.3463e-02,\n",
      "        -5.7258e-02, -2.6591e-02,  4.0451e-02, -6.7005e-02,  1.5274e-02,\n",
      "         5.0633e-02, -1.9993e-02,  3.5713e-02, -2.5464e-02,  9.7470e-02,\n",
      "        -4.9436e-02, -6.5865e-02, -4.5306e-02,  7.4183e-02,  3.8548e-02,\n",
      "        -2.0381e-02,  9.2280e-02,  2.3268e-02,  1.6957e-03,  8.3720e-02,\n",
      "        -5.3385e-02, -1.5139e-02,  3.1466e-02,  7.7452e-02,  7.3411e-02,\n",
      "        -3.3437e-02,  4.5083e-02, -1.0210e-02,  8.1834e-02, -6.9724e-03,\n",
      "        -7.7546e-03, -8.3368e-02,  6.9510e-03,  6.4397e-02,  9.9828e-02,\n",
      "        -1.5542e-02, -7.2283e-02, -7.3022e-02, -4.1183e-02, -3.9054e-03,\n",
      "        -9.0223e-02, -1.8599e-02, -7.8931e-02, -3.7217e-02, -3.7418e-02,\n",
      "         2.7892e-02, -9.0099e-02, -8.9612e-02, -1.0423e-01,  5.4865e-02,\n",
      "        -1.8987e-02,  8.9337e-02, -1.0954e-01,  8.5438e-02, -3.5699e-02,\n",
      "        -5.5333e-02, -1.3828e-02, -6.0780e-02,  1.2037e-01, -2.1119e-02,\n",
      "         7.6505e-03, -7.9053e-02, -5.3211e-02,  8.2784e-02, -7.1667e-02,\n",
      "         1.1064e-01,  6.0703e-02, -4.7683e-02, -1.0358e-01,  1.2377e-01,\n",
      "        -1.0130e-01,  6.8251e-03, -3.0138e-02,  1.0077e-01,  2.3557e-03,\n",
      "        -3.9091e-02, -1.2710e-01, -1.2944e-01,  1.2125e-01,  1.2279e-01,\n",
      "        -9.8395e-02, -3.3111e-02, -6.6208e-02,  3.2028e-02,  6.7914e-02,\n",
      "        -6.3157e-03,  2.6235e-04,  7.4915e-02,  2.2199e-02,  1.2041e-01,\n",
      "         1.1707e-01, -1.2766e-02, -1.5651e-02, -4.7690e-03,  8.2301e-02,\n",
      "        -6.7856e-03, -7.4340e-02, -1.2765e-01,  8.7001e-02,  4.4286e-02,\n",
      "         1.2350e-01,  4.0775e-02,  9.7653e-02, -3.9861e-02, -6.1568e-02,\n",
      "         1.1716e-01, -5.3047e-02, -1.1143e-02,  7.5003e-02,  9.3001e-02,\n",
      "        -9.4862e-02, -5.2607e-02,  7.6453e-03,  1.0435e-02,  1.3494e-01,\n",
      "         1.1701e-01, -8.0350e-02,  9.9346e-02,  7.6780e-02, -4.1039e-02,\n",
      "        -5.5820e-02,  4.7197e-02,  6.5580e-03, -8.3533e-02, -1.2947e-01,\n",
      "         5.8330e-02, -1.0187e-01,  6.1706e-02, -7.4343e-02, -3.6969e-02,\n",
      "        -1.0662e-01,  1.1840e-01, -8.3392e-02,  1.0695e-01, -1.2958e-01,\n",
      "         9.9832e-03, -9.6722e-02,  6.1141e-02, -9.5124e-02,  7.5676e-02,\n",
      "        -7.9348e-02,  3.7922e-02,  3.9256e-02, -5.9990e-02, -3.0056e-02,\n",
      "         5.7523e-02,  6.0653e-02, -1.0635e-02,  7.0056e-02, -1.1439e-01,\n",
      "         1.1465e-01,  1.1317e-01, -9.9286e-02, -5.4269e-04,  9.3253e-02,\n",
      "         1.1338e-01, -9.9464e-02, -7.1746e-02,  1.1999e-01,  9.1803e-02,\n",
      "        -1.0330e-01,  1.1520e-01, -3.4723e-02, -4.7542e-02,  1.0824e-01,\n",
      "        -1.0218e-01, -5.2415e-02,  7.6626e-02, -2.7604e-02, -5.2188e-02,\n",
      "        -8.2623e-02, -1.2245e-01, -4.3636e-02, -6.1914e-02,  2.2672e-02,\n",
      "        -3.4572e-03,  2.4488e-02, -8.6269e-02, -3.8800e-02,  1.0465e-01,\n",
      "        -2.6139e-02, -1.0360e-01,  5.4284e-03,  6.0914e-02,  1.2151e-01,\n",
      "        -1.2096e-01, -7.1376e-03,  1.2120e-01,  2.9846e-02, -1.1521e-02,\n",
      "         6.0785e-03,  2.7895e-02, -5.4713e-02, -6.4126e-02,  2.7796e-02,\n",
      "        -1.3015e-01,  8.4806e-02,  2.0610e-03, -4.3505e-02, -6.7137e-02,\n",
      "        -8.2821e-02,  1.0471e-01,  2.4074e-03,  9.3281e-02,  8.7597e-02,\n",
      "        -7.1021e-02,  4.5913e-02, -3.9827e-02, -1.1574e-01, -6.6084e-02,\n",
      "        -4.1100e-02,  1.1897e-01, -1.9109e-02,  8.0602e-02,  1.3699e-01,\n",
      "        -4.0222e-02, -1.1731e-01,  4.8458e-02, -1.8745e-02, -2.5579e-02,\n",
      "        -1.1211e-01, -5.6460e-02,  6.9102e-02,  1.1953e-01, -7.2032e-02,\n",
      "         9.8375e-02,  4.1901e-02, -1.0125e-01, -7.7559e-02, -9.8310e-02,\n",
      "        -4.1951e-02,  3.0738e-02,  6.9306e-02,  4.1316e-02,  1.2035e-01,\n",
      "         9.0324e-02, -1.0376e-01, -5.6558e-02,  8.9421e-02, -1.6224e-02,\n",
      "         9.1084e-02, -7.0211e-02, -6.6739e-02, -6.6568e-02, -2.0907e-02,\n",
      "         1.2605e-01,  3.8325e-02,  7.4124e-02,  8.6033e-02,  4.7356e-02,\n",
      "         1.1310e-01, -3.0325e-02,  2.8206e-02,  7.8227e-02,  6.5481e-02,\n",
      "        -7.6448e-02,  1.1077e-01,  1.1234e-01, -3.9516e-02, -2.1316e-02,\n",
      "         3.7952e-02,  1.3644e-01,  8.3623e-02,  2.2350e-03, -4.8150e-02,\n",
      "        -3.7250e-02,  7.7658e-02,  3.5266e-02, -5.9127e-02,  7.4699e-02,\n",
      "        -1.2151e-01, -4.0306e-02,  9.5626e-04, -3.4679e-02, -9.5968e-02,\n",
      "         7.4739e-02, -5.2187e-02, -1.0351e-01, -8.3309e-02, -8.7759e-02,\n",
      "         3.8643e-02, -1.0905e-01, -4.0936e-02, -3.6914e-02,  6.8218e-02,\n",
      "         1.1390e-01,  2.5182e-02,  7.0364e-02, -7.6850e-02,  9.1657e-02,\n",
      "        -2.0962e-02,  2.9624e-02, -1.0362e-01, -1.1198e-01, -1.0301e-01,\n",
      "        -2.0327e-02, -6.0103e-02,  1.1691e-01, -5.3248e-02,  9.0766e-02,\n",
      "         1.1282e-01,  2.8727e-02,  1.0240e-01,  1.5604e-02,  4.7545e-02,\n",
      "        -2.3578e-02, -5.0104e-02, -7.6650e-02,  7.0085e-02,  1.6505e-02,\n",
      "         7.9967e-02, -1.6263e-02,  4.3647e-02, -3.1869e-02,  8.4664e-02,\n",
      "        -8.4527e-02,  6.8305e-02,  4.4597e-02, -8.2241e-05, -9.9217e-02,\n",
      "         7.3576e-02, -1.7209e-02, -9.2094e-02,  6.6949e-02,  9.7766e-02,\n",
      "        -5.1062e-02,  6.2753e-02, -2.5223e-02, -6.0376e-02,  9.1814e-02,\n",
      "         1.8796e-02, -9.2055e-02,  7.9508e-02,  6.0524e-04, -1.2577e-01,\n",
      "        -3.8785e-03, -7.7824e-02, -9.9934e-02,  5.9100e-02,  9.6545e-02,\n",
      "         1.0799e-01,  7.2419e-02,  5.1655e-02,  7.8391e-02, -3.9310e-03,\n",
      "        -9.1792e-02,  1.2335e-01,  6.3262e-02,  4.2927e-02, -6.1408e-02,\n",
      "        -7.6864e-02, -1.1669e-01,  1.1683e-01,  4.6927e-02, -2.6814e-02,\n",
      "        -1.2824e-01, -1.5033e-02, -4.7444e-03,  6.3986e-02, -1.1627e-01,\n",
      "        -9.7423e-02,  1.2468e-01, -9.4112e-02, -1.0713e-01,  9.9342e-02,\n",
      "         1.1707e-01, -2.3512e-02, -7.1979e-02,  1.0916e-01,  7.0230e-02,\n",
      "        -1.1560e-01, -5.2779e-02,  1.1659e-01, -1.7647e-02, -5.5518e-02,\n",
      "         1.1152e-01, -7.1429e-03, -5.3861e-02,  1.1460e-01,  5.0683e-02,\n",
      "         7.9609e-02,  1.9839e-02,  3.4976e-02,  6.4270e-02,  9.0451e-02,\n",
      "         7.0650e-02, -3.6932e-02, -7.7623e-02,  1.7792e-02,  1.9680e-02,\n",
      "         3.2455e-02, -1.2672e-01,  2.2989e-02, -6.4682e-02,  7.3749e-02,\n",
      "        -1.1571e-01,  1.8929e-02, -8.9262e-02, -7.4168e-02,  1.4531e-01,\n",
      "        -2.4238e-02,  9.9314e-02, -6.0990e-02,  5.7350e-03,  1.3316e-01,\n",
      "         2.8879e-02, -1.7655e-02, -3.6501e-02, -8.9430e-02, -5.2546e-02,\n",
      "         2.8733e-02, -1.0087e-01,  1.0172e-01,  4.1466e-02, -5.2181e-02,\n",
      "        -7.7795e-02,  1.2490e-01,  1.2006e-02, -8.8184e-02,  9.9044e-03,\n",
      "        -1.8766e-02,  1.0356e-01, -7.4589e-03, -4.8252e-02, -8.4895e-02,\n",
      "        -3.0040e-02, -7.3341e-02,  1.0094e-02,  9.4275e-02, -2.7274e-02,\n",
      "         9.0059e-02, -8.3287e-02,  8.7076e-02, -6.7747e-02,  9.1401e-02,\n",
      "        -2.6113e-02, -2.6687e-02, -9.1189e-02, -6.8457e-02, -3.4502e-02,\n",
      "         1.1901e-01, -8.8431e-02,  1.2356e-01, -1.0897e-01,  1.3342e-01,\n",
      "        -9.4717e-02,  1.1014e-02,  4.8801e-02, -2.8305e-02, -1.9120e-02,\n",
      "        -6.9859e-02, -7.8977e-02, -9.8788e-02, -1.0356e-01,  1.0076e-01,\n",
      "         6.9980e-02,  8.8694e-02,  4.5355e-02,  1.1521e-01, -6.7176e-02,\n",
      "         5.0972e-03,  8.6522e-02,  1.2921e-01, -1.3183e-01, -4.7101e-02,\n",
      "         2.2735e-02,  1.1111e-01, -6.9562e-02,  3.6046e-02, -1.1242e-01,\n",
      "         5.0989e-02,  1.3562e-01, -9.0800e-02,  2.9527e-02, -1.0925e-01,\n",
      "         1.1258e-01,  1.1636e-01, -1.0166e-01, -5.6827e-02,  4.5751e-02,\n",
      "        -5.3350e-02, -7.4222e-02, -1.0192e-01, -2.2428e-02, -8.0325e-02,\n",
      "        -3.1830e-02, -1.6716e-02, -1.2698e-01, -2.6029e-02, -5.0889e-02,\n",
      "         8.6515e-02,  3.6232e-02,  6.8258e-02, -1.2117e-02,  5.6388e-02,\n",
      "         8.6639e-02,  7.9861e-02, -1.3655e-02, -8.7114e-02,  5.3175e-02,\n",
      "        -8.1026e-02, -3.4362e-03,  1.0902e-01, -9.7824e-02, -8.7416e-02,\n",
      "        -9.6078e-03, -5.7163e-02, -2.5924e-02, -2.0381e-02, -1.9891e-02,\n",
      "        -5.6162e-02,  7.7475e-02, -2.3372e-02,  6.5146e-02,  9.3576e-02,\n",
      "        -4.9594e-02, -1.1197e-01, -7.2724e-03,  1.0419e-01, -7.1454e-02,\n",
      "         1.2578e-01, -8.5462e-02, -2.6077e-04, -3.0368e-02, -7.2858e-03],\n",
      "       requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([[ 0.0027,  0.0083, -0.0271,  ..., -0.0002,  0.0327, -0.0146],\n",
      "        [-0.0288, -0.0147,  0.0102,  ..., -0.0354, -0.0408,  0.0022]],\n",
      "       requires_grad=True)\n",
      "Parameter containing:\n",
      "tensor([ 0.0292, -0.0217], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "params = list(net.parameters())\n",
    "\n",
    "# Print the parameters\n",
    "for param in params:\n",
    "    print(param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "f385ccc0-7211-4d46-8684-96798fe0b638",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<built-in method size of Tensor object at 0x00000160B531B270>\n",
      "tensor(0)\n",
      "<built-in method size of Tensor object at 0x00000160B531BBD0>\n",
      "tensor(1)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_22108\\1880285545.py:18: DeprecationWarning: an integer is required (got type numpy.float64).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.\n",
      "  return torch.tensor(sample, dtype=torch.float32), torch.tensor(label, dtype=torch.long)\n"
     ]
    }
   ],
   "source": [
    "for samples, labels in test_loader:\n",
    "    print(samples.size)\n",
    "    output = net(samples[3])\n",
    "    print(labels[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "6f918303-4e59-4985-b80b-76e986dd96c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "spk_In = torch.stack(net.spkIn)\n",
    "spk_rec1 = torch.stack(net.spk1)\n",
    "spk_rec2 = torch.stack(net.spk2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "2d387f15-174a-4215-868f-3fb9277c204d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(net.spkIn[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "82add137-6812-4b3d-98dc-68e71d611b7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59\n",
      "25\n",
      "2\n",
      "tensor(0)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\USER\\AppData\\Local\\Temp\\ipykernel_22108\\1880285545.py:18: DeprecationWarning: an integer is required (got type numpy.float64).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.\n",
      "  return torch.tensor(sample, dtype=torch.float32), torch.tensor(label, dtype=torch.long)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x700 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59\n",
      "25\n",
      "2\n",
      "tensor(1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x700 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for samples, labels in test_loader:\n",
    "    print(len(samples[2]))\n",
    "    output = net(samples[2])\n",
    "    print(len(net.spkIn))\n",
    "    print(len(output))\n",
    "    print(labels[2])\n",
    "    #spk_In = torch.stack(net.spkIn)\n",
    "    spk_rec1 = torch.stack(net.spk1)\n",
    "    spk_rec2 = torch.stack(net.spk2)\n",
    "    plot_snn_spikes_modified(net.spkIn[0], spk_rec1, spk_rec2, num_steps, \"Fully Connected Spiking Neural Network\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bb1e464-e83a-4008-bfd6-5860051867c8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "16952192-4773-4ca8-b19c-f2994693caf1",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1446673835.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[94], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    spk_In = torch.stack(net.spkIn[])\u001b[0m\n\u001b[1;37m                                   ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "spk_In = torch.stack(net.spkIn[])\n",
    "spk_rec1 = torch.stack(net.spk1)\n",
    "spk_rec2 = torch.stack(net.spk2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d83064b-750d-4a73-a945-dd24aad065ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_snn_spikes(spk_In, spk_rec1, spk_rec2, num_steps, \"Fully Connected Spiking Neural Network\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc7606a3-d7c4-438d-bc40-19d165e1b495",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Sample data\n",
    "neuron_numbers = list(range(59))\n",
    "currents = net.spkIn[0].tolist()  # Currents fed to each neuron\n",
    "\n",
    "# Create bar chart\n",
    "plt.bar(neuron_numbers, currents, color='skyblue')\n",
    "\n",
    "# Add labels and title\n",
    "plt.xlabel('Neuron Numbers')\n",
    "plt.ylabel('Currents')\n",
    "plt.title('Currents Fed to Neurons')\n",
    "\n",
    "# Show plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "868ada83-9863-4ebf-8abf-b2f268ea31cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(neuron_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9ece0ec-708d-4bbb-817a-7e3887ebe8cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(net.state_dict(), 'model.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbf261c7-5eab-43e6-801a-8fe7d92e8b12",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}