NNFL_Assignment_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o2CfhEkZ24Wl"
   },
   "source": [
    "# NNFL Assignment 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CPmSt2xBYbS2"
   },
   "source": [
    "# Ishan Dixit           -                           2018AAPS0333H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "T1Pt1xBxJy6G"
   },
   "outputs": [],
   "source": [
    "#Importing libraries\n",
    "\n",
    "import scipy.io\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "import numpy as np\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D\n",
    "from tensorflow.keras import regularizers\n",
    "from PIL import Image\n",
    "import glob\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split,KFold\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wfiRQXAkuCJt"
   },
   "outputs": [],
   "source": [
    "#Helper Functions\n",
    "\n",
    "def holdout_crossvalid(data, train, val, test,norm=False):\n",
    "\n",
    "    np.random.seed(0)\n",
    "    if isinstance(data, pd.DataFrame):\n",
    "        vec = data.to_numpy()\n",
    "    else:\n",
    "        vec=data\n",
    "    np.random.shuffle(vec)\n",
    "    total = data.shape[0]\n",
    "\n",
    "    train_len = int(train * total)\n",
    "    val_len = int(val * total)\n",
    "    test_len = int(test * total)\n",
    "    train = vec[:train_len, :vec.shape[1]-1]\n",
    "    val = vec[train_len:train_len + val_len, :vec.shape[1]-1]\n",
    "    test = vec[train_len + val_len:, :vec.shape[1]-1]\n",
    "\n",
    "    train_label = vec[:train_len, vec.shape[1]-1].reshape(-1, 1)\n",
    "    val_label = vec[train_len:train_len + val_len, vec.shape[1]-1].reshape(-1, 1)\n",
    "    test_label = vec[train_len + val_len:, vec.shape[1]-1].reshape(-1, 1)\n",
    "    \n",
    "    if norm:\n",
    "    \n",
    "        x=[]\n",
    "        mean=[]\n",
    "        std=[]\n",
    "        for i in range(train.shape[1]):\n",
    "            x.append((train[:,i]-np.mean(train[:,i]))/np.std(train[:,i]))\n",
    "            mean.append(np.mean(train[:,i]))\n",
    "            std.append(np.std(train[:,i]))\n",
    "\n",
    "\n",
    "        train=np.array(x).T\n",
    "\n",
    "\n",
    "        x=[]\n",
    "        for i in range(test.shape[1]):\n",
    "            x.append((test[:,i]-mean[i])/std[i])\n",
    "\n",
    "        test=np.array(x).T\n",
    "        \n",
    "        x=[]\n",
    "        for i in range(val.shape[1]):\n",
    "            x.append((val[:,i]-mean[i])/std[i])\n",
    "\n",
    "        val=np.array(x).T\n",
    "\n",
    "\n",
    "    return train, train_label, val, val_label, test, test_label\n",
    "\n",
    "def acc(h, test_output):\n",
    "    TN = 0\n",
    "    TP = 0\n",
    "    FN = 0\n",
    "    FP = 0\n",
    "    for i in range(test_output.shape[0]):\n",
    "        if (h[i] == test_output[i]) & (test_output[i] == 0):\n",
    "            TN += 1\n",
    "        elif (h[i] == test_output[i]) & (test_output[i] == 1):\n",
    "            TP += 1\n",
    "        elif (h[i] == 0) & (test_output[i] == 1):\n",
    "            FN += 1\n",
    "        elif (h[i] == 1) & (test_output[i] == 0):\n",
    "            FP += 1\n",
    "    SE = TP / (TP + FN)\n",
    "    SP = TN / (TN + FP)\n",
    "    Acc = (TP + TN) / (TP + FN + TN + FP)\n",
    "    return SE,SP, Acc\n",
    "\n",
    "def sigmoid(x,deriv = False):\n",
    "    if not deriv:\n",
    "        return 1/(1 + np.exp(-x))\n",
    "    else:\n",
    "        return x*(1 - x)     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "20Z6qAPTt5yM"
   },
   "source": [
    "## Q.1 Non-linear perceptron algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "9POQQ_w1t483",
    "outputId": "1150f81d-5c8e-4ebd-c1ec-07bb16ea20a8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training split accuracy for iteration 0 : 80.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 1 : 95.71428571428572 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 2 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 3 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 4 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 5 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 6 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 7 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 8 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 9 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 10 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 11 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Training split accuracy for iteration 12 : 100.0 %\n",
      "Validation split accuracy : 100.0 %\n",
      "\n",
      "\n",
      "Test split Sensitivity and Specificity :  1.0 1.0\n",
      "Test split Accuracy : 100.0 %\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f1e214a2f60>]"
      ]
     },
     "execution_count": 3,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.read_excel('/content/drive/MyDrive/Copy of data55.xlsx',header=None)\n",
    "\n",
    "train, train_label, val, val_label, test, test_label = holdout_crossvalid(df, 0.7, 0.1, 0.2,True)\n",
    "\n",
    "def non_linear_perceptron(train, train_label, val=None,val_label=None,test=None,test_label=None,alpha=0.001,iters=1000):\n",
    "\n",
    "    np.random.seed(42)\n",
    "    w = np.random.rand(1, train.shape[1])*0.01\n",
    "    b = 0\n",
    "    alpha = alpha\n",
    "    cost = []\n",
    "    for i in range(iters):\n",
    "        a = np.dot(train, w.T) + b\n",
    "        h = sigmoid(a)\n",
    "        cnt = 0\n",
    "        J = 0.5 * np.sum((h - train_label)**2, axis=0)\n",
    "        w = w - alpha * np.sum(np.dot(((h - train_label) * h * (1 - h)).T, train),axis=0)\n",
    "        b = b - alpha * np.sum(((h - train_label) * h * (1 - h)), axis=0)\n",
    "        cost.append(J)\n",
    "        if i%1==0 and i<=12:\n",
    "            _,_,accuracy=acc(np.round(h),train_label)\n",
    "            print(\"Training split accuracy for iteration\",i,\":\",accuracy*100,\"%\")\n",
    "\n",
    "            if val is not None:\n",
    "                _,_,accuracy=acc(np.round(sigmoid(np.dot(val, w.T) + b)),val_label)\n",
    "                print(\"Validation split accuracy :\",accuracy*100,\"%\")\n",
    "            print(\"\\n\")\n",
    "    if test is not None:\n",
    "        SE,SP,accuracy=acc(np.round(sigmoid(np.dot(test, w.T) + b)),test_label)\n",
    "        print(\"Test split Sensitivity and Specificity : \",SE,SP)\n",
    "        print(\"Test split Accuracy :\",accuracy*100,\"%\")\n",
    "\n",
    "\n",
    "    return cost\n",
    "\n",
    "cost = non_linear_perceptron(train, train_label, val, val_label, test,test_label)\n",
    "\n",
    "fig = plt.figure(figsize=(6, 6))\n",
    "ax = fig.add_subplot(111)\n",
    "ax.set_xlabel('Iterations', fontsize=20)\n",
    "ax.set_ylabel('Cost', fontsize=20)\n",
    "plt.plot(cost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PgRKgf22Tx9E"
   },
   "source": [
    "## Q.2 Kernel Perceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8cOji-JRT4ki",
    "outputId": "3d2ff6b2-74e1-43a9-d428-5c9191600a84"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training split Sensitivity and Specificity : 1.0 1.0\n",
      "Training split Accuracy : 100.0 % \n",
      "\n",
      "Validation split Sensitivity and Specificity : 1.0 1.0\n",
      "Validation split Accuracy : 100.0 % \n",
      "\n",
      "Test split Sensitivity and Specificity : 1.0 1.0\n",
      "Test split Accuracy : 100.0 %\n"
     ]
    }
   ],
   "source": [
    "df=pd.read_excel('/content/drive/MyDrive/Copy of data55.xlsx',header=None)\n",
    "\n",
    "train, train_label, val, val_label, test, test_label = holdout_crossvalid(df, 0.7, 0.1, 0.2,True)\n",
    "\n",
    "#Kernel Functions\n",
    "def kernel(u, v, key=\"poly\", n=5, sig=5):\n",
    "    if key == \"poly\":\n",
    "        return np.power((np.dot(u, v) + 1),n)\n",
    "    if key == \"rbf\":\n",
    "        return np.exp(-(0.5 / sig) * (np.linalg.norm((v - u)))**2)\n",
    "\n",
    "def kernel_perceptron(train, train_label, test, test_label,iters=500):\n",
    "    alpha = np.zeros((1, train.shape[0]))\n",
    "    for k in range(iters):\n",
    "        yhat = 0\n",
    "        for j in range(train.shape[0]):\n",
    "            yhat = 0\n",
    "            for i in range(train.shape[0]):\n",
    "                yhat += (alpha[0, i] * train_label[i] *\n",
    "                         kernel(train[i], train[j], \"poly\"))\n",
    "            yhat = np.sign(yhat)\n",
    "            if yhat==-1:\n",
    "                yhat=0\n",
    "            if yhat != train_label[j]:\n",
    "                alpha[0, j] += 1\n",
    "    ls = []\n",
    "    for j in range(train.shape[0]):\n",
    "        yhat = 0\n",
    "        for i in range(train.shape[0]):\n",
    "            yhat += (alpha[0, i] * train_label[i] *\n",
    "                     kernel(train[i], train[j], \"poly\"))\n",
    "        yhat = np.sign(yhat)\n",
    "        if yhat==-1:\n",
    "            yhat=0\n",
    "        ls.append(yhat)        \n",
    "    \n",
    "    SE,SP,accuracy=acc(ls,train_label)\n",
    "    print(\"Training split Sensitivity and Specificity :\",SE,SP)\n",
    "    print(\"Training split Accuracy :\",accuracy*100,\"%\",\"\\n\")\n",
    "    ls = []\n",
    "    for j in range(val.shape[0]):\n",
    "        yhat = 0\n",
    "        for i in range(train.shape[0]):\n",
    "            yhat += (alpha[0, i] * train_label[i] *\n",
    "                     kernel(train[i], val[j], \"poly\"))\n",
    "        yhat = np.sign(yhat)\n",
    "        if yhat==-1:\n",
    "            yhat=0\n",
    "        ls.append(yhat)        \n",
    "    \n",
    "    SE,SP,accuracy=acc(ls,val_label)\n",
    "    print(\"Validation split Sensitivity and Specificity :\",SE,SP)\n",
    "    print(\"Validation split Accuracy :\",accuracy*100,\"%\",\"\\n\")\n",
    "\n",
    "    ls = []\n",
    "    for j in range(test.shape[0]):\n",
    "        yhat = 0\n",
    "        for i in range(train.shape[0]):\n",
    "            yhat += (alpha[0, i] * train_label[i] *\n",
    "                     kernel(train[i], test[j], \"poly\"))\n",
    "        yhat = np.sign(yhat)\n",
    "        if yhat==-1:\n",
    "            yhat=0\n",
    "        ls.append(yhat)\n",
    "    SE,SP,accuracy=acc(ls,test_label)\n",
    "\n",
    "    print(\"Test split Sensitivity and Specificity :\",SE,SP)\n",
    "    print(\"Test split Accuracy :\",accuracy*100,\"%\")\n",
    "\n",
    "    return (alpha)\n",
    "\n",
    "alpha=kernel_perceptron(train,train_label,test,test_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ffOvO-djv0N-"
   },
   "source": [
    "## Q.3 MLP\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3mTLoJtSv0hG",
    "outputId": "0a7efc3e-7af5-4236-9ad1-e8ed1a5f47fd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1.])"
      ]
     },
     "execution_count": 5,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = scipy.io.loadmat('/content/drive/MyDrive/Copy of data5.mat')\n",
    "\n",
    "data = np.array(mat['x'])\n",
    "vec=data\n",
    "x=[]\n",
    "for i in range(vec.shape[1]-1):\n",
    "    x.append((vec[:,i]-np.mean(vec[:,i]))/np.std(vec[:,i]))\n",
    "x.append(vec[:,72])\n",
    "norm_data=np.array(x).T\n",
    "norm_data = np.insert(norm_data,72, 1,axis=1)\n",
    "\n",
    "#Pre-processing for 5-Fold cross validation\n",
    "k=5  # No. of folds\n",
    "sub_len=int(norm_data.shape[0]/5)\n",
    "sub_data=[]\n",
    "start=0\n",
    "for i in range(k):\n",
    "    sub_data.append(norm_data[start:start+sub_len,:74])\n",
    "    start+=sub_len\n",
    "sub_data=np.array(sub_data)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "train, train_label, val, val_label, test, test_label = holdout_crossvalid(data, 0.7, 0.1, 0.2,True)\n",
    "\n",
    "np.unique(train_label)  #No. of classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6JI4NxTDyIhZ"
   },
   "outputs": [],
   "source": [
    "#MLP architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dWlX3aENv0j4"
   },
   "outputs": [],
   "source": [
    "def MLP(train_X, train_Y, test_X, test_Y,val_X=None, val_Y=None,g=None, num_iterations=1000):\n",
    "    alpha = [0.00001, 0.00001, 0.00001]\n",
    "    train_X = train_X.T\n",
    "    test_X=test_X.T\n",
    "    train_Y = train_Y\n",
    "    \n",
    "    train_size = train_X.shape[1]\n",
    "\n",
    "    num_hidden1 = 70\n",
    "    num_hidden2 = 80\n",
    "\n",
    "    W1 = np.random.randn(num_hidden1, train_X.shape[0])\n",
    "    b1 = np.zeros((num_hidden1, 1))\n",
    "\n",
    "    W2 = np.random.randn(num_hidden2, num_hidden1)\n",
    "    b2 = np.zeros((num_hidden2, 1))\n",
    "\n",
    "    W3 = np.random.randn(1, num_hidden2)\n",
    "    b3 = np.zeros((1, 1))\n",
    "\n",
    "    loss = []\n",
    "    for iteration in range(num_iterations):\n",
    "\n",
    "        Z1 = np.dot(W1, train_X) + b1\n",
    "        A1 = sigmoid(Z1)\n",
    "        Z2 = np.dot(W2, A1) + b2\n",
    "        A2 = sigmoid(Z2)\n",
    "        Z3 = np.dot(W3, A2) + b3\n",
    "        Y_tilda = sigmoid(Z3).reshape(-1, 1)\n",
    "        if iteration % 100 == 0:\n",
    "            error = (np.sum(np.power(\n",
    "                (Y_tilda - train_Y), 2))) / (train_size * 6)  \n",
    "            loss.append(error)\n",
    "\n",
    "        delta_3 = (Y_tilda - train_Y).T\n",
    "        delta_2 = W3.T.dot((delta_3)) * sigmoid(A2, deriv=True)\n",
    "        delta_1 = W2.T.dot((delta_2)) * sigmoid(A1, deriv=True)\n",
    "\n",
    "        W3 = W3 - alpha[0] * np.dot(delta_3, A2.T) / 3 * train_size\n",
    "        b3 = b3 - alpha[0] * np.sum(delta_3, axis=1,\n",
    "                                    keepdims=True) / 3 * train_size\n",
    "        W2 = W2 - alpha[1] * np.dot(delta_2, A1.T) / 3 * train_size\n",
    "        b2 = b2 - alpha[1] * np.sum(delta_2, axis=1,\n",
    "                                    keepdims=True) / 3 * train_size\n",
    "        W1 = W1 - alpha[2] * np.dot(delta_1, train_X.T) / 3 * train_size\n",
    "        b1 = b1 - alpha[2] * np.sum(delta_1, axis=1,\n",
    "                                    keepdims=True) / 3 * train_size\n",
    "                                    \n",
    "    if g is not None:\n",
    "      fig = plt.figure(figsize=(6, 6))\n",
    "      ax = fig.add_subplot(111)\n",
    "      ax.set_xlabel('Iterations', fontsize=20)\n",
    "      ax.set_ylabel('Cost', fontsize=20)\n",
    "      plt.plot(loss)\n",
    "    count = 0\n",
    "    temp = np.round(Y_tilda)\n",
    "    for i in range(train_X.shape[1]):\n",
    "\n",
    "        if train_Y[i] == temp[i]:\n",
    "            count += 1\n",
    "    accuracy_train = count * 100 / train_X.shape[1]\n",
    "\n",
    "    Z1 = np.dot(W1, test_X) + b1\n",
    "    A1 = sigmoid(Z1)\n",
    "    Z2 = np.dot(W2, A1) + b2\n",
    "    A2 = sigmoid(Z2)\n",
    "    Z3 = np.dot(W3, A2) + b3\n",
    "\n",
    "    Y_tilda = sigmoid(Z3).reshape(-1, 1)\n",
    "\n",
    "    count = 0\n",
    "    temp = np.round(Y_tilda)\n",
    "    for i in range(test_X.shape[1]):\n",
    "\n",
    "        if test_Y[i] == temp[i]:\n",
    "            count += 1\n",
    "    accuracy_test = count * 100 / test_X.shape[1]\n",
    "    if val_X is not None:\n",
    "      val_X=val_X.T\n",
    "      Z1 = np.dot(W1, val_X) + b1\n",
    "      A1 = sigmoid(Z1)\n",
    "      Z2 = np.dot(W2, A1) + b2\n",
    "      A2 = sigmoid(Z2)\n",
    "      Z3 = np.dot(W3, A2) + b3\n",
    "\n",
    "      Y_tilda = sigmoid(Z3).reshape(-1, 1)\n",
    "\n",
    "      count = 0\n",
    "      temp = np.round(Y_tilda)\n",
    "      for i in range(val_X.shape[1]):\n",
    "\n",
    "          if val_Y[i] == temp[i]:\n",
    "              count += 1\n",
    "      accuracy_val = count * 100 / val_X.shape[1]\n",
    "      return accuracy_train, accuracy_test,accuracy_val\n",
    "\n",
    "\n",
    "    return accuracy_train, accuracy_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UB2jvbDyyjlg"
   },
   "outputs": [],
   "source": [
    "#Hold-out cross-validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 447
    },
    "id": "dKhXRQEv2GlN",
    "outputId": "04fc3dc0-d872-4de3-baaf-f32940b04460"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy 100.0 \n",
      " Test Accuracy 93.27146171693735 \n",
      " Validation Accuracy 91.58878504672897\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a,b,c=MLP(train, train_label, test, test_label,val, val_label,num_iterations=1000,g=1)\n",
    "print(\"Training Accuracy\",a,'\\n',\"Test Accuracy\",b,'\\n',\"Validation Accuracy\",c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ooe_Gt-wdXmg",
    "outputId": "ab3b3e99-e45f-48a6-b33d-2de703f9d706"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold 1 \n",
      "\n",
      "Accuracy: 93.473193\n",
      "\n",
      "\n",
      "Fold 2 \n",
      "\n",
      "Accuracy: 88.811189\n",
      "\n",
      "\n",
      "Fold 3 \n",
      "\n",
      "Accuracy: 93.240093\n",
      "\n",
      "\n",
      "Fold 4 \n",
      "\n",
      "Accuracy: 87.412587\n",
      "\n",
      "\n",
      "Fold 5 \n",
      "\n",
      "Accuracy: 92.307692\n",
      "\n",
      "\n",
      "Overall Accuracy : 91.04895104895105\n"
     ]
    }
   ],
   "source": [
    "#5 Fold Cross Validation\n",
    "\n",
    "accu=0\n",
    "cnt = 1\n",
    "for i in range(k):\n",
    "    \n",
    "    test_X = sub_data[i, :, :73].reshape(-1, 73)\n",
    "    test_Y = sub_data[i, :, 73].reshape(-1, 1)\n",
    "    temp = np.delete(sub_data, i, axis=0)\n",
    "    train_X= temp[:, :, :73].reshape(-1, 73)\n",
    "    train_Y = temp[:, :,73].reshape(-1, 1)\n",
    "    _,Acc=MLP(train_X, train_Y, test_X, test_Y,num_iterations=1000)\n",
    "    print(\"Fold\", cnt, \"\\n\")\n",
    "    print('Accuracy: {:f}'.format(Acc))\n",
    "    print(\"\\n\")\n",
    "    accu+=Acc\n",
    "    cnt += 1\n",
    "print(\"Overall Accuracy :\",accu/5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8Dwu1Y0dvXpV"
   },
   "source": [
    "## Q.4 RBFNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bF5VFIXRt4_J"
   },
   "outputs": [],
   "source": [
    "mat = scipy.io.loadmat('/content/drive/MyDrive/Copy of data5.mat')\n",
    "\n",
    "data = np.array(mat['x'])\n",
    "\n",
    "#Data prep for kfold\n",
    "\n",
    "vec = data\n",
    "x = []\n",
    "for i in range(vec.shape[1] - 1):\n",
    "    x.append((vec[:, i] - np.mean(vec[:, i])) / np.std(vec[:, i]))\n",
    "x.append(vec[:, 72])\n",
    "norm_data = np.array(x).T\n",
    "norm_data = np.insert(norm_data, 72, 1, axis=1)\n",
    "\n",
    "k = 5  # No. of folds\n",
    "sub_len = int(norm_data.shape[0] / 5)\n",
    "sub_data = []\n",
    "start = 0\n",
    "for i in range(k):\n",
    "    sub_data.append(norm_data[start:start + sub_len, :74])\n",
    "    start += sub_len\n",
    "sub_data = np.array(sub_data)\n",
    "\n",
    "\n",
    "#Kmeans\n",
    "def Kmeans(train, k=30, max_iter=1000):\n",
    "    k = k\n",
    "\n",
    "    def dist(x, y):\n",
    "        return (np.sum((x - y)**2, axis=-1))**0.5\n",
    "\n",
    "    points = np.random.randint(train.shape[0], size=(k))\n",
    "\n",
    "    centroids = [train[i] for i in points]\n",
    "\n",
    "    centroids = np.array(centroids)\n",
    "\n",
    "    max_iter = max_iter\n",
    "\n",
    "    for i in range(max_iter):\n",
    "        pred = [np.argmin(dist(centroids, x.reshape(1, -1))) for x in train]\n",
    "        cnt = collections.Counter(pred)\n",
    "        temp = np.zeros((centroids.shape))\n",
    "        for i, x in enumerate(pred):\n",
    "            temp[x] += train[i] / cnt[x]\n",
    "        centroids = temp\n",
    "\n",
    "    return centroids, pred\n",
    "\n",
    "\n",
    "centroids, _ = Kmeans(train, k=400, max_iter=1800)\n",
    "\n",
    "k = 400\n",
    "\n",
    "\n",
    "def dist(x, y):\n",
    "    return (np.sum((x - y)**2, axis=-1))**0.5\n",
    "\n",
    "\n",
    "dmax = -1\n",
    "for x in centroids:\n",
    "    temp = np.max(dist(x, centroids))\n",
    "    if temp > dmax:\n",
    "        dmax = temp\n",
    "\n",
    "\n",
    "def mat(train, centroids, dmax, k):\n",
    "    G = []\n",
    "    for x, y in product(train, centroids):\n",
    "        G.append(math.exp(-(k / (dmax)**2) * (dist(x, y))**2))\n",
    "\n",
    "    return G\n",
    "\n",
    "\n",
    "G = np.array(mat(train, centroids, dmax, k)).reshape(train.shape[0], k)\n",
    "\n",
    "W = np.dot(np.linalg.pinv(G), train_label)\n",
    "\n",
    "G_test = np.array(mat(test, centroids, dmax, k)).reshape(test.shape[0], k)\n",
    "\n",
    "prediction = np.dot(G_test, W)\n",
    "\n",
    "prediction = 0.5 * (np.sign(prediction - 0.5) + 1)\n",
    "\n",
    "cnt = 0\n",
    "for i in range(test_label.shape[0]):\n",
    "    if prediction[i] == test_label[i]:\n",
    "        cnt += 1\n",
    "score = cnt * 100 / test_label.shape[0]\n",
    "\n",
    "score\n",
    "\n",
    "#Confusion Matrix using pandas\n",
    "if cm == True:\n",
    "    data = {\n",
    "        'y_Actual': Y_test.ravel().tolist(),\n",
    "        'y_Predicted': prediction.ravel().tolist()\n",
    "    }\n",
    "\n",
    "    df = pd.DataFrame(data, columns=['y_Actual', 'y_Predicted'])\n",
    "    confusion_matrix = pd.crosstab(df['y_Actual'],\n",
    "                                   df['y_Predicted'],\n",
    "                                   rownames=['Actual'],\n",
    "                                   colnames=['Predicted'])\n",
    "    #print (confusion_matrix,'\\n')\n",
    "    sns.heatmap(confusion_matrix, annot=True, fmt='g')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LhGASpCBz7U8"
   },
   "outputs": [],
   "source": [
    "#Holdout cross-validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 430
    },
    "id": "X4L3BXaczxvo",
    "outputId": "635dba86-f99e-4f03-9746-5d4fd9e422ec"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of training set: 88.689288 \n",
      "\n",
      "Accuracy of validation set: 87.850467 \n",
      "\n",
      "Confusion Matrix for Test set \n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Accuracy of test set: 86.774942\n"
     ]
    }
   ],
   "source": [
    "train, train_label, val, val_label, test, test_label = holdout_crossvalid(data, 0.7, 0.1, 0.2, True)\n",
    "\n",
    "Acc=RBFNN(train, train_label, train, train_label)\n",
    "print('Accuracy of training set: {:f}'.format(Acc),'\\n')\n",
    "\n",
    "Acc=RBFNN(train, train_label, val, val_label)\n",
    "print('Accuracy of validation set: {:f}'.format(Acc),'\\n')\n",
    "\n",
    "print('Confusion Matrix for Test set','\\n')\n",
    "Acc=RBFNN(train, train_label, test, test_label,cm=True)\n",
    "print('\\n')\n",
    "print('Accuracy of test set: {:f}'.format(Acc))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "edJ_TCQwx6uO",
    "outputId": "42a8a9ea-71df-4d61-9ba7-690309b4b0cc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold 1 \n",
      "\n",
      "Accuracy: 85.314685\n",
      "\n",
      "\n",
      "Fold 2 \n",
      "\n",
      "Accuracy: 84.149184\n",
      "\n",
      "\n",
      "Fold 3 \n",
      "\n",
      "Accuracy: 90.675991\n",
      "\n",
      "\n",
      "Fold 4 \n",
      "\n",
      "Accuracy: 82.983683\n",
      "\n",
      "\n",
      "Fold 5 \n",
      "\n",
      "Accuracy: 87.645688\n",
      "\n",
      "\n",
      "Overall Accuracy : 86.15384615384616\n"
     ]
    }
   ],
   "source": [
    "#5 Fold Cross Validation\n",
    "accu=0\n",
    "cnt = 1\n",
    "for i in range(k):\n",
    "    test_X = sub_data[i, :, :73].reshape(-1, 73)\n",
    "    test_Y = sub_data[i, :, 73].reshape(-1, 1)\n",
    "    temp = np.delete(sub_data, i, axis=0)\n",
    "    train_X= temp[:, :, :73].reshape(-1, 73)\n",
    "    train_Y = temp[:, :,73].reshape(-1, 1)\n",
    "    Acc=RBFNN(train_X, train_Y, test_X, test_Y)\n",
    "    print(\"Fold\", cnt, \"\\n\")\n",
    "    print('Accuracy: {:f}'.format(Acc))\n",
    "    print(\"\\n\")\n",
    "    cnt += 1\n",
    "    accu+=Acc\n",
    "print(\"Overall Accuracy :\",accu/5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J_uInHOpx64K"
   },
   "source": [
    "## Q.5 Stacked Autoencoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 514
    },
    "id": "enxdU-5MyGgA",
    "outputId": "cf38189b-a40f-4cc5-8d5d-1df3d8b665a8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy in train set : 100.0 % \n",
      "\n",
      "Accuracy in test set : 100.0 % \n",
      "\n",
      "Accuracy in validation set : 100.0 % \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f1e1d2b97b8>]"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.io\n",
    "mat = scipy.io.loadmat('/content/drive/MyDrive/Copy of data5.mat')\n",
    "\n",
    "data = np.array(mat['x'])\n",
    "\n",
    "train, train_label, val, val_label, test, test_label = holdout_crossvalid(data, 0.7, 0.1, 0.2,True)\n",
    "\n",
    "np.unique(train_label)  #No. of classes\n",
    "\n",
    "def autoencoder(train,num_hidden1):\n",
    "    alpha = [0.00001,0.000001,0.00001]\n",
    "    num_iterations = 500\n",
    "\n",
    "    train_X=train.T\n",
    "    X=train\n",
    "    train_Y=train\n",
    "\n",
    "    num_hidden1 = num_hidden1\n",
    "    train_size=200\n",
    "    losses_data = {}\n",
    "\n",
    "\n",
    "    W1 = np.random.randn(num_hidden1,X.shape[1])\n",
    "    b1 = np.zeros((num_hidden1,1))\n",
    "    W2 = np.random.randn(X.shape[1],num_hidden1)\n",
    "    b2 = np.zeros((1,1))\n",
    "    loss = []\n",
    "    at_iteration = [] \n",
    "    for iteration in range(num_iterations):\n",
    "\n",
    "            Z1 = np.dot(W1,train_X) + b1\n",
    "            A1 = sigmoid(Z1)\n",
    "            Z2 = np.dot(W2,A1) + b2\n",
    "            Y_tilda = sigmoid(Z2).T\n",
    "            if iteration % 100 == 0:\n",
    "                    error = (np.sum(np.power((Y_tilda-train_Y),2)))/(train_size*6) # m*c*2\n",
    "                    loss.append(error)\n",
    "                    at_iteration.append(iteration)\n",
    "\n",
    "            delta_2 = (Y_tilda - train_Y).T\n",
    "            delta_1 = W2.T.dot((delta_2))*sigmoid(A1,deriv=True)\n",
    "\n",
    "            W2 = W2 - alpha[1]*np.dot(delta_2,A1.T)/3*train_size\n",
    "            b2 = b2 - alpha[1]*np.sum(delta_2,axis=1,keepdims=True)/3*train_size\n",
    "            W1 = W1 - alpha[2]*np.dot(delta_1,train_X.T)/3*train_size\n",
    "            b1 = b1 - alpha[2]*np.sum(delta_1,axis=1,keepdims=True)/3*train_size\n",
    "    iterations = np.arange(len(loss))\n",
    "    losses_data[(num_hidden1)] = loss \n",
    "    #plt.plot(iterations,loss)\n",
    "    #plt.show()\n",
    "    \n",
    "    return W1\n",
    "\n",
    "w1=autoencoder(train,64)\n",
    "z1=sigmoid(np.dot(train,w1.T))\n",
    "w2=autoencoder(z1,32)\n",
    "z2=sigmoid(np.dot(z1,w2.T))\n",
    "w3=autoencoder(z2,16)\n",
    "\n",
    "W1=w1\n",
    "W2=w2\n",
    "W3=w3\n",
    "\n",
    "alpha = [0.00001,0.000002,0.00002]\n",
    "num_iterations = 1000\n",
    "\n",
    "train_X=train.T\n",
    "X=train\n",
    "train_Y=train_label\n",
    "\n",
    "accuracy_data = []\n",
    "train_size=train.shape[0]\n",
    "losses_data = {}\n",
    "b1 = 0\n",
    "b2 = 0\n",
    "b3 = 0\n",
    "W4 = np.random.randn(1,W3.shape[0])\n",
    "b4 = np.zeros((1,1))\n",
    "\n",
    "loss = []\n",
    "at_iteration = [] \n",
    "for iteration in range(num_iterations):\n",
    "\n",
    "        Z1 = np.dot(W1,train_X) + b1\n",
    "        A1 = sigmoid(Z1)\n",
    "        Z2 = np.dot(W2,A1) + b2\n",
    "        A2 = sigmoid(Z2)\n",
    "        Z3 = np.dot(W3,A2) + b3\n",
    "        A3=sigmoid(Z3)\n",
    "        Z4= np.dot(W4,A3) + b4\n",
    "        Y_tilda = sigmoid(Z4).reshape(-1,1)\n",
    "        if iteration % 100 == 0:\n",
    "                error = (np.sum(np.power((Y_tilda-train_Y),2)))/(train_size*6) \n",
    "                loss.append(error)\n",
    "                at_iteration.append(iteration)\n",
    "\n",
    "        delta_4 = (Y_tilda - train_Y).T\n",
    "\n",
    "        delta_3 = W4.T.dot((delta_4))*sigmoid(A3,deriv=True)\n",
    "        delta_2 = W3.T.dot((delta_3))*sigmoid(A2,deriv=True)\n",
    "        delta_1 = W2.T.dot((delta_2))*sigmoid(A1,deriv=True)\n",
    "\n",
    "        W4 = W4 - alpha[0]*np.dot(delta_4,A3.T)/3*train_size\n",
    "        b4 = b4 - alpha[0]*np.sum(delta_4,axis=1,keepdims=True)/3*train_size\n",
    "        W3 = W3 - alpha[0]*np.dot(delta_3,A2.T)/3*train_size\n",
    "        b3 = b3 - alpha[0]*np.sum(delta_3,axis=1,keepdims=True)/3*train_size\n",
    "        W2 = W2 - alpha[1]*np.dot(delta_2,A1.T)/3*train_size\n",
    "        b2 = b2 - alpha[1]*np.sum(delta_2,axis=1,keepdims=True)/3*train_size\n",
    "        W1 = W1 - alpha[2]*np.dot(delta_1,train_X.T)/3*train_size\n",
    "        b1 = b1 - alpha[2]*np.sum(delta_1,axis=1,keepdims=True)/3*train_size\n",
    "\n",
    "Z1 = np.dot(W1,train_X) + b1\n",
    "A1 = sigmoid(Z1)\n",
    "Z2 = np.dot(W2,A1) + b2\n",
    "A2 = sigmoid(Z2)\n",
    "Z3 = np.dot(W3,A2) + b3\n",
    "A3=sigmoid(Z3)\n",
    "Z4= np.dot(W4,A3) + b4\n",
    "Y_tilda = sigmoid(Z4).reshape(-1,1)\n",
    "\n",
    "\n",
    "count = 0\n",
    "temp = Y_tilda\n",
    "\n",
    "for i in range(train.shape[0]):\n",
    "        if np.argmax(train_label[i]) == np.argmax(temp[i]):\n",
    "                count += 1\n",
    "\n",
    "accuracy = count*100/train.shape[0]\n",
    "print(\"Accuracy in train set :\",accuracy,\"%\",\"\\n\")\n",
    "\n",
    "Z1 = np.dot(W1,test.T) + b1\n",
    "A1 = sigmoid(Z1)\n",
    "Z2 = np.dot(W2,A1) + b2\n",
    "A2 = sigmoid(Z2)\n",
    "Z3 = np.dot(W3,A2) + b3\n",
    "A3=sigmoid(Z3)\n",
    "Z4= np.dot(W4,A3) + b4\n",
    "Y_tilda = sigmoid(Z4).reshape(-1,1)\n",
    "\n",
    "\n",
    "count = 0\n",
    "\n",
    "temp = Y_tilda\n",
    "for i in range(test.shape[0]):\n",
    "        if np.argmax(test_label[i]) == np.argmax(temp[i]):\n",
    "                count += 1\n",
    "accuracy = count*100/test.shape[0]\n",
    "print(\"Accuracy in test set :\",accuracy,\"%\",\"\\n\")\n",
    "\n",
    "\n",
    "Z1 = np.dot(W1,val.T) + b1\n",
    "A1 = sigmoid(Z1)\n",
    "Z2 = np.dot(W2,A1) + b2\n",
    "A2 = sigmoid(Z2)\n",
    "Z3 = np.dot(W3,A2) + b3\n",
    "A3=sigmoid(Z3)\n",
    "Z4= np.dot(W4,A3) + b4\n",
    "Y_tilda = sigmoid(Z4).reshape(-1,1)\n",
    "\n",
    "\n",
    "count = 0\n",
    "\n",
    "temp = Y_tilda\n",
    "for i in range(val.shape[0]):\n",
    "        if np.argmax(val_label[i]) == np.argmax(temp[i]):\n",
    "                count += 1\n",
    "accuracy = count*100/val.shape[0]\n",
    "print(\"Accuracy in validation set :\",accuracy,\"%\",\"\\n\")\n",
    "\n",
    "fig = plt.figure(figsize=(6, 6))\n",
    "ax = fig.add_subplot(111)\n",
    "ax.set_xlabel('Iterations', fontsize=20)\n",
    "ax.set_ylabel('Cost', fontsize=20)\n",
    "plt.plot(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xSWqE3E8zejh"
   },
   "source": [
    "## Q.6 ELM Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dA-qLoynyGkm",
    "outputId": "cc6781a3-6bde-4ef2-dfdb-64f49eab0e12"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Weight shape: (73, 1000)\n",
      "Fold 1 \n",
      "\n",
      "Accuracy: 100.000000\n",
      "\n",
      "\n",
      "Fold 2 \n",
      "\n",
      "Accuracy: 100.000000\n",
      "\n",
      "\n",
      "Fold 3 \n",
      "\n",
      "Accuracy: 100.000000\n",
      "\n",
      "\n",
      "Fold 4 \n",
      "\n",
      "Accuracy: 100.000000\n",
      "\n",
      "\n",
      "Fold 5 \n",
      "\n",
      "Accuracy: 100.000000\n",
      "\n",
      "\n",
      "Overall Accuracy : 100.0\n"
     ]
    }
   ],
   "source": [
    "import scipy.io\n",
    "mat = scipy.io.loadmat('/content/drive/MyDrive/Copy of data5.mat')\n",
    "\n",
    "vec = np.array(mat['x'])\n",
    "\n",
    "\n",
    "\n",
    "x=[]\n",
    "for i in range(vec.shape[1]-1):\n",
    "    x.append((vec[:,i]-np.mean(vec[:,i]))/np.std(vec[:,i]))\n",
    "x.append(vec[:,72])\n",
    "norm_data=np.array(x).T\n",
    "norm_data = np.insert(norm_data,72, 1,axis=1)\n",
    "\n",
    "k=5  # No. of folds\n",
    "sub_len=int(norm_data.shape[0]/5)\n",
    "sub_data=[]\n",
    "start=0\n",
    "for i in range(k):\n",
    "    sub_data.append(norm_data[start:start+sub_len,:74])\n",
    "    start+=sub_len\n",
    "sub_data=np.array(sub_data)\n",
    "cnt = 1\n",
    "\n",
    "\n",
    "\n",
    "INPUT_LENGHT = train.shape[1]  +1\n",
    "HIDDEN_UNITS = 1000\n",
    "\n",
    "Win = np.random.normal(size=[INPUT_LENGHT, HIDDEN_UNITS])\n",
    "print('Input Weight shape: {shape}'.format(shape=Win.shape))\n",
    "\n",
    "\n",
    "def gaussian(x):\n",
    "    return np.exp(-(x))\n",
    "def input_to_hidden(x,o=\"g\"):\n",
    "    a = np.dot(x, Win)\n",
    "    if o==\"g\":\n",
    "        a=gaussian(a)\n",
    "    else:\n",
    "        a = np.tanh(a) \n",
    "    return a\n",
    "\n",
    "def predict(x):\n",
    "    x = input_to_hidden(x)\n",
    "    y = np.dot(x, Wout)\n",
    "    return y\n",
    "\n",
    "def acc(h,test_output):\n",
    "    TN = 0\n",
    "    TP = 0\n",
    "    FN = 0\n",
    "    FP = 0\n",
    "    for i in range(test_output.shape[0]):\n",
    "        if (h[i] == test_output[i]) & (test_output[i] == 0):\n",
    "            TN += 1\n",
    "        elif (h[i] == test_output[i]) & (test_output[i] == 1):\n",
    "            TP += 1\n",
    "        elif (h[i] == 0) & (test_output[i] == 1):\n",
    "            FN += 1\n",
    "        elif (h[i] == 1) & (test_output[i] == 0):\n",
    "            FP += 1\n",
    "\n",
    "    SE=TP/(TP+FN)\n",
    "    SP=TN/(TN+FP)\n",
    "    Acc=(TP+TN)/(TP+FN+TN+FP)\n",
    "    return TP,FN,SE*100\n",
    "\n",
    "acc=0\n",
    "for i in range(k):\n",
    "    start = 0\n",
    "    test_data = sub_data[i, :, :73].reshape(-1, 73)\n",
    "    test_label = sub_data[i, :, 73].reshape(-1, 1)\n",
    "    temp = np.delete(sub_data, i, axis=0)\n",
    "    train_data = temp[:, :, :73].reshape(-1, 73)\n",
    "    train_label = temp[:, :,73].reshape(-1, 1)\n",
    "\n",
    "    X = input_to_hidden(train_data)\n",
    "    Xt = np.transpose(X)\n",
    "    Wout = np.dot(np.linalg.inv(np.dot(Xt, X)), np.dot(Xt, train_label))\n",
    "    y = predict(test_data)\n",
    "    correct = 0\n",
    "    total = y.shape[0]\n",
    "    for i in range(total):\n",
    "        predicted = np.argmax(y[i])\n",
    "        test = np.argmax(test_label[i])\n",
    "        correct = correct + (1 if predicted == test else 0)\n",
    "    print(\"Fold\", cnt, \"\\n\")\n",
    "    print('Accuracy: {:f}'.format(correct*100/total))\n",
    "    print(\"\\n\")\n",
    "    acc+=correct*100/total\n",
    "    cnt += 1\n",
    "print(\"Overall Accuracy :\",acc/5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9_4awa2c3Hmu"
   },
   "source": [
    "## Q.7 ELM-Autoencoders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3jfWw0-nyGnG",
    "outputId": "a55d01f0-7b61-4750-e6ce-ec7c81587660"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Train set: 100.000000 %\n",
      "Accuracy Test set: 100.000000 %\n",
      "Accuracy Validation set: 100.000000 %\n"
     ]
    }
   ],
   "source": [
    "import scipy.io\n",
    "mat = scipy.io.loadmat('/content/drive/MyDrive/Copy of data5.mat')\n",
    "\n",
    "data = np.array(mat['x'])\n",
    "\n",
    "train, train_label, val, val_label, test, test_label = holdout_crossvalid(data, 0.7, 0.1, 0.2,True)\n",
    "\n",
    "np.unique(train_label)  #No. of classes\n",
    "\n",
    "INPUT_LENGHT = train.shape[1] \n",
    "HIDDEN_UNITS = 1000\n",
    "\n",
    "Win = np.random.rand(INPUT_LENGHT, HIDDEN_UNITS)\n",
    "\n",
    "from numpy import linalg\n",
    "def gaussian(x):\n",
    "    return np.exp(-numpy.linalg.norm(x,order=2))\n",
    "\n",
    "def input_to_hidden(x,Win,o=\"n\"):\n",
    "    a = np.dot(x, Win)\n",
    "    if o==\"g\":\n",
    "        a=gaussian(a)\n",
    "    else:\n",
    "        a = np.tanh(a) \n",
    "    return a\n",
    "\n",
    "def predict(x,Wout):\n",
    "    x = input_to_hidden(x,Win)\n",
    "    y = np.dot(x, w)\n",
    "    return y\n",
    "\n",
    "X = input_to_hidden(train,Win)\n",
    "Xt = np.transpose(X)\n",
    "Wout = np.dot(np.linalg.inv(np.dot(Xt, X)), np.dot(Xt, train))\n",
    "\n",
    "Win = np.random.rand(INPUT_LENGHT, HIDDEN_UNITS)\n",
    "h1= input_to_hidden(train,Wout.T)\n",
    "X = input_to_hidden(h1,Win.T)\n",
    "Xt=np.transpose(X)\n",
    "Wout_ = np.dot(np.linalg.inv(np.dot(Xt, X)), np.dot(Xt, h1))\n",
    "\n",
    "\n",
    "\n",
    "h2= input_to_hidden(h1,Wout_.T)\n",
    "X = input_to_hidden(h2,Win)\n",
    "Xt=np.transpose(X)\n",
    "Wout1 = np.dot(np.linalg.inv(np.dot(Xt, X)), np.dot(Xt, h2))\n",
    "\n",
    "X = input_to_hidden(h2,Wout_)\n",
    "Xt = np.transpose(X)\n",
    "Wout2 = np.dot(np.linalg.inv(np.dot(Xt, X)), np.dot(Xt, train_label))\n",
    "\n",
    "x=input_to_hidden(train,Wout.T)\n",
    "x_=input_to_hidden(x,Wout_.T)\n",
    "y_=input_to_hidden(x_,Wout1.T)\n",
    "y=input_to_hidden(y_,Wout2)\n",
    "\n",
    "correct = 0\n",
    "total = y.shape[0]\n",
    "for i in range(total):\n",
    "    predicted = np.argmax(y[i])\n",
    "    test_ = np.argmax(train_label[i])\n",
    "    correct = correct + (1 if predicted == test_ else 0)\n",
    "    \n",
    "print('Accuracy Train set: {:f}'.format(correct*100/total),\"%\")\n",
    "\n",
    "x=input_to_hidden(test,Wout.T)\n",
    "x_=input_to_hidden(x,Wout_.T)\n",
    "y_=input_to_hidden(x_,Wout1.T)\n",
    "y=input_to_hidden(y_,Wout2)\n",
    "\n",
    "correct = 0\n",
    "total = y.shape[0]\n",
    "for i in range(total):\n",
    "    predicted = np.argmax(y[i])\n",
    "    test_ = np.argmax(test_label[i])\n",
    "    correct = correct + (1 if predicted == test_ else 0)\n",
    "    \n",
    "print('Accuracy Test set: {:f}'.format(correct*100/total),\"%\")\n",
    "\n",
    "x=input_to_hidden(val,Wout.T)\n",
    "x_=input_to_hidden(x,Wout_.T)\n",
    "y_=input_to_hidden(x_,Wout1.T)\n",
    "y=input_to_hidden(y_,Wout2)\n",
    "\n",
    "correct = 0\n",
    "total = y.shape[0]\n",
    "for i in range(total):\n",
    "    predicted = np.argmax(y[i])\n",
    "    test_ = np.argmax(val_label[i])\n",
    "    correct = correct + (1 if predicted == test_ else 0)\n",
    "    \n",
    "print('Accuracy Validation set: {:f}'.format(correct*100/total),\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HCMc9-M83eYB"
   },
   "source": [
    "## Q.8 SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cfJMF4jh3emk"
   },
   "outputs": [],
   "source": [
    "import scipy.io\n",
    "import random as rand\n",
    "import math\n",
    "mat = scipy.io.loadmat('/content/drive/MyDrive/Copy of data5.mat')\n",
    "\n",
    "data = np.array(mat['x'])\n",
    "\n",
    "train, train_label, val, val_label, test, test_label = holdout_crossvalid(data, 0.7, 0.1, 0.2,True)\n",
    "\n",
    "np.unique(train_label)  #No. of classes\n",
    "\n",
    "def GaussianMatrix(X,sigma):\n",
    "    row,col=X.shape\n",
    "    GassMatrix=np.zeros(shape=(row,row))\n",
    "    X=np.asarray(X)\n",
    "    i=0\n",
    "    for v_i in X:\n",
    "        j=0\n",
    "        for v_j in X:\n",
    "            GassMatrix[i,j]=Gaussian(v_i.T,v_j.T,sigma)\n",
    "            j+=1\n",
    "        i+=1\n",
    "    return GassMatrix\n",
    "\n",
    "def Gaussian(x,z,sigma):\n",
    "    return np.exp((-(np.linalg.norm(x-z)**2))/(2*sigma**2))\n",
    "\n",
    "\n",
    "\n",
    "z=np.zeros((train_label.shape[0],1))\n",
    "for i in range(train_label.shape[0]):\n",
    "    if train_label[i]==0:\n",
    "        z[i]=-1\n",
    "    else:\n",
    "        z[i]=1\n",
    "X=train\n",
    "Y=z\n",
    "def SVM(X,Y,test,test_label,K,C,maxiter,val=None, val_label=None) :\n",
    "  b=0\n",
    "  itr=0\n",
    "  m=train.shape[0]\n",
    "  E=np.zeros((X.shape[0],1))\n",
    "  mus=np.zeros((X.shape[0],1))\n",
    "  bound=0.0001\n",
    "  L=0\n",
    "  H=0\n",
    "  while (itr<maxiter):\n",
    "      rand.seed(0)\n",
    "      cnt=0\n",
    "      for i in range(X.shape[0]):\n",
    "          E[i] = b + np.sum((mus*Y)*K[:,i]) - Y[i]\n",
    "          if ((Y[i] * E[i] < -bound and mus[i] < C) or (Y[i] * E[i] > bound and mus[i] > 0)):\n",
    "              \n",
    "              j = int(rand.uniform(0,m))\n",
    "              while j == i:\n",
    "                 \n",
    "                  j =(int(rand.uniform(0,m)))\n",
    "              \n",
    "              E[j] = b + np.sum((mus*Y)*K[:,j].reshape(-1,1)) - Y[j]\n",
    "              mu_i_old = mus[i]\n",
    "              mu_j_old = mus[j]\n",
    "              if (Y[i] == Y[j]):\n",
    "                  L = max(0, mus[i] + mus[j] - C)\n",
    "                  H = min(C, mus[i] + mus[j])\n",
    "              else:\n",
    "                  L = max(0, -mus[i] + mus[j])\n",
    "                  H = min(C, C - mus[i] + mus[j])\n",
    "\n",
    "              if (L == H):\n",
    "                  continue\n",
    "\n",
    "              eta = 2 * K[i, j] - K[i, i] - K[j, j]\n",
    "              if (eta >= 0):\n",
    "                  continue\n",
    "              \n",
    "              mus[j] = mus[j] - (Y[j] * (E[i] - E[j])) / eta\n",
    "              mus[j] = min(H, mus[j])\n",
    "              mus[j] = max(L, mus[j])\n",
    "              if (abs(mus[j] - mu_j_old) < bound):\n",
    "                  mus[j] = mu_j_old\n",
    "                  continue\n",
    "              mus[i] = mus[i] + (Y[i] * Y[j] * (-mus[j] + mus_j_old))\n",
    "              b1 = b - E[i] - Y[i] * (mus[i] - mu_i_old) * K[i, j].H - Y[j] * (mus[j] - mus[i]) * K[i, j].H\n",
    "              b2 = b - E[j] - Y[i] * (mus[i] - mu_i_old) * K[i, j].H - Y[j] * (mus[j] - mus[i]) * K[j, j].H\n",
    "              if (mus[i] > 0 and mus[i] < C):\n",
    "                  b = b1\n",
    "              elif (mus[j] > 0 and mus[j] < C):\n",
    "                  b = b2\n",
    "              else:\n",
    "                  b = (b1 + b2) / 2\n",
    "\n",
    "              cnt += 1\n",
    "      if(cnt==0):\n",
    "          itr+=1\n",
    "      else:\n",
    "          itr=0\n",
    "  Xsvm=[]\n",
    "  Ysvm=[]\n",
    "  mus_=[]\n",
    "  for i in range(mus.shape[0]):\n",
    "      if mus[i]>0:\n",
    "          Ysvm.append(Y[ i])\n",
    "          Xsvm.append(X[i,:])\n",
    "          mus_.append(mus[i])\n",
    "  Xsvm=np.array(Xsvm)\n",
    "  Ysvm=np.array(Ysvm)\n",
    "  mus_=np.array(mus_)\n",
    "\n",
    "  w=np.dot((mus_*Ysvm).T,Xsvm).T\n",
    "\n",
    "  p=np.dot(test,w)+b\n",
    "  q=[]\n",
    "  for i in range(p.shape[0]):\n",
    "      if p[i]>0:\n",
    "          q.append(1)\n",
    "      else:\n",
    "          q.append(0)\n",
    "\n",
    "  t=0\n",
    "  for i in range(test_label.shape[0]):\n",
    "      if test_label[i]==q[i]:\n",
    "          t+=1\n",
    "\n",
    "  p=np.dot(X,w)+b\n",
    "  q=[]\n",
    "  for i in range(p.shape[0]):\n",
    "      if p[i]>0:\n",
    "          q.append(1)\n",
    "      else:\n",
    "          q.append(-1)\n",
    "\n",
    "  l=0\n",
    "  for i in range(Y.shape[0]):\n",
    "      if Y[i]==q[i]:\n",
    "          l+=1\n",
    "\n",
    "  if val is not None:\n",
    "    p=np.dot(val,w)+b\n",
    "    q=[]\n",
    "    for i in range(p.shape[0]):\n",
    "        if p[i]>0:\n",
    "            q.append(1)\n",
    "        else:\n",
    "            q.append(0)\n",
    "    o=0\n",
    "    for i in range(val_label.shape[0]):\n",
    "        if val_label[i]==q[i]:\n",
    "            o+=1       \n",
    "    return t*100/test_label.shape[0],o*100/val_label.shape[0],l*100/X.shape[0]\n",
    "  return t*100/test_label.shape[0],l*100/X.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IzpnrJCY4ehU"
   },
   "outputs": [],
   "source": [
    "class_acc1,class_acc2,class_acc3=SVM(X,Y,test,test_label,K=np.dot(X,X.T),C=5,maxiter=30,val=val,val_label=val_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "F8fzUkkS5CKu",
    "outputId": "af585ed7-9d12-4fec-99f5-28b8a1c064f1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy : 84.4311377245509 %\n",
      "Validation Accuracy : 85.04672897196262 %\n",
      "Test Accuracy : 85.61484918793504 %\n"
     ]
    }
   ],
   "source": [
    "print(\"Training Accuracy :\",class_acc3,\"%\")\n",
    "print(\"Validation Accuracy :\",class_acc2,\"%\")\n",
    "print(\"Test Accuracy :\",class_acc1,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NXKzu8AC4Qhu"
   },
   "source": [
    "##### Multiclass classification using SVM and 1 vs all multiclass classification technique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RcokwFLDWzVl"
   },
   "outputs": [],
   "source": [
    "#Dataset used is from Assignment 1\n",
    "df=pd.read_excel('/content/drive/MyDrive/data4.xlsx',header=None)\n",
    "vec=df.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zGmlcc7VWv3Y"
   },
   "outputs": [],
   "source": [
    "np.random.seed(42) \n",
    "np.random.shuffle(vec)\n",
    "\n",
    "total=vec.shape[0]\n",
    "train_len=int(0.7*total)\n",
    "train_features=vec[:train_len,:7]\n",
    "test_features=vec[train_len:,:7]\n",
    "train_output=vec[:train_len,7].reshape(-1,1)\n",
    "test_output=vec[train_len:,7].reshape(-1,1)\n",
    "\n",
    "x=[]\n",
    "mean=[]\n",
    "std=[]\n",
    "for i in range(train_features.shape[1]):\n",
    "    x.append((train_features[:,i]-np.mean(train_features[:,i]))/np.std(train_features[:,i]))\n",
    "    mean.append(np.mean(train_features[:,i]))\n",
    "    std.append(np.std(train_features[:,i]))\n",
    "\n",
    "\n",
    "train_features=np.array(x)\n",
    "train = np.append(train_features.T,np.ones([train_features.shape[1], 1]),axis=1)\n",
    "\n",
    "x=[]\n",
    "for i in range(test_features.shape[1]):\n",
    "    x.append((test_features[:,i]-mean[i])/std[i])\n",
    "    \n",
    "test_features=np.array(x)\n",
    "test = np.append(test_features.T,np.ones([test_features.shape[1], 1]),axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XBLycn1T3erH"
   },
   "outputs": [],
   "source": [
    "#Preparing data for 1 vs all multiclass classification\n",
    "\n",
    "train_label=np.zeros(shape=(train_output.shape[0],3))\n",
    "for i in range(3):\n",
    "    for j in range(train_output.shape[0]):\n",
    "        if train_output[j]==i+1:\n",
    "            train_label[j][i]=1\n",
    "            \n",
    "        else:\n",
    "            train_label[j][i]=-1\n",
    "\n",
    "test_label=np.zeros(shape=(test_output.shape[0],3))\n",
    "for i in range(3):\n",
    "    for j in range(test_output.shape[0]):\n",
    "        if test_output[j]==i+1:\n",
    "            test_label[j][i]=1\n",
    "            \n",
    "        else:\n",
    "            test_label[j][i]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Q5lqds0Iwagk"
   },
   "outputs": [],
   "source": [
    "_,class1_acc=SVM(train,train_label[:,0].reshape(-1,1),test,test_label[:,0].reshape(-1,1),K=np.dot(1+train,train.T)**3,C=0.1,maxiter=100)\n",
    "_,class2_acc=SVM(train,train_label[:,1].reshape(-1,1),test,test_label[:,1].reshape(-1,1),K=np.dot(train,train.T),C=0.01,maxiter=100)\n",
    "_,class3_acc=SVM(train,train_label[:,2].reshape(-1,1),test,test_label[:,2].reshape(-1,1),K=np.dot(train,train.T),C=0.1,maxiter=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OgIoTacmuBH5",
    "outputId": "a490577f-fef4-4d92-f08a-00a74a08de59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Class1 Class2 Class 3 -  100.0 % 63.80952380952381 % 88.5714 %\n",
      "Overall Accuracy 84.127 %\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy Class1 Class2 Class 3 - \",round(class1_acc,4),'%',class2_acc,'%',round(class3_acc,4),'%')\n",
    "print(\"Overall Accuracy\",round((class1_acc+class2_acc+class3_acc)/3,4),'%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tD4eXvFfKUr8"
   },
   "source": [
    "## Q.9 1D CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hf4kN6KAXKxF"
   },
   "outputs": [],
   "source": [
    "mat = scipy.io.loadmat('/content/drive/MyDrive/Copy of input.mat')\n",
    "mat_ = scipy.io.loadmat('/content/drive/MyDrive/Copy of class_label.mat')\n",
    "data = np.array(mat['x']).T\n",
    "label=np.array(mat_['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hPOZxyAmXL56"
   },
   "outputs": [],
   "source": [
    "temp=[]\n",
    "for i in range(data.shape[0]):\n",
    "    temp.append(data[i][0].T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vkavNM30XL-0"
   },
   "outputs": [],
   "source": [
    "train=np.array(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z2zoHFVKYsO1"
   },
   "outputs": [],
   "source": [
    "num_classes = 7\n",
    "input_shape = train.T.shape[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tdwZya--Bfga"
   },
   "outputs": [],
   "source": [
    "#Holdout cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oSdZhUdLc1iA"
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(train, label, test_size=0.2, random_state=1)\n",
    "y_train = keras.utils.to_categorical(np.asarray(y_train)-1)\n",
    "y_test=keras.utils.to_categorical(np.asarray(y_test)-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "J1tgTmZ8vxrW"
   },
   "outputs": [],
   "source": [
    "#CNN Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XMvhzgP5Yt2H",
    "outputId": "beb111c1-6446-4131-f4d4-b664e2b039b9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv1d (Conv1D)              (None, 794, 20)           1700      \n",
      "_________________________________________________________________\n",
      "max_pooling1d (MaxPooling1D) (None, 264, 20)           0         \n",
      "_________________________________________________________________\n",
      "conv1d_1 (Conv1D)            (None, 258, 60)           8460      \n",
      "_________________________________________________________________\n",
      "max_pooling1d_1 (MaxPooling1 (None, 86, 60)            0         \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 86, 60)            0         \n",
      "_________________________________________________________________\n",
      "conv1d_2 (Conv1D)            (None, 80, 120)           50520     \n",
      "_________________________________________________________________\n",
      "conv1d_3 (Conv1D)            (None, 74, 120)           100920    \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 8880)              0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 2000)              17762000  \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 700)               1400700   \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 500)               350500    \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 7)                 3507      \n",
      "=================================================================\n",
      "Total params: 19,678,307\n",
      "Trainable params: 19,678,307\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = keras.Sequential(\n",
    "    [\n",
    "        layers.Conv1D(20, kernel_size=7, input_shape=(800,12),activation=\"relu\"),\n",
    "        layers.MaxPooling1D(pool_size=3,strides=3),\n",
    "        layers.Conv1D(60, kernel_size=7,activation=\"relu\"),\n",
    "        layers.MaxPooling1D(pool_size=3,strides=3),\n",
    "        layers.Dropout(.7),\n",
    "        layers.Conv1D(120, kernel_size=7),\n",
    "        layers.Conv1D(120, kernel_size=7),\n",
    "        layers.Flatten(),\n",
    "        layers.Dense(2000, activation=\"relu\"),\n",
    "        layers.Dense(700),\n",
    "        layers.Dense(500),\n",
    "        layers.Dense(num_classes, activation=\"sigmoid\"),\n",
    "    ]\n",
    ")\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "irT-peBsYzOz",
    "outputId": "67a3ed22-1a00-482a-890c-04d8fc8eb2bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/8\n",
      "24/24 [==============================] - 2s 74ms/step - loss: 0.9682 - accuracy: 0.6313 - val_loss: 0.0519 - val_accuracy: 0.9825\n",
      "Epoch 2/8\n",
      "24/24 [==============================] - 1s 49ms/step - loss: 0.0679 - accuracy: 0.9791 - val_loss: 0.0049 - val_accuracy: 1.0000\n",
      "Epoch 3/8\n",
      "24/24 [==============================] - 1s 49ms/step - loss: 0.0235 - accuracy: 0.9943 - val_loss: 4.4610e-04 - val_accuracy: 1.0000\n",
      "Epoch 4/8\n",
      "24/24 [==============================] - 1s 49ms/step - loss: 0.0105 - accuracy: 0.9971 - val_loss: 5.9081e-05 - val_accuracy: 1.0000\n",
      "Epoch 5/8\n",
      "24/24 [==============================] - 1s 49ms/step - loss: 0.0100 - accuracy: 0.9978 - val_loss: 2.3375e-04 - val_accuracy: 1.0000\n",
      "Epoch 6/8\n",
      "24/24 [==============================] - 1s 48ms/step - loss: 0.0107 - accuracy: 0.9973 - val_loss: 3.1451e-04 - val_accuracy: 1.0000\n",
      "Epoch 7/8\n",
      "24/24 [==============================] - 1s 49ms/step - loss: 0.0086 - accuracy: 0.9982 - val_loss: 5.7699e-05 - val_accuracy: 1.0000\n",
      "Epoch 8/8\n",
      "24/24 [==============================] - 1s 48ms/step - loss: 0.0157 - accuracy: 0.9961 - val_loss: 1.0656e-04 - val_accuracy: 1.0000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f1e1017f588>"
      ]
     },
     "execution_count": 34,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_size = 512\n",
    "epochs = 8\n",
    "\n",
    "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
    "\n",
    "model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.125)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KQwigXy5ahVO",
    "outputId": "deff8aca-18f3-4a1b-fb25-5ea723bc57be"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 8.370493742404506e-05\n",
      "Test accuracy: 100.0 %\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(X_test, y_test, verbose=0)\n",
    "print(\"Test loss:\", score[0])\n",
    "print(\"Test accuracy:\", score[1]*100,\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-28T07:33:31.248373Z",
     "start_time": "2020-09-28T07:33:30.351890Z"
    },
    "id": "dkJG-jxno1jp"
   },
   "outputs": [],
   "source": [
    "predictions = model.predict(X_test)\n",
    "predictions = predictions.argmax( axis=1)\n",
    "#predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-28T07:33:31.263644Z",
     "start_time": "2020-09-28T07:33:31.250369Z"
    },
    "id": "6K6lvRe3o1jq"
   },
   "outputs": [],
   "source": [
    "cm = confusion_matrix(y_test.argmax(axis=1), predictions)\n",
    "cm = cm/cm.sum(axis=1)[:, np.newaxis]\n",
    "l=np.unique(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-28T07:33:31.751326Z",
     "start_time": "2020-09-28T07:33:31.265233Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 627
    },
    "id": "wDqYxikno1js",
    "outputId": "1292c09e-e5fb-4c64-b3f8-0f3ff38a4416"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(69.0, 0.5, 'True')"
      ]
     },
     "execution_count": 38,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10,10))  \n",
    "sns.heatmap(\n",
    "    cm, annot=True,\n",
    "    xticklabels=set(l),\n",
    "    yticklabels=set(l))\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"True\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bW6zEXO8KG7q"
   },
   "source": [
    "## Q.10 2D CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "86jY8XzabYW8"
   },
   "outputs": [],
   "source": [
    "# import zipfile\n",
    "# with zipfile.ZipFile(\"/content/drive/MyDrive/Copy of class1_images.zip\", 'r') as zip_ref:\n",
    "#     zip_ref.extractall(\"/content/drive/MyDrive\")\n",
    "# with zipfile.ZipFile(\"/content/drive/MyDrive/Copy of class2_images.zip\", 'r') as zip_ref:\n",
    "#     zip_ref.extractall(\"/content/drive/MyDrive\")\n",
    "# with zipfile.ZipFile(\"/content/drive/MyDrive/Copy of class3_images.zip\", 'r') as zip_ref:\n",
    "#     zip_ref.extractall(\"/content/drive/MyDrive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iHiQrC8vvTnx"
   },
   "outputs": [],
   "source": [
    "#Pre-processing images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8tiCGdYghodz"
   },
   "outputs": [],
   "source": [
    "image_list = []\n",
    "label=[]\n",
    "for filename in glob.glob('/content/drive/MyDrive/class1_images/*.png'): \n",
    "    im=Image.open(filename)\n",
    "    im=im.resize((28, 28))\n",
    "    data = np.asarray(im)/255\n",
    "    image_list.append(data)\n",
    "    label.append(1)\n",
    "class1=np.array(image_list)\n",
    "\n",
    "image_list = []\n",
    "for filename in glob.glob('/content/drive/MyDrive/class2_images/*.png'): \n",
    "    im=Image.open(filename)\n",
    "    im=im.resize((28, 28))\n",
    "    data = np.asarray(im)/255\n",
    "    image_list.append(data)\n",
    "    label.append(2)\n",
    "class2=np.array(image_list)\n",
    "\n",
    "image_list = []\n",
    "for filename in glob.glob('/content/drive/MyDrive/class3_images/*.png'): \n",
    "    im=Image.open(filename)\n",
    "    im=im.resize((28, 28))\n",
    "    data = np.asarray(im)/255\n",
    "    image_list.append(data)\n",
    "    label.append(3)\n",
    "class3=np.array(image_list)\n",
    "label=np.array(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "f9uBdNIpvK4C"
   },
   "outputs": [],
   "source": [
    "#CNN Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "M82kWNTZAenF"
   },
   "outputs": [],
   "source": [
    "def create_model():\n",
    "  model = Sequential()\n",
    "\n",
    "  model.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', activation ='relu', input_shape = (28,28,3)))\n",
    "  model.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', activation ='relu'))\n",
    "  model.add(MaxPool2D(pool_size=(2,2)))\n",
    "  model.add(Dropout(0.5))\n",
    "\n",
    "\n",
    "  model.add(Conv2D(filters = 128, kernel_size = (3,3),padding = 'Same',  activation ='relu'))\n",
    "  model.add(Conv2D(filters = 128, kernel_size = (3,3),padding = 'Same',  activation ='relu'))\n",
    "  model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))\n",
    "  model.add(Dropout(0.5))\n",
    "\n",
    "\n",
    "  model.add(Flatten())\n",
    "  model.add(Dense(256, activation = \"relu\"))\n",
    "  model.add(Dropout(0.5))\n",
    "  model.add(Dense(128, activation = \"relu\"))\n",
    "  model.add(Dense(64, activation = \"relu\"))\n",
    "  model.add(Dense(32, activation = \"relu\"))\n",
    "  model.add(Dense(3, activation = \"softmax\"))\n",
    "  return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RME39ldcur91"
   },
   "outputs": [],
   "source": [
    "#Hold-out cross-validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "38FgPJtLjXxc"
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(np.vstack((class1,class2,class3)), label, test_size=0.2, random_state=1)\n",
    "y_train = keras.utils.to_categorical(np.asarray(y_train)-1)\n",
    "y_test=keras.utils.to_categorical(np.asarray(y_test)-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7DS2PuH1smtn",
    "outputId": "0569aedd-008c-45c7-a347-c2aad6c78118"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "8/8 [==============================] - 0s 50ms/step - loss: 1.1107 - accuracy: 0.3472 - val_loss: 1.0955 - val_accuracy: 0.3750\n",
      "Epoch 2/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0993 - accuracy: 0.3393 - val_loss: 1.0975 - val_accuracy: 0.3750\n",
      "Epoch 3/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0983 - accuracy: 0.3552 - val_loss: 1.0978 - val_accuracy: 0.3750\n",
      "Epoch 4/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0971 - accuracy: 0.3690 - val_loss: 1.0972 - val_accuracy: 0.3750\n",
      "Epoch 5/100\n",
      "8/8 [==============================] - 0s 10ms/step - loss: 1.0975 - accuracy: 0.3611 - val_loss: 1.0960 - val_accuracy: 0.3750\n",
      "Epoch 6/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0993 - accuracy: 0.3472 - val_loss: 1.0981 - val_accuracy: 0.3750\n",
      "Epoch 7/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0979 - accuracy: 0.3433 - val_loss: 1.0981 - val_accuracy: 0.3750\n",
      "Epoch 8/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0985 - accuracy: 0.3413 - val_loss: 1.0978 - val_accuracy: 0.3750\n",
      "Epoch 9/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0970 - accuracy: 0.3571 - val_loss: 1.0970 - val_accuracy: 0.3750\n",
      "Epoch 10/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0988 - accuracy: 0.3472 - val_loss: 1.0971 - val_accuracy: 0.3750\n",
      "Epoch 11/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 1.0973 - accuracy: 0.3512 - val_loss: 1.0974 - val_accuracy: 0.3750\n",
      "Epoch 12/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0981 - accuracy: 0.3532 - val_loss: 1.0973 - val_accuracy: 0.3750\n",
      "Epoch 13/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0975 - accuracy: 0.3552 - val_loss: 1.0972 - val_accuracy: 0.3750\n",
      "Epoch 14/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0978 - accuracy: 0.3552 - val_loss: 1.0978 - val_accuracy: 0.3750\n",
      "Epoch 15/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0972 - accuracy: 0.3552 - val_loss: 1.0972 - val_accuracy: 0.3750\n",
      "Epoch 16/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0969 - accuracy: 0.3552 - val_loss: 1.0973 - val_accuracy: 0.3750\n",
      "Epoch 17/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0974 - accuracy: 0.3532 - val_loss: 1.0974 - val_accuracy: 0.3750\n",
      "Epoch 18/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0960 - accuracy: 0.3512 - val_loss: 1.0971 - val_accuracy: 0.3750\n",
      "Epoch 19/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0990 - accuracy: 0.3552 - val_loss: 1.0965 - val_accuracy: 0.3750\n",
      "Epoch 20/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0991 - accuracy: 0.3611 - val_loss: 1.0972 - val_accuracy: 0.3750\n",
      "Epoch 21/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0986 - accuracy: 0.3472 - val_loss: 1.0972 - val_accuracy: 0.3750\n",
      "Epoch 22/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0973 - accuracy: 0.3552 - val_loss: 1.0974 - val_accuracy: 0.3750\n",
      "Epoch 23/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0974 - accuracy: 0.3552 - val_loss: 1.0972 - val_accuracy: 0.3750\n",
      "Epoch 24/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0976 - accuracy: 0.3552 - val_loss: 1.0971 - val_accuracy: 0.3750\n",
      "Epoch 25/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0973 - accuracy: 0.3552 - val_loss: 1.0969 - val_accuracy: 0.3750\n",
      "Epoch 26/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0971 - accuracy: 0.3552 - val_loss: 1.0966 - val_accuracy: 0.3750\n",
      "Epoch 27/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0977 - accuracy: 0.3552 - val_loss: 1.0965 - val_accuracy: 0.3750\n",
      "Epoch 28/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0963 - accuracy: 0.3552 - val_loss: 1.0968 - val_accuracy: 0.3750\n",
      "Epoch 29/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0975 - accuracy: 0.3552 - val_loss: 1.0963 - val_accuracy: 0.3750\n",
      "Epoch 30/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0972 - accuracy: 0.3552 - val_loss: 1.0962 - val_accuracy: 0.3750\n",
      "Epoch 31/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0971 - accuracy: 0.3591 - val_loss: 1.0966 - val_accuracy: 0.3750\n",
      "Epoch 32/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0980 - accuracy: 0.3611 - val_loss: 1.0968 - val_accuracy: 0.3750\n",
      "Epoch 33/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0963 - accuracy: 0.3552 - val_loss: 1.0955 - val_accuracy: 0.3750\n",
      "Epoch 34/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0975 - accuracy: 0.3571 - val_loss: 1.0923 - val_accuracy: 0.3750\n",
      "Epoch 35/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0960 - accuracy: 0.3591 - val_loss: 1.0912 - val_accuracy: 0.3750\n",
      "Epoch 36/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0910 - accuracy: 0.3571 - val_loss: 1.0656 - val_accuracy: 0.3750\n",
      "Epoch 37/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 1.0557 - accuracy: 0.4266 - val_loss: 0.9083 - val_accuracy: 0.6111\n",
      "Epoch 38/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.9449 - accuracy: 0.5218 - val_loss: 0.6655 - val_accuracy: 0.7083\n",
      "Epoch 39/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.7337 - accuracy: 0.6131 - val_loss: 0.5793 - val_accuracy: 0.6944\n",
      "Epoch 40/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.7145 - accuracy: 0.6389 - val_loss: 0.5141 - val_accuracy: 0.7222\n",
      "Epoch 41/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.6336 - accuracy: 0.6786 - val_loss: 0.5559 - val_accuracy: 0.6250\n",
      "Epoch 42/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.6023 - accuracy: 0.6865 - val_loss: 0.4937 - val_accuracy: 0.7361\n",
      "Epoch 43/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.6077 - accuracy: 0.6984 - val_loss: 0.5017 - val_accuracy: 0.7222\n",
      "Epoch 44/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.5821 - accuracy: 0.6984 - val_loss: 0.5124 - val_accuracy: 0.6806\n",
      "Epoch 45/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.5544 - accuracy: 0.7183 - val_loss: 0.4926 - val_accuracy: 0.7778\n",
      "Epoch 46/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.5433 - accuracy: 0.7063 - val_loss: 0.4857 - val_accuracy: 0.7361\n",
      "Epoch 47/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.5455 - accuracy: 0.7044 - val_loss: 0.4505 - val_accuracy: 0.7500\n",
      "Epoch 48/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.5156 - accuracy: 0.7341 - val_loss: 0.5056 - val_accuracy: 0.6944\n",
      "Epoch 49/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.4957 - accuracy: 0.7738 - val_loss: 0.4260 - val_accuracy: 0.7917\n",
      "Epoch 50/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.4946 - accuracy: 0.7897 - val_loss: 0.4595 - val_accuracy: 0.7083\n",
      "Epoch 51/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.4488 - accuracy: 0.7718 - val_loss: 0.3437 - val_accuracy: 0.8472\n",
      "Epoch 52/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.4044 - accuracy: 0.8155 - val_loss: 0.3295 - val_accuracy: 0.8333\n",
      "Epoch 53/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.4122 - accuracy: 0.8194 - val_loss: 0.2761 - val_accuracy: 0.8889\n",
      "Epoch 54/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.3780 - accuracy: 0.8254 - val_loss: 0.3107 - val_accuracy: 0.8750\n",
      "Epoch 55/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.3623 - accuracy: 0.8413 - val_loss: 0.2633 - val_accuracy: 0.8889\n",
      "Epoch 56/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.2914 - accuracy: 0.8690 - val_loss: 0.2044 - val_accuracy: 0.9028\n",
      "Epoch 57/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.2453 - accuracy: 0.9028 - val_loss: 0.1562 - val_accuracy: 0.9444\n",
      "Epoch 58/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.2317 - accuracy: 0.9107 - val_loss: 0.0862 - val_accuracy: 1.0000\n",
      "Epoch 59/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.2819 - accuracy: 0.8849 - val_loss: 0.1553 - val_accuracy: 0.9444\n",
      "Epoch 60/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.2389 - accuracy: 0.9107 - val_loss: 0.1349 - val_accuracy: 0.9306\n",
      "Epoch 61/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.2000 - accuracy: 0.9226 - val_loss: 0.1298 - val_accuracy: 0.9306\n",
      "Epoch 62/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.1819 - accuracy: 0.9206 - val_loss: 0.1083 - val_accuracy: 0.9444\n",
      "Epoch 63/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.1249 - accuracy: 0.9504 - val_loss: 0.0818 - val_accuracy: 0.9583\n",
      "Epoch 64/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1590 - accuracy: 0.9405 - val_loss: 0.0731 - val_accuracy: 0.9722\n",
      "Epoch 65/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.1205 - accuracy: 0.9583 - val_loss: 0.0725 - val_accuracy: 0.9722\n",
      "Epoch 66/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.1557 - accuracy: 0.9365 - val_loss: 0.0628 - val_accuracy: 1.0000\n",
      "Epoch 67/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1317 - accuracy: 0.9504 - val_loss: 0.0927 - val_accuracy: 0.9444\n",
      "Epoch 68/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1556 - accuracy: 0.9365 - val_loss: 0.0609 - val_accuracy: 0.9722\n",
      "Epoch 69/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.1229 - accuracy: 0.9603 - val_loss: 0.0595 - val_accuracy: 0.9722\n",
      "Epoch 70/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1030 - accuracy: 0.9683 - val_loss: 0.0600 - val_accuracy: 0.9722\n",
      "Epoch 71/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0796 - accuracy: 0.9702 - val_loss: 0.0315 - val_accuracy: 0.9861\n",
      "Epoch 72/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1477 - accuracy: 0.9544 - val_loss: 0.0675 - val_accuracy: 0.9861\n",
      "Epoch 73/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1340 - accuracy: 0.9524 - val_loss: 0.0304 - val_accuracy: 1.0000\n",
      "Epoch 74/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1027 - accuracy: 0.9603 - val_loss: 0.0469 - val_accuracy: 0.9861\n",
      "Epoch 75/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0577 - accuracy: 0.9782 - val_loss: 0.0445 - val_accuracy: 0.9861\n",
      "Epoch 76/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0799 - accuracy: 0.9702 - val_loss: 0.0236 - val_accuracy: 0.9861\n",
      "Epoch 77/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1010 - accuracy: 0.9603 - val_loss: 0.0133 - val_accuracy: 1.0000\n",
      "Epoch 78/100\n",
      "8/8 [==============================] - 0s 12ms/step - loss: 0.0679 - accuracy: 0.9683 - val_loss: 0.0390 - val_accuracy: 0.9861\n",
      "Epoch 79/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1164 - accuracy: 0.9563 - val_loss: 0.0799 - val_accuracy: 0.9722\n",
      "Epoch 80/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.1007 - accuracy: 0.9663 - val_loss: 0.0274 - val_accuracy: 1.0000\n",
      "Epoch 81/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0631 - accuracy: 0.9782 - val_loss: 0.0523 - val_accuracy: 0.9722\n",
      "Epoch 82/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0804 - accuracy: 0.9683 - val_loss: 0.0089 - val_accuracy: 1.0000\n",
      "Epoch 83/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0820 - accuracy: 0.9782 - val_loss: 0.0267 - val_accuracy: 0.9861\n",
      "Epoch 84/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0870 - accuracy: 0.9802 - val_loss: 0.0213 - val_accuracy: 1.0000\n",
      "Epoch 85/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0783 - accuracy: 0.9722 - val_loss: 0.0574 - val_accuracy: 0.9722\n",
      "Epoch 86/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0634 - accuracy: 0.9702 - val_loss: 0.0307 - val_accuracy: 0.9861\n",
      "Epoch 87/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0501 - accuracy: 0.9841 - val_loss: 0.0514 - val_accuracy: 0.9861\n",
      "Epoch 88/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0521 - accuracy: 0.9861 - val_loss: 0.0082 - val_accuracy: 1.0000\n",
      "Epoch 89/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0581 - accuracy: 0.9861 - val_loss: 0.0073 - val_accuracy: 1.0000\n",
      "Epoch 90/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0323 - accuracy: 0.9821 - val_loss: 0.0167 - val_accuracy: 0.9861\n",
      "Epoch 91/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0656 - accuracy: 0.9802 - val_loss: 0.0319 - val_accuracy: 0.9861\n",
      "Epoch 92/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0409 - accuracy: 0.9861 - val_loss: 0.0049 - val_accuracy: 1.0000\n",
      "Epoch 93/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0597 - accuracy: 0.9742 - val_loss: 0.0154 - val_accuracy: 1.0000\n",
      "Epoch 94/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0463 - accuracy: 0.9821 - val_loss: 0.0254 - val_accuracy: 0.9861\n",
      "Epoch 95/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0326 - accuracy: 0.9881 - val_loss: 0.0390 - val_accuracy: 0.9861\n",
      "Epoch 96/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0272 - accuracy: 0.9901 - val_loss: 0.0532 - val_accuracy: 0.9861\n",
      "Epoch 97/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0421 - accuracy: 0.9821 - val_loss: 0.0049 - val_accuracy: 1.0000\n",
      "Epoch 98/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0522 - accuracy: 0.9802 - val_loss: 0.0153 - val_accuracy: 1.0000\n",
      "Epoch 99/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0351 - accuracy: 0.9841 - val_loss: 0.0152 - val_accuracy: 0.9861\n",
      "Epoch 100/100\n",
      "8/8 [==============================] - 0s 11ms/step - loss: 0.0349 - accuracy: 0.9901 - val_loss: 0.0073 - val_accuracy: 1.0000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f238005e6a0>"
      ]
     },
     "execution_count": 7,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_size = 64\n",
    "epochs = 100\n",
    "model=create_model()\n",
    "model.compile(loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])\n",
    "\n",
    "model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.125)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QPKDFiKx7_S-",
    "outputId": "de7d9fc9-2366-4cb0-fc49-ba5411afb40e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.04308682307600975\n",
      "Test accuracy: 98.61111044883728 %\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(X_test, y_test, verbose=0)\n",
    "print(\"Test loss:\", score[0])\n",
    "print(\"Test accuracy:\", score[1]*100,\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-28T07:33:31.248373Z",
     "start_time": "2020-09-28T07:33:30.351890Z"
    },
    "id": "evICnF2AWh4V"
   },
   "outputs": [],
   "source": [
    "predictions = model.predict(X_test)\n",
    "predictions = predictions.argmax( axis=1)\n",
    "#predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-28T07:33:31.263644Z",
     "start_time": "2020-09-28T07:33:31.250369Z"
    },
    "id": "yUdn2RD2Wh4W"
   },
   "outputs": [],
   "source": [
    "cm = confusion_matrix(y_test.argmax(axis=1), predictions)\n",
    "cm = cm/cm.sum(axis=1)[:, np.newaxis]\n",
    "l=np.unique(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-09-28T07:33:31.751326Z",
     "start_time": "2020-09-28T07:33:31.265233Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 627
    },
    "id": "7rgZ62bhWh4W",
    "outputId": "f04db246-1c21-4bc3-a877-924ac36969b9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(69.0, 0.5, 'True')"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10,10))  \n",
    "sns.heatmap(\n",
    "    cm, annot=True,\n",
    "    xticklabels=set(l),\n",
    "    yticklabels=set(l))\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"True\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Lrhntlaru9RN"
   },
   "outputs": [],
   "source": [
    "#10-fold cross-validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "HT4KR-idGJ0h",
    "outputId": "fe013ec9-bc21-4c98-abf7-f851932a4242"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Fold : 1 \n",
      "\n",
      "Training Accuracy 99.29453134536743 %\n",
      "Validation Accuracy 88.88888955116272 %\n",
      "Test Accuracy  100.0 %\n",
      "\n",
      "\n",
      "Fold : 2 \n",
      "\n",
      "Training Accuracy 99.29453134536743 %\n",
      "Validation Accuracy 28.395062685012817 %\n",
      "Test Accuracy  100.0 %\n",
      "\n",
      "\n",
      "Fold : 3 \n",
      "\n",
      "Training Accuracy 100.0 %\n",
      "Validation Accuracy 53.08641791343689 %\n",
      "Test Accuracy  80.55555820465088 %\n",
      "\n",
      "\n",
      "Fold : 4 \n",
      "\n",
      "Training Accuracy 99.47090148925781 %\n",
      "Validation Accuracy 66.66666865348816 %\n",
      "Test Accuracy  95.83333134651184 %\n",
      "\n",
      "\n",
      "Fold : 5 \n",
      "\n",
      "Training Accuracy 98.23633432388306 %\n",
      "Validation Accuracy 59.25925970077515 %\n",
      "Test Accuracy  97.22222089767456 %\n",
      "\n",
      "\n",
      "Fold : 6 \n",
      "\n",
      "Training Accuracy 99.47090148925781 %\n",
      "Validation Accuracy 71.60493731498718 %\n",
      "Test Accuracy  95.83333134651184 %\n",
      "\n",
      "\n",
      "Fold : 7 \n",
      "\n",
      "Training Accuracy 98.94179701805115 %\n",
      "Validation Accuracy 81.4814805984497 %\n",
      "Test Accuracy  95.83333134651184 %\n",
      "\n",
      "\n",
      "Fold : 8 \n",
      "\n",
      "Training Accuracy 98.76543283462524 %\n",
      "Validation Accuracy 62.962961196899414 %\n",
      "Test Accuracy  48.61111044883728 %\n",
      "\n",
      "\n",
      "Fold : 9 \n",
      "\n",
      "Training Accuracy 99.29453134536743 %\n",
      "Validation Accuracy 67.90123581886292 %\n",
      "Test Accuracy  43.05555522441864 %\n",
      "\n",
      "\n",
      "Fold : 10 \n",
      "\n",
      "Training Accuracy 98.94179701805115 %\n",
      "Validation Accuracy 66.66666865348816 %\n",
      "Test Accuracy  79.16666865348816 %\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n_split=10\n",
    "a=0\n",
    "X=np.vstack((class1,class2,class3))\n",
    "f=0\n",
    "for train_index,test_index in KFold(n_split).split(X):\n",
    "  f+=1\n",
    "  x_train,x_test=X[train_index],X[test_index]\n",
    "  y_train,y_test=label[train_index],label[test_index]\n",
    "  y_train = keras.utils.to_categorical(y_train-1,num_classes=3)\n",
    "  y_test=keras.utils.to_categorical(y_test-1,num_classes=3)\n",
    "\n",
    "  batch_size = 128\n",
    "  epochs = 200\n",
    "  model=create_model()\n",
    "  opt = keras.optimizers.Adam(learning_rate=0.0001)\n",
    "  model.compile(loss=\"categorical_crossentropy\", optimizer=opt, metrics=[\"accuracy\"])\n",
    "\n",
    "  history=model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.125,verbose=0)\n",
    "  print(\"\\n\")\n",
    "  print(\"Fold :\",f,\"\\n\")\n",
    "  print(\"Training Accuracy\",history.history['accuracy'][-1]*100,\"%\")\n",
    "  print(\"Validation Accuracy\",history.history['val_accuracy'][-1]*100,\"%\")\n",
    "  print('Test Accuracy ',model.evaluate(x_test,y_test,verbose=0)[1]*100,\"%\")\n",
    "  a+=model.evaluate(x_test,y_test,verbose=0)[1]*100\n",
    "print(\"\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "X_IAjYHmvlVb"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bOZ85KEo6C-n"
   },
   "source": [
    "## Q.11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fs-jnJcLERUh"
   },
   "source": [
    "## Things Learnt :\n",
    "\n",
    "\n",
    "\n",
    "1. Non-linear perceptron algorithm\n",
    "2. Forward Propagation Back Propagation\n",
    "3. Multi-layer neural network\n",
    "4. Kernel perceptron algorithm\n",
    "5. Radial basis function neural network\n",
    "6. Stacked autoencoder\n",
    "7. ELM\n",
    "8. ELM-Autoencoder\n",
    "9. Binary and multiclass SVM\n",
    "10. Multi-channel 1D deep CNN architecture\n",
    "11. 2D deep CNN classifier\n",
    "12. Confusion Matrix"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "NNFL Assignment 2 (2018AAPS0333H_IshanDixit).ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}