Classifier_Interpretability.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------CNN Training ---------\n",
      "---------CNN prediction on saved model----\n",
      "Final accuracy of CNN: 67.88\n",
      "---------Activation Maximization---------\n",
      "Inputed image trying to adjust as per class 6\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\arsal\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:173: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximised image \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------D Tree---------\n",
      "Final Dtree score: 26.119999999999997\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import copy\n",
    "from sklearn.preprocessing import label_binarize\n",
    "import warnings\n",
    "import pickle\n",
    "from sklearn.metrics import accuracy_score\n",
    "import sklearn.tree        # For DecisionTreeClassifier class\n",
    "import sklearn.ensemble    # For RandomForestClassifier class\n",
    "import sklearn.datasets    # For make_circles\n",
    "import sklearn.metrics     # For accuracy_score\n",
    "from sklearn.feature_selection import VarianceThreshold, SelectKBest\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "np.set_printoptions(precision=3, suppress=True)  # Print array values as 0.0023 instead of 2.352e-3\n",
    "torch.set_printoptions(precision=3, sci_mode=False)\n",
    "class CNN_CIFAR:\n",
    "    \n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    def unpickle(self,file):\n",
    "        import pickle\n",
    "        with open(file, 'rb') as fo:\n",
    "            dict = pickle.load(fo, encoding='bytes')\n",
    "        return dict\n",
    "    def scale_data(self,data):\n",
    "        data = data/255\n",
    "        data = (2*data)-1\n",
    "        return data\n",
    "    \n",
    "    def build_model(self):\n",
    "        torch.manual_seed(0)\n",
    "        \n",
    "        filter_size = 5\n",
    "        num_filters = 6\n",
    "        pool_size = 2\n",
    "        \n",
    "        model = torch.nn.Sequential(\n",
    "            torch.nn.Conv2d(in_channels=3,\n",
    "                    out_channels=10,\n",
    "                    kernel_size=filter_size,\n",
    "                    stride = 1,\n",
    "                    padding=2\n",
    "                           ),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.MaxPool2d(kernel_size=pool_size,stride = 2),\n",
    "            torch.nn.Conv2d(in_channels=10,\n",
    "                    out_channels=20,\n",
    "                    kernel_size=filter_size,\n",
    "                    stride = 1,\n",
    "                    padding=2\n",
    "                           ),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.MaxPool2d(kernel_size=pool_size, stride=pool_size), \n",
    "            torch.nn.Flatten(),\n",
    "            torch.nn.Linear((2*10*16**2)//pool_size**2, 80),\n",
    "            torch.nn.ReLU(),\n",
    "            torch.nn.Linear(80, 10),\n",
    "           # torch.nn.Linear(84, 10),\n",
    "        )\n",
    "        model = model.float()\n",
    "        return model\n",
    "    \n",
    "    def train_model(self,model,X_train,y_train,batch_size,epoch_num):\n",
    "        #define loss function as entropy loss funcion\n",
    "        model.float()\n",
    "        loss = torch.nn.CrossEntropyLoss()\n",
    "        loss = loss.float()\n",
    "        optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.9, weight_decay=1e-3)\n",
    "        for epoch in range(1, epoch_num+1):\n",
    "            for i in range(0, len(X_train), batch_size):        \n",
    "                X = X_train[i:i+batch_size]\n",
    "                y = y_train[i:i+batch_size]\n",
    "\n",
    "                y_pred = model(X)\n",
    "                #print(y_pred.shape)\n",
    "                #print(y.shape)\n",
    "                l = loss(y_pred, torch.max(y, 1)[1])\n",
    "        \n",
    "                model.zero_grad()\n",
    "                l.backward()\n",
    "                optimizer.step()\n",
    "        \n",
    "            print(\"Epoch %d final minibatch had loss %.4f\" % (epoch, l.item()))\n",
    "        return model\n",
    "    \n",
    "    def testing(self):      \n",
    "        X_dtest = self.unpickle('test_batch')\n",
    "        X_test,y_test = X_dtest[b'data'],(X_dtest[b'labels'])\n",
    "        X_test = self.scale_data(X_test)\n",
    "        X_test = X_test.reshape(-1,3,32,32)\n",
    "        y_test =  np.asarray(y_test) \n",
    "        X_test = torch.tensor(X_test)\n",
    "        X_test = X_test.float()\n",
    "        model = pickle.load(open('finalized_model2.sav', 'rb'))\n",
    "        \n",
    "        y_pred = model(X_test.float())\n",
    "        \n",
    "        y_predicted = np.zeros((y_pred.shape[0]))\n",
    "        for i in range(y_pred.shape[0]):\n",
    "             y_predicted[i] = np.where(y_pred[i] == max(y_pred[i]))[0][0]\n",
    "        \n",
    "        print(\"Final accuracy of CNN:\",accuracy_score(y_test, y_predicted)*100)\n",
    "               \n",
    "    \n",
    "    def start(self):\n",
    "        print(\"Unpickling Data files begin\")\n",
    "        #unpickling the data set\n",
    "        file1 = 'data_batch_1'\n",
    "        file2 = 'data_batch_2'\n",
    "        file3 = 'data_batch_3'\n",
    "        file4 = 'data_batch_4'\n",
    "        file5 = 'data_batch_5'\n",
    "        test_file = 'test_batch'\n",
    "        \n",
    "        X_d1 = self.unpickle(file1)\n",
    "        X_d2 = self.unpickle(file2)\n",
    "        X_d3 = self.unpickle(file3)\n",
    "        X_d4 = self.unpickle(file4)\n",
    "        X_d5 = self.unpickle(file5)\n",
    "        \n",
    "        X_dtest = self.unpickle(test_file)\n",
    "        \n",
    "        print(list(X_d1.keys()))        \n",
    "        \n",
    "        X1,y1 = X_d1[b'data'],(X_d1[b'labels'])\n",
    "        X2,y2 = X_d2[b'data'],(X_d2[b'labels'])\n",
    "        X3,y3 = X_d3[b'data'],(X_d3[b'labels'])\n",
    "        X4,y4 = X_d4[b'data'],(X_d4[b'labels'])\n",
    "        X5,y5 = X_d5[b'data'],(X_d5[b'labels'])\n",
    "        \n",
    "        X_test,y_test = X_dtest[b'data'],(X_dtest[b'labels'])\n",
    "        \n",
    "        X = np.vstack((X1,X2,X3,X4,X5))\n",
    "        y = y1+y2+y3+y4+y5\n",
    "        y = np.asarray(y)\n",
    "        \n",
    "        model = self.build_model()\n",
    "        \n",
    "        #Rescaling pixel data to fit between -1 and 1\n",
    "        X = self.scale_data(X)               \n",
    "        X = X.reshape(-1,3,32,32)\n",
    "        \n",
    "        y = label_binarize(y,classes = np.arange(0,10,1))\n",
    "        X,y = torch.tensor(X), torch.tensor(y)\n",
    "        \n",
    "        X = X.float()\n",
    "        y = y.float()\n",
    "        #predictions before training\n",
    "        y_pred = model(X[:5].float())\n",
    "            \n",
    "        model = self.train_model(model,X,y,300,10)\n",
    "            \n",
    "        # saving trained model on the file\n",
    "        filename = 'finalized_model3.sav'\n",
    "        pickle.dump(model, open(filename, 'wb'))\n",
    "        \n",
    "        #predictions after training\n",
    "        y_pred = model(X[:5].float())\n",
    "        y_pred = torch.softmax(model(X[:5].float()), dim=1)\n",
    "                \n",
    "        return\n",
    "    \n",
    "    def Activation_Maximisation(self, i):\n",
    "        x = torch.zeros([1, 3, 32, 32])\n",
    "        print('Inputed image trying to adjust as per class', i)\n",
    "        plt.imshow(torch.Tensor.cpu(x).detach().numpy()[:,:,:,:][0].transpose(1,2,0))\n",
    "        plt.show() \n",
    "        x = torch.tensor(x, requires_grad=True)\n",
    "        y_test = torch.tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])        \n",
    "        y_test[i] = 1\n",
    "        for i in range(100):\n",
    "            model = pickle.load(open('finalized_model2.sav', 'rb'))\n",
    "            y = model(x)\n",
    "            y_predicted = np.where(y == max(y))[0][0]\n",
    "\n",
    "            y.backward(gradient=y_test.reshape(-1,10))\n",
    "            x.data += 0.1*x.grad.data\n",
    "\n",
    "            x.grad.data.zero_()\n",
    "        x=torch.Tensor.cpu(x).detach().numpy()[:,:,:,:]\n",
    "        print('Maximised image ')\n",
    "        plt.imshow(x[0].transpose(1,2,0))\n",
    "        plt.show()  \n",
    "        return\n",
    "\n",
    "class Decision_tree:\n",
    "    def unpickle(self, file):\n",
    "        with open(file, 'rb') as fo:\n",
    "            dict = pickle.load(fo, encoding='bytes')\n",
    "        return dict\n",
    "    \n",
    "    def start(self):\n",
    "        x = np.zeros(3072)\n",
    "        y = np.array([], dtype= np.int)\n",
    "        for i in range(1,6):\n",
    "            dicti = self.unpickle(\"data_batch_\"+str(i))\n",
    "            x = np.row_stack( ( x, np.array(dicti[b'data'] , dtype= np.uint8) )  )\n",
    "            y = np.append(  y, np.array( dicti[b'labels'], dtype= np.int32) , axis = 0 )\n",
    "        x = x[1:]\n",
    "        dicti = self.unpickle(\"test_batch\")\n",
    "        x_test = np.array(dicti[b'data'] , dtype= np.uint8)\n",
    "        y_test = np.array( dicti[b'labels'], dtype= np.int32)\n",
    "        scaler = StandardScaler()\n",
    "        scaler.fit(x)\n",
    "        x = scaler.transform(x)\n",
    "        x_test = scaler.transform(x_test)\n",
    "        pca = PCA(n_components = 80)\n",
    "        pca.fit(x)\n",
    "        x = pca.transform(x)\n",
    "        x_test = pca.transform(x_test)\n",
    "        tree = sklearn.tree.DecisionTreeClassifier(random_state=0, max_depth = 5)\n",
    "        tree.fit(x, y)\n",
    "        sklearn.tree.plot_tree(tree, max_depth = 2)\n",
    "        print(\"Final Dtree score:\", tree.score(x_test, y_test)*100)\n",
    "        return\n",
    "\n",
    "print(\"-------CNN Training ---------\")\n",
    "# for training please uncomment the code below\n",
    "obj = CNN_CIFAR()\n",
    "#obj.start()\n",
    "print(\"---------CNN prediction on saved model----\")\n",
    "# for testing on saved model\n",
    "obj = CNN_CIFAR()\n",
    "obj.testing()\n",
    "print(\"---------Activation Maximization---------\")\n",
    "# You can change the class number while calling the function, which data you want to generate\n",
    "obj = CNN_CIFAR()\n",
    "# initially calling for frog class\n",
    "obj.Activation_Maximisation(6)\n",
    "print(\"---------D Tree---------\")\n",
    "obj = Decision_tree()\n",
    "obj.start()"
   ]
  }
 ],
 "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
}