pruning.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "pruning.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "36svGbw1B7nc"
      },
      "source": [
        "import torch\r\n",
        "import torch.nn.utils.prune as prune\r\n",
        "\r\n",
        "class ThresholdPruning(prune.BasePruningMethod):\r\n",
        "    PRUNING_TYPE = \"unstructured\"\r\n",
        "\r\n",
        "    def __init__(self, threshold):\r\n",
        "        self.threshold = threshold\r\n",
        "\r\n",
        "    def compute_mask(self, tensor, default_mask):\r\n",
        "        return torch.abs(tensor) > self.threshold"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nQ3nLhXcBLdt"
      },
      "source": [
        "import torch \r\n",
        "\r\n",
        "def corr_coeff(x,y):\r\n",
        "    \"\"\"\r\n",
        "    Function that computes coelation coefficient between two tensors with same size\r\n",
        "    Returns\r\n",
        "    -------\r\n",
        "    corr: \r\n",
        "        correlation coefficient between x and y\r\n",
        "    \"\"\" \r\n",
        "    vx = x - torch.mean(x)\r\n",
        "    vy = y - torch.mean(y)\r\n",
        "\r\n",
        "    corr= torch.sum(vx * vy) / (torch.sqrt(torch.mean(vx ** 2)) * torch.mean(torch.mean(vy ** 2)))\r\n",
        "        \r\n",
        "    corr = torch.clamp(corr,-1.0,1.0)\r\n",
        "    return corr"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TQVk3CeFAkfL"
      },
      "source": [
        "import torch.nn as nn\r\n",
        "import torch \r\n",
        "import numpy as np\r\n",
        "import copy\r\n",
        "import torch.nn.utils.prune as prune\r\n",
        "\r\n",
        "\r\n",
        "class LSTM(nn.Module):\r\n",
        "    \r\n",
        "    def __init__(self, input_dim, output_dim, seq_len, n_hidden= 10 , n_layers = 1, fixed_pt_quantize = False):\r\n",
        "        \"\"\"\r\n",
        "        Function that initializes our lstm netwrok with two lstm layers and one linear layer\r\n",
        "        Parameters\r\n",
        "        ----------\r\n",
        "        input_dim: int\r\n",
        "            number of features\r\n",
        "        output_dim: int\r\n",
        "            pediction's dimension\r\n",
        "        seq_len: int\r\n",
        "            length of sequence of data\r\n",
        "        n_hidden: int\r\n",
        "            number of hidden nodes of eacch lstm layer\r\n",
        "        n_layers: int\r\n",
        "            number of layers in each lstm layer\r\n",
        "        fixed_pt_quantize: boolean\r\n",
        "            if set fixed point qunatization will a applied\r\n",
        "      \r\n",
        "        \"\"\"\r\n",
        "        super().__init__()\r\n",
        "        self.n_hidden = n_hidden\r\n",
        "        self.n_layers = n_layers\r\n",
        "        self.input_dim = input_dim\r\n",
        "        self.output_dim = output_dim\r\n",
        "        self.seq_len = seq_len\r\n",
        "\r\n",
        "        \r\n",
        "        #lstm layers\r\n",
        "        self.lstm = nn.LSTM(self.input_dim, self.n_hidden, self.n_layers, batch_first=False)\r\n",
        "        #linear layer\r\n",
        "        self.fc = nn.Linear(self.n_hidden, self.output_dim)\r\n",
        "        #activation function\r\n",
        "        self.act = nn.Sigmoid()\r\n",
        "      \r\n",
        "    def threshold_pruning(self):\r\n",
        "        \"\"\"\r\n",
        "        Function that pruns the weights\r\n",
        "        \"\"\"\r\n",
        "\r\n",
        "        for k in range(self.n_layers):\r\n",
        "            parameters_to_prune = ((self.lstm, \"weight_ih_l\"+str(k)), (self.lstm, \"weight_hh_l\"+str(k)))\r\n",
        "            prune.global_unstructured(parameters_to_prune, pruning_method=ThresholdPruning, threshold= 0.125)\r\n",
        "        \r\n",
        "\r\n",
        "\r\n",
        "    def forward(self, input, hidden, bin_=False, quant=False):\r\n",
        "        \"\"\"\r\n",
        "        Function that forward pass through the network \r\n",
        "        Parameters\r\n",
        "        ----------\r\n",
        "        TrainX: matrix of shape [#datapoints, seq_len, input_dim]\r\n",
        "            contain feature vectors of train data\r\n",
        "        hidden: pair of matrices of shape [n_layer, batch_size, n_hidden]\r\n",
        "            hidden/cell state of LSTM layers\r\n",
        "        bin_: boolean\r\n",
        "            if set, the network is binarized\r\n",
        "        quant: boolean\r\n",
        "            if set, the network is quantized\r\n",
        "        Returns\r\n",
        "        -------\r\n",
        "        out: matrix of shape [seq_len, batch_size, n_hidden]\r\n",
        "            scaler used to standardize the data\r\n",
        "        hidden: pair of matrices of shape [n_layer, batch_size, n_hidden]\r\n",
        "            hidden/cell state of LSTM layers\r\n",
        "        \"\"\" \r\n",
        "        ##our input has shape [batch_size, seq_len, input_dim] but lstm wants [seq_len, batch_size, input_dim], we need to reconstrcut the input the way lstm wants:\r\n",
        "        new_input = torch.ones((self.seq_len, input.shape[0], self.input_dim))\r\n",
        "        for i in range(self.seq_len):\r\n",
        "            new_input[i] = input[:,i,:]\r\n",
        "\r\n",
        "        r_output, hidden = self.lstm(new_input, hidden)\r\n",
        "        \r\n",
        "    \r\n",
        "        ## put x through the fully-connected layer\r\n",
        "        out = self.act(r_output)\r\n",
        "        out = self.fc(out)\r\n",
        "        \r\n",
        "        return out, hidden\r\n",
        "\r\n",
        "\r\n",
        "    def init_hidden(self, batch_size):\r\n",
        "        \"\"\"\r\n",
        "        Function that initializes hidden state\r\n",
        "        Parameters\r\n",
        "        ----------\r\n",
        "        batch_size: int\r\n",
        "            batch size!\r\n",
        "        Returns\r\n",
        "        -------\r\n",
        "        hidden: pair of matrices of shape [n_layer, batch_size, n_hidden]\r\n",
        "            hidden/cell state of LSTM layers\r\n",
        "        \"\"\" \r\n",
        "        # Create two new tensors with sizes n_layers x n_hidden,\r\n",
        "        # initialized to zero, for hidden state and cell state of LSTM\r\n",
        "        hidden_state = torch.zeros(self.n_layers, batch_size, self.n_hidden)\r\n",
        "        cell_state = torch.zeros(self.n_layers, batch_size, self.n_hidden)\r\n",
        "        hidden = (hidden_state, cell_state)\r\n",
        "\r\n",
        "        return hidden"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 959
        },
        "id": "_AkHAp-NBWfY",
        "outputId": "44cce65a-d111-43a5-f6c7-1856f1f5a416"
      },
      "source": [
        "import numpy as np\r\n",
        "import scipy.io as sio \r\n",
        "import torch.nn as nn\r\n",
        "import torch \r\n",
        "import matplotlib.pyplot as plt\r\n",
        "import os\r\n",
        "import argparse\r\n",
        "import pickle\r\n",
        "\r\n",
        "#from preprocessing_funcs import get_spikes_with_history, preprocessing, remove_outliers\r\n",
        "#from model import LSTM\r\n",
        "#from trainer import train\r\n",
        "#from pruning import ThresholdPruning\r\n",
        "#from \r\n",
        "\r\n",
        "#set this to the root directory where you want to save and load data and figures\r\n",
        "root = os.path.join('drive')\r\n",
        "#set this to the diectory where you want to save data and checkpoints\r\n",
        "data_path = os.path.join(root, 'data')\r\n",
        "#set this to the diectory where you want to save checkpoints\r\n",
        "#set this to directory where you want to save figures\r\n",
        "figure_path = 'figs'\r\n",
        "checkpoint_path = 'res'\r\n",
        "# thresholds values used in the report : 0.05; 0.1; 0.125; 0.15\r\n",
        "threshold = 0.125\r\n",
        "\r\n",
        "for Idx_subject in list([10]): # 3 subjects index 10-12\r\n",
        "\r\n",
        "        for Finger in list([0]): # 5 fingers for each subject. 0:thumb, 1:index, 2:middle ...\r\n",
        "            \r\n",
        "            #load training data (TrainX: feature vectors, TrainY: labels)\r\n",
        "            matData = sio.loadmat('BCImoreData_Subj_'+str(Idx_subject)+'_200msLMP.mat')\r\n",
        "            TrainX = matData['Data_Feature'].transpose()\r\n",
        "            TrainY = matData['SmoothedFinger']\r\n",
        "            TrainY = TrainY [:,Finger]\r\n",
        "            TrainY = TrainY.reshape(TrainY.shape[0],1)\r\n",
        "            #load testing data (TestX: feature vectors, TestY: labels)\r\n",
        "            matData = sio.loadmat('BCImoreData_Subj_'+str(Idx_subject)+'_200msLMPTest.mat')\r\n",
        "            TestX = matData['Data_Feature'].transpose()\r\n",
        "            TestY = matData['SmoothedFinger']\r\n",
        "            TestY = TestY[:,Finger]\r\n",
        "            TestY = TestY.reshape(TestY.shape[0],1)\r\n",
        "            \r\n",
        "            # preprocessing \r\n",
        "            TrainX = remove_outliers(TrainX)\r\n",
        "            \r\n",
        "            x_scaler, y_scaler, TrainX, TestX, TrainY, TestY  = preprocessing(TrainX,TestX,TrainY,TestY)\r\n",
        "            \r\n",
        "            \r\n",
        "            # from here, we reconstruct the input by \"looking back\" a few steps\r\n",
        "            bins_before= 20 #How many bins of neural data prior to the output are used for decoding\r\n",
        "            bins_current=1 #Whether to use concurrent time bin of neural data\r\n",
        "            bins_after=0 #How many bins of neural data after the output are used for decoding\r\n",
        "            \r\n",
        "            TrainX=get_spikes_with_history(TrainX,bins_before,bins_after,bins_current)\r\n",
        "            TrainX, TrainY = TrainX[bins_before:,:,:], TrainY[bins_before:,]\r\n",
        "         \r\n",
        "            TestX=get_spikes_with_history(TestX,bins_before,bins_after,bins_current)\r\n",
        "            TestX, TestY = TestX[bins_before:,:,:], TestY[bins_before:,]\r\n",
        "            \r\n",
        "            # Now, we reconstructed TrainX/TestX to have a shape (num_of_samples, sequence_length, input_size)\r\n",
        "            # We can fit this to the LSTM\r\n",
        "            \r\n",
        "            print(\"Run for subject \" + str(Idx_subject) + \" finger \"+str(Finger))\r\n",
        "\r\n",
        "            n_hidden = 20\r\n",
        "            n_layers = 5\r\n",
        "            input_dim = TrainX.shape[2]\r\n",
        "            output_dim = TrainY.shape[1]\r\n",
        "            seq_len =  TrainX.shape[1]\r\n",
        "\r\n",
        "            net = LSTM(input_dim, output_dim, seq_len,  n_hidden, n_layers, fixed_pt_quantize = fixed_pt_quantize)\r\n",
        "\r\n",
        "            lossfunc = nn.MSELoss()\r\n",
        "            lr = 0.002\r\n",
        "            optimizer = torch.optim.Adamax(net.parameters(), lr=lr)\r\n",
        "\r\n",
        "           \r\n",
        "            print(\"Baseline ===================================================================\")\r\n",
        "            ##training the initial model\r\n",
        "\r\n",
        "            net.train()\r\n",
        "            corr_train, corr_val, corr_test = train(TrainX, TrainY,TestX,TestY, net, lossfunc, optimizer, num_epoch = 40, clip = 5, Finger=Finger)\r\n",
        "            net.eval()\r\n",
        "            pred,h = net(torch.from_numpy(TestX).float(), net.init_hidden(TestX.shape[0]))\r\n",
        "\r\n",
        "            \r\n",
        "            ##############################################PRUNING###########################################################################\r\n",
        "            print(\"Pruning============================================================================\")\r\n",
        "            PATH_pre_trained_prun = checkpoint_path + '/s'+ str(Idx_subject) + '_f'+str(Finger)+'_trained_pruned_model'\r\n",
        "            figure_name = \"/Subject_\" + str(Idx_subject) + \"_Finger_\"+str(Finger)+\"_pruning\"\r\n",
        "\r\n",
        "            \r\n",
        "            net.train()\r\n",
        "            # default value or threshold is 0.125\r\n",
        "            net.threshold_pruning() \r\n",
        "\r\n",
        "            #train the prunned model:\r\n",
        "            corr_train, corr_val, corr_test = train(TrainX, TrainY, TestX, TestY, net, lossfunc, optimizer, num_epoch=2, clip = 5, Finger = Finger)\r\n",
        "\r\n",
        "            net.eval()\r\n",
        "            pred,h = net(torch.from_numpy(TestX).float(), net.init_hidden(TestX.shape[0]))\r\n",
        "               \r\n",
        "          \r\n",
        "            pred = pred.detach().numpy()[-1,:,:]\r\n",
        "            pred = y_scaler.inverse_transform(pred)\r\n",
        "            TestY = y_scaler.inverse_transform(TestY)\r\n",
        "            pred = pred.reshape((-1,))\r\n",
        "            corrcoef = np.corrcoef(pred,TestY.reshape((-1,)))\r\n",
        "\r\n",
        "            TestYShifted = TestY\r\n",
        "            #pred_tf = scaler.inverse_transform(pred)\r\n",
        "            x = np.arange(TestYShifted.shape[0])\r\n",
        "            \r\n",
        "           \r\n",
        "            fig_label = plt.figure(figsize=(15,10))\r\n",
        "            plt.title(\"Subject_\" + str(Idx_subject) + \"_Finger_\"+str(Finger))\r\n",
        "            plt.plot(x, TestYShifted)\r\n",
        "            plt.plot(x, pred)\r\n",
        "            fig_label.savefig(figure_path + figure_name)\r\n",
        "\r\n",
        "            \r\n",
        "            print ('Correlation coefficient test : {corrcoef}'.format(corrcoef=corrcoef[0,1]))   "
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Run for subject 10 finger 0\n",
            "Baseline ===================================================================\n",
            "Epoch [1/2], Loss: 0.2641\n",
            "Correlation coefficient train : 0.003967322233571132\n",
            "Correlation coefficient validation: 0.012257746673844043\n",
            "Correlation coefficient test: 7.611981829669507e-05\n",
            "Epoch [2/2], Loss: 0.2377\n",
            "Correlation coefficient train : 0.016128080340051833\n",
            "Correlation coefficient validation: 0.005914392940892592\n",
            "Correlation coefficient test: -0.022781252228760006\n",
            "Pruning============================================================================\n",
            "Epoch [1/2], Loss: 0.2130\n",
            "Correlation coefficient train : 0.03382977351641301\n",
            "Correlation coefficient validation: 0.016758406436650358\n",
            "Correlation coefficient test: -0.022131684933127817\n",
            "Epoch [2/2], Loss: 0.1915\n",
            "Correlation coefficient train : 0.03812967169948683\n",
            "Correlation coefficient validation: 0.012531726565054172\n",
            "Correlation coefficient test: -0.03504524263005223\n",
            "Correlation coefficient test : -0.03504479810286855\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}